    001/* ===========================================================
    002 * JFreeChart : a free chart library for the Java(tm) platform
    003 * ===========================================================
    004 *
    005 * (C) Copyright 2000-2011, by Object Refinery Limited and Contributors.
    006 *
    007 * Project Info:  http://www.jfree.org/jfreechart/index.html
    008 *
    009 * This library is free software; you can redistribute it and/or modify it
    010 * under the terms of the GNU Lesser General Public License as published by
    011 * the Free Software Foundation; either version 2.1 of the License, or
    012 * (at your option) any later version.
    013 *
    014 * This library is distributed in the hope that it will be useful, but
    015 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
    016 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
    017 * License for more details.
    018 *
    019 * You should have received a copy of the GNU Lesser General Public
    020 * License along with this library; if not, write to the Free Software
    021 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
    022 * USA.
    023 *
    024 * [Oracle and Java are registered trademarks of Oracle and/or its affiliates.
    025 * Other names may be trademarks of their respective owners.]
    026 *
    027 * ---------------
    028 * NumberAxis.java
    029 * ---------------
    030 * (C) Copyright 2000-2011, by Object Refinery Limited and Contributors.
    031 *
    032 * Original Author:  David Gilbert (for Object Refinery Limited);
    033 * Contributor(s):   Laurence Vanhelsuwe;
    034 *                   Peter Kolb (patches 1934255 and 2603321);
    035 *
    036 * Changes
    037 * -------
    038 * 18-Sep-2001 : Added standard header and fixed DOS encoding problem (DG);
    039 * 22-Sep-2001 : Changed setMinimumAxisValue() and setMaximumAxisValue() so
    040 *               that they clear the autoRange flag (DG);
    041 * 27-Nov-2001 : Removed old, redundant code (DG);
    042 * 30-Nov-2001 : Added accessor methods for the standard tick units (DG);
    043 * 08-Jan-2002 : Added setAxisRange() method (since renamed setRange()) (DG);
    044 * 16-Jan-2002 : Added setTickUnit() method.  Extended ValueAxis to support an
    045 *               optional cross-hair (DG);
    046 * 08-Feb-2002 : Fixes bug to ensure the autorange is recalculated if the
    047 *               setAutoRangeIncludesZero flag is changed (DG);
    048 * 25-Feb-2002 : Added a new flag autoRangeStickyZero to provide further
    049 *               control over margins in the auto-range mechanism.  Updated
    050 *               constructors.  Updated import statements.  Moved the
    051 *               createStandardTickUnits() method to the TickUnits class (DG);
    052 * 19-Apr-2002 : Updated Javadoc comments (DG);
    053 * 01-May-2002 : Updated for changes to TickUnit class, removed valueToString()
    054 *               method (DG);
    055 * 25-Jul-2002 : Moved the lower and upper margin attributes, and the
    056 *               auto-range minimum size, up one level to the ValueAxis
    057 *               class (DG);
    058 * 05-Sep-2002 : Updated constructor to match changes in Axis class (DG);
    059 * 01-Oct-2002 : Fixed errors reported by Checkstyle (DG);
    060 * 04-Oct-2002 : Moved standardTickUnits from NumberAxis --> ValueAxis (DG);
    061 * 24-Oct-2002 : Added a number format override (DG);
    062 * 08-Nov-2002 : Moved to new package com.jrefinery.chart.axis (DG);
    063 * 19-Nov-2002 : Removed grid settings (now controlled by the plot) (DG);
    064 * 14-Jan-2003 : Changed autoRangeMinimumSize from Number --> double, and moved
    065 *               crosshair settings to the plot classes (DG);
    066 * 20-Jan-2003 : Removed the monolithic constructor (DG);
    067 * 26-Mar-2003 : Implemented Serializable (DG);
    068 * 16-Jul-2003 : Reworked to allow for multiple secondary axes (DG);
    069 * 13-Aug-2003 : Implemented Cloneable (DG);
    070 * 07-Oct-2003 : Fixed bug (815028) in the auto range calculation (DG);
    071 * 29-Oct-2003 : Added workaround for font alignment in PDF output (DG);
    072 * 07-Nov-2003 : Modified to use NumberTick class (DG);
    073 * 21-Jan-2004 : Renamed translateJava2DToValue --> java2DToValue, and
    074 *               translateValueToJava2D --> valueToJava2D (DG);
    075 * 03-Mar-2004 : Added plotState to draw() method (DG);
    076 * 07-Apr-2004 : Changed string width calculation (DG);
    077 * 11-Jan-2005 : Removed deprecated methods in preparation for 1.0.0
    078 *               release (DG);
    079 * 28-Mar-2005 : Renamed autoRangeIncludesZero() --> getAutoRangeIncludesZero()
    080 *               and autoRangeStickyZero() --> getAutoRangeStickyZero() (DG);
    081 * 21-Apr-2005 : Removed redundant argument from selectAutoTickUnit() (DG);
    082 * 22-Apr-2005 : Renamed refreshHorizontalTicks --> refreshTicksHorizontal
    083 *               (and likewise the vertical version) for consistency with
    084 *               other axis classes (DG);
    085 * ------------- JFREECHART 1.0.x ---------------------------------------------
    086 * 10-Feb-2006 : Added some API doc comments in respect of bug 821046 (DG);
    087 * 20-Feb-2006 : Modified equals() method to check rangeType field (fixes bug
    088 *               1435461) (DG);
    089 * 04-Sep-2006 : Fix auto range calculation for the case where all data values
    090 *               are constant and large (see bug report 1549218) (DG);
    091 * 11-Dec-2006 : Fix bug in auto-tick unit selection with tick format override,
    092 *               see bug 1608371 (DG);
    093 * 22-Mar-2007 : Use new defaultAutoRange attribute (DG);
    094 * 25-Sep-2008 : Added minor tick support, see patch 1934255 by Peter Kolb (DG);
    095 * 21-Jan-2009 : Default minor tick counts will now come from the tick unit
    096 *               collection (DG);
    097 * 19-Mar-2009 : Added entity support - see patch 2603321 by Peter Kolb (DG);
    098 *
    099 */
    100
    101package org.jfree.chart.axis;
    102
    103import java.awt.Font;
    104import java.awt.FontMetrics;
    105import java.awt.Graphics2D;
    106import java.awt.font.FontRenderContext;
    107import java.awt.font.LineMetrics;
    108import java.awt.geom.Rectangle2D;
    109import java.io.Serializable;
    110import java.text.DecimalFormat;
    111import java.text.NumberFormat;
    112import java.util.List;
    113import java.util.Locale;
    114
    115import org.jfree.chart.event.AxisChangeEvent;
    116import org.jfree.chart.plot.Plot;
    117import org.jfree.chart.plot.PlotRenderingInfo;
    118import org.jfree.chart.plot.ValueAxisPlot;
    119import org.jfree.data.Range;
    120import org.jfree.data.RangeType;
    121import org.jfree.ui.RectangleEdge;
    122import org.jfree.ui.RectangleInsets;
    123import org.jfree.ui.TextAnchor;
    124import org.jfree.util.ObjectUtilities;
    125
    126/**
    127 * An axis for displaying numerical data.
    128 * <P>
    129 * If the axis is set up to automatically determine its range to fit the data,
    130 * you can ensure that the range includes zero (statisticians usually prefer
    131 * this) by setting the <code>autoRangeIncludesZero</code> flag to
    132 * <code>true</code>.
    133 * <P>
    134 * The <code>NumberAxis</code> class has a mechanism for automatically
    135 * selecting a tick unit that is appropriate for the current axis range.  This
    136 * mechanism is an adaptation of code suggested by Laurence Vanhelsuwe.
    137 */
    138public class NumberAxis extends ValueAxis implements Cloneable, Serializable {
    139
    140    /** For serialization. */
    141    private static final long serialVersionUID = 2805933088476185789L;
    142
    143    /** The default value for the autoRangeIncludesZero flag. */
    144    public static final boolean DEFAULT_AUTO_RANGE_INCLUDES_ZERO = true;
    145
    146    /** The default value for the autoRangeStickyZero flag. */
    147    public static final boolean DEFAULT_AUTO_RANGE_STICKY_ZERO = true;
    148
    149    /** The default tick unit. */
    150    public static final NumberTickUnit DEFAULT_TICK_UNIT = new NumberTickUnit(
    151            1.0, new DecimalFormat("0"));
    152
    153    /** The default setting for the vertical tick labels flag. */
    154    public static final boolean DEFAULT_VERTICAL_TICK_LABELS = false;
    155
    156    /**
    157     * The range type (can be used to force the axis to display only positive
    158     * values or only negative values).
    159     */
    160    private RangeType rangeType;
    161
    162    /**
    163     * A flag that affects the axis range when the range is determined
    164     * automatically.  If the auto range does NOT include zero and this flag
    165     * is TRUE, then the range is changed to include zero.
    166     */
    167    private boolean autoRangeIncludesZero;
    168
    169    /**
    170     * A flag that affects the size of the margins added to the axis range when
    171     * the range is determined automatically.  If the value 0 falls within the
    172     * margin and this flag is TRUE, then the margin is truncated at zero.
    173     */
    174    private boolean autoRangeStickyZero;
    175
    176    /** The tick unit for the axis. */
    177    private NumberTickUnit tickUnit;
    178
    179    /** The override number format. */
    180    private NumberFormat numberFormatOverride;
    181
    182    /** An optional band for marking regions on the axis. */
    183    private MarkerAxisBand markerBand;
    184
    185    /**
    186     * Default constructor.
    187     */
    188    public NumberAxis() {
    189        this(null);
    190    }
    191
    192    /**
    193     * Constructs a number axis, using default values where necessary.
    194     *
    195     * @param label  the axis label (<code>null</code> permitted).
    196     */
    197    public NumberAxis(String label) {
    198        super(label, NumberAxis.createStandardTickUnits());
    199        this.rangeType = RangeType.FULL;
    200        this.autoRangeIncludesZero = DEFAULT_AUTO_RANGE_INCLUDES_ZERO;
    201        this.autoRangeStickyZero = DEFAULT_AUTO_RANGE_STICKY_ZERO;
    202        this.tickUnit = DEFAULT_TICK_UNIT;
    203        this.numberFormatOverride = null;
    204        this.markerBand = null;
    205    }
    206
    207    /**
    208     * Returns the axis range type.
    209     *
    210     * @return The axis range type (never <code>null</code>).
    211     *
    212     * @see #setRangeType(RangeType)
    213     */
    214    public RangeType getRangeType() {
    215        return this.rangeType;
    216    }
    217
    218    /**
    219     * Sets the axis range type.
    220     *
    221     * @param rangeType  the range type (<code>null</code> not permitted).
    222     *
    223     * @see #getRangeType()
    224     */
    225    public void setRangeType(RangeType rangeType) {
    226        if (rangeType == null) {
    227            throw new IllegalArgumentException("Null 'rangeType' argument.");
    228        }
    229        this.rangeType = rangeType;
    230        notifyListeners(new AxisChangeEvent(this));
    231    }
    232
    233    /**
    234     * Returns the flag that indicates whether or not the automatic axis range
    235     * (if indeed it is determined automatically) is forced to include zero.
    236     *
    237     * @return The flag.
    238     */
    239    public boolean getAutoRangeIncludesZero() {
    240        return this.autoRangeIncludesZero;
    241    }
    242
    243    /**
    244     * Sets the flag that indicates whether or not the axis range, if
    245     * automatically calculated, is forced to include zero.
    246     * <p>
    247     * If the flag is changed to <code>true</code>, the axis range is
    248     * recalculated.
    249     * <p>
    250     * Any change to the flag will trigger an {@link AxisChangeEvent}.
    251     *
    252     * @param flag  the new value of the flag.
    253     *
    254     * @see #getAutoRangeIncludesZero()
    255     */
    256    public void setAutoRangeIncludesZero(boolean flag) {
    257        if (this.autoRangeIncludesZero != flag) {
    258            this.autoRangeIncludesZero = flag;
    259            if (isAutoRange()) {
    260                autoAdjustRange();
    261            }
    262            notifyListeners(new AxisChangeEvent(this));
    263        }
    264    }
    265
    266    /**
    267     * Returns a flag that affects the auto-range when zero falls outside the
    268     * data range but inside the margins defined for the axis.
    269     *
    270     * @return The flag.
    271     *
    272     * @see #setAutoRangeStickyZero(boolean)
    273     */
    274    public boolean getAutoRangeStickyZero() {
    275        return this.autoRangeStickyZero;
    276    }
    277
    278    /**
    279     * Sets a flag that affects the auto-range when zero falls outside the data
    280     * range but inside the margins defined for the axis.
    281     *
    282     * @param flag  the new flag.
    283     *
    284     * @see #getAutoRangeStickyZero()
    285     */
    286    public void setAutoRangeStickyZero(boolean flag) {
    287        if (this.autoRangeStickyZero != flag) {
    288            this.autoRangeStickyZero = flag;
    289            if (isAutoRange()) {
    290                autoAdjustRange();
    291            }
    292            notifyListeners(new AxisChangeEvent(this));
    293        }
    294    }
    295
    296    /**
    297     * Returns the tick unit for the axis.
    298     * <p>
    299     * Note: if the <code>autoTickUnitSelection</code> flag is
    300     * <code>true</code> the tick unit may be changed while the axis is being
    301     * drawn, so in that case the return value from this method may be
    302     * irrelevant if the method is called before the axis has been drawn.
    303     *
    304     * @return The tick unit for the axis.
    305     *
    306     * @see #setTickUnit(NumberTickUnit)
    307     * @see ValueAxis#isAutoTickUnitSelection()
    308     */
    309    public NumberTickUnit getTickUnit() {
    310        return this.tickUnit;
    311    }
    312
    313    /**
    314     * Sets the tick unit for the axis and sends an {@link AxisChangeEvent} to
    315     * all registered listeners.  A side effect of calling this method is that
    316     * the "auto-select" feature for tick units is switched off (you can
    317     * restore it using the {@link ValueAxis#setAutoTickUnitSelection(boolean)}
    318     * method).
    319     *
    320     * @param unit  the new tick unit (<code>null</code> not permitted).
    321     *
    322     * @see #getTickUnit()
    323     * @see #setTickUnit(NumberTickUnit, boolean, boolean)
    324     */
    325    public void setTickUnit(NumberTickUnit unit) {
    326        // defer argument checking...
    327        setTickUnit(unit, true, true);
    328    }
    329
    330    /**
    331     * Sets the tick unit for the axis and, if requested, sends an
    332     * {@link AxisChangeEvent} to all registered listeners.  In addition, an
    333     * option is provided to turn off the "auto-select" feature for tick units
    334     * (you can restore it using the
    335     * {@link ValueAxis#setAutoTickUnitSelection(boolean)} method).
    336     *
    337     * @param unit  the new tick unit (<code>null</code> not permitted).
    338     * @param notify  notify listeners?
    339     * @param turnOffAutoSelect  turn off the auto-tick selection?
    340     */
    341    public void setTickUnit(NumberTickUnit unit, boolean notify,
    342                            boolean turnOffAutoSelect) {
    343
    344        if (unit == null) {
    345            throw new IllegalArgumentException("Null 'unit' argument.");
    346        }
    347        this.tickUnit = unit;
    348        if (turnOffAutoSelect) {
    349            setAutoTickUnitSelection(false, false);
    350        }
    351        if (notify) {
    352            notifyListeners(new AxisChangeEvent(this));
    353        }
    354
    355    }
    356
    357    /**
    358     * Returns the number format override.  If this is non-null, then it will
    359     * be used to format the numbers on the axis.
    360     *
    361     * @return The number formatter (possibly <code>null</code>).
    362     *
    363     * @see #setNumberFormatOverride(NumberFormat)
    364     */
    365    public NumberFormat getNumberFormatOverride() {
    366        return this.numberFormatOverride;
    367    }
    368
    369    /**
    370     * Sets the number format override.  If this is non-null, then it will be
    371     * used to format the numbers on the axis.
    372     *
    373     * @param formatter  the number formatter (<code>null</code> permitted).
    374     *
    375     * @see #getNumberFormatOverride()
    376     */
    377    public void setNumberFormatOverride(NumberFormat formatter) {
    378        this.numberFormatOverride = formatter;
    379        notifyListeners(new AxisChangeEvent(this));
    380    }
    381
    382    /**
    383     * Returns the (optional) marker band for the axis.
    384     *
    385     * @return The marker band (possibly <code>null</code>).
    386     *
    387     * @see #setMarkerBand(MarkerAxisBand)
    388     */
    389    public MarkerAxisBand getMarkerBand() {
    390        return this.markerBand;
    391    }
    392
    393    /**
    394     * Sets the marker band for the axis.
    395     * <P>
    396     * The marker band is optional, leave it set to <code>null</code> if you
    397     * don't require it.
    398     *
    399     * @param band the new band (<code>null</code> permitted).
    400     *
    401     * @see #getMarkerBand()
    402     */
    403    public void setMarkerBand(MarkerAxisBand band) {
    404        this.markerBand = band;
    405        notifyListeners(new AxisChangeEvent(this));
    406    }
    407
    408    /**
    409     * Configures the axis to work with the specified plot.  If the axis has
    410     * auto-scaling, then sets the maximum and minimum values.
    411     */
    412    public void configure() {
    413        if (isAutoRange()) {
    414            autoAdjustRange();
    415        }
    416    }
    417
    418    /**
    419     * Rescales the axis to ensure that all data is visible.
    420     */
    421    protected void autoAdjustRange() {
    422
    423        Plot plot = getPlot();
    424        if (plot == null) {
    425            return;  // no plot, no data
    426        }
    427
    428        if (plot instanceof ValueAxisPlot) {
    429            ValueAxisPlot vap = (ValueAxisPlot) plot;
    430
    431            Range r = vap.getDataRange(this);
    432            if (r == null) {
    433                r = getDefaultAutoRange();
    434            }
    435
    436            double upper = r.getUpperBound();
    437            double lower = r.getLowerBound();
    438            if (this.rangeType == RangeType.POSITIVE) {
    439                lower = Math.max(0.0, lower);
    440                upper = Math.max(0.0, upper);
    441            }
    442            else if (this.rangeType == RangeType.NEGATIVE) {
    443                lower = Math.min(0.0, lower);
    444                upper = Math.min(0.0, upper);
    445            }
    446
    447            if (getAutoRangeIncludesZero()) {
    448                lower = Math.min(lower, 0.0);
    449                upper = Math.max(upper, 0.0);
    450            }
    451            double range = upper - lower;
    452
    453            // if fixed auto range, then derive lower bound...
    454            double fixedAutoRange = getFixedAutoRange();
    455            if (fixedAutoRange > 0.0) {
    456                lower = upper - fixedAutoRange;
    457            }
    458            else {
    459                // ensure the autorange is at least <minRange> in size...
    460                double minRange = getAutoRangeMinimumSize();
    461                if (range < minRange) {
    462                    double expand = (minRange - range) / 2;
    463                    upper = upper + expand;
    464                    lower = lower - expand;
    465                    if (lower == upper) { // see bug report 1549218
    466                        double adjust = Math.abs(lower) / 10.0;
    467                        lower = lower - adjust;
    468                        upper = upper + adjust;
    469                    }
    470                    if (this.rangeType == RangeType.POSITIVE) {
    471                        if (lower < 0.0) {
    472                            upper = upper - lower;
    473                            lower = 0.0;
    474                        }
    475                    }
    476                    else if (this.rangeType == RangeType.NEGATIVE) {
    477                        if (upper > 0.0) {
    478                            lower = lower - upper;
    479                            upper = 0.0;
    480                        }
    481                    }
    482                }
    483
    484                if (getAutoRangeStickyZero()) {
    485                    if (upper <= 0.0) {
    486                        upper = Math.min(0.0, upper + getUpperMargin() * range);
    487                    }
    488                    else {
    489                        upper = upper + getUpperMargin() * range;
    490                    }
    491                    if (lower >= 0.0) {
    492                        lower = Math.max(0.0, lower - getLowerMargin() * range);
    493                    }
    494                    else {
    495                        lower = lower - getLowerMargin() * range;
    496                    }
    497                }
    498                else {
    499                    upper = upper + getUpperMargin() * range;
    500                    lower = lower - getLowerMargin() * range;
    501                }
    502            }
    503
    504            setRange(new Range(lower, upper), false, false);
    505        }
    506
    507    }
    508
    509    /**
    510     * Converts a data value to a coordinate in Java2D space, assuming that the
    511     * axis runs along one edge of the specified dataArea.
    512     * <p>
    513     * Note that it is possible for the coordinate to fall outside the plotArea.
    514     *
    515     * @param value  the data value.
    516     * @param area  the area for plotting the data.
    517     * @param edge  the axis location.
    518     *
    519     * @return The Java2D coordinate.
    520     *
    521     * @see #java2DToValue(double, Rectangle2D, RectangleEdge)
    522     */
    523    public double valueToJava2D(double value, Rectangle2D area,
    524                                RectangleEdge edge) {
    525
    526        Range range = getRange();
    527        double axisMin = range.getLowerBound();
    528        double axisMax = range.getUpperBound();
    529
    530        double min = 0.0;
    531        double max = 0.0;
    532        if (RectangleEdge.isTopOrBottom(edge)) {
    533            min = area.getX();
    534            max = area.getMaxX();
    535        }
    536        else if (RectangleEdge.isLeftOrRight(edge)) {
    537            max = area.getMinY();
    538            min = area.getMaxY();
    539        }
    540        if (isInverted()) {
    541            return max
    542                   - ((value - axisMin) / (axisMax - axisMin)) * (max - min);
    543        }
    544        else {
    545            return min
    546                   + ((value - axisMin) / (axisMax - axisMin)) * (max - min);
    547        }
    548
    549    }
    550
    551    /**
    552     * Converts a coordinate in Java2D space to the corresponding data value,
    553     * assuming that the axis runs along one edge of the specified dataArea.
    554     *
    555     * @param java2DValue  the coordinate in Java2D space.
    556     * @param area  the area in which the data is plotted.
    557     * @param edge  the location.
    558     *
    559     * @return The data value.
    560     *
    561     * @see #valueToJava2D(double, Rectangle2D, RectangleEdge)
    562     */
    563    public double java2DToValue(double java2DValue, Rectangle2D area,
    564                                RectangleEdge edge) {
    565
    566        Range range = getRange();
    567        double axisMin = range.getLowerBound();
    568        double axisMax = range.getUpperBound();
    569
    570        double min = 0.0;
    571        double max = 0.0;
    572        if (RectangleEdge.isTopOrBottom(edge)) {
    573            min = area.getX();
    574            max = area.getMaxX();
    575        }
    576        else if (RectangleEdge.isLeftOrRight(edge)) {
    577            min = area.getMaxY();
    578            max = area.getY();
    579        }
    580        if (isInverted()) {
    581            return axisMax
    582                   - (java2DValue - min) / (max - min) * (axisMax - axisMin);
    583        }
    584        else {
    585            return axisMin
    586                   + (java2DValue - min) / (max - min) * (axisMax - axisMin);
    587        }
    588
    589    }
    590
    591    /**
    592     * Calculates the value of the lowest visible tick on the axis.
    593     *
    594     * @return The value of the lowest visible tick on the axis.
    595     *
    596     * @see #calculateHighestVisibleTickValue()
    597     */
    598    protected double calculateLowestVisibleTickValue() {
    599
    600        double unit = getTickUnit().getSize();
    601        double index = Math.ceil(getRange().getLowerBound() / unit);
    602        return index * unit;
    603
    604    }
    605
    606    /**
    607     * Calculates the value of the highest visible tick on the axis.
    608     *
    609     * @return The value of the highest visible tick on the axis.
    610     *
    611     * @see #calculateLowestVisibleTickValue()
    612     */
    613    protected double calculateHighestVisibleTickValue() {
    614
    615        double unit = getTickUnit().getSize();
    616        double index = Math.floor(getRange().getUpperBound() / unit);
    617        return index * unit;
    618
    619    }
    620
    621    /**
    622     * Calculates the number of visible ticks.
    623     *
    624     * @return The number of visible ticks on the axis.
    625     */
    626    protected int calculateVisibleTickCount() {
    627
    628        double unit = getTickUnit().getSize();
    629        Range range = getRange();
    630        return (int) (Math.floor(range.getUpperBound() / unit)
    631                      - Math.ceil(range.getLowerBound() / unit) + 1);
    632
    633    }
    634
    635    /**
    636     * Draws the axis on a Java 2D graphics device (such as the screen or a
    637     * printer).
    638     *
    639     * @param g2  the graphics device (<code>null</code> not permitted).
    640     * @param cursor  the cursor location.
    641     * @param plotArea  the area within which the axes and data should be drawn
    642     *                  (<code>null</code> not permitted).
    643     * @param dataArea  the area within which the data should be drawn
    644     *                  (<code>null</code> not permitted).
    645     * @param edge  the location of the axis (<code>null</code> not permitted).
    646     * @param plotState  collects information about the plot
    647     *                   (<code>null</code> permitted).
    648     *
    649     * @return The axis state (never <code>null</code>).
    650     */
    651    public AxisState draw(Graphics2D g2, double cursor, Rectangle2D plotArea,
    652            Rectangle2D dataArea, RectangleEdge edge,
    653            PlotRenderingInfo plotState) {
    654
    655        AxisState state = null;
    656        // if the axis is not visible, don't draw it...
    657        if (!isVisible()) {
    658            state = new AxisState(cursor);
    659            // even though the axis is not visible, we need ticks for the
    660            // gridlines...
    661            List ticks = refreshTicks(g2, state, dataArea, edge);
    662            state.setTicks(ticks);
    663            return state;
    664        }
    665
    666        // draw the tick marks and labels...
    667        state = drawTickMarksAndLabels(g2, cursor, plotArea, dataArea, edge);
    668
    669//        // draw the marker band (if there is one)...
    670//        if (getMarkerBand() != null) {
    671//            if (edge == RectangleEdge.BOTTOM) {
    672//                cursor = cursor - getMarkerBand().getHeight(g2);
    673//            }
    674//            getMarkerBand().draw(g2, plotArea, dataArea, 0, cursor);
    675//        }
    676
    677        // draw the axis label...
    678        state = drawLabel(getLabel(), g2, plotArea, dataArea, edge, state);
    679        createAndAddEntity(cursor, state, dataArea, edge, plotState);
    680        return state;
    681
    682    }
    683
    684    /**
    685     * Creates the standard tick units.
    686     * <P>
    687     * If you don't like these defaults, create your own instance of TickUnits
    688     * and then pass it to the setStandardTickUnits() method in the
    689     * NumberAxis class.
    690     *
    691     * @return The standard tick units.
    692     *
    693     * @see #setStandardTickUnits(TickUnitSource)
    694     * @see #createIntegerTickUnits()
    695     */
    696    public static TickUnitSource createStandardTickUnits() {
    697
    698        TickUnits units = new TickUnits();
    699        DecimalFormat df000 = new DecimalFormat("0.0000000000");
    700        DecimalFormat df00 = new DecimalFormat("0.000000000");
    701        DecimalFormat df0 = new DecimalFormat("0.00000000");
    702        DecimalFormat df1 = new DecimalFormat("0.0000000");
    703        DecimalFormat df2 = new DecimalFormat("0.000000");
    704        DecimalFormat df3 = new DecimalFormat("0.00000");
    705        DecimalFormat df4 = new DecimalFormat("0.0000");
    706        DecimalFormat df5 = new DecimalFormat("0.000");
    707        DecimalFormat df6 = new DecimalFormat("0.00");
    708        DecimalFormat df7 = new DecimalFormat("0.0");
    709        DecimalFormat df8 = new DecimalFormat("#,##0");
    710        DecimalFormat df9 = new DecimalFormat("#,###,##0");
    711        DecimalFormat df10 = new DecimalFormat("#,###,###,##0");
    712
    713        // we can add the units in any order, the TickUnits collection will
    714        // sort them...
    715        units.add(new NumberTickUnit(0.000000001, df00, 2));
    716        units.add(new NumberTickUnit(0.00000001, df0, 2));
    717        units.add(new NumberTickUnit(0.0000001, df1, 2));
    718        units.add(new NumberTickUnit(0.000001, df2, 2));
    719        units.add(new NumberTickUnit(0.00001, df3, 2));
    720        units.add(new NumberTickUnit(0.0001, df4, 2));
    721        units.add(new NumberTickUnit(0.001, df5, 2));
    722        units.add(new NumberTickUnit(0.01, df6, 2));
    723        units.add(new NumberTickUnit(0.1, df7, 2));
    724        units.add(new NumberTickUnit(1, df8, 2));
    725        units.add(new NumberTickUnit(10, df8, 2));
    726        units.add(new NumberTickUnit(100, df8, 2));
    727        units.add(new NumberTickUnit(1000, df8, 2));
    728        units.add(new NumberTickUnit(10000, df8, 2));
    729        units.add(new NumberTickUnit(100000, df8, 2));
    730        units.add(new NumberTickUnit(1000000, df9, 2));
    731        units.add(new NumberTickUnit(10000000, df9, 2));
    732        units.add(new NumberTickUnit(100000000, df9, 2));
    733        units.add(new NumberTickUnit(1000000000, df10, 2));
    734        units.add(new NumberTickUnit(10000000000.0, df10, 2));
    735        units.add(new NumberTickUnit(100000000000.0, df10, 2));
    736
    737        units.add(new NumberTickUnit(0.0000000025, df000, 5));
    738        units.add(new NumberTickUnit(0.000000025, df00, 5));
    739        units.add(new NumberTickUnit(0.00000025, df0, 5));
    740        units.add(new NumberTickUnit(0.0000025, df1, 5));
    741        units.add(new NumberTickUnit(0.000025, df2, 5));
    742        units.add(new NumberTickUnit(0.00025, df3, 5));
    743        units.add(new NumberTickUnit(0.0025, df4, 5));
    744        units.add(new NumberTickUnit(0.025, df5, 5));
    745        units.add(new NumberTickUnit(0.25, df6, 5));
    746        units.add(new NumberTickUnit(2.5, df7, 5));
    747        units.add(new NumberTickUnit(25, df8, 5));
    748        units.add(new NumberTickUnit(250, df8, 5));
    749        units.add(new NumberTickUnit(2500, df8, 5));
    750        units.add(new NumberTickUnit(25000, df8, 5));
    751        units.add(new NumberTickUnit(250000, df8, 5));
    752        units.add(new NumberTickUnit(2500000, df9, 5));
    753        units.add(new NumberTickUnit(25000000, df9, 5));
    754        units.add(new NumberTickUnit(250000000, df9, 5));
    755        units.add(new NumberTickUnit(2500000000.0, df10, 5));
    756        units.add(new NumberTickUnit(25000000000.0, df10, 5));
    757        units.add(new NumberTickUnit(250000000000.0, df10, 5));
    758
    759        units.add(new NumberTickUnit(0.000000005, df00, 5));
    760        units.add(new NumberTickUnit(0.00000005, df0, 5));
    761        units.add(new NumberTickUnit(0.0000005, df1, 5));
    762        units.add(new NumberTickUnit(0.000005, df2, 5));
    763        units.add(new NumberTickUnit(0.00005, df3, 5));
    764        units.add(new NumberTickUnit(0.0005, df4, 5));
    765        units.add(new NumberTickUnit(0.005, df5, 5));
    766        units.add(new NumberTickUnit(0.05, df6, 5));
    767        units.add(new NumberTickUnit(0.5, df7, 5));
    768        units.add(new NumberTickUnit(5L, df8, 5));
    769        units.add(new NumberTickUnit(50L, df8, 5));
    770        units.add(new NumberTickUnit(500L, df8, 5));
    771        units.add(new NumberTickUnit(5000L, df8, 5));
    772        units.add(new NumberTickUnit(50000L, df8, 5));
    773        units.add(new NumberTickUnit(500000L, df8, 5));
    774        units.add(new NumberTickUnit(5000000L, df9, 5));
    775        units.add(new NumberTickUnit(50000000L, df9, 5));
    776        units.add(new NumberTickUnit(500000000L, df9, 5));
    777        units.add(new NumberTickUnit(5000000000L, df10, 5));
    778        units.add(new NumberTickUnit(50000000000L, df10, 5));
    779        units.add(new NumberTickUnit(500000000000L, df10, 5));
    780
    781        return units;
    782
    783    }
    784
    785    /**
    786     * Returns a collection of tick units for integer values.
    787     *
    788     * @return A collection of tick units for integer values.
    789     *
    790     * @see #setStandardTickUnits(TickUnitSource)
    791     * @see #createStandardTickUnits()
    792     */
    793    public static TickUnitSource createIntegerTickUnits() {
    794        TickUnits units = new TickUnits();
    795        DecimalFormat df0 = new DecimalFormat("0");
    796        DecimalFormat df1 = new DecimalFormat("#,##0");
    797        units.add(new NumberTickUnit(1, df0, 2));
    798        units.add(new NumberTickUnit(2, df0, 2));
    799        units.add(new NumberTickUnit(5, df0, 5));
    800        units.add(new NumberTickUnit(10, df0, 2));
    801        units.add(new NumberTickUnit(20, df0, 2));
    802        units.add(new NumberTickUnit(50, df0, 5));
    803        units.add(new NumberTickUnit(100, df0, 2));
    804        units.add(new NumberTickUnit(200, df0, 2));
    805        units.add(new NumberTickUnit(500, df0, 5));
    806        units.add(new NumberTickUnit(1000, df1, 2));
    807        units.add(new NumberTickUnit(2000, df1, 2));
    808        units.add(new NumberTickUnit(5000, df1, 5));
    809        units.add(new NumberTickUnit(10000, df1, 2));
    810        units.add(new NumberTickUnit(20000, df1, 2));
    811        units.add(new NumberTickUnit(50000, df1, 5));
    812        units.add(new NumberTickUnit(100000, df1, 2));
    813        units.add(new NumberTickUnit(200000, df1, 2));
    814        units.add(new NumberTickUnit(500000, df1, 5));
    815        units.add(new NumberTickUnit(1000000, df1, 2));
    816        units.add(new NumberTickUnit(2000000, df1, 2));
    817        units.add(new NumberTickUnit(5000000, df1, 5));
    818        units.add(new NumberTickUnit(10000000, df1, 2));
    819        units.add(new NumberTickUnit(20000000, df1, 2));
    820        units.add(new NumberTickUnit(50000000, df1, 5));
    821        units.add(new NumberTickUnit(100000000, df1, 2));
    822        units.add(new NumberTickUnit(200000000, df1, 2));
    823        units.add(new NumberTickUnit(500000000, df1, 5));
    824        units.add(new NumberTickUnit(1000000000, df1, 2));
    825        units.add(new NumberTickUnit(2000000000, df1, 2));
    826        units.add(new NumberTickUnit(5000000000.0, df1, 5));
    827        units.add(new NumberTickUnit(10000000000.0, df1, 2));
    828        return units;
    829    }
    830
    831    /**
    832     * Creates a collection of standard tick units.  The supplied locale is
    833     * used to create the number formatter (a localised instance of
    834     * <code>NumberFormat</code>).
    835     * <P>
    836     * If you don't like these defaults, create your own instance of
    837     * {@link TickUnits} and then pass it to the
    838     * <code>setStandardTickUnits()</code> method.
    839     *
    840     * @param locale  the locale.
    841     *
    842     * @return A tick unit collection.
    843     *
    844     * @see #setStandardTickUnits(TickUnitSource)
    845     */
    846    public static TickUnitSource createStandardTickUnits(Locale locale) {
    847
    848        TickUnits units = new TickUnits();
    849        NumberFormat numberFormat = NumberFormat.getNumberInstance(locale);
    850        // we can add the units in any order, the TickUnits collection will
    851        // sort them...
    852        units.add(new NumberTickUnit(0.0000001, numberFormat, 2));
    853        units.add(new NumberTickUnit(0.000001, numberFormat, 2));
    854        units.add(new NumberTickUnit(0.00001, numberFormat, 2));
    855        units.add(new NumberTickUnit(0.0001, numberFormat, 2));
    856        units.add(new NumberTickUnit(0.001, numberFormat, 2));
    857        units.add(new NumberTickUnit(0.01, numberFormat, 2));
    858        units.add(new NumberTickUnit(0.1, numberFormat, 2));
    859        units.add(new NumberTickUnit(1, numberFormat, 2));
    860        units.add(new NumberTickUnit(10, numberFormat, 2));
    861        units.add(new NumberTickUnit(100, numberFormat, 2));
    862        units.add(new NumberTickUnit(1000, numberFormat, 2));
    863        units.add(new NumberTickUnit(10000, numberFormat, 2));
    864        units.add(new NumberTickUnit(100000, numberFormat, 2));
    865        units.add(new NumberTickUnit(1000000, numberFormat, 2));
    866        units.add(new NumberTickUnit(10000000, numberFormat, 2));
    867        units.add(new NumberTickUnit(100000000, numberFormat, 2));
    868        units.add(new NumberTickUnit(1000000000, numberFormat, 2));
    869        units.add(new NumberTickUnit(10000000000.0, numberFormat, 2));
    870
    871        units.add(new NumberTickUnit(0.00000025, numberFormat, 5));
    872        units.add(new NumberTickUnit(0.0000025, numberFormat, 5));
    873        units.add(new NumberTickUnit(0.000025, numberFormat, 5));
    874        units.add(new NumberTickUnit(0.00025, numberFormat, 5));
    875        units.add(new NumberTickUnit(0.0025, numberFormat, 5));
    876        units.add(new NumberTickUnit(0.025, numberFormat, 5));
    877        units.add(new NumberTickUnit(0.25, numberFormat, 5));
    878        units.add(new NumberTickUnit(2.5, numberFormat, 5));
    879        units.add(new NumberTickUnit(25, numberFormat, 5));
    880        units.add(new NumberTickUnit(250, numberFormat, 5));
    881        units.add(new NumberTickUnit(2500, numberFormat, 5));
    882        units.add(new NumberTickUnit(25000, numberFormat, 5));
    883        units.add(new NumberTickUnit(250000, numberFormat, 5));
    884        units.add(new NumberTickUnit(2500000, numberFormat, 5));
    885        units.add(new NumberTickUnit(25000000, numberFormat, 5));
    886        units.add(new NumberTickUnit(250000000, numberFormat, 5));
    887        units.add(new NumberTickUnit(2500000000.0, numberFormat, 5));
    888        units.add(new NumberTickUnit(25000000000.0, numberFormat, 5));
    889
    890        units.add(new NumberTickUnit(0.0000005, numberFormat, 5));
    891        units.add(new NumberTickUnit(0.000005, numberFormat, 5));
    892        units.add(new NumberTickUnit(0.00005, numberFormat, 5));
    893        units.add(new NumberTickUnit(0.0005, numberFormat, 5));
    894        units.add(new NumberTickUnit(0.005, numberFormat, 5));
    895        units.add(new NumberTickUnit(0.05, numberFormat, 5));
    896        units.add(new NumberTickUnit(0.5, numberFormat, 5));
    897        units.add(new NumberTickUnit(5L, numberFormat, 5));
    898        units.add(new NumberTickUnit(50L, numberFormat, 5));
    899        units.add(new NumberTickUnit(500L, numberFormat, 5));
    900        units.add(new NumberTickUnit(5000L, numberFormat, 5));
    901        units.add(new NumberTickUnit(50000L, numberFormat, 5));
    902        units.add(new NumberTickUnit(500000L, numberFormat, 5));
    903        units.add(new NumberTickUnit(5000000L, numberFormat, 5));
    904        units.add(new NumberTickUnit(50000000L, numberFormat, 5));
    905        units.add(new NumberTickUnit(500000000L, numberFormat, 5));
    906        units.add(new NumberTickUnit(5000000000L, numberFormat, 5));
    907        units.add(new NumberTickUnit(50000000000L, numberFormat, 5));
    908
    909        return units;
    910
    911    }
    912
    913    /**
    914     * Returns a collection of tick units for integer values.
    915     * Uses a given Locale to create the DecimalFormats.
    916     *
    917     * @param locale the locale to use to represent Numbers.
    918     *
    919     * @return A collection of tick units for integer values.
    920     *
    921     * @see #setStandardTickUnits(TickUnitSource)
    922     */
    923    public static TickUnitSource createIntegerTickUnits(Locale locale) {
    924        TickUnits units = new TickUnits();
    925        NumberFormat numberFormat = NumberFormat.getNumberInstance(locale);
    926        units.add(new NumberTickUnit(1, numberFormat, 2));
    927        units.add(new NumberTickUnit(2, numberFormat, 2));
    928        units.add(new NumberTickUnit(5, numberFormat, 5));
    929        units.add(new NumberTickUnit(10, numberFormat, 2));
    930        units.add(new NumberTickUnit(20, numberFormat, 2));
    931        units.add(new NumberTickUnit(50, numberFormat, 5));
    932        units.add(new NumberTickUnit(100, numberFormat, 2));
    933        units.add(new NumberTickUnit(200, numberFormat, 2));
    934        units.add(new NumberTickUnit(500, numberFormat, 5));
    935        units.add(new NumberTickUnit(1000, numberFormat, 2));
    936        units.add(new NumberTickUnit(2000, numberFormat, 2));
    937        units.add(new NumberTickUnit(5000, numberFormat, 5));
    938        units.add(new NumberTickUnit(10000, numberFormat, 2));
    939        units.add(new NumberTickUnit(20000, numberFormat, 2));
    940        units.add(new NumberTickUnit(50000, numberFormat, 5));
    941        units.add(new NumberTickUnit(100000, numberFormat, 2));
    942        units.add(new NumberTickUnit(200000, numberFormat, 2));
    943        units.add(new NumberTickUnit(500000, numberFormat, 5));
    944        units.add(new NumberTickUnit(1000000, numberFormat, 2));
    945        units.add(new NumberTickUnit(2000000, numberFormat, 2));
    946        units.add(new NumberTickUnit(5000000, numberFormat, 5));
    947        units.add(new NumberTickUnit(10000000, numberFormat, 2));
    948        units.add(new NumberTickUnit(20000000, numberFormat, 2));
    949        units.add(new NumberTickUnit(50000000, numberFormat, 5));
    950        units.add(new NumberTickUnit(100000000, numberFormat, 2));
    951        units.add(new NumberTickUnit(200000000, numberFormat, 2));
    952        units.add(new NumberTickUnit(500000000, numberFormat, 5));
    953        units.add(new NumberTickUnit(1000000000, numberFormat, 2));
    954        units.add(new NumberTickUnit(2000000000, numberFormat, 2));
    955        units.add(new NumberTickUnit(5000000000.0, numberFormat, 5));
    956        units.add(new NumberTickUnit(10000000000.0, numberFormat, 2));
    957        return units;
    958    }
    959
    960    /**
    961     * Estimates the maximum tick label height.
    962     *
    963     * @param g2  the graphics device.
    964     *
    965     * @return The maximum height.
    966     */
    967    protected double estimateMaximumTickLabelHeight(Graphics2D g2) {
    968
    969        RectangleInsets tickLabelInsets = getTickLabelInsets();
    970        double result = tickLabelInsets.getTop() + tickLabelInsets.getBottom();
    971
    972        Font tickLabelFont = getTickLabelFont();
    973        FontRenderContext frc = g2.getFontRenderContext();
    974        result += tickLabelFont.getLineMetrics("123", frc).getHeight();
    975        return result;
    976
    977    }
    978
    979    /**
    980     * Estimates the maximum width of the tick labels, assuming the specified
    981     * tick unit is used.
    982     * <P>
    983     * Rather than computing the string bounds of every tick on the axis, we
    984     * just look at two values: the lower bound and the upper bound for the
    985     * axis.  These two values will usually be representative.
    986     *
    987     * @param g2  the graphics device.
    988     * @param unit  the tick unit to use for calculation.
    989     *
    990     * @return The estimated maximum width of the tick labels.
    991     */
    992    protected double estimateMaximumTickLabelWidth(Graphics2D g2,
    993                                                   TickUnit unit) {
    994
    995        RectangleInsets tickLabelInsets = getTickLabelInsets();
    996        double result = tickLabelInsets.getLeft() + tickLabelInsets.getRight();
    997
    998        if (isVerticalTickLabels()) {
    999            // all tick labels have the same width (equal to the height of the
    1000            // font)...
    1001            FontRenderContext frc = g2.getFontRenderContext();
    1002            LineMetrics lm = getTickLabelFont().getLineMetrics("0", frc);
    1003            result += lm.getHeight();
    1004        }
    1005        else {
    1006            // look at lower and upper bounds...
    1007            FontMetrics fm = g2.getFontMetrics(getTickLabelFont());
    1008            Range range = getRange();
    1009            double lower = range.getLowerBound();
    1010            double upper = range.getUpperBound();
    1011            String lowerStr = "";
    1012            String upperStr = "";
    1013            NumberFormat formatter = getNumberFormatOverride();
    1014            if (formatter != null) {
    1015                lowerStr = formatter.format(lower);
    1016                upperStr = formatter.format(upper);
    1017            }
    1018            else {
    1019                lowerStr = unit.valueToString(lower);
    1020                upperStr = unit.valueToString(upper);
    1021            }
    1022            double w1 = fm.stringWidth(lowerStr);
    1023            double w2 = fm.stringWidth(upperStr);
    1024            result += Math.max(w1, w2);
    1025        }
    1026
    1027        return result;
    1028
    1029    }
    1030
    1031    /**
    1032     * Selects an appropriate tick value for the axis.  The strategy is to
    1033     * display as many ticks as possible (selected from an array of 'standard'
    1034     * tick units) without the labels overlapping.
    1035     *
    1036     * @param g2  the graphics device.
    1037     * @param dataArea  the area defined by the axes.
    1038     * @param edge  the axis location.
    1039     */
    1040    protected void selectAutoTickUnit(Graphics2D g2,
    1041                                      Rectangle2D dataArea,
    1042                                      RectangleEdge edge) {
    1043
    1044        if (RectangleEdge.isTopOrBottom(edge)) {
    1045            selectHorizontalAutoTickUnit(g2, dataArea, edge);
    1046        }
    1047        else if (RectangleEdge.isLeftOrRight(edge)) {
    1048            selectVerticalAutoTickUnit(g2, dataArea, edge);
    1049        }
    1050
    1051    }
    1052
    1053    /**
    1054     * Selects an appropriate tick value for the axis.  The strategy is to
    1055     * display as many ticks as possible (selected from an array of 'standard'
    1056     * tick units) without the labels overlapping.
    1057     *
    1058     * @param g2  the graphics device.
    1059     * @param dataArea  the area defined by the axes.
    1060     * @param edge  the axis location.
    1061     */
    1062   protected void selectHorizontalAutoTickUnit(Graphics2D g2,
    1063                                               Rectangle2D dataArea,
    1064                                               RectangleEdge edge) {
    1065
    1066        double tickLabelWidth = estimateMaximumTickLabelWidth(g2,
    1067                getTickUnit());
    1068
    1069        // start with the current tick unit...
    1070        TickUnitSource tickUnits = getStandardTickUnits();
    1071        TickUnit unit1 = tickUnits.getCeilingTickUnit(getTickUnit());
    1072        double unit1Width = lengthToJava2D(unit1.getSize(), dataArea, edge);
    1073
    1074        // then extrapolate...
    1075        double guess = (tickLabelWidth / unit1Width) * unit1.getSize();
    1076
    1077        NumberTickUnit unit2 = (NumberTickUnit) tickUnits.getCeilingTickUnit(
    1078                guess);
    1079        double unit2Width = lengthToJava2D(unit2.getSize(), dataArea, edge);
    1080
    1081        tickLabelWidth = estimateMaximumTickLabelWidth(g2, unit2);
    1082        if (tickLabelWidth > unit2Width) {
    1083            unit2 = (NumberTickUnit) tickUnits.getLargerTickUnit(unit2);
    1084        }
    1085
    1086        setTickUnit(unit2, false, false);
    1087
    1088    }
    1089
    1090    /**
    1091     * Selects an appropriate tick value for the axis.  The strategy is to
    1092     * display as many ticks as possible (selected from an array of 'standard'
    1093     * tick units) without the labels overlapping.
    1094     *
    1095     * @param g2  the graphics device.
    1096     * @param dataArea  the area in which the plot should be drawn.
    1097     * @param edge  the axis location.
    1098     */
    1099    protected void selectVerticalAutoTickUnit(Graphics2D g2,
    1100                                              Rectangle2D dataArea,
    1101                                              RectangleEdge edge) {
    1102
    1103        double tickLabelHeight = estimateMaximumTickLabelHeight(g2);
    1104
    1105        // start with the current tick unit...
    1106        TickUnitSource tickUnits = getStandardTickUnits();
    1107        TickUnit unit1 = tickUnits.getCeilingTickUnit(getTickUnit());
    1108        double unitHeight = lengthToJava2D(unit1.getSize(), dataArea, edge);
    1109
    1110        // then extrapolate...
    1111        double guess = (tickLabelHeight / unitHeight) * unit1.getSize();
    1112
    1113        NumberTickUnit unit2
    1114            = (NumberTickUnit) tickUnits.getCeilingTickUnit(guess);
    1115        double unit2Height = lengthToJava2D(unit2.getSize(), dataArea, edge);
    1116
    1117        tickLabelHeight = estimateMaximumTickLabelHeight(g2);
    1118        if (tickLabelHeight > unit2Height) {
    1119            unit2 = (NumberTickUnit) tickUnits.getLargerTickUnit(unit2);
    1120        }
    1121
    1122        setTickUnit(unit2, false, false);
    1123
    1124    }
    1125
    1126    /**
    1127     * Calculates the positions of the tick labels for the axis, storing the
    1128     * results in the tick label list (ready for drawing).
    1129     *
    1130     * @param g2  the graphics device.
    1131     * @param state  the axis state.
    1132     * @param dataArea  the area in which the plot should be drawn.
    1133     * @param edge  the location of the axis.
    1134     *
    1135     * @return A list of ticks.
    1136     *
    1137     */
    1138    public List refreshTicks(Graphics2D g2,
    1139                             AxisState state,
    1140                             Rectangle2D dataArea,
    1141                             RectangleEdge edge) {
    1142
    1143        List result = new java.util.ArrayList();
    1144        if (RectangleEdge.isTopOrBottom(edge)) {
    1145            result = refreshTicksHorizontal(g2, dataArea, edge);
    1146        }
    1147        else if (RectangleEdge.isLeftOrRight(edge)) {
    1148            result = refreshTicksVertical(g2, dataArea, edge);
    1149        }
    1150        return result;
    1151
    1152    }
    1153
    1154    /**
    1155     * Calculates the positions of the tick labels for the axis, storing the
    1156     * results in the tick label list (ready for drawing).
    1157     *
    1158     * @param g2  the graphics device.
    1159     * @param dataArea  the area in which the data should be drawn.
    1160     * @param edge  the location of the axis.
    1161     *
    1162     * @return A list of ticks.
    1163     */
    1164    protected List refreshTicksHorizontal(Graphics2D g2,
    1165            Rectangle2D dataArea, RectangleEdge edge) {
    1166
    1167        List result = new java.util.ArrayList();
    1168
    1169        Font tickLabelFont = getTickLabelFont();
    1170        g2.setFont(tickLabelFont);
    1171
    1172        if (isAutoTickUnitSelection()) {
    1173            selectAutoTickUnit(g2, dataArea, edge);
    1174        }
    1175
    1176        TickUnit tu = getTickUnit();
    1177        double size = tu.getSize();
    1178        int count = calculateVisibleTickCount();
    1179        double lowestTickValue = calculateLowestVisibleTickValue();
    1180
    1181        if (count <= ValueAxis.MAXIMUM_TICK_COUNT) {
    1182            int minorTickSpaces = getMinorTickCount();
    1183            if (minorTickSpaces <= 0) {
    1184                minorTickSpaces = tu.getMinorTickCount();
    1185            }
    1186            for (int minorTick = 1; minorTick < minorTickSpaces; minorTick++) {
    1187                double minorTickValue = lowestTickValue
    1188                        - size * minorTick / minorTickSpaces;
    1189                if (getRange().contains(minorTickValue)) {
    1190                    result.add(new NumberTick(TickType.MINOR, minorTickValue,
    1191                            "", TextAnchor.TOP_CENTER, TextAnchor.CENTER,
    1192                            0.0));
    1193                }
    1194            }
    1195            for (int i = 0; i < count; i++) {
    1196                double currentTickValue = lowestTickValue + (i * size);
    1197                String tickLabel;
    1198                NumberFormat formatter = getNumberFormatOverride();
    1199                if (formatter != null) {
    1200                    tickLabel = formatter.format(currentTickValue);
    1201                }
    1202                else {
    1203                    tickLabel = getTickUnit().valueToString(currentTickValue);
    1204                }
    1205                TextAnchor anchor = null;
    1206                TextAnchor rotationAnchor = null;
    1207                double angle = 0.0;
    1208                if (isVerticalTickLabels()) {
    1209                    anchor = TextAnchor.CENTER_RIGHT;
    1210                    rotationAnchor = TextAnchor.CENTER_RIGHT;
    1211                    if (edge == RectangleEdge.TOP) {
    1212                        angle = Math.PI / 2.0;
    1213                    }
    1214                    else {
    1215                        angle = -Math.PI / 2.0;
    1216                    }
    1217                }
    1218                else {
    1219                    if (edge == RectangleEdge.TOP) {
    1220                        anchor = TextAnchor.BOTTOM_CENTER;
    1221                        rotationAnchor = TextAnchor.BOTTOM_CENTER;
    1222                    }
    1223                    else {
    1224                        anchor = TextAnchor.TOP_CENTER;
    1225                        rotationAnchor = TextAnchor.TOP_CENTER;
    1226                    }
    1227                }
    1228
    1229                Tick tick = new NumberTick(new Double(currentTickValue),
    1230                        tickLabel, anchor, rotationAnchor, angle);
    1231                result.add(tick);
    1232                double nextTickValue = lowestTickValue + ((i + 1) * size);
    1233                for (int minorTick = 1; minorTick < minorTickSpaces;
    1234                        minorTick++) {
    1235                    double minorTickValue = currentTickValue
    1236                            + (nextTickValue - currentTickValue)
    1237                            * minorTick / minorTickSpaces;
    1238                    if (getRange().contains(minorTickValue)) {
    1239                        result.add(new NumberTick(TickType.MINOR,
    1240                                minorTickValue, "", TextAnchor.TOP_CENTER,
    1241                                TextAnchor.CENTER, 0.0));
    1242                    }
    1243                }
    1244            }
    1245        }
    1246        return result;
    1247
    1248    }
    1249
    1250    /**
    1251     * Calculates the positions of the tick labels for the axis, storing the
    1252     * results in the tick label list (ready for drawing).
    1253     *
    1254     * @param g2  the graphics device.
    1255     * @param dataArea  the area in which the plot should be drawn.
    1256     * @param edge  the location of the axis.
    1257     *
    1258     * @return A list of ticks.
    1259     */
    1260    protected List refreshTicksVertical(Graphics2D g2,
    1261            Rectangle2D dataArea, RectangleEdge edge) {
    1262
    1263        List result = new java.util.ArrayList();
    1264        result.clear();
    1265
    1266        Font tickLabelFont = getTickLabelFont();
    1267        g2.setFont(tickLabelFont);
    1268        if (isAutoTickUnitSelection()) {
    1269            selectAutoTickUnit(g2, dataArea, edge);
    1270        }
    1271
    1272        TickUnit tu = getTickUnit();
    1273        double size = tu.getSize();
    1274        int count = calculateVisibleTickCount();
    1275        double lowestTickValue = calculateLowestVisibleTickValue();
    1276
    1277        if (count <= ValueAxis.MAXIMUM_TICK_COUNT) {
    1278            int minorTickSpaces = getMinorTickCount();
    1279            if (minorTickSpaces <= 0) {
    1280                minorTickSpaces = tu.getMinorTickCount();
    1281            }
    1282            for (int minorTick = 1; minorTick < minorTickSpaces; minorTick++) {
    1283                double minorTickValue = lowestTickValue
    1284                        - size * minorTick / minorTickSpaces;
    1285                if (getRange().contains(minorTickValue)) {
    1286                    result.add(new NumberTick(TickType.MINOR, minorTickValue,
    1287                            "", TextAnchor.TOP_CENTER, TextAnchor.CENTER,
    1288                            0.0));
    1289                }
    1290            }
    1291
    1292            for (int i = 0; i < count; i++) {
    1293                double currentTickValue = lowestTickValue + (i * size);
    1294                String tickLabel;
    1295                NumberFormat formatter = getNumberFormatOverride();
    1296                if (formatter != null) {
    1297                    tickLabel = formatter.format(currentTickValue);
    1298                }
    1299                else {
    1300                    tickLabel = getTickUnit().valueToString(currentTickValue);
    1301                }
    1302
    1303                TextAnchor anchor = null;
    1304                TextAnchor rotationAnchor = null;
    1305                double angle = 0.0;
    1306                if (isVerticalTickLabels()) {
    1307                    if (edge == RectangleEdge.LEFT) {
    1308                        anchor = TextAnchor.BOTTOM_CENTER;
    1309                        rotationAnchor = TextAnchor.BOTTOM_CENTER;
    1310                        angle = -Math.PI / 2.0;
    1311                    }
    1312                    else {
    1313                        anchor = TextAnchor.BOTTOM_CENTER;
    1314                        rotationAnchor = TextAnchor.BOTTOM_CENTER;
    1315                        angle = Math.PI / 2.0;
    1316                    }
    1317                }
    1318                else {
    1319                    if (edge == RectangleEdge.LEFT) {
    1320                        anchor = TextAnchor.CENTER_RIGHT;
    1321                        rotationAnchor = TextAnchor.CENTER_RIGHT;
    1322                    }
    1323                    else {
    1324                        anchor = TextAnchor.CENTER_LEFT;
    1325                        rotationAnchor = TextAnchor.CENTER_LEFT;
    1326                    }
    1327                }
    1328
    1329                Tick tick = new NumberTick(new Double(currentTickValue),
    1330                        tickLabel, anchor, rotationAnchor, angle);
    1331                result.add(tick);
    1332
    1333                double nextTickValue = lowestTickValue + ((i + 1) * size);
    1334                for (int minorTick = 1; minorTick < minorTickSpaces;
    1335                        minorTick++) {
    1336                    double minorTickValue = currentTickValue
    1337                            + (nextTickValue - currentTickValue)
    1338                            * minorTick / minorTickSpaces;
    1339                    if (getRange().contains(minorTickValue)) {
    1340                        result.add(new NumberTick(TickType.MINOR,
    1341                                minorTickValue, "", TextAnchor.TOP_CENTER,
    1342                                TextAnchor.CENTER, 0.0));
    1343                    }
    1344                }
    1345            }
    1346        }
    1347        return result;
    1348
    1349    }
    1350
    1351    /**
    1352     * Returns a clone of the axis.
    1353     *
    1354     * @return A clone
    1355     *
    1356     * @throws CloneNotSupportedException if some component of the axis does
    1357     *         not support cloning.
    1358     */
    1359    public Object clone() throws CloneNotSupportedException {
    1360        NumberAxis clone = (NumberAxis) super.clone();
    1361        if (this.numberFormatOverride != null) {
    1362            clone.numberFormatOverride
    1363                = (NumberFormat) this.numberFormatOverride.clone();
    1364        }
    1365        return clone;
    1366    }
    1367
    1368    /**
    1369     * Tests the axis for equality with an arbitrary object.
    1370     *
    1371     * @param obj  the object (<code>null</code> permitted).
    1372     *
    1373     * @return A boolean.
    1374     */
    1375    public boolean equals(Object obj) {
    1376        if (obj == this) {
    1377            return true;
    1378        }
    1379        if (!(obj instanceof NumberAxis)) {
    1380            return false;
    1381        }
    1382        NumberAxis that = (NumberAxis) obj;
    1383        if (this.autoRangeIncludesZero != that.autoRangeIncludesZero) {
    1384            return false;
    1385        }
    1386        if (this.autoRangeStickyZero != that.autoRangeStickyZero) {
    1387            return false;
    1388        }
    1389        if (!ObjectUtilities.equal(this.tickUnit, that.tickUnit)) {
    1390            return false;
    1391        }
    1392        if (!ObjectUtilities.equal(this.numberFormatOverride,
    1393                that.numberFormatOverride)) {
    1394            return false;
    1395        }
    1396        if (!this.rangeType.equals(that.rangeType)) {
    1397            return false;
    1398        }
    1399        return super.equals(obj);
    1400    }
    1401
    1402    /**
    1403     * Returns a hash code for this object.
    1404     *
    1405     * @return A hash code.
    1406     */
    1407    public int hashCode() {
    1408        if (getLabel() != null) {
    1409            return getLabel().hashCode();
    1410        }
    1411        else {
    1412            return 0;
    1413        }
    1414    }
    1415
    1416}