/*
 * GRAL: GRAphing Library for Java(R)
 *
 * (C) Copyright 2009-2016 Erich Seifert ,
 * Michael Seifert 
 *
 * This file is part of GRAL.
 *
 * GRAL is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GRAL is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with GRAL.  If not, see .
 */
package de.erichseifert.gral.plots.axes;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.geom.AffineTransform;
import java.awt.geom.Dimension2D;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.text.Format;
import java.text.NumberFormat;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import de.erichseifert.gral.graphics.AbstractDrawable;
import de.erichseifert.gral.graphics.Drawable;
import de.erichseifert.gral.graphics.DrawingContext;
import de.erichseifert.gral.graphics.Label;
import de.erichseifert.gral.plots.axes.Tick.TickType;
import de.erichseifert.gral.util.GeometryUtils;
import de.erichseifert.gral.util.GraphicsUtils;
import de.erichseifert.gral.util.MathUtils;
import de.erichseifert.gral.util.PointND;
import de.erichseifert.gral.util.SerializationUtils;


/**
 * 

Abstract class that provides function for rendering axes in * two-dimensional space.

*

Functionality includes:

*
    *
  • Calculating tick positions of an axis
  • *
  • Calculating tick normals
  • *
  • Administration of settings
  • *
*/ public abstract class AbstractAxisRenderer2D implements AxisRenderer, Serializable { /** Version id for serialization. */ private static final long serialVersionUID = 5623525683845512624L; /** Line segments approximating the shape of the axis. */ private Line2D[] shapeLines; /** Normals of the line segments approximating the axis. */ private Point2D[] shapeLineNormals; /** Lengths of the line segments approximating the axis. */ private double[] shapeSegmentLengths; /** Length of the axis up to a certain approximating line segment. */ private double[] shapeSegmentLengthsAccumulated; /** Intersection point of the axis. */ private Number intersection; /** Shape used for drawing. */ private Shape shape; /** Decides whether the shape is drawn. */ private boolean shapeVisible; /** Decides whether the shape normals are orientated clockwise. */ private boolean shapeNormalOrientationClockwise; /** Paint used to draw axis shape, ticks, and labels. */ private Paint shapeColor; /** Stroke used for drawing the axis shape. */ // Property will be serialized using a wrapper private transient Stroke shapeStroke; /** Decides whether the axis direction will be changed. */ private boolean shapeDirectionSwapped; /** Decides whether major ticks are drawn. */ private boolean ticksVisible; /** Distance on axis in which major ticks are drawn. */ private Number tickSpacing; /** Decides whether automatic tick spacing is enabled. */ private boolean ticksAutoSpaced; /** Tick length relative to the font */ private double tickLength; /** Stroke which is used to draw all major ticks. */ // Property will be serialized using a wrapper private transient Stroke tickStroke; /** Alignment of major ticks relative to the axis. */ private double tickAlignment; /** Font used to display the text of major ticks. */ private Font tickFont; /** Paint used to draw the shapes of major ticks. */ private Paint tickColor; /** Decides whether tick labels will be shown. */ private boolean tickLabelsVisible; /** Format which converts the tick values to labels. */ private Format tickLabelFormat; /** Distance between labels and ticks relative to the font height. */ private double tickLabelDistance; /** Decides whether the tick labels are drawn outside of the plot. */ private boolean tickLabelsOutside; /** Tick label rotation in degrees. */ private double tickLabelRotation; /** Decides whether minor ticks are drawn. */ private boolean minorTickVisible; /** Number of minor ticks between two major ticks. */ private int minorTicksCount; /** Tick length relative to font height.*/ private double minorTickLength; /** Stroke used to draw all minor ticks. */ // Property will be serialized using a wrapper private transient Stroke minorTickStroke; /** Minor tick alignment relative to the axis. */ private double minorTickAlignment; /** Paint used to draw the shapes of minor ticks. */ private Paint minorTickColor; /** Custom labels containing their respective position and text. */ private final Map customTicks; /** Label text of the axis. */ private Label label; /** Distance relative to font height. */ private double labelDistance; /** * Initializes a new instance with default settings. */ public AbstractAxisRenderer2D() { intersection = 0.0; // The direction must defined as swapped before the shape is evaluated. shapeDirectionSwapped = false; shape = new Line2D.Double(0.0, 0.0, 1.0, 0.0); evaluateShape(shape); shapeVisible = true; shapeNormalOrientationClockwise = false; shapeStroke = new BasicStroke(); shapeColor = Color.BLACK; ticksVisible = true; tickSpacing = 0.0; ticksAutoSpaced = false; tickLength = 1.0; tickStroke = new BasicStroke(); tickAlignment = 0.5; tickFont = Font.decode(null); tickColor = Color.BLACK; tickLabelsVisible = true; tickLabelFormat = NumberFormat.getInstance(); tickLabelDistance = 1.0; tickLabelsOutside = true; tickLabelRotation = 0.0; customTicks = new HashMap(); minorTickVisible = true; minorTicksCount = 1; minorTickLength = 0.5; minorTickStroke = new BasicStroke(); minorTickAlignment = 0.5; minorTickColor = Color.BLACK; label = new Label(); labelDistance = 1.0; } /** * Returns a component that displays the specified axis. * @param axis axis to be displayed * @return component displaying the axis * @see Axis */ public Drawable getRendererComponent(final Axis axis) { final Drawable component = new AbstractDrawable() { /** Version id for serialization. */ private static final long serialVersionUID = 3605211198378801694L; /** * Draws the {@code Drawable} with the specified drawing context. * @param context Environment used for drawing */ public void draw(DrawingContext context) { if (shapeLines == null || shapeLines.length == 0) { return; } AbstractAxisRenderer2D renderer = AbstractAxisRenderer2D.this; Graphics2D graphics = context.getGraphics(); // Remember old state of Graphics2D instance AffineTransform txOrig = graphics.getTransform(); graphics.translate(getX(), getY()); Stroke strokeOld = graphics.getStroke(); Paint paintOld = graphics.getPaint(); // Draw axis shape Paint axisPaint = renderer.getShapeColor(); Stroke axisStroke = renderer.getShapeStroke(); boolean isShapeVisible = renderer.isShapeVisible(); if (isShapeVisible) { Shape shape = renderer.getShape(); GraphicsUtils.drawPaintedShape( graphics, shape, axisPaint, null, axisStroke); } double fontSize = renderer.getTickFont().getSize2D(); // Draw ticks boolean drawTicksMajor = renderer.isTicksVisible(); boolean drawTicksMinor = renderer.isMinorTicksVisible(); if (drawTicksMajor || (drawTicksMajor && drawTicksMinor)) { // Calculate tick positions (in pixel coordinates) List ticks = getTicks(axis); boolean isTickLabelVisible = renderer.isTickLabelsVisible(); boolean isTickLabelOutside = renderer.isTickLabelsOutside(); double tickLabelRotation = renderer.getTickLabelRotation(); double tickLabelDist = renderer.getTickLabelDistanceAbsolute(); Line2D tickShape = new Line2D.Double(); for (Tick tick : ticks) { // Draw tick if ((tick.position == null) || (tick.normal == null)) { continue; } Point2D tickPoint = tick.position.getPoint2D(); Point2D tickNormal = tick.normal.getPoint2D(); double tickLength; double tickAlignment; Paint tickPaint; Stroke tickStroke; if (TickType.MINOR.equals(tick.type)) { tickLength = renderer.getTickMinorLengthAbsolute(); tickAlignment = renderer.getMinorTickAlignment(); tickPaint = renderer.getMinorTickColor(); tickStroke = renderer.getMinorTickStroke(); } else { tickLength = getTickLengthAbsolute(); tickAlignment = renderer.getTickAlignment(); tickPaint = renderer.getTickColor(); tickStroke = renderer.getTickStroke(); } double tickLengthInner = tickLength*tickAlignment; double tickLengthOuter = tickLength*(1.0 - tickAlignment); if ((drawTicksMajor && (tick.type == TickType.MAJOR) || tick.type == TickType.CUSTOM) || (drawTicksMinor && tick.type == TickType.MINOR)) { tickShape.setLine( tickPoint.getX() - tickNormal.getX()*tickLengthInner, tickPoint.getY() - tickNormal.getY()*tickLengthInner, tickPoint.getX() + tickNormal.getX()*tickLengthOuter, tickPoint.getY() + tickNormal.getY()*tickLengthOuter ); GraphicsUtils.drawPaintedShape( graphics, tickShape, tickPaint, null, tickStroke); } // Draw label if (isTickLabelVisible && (tick.type == TickType.MAJOR || tick.type == TickType.CUSTOM)) { String tickLabelText = tick.label; if (tickLabelText != null && !tickLabelText.trim().isEmpty()) { Label tickLabel = new Label(tickLabelText); tickLabel.setFont(renderer.getTickFont()); // TODO Allow separate colors for ticks and tick labels? tickLabel.setColor(tickPaint); double labelDist = tickLengthOuter + tickLabelDist; layoutLabel(tickLabel, tickPoint, tickNormal, labelDist, isTickLabelOutside, tickLabelRotation); tickLabel.draw(context); } } } } // Draw axis label Label axisLabel = renderer.getLabel(); if (axisLabel != null && !axisLabel.getText().trim().isEmpty()) { double tickLength = getTickLengthAbsolute(); double tickAlignment = renderer.getTickAlignment(); double tickLengthOuter = tickLength*(1.0 - tickAlignment); double tickLabelDistance = renderer.getTickLabelDistanceAbsolute(); double labelDistance = renderer.getLabelDistance()*fontSize; double labelDist = tickLengthOuter + tickLabelDistance + fontSize + labelDistance; double axisLabelPos = (axis.getMin().doubleValue() + axis.getMax().doubleValue()) * 0.5; boolean isTickLabelOutside = renderer.isTickLabelsOutside(); PointND labelPos = getPosition(axis, axisLabelPos, false, true); PointND labelNormal = getNormal(axis, axisLabelPos, false, true); if (labelPos != null && labelNormal != null) { layoutLabel(axisLabel, labelPos.getPoint2D(), labelNormal.getPoint2D(), labelDist, isTickLabelOutside, axisLabel.getRotation()); axisLabel.draw(context); } } graphics.setPaint(paintOld); graphics.setStroke(strokeOld); graphics.setTransform(txOrig); } private void layoutLabel(Label label, Point2D labelPos, Point2D labelNormal, double labelDist, boolean isLabelOutside, double rotation) { Rectangle2D labelSize = label.getTextRectangle(); Shape marginShape = new Rectangle2D.Double( 0, 0, labelSize.getWidth() + 2.0*labelDist, labelSize.getHeight() + 2.0*labelDist ); Rectangle2D marginBounds = marginShape.getBounds2D(); label.setRotation(rotation); if ((rotation%360.0) != 0.0) { marginShape = AffineTransform.getRotateInstance( Math.toRadians(-rotation), marginBounds.getCenterX(), marginBounds.getCenterY() ).createTransformedShape(marginShape); } marginBounds = marginShape.getBounds2D(); double intersRayLength = marginBounds.getHeight()*marginBounds.getHeight() + marginBounds.getWidth()*marginBounds.getWidth(); double intersRayDir = (isLabelOutside?-1.0:1.0)*intersRayLength; List descriptionBoundsIntersections = GeometryUtils.intersection( marginBounds, new Line2D.Double( marginBounds.getCenterX(), marginBounds.getCenterY(), marginBounds.getCenterX() + intersRayDir*labelNormal.getX(), marginBounds.getCenterY() + intersRayDir*labelNormal.getY() ) ); if (!descriptionBoundsIntersections.isEmpty()) { Point2D inters = descriptionBoundsIntersections.get(0); double intersX = inters.getX() - marginBounds.getCenterX(); double intersY = inters.getY() - marginBounds.getCenterY(); double posX = labelPos.getX() - intersX - labelSize.getWidth()/2.0; double posY = labelPos.getY() - intersY - labelSize.getHeight()/2.0; label.setBounds(posX, posY, labelSize.getWidth(), labelSize.getHeight()); } } @Override public Dimension2D getPreferredSize() { AbstractAxisRenderer2D renderer = AbstractAxisRenderer2D.this; double fontSize = renderer.getTickFont().getSize2D(); double tickLength = getTickLengthAbsolute(); double tickAlignment = renderer.getTickAlignment(); double tickLengthOuter = tickLength*(1.0 - tickAlignment); double labelDistance = renderer.getTickLabelDistanceAbsolute() + tickLengthOuter; double minSize = fontSize + labelDistance + tickLengthOuter; return new de.erichseifert.gral.graphics.Dimension2D.Double(minSize, minSize); } }; return component; } /** * Returns a list of all tick element on the axis. * @param axis Axis * @return A list of {@code Tick} instances */ public List getTicks(Axis axis) { List ticks = new LinkedList(); if (!axis.isValid()) { return ticks; } double min = axis.getMin().doubleValue(); double max = axis.getMax().doubleValue(); Set tickPositions = new HashSet(); createTicksCustom(ticks, axis, min, max, tickPositions); boolean isAutoSpacing = isTicksAutoSpaced(); // If the spacing is invalid, use auto spacing if (!isAutoSpacing) { Number tickSpacing = getTickSpacing(); if (tickSpacing == null) { isAutoSpacing = true; } else { double tickSpacingValue = tickSpacing.doubleValue(); if (tickSpacingValue <= 0.0 || !MathUtils.isCalculatable(tickSpacingValue)) { isAutoSpacing = true; } } } createTicks(ticks, axis, min, max, tickPositions, isAutoSpacing); return ticks; } /** * Returns the absolute length of a major tick. * @return Major tick length in pixels. */ protected double getTickLengthAbsolute() { double fontSize = getTickFont().getSize2D(); return getTickLength()*fontSize; } /** * Returns the absolute length of a minor tick. * @return Minor tick length in pixels. */ protected double getTickMinorLengthAbsolute() { double fontSize = getTickFont().getSize2D(); return getMinorTickLength()*fontSize; } /** * Returns the absolute distance between ticks and labels. * @return Distance in pixels. */ protected double getTickLabelDistanceAbsolute() { double fontSize = getTickFont().getSize2D(); return getTickLabelDistance()*fontSize; } /** * Adds minor and major ticks to a list of ticks. * @param ticks List of ticks * @param axis Axis * @param min Minimum value of axis * @param max Maximum value of axis * @param tickPositions Set of tick positions * @param isAutoSpacing Use automatic scaling */ protected abstract void createTicks(List ticks, Axis axis, double min, double max, Set tickPositions, boolean isAutoSpacing); /** * Adds custom ticks to a list of ticks. * @param ticks List of ticks * @param axis Axis * @param min Minimum value of axis * @param max Maximum value of axis * @param tickPositions Set of tick positions */ protected void createTicksCustom(List ticks, Axis axis, double min, double max, Set tickPositions) { Map labelsCustom = getCustomTicks(); if (labelsCustom != null) { for (Number tickPositionWorldObj : labelsCustom.keySet()) { double tickPositionWorld = tickPositionWorldObj.doubleValue(); if (tickPositionWorld < min || tickPositionWorld > max) { continue; } Tick tick = getTick( TickType.CUSTOM, axis, tickPositionWorld); ticks.add(tick); tickPositions.add(tickPositionWorld); } } } /** * Returns the point of the tick mark (in pixel coordinates) on the * specified axis with the specified value. * @param type Type of tick mark. * @param axis Axis containing the tick mark. * @param tickPositionWorld Displayed value on the axis. * @return Object describing the desired tick mark. */ protected Tick getTick(TickType type, Axis axis, double tickPositionWorld) { // Calculate position of tick on axis shape PointND tickPoint = getPosition(axis, tickPositionWorld, false, false); // Calculate tick normal PointND tickNormal = getNormal(axis, tickPositionWorld, false, false); // Retrieve tick label String tickLabel; Map labelsCustom = getCustomTicks(); if (labelsCustom != null && labelsCustom.containsKey(tickPositionWorld)) { tickLabel = labelsCustom.get(tickPositionWorld); } else { Format labelFormat = getTickLabelFormat(); if (labelFormat != null) { tickLabel = labelFormat.format(tickPositionWorld); } else { tickLabel = String.valueOf(tickPositionWorld); } } Tick tick = new Tick(type, tickPoint, tickNormal, null, null, tickLabel); return tick; } /** * Returns the normal vector at the position of the specified value. * The vector is normalized. * @param axis Axis * @param value World coordinate value to convert * @param extrapolate Option to activate extrapolation value that are not * on the axis * @param forceLinear Force linear interpolation. * @return N-dimensional normal vector at the position */ public PointND getNormal(Axis axis, Number value, boolean extrapolate, boolean forceLinear) { double valueView; if (forceLinear) { valueView = (value.doubleValue() - axis.getMin().doubleValue()) / axis.getRange()*getShapeLength(); } else { valueView = worldToView(axis, value, extrapolate); } int segmentIndex = MathUtils.binarySearchFloor(shapeSegmentLengthsAccumulated, valueView); if (segmentIndex < 0 || segmentIndex >= shapeLines.length) { return null; } segmentIndex = MathUtils.limit( segmentIndex, 0, shapeLineNormals.length - 1); boolean normalOrientationClockwise = AbstractAxisRenderer2D.this .isShapeNormalOrientationClockwise(); double normalOrientation = normalOrientationClockwise ? 1.0 : -1.0; PointND tickNormal = new PointND( normalOrientation * shapeLineNormals[segmentIndex].getX(), normalOrientation * shapeLineNormals[segmentIndex].getY() ); return tickNormal; } /** * Returns the length of the shape path which is used to render axes. * @return Shape length. */ protected double getShapeLength() { if (shapeSegmentLengthsAccumulated == null || shapeSegmentLengthsAccumulated.length == 0) { return 0.0; } return shapeSegmentLengthsAccumulated[shapeSegmentLengthsAccumulated.length - 1]; } /** * Returns the position of the specified value on the axis. * The value is returned in view coordinates. * @param axis Axis * @param value World coordinate value to convert * @param extrapolate Option to activate extrapolation value that are not * on the axis * @param forceLinear Force linear interpolation. * @return N-dimensional point of the value */ public PointND getPosition(Axis axis, Number value, boolean extrapolate, boolean forceLinear) { if (shapeLines == null || shapeLines.length == 0 || value == null) { return null; } // Determine relative position of the value double relativePositionOnShapePath = axis.getPosition(value).doubleValue(); if (!extrapolate) { relativePositionOnShapePath = MathUtils.limit(relativePositionOnShapePath, 0.0, 1.0); } // Determine absolute position of the value double positionOnShapePath; if (forceLinear) { positionOnShapePath = relativePositionOnShapePath*getShapeLength(); } else { positionOnShapePath = worldToView(axis, value, extrapolate); } if (Double.isNaN(positionOnShapePath)) { return null; } // TODO Check if this is a valid way to allow infinite values if (positionOnShapePath == Double.NEGATIVE_INFINITY) { positionOnShapePath = 0.0; } else if (positionOnShapePath == Double.POSITIVE_INFINITY) { positionOnShapePath = 1.0; } // Determine shape segment int segmentIndex; if (relativePositionOnShapePath <= 0.0) { segmentIndex = 0; } else if (relativePositionOnShapePath >= 1.0) { segmentIndex = shapeLines.length - 1; } else { // Determine to which segment the value belongs using a binary search segmentIndex = MathUtils.binarySearchFloor(shapeSegmentLengthsAccumulated, positionOnShapePath); } if (segmentIndex < 0 || segmentIndex >= shapeLines.length) { return null; } // Compute actual position of the value in view coordinates Line2D segment = shapeLines[segmentIndex]; double segmentLen = shapeSegmentLengths[segmentIndex]; double segmentLenAcc = shapeSegmentLengthsAccumulated[segmentIndex]; double relLen = (positionOnShapePath - segmentLenAcc)/segmentLen; double x = segment.getX1() + (segment.getX2() - segment.getX1())*relLen; double y = segment.getY1() + (segment.getY2() - segment.getY1())*relLen; return new PointND(x, y); } /** * Calculates important aspects of the specified shape. * @param shape Shape to be evaluated. */ protected final void evaluateShape(Shape shape) { boolean directionSwapped = isShapeDirectionSwapped(); shapeLines = GeometryUtils.shapeToLines(shape, directionSwapped); shapeSegmentLengths = new double[shapeLines.length]; // First length is always 0.0, last length is the total length shapeSegmentLengthsAccumulated = new double[shapeLines.length + 1]; shapeLineNormals = new Point2D[shapeLines.length]; if (shapeLines.length == 0) { return; } for (int i = 0; i < shapeLines.length; i++) { Line2D line = shapeLines[i]; // Calculate length of axis shape at each shape segment double segmentLength = line.getP1().distance(line.getP2()); shapeSegmentLengths[i] = segmentLength; shapeSegmentLengthsAccumulated[i + 1] = shapeSegmentLengthsAccumulated[i] + segmentLength; // Calculate a normalized vector perpendicular to the current // axis shape segment shapeLineNormals[i] = new Point2D.Double( (line.getY2() - line.getY1()) / segmentLength, -(line.getX2() - line.getX1()) / segmentLength ); } } /** * Custom deserialization method. * @param in Input stream. * @throws ClassNotFoundException if a serialized class doesn't exist anymore. * @throws IOException if there is an error while reading data from the * input stream. */ private void readObject(ObjectInputStream in) throws ClassNotFoundException, IOException { // Default deserialization in.defaultReadObject(); // Custom deserialization shapeStroke = (Stroke) SerializationUtils.unwrap((Serializable) in.readObject()); tickStroke = (Stroke) SerializationUtils.unwrap((Serializable) in.readObject()); minorTickStroke = (Stroke) SerializationUtils.unwrap((Serializable) in.readObject()); } private void writeObject(ObjectOutputStream out) throws IOException { // Default deserialization out.defaultWriteObject(); // Custom serialization out.writeObject(SerializationUtils.wrap(shapeStroke)); out.writeObject(SerializationUtils.wrap(tickStroke)); out.writeObject(SerializationUtils.wrap(minorTickStroke)); } @Override public Number getIntersection() { return intersection; } @Override public void setIntersection(Number intersection) { this.intersection = intersection; } @Override public Shape getShape() { return shape; } @Override public void setShape(Shape shape) { this.shape = shape; evaluateShape(shape); } @Override public boolean isShapeVisible() { return shapeVisible; } @Override public void setShapeVisible(boolean shapeVisible) { this.shapeVisible = shapeVisible; } @Override public boolean isShapeNormalOrientationClockwise() { return shapeNormalOrientationClockwise; } @Override public void setShapeNormalOrientationClockwise(boolean clockwise) { this.shapeNormalOrientationClockwise = clockwise; } @Override public Paint getShapeColor() { return shapeColor; } @Override public void setShapeColor(Paint color) { this.shapeColor = color; } @Override public Stroke getShapeStroke() { return shapeStroke; } @Override public void setShapeStroke(Stroke stroke) { this.shapeStroke = stroke; } @Override public boolean isShapeDirectionSwapped() { return shapeDirectionSwapped; } @Override public void setShapeDirectionSwapped(boolean directionSwapped) { this.shapeDirectionSwapped = directionSwapped; } @Override public boolean isTicksVisible() { return ticksVisible; } @Override public void setTicksVisible(boolean ticksVisible) { this.ticksVisible = ticksVisible; } @Override public Number getTickSpacing() { return tickSpacing; } @Override public void setTickSpacing(Number spacing) { this.tickSpacing = spacing; } @Override public boolean isTicksAutoSpaced() { return ticksAutoSpaced; } @Override public void setTicksAutoSpaced(boolean autoSpaced) { this.ticksAutoSpaced = autoSpaced; } @Override public double getTickLength() { return tickLength; } @Override public void setTickLength(double length) { this.tickLength = length; } @Override public Stroke getTickStroke() { return tickStroke; } @Override public void setTickStroke(Stroke stroke) { this.tickStroke = stroke; } @Override public double getTickAlignment() { return tickAlignment; } @Override public void setTickAlignment(double alignment) { this.tickAlignment = alignment; } @Override public Font getTickFont() { return tickFont; } @Override public void setTickFont(Font font) { this.tickFont = font; } @Override public Paint getTickColor() { return tickColor; } @Override public void setTickColor(Paint color) { this.tickColor = color; } @Override public boolean isTickLabelsVisible() { return tickLabelsVisible; } @Override public void setTickLabelsVisible(boolean tickLabelsVisible) { this.tickLabelsVisible = tickLabelsVisible; } @Override public Format getTickLabelFormat() { return tickLabelFormat; } @Override public void setTickLabelFormat(Format format) { this.tickLabelFormat = format; } @Override public double getTickLabelDistance() { return tickLabelDistance; } @Override public void setTickLabelDistance(double distance) { this.tickLabelDistance = distance; } @Override public boolean isTickLabelsOutside() { return tickLabelsOutside; } @Override public void setTickLabelsOutside(boolean labelsOutside) { this.tickLabelsOutside = labelsOutside; } @Override public double getTickLabelRotation() { return tickLabelRotation; } @Override public void setTickLabelRotation(double angle) { this.tickLabelRotation = angle; } @Override public boolean isMinorTicksVisible() { return minorTickVisible; } @Override public void setMinorTicksVisible(boolean minorTicksVisible) { this.minorTickVisible = minorTicksVisible; } @Override public int getMinorTicksCount() { return minorTicksCount; } @Override public void setMinorTicksCount(int count) { this.minorTicksCount = count; } @Override public double getMinorTickLength() { return minorTickLength; } @Override public void setMinorTickLength(double length) { this.minorTickLength = length; } @Override public Stroke getMinorTickStroke() { return minorTickStroke; } @Override public void setMinorTickStroke(Stroke stroke) { this.minorTickStroke = stroke; } @Override public double getMinorTickAlignment() { return minorTickAlignment; } @Override public void setMinorTickAlignment(double alignment) { this.minorTickAlignment = alignment; } @Override public Paint getMinorTickColor() { return minorTickColor; } @Override public void setMinorTickColor(Paint color) { this.minorTickColor = color; } @Override public Map getCustomTicks() { return Collections.unmodifiableMap(customTicks); } @Override public void setCustomTicks(Map positionsAndLabels) { customTicks.clear(); customTicks.putAll(positionsAndLabels); } @Override public Label getLabel() { return label; } @Override public void setLabel(Label label) { this.label = label; } @Override public double getLabelDistance() { return labelDistance; } @Override public void setLabelDistance(double distance) { this.labelDistance = distance; } }

Ads help maintain this website.