package prefuse.visual;

import java.awt.BasicStroke;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;

import prefuse.Visualization;
import prefuse.data.Schema;
import prefuse.data.Tuple;
import prefuse.data.tuple.TupleSet;
import prefuse.render.Renderer;
import prefuse.util.PrefuseLib;

/**
 * <p>Base interface for representing a visual item, a data object with a
 * visual interactive form. VisualItems are Tuple instances, and so
 * can support any number of data fields in a backing data table. VisualItems
 * also support data fields specific to visualization, such as a location,
 * bounding box, colors, size, and font. The VisualItem interface provides
 * convenience methods for accessing these common visual properties, but
 * the underlying mechanism is the same as any Tuple -- data stored in
 * a tabular format. Just as all Tuple instances are backed by a data Table,
 * each VisualItem is backed by a VisualTable. Additionally, each VisualItem
 * is associated with one and only one {@link prefuse.Visualization}.</p>
 * 
 * <p>VisualItems are only responsible for storing their visual data
 * properties. The final visual appearance of an item is determined by
 * a {@link prefuse.render.Renderer}, which contains instructions for drawing
 * the item. The Renderer to use for a given item is decided by the
 * {@link prefuse.render.RendererFactory} associated with the item's
 * backing Visualization.</p>
 * 
 * <p>Finally, actually setting the visual properties of VisualItems is
 * commonly done by the many {@link prefuse.action.Action} modules available
 * for processing visual data. This includes spatial layout as well as
 * color, size, and font assignment.</p> 
 * 
 * @author <a href="http://jheer.org">jeffrey heer</a>
 */
public interface VisualItem extends Tuple {

    /**
     * Get the backing Visualization of which this VisualItem is a part.
     * @return the backing Visualization
     */
    public Visualization getVisualization();
    
    /**
     * Get the primary data group of which this VisualItem is a member.
     * Returns the name of the group of this item's backing VisualTable.
     * @return the item's primary group
     */
    public String getGroup();
    
    /**
     * Indicates if this item is a member of a given group. This includes both
     * the item's primary group (that of it's backing VisualTable) and any
     * number of additional focus groups associated with the Visualization.
     * @param group the group to check for membership.
     * @return true if this item is in the group, false otherwise.
     */
    public boolean isInGroup(String group);
    
    /**
     * Returns the original backing data set from which this VisualItem is
     * derived. This could be a Table, Graph, or Tree instance. This method
     * returns null if this VisualItem is not derived from backing data.
     * @return the backing data set from which this VisualItem is derived,
     * or null if none.
     */
    public TupleSet getSourceData();

    /**
     * Returns the original backing data tuple from which this VisualItem is
     * derived. This could be a Tuple, Node, or Edge instance. This method
     * returns null if this VisualItem is not derived from backing data.
     * @return the backing data tuple from which this VisualItem is derived,
     * or null if none.
     */
    public Tuple getSourceTuple();
    
    
    // ------------------------------------------------------------------------
    // VisualItem Methods
    
    /**
     * Render this item to the given graphics context. This is typically done
     * by requesting the appropriate Renderer from the backing Visualization's
     * RendererFactory, and then using the Renderer to draw this item.
     * @param g the graphics context to render into.
     */
    public void render(Graphics2D g);
    
    /**
     * Get the Renderer instance for drawing this VisualItem. The Renderer is
     * retrieved by requesting it from the backing Visualization's
     * RendererFactory.
     * @return the Renderer for this VisualItem
     */
    public Renderer getRenderer();
    
    /**
     * Validate the bounds of this VisualItem. When a data value for a
     * VisualItem is updated, it's bounds are invalidated, as the data change
     * may have changed to appearance of the item. Revalidating the bounds
     * causes the bounds of the item to be recomputed and made current.
     * @return the validated boundig box of this item
     */
    public Rectangle2D validateBounds();
    
    // -- Boolean Flags -------------------------------------------------------
      
    /**
     * Indicates if this VisualItem is currently validated. If not,
     * validateBounds() must be run to update the bounds to a current value.
     * @return true if validated, false otherwise
     * @see #VALIDATED
     */
    public boolean isValidated();
    
    /**
     * Set this item's validated flag. This is for internal use by prefuse and,
     * in general, should not be called by application code.
     * @param value the value of the validated flag to set.
     * @see #VALIDATED
     */
    public void setValidated(boolean value);
    
    /**
     * Indicates if this VisualItem is currently set to be visible. Items with
     * the visible flag set false will not be drawn by a display. Invisible
     * items are also by necessity not interactive, regardless of the value of
     * the interactive flag.
     * @return true if visible, false if invisible
     * @see #VISIBLE
     */
    public boolean isVisible();
    
    /**
     * Set this item's visibility.
     * @param value true to make the item visible, false otherwise.
     * @see #VISIBLE
     */
    public void setVisible(boolean value);
    
    /**
     * Indicates if the start visible flag is set to true. This is the
     * visibility value consulted for the staring value of the visibility
     * field at the beginning of an animated transition.
     * @return true if this item starts out visible, false otherwise.
     * @see #STARTVISIBLE
     */
    public boolean isStartVisible();
    
    /**
     * Set the start visible flag.
     * @param value true to set the start visible flag, false otherwise
     * @see #STARTVISIBLE
     */
    public void setStartVisible(boolean value);

    /**
     * Indictes if the end visible flag is set to true. This is the
     * visibility value consulted for the ending value of the visibility
     * field at the end of an animated transition.
     * @return true if this items ends visible, false otherwise.
     * @see #ENDVISIBLE
     */
    public boolean isEndVisible();
    
    /**
     * Set the end visible flag.
     * @param value true to set the end visible flag, false otherwise
     * @see #ENDVISIBLE
     */
    public void setEndVisible(boolean value);
    
    /**
     * Indicates if this item is interactive, meaning it can potentially
     * respond to mouse and keyboard input events.
     * @return true if the item is interactive, false otherwise
     * @see #INTERACTIVE
     */
    public boolean isInteractive();

    /**
     * Set the interactive status of this VisualItem.
     * @param value true for interactive, false for non-interactive
     * @see #INTERACTIVE
     */
    public void setInteractive(boolean value);
    
    /**
     * Indicates this item is expanded. Only used for items that are
     * part of a graph structure. 
     * @return true if expanded, false otherwise
     * @see #EXPANDED
     */
    public boolean isExpanded();

    /**
     * Set the expanded flag.
     * @param value true to set as expanded, false as collapsed.
     * @see #EXPANDED
     */
    public void setExpanded(boolean value);
    
    /**
     * Indicates if the item is fixed, and so will not have its position
     * changed by any layout or distortion actions.
     * @return true if the item has a fixed position, false otherwise
     * @see #FIXED
     */
    public boolean isFixed();

    /**
     * Sets if the item is fixed in its position.
     * @param value true to fix the item, false otherwise
     * @see #FIXED
     */
    public void setFixed(boolean value);
    
    /**
     * Indicates if the item is highlighted.
     * @return true for highlighted, false for not highlighted
     * @see #HIGHLIGHT
     */
    public boolean isHighlighted();
    
    /**
     * Set the highlighted status of this item. How higlighting values are
     * interpreted by the system depends on the various processing actions
     * set up for an application (e.g., how a
     * {@link prefuse.action.assignment.ColorAction} might assign colors
     * based on the flag).
     * @param value true to highlight the item, false for no highlighting.
     * @see #HIGHLIGHT
     */
    public void setHighlighted(boolean value);

    /**
     * Indicates if the item currently has the mouse pointer over it.
     * @return true if the mouse pointer is over this item, false otherwise
     * @see #HOVER
     */
    public boolean isHover();
    
    /**
     * Set the hover flag. This is set automatically by the prefuse framework,
     * so should not need to be set explicitly by application code.
     * @param value true to set the hover flag, false otherwise
     * @see #HOVER
     */
    public void setHover(boolean value);
    
    // ------------------------------------------------------------------------
    
    /**
     * Get the current x-coordinate of this item.
     * @return the current x-coordinate
     * @see #X
     */
    public double getX();

    /**
     * Set the current x-coordinate of this item.
     * @param x the new current x-coordinate
     * @see #X
     */
    public void setX(double x);
    
    /**
     * Get the current y-coordinate of this item.
     * @return the current y-coordinate
     * @see #Y
     */
    public double getY();
    
    /**
     * Set the current y-coordinate of this item.
     * @param y the new current y-coordinate
     * @see #Y
     */
    public void setY(double y);
    
    /**
     * Get the starting x-coordinate of this item.
     * @return the starting x-coordinate
     * @see #STARTX
     */
    public double getStartX();
    
    /**
     * Set the starting x-coordinate of this item.
     * @param x the new starting x-coordinate
     * @see #STARTX
     */
    public void setStartX(double x);
    
    /**
     * Get the starting y-coordinate of this item.
     * @return the starting y-coordinate
     * @see #STARTY
     */
    public double getStartY();
    
    /**
     * Set the starting y-coordinate of this item.
     * @param y the new starting y-coordinate
     * @see #STARTY
     */
    public void setStartY(double y);
    
    /**
     * Get the ending x-coordinate of this item.
     * @return the ending x-coordinate
     * @see #ENDX
     */
    public double getEndX();
    
    /**
     * Set the ending x-coordinate of this item.
     * @param x the new ending x-coordinate
     * @see #ENDX
     */
    public void setEndX(double x);
    
    /**
     * Get the ending y-coordinate of this item.
     * @return the ending y-coordinate
     * @see #ENDY
     */
    public double getEndY();
    
    /**
     * Set the ending y-coordinate of this item.
     * @param y the new ending y-coordinate
     * @see #ENDY
     */
    public void setEndY(double y);

    /**
     * Get the bounding box for this VisualItem. If necessary, the bounds
     * will be validated before returning the bounding box.
     * @return the item's bounding box
     * @see #BOUNDS
     */
    public Rectangle2D getBounds();
    
    /**
     * Set the bounding box for this item. This method is used by Renderer
     * modules when the bounds are validated, or set by processing Actions
     * used in conjunction with Renderers that do not perform bounds
     * management.
     * @param x the minimum x-coordinate
     * @param y the minimum y-coorindate
     * @param w the width of this item
     * @param h the height of this item
     * @see #BOUNDS
     */
    public void setBounds(double x, double y, double w, double h);
    
    // ------------------------------------------------------------------------
    
    /**
     * Get the current stroke color of this item. The stroke color is used to
     * draw lines and the outlines of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @return the current stroke color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #STROKECOLOR
     */
    public int getStrokeColor();
    
    /**
     * Set the current stroke color of this item. The stroke color is used to
     * draw lines and the outlines of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @param color the current stroke color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #STROKECOLOR
     */
    public void setStrokeColor(int color);
    
    /**
     * Get the starting stroke color of this item. The stroke color is used to
     * draw lines and the outlines of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @return the starting stroke color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #STARTSTROKECOLOR
     */
    public int getStartStrokeColor();
    
    /**
     * Set the starting stroke color of this item. The stroke color is used to
     * draw lines and the outlines of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @param color the starting stroke color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #STARTSTROKECOLOR
     */
    public void setStartStrokeColor(int color);
    
    /**
     * Get the ending stroke color of this item. The stroke color is used to
     * draw lines and the outlines of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @return the ending stroke color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #ENDSTROKECOLOR
     */
    public int getEndStrokeColor();
    
    /**
     * Set the ending stroke color of this item. The stroke color is used to
     * draw lines and the outlines of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @param color the ending stroke color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #ENDSTROKECOLOR
     */
    public void setEndStrokeColor(int color);
    
    /**
     * Get the current fill color of this item. The fill color is used to
     * fill the interior of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @return the current fill color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #FILLCOLOR
     */
    public int getFillColor();
    
    /**
     * Set the current fill color of this item. The fill color is used to
     * fill the interior of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @param color the current fill color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #FILLCOLOR
     */
    public void setFillColor(int color);
    
    /**
     * Get the starting fill color of this item. The fill color is used to
     * fill the interior of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with zero alpha component is fully
     * transparent and will not be drawn.
     * @return the starting fill color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #STARTFILLCOLOR
     */
    public int getStartFillColor();

    /**
     * Set the starting fill color of this item. The fill color is used to
     * fill the interior of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @param color the starting fill color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #STARTFILLCOLOR
     */
    public void setStartFillColor(int color);
    
    /**
     * Get the ending fill color of this item. The fill color is used to
     * fill the interior of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with zero alpha component is fully
     * transparent and will not be drawn.
     * @return the ending fill color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #ENDFILLCOLOR
     */
    public int getEndFillColor();
    
    /**
     * Set the ending fill color of this item. The fill color is used to
     * fill the interior of shapes. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @param color the ending fill color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #ENDFILLCOLOR
     */
    public void setEndFillColor(int color);
    
    /**
     * Get the current text color of this item. The text color is used to
     * draw text strings for the item. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with zero alpha component is fully
     * transparent and will not be drawn.
     * @return the current text color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #TEXTCOLOR
     */
    public int getTextColor();
    
    /**
     * Set the current text color of this item. The text color is used to
     * draw text strings for the item. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @param color the current text color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #TEXTCOLOR
     */
    public void setTextColor(int color);
    
    /**
     * Get the starting text color of this item. The text color is used to
     * draw text strings for the item. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with zero alpha component is fully
     * transparent and will not be drawn.
     * @return the starting text color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #STARTTEXTCOLOR
     */
    public int getStartTextColor();
    
    /**
     * Set the starting text color of this item. The text color is used to
     * draw text strings for the item. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @param color the starting text color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #STARTTEXTCOLOR
     */
    public void setStartTextColor(int color);
    
    /**
     * Get the ending text color of this item. The text color is used to
     * draw text strings for the item. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with zero alpha component is fully
     * transparent and will not be drawn.
     * @return the ending text color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #ENDTEXTCOLOR
     */
    public int getEndTextColor();
    
    /**
     * Set the ending text color of this item. The text color is used to
     * draw text strings for the item. Color values as represented as an
     * integer containing the red, green, blue, and alpha (transparency)
     * color channels. A color with a zero alpha component is fully
     * transparent and will not be drawn.
     * @param color the ending text color, represented as an integer
     * @see prefuse.util.ColorLib
     * @see #ENDTEXTCOLOR
     */
    public void setEndTextColor(int color);
    
    // ------------------------------------------------------------------------
    
    /**
     * Get the current size value of the item. Size values are typically used
     * to scale an item, either in one-dimension (e.g., a bar chart length) or
     * two-dimensions (e.g., using pixel area to encode a quantitative value).
     * @return the current size value
     * @see #SIZE
     */
    public double getSize();
    
    /**
     * Set the current size value of the item. Size values are typically used
     * to scale an item, either in one-dimension (e.g., a bar chart length) or
     * two-dimensions (e.g., using pixel area to encode a quantitative value).
     * @param size the current size value
     * @see #SIZE
     */
    public void setSize(double size);
    
    /**
     * Get the starting size value of the item. Size values are typically used
     * to scale an item, either in one-dimension (e.g., a bar chart length) or
     * two-dimensions (e.g., using pixel area to encode a quantitative value).
     * @return the starting size value
     * @see #STARTSIZE
     */
    public double getStartSize();
    
    /**
     * Set the starting size value of the item. Size values are typically used
     * to scale an item, either in one-dimension (e.g., a bar chart length) or
     * two-dimensions (e.g., using pixel area to encode a quantitative value).
     * @param size the starting size value
     * @see #STARTSIZE
     */
    public void setStartSize(double size);
    
    /**
     * Get the ending size value of the item. Size values are typically used
     * to scale an item, either in one-dimension (e.g., a bar chart length) or
     * two-dimensions (e.g., using pixel area to encode a quantitative value).
     * @return the ending size value
     * @see #ENDSIZE
     */
    public double getEndSize();
    
    /**
     * Set the ending size value of the item. Size values are typically used
     * to scale an item, either in one-dimension (e.g., a bar chart length) or
     * two-dimensions (e.g., using pixel area to encode a quantitative value).
     * @param size the ending size value
     * @see #ENDSIZE
     */
    public void setEndSize(double size);
    
    // ------------------------------------------------------------------------
    
    /**
     * Get the current shape value of the item. One of the SHAPE constants
     * included in the {@link prefuse.Constants} class. This value only has an
     * effect if a Renderer that supports different shapes is used
     * (e.g., {@link prefuse.render.ShapeRenderer}.
     * @return the current shape value
     * @see #SHAPE
     */
    public int getShape();
    
    /**
     * Set the current shape value of the item. One of the SHAPE constants
     * included in the {@link prefuse.Constants} class. This value only has an
     * effect if a Renderer that supports different shapes is used
     * (e.g., {@link prefuse.render.ShapeRenderer}.
     * @param shape the shape value to use
     * @see #SHAPE
     */
    public void setShape(int shape);
    
    // ------------------------------------------------------------------------
    
    /**
     * Get the current stroke used to draw lines and shape outlines.
     * @return the stroke used to draw lines and shape outlines
     */
    public BasicStroke getStroke();
    
    /**
     * Set the current stroke used to draw lines and shape outlines.
     * @param stroke the stroke to use to draw lines and shape outlines
     */
    public void setStroke(BasicStroke stroke);
    
    // ------------------------------------------------------------------------
    
    /**
     * Get the current font for the item. The font is used as the default
     * typeface for drawing text for this item.
     * @return the current font value
     * @see #FONT
     */
    public Font getFont();

    /**
     * Set the current font for the item. The font is used as the default
     * typeface for drawing text for this item.
     * @param font the current font value
     * @see #FONT
     */
    public void setFont(Font font);
    
    /**
     * Get the starting font for the item. The font is used as the default
     * typeface for drawing text for this item.
     * @return the starting font value
     * @see #STARTFONT
     */
    public Font getStartFont();

    /**
     * Set the starting font for the item. The font is used as the default
     * typeface for drawing text for this item.
     * @param font the starting font value
     * @see #STARTFONT
     */
    public void setStartFont(Font font);
    
    /**
     * Get the ending font for the item. The font is used as the default
     * typeface for drawing text for this item.
     * @return the ending font value
     * @see #ENDFONT
     */
    public Font getEndFont();
    
    /**
     * Set the ending font for the item. The font is used as the default
     * typeface for drawing text for this item.
     * @param font the ending font value
     * @see #ENDFONT
     */
    public void setEndFont(Font font);
    
    // ------------------------------------------------------------------------
    
    /**
     * Get the degree-of-interest (DOI) value. The degree-of-interet is an
     * optional value that can be used to sort items by importance, control
     * item visibility, or influence particular visual encodings. A common
     * example is to use the DOI to store the graph distance of a node from
     * the nearest selected focus node.
     * @return the DOI value of this item
     * @see #DOI
     */
    public double getDOI();
    
    /**
     * Set the degree-of-interest (DOI) value. The degree-of-interet is an
     * optional value that can be used to sort items by importance, control
     * item visibility, or influence particular visual encodings. A common
     * example is to use the DOI to store the graph distance of a node from
     * the nearest selected focus node.
     * @param doi the DOI value of this item
     * @see #DOI
     */
    public void setDOI(double doi);
    
    // ------------------------------------------------------------------------
    // VisualItem Base Schema
        
    /** The validated data field */
    public static final String VALIDATED
        = PrefuseLib.FIELD_PREFIX+"validated";
    /** The visible data field */
    public static final String VISIBLE
        = PrefuseLib.FIELD_PREFIX+"visible";
    /** The start visible data field */
    public static final String STARTVISIBLE
        = PrefuseLib.getStartField(VISIBLE);
    /** The end visible data field */
    public static final String ENDVISIBLE
        = PrefuseLib.getEndField(VISIBLE);
    /** The interactive data field */
    public static final String INTERACTIVE
        = PrefuseLib.FIELD_PREFIX+"interactive";
    /** The expanded data field */
    public static final String EXPANDED
        = PrefuseLib.FIELD_PREFIX+"expanded";
    /** The fixed data field */
    public static final String FIXED
        = PrefuseLib.FIELD_PREFIX+"fixed";
    /** The highlight data field */
    public static final String HIGHLIGHT
        = PrefuseLib.FIELD_PREFIX+"highlight";
    /** The hover data field */
    public static final String HOVER
        = PrefuseLib.FIELD_PREFIX+"hover";
    /** The x data field */
    public static final String X
        = PrefuseLib.FIELD_PREFIX+"x";
    /** The y data field */
    public static final String Y
        = PrefuseLib.FIELD_PREFIX+"y";
    /** The start x data field */
    public static final String STARTX
        = PrefuseLib.getStartField(X);
    /** The start y data field */
    public static final String STARTY
        = PrefuseLib.getStartField(Y);
    /** The end x data field */
    public static final String ENDX
        = PrefuseLib.getEndField(X);
    /** The end y data field */
    public static final String ENDY
        = PrefuseLib.getEndField(Y);
    /** The bounds data field */
    public static final String BOUNDS
        = PrefuseLib.FIELD_PREFIX+"bounds";
    /** The stroke color data field */
    public static final String STROKECOLOR
        = PrefuseLib.FIELD_PREFIX+"strokeColor";
    /** The start stroke color data field */
    public static final String STARTSTROKECOLOR
        = PrefuseLib.getStartField(STROKECOLOR);
    /** The end stroke color data field */
    public static final String ENDSTROKECOLOR
        = PrefuseLib.getEndField(STROKECOLOR);
    /** The fill color data field */
    public static final String FILLCOLOR
        = PrefuseLib.FIELD_PREFIX+"fillColor";
    /** The start fill color data field */
    public static final String STARTFILLCOLOR
        = PrefuseLib.getStartField(FILLCOLOR);
    /** The end fill color data field */
    public static final String ENDFILLCOLOR
        = PrefuseLib.getEndField(FILLCOLOR);
    /** The text color data field */
    public static final String TEXTCOLOR
        = PrefuseLib.FIELD_PREFIX+"textColor";
    /** The start text color data field */
    public static final String STARTTEXTCOLOR
        = PrefuseLib.getStartField(TEXTCOLOR);
    /** The end text color data field */
    public static final String ENDTEXTCOLOR
        = PrefuseLib.getEndField(TEXTCOLOR);
    /** The size data field */
    public static final String SIZE
        = PrefuseLib.FIELD_PREFIX+"size";
    /** The start size data field */
    public static final String STARTSIZE
        = PrefuseLib.getStartField(SIZE);
    /** The end size data field */
    public static final String ENDSIZE
        = PrefuseLib.getEndField(SIZE);
    /** The shape data field */
    public static final String SHAPE
        = PrefuseLib.FIELD_PREFIX+"shape";
    /** The stroke data field */
    public static final String STROKE
        = PrefuseLib.FIELD_PREFIX+"stroke";
    /** The font data field */
    public static final String FONT
        = PrefuseLib.FIELD_PREFIX+"font";
    /** The start font data field */
    public static final String STARTFONT
        = PrefuseLib.getStartField(FONT);
    /** The end font data field */
    public static final String ENDFONT
        = PrefuseLib.getEndField(FONT);
    /** The doi data field */
    public static final String DOI
        = PrefuseLib.FIELD_PREFIX+"doi";
    
    /** A permanent, locked copy of the base VisualItem schema */
    public static final Schema SCHEMA
        = PrefuseLib.getVisualItemSchema().lockSchema();
    
    /** 
     *  The column index of the validated data field. This should be safe to do
     *  because a unique (non-inherited) validated field is required of all
     *  VisualItems, and should always be the first field included.
     */
    public static final int IDX_VALIDATED 
        = SCHEMA.getColumnIndex(VALIDATED);
    
    // ------------------------------------------------------------------------
    // VisualItem Extended Schema
    
    /** The label data field.
     * Not included in the VisualItem schema by default */
    public static final String LABEL
        = PrefuseLib.FIELD_PREFIX+"label";
    /** The value data field.
     * Not included in the VisualItem schema by default */
    public static final String VALUE
        = PrefuseLib.FIELD_PREFIX+"value";
    
    /** The polygon data field.
     * Not included in the VisualItem schema by default */
    public static final String POLYGON
        = PrefuseLib.FIELD_PREFIX+"polygon";
    /** The start polygon data field.
     * Not included in the VisualItem schema by default */
    public static final String STARTPOLYGON
        = PrefuseLib.getStartField(POLYGON);
    /** The end polygon data field.
     * Not included in the VisualItem schema by default */
    public static final String ENDPOLYGON
        = PrefuseLib.getStartField(POLYGON);
    
    /** The x2 data field.
     * Not included in the VisualItem schema by default */
    public static final String X2
        = PrefuseLib.FIELD_PREFIX+"x2";
    /** The y2 data field.
     * Not included in the VisualItem schema by default */
    public static final String Y2
        = PrefuseLib.FIELD_PREFIX+"y2";
    /** The start x2 data field.
     * Not included in the VisualItem schema by default */
    public static final String STARTX2
        = PrefuseLib.getStartField(X2);
    /** The start y2 data field.
     * Not included in the VisualItem schema by default */
    public static final String STARTY2
        = PrefuseLib.getStartField(Y2);
    /** The end x2 data field.
     * Not included in the VisualItem schema by default */
    public static final String ENDX2
        = PrefuseLib.getEndField(X2);
    /** The end y2 data field.
     * Not included in the VisualItem schema by default */
    public static final String ENDY2
        = PrefuseLib.getEndField(Y2);
    
} // end of interface VisualItem
