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    }