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