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