| java.lang.Object
 net.sourceforge.chart2d.GraphProperties
| GraphProperties | | final public class GraphProperties (Code) | | A data structure for holding the properties common to all graph area objects.
A graph area is the rectangular region surrounded on two sides by axes and containing either
lines, dots, or bars as graph components.
Pass this to any number of GraphChart2D objects.
|
| Constructor Summary | |
| public | GraphProperties()
Creates a GraphProperties object with the documented default values. | | public | GraphProperties(GraphProperties graphProps)
Creates a GraphProperties object with property values copied from another object. |
| Method Summary | |
| final void | addGraphChart2D(GraphChart2D graphChart2D)
Adds a GraphChart2D to the set of objects using these properties. | | final void | configureGraphArea(int type, GraphArea graph)
Accepts a graph area and configures it with current properties. | | final void | configureGraphArea(GraphProperties backgroundGraphProps, int type, GraphArea graph)
Accepts a graph area and configures it with current properties. | | final public boolean | getGraphAllowComponentAlignment()
Gets whether the graph's components (ie bars, dots, or lines) are
allowed to overlap/align or are offset for each set and within each
category. | | final public Color | getGraphBackgroundColor()
Gets the color of the background of this graph. | | final public boolean | getGraphBackgroundExistence()
Gets whether the background of this graph exists. | | final public float | getGraphBarsExcessSpaceFeedbackRatio()
Gets the amount of the excess space to feed back to bars thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the bars, making them larger. | | final public boolean | getGraphBarsExistence()
Gets whether the graph contains bar components. | | final public float | getGraphBarsRoundingRatio()
Gets the degree of rounding for the bars. | | final public int | getGraphBarsThicknessModel()
Gets the thickness of the bar components for the chart's model size. | | final public float | getGraphBarsWithinCategoryOverlapRatio()
Gets how much the bars can overlap eachother when there are multiple
data values per data set and per data category. | | final public boolean | getGraphBetweenComponentsGapExistence()
Gets whether a gap between each category of components exists (ie
not the gap between each each component with each category). | | final public int | getGraphBetweenComponentsGapThicknessModel()
Gets the thickness of the gap between each category of components for
the chart's model size. | | final public boolean | getGraphBorderExistence()
Gets whether the graph's left and bottom border exists. | | final public Color | getGraphBorderLeftBottomColor()
Gets the color of the graph's left and bottom border. | | final public Color | getGraphBorderRightTopColor()
Gets the color of the graph's right and top border. | | final public int | getGraphBorderThicknessModel()
Gets the thickness of the graph's left and bottom border for the
chart's model size. | | final boolean | getGraphChart2DNeedsUpdate(GraphChart2D graphChart2D)
Gets whether this object needs to be updated with new properties.
Parameters:
graphChart2D - The object that may need to be updated. | | final public AlphaComposite | getGraphComponentsAlphaComposite()
Gets the actual AlphaComposite object to use on the Graphics2D object context for painting the
graph components managed by this GraphProperties object. | | final public int | getGraphComponentsLightSource()
Gets the direction of the source of the light if any. | | final public int | getGraphComponentsLightType()
Gets the type of the lighting affect. | | final public boolean | getGraphComponentsOverflowClip()
Gets whether the graph's components will be clipped if they pass over the graph's inner
space or border. | | final public float | getGraphDotsExcessSpaceFeedbackRatio()
Gets the amount of the excess space to feed back to dots thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the dots, making them larger. | | final public boolean | getGraphDotsExistence()
Gets whether the graph contains dot components. | | final public int | getGraphDotsThicknessModel()
Gets the thickness of the dot components for the chart's model size. | | final public float | getGraphDotsWithinCategoryOverlapRatio()
Gets how much the dots can overlap eachother when there are multiple
data values per data set and per data category. | | final public Color | getGraphLabelsLinesColor()
Gets the color of the vertical lines of this graph. | | final public boolean | getGraphLabelsLinesExistence()
Gets whether the vertical lines of this graph exist. | | final public float[] | getGraphLabelsLinesStyle()
Gets the style of the vertical lines of this graph. | | final public int | getGraphLabelsLinesThicknessModel()
Gets the thickness of the vertical lines of this graph for the
chart's model size. | | final public float | getGraphLinesExcessSpaceFeedbackRatio()
Gets the amount of the excess space to feed back to lines thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the lines, making them larger. | | final public boolean | getGraphLinesExistence()
Gets whether the graph contains line components. | | final public boolean | getGraphLinesFillInterior()
Gets whether the graph lines will made to form a shap (ie like a
mountain range). | | final public boolean | getGraphLinesThicknessAssociation()
Gets whether the horizontal and vertical lines (if they both exist)
should both be the same thickness at all times. | | final public int | getGraphLinesThicknessModel()
Gets the thickness of the line components for the chart's model size. | | final public float | getGraphLinesWithinCategoryOverlapRatio()
Gets how much the lines can overlap eachother when there are multiple
data values per data set and per data category. | | final public Color | getGraphNumbersLinesColor()
Gets the color of the horizontal lines of this graph. | | final public boolean | getGraphNumbersLinesExistence()
Gets whether the horizontal lines of this graph exist. | | final public float[] | getGraphNumbersLinesStyle()
Gets the style of the horizontal lines of this graph. | | final public int | getGraphNumbersLinesThicknessModel()
Gets the thickness of the horizontal lines of this graph for the
chart's model size. | | final public Color | getGraphOutlineComponentsColor()
Gets the color of the thin outline around components
(ie bars, lines, or dots). | | final public boolean | getGraphOutlineComponentsExistence()
Gets whether there exists a thin outline around each component
(ie bars, lines, or dots). | | final void | removeGraphChart2D(GraphChart2D graphChart2D)
Removes a GraphChart2D from the set of objects using these properties. | | final public void | setGraphAllowComponentAlignment(boolean alignment)
Sets whether the graph's components (ie bars, dots, or lines) are
allowed to overlap/align or are offset for each set and within each
category. | | final public void | setGraphBackgroundColor(Color color)
Sets the color of the background of this graph. | | final public void | setGraphBackgroundExistence(boolean existence)
Sets whether the background of this graph exists. | | final public void | setGraphBarsExcessSpaceFeedbackRatio(float ratio)
Sets the amount of the excess space to feed back to bars thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the bars, making them larger. | | final public void | setGraphBarsExistence(boolean existence)
Sets whether the graph contains bar components. | | final public void | setGraphBarsRoundingRatio(float r)
Sets the degree of rounding for the bars. | | final public void | setGraphBarsThicknessModel(int thickness)
Sets the thickness of the bar components for the chart's model size. | | final public void | setGraphBarsWithinCategoryOverlapRatio(float ratio)
Sets how much the bars can overlap eachother when there are multiple
data values per data set and per data category. | | final public void | setGraphBetweenComponentsGapExistence(boolean existence)
Sets whether a gap between each category of components exists (ie
not the gap between each each component with each category). | | final public void | setGraphBetweenComponentsGapThicknessModel(int thickness)
Sets the thickness of the gap between each category of components for
the chart's model size. | | final public void | setGraphBorderExistence(boolean existence)
Sets whether the graph's left and bottom border exists. | | final public void | setGraphBorderLeftBottomColor(Color color)
Sets the color of the graph's left and bottom border. | | final public void | setGraphBorderRightTopColor(Color color)
Sets the color of the graph's right and top border. | | final public void | setGraphBorderThicknessModel(int thickness)
Sets the thickness of the graph's left and bottom border for the
chart's model size. | | final public void | setGraphComponentsAlphaComposite(AlphaComposite a)
Sets the actual AlphaComposite object to use on the Graphics2D object context for painting the
graph components managed by this GraphProperties object. | | final public void | setGraphComponentsLightSource(int s)
Sets the direction of the source of the light if any. | | final public void | setGraphComponentsLightType(int t)
Sets the type of the lighting affect. | | final public void | setGraphComponentsOverflowClip(boolean c)
Sets whether the graph's components will be clipped if they pass over the graph's inner space
or border. | | final public void | setGraphDotsExcessSpaceFeedbackRatio(float ratio)
Sets the amount of the excess space to feed back to dots thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the dots, making them larger. | | final public void | setGraphDotsExistence(boolean existence)
Sets whether the graph contains dot components. | | final public void | setGraphDotsThicknessModel(int thickness)
Sets the thickness of the dot components for the chart's model size. | | final public void | setGraphDotsWithinCategoryOverlapRatio(float ratio)
Sets how much the dots can overlap eachother when there are multiple
data values per data set and per data category. | | final public void | setGraphLabelsLinesColor(Color color)
Sets the color of the vertical lines of this graph. | | final public void | setGraphLabelsLinesExistence(boolean existence)
Sets whether the vertical lines of this graph exist. | | final public void | setGraphLabelsLinesStyle(float[] style)
Sets the style of the vertical lines of this graph. | | final public void | setGraphLabelsLinesThicknessModel(int thickness)
Sets the thickness of the vertical lines of this graph for the
chart's model size. | | final public void | setGraphLinesExcessSpaceFeedbackRatio(float ratio)
Sets the amount of the excess space to feed back to lines thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the lines, making them larger. | | final public void | setGraphLinesExistence(boolean existence)
Sets whether the graph contains line components. | | final public void | setGraphLinesFillInterior(boolean fill)
Sets whether the graph lines will made to form a shap (ie like a
mountain range). | | final public void | setGraphLinesThicknessAssociation(boolean association)
Sets whether the horizontal and vertical lines (if they both exist)
should both be the same thickness at all times. | | final public void | setGraphLinesThicknessModel(int thickness)
Sets the thickness of the line components for the chart's model size. | | final public void | setGraphLinesWithinCategoryOverlapRatio(float ratio)
Sets how much the lines can overlap eachother when there are multiple
data values per data set and per data category. | | final public void | setGraphNumbersLinesColor(Color color)
Sets the color of the horizontal lines of this graph. | | final public void | setGraphNumbersLinesExistence(boolean existence)
Sets whether the horizontal lines of this graph exist. | | final public void | setGraphNumbersLinesStyle(float[] style)
Sets the style of the horizontal lines of this graph. | | final public void | setGraphNumbersLinesThicknessModel(int thickness)
Sets the thickness of the horizontal lines of this graph for the
chart's model size. | | final public void | setGraphOutlineComponentsColor(Color color)
Sets the color of the thin outline around components
(ie bars, lines, or dots). | | final public void | setGraphOutlineComponentsExistence(boolean existence)
Sets whether there exists a thin outline around each component
(ie bars, lines, or dots). | | final public void | setGraphProperties(GraphProperties graphProps)
Sets all properties to be the values of another GraphProperties object. | | final public void | setGraphPropertiesToDefaults()
Sets all properties to their default values. | | final void | updateGraphChart2D(GraphChart2D graphChart2D)
Updates the properties of this GraphChart2D. | | final boolean | validate(boolean debug)
Validates the properties of this object.
If debug is true then prints a messages indicating whether each property is valid.
Returns true if all the properties were valid and false otherwise.
Parameters:
debug - If true then will print status messages. |
| ALPHA_COMPOSITE_MEDIUM | | public static AlphaComposite ALPHA_COMPOSITE_MEDIUM(Code) | | A medium transparent (some blending) alpha composite.
|
| ALPHA_COMPOSITE_MILD | | public static AlphaComposite ALPHA_COMPOSITE_MILD(Code) | | A mildly transparent (some blending) alpha composite.
|
| ALPHA_COMPOSITE_NONE | | public static AlphaComposite ALPHA_COMPOSITE_NONE(Code) | | An opaque (no blending) alpha composite.
|
| BOTTOM | | public static int BOTTOM(Code) | | Indicates the bottom of something. Used by setGraphComponentsLightSource(int).
|
| COMPONENT | | public static int COMPONENT(Code) | | Indicates only the component. Used by setGraphComponentsLightType(int).
|
| CONTINUOUS | | public static float[] CONTINUOUS(Code) | | Indicates the lines will be continuous.
Used by setGraphNumbersLinesStyle(int) and setGraphLabelsLinesStyle(int).
|
| DASHED | | public static float[] DASHED(Code) | | Indicates the lines will be dashed.
Used by setGraphNumbersLinesStyle(int) and setGraphLabelsLinesStyle(int).
|
| DOTTED | | public static float[] DOTTED(Code) | | Indicates the lines will be dotted.
Used by setGraphNumbersLinesStyle(int) and setGraphLabelsLinesStyle(int).
|
| GRAPH | | public static int GRAPH(Code) | | Indicates only the graph. Used by setGraphComponentsLightType(int).
|
| GRAPH_ALLOW_COMPONENT_ALIGNMENT_DEFAULT | | final public static boolean GRAPH_ALLOW_COMPONENT_ALIGNMENT_DEFAULT(Code) | | The default is false.
|
| GRAPH_BACKGROUND_COLOR_DEFAULT | | final public static Color GRAPH_BACKGROUND_COLOR_DEFAULT(Code) | | The default is Color.white.
|
| GRAPH_BACKGROUND_EXISTENCE_DEFAULT | | final public static boolean GRAPH_BACKGROUND_EXISTENCE_DEFAULT(Code) | | The default is false.
|
| GRAPH_BARS_EXCESS_SPACE_FEEDBACK_RATIO_DEFAULT | | final public static float GRAPH_BARS_EXCESS_SPACE_FEEDBACK_RATIO_DEFAULT(Code) | | The default is 1f.
|
| GRAPH_BARS_EXISTENCE_DEFAULT | | final public static boolean GRAPH_BARS_EXISTENCE_DEFAULT(Code) | | The default is true.
|
| GRAPH_BARS_ROUNDING_RATIO_DEFAULT | | public static float GRAPH_BARS_ROUNDING_RATIO_DEFAULT(Code) | | The default is .75f.
|
| GRAPH_BARS_THICKNESS_MODEL_DEFAULT | | final public static int GRAPH_BARS_THICKNESS_MODEL_DEFAULT(Code) | | The default is 10.
|
| GRAPH_BARS_WITHIN_CATEGORY_OVERLAP_RATIO_DEFAULT | | final public static float GRAPH_BARS_WITHIN_CATEGORY_OVERLAP_RATIO_DEFAULT(Code) | | The default is .535f.
|
| GRAPH_BETWEEN_COMPONENTS_GAP_EXISTENCE_DEFAULT | | final public static boolean GRAPH_BETWEEN_COMPONENTS_GAP_EXISTENCE_DEFAULT(Code) | | The default is true.
|
| GRAPH_BETWEEN_COMPONENTS_GAP_THICKNESS_MODEL_DEFAULT | | final public static int GRAPH_BETWEEN_COMPONENTS_GAP_THICKNESS_MODEL_DEFAULT(Code) | | The default is 2.
|
| GRAPH_BORDER_EXISTENCE_DEFAULT | | final public static boolean GRAPH_BORDER_EXISTENCE_DEFAULT(Code) | | The default is true.
|
| GRAPH_BORDER_LEFT_BOTTOM_COLOR_DEFAULT | | final public static Color GRAPH_BORDER_LEFT_BOTTOM_COLOR_DEFAULT(Code) | | The default is Color.black.
|
| GRAPH_BORDER_RIGHT_TOP_COLOR_DEFAULT | | final public static Color GRAPH_BORDER_RIGHT_TOP_COLOR_DEFAULT(Code) | | The default is Color.gray.
|
| GRAPH_BORDER_THICKNESS_MODEL_DEFAULT | | final public static int GRAPH_BORDER_THICKNESS_MODEL_DEFAULT(Code) | | The default is 2.
|
| GRAPH_COMPONENTS_ALPHA_COMPOSITE_DEFAULT | | public static AlphaComposite GRAPH_COMPONENTS_ALPHA_COMPOSITE_DEFAULT(Code) | | The default is ALPHA_COMPOSITE_NONE.
|
| GRAPH_COMPONENTS_LIGHT_SOURCE_DEFAULT | | public static int GRAPH_COMPONENTS_LIGHT_SOURCE_DEFAULT(Code) | | The default is TOP.
|
| GRAPH_COMPONENTS_LIGHT_TYPE_DEFAULT | | public static int GRAPH_COMPONENTS_LIGHT_TYPE_DEFAULT(Code) | | The default is COMPONENT.
|
| GRAPH_COMPONENTS_OVERFLOW_CLIP_DEFAULT | | final public static boolean GRAPH_COMPONENTS_OVERFLOW_CLIP_DEFAULT(Code) | | The default is true.
|
| GRAPH_DOTS_EXCESS_SPACE_FEEDBACK_RATIO_DEFAULT | | final public static float GRAPH_DOTS_EXCESS_SPACE_FEEDBACK_RATIO_DEFAULT(Code) | | The default is 0f.
|
| GRAPH_DOTS_EXISTENCE_DEFAULT | | final public static boolean GRAPH_DOTS_EXISTENCE_DEFAULT(Code) | | The default is false.
|
| GRAPH_DOTS_THICKNESS_MODEL_DEFAULT | | final public static int GRAPH_DOTS_THICKNESS_MODEL_DEFAULT(Code) | | The default is 8.
|
| GRAPH_DOTS_WITHIN_CATEGORY_OVERLAP_RATIO_DEFAULT | | final public static float GRAPH_DOTS_WITHIN_CATEGORY_OVERLAP_RATIO_DEFAULT(Code) | | The default is .40f.
|
| GRAPH_LABELS_LINES_COLOR_DEFAULT | | final public static Color GRAPH_LABELS_LINES_COLOR_DEFAULT(Code) | | The default is Color.gray.
|
| GRAPH_LABELS_LINES_EXISTENCE_DEFAULT | | final public static boolean GRAPH_LABELS_LINES_EXISTENCE_DEFAULT(Code) | | The default is false.
|
| GRAPH_LABELS_LINES_STYLE_DEFAULT | | final public static float[] GRAPH_LABELS_LINES_STYLE_DEFAULT(Code) | | The default is CONTINUOUS.
|
| GRAPH_LABELS_LINES_THICKNESS_MODEL_DEFAULT | | final public static int GRAPH_LABELS_LINES_THICKNESS_MODEL_DEFAULT(Code) | | The default is 2.
|
| GRAPH_LINES_EXCESS_SPACE_FEEDBACK_RATIO_DEFAULT | | final public static float GRAPH_LINES_EXCESS_SPACE_FEEDBACK_RATIO_DEFAULT(Code) | | The default is 0f.
|
| GRAPH_LINES_EXISTENCE_DEFAULT | | final public static boolean GRAPH_LINES_EXISTENCE_DEFAULT(Code) | | The default is false.
|
| GRAPH_LINES_FILL_INTERIOR_DEFAULT | | final public static boolean GRAPH_LINES_FILL_INTERIOR_DEFAULT(Code) | | The default is false.
|
| GRAPH_LINES_THICKNESS_ASSOCIATION_DEFAULT | | final public static boolean GRAPH_LINES_THICKNESS_ASSOCIATION_DEFAULT(Code) | | The default is true.
|
| GRAPH_LINES_THICKNESS_MODEL_DEFAULT | | final public static int GRAPH_LINES_THICKNESS_MODEL_DEFAULT(Code) | | The default is 5.
|
| GRAPH_LINES_WITHIN_CATEGORY_OVERLAP_RATIO_DEFAULT | | final public static float GRAPH_LINES_WITHIN_CATEGORY_OVERLAP_RATIO_DEFAULT(Code) | | The default is 0f.
|
| GRAPH_NUMBERS_LINES_COLOR_DEFAULT | | final public static Color GRAPH_NUMBERS_LINES_COLOR_DEFAULT(Code) | | The default is Color.gray.
|
| GRAPH_NUMBERS_LINES_EXISTENCE_DEFAULT | | final public static boolean GRAPH_NUMBERS_LINES_EXISTENCE_DEFAULT(Code) | | The default is true.
|
| GRAPH_NUMBERS_LINES_STYLE_DEFAULT | | final public static float[] GRAPH_NUMBERS_LINES_STYLE_DEFAULT(Code) | | The default is CONTINUOUS.
|
| GRAPH_NUMBERS_LINES_THICKNESS_MODEL_DEFAULT | | final public static int GRAPH_NUMBERS_LINES_THICKNESS_MODEL_DEFAULT(Code) | | The default is 2.
|
| GRAPH_OUTLINE_COMPONENTS_COLOR_DEFAULT | | final public static Color GRAPH_OUTLINE_COMPONENTS_COLOR_DEFAULT(Code) | | The default is Color.black.
|
| GRAPH_OUTLINE_COMPONENTS_EXISTENCE_DEFAULT | | final public static boolean GRAPH_OUTLINE_COMPONENTS_EXISTENCE_DEFAULT(Code) | | The default is false.
|
| LEFT | | public static int LEFT(Code) | | Indicates the left of something. Used by setGraphComponentsLightSource(int).
|
| NONE | | public static int NONE(Code) | | Indicates none. Used by setGraphComponentsLightSource(int).
|
| RIGHT | | public static int RIGHT(Code) | | Indicates the right of something. Used by setGraphComponentsLightSource(int).
|
| TOP | | public static int TOP(Code) | | Indicates the top of something. Used by setGraphComponentsLightSource(int).
|
| GraphProperties | | public GraphProperties()(Code) | | Creates a GraphProperties object with the documented default values.
|
| GraphProperties | | public GraphProperties(GraphProperties graphProps)(Code) | | Creates a GraphProperties object with property values copied from another object.
The copying is a deep copy.
Parameters:
graphProps - The properties to copy. |
| addGraphChart2D | | final void addGraphChart2D(GraphChart2D graphChart2D)(Code) | | Adds a GraphChart2D to the set of objects using these properties.
Parameters:
graphChart2D - The Object2D to add. |
| configureGraphArea | | final void configureGraphArea(int type, GraphArea graph)(Code) | | Accepts a graph area and configures it with current properties.
Parameters:
type - Whether the graph is labels bottom or labels left using GraphChart2D fields.
Parameters:
graph - The graph area to configure. |
| configureGraphArea | | final void configureGraphArea(GraphProperties backgroundGraphProps, int type, GraphArea graph)(Code) | | Accepts a graph area and configures it with current properties.
Uses the properties of the background graph in order to overlay correctly.
Parameters:
backgroundGraphProps - The properties of the background graph.
Parameters:
type - Whether the graph is labels bottom or labels left using GraphChart2D fields.
Parameters:
graph - The graph area to configure. |
| getGraphAllowComponentAlignment | | final public boolean getGraphAllowComponentAlignment()(Code) | | Gets whether the graph's components (ie bars, dots, or lines) are
allowed to overlap/align or are offset for each set and within each
category. For non-stacked bars charts, don't align; for all other chart
types alignment is generally preferrable.
boolean If true, the components will not be offset within thecategory. |
| getGraphBackgroundColor | | final public Color getGraphBackgroundColor()(Code) | | Gets the color of the background of this graph. For each chart this
graph is added to, this property will only be respected if its the first
graph added that the chart; otherwise, graphs added after any chart would
totally paint over the previous graph.
Color The color of the background of this graph. |
| getGraphBackgroundExistence | | final public boolean getGraphBackgroundExistence()(Code) | | Gets whether the background of this graph exists. For each chart this
graph is added to, this property will only be respected if its the first
graph added that the chart; otherwise, graphs added after any chart would
totally paint over the previous graph.
boolean If true, the background of this graph will exist. |
| getGraphBarsExcessSpaceFeedbackRatio | | final public float getGraphBarsExcessSpaceFeedbackRatio()(Code) | | Gets the amount of the excess space to feed back to bars thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the bars, making them larger. The ratio is the amount of
space to feed back to the bars, to the total amount of space.
float The ratio on the total amount of space to feedback. |
| getGraphBarsExistence | | final public boolean getGraphBarsExistence()(Code) | | Gets whether the graph contains bar components.
boolean If true, then the graph contains bars. |
| getGraphBarsRoundingRatio | | final public float getGraphBarsRoundingRatio()(Code) | | Gets the degree of rounding for the bars. Uses the RoundRectangle in its implemenation.
See the arcw and arch properties for guidance of RoundRectangle.
The ratio is the diameter of the half-ellipse making the arc over the dimension in one
direction of a bar. For the "Labels" ratio, the direction is the same direction in which the
labels axis runs. Possible values are between zero and 1. Zero means less round, one means
more round.
The rounding ratio. |
| getGraphBarsThicknessModel | | final public int getGraphBarsThicknessModel()(Code) | | Gets the thickness of the bar components for the chart's model size.
int The model thickness of the bars. |
| getGraphBarsWithinCategoryOverlapRatio | | final public float getGraphBarsWithinCategoryOverlapRatio()(Code) | | Gets how much the bars can overlap eachother when there are multiple
data values per data set and per data category.
ratio The ratio on the thickness of the bar for overlap. |
| getGraphBetweenComponentsGapExistence | | final public boolean getGraphBetweenComponentsGapExistence()(Code) | | Gets whether a gap between each category of components exists (ie
not the gap between each each component with each category).
boolean If true, then the gap between components exists. |
| getGraphBetweenComponentsGapThicknessModel | | final public int getGraphBetweenComponentsGapThicknessModel()(Code) | | Gets the thickness of the gap between each category of components for
the chart's model size.
int The model thickness of teh gap between components. |
| getGraphBorderExistence | | final public boolean getGraphBorderExistence()(Code) | | Gets whether the graph's left and bottom border exists.
boolean If true, then the graph's left and bottom border exists. |
| getGraphBorderLeftBottomColor | | final public Color getGraphBorderLeftBottomColor()(Code) | | Gets the color of the graph's left and bottom border.
Color The color of the graph's left and bottom border. |
| getGraphBorderRightTopColor | | final public Color getGraphBorderRightTopColor()(Code) | | Gets the color of the graph's right and top border.
Color The color of the graph's right and top border. |
| getGraphBorderThicknessModel | | final public int getGraphBorderThicknessModel()(Code) | | Gets the thickness of the graph's left and bottom border for the
chart's model size.
int The model thickness of the graph's left and bottom border. |
| getGraphChart2DNeedsUpdate | | final boolean getGraphChart2DNeedsUpdate(GraphChart2D graphChart2D)(Code) | | Gets whether this object needs to be updated with new properties.
Parameters:
graphChart2D - The object that may need to be updated. If true then needs update. |
| getGraphComponentsAlphaComposite | | final public AlphaComposite getGraphComponentsAlphaComposite()(Code) | | Gets the actual AlphaComposite object to use on the Graphics2D object context for painting the
graph components managed by this GraphProperties object. By passing different AlphaComposite
objects, the graph components can take on a blending or transparency effect. Underneath
components can be seen through components painted over them. This is especially useful for
"line area" or "filled line" charts because top lines can paint over underneath lines if not
using a "stacked" dataset object.
The AlphaComposite object to use. |
| getGraphComponentsLightSource | | final public int getGraphComponentsLightSource()(Code) | | Gets the direction of the source of the light if any.
Possible values are: TOP, BOTTOM, LEFT, RIGHT, and NONE.
The direction of the light source. |
| getGraphComponentsLightType | | final public int getGraphComponentsLightType()(Code) | | Gets the type of the lighting affect.
Possible values are: COMPONENT and GRAPH.
COMPONENT implies that the light source is positioned directly on the components (for example
leaving a complete shading affect for each component).
GRAPH implies that the light source is positioned directly on the graph (for example leaving
the components on one side of the graph lighter than the others).
The lighting affect type. |
| getGraphComponentsOverflowClip | | final public boolean getGraphComponentsOverflowClip()(Code) | | Gets whether the graph's components will be clipped if they pass over the graph's inner
space or border. The only time the graph's components should not be clipped is if the graph's
inner space and border are set to not exist. Not clipping may cause components to be painted
over other chart components such as the legend or axis.
If true, then the components will be clipped. |
| getGraphDotsExcessSpaceFeedbackRatio | | final public float getGraphDotsExcessSpaceFeedbackRatio()(Code) | | Gets the amount of the excess space to feed back to dots thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the dots, making them larger. The ratio is the amount of
space to feed back to the dots, to the total amount of space.
float The ratio on the total amount of space to feedback. |
| getGraphDotsExistence | | final public boolean getGraphDotsExistence()(Code) | | Gets whether the graph contains dot components.
boolean If true, then the graph contains dots. |
| getGraphDotsThicknessModel | | final public int getGraphDotsThicknessModel()(Code) | | Gets the thickness of the dot components for the chart's model size.
int The model thickness of the dots. |
| getGraphDotsWithinCategoryOverlapRatio | | final public float getGraphDotsWithinCategoryOverlapRatio()(Code) | | Gets how much the dots can overlap eachother when there are multiple
data values per data set and per data category.
ratio The ratio on the thickness of the dot for overlap. |
| getGraphLabelsLinesColor | | final public Color getGraphLabelsLinesColor()(Code) | | Gets the color of the vertical lines of this graph. These lines
are aligned with the axis's ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components.
Color The color of the vertical lines. |
| getGraphLabelsLinesExistence | | final public boolean getGraphLabelsLinesExistence()(Code) | | Gets whether the vertical lines of this graph exist. These lines
are aligned with the axis' ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components.
boolean If true, the vertical lines exist. |
| getGraphLabelsLinesStyle | | final public float[] getGraphLabelsLinesStyle()(Code) | | Gets the style of the vertical lines of this graph. These lines
are aligned with the axis's ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components. Possible values for style are:
CONTINUOUS, DASHED, and DOTTED.
float[] The style of the vertical lines. |
| getGraphLabelsLinesThicknessModel | | final public int getGraphLabelsLinesThicknessModel()(Code) | | Gets the thickness of the vertical lines of this graph for the
chart's model size. These lines are aligned with the axis's ticks. For
each chart this graph is added to, this property will only be respected if
its the first graph added that the chart; otherwise, graphs added after any
chart would paint over the previous graph's components.
int The model thickness of the vertical lines. |
| getGraphLinesExcessSpaceFeedbackRatio | | final public float getGraphLinesExcessSpaceFeedbackRatio()(Code) | | Gets the amount of the excess space to feed back to lines thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the lines, making them larger. The ratio is the amount of
space to feed back to the lines, to the total amount of space.
float The ratio on the total amount of space to feedback. |
| getGraphLinesExistence | | final public boolean getGraphLinesExistence()(Code) | | Gets whether the graph contains line components.
boolean If true, then the graph contains lines. |
| getGraphLinesFillInterior | | final public boolean getGraphLinesFillInterior()(Code) | | Gets whether the graph lines will made to form a shap (ie like a
mountain range).
boolean If true, then the lines will be filled. |
| getGraphLinesThicknessAssociation | | final public boolean getGraphLinesThicknessAssociation()(Code) | | Gets whether the horizontal and vertical lines (if they both exist)
should both be the same thickness at all times. Uses the smaller thickness
if they are not already equal.
boolean If true, then these lines will have equal thickness. |
| getGraphLinesThicknessModel | | final public int getGraphLinesThicknessModel()(Code) | | Gets the thickness of the line components for the chart's model size.
int The model thickness of the lines. |
| getGraphLinesWithinCategoryOverlapRatio | | final public float getGraphLinesWithinCategoryOverlapRatio()(Code) | | Gets how much the lines can overlap eachother when there are multiple
data values per data set and per data category.
ratio The ratio on the thickness of the line for overlap. |
| getGraphNumbersLinesColor | | final public Color getGraphNumbersLinesColor()(Code) | | Gets the color of the horizontal lines of this graph. These lines
are aligned with the axis's ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components.
Color The color of the horizontal lines. |
| getGraphNumbersLinesExistence | | final public boolean getGraphNumbersLinesExistence()(Code) | | Gets whether the horizontal lines of this graph exist. These lines
are aligned with the axis' ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components.
boolean If true, the horizontal lines exist. |
| getGraphNumbersLinesStyle | | final public float[] getGraphNumbersLinesStyle()(Code) | | Gets the style of the horizontal lines of this graph. These lines
are aligned with the axis's ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components. Possible values for style are:
CONTINUOUS, DASHED, and DOTTED.
float[] The style of the horizontal lines. |
| getGraphNumbersLinesThicknessModel | | final public int getGraphNumbersLinesThicknessModel()(Code) | | Gets the thickness of the horizontal lines of this graph for the
chart's model size. These lines are aligned with the axis's ticks. For
each chart this graph is added to, this property will only be respected if
its the first graph added that the chart; otherwise, graphs added after any
chart would paint over the previous graph's components.
int The model thickness of the horizontal lines. |
| getGraphOutlineComponentsColor | | final public Color getGraphOutlineComponentsColor()(Code) | | Gets the color of the thin outline around components
(ie bars, lines, or dots).
Color The color of each component's outline. |
| getGraphOutlineComponentsExistence | | final public boolean getGraphOutlineComponentsExistence()(Code) | | Gets whether there exists a thin outline around each component
(ie bars, lines, or dots).
boolean If true, the components will have an outline. |
| removeGraphChart2D | | final void removeGraphChart2D(GraphChart2D graphChart2D)(Code) | | Removes a GraphChart2D from the set of objects using these properties.
Parameters:
graphChart2D - The Object2D to remove. |
| setGraphAllowComponentAlignment | | final public void setGraphAllowComponentAlignment(boolean alignment)(Code) | | Sets whether the graph's components (ie bars, dots, or lines) are
allowed to overlap/align or are offset for each set and within each
category. For non-stacked bars charts, don't align; for all other chart
types alignment is generally preferrable.
Parameters:
alignment - If true, the components will not be offset within thecategory. |
| setGraphBackgroundColor | | final public void setGraphBackgroundColor(Color color)(Code) | | Sets the color of the background of this graph. For each chart this
graph is added to, this property will only be respected if its the first
graph added that the chart; otherwise, graphs added after any chart would
totally paint over the previous graph.
Parameters:
color - The color of the background of this graph. |
| setGraphBackgroundExistence | | final public void setGraphBackgroundExistence(boolean existence)(Code) | | Sets whether the background of this graph exists. For each chart this
graph is added to, this property will only be respected if its the first
graph added that the chart; otherwise, graphs added after any chart would
totally paint over the previous graph.
Parameters:
existence - If true, the background of this graph will exist. |
| setGraphBarsExcessSpaceFeedbackRatio | | final public void setGraphBarsExcessSpaceFeedbackRatio(float ratio)(Code) | | Sets the amount of the excess space to feed back to bars thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the bars, making them larger. The ratio is the amount of
space to feed back to the bars, to the total amount of space.
Parameters:
ratio - The ratio on the total amount of space to feedback. |
| setGraphBarsExistence | | final public void setGraphBarsExistence(boolean existence)(Code) | | Sets whether the graph contains bar components.
Parameters:
existence - If true, then the graph contains bars. |
| setGraphBarsRoundingRatio | | final public void setGraphBarsRoundingRatio(float r)(Code) | | Sets the degree of rounding for the bars. Uses the RoundRectangle in its implemenation.
See the arcw and arch properties for guidance of RoundRectangle.
The ratio is the diameter of the half-ellipse making the arc over the dimension in one
direction of a bar. For the "Labels" ratio, the direction is the same direction in which the
labels axis runs. Possible values are between zero and 1. Zero means less round, one means
more round.
Parameters:
r - The rounding ratio. |
| setGraphBarsThicknessModel | | final public void setGraphBarsThicknessModel(int thickness)(Code) | | Sets the thickness of the bar components for the chart's model size.
Parameters:
thickness - The model thickness of the bars. |
| setGraphBarsWithinCategoryOverlapRatio | | final public void setGraphBarsWithinCategoryOverlapRatio(float ratio)(Code) | | Sets how much the bars can overlap eachother when there are multiple
data values per data set and per data category.
Parameters:
ratio - The ratio on the thickness of the bar for overlap. |
| setGraphBetweenComponentsGapExistence | | final public void setGraphBetweenComponentsGapExistence(boolean existence)(Code) | | Sets whether a gap between each category of components exists (ie
not the gap between each each component with each category).
Parameters:
existence - If true, then the gap between components exists. |
| setGraphBetweenComponentsGapThicknessModel | | final public void setGraphBetweenComponentsGapThicknessModel(int thickness)(Code) | | Sets the thickness of the gap between each category of components for
the chart's model size.
Parameters:
thickness - The model thickness of teh gap between components. |
| setGraphBorderExistence | | final public void setGraphBorderExistence(boolean existence)(Code) | | Sets whether the graph's left and bottom border exists.
Parameters:
existence - If true, then the graph's left and bottom border exists. |
| setGraphBorderLeftBottomColor | | final public void setGraphBorderLeftBottomColor(Color color)(Code) | | Sets the color of the graph's left and bottom border.
Parameters:
color - The color of the graph's left and bottom border. |
| setGraphBorderRightTopColor | | final public void setGraphBorderRightTopColor(Color color)(Code) | | Sets the color of the graph's right and top border.
Parameters:
color - The color of the graph's right and top border. |
| setGraphBorderThicknessModel | | final public void setGraphBorderThicknessModel(int thickness)(Code) | | Sets the thickness of the graph's left and bottom border for the
chart's model size.
Parameters:
thickness - The model thickness of the graph's left and bottom border. |
| setGraphComponentsAlphaComposite | | final public void setGraphComponentsAlphaComposite(AlphaComposite a)(Code) | | Sets the actual AlphaComposite object to use on the Graphics2D object context for painting the
graph components managed by this GraphProperties object. By passing different AlphaComposite
objects, the graph components can take on a blending or transparency effect. Underneath
components can be seen through components painted over them. This is especially useful for
"line area" or "filled line" charts because top lines can paint over underneath lines if not
using a "stacked" dataset object.
Parameters:
a - The AlphaComposite object to use. |
| setGraphComponentsLightSource | | final public void setGraphComponentsLightSource(int s)(Code) | | Sets the direction of the source of the light if any.
Possible values are: TOP, BOTTOM, LEFT, RIGHT, TOPLEFT, BOTTOMRIGHT, and NONE.
Parameters:
s - The direction of the light source. |
| setGraphComponentsLightType | | final public void setGraphComponentsLightType(int t)(Code) | | Sets the type of the lighting affect.
Possible values are: COMPONENT and GRAPH.
COMPONENT implies that the light source is positioned directly on the components (for example
leaving a complete shading affect for each component).
GRAPH implies that the light source is positioned directly on the graph (for example leaving
the components on one side of the graph lighter than the others).
Parameters:
t - The lighting affect type. |
| setGraphComponentsOverflowClip | | final public void setGraphComponentsOverflowClip(boolean c)(Code) | | Sets whether the graph's components will be clipped if they pass over the graph's inner space
or border. The only time the graph's components should not be clipped is if the graph's
inner space and border are set to not exist. Not clipping may cause components to be painted
over other chart components such as the legend or axis.
Parameters:
c - If true, then the components will be clipped. |
| setGraphDotsExcessSpaceFeedbackRatio | | final public void setGraphDotsExcessSpaceFeedbackRatio(float ratio)(Code) | | Sets the amount of the excess space to feed back to dots thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the dots, making them larger. The ratio is the amount of
space to feed back to the dots, to the total amount of space.
Parameters:
ratio - The ratio on the total amount of space to feedback. |
| setGraphDotsExistence | | final public void setGraphDotsExistence(boolean existence)(Code) | | Sets whether the graph contains dot components.
Parameters:
existence - If true, then the graph contains dots. |
| setGraphDotsThicknessModel | | final public void setGraphDotsThicknessModel(int thickness)(Code) | | Sets the thickness of the dot components for the chart's model size.
Parameters:
thickness - The model thickness of the dots. |
| setGraphDotsWithinCategoryOverlapRatio | | final public void setGraphDotsWithinCategoryOverlapRatio(float ratio)(Code) | | Sets how much the dots can overlap eachother when there are multiple
data values per data set and per data category.
Parameters:
ratio - The ratio on the thickness of the dot for overlap. |
| setGraphLabelsLinesColor | | final public void setGraphLabelsLinesColor(Color color)(Code) | | Sets the color of the vertical lines of this graph. These lines
are aligned with the axis's ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components.
Parameters:
color - The color of the vertical lines. |
| setGraphLabelsLinesExistence | | final public void setGraphLabelsLinesExistence(boolean existence)(Code) | | Sets whether the vertical lines of this graph exist. These lines
are aligned with the axis' ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components.
Parameters:
existence - If true, the vertical lines exist. |
| setGraphLabelsLinesStyle | | final public void setGraphLabelsLinesStyle(float[] style)(Code) | | Sets the style of the vertical lines of this graph. These lines
are aligned with the axis's ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components. Possible values for style are:
CONTINUOUS, DASHED, and DOTTED.
Parameters:
style - The style of the vertical lines. |
| setGraphLabelsLinesThicknessModel | | final public void setGraphLabelsLinesThicknessModel(int thickness)(Code) | | Sets the thickness of the vertical lines of this graph for the
chart's model size. These lines are aligned with the axis's ticks. For
each chart this graph is added to, this property will only be respected if
its the first graph added that the chart; otherwise, graphs added after any
chart would paint over the previous graph's components.
Parameters:
thickness - The model thickness of the vertical lines. |
| setGraphLinesExcessSpaceFeedbackRatio | | final public void setGraphLinesExcessSpaceFeedbackRatio(float ratio)(Code) | | Sets the amount of the excess space to feed back to lines thickness.
Frequently the graphs are larger than necessary, the excess space can
be fedback to the lines, making them larger. The ratio is the amount of
space to feed back to the lines, to the total amount of space.
Parameters:
ratio - The ratio on the total amount of space to feedback. |
| setGraphLinesExistence | | final public void setGraphLinesExistence(boolean existence)(Code) | | Sets whether the graph contains line components.
Parameters:
existence - If true, then the graph contains lines. |
| setGraphLinesFillInterior | | final public void setGraphLinesFillInterior(boolean fill)(Code) | | Sets whether the graph lines will made to form a shap (ie like a
mountain range).
Parameters:
fill - If true, then the lines will be filled. |
| setGraphLinesThicknessAssociation | | final public void setGraphLinesThicknessAssociation(boolean association)(Code) | | Sets whether the horizontal and vertical lines (if they both exist)
should both be the same thickness at all times. Uses the smaller thickness
if they are not already equal.
Parameters:
association - If true, then these lines will have equal thickness. |
| setGraphLinesThicknessModel | | final public void setGraphLinesThicknessModel(int thickness)(Code) | | Sets the thickness of the line components for the chart's model size.
Parameters:
thickness - The model thickness of the lines. |
| setGraphLinesWithinCategoryOverlapRatio | | final public void setGraphLinesWithinCategoryOverlapRatio(float ratio)(Code) | | Sets how much the lines can overlap eachother when there are multiple
data values per data set and per data category.
Parameters:
ratio - The ratio on the thickness of the line for overlap. |
| setGraphNumbersLinesColor | | final public void setGraphNumbersLinesColor(Color color)(Code) | | Sets the color of the horizontal lines of this graph. These lines
are aligned with the axis's ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components.
Parameters:
color - The color of the horizontal lines. |
| setGraphNumbersLinesExistence | | final public void setGraphNumbersLinesExistence(boolean existence)(Code) | | Sets whether the horizontal lines of this graph exist. These lines
are aligned with the axis' ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components.
Parameters:
existence - If true, the horizontal lines exist. |
| setGraphNumbersLinesStyle | | final public void setGraphNumbersLinesStyle(float[] style)(Code) | | Sets the style of the horizontal lines of this graph. These lines
are aligned with the axis's ticks. For each chart this graph is added to,
this property will only be respected if its the first graph added that the
chart; otherwise, graphs added after any chart would paint over the
previous graph's components. Possible values for style are:
CONTINUOUS, DASHED, and DOTTED.
Parameters:
style - The style of the horizontal lines. |
| setGraphNumbersLinesThicknessModel | | final public void setGraphNumbersLinesThicknessModel(int thickness)(Code) | | Sets the thickness of the horizontal lines of this graph for the
chart's model size. These lines are aligned with the axis's ticks. For
each chart this graph is added to, this property will only be respected if
its the first graph added that the chart; otherwise, graphs added after any
chart would paint over the previous graph's components.
Parameters:
thickness - The model thickness of the horizontal lines. |
| setGraphOutlineComponentsColor | | final public void setGraphOutlineComponentsColor(Color color)(Code) | | Sets the color of the thin outline around components
(ie bars, lines, or dots).
Parameters:
color - The color of each component's outline. |
| setGraphOutlineComponentsExistence | | final public void setGraphOutlineComponentsExistence(boolean existence)(Code) | | Sets whether there exists a thin outline around each component
(ie bars, lines, or dots).
Parameters:
existence - If true, the components will have an outline. |
| setGraphProperties | | final public void setGraphProperties(GraphProperties graphProps)(Code) | | Sets all properties to be the values of another GraphProperties object.
The copying is a deep copy.
Parameters:
graphProps - The properties to copy. |
| setGraphPropertiesToDefaults | | final public void setGraphPropertiesToDefaults()(Code) | | Sets all properties to their default values.
|
| updateGraphChart2D | | final void updateGraphChart2D(GraphChart2D graphChart2D)(Code) | | Updates the properties of this GraphChart2D.
Parameters:
graphChart2D - The object to update. |
| validate | | final boolean validate(boolean debug)(Code) | | Validates the properties of this object.
If debug is true then prints a messages indicating whether each property is valid.
Returns true if all the properties were valid and false otherwise.
Parameters:
debug - If true then will print status messages. If true then valid. |
|
|