visualitem.java

用applet实现很多应用小程序

    
    /**
     * 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