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 * LogAxis.java
029 * ------------
030 * (C) Copyright 2006-2009, by Object Refinery Limited and Contributors.
031 *
032 * Original Author:  David Gilbert (for Object Refinery Limited);
033 * Contributor(s):   Andrew Mickish (patch 1868745);
034 *                   Peter Kolb (patches 1934255 and 2603321);
035 *
036 * Changes
037 * -------
038 * 24-Aug-2006 : Version 1 (DG);
039 * 22-Mar-2007 : Use defaultAutoArrange attribute (DG);
040 * 02-Aug-2007 : Fixed zooming bug, added support for margins (DG);
041 * 14-Feb-2008 : Changed default minorTickCount to 9 - see bug report
042 *               1892419 (DG);
043 * 15-Feb-2008 : Applied a variation of patch 1868745 by Andrew Mickish to
044 *               fix a labelling bug when the axis appears at the top or
045 *               right of the chart (DG);
046 * 19-Mar-2008 : Applied patch 1902418 by Andrew Mickish to fix bug in tick
047 *               labels for vertical axis (DG);
048 * 26-Mar-2008 : Changed createTickLabel() method from private to protected -
049 *               see patch 1918209 by Andrew Mickish (DG);
050 * 25-Sep-2008 : Moved minor tick fields up to superclass, see patch 1934255
051 *               by Peter Kolb (DG);
052 * 14-Jan-2009 : Fetch minor ticks from TickUnit, and corrected
053 *               createLogTickUnits() (DG);
054 * 21-Jan-2009 : No need to call setMinorTickCount() in constructor (DG);
055 * 19-Mar-2009 : Added entity support - see patch 2603321 by Peter Kolb (DG);
056 * 30-Mar-2009 : Added pan(double) method (DG);
057 *
058 */
059
060package org.jfree.chart.axis;
061
062import java.awt.Font;
063import java.awt.FontMetrics;
064import java.awt.Graphics2D;
065import java.awt.font.FontRenderContext;
066import java.awt.font.LineMetrics;
067import java.awt.geom.Rectangle2D;
068import java.text.DecimalFormat;
069import java.text.NumberFormat;
070import java.util.ArrayList;
071import java.util.List;
072import java.util.Locale;
073
074import org.jfree.chart.event.AxisChangeEvent;
075import org.jfree.chart.plot.Plot;
076import org.jfree.chart.plot.PlotRenderingInfo;
077import org.jfree.chart.plot.ValueAxisPlot;
078import org.jfree.chart.util.LogFormat;
079import org.jfree.data.Range;
080import org.jfree.ui.RectangleEdge;
081import org.jfree.ui.RectangleInsets;
082import org.jfree.ui.TextAnchor;
083
084/**
085 * A numerical axis that uses a logarithmic scale.  The class is an
086 * alternative to the {@link LogarithmicAxis} class.
087 *
088 * @since 1.0.7
089 */
090public class LogAxis extends ValueAxis {
091
092    /** The logarithm base. */
093    private double base = 10.0;
094
095    /** The logarithm of the base value - cached for performance. */
096    private double baseLog = Math.log(10.0);
097
098    /**  The smallest value permitted on the axis. */
099    private double smallestValue = 1E-100;
100
101    /** The current tick unit. */
102    private NumberTickUnit tickUnit;
103
104    /** The override number format. */
105    private NumberFormat numberFormatOverride;
106
107    /**
108     * Creates a new <code>LogAxis</code> with no label.
109     */
110    public LogAxis() {
111        this(null);
112    }
113
114    /**
115     * Creates a new <code>LogAxis</code> with the given label.
116     *
117     * @param label  the axis label (<code>null</code> permitted).
118     */
119    public LogAxis(String label) {
120        super(label, createLogTickUnits(Locale.getDefault()));
121        setDefaultAutoRange(new Range(0.01, 1.0));
122        this.tickUnit = new NumberTickUnit(1.0, new DecimalFormat("0.#"), 9);
123    }
124
125    /**
126     * Returns the base for the logarithm calculation.
127     *
128     * @return The base for the logarithm calculation.
129     *
130     * @see #setBase(double)
131     */
132    public double getBase() {
133        return this.base;
134    }
135
136    /**
137     * Sets the base for the logarithm calculation and sends an
138     * {@link AxisChangeEvent} to all registered listeners.
139     *
140     * @param base  the base value (must be > 1.0).
141     *
142     * @see #getBase()
143     */
144    public void setBase(double base) {
145        if (base <= 1.0) {
146            throw new IllegalArgumentException("Requires 'base' > 1.0.");
147        }
148        this.base = base;
149        this.baseLog = Math.log(base);
150        notifyListeners(new AxisChangeEvent(this));
151    }
152
153    /**
154     * Returns the smallest value represented by the axis.
155     *
156     * @return The smallest value represented by the axis.
157     *
158     * @see #setSmallestValue(double)
159     */
160    public double getSmallestValue() {
161        return this.smallestValue;
162    }
163
164    /**
165     * Sets the smallest value represented by the axis and sends an
166     * {@link AxisChangeEvent} to all registered listeners.
167     *
168     * @param value  the value.
169     *
170     * @see #getSmallestValue()
171     */
172    public void setSmallestValue(double value) {
173        if (value <= 0.0) {
174            throw new IllegalArgumentException("Requires 'value' > 0.0.");
175        }
176        this.smallestValue = value;
177        notifyListeners(new AxisChangeEvent(this));
178    }
179
180    /**
181     * Returns the current tick unit.
182     *
183     * @return The current tick unit.
184     *
185     * @see #setTickUnit(NumberTickUnit)
186     */
187    public NumberTickUnit getTickUnit() {
188        return this.tickUnit;
189    }
190
191    /**
192     * Sets the tick unit for the axis and sends an {@link AxisChangeEvent} to
193     * all registered listeners.  A side effect of calling this method is that
194     * the "auto-select" feature for tick units is switched off (you can
195     * restore it using the {@link ValueAxis#setAutoTickUnitSelection(boolean)}
196     * method).
197     *
198     * @param unit  the new tick unit (<code>null</code> not permitted).
199     *
200     * @see #getTickUnit()
201     */
202    public void setTickUnit(NumberTickUnit unit) {
203        // defer argument checking...
204        setTickUnit(unit, true, true);
205    }
206
207    /**
208     * Sets the tick unit for the axis and, if requested, sends an
209     * {@link AxisChangeEvent} to all registered listeners.  In addition, an
210     * option is provided to turn off the "auto-select" feature for tick units
211     * (you can restore it using the
212     * {@link ValueAxis#setAutoTickUnitSelection(boolean)} method).
213     *
214     * @param unit  the new tick unit (<code>null</code> not permitted).
215     * @param notify  notify listeners?
216     * @param turnOffAutoSelect  turn off the auto-tick selection?
217     *
218     * @see #getTickUnit()
219     */
220    public void setTickUnit(NumberTickUnit unit, boolean notify,
221                            boolean turnOffAutoSelect) {
222
223        if (unit == null) {
224            throw new IllegalArgumentException("Null 'unit' argument.");
225        }
226        this.tickUnit = unit;
227        if (turnOffAutoSelect) {
228            setAutoTickUnitSelection(false, false);
229        }
230        if (notify) {
231            notifyListeners(new AxisChangeEvent(this));
232        }
233
234    }
235
236    /**
237     * Returns the number format override.  If this is non-null, then it will
238     * be used to format the numbers on the axis.
239     *
240     * @return The number formatter (possibly <code>null</code>).
241     *
242     * @see #setNumberFormatOverride(NumberFormat)
243     */
244    public NumberFormat getNumberFormatOverride() {
245        return this.numberFormatOverride;
246    }
247
248    /**
249     * Sets the number format override.  If this is non-null, then it will be
250     * used to format the numbers on the axis.
251     *
252     * @param formatter  the number formatter (<code>null</code> permitted).
253     *
254     * @see #getNumberFormatOverride()
255     */
256    public void setNumberFormatOverride(NumberFormat formatter) {
257        this.numberFormatOverride = formatter;
258        notifyListeners(new AxisChangeEvent(this));
259    }
260
261    /**
262     * Calculates the log of the given value, using the current base.
263     *
264     * @param value  the value.
265     *
266     * @return The log of the given value.
267     *
268     * @see #calculateValue(double)
269     * @see #getBase()
270     */
271    public double calculateLog(double value) {
272        return Math.log(value) / this.baseLog;
273    }
274
275    /**
276     * Calculates the value from a given log.
277     *
278     * @param log  the log value (must be > 0.0).
279     *
280     * @return The value with the given log.
281     *
282     * @see #calculateLog(double)
283     * @see #getBase()
284     */
285    public double calculateValue(double log) {
286        return Math.pow(this.base, log);
287    }
288
289    /**
290     * Converts a Java2D coordinate to an axis value, assuming that the
291     * axis covers the specified <code>edge</code> of the <code>area</code>.
292     *
293     * @param java2DValue  the Java2D coordinate.
294     * @param area  the area.
295     * @param edge  the edge that the axis belongs to.
296     *
297     * @return A value along the axis scale.
298     */
299    public double java2DToValue(double java2DValue, Rectangle2D area,
300            RectangleEdge edge) {
301
302        Range range = getRange();
303        double axisMin = calculateLog(range.getLowerBound());
304        double axisMax = calculateLog(range.getUpperBound());
305
306        double min = 0.0;
307        double max = 0.0;
308        if (RectangleEdge.isTopOrBottom(edge)) {
309            min = area.getX();
310            max = area.getMaxX();
311        }
312        else if (RectangleEdge.isLeftOrRight(edge)) {
313            min = area.getMaxY();
314            max = area.getY();
315        }
316        double log = 0.0;
317        if (isInverted()) {
318            log = axisMax - (java2DValue - min) / (max - min)
319                    * (axisMax - axisMin);
320        }
321        else {
322            log = axisMin + (java2DValue - min) / (max - min)
323                    * (axisMax - axisMin);
324        }
325        return calculateValue(log);
326    }
327
328    /**
329     * Converts a value on the axis scale to a Java2D coordinate relative to
330     * the given <code>area</code>, based on the axis running along the
331     * specified <code>edge</code>.
332     *
333     * @param value  the data value.
334     * @param area  the area.
335     * @param edge  the edge.
336     *
337     * @return The Java2D coordinate corresponding to <code>value</code>.
338     */
339    public double valueToJava2D(double value, Rectangle2D area,
340            RectangleEdge edge) {
341
342        Range range = getRange();
343        double axisMin = calculateLog(range.getLowerBound());
344        double axisMax = calculateLog(range.getUpperBound());
345        value = calculateLog(value);
346
347        double min = 0.0;
348        double max = 0.0;
349        if (RectangleEdge.isTopOrBottom(edge)) {
350            min = area.getX();
351            max = area.getMaxX();
352        }
353        else if (RectangleEdge.isLeftOrRight(edge)) {
354            max = area.getMinY();
355            min = area.getMaxY();
356        }
357        if (isInverted()) {
358            return max
359                   - ((value - axisMin) / (axisMax - axisMin)) * (max - min);
360        }
361        else {
362            return min
363                   + ((value - axisMin) / (axisMax - axisMin)) * (max - min);
364        }
365    }
366
367    /**
368     * Configures the axis.  This method is typically called when an axis
369     * is assigned to a new plot.
370     */
371    public void configure() {
372        if (isAutoRange()) {
373            autoAdjustRange();
374        }
375    }
376
377    /**
378     * Adjusts the axis range to match the data range that the axis is
379     * required to display.
380     */
381    protected void autoAdjustRange() {
382        Plot plot = getPlot();
383        if (plot == null) {
384            return;  // no plot, no data
385        }
386
387        if (plot instanceof ValueAxisPlot) {
388            ValueAxisPlot vap = (ValueAxisPlot) plot;
389
390            Range r = vap.getDataRange(this);
391            if (r == null) {
392                r = getDefaultAutoRange();
393            }
394
395            double upper = r.getUpperBound();
396            double lower = Math.max(r.getLowerBound(), this.smallestValue);
397            double range = upper - lower;
398
399            // if fixed auto range, then derive lower bound...
400            double fixedAutoRange = getFixedAutoRange();
401            if (fixedAutoRange > 0.0) {
402                lower = Math.max(upper - fixedAutoRange, this.smallestValue);
403            }
404            else {
405                // ensure the autorange is at least <minRange> in size...
406                double minRange = getAutoRangeMinimumSize();
407                if (range < minRange) {
408                    double expand = (minRange - range) / 2;
409                    upper = upper + expand;
410                    lower = lower - expand;
411                }
412
413                // apply the margins - these should apply to the exponent range
414                double logUpper = calculateLog(upper);
415                double logLower = calculateLog(lower);
416                double logRange = logUpper - logLower;
417                logUpper = logUpper + getUpperMargin() * logRange;
418                logLower = logLower - getLowerMargin() * logRange;
419                upper = calculateValue(logUpper);
420                lower = calculateValue(logLower);
421            }
422
423            setRange(new Range(lower, upper), false, false);
424        }
425
426    }
427
428    /**
429     * Draws the axis on a Java 2D graphics device (such as the screen or a
430     * printer).
431     *
432     * @param g2  the graphics device (<code>null</code> not permitted).
433     * @param cursor  the cursor location (determines where to draw the axis).
434     * @param plotArea  the area within which the axes and plot should be drawn.
435     * @param dataArea  the area within which the data should be drawn.
436     * @param edge  the axis location (<code>null</code> not permitted).
437     * @param plotState  collects information about the plot
438     *                   (<code>null</code> permitted).
439     *
440     * @return The axis state (never <code>null</code>).
441     */
442    public AxisState draw(Graphics2D g2, double cursor, Rectangle2D plotArea,
443            Rectangle2D dataArea, RectangleEdge edge,
444            PlotRenderingInfo plotState) {
445
446        AxisState state = null;
447        // if the axis is not visible, don't draw it...
448        if (!isVisible()) {
449            state = new AxisState(cursor);
450            // even though the axis is not visible, we need ticks for the
451            // gridlines...
452            List ticks = refreshTicks(g2, state, dataArea, edge);
453            state.setTicks(ticks);
454            return state;
455        }
456        state = drawTickMarksAndLabels(g2, cursor, plotArea, dataArea, edge);
457        state = drawLabel(getLabel(), g2, plotArea, dataArea, edge, state);
458        createAndAddEntity(cursor, state, dataArea, edge, plotState);
459        return state;
460    }
461
462    /**
463     * Calculates the positions of the tick labels for the axis, storing the
464     * results in the tick label list (ready for drawing).
465     *
466     * @param g2  the graphics device.
467     * @param state  the axis state.
468     * @param dataArea  the area in which the plot should be drawn.
469     * @param edge  the location of the axis.
470     *
471     * @return A list of ticks.
472     *
473     */
474    public List refreshTicks(Graphics2D g2, AxisState state,
475            Rectangle2D dataArea, RectangleEdge edge) {
476
477        List result = new java.util.ArrayList();
478        if (RectangleEdge.isTopOrBottom(edge)) {
479            result = refreshTicksHorizontal(g2, dataArea, edge);
480        }
481        else if (RectangleEdge.isLeftOrRight(edge)) {
482            result = refreshTicksVertical(g2, dataArea, edge);
483        }
484        return result;
485
486    }
487
488    /**
489     * Returns a list of ticks for an axis at the top or bottom of the chart.
490     *
491     * @param g2  the graphics device.
492     * @param dataArea  the data area.
493     * @param edge  the edge.
494     *
495     * @return A list of ticks.
496     */
497    protected List refreshTicksHorizontal(Graphics2D g2, Rectangle2D dataArea,
498            RectangleEdge edge) {
499
500        Range range = getRange();
501        List ticks = new ArrayList();
502        Font tickLabelFont = getTickLabelFont();
503        g2.setFont(tickLabelFont);
504        TextAnchor textAnchor;
505        if (edge == RectangleEdge.TOP) {
506            textAnchor = TextAnchor.BOTTOM_CENTER;
507        }
508        else {
509            textAnchor = TextAnchor.TOP_CENTER;
510        }
511
512        if (isAutoTickUnitSelection()) {
513            selectAutoTickUnit(g2, dataArea, edge);
514        }
515        int minorTickCount = this.tickUnit.getMinorTickCount();
516        double start = Math.floor(calculateLog(getLowerBound()));
517        double end = Math.ceil(calculateLog(getUpperBound()));
518        double current = start;
519        while (current <= end) {
520            double v = calculateValue(current);
521            if (range.contains(v)) {
522                ticks.add(new NumberTick(TickType.MAJOR, v, createTickLabel(v),
523                        textAnchor, TextAnchor.CENTER, 0.0));
524            }
525            // add minor ticks (for gridlines)
526            double next = Math.pow(this.base, current
527                    + this.tickUnit.getSize());
528            for (int i = 1; i < minorTickCount; i++) {
529                double minorV = v + i * ((next - v) / minorTickCount);
530                if (range.contains(minorV)) {
531                    ticks.add(new NumberTick(TickType.MINOR, minorV, "",
532                            textAnchor, TextAnchor.CENTER, 0.0));
533                }
534            }
535            current = current + this.tickUnit.getSize();
536        }
537        return ticks;
538    }
539
540    /**
541     * Returns a list of ticks for an axis at the left or right of the chart.
542     *
543     * @param g2  the graphics device.
544     * @param dataArea  the data area.
545     * @param edge  the edge.
546     *
547     * @return A list of ticks.
548     */
549    protected List refreshTicksVertical(Graphics2D g2, Rectangle2D dataArea,
550            RectangleEdge edge) {
551
552        Range range = getRange();
553        List ticks = new ArrayList();
554        Font tickLabelFont = getTickLabelFont();
555        g2.setFont(tickLabelFont);
556        TextAnchor textAnchor;
557        if (edge == RectangleEdge.RIGHT) {
558            textAnchor = TextAnchor.CENTER_LEFT;
559        }
560        else {
561            textAnchor = TextAnchor.CENTER_RIGHT;
562        }
563
564        if (isAutoTickUnitSelection()) {
565            selectAutoTickUnit(g2, dataArea, edge);
566        }
567        int minorTickCount = this.tickUnit.getMinorTickCount();
568        double start = Math.floor(calculateLog(getLowerBound()));
569        double end = Math.ceil(calculateLog(getUpperBound()));
570        double current = start;
571        while (current <= end) {
572            double v = calculateValue(current);
573            if (range.contains(v)) {
574                ticks.add(new NumberTick(TickType.MAJOR, v, createTickLabel(v),
575                        textAnchor, TextAnchor.CENTER, 0.0));
576            }
577            // add minor ticks (for gridlines)
578            double next = Math.pow(this.base, current
579                    + this.tickUnit.getSize());
580            for (int i = 1; i < minorTickCount; i++) {
581                double minorV = v + i * ((next - v) / minorTickCount);
582                if (range.contains(minorV)) {
583                    ticks.add(new NumberTick(TickType.MINOR, minorV, "",
584                            textAnchor, TextAnchor.CENTER, 0.0));
585                }
586            }
587            current = current + this.tickUnit.getSize();
588        }
589        return ticks;
590    }
591
592    /**
593     * Selects an appropriate tick value for the axis.  The strategy is to
594     * display as many ticks as possible (selected from an array of 'standard'
595     * tick units) without the labels overlapping.
596     *
597     * @param g2  the graphics device.
598     * @param dataArea  the area defined by the axes.
599     * @param edge  the axis location.
600     *
601     * @since 1.0.7
602     */
603    protected void selectAutoTickUnit(Graphics2D g2, Rectangle2D dataArea,
604            RectangleEdge edge) {
605
606        if (RectangleEdge.isTopOrBottom(edge)) {
607            selectHorizontalAutoTickUnit(g2, dataArea, edge);
608        }
609        else if (RectangleEdge.isLeftOrRight(edge)) {
610            selectVerticalAutoTickUnit(g2, dataArea, edge);
611        }
612
613    }
614
615    /**
616     * Selects an appropriate tick value for the axis.  The strategy is to
617     * display as many ticks as possible (selected from an array of 'standard'
618     * tick units) without the labels overlapping.
619     *
620     * @param g2  the graphics device.
621     * @param dataArea  the area defined by the axes.
622     * @param edge  the axis location.
623     *
624     * @since 1.0.7
625     */
626   protected void selectHorizontalAutoTickUnit(Graphics2D g2,
627           Rectangle2D dataArea, RectangleEdge edge) {
628
629        double tickLabelWidth = estimateMaximumTickLabelWidth(g2,
630                getTickUnit());
631
632        // start with the current tick unit...
633        TickUnitSource tickUnits = getStandardTickUnits();
634        TickUnit unit1 = tickUnits.getCeilingTickUnit(getTickUnit());
635        double unit1Width = exponentLengthToJava2D(unit1.getSize(), dataArea,
636                edge);
637
638        // then extrapolate...
639        double guess = (tickLabelWidth / unit1Width) * unit1.getSize();
640
641        NumberTickUnit unit2 = (NumberTickUnit)
642                tickUnits.getCeilingTickUnit(guess);
643        double unit2Width = exponentLengthToJava2D(unit2.getSize(), dataArea,
644                edge);
645
646        tickLabelWidth = estimateMaximumTickLabelWidth(g2, unit2);
647        if (tickLabelWidth > unit2Width) {
648            unit2 = (NumberTickUnit) tickUnits.getLargerTickUnit(unit2);
649        }
650
651        setTickUnit(unit2, false, false);
652
653    }
654
655    /**
656     * Converts a length in data coordinates into the corresponding length in
657     * Java2D coordinates.
658     *
659     * @param length  the length.
660     * @param area  the plot area.
661     * @param edge  the edge along which the axis lies.
662     *
663     * @return The length in Java2D coordinates.
664     *
665     * @since 1.0.7
666     */
667    public double exponentLengthToJava2D(double length, Rectangle2D area,
668                                RectangleEdge edge) {
669        double one = valueToJava2D(calculateValue(1.0), area, edge);
670        double l = valueToJava2D(calculateValue(length + 1.0), area, edge);
671        return Math.abs(l - one);
672    }
673
674    /**
675     * Selects an appropriate tick value for the axis.  The strategy is to
676     * display as many ticks as possible (selected from an array of 'standard'
677     * tick units) without the labels overlapping.
678     *
679     * @param g2  the graphics device.
680     * @param dataArea  the area in which the plot should be drawn.
681     * @param edge  the axis location.
682     *
683     * @since 1.0.7
684     */
685    protected void selectVerticalAutoTickUnit(Graphics2D g2,
686                                              Rectangle2D dataArea,
687                                              RectangleEdge edge) {
688
689        double tickLabelHeight = estimateMaximumTickLabelHeight(g2);
690
691        // start with the current tick unit...
692        TickUnitSource tickUnits = getStandardTickUnits();
693        TickUnit unit1 = tickUnits.getCeilingTickUnit(getTickUnit());
694        double unitHeight = exponentLengthToJava2D(unit1.getSize(), dataArea,
695                edge);
696
697        // then extrapolate...
698        double guess = (tickLabelHeight / unitHeight) * unit1.getSize();
699
700        NumberTickUnit unit2 = (NumberTickUnit)
701                tickUnits.getCeilingTickUnit(guess);
702        double unit2Height = exponentLengthToJava2D(unit2.getSize(), dataArea,
703                edge);
704
705        tickLabelHeight = estimateMaximumTickLabelHeight(g2);
706        if (tickLabelHeight > unit2Height) {
707            unit2 = (NumberTickUnit) tickUnits.getLargerTickUnit(unit2);
708        }
709
710        setTickUnit(unit2, false, false);
711
712    }
713
714    /**
715     * Estimates the maximum tick label height.
716     *
717     * @param g2  the graphics device.
718     *
719     * @return The maximum height.
720     *
721     * @since 1.0.7
722     */
723    protected double estimateMaximumTickLabelHeight(Graphics2D g2) {
724
725        RectangleInsets tickLabelInsets = getTickLabelInsets();
726        double result = tickLabelInsets.getTop() + tickLabelInsets.getBottom();
727
728        Font tickLabelFont = getTickLabelFont();
729        FontRenderContext frc = g2.getFontRenderContext();
730        result += tickLabelFont.getLineMetrics("123", frc).getHeight();
731        return result;
732
733    }
734
735    /**
736     * Estimates the maximum width of the tick labels, assuming the specified
737     * tick unit is used.
738     * <P>
739     * Rather than computing the string bounds of every tick on the axis, we
740     * just look at two values: the lower bound and the upper bound for the
741     * axis.  These two values will usually be representative.
742     *
743     * @param g2  the graphics device.
744     * @param unit  the tick unit to use for calculation.
745     *
746     * @return The estimated maximum width of the tick labels.
747     *
748     * @since 1.0.7
749     */
750    protected double estimateMaximumTickLabelWidth(Graphics2D g2,
751                                                   TickUnit unit) {
752
753        RectangleInsets tickLabelInsets = getTickLabelInsets();
754        double result = tickLabelInsets.getLeft() + tickLabelInsets.getRight();
755
756        if (isVerticalTickLabels()) {
757            // all tick labels have the same width (equal to the height of the
758            // font)...
759            FontRenderContext frc = g2.getFontRenderContext();
760            LineMetrics lm = getTickLabelFont().getLineMetrics("0", frc);
761            result += lm.getHeight();
762        }
763        else {
764            // look at lower and upper bounds...
765            FontMetrics fm = g2.getFontMetrics(getTickLabelFont());
766            Range range = getRange();
767            double lower = range.getLowerBound();
768            double upper = range.getUpperBound();
769            String lowerStr = "";
770            String upperStr = "";
771            NumberFormat formatter = getNumberFormatOverride();
772            if (formatter != null) {
773                lowerStr = formatter.format(lower);
774                upperStr = formatter.format(upper);
775            }
776            else {
777                lowerStr = unit.valueToString(lower);
778                upperStr = unit.valueToString(upper);
779            }
780            double w1 = fm.stringWidth(lowerStr);
781            double w2 = fm.stringWidth(upperStr);
782            result += Math.max(w1, w2);
783        }
784
785        return result;
786
787    }
788
789    /**
790     * Zooms in on the current range.
791     *
792     * @param lowerPercent  the new lower bound.
793     * @param upperPercent  the new upper bound.
794     */
795    public void zoomRange(double lowerPercent, double upperPercent) {
796        Range range = getRange();
797        double start = range.getLowerBound();
798        double end = range.getUpperBound();
799        double log1 = calculateLog(start);
800        double log2 = calculateLog(end);
801        double length = log2 - log1;
802        Range adjusted = null;
803        if (isInverted()) {
804            double logA = log1 + length * (1 - upperPercent);
805            double logB = log1 + length * (1 - lowerPercent);
806            adjusted = new Range(calculateValue(logA), calculateValue(logB));
807        }
808        else {
809            double logA = log1 + length * lowerPercent;
810            double logB = log1 + length * upperPercent;
811            adjusted = new Range(calculateValue(logA), calculateValue(logB));
812        }
813        setRange(adjusted);
814    }
815
816    /**
817     * Slides the axis range by the specified percentage.
818     *
819     * @param percent  the percentage.
820     *
821     * @since 1.0.13
822     */
823    public void pan(double percent) {
824        Range range = getRange();
825        double lower = range.getLowerBound();
826        double upper = range.getUpperBound();
827        double log1 = calculateLog(lower);
828        double log2 = calculateLog(upper);
829        double length = log2 - log1;
830        double adj = length * percent;
831        log1 = log1 + adj;
832        log2 = log2 + adj;
833        setRange(calculateValue(log1), calculateValue(log2));
834    }
835
836    /**
837     * Creates a tick label for the specified value.  Note that this method
838     * was 'private' prior to version 1.0.10.
839     *
840     * @param value  the value.
841     *
842     * @return The label.
843     *
844     * @since 1.0.10
845     */
846    protected String createTickLabel(double value) {
847        if (this.numberFormatOverride != null) {
848            return this.numberFormatOverride.format(value);
849        }
850        else {
851            return this.tickUnit.valueToString(value);
852        }
853    }
854
855    /**
856     * Tests this axis for equality with an arbitrary object.
857     *
858     * @param obj  the object (<code>null</code> permitted).
859     *
860     * @return A boolean.
861     */
862    public boolean equals(Object obj) {
863        if (obj == this) {
864            return true;
865        }
866        if (!(obj instanceof LogAxis)) {
867            return false;
868        }
869        LogAxis that = (LogAxis) obj;
870        if (this.base != that.base) {
871            return false;
872        }
873        if (this.smallestValue != that.smallestValue) {
874            return false;
875        }
876        return super.equals(obj);
877    }
878
879    /**
880     * Returns a hash code for this instance.
881     *
882     * @return A hash code.
883     */
884    public int hashCode() {
885        int result = 193;
886        long temp = Double.doubleToLongBits(this.base);
887        result = 37 * result + (int) (temp ^ (temp >>> 32));
888        temp = Double.doubleToLongBits(this.smallestValue);
889        result = 37 * result + (int) (temp ^ (temp >>> 32));
890        if (this.numberFormatOverride != null) {
891            result = 37 * result + this.numberFormatOverride.hashCode();
892        }
893        result = 37 * result + this.tickUnit.hashCode();
894        return result;
895    }
896
897    /**
898     * Returns a collection of tick units for log (base 10) values.
899     * Uses a given Locale to create the DecimalFormats.
900     *
901     * @param locale the locale to use to represent Numbers.
902     *
903     * @return A collection of tick units for integer values.
904     *
905     * @since 1.0.7
906     */
907    public static TickUnitSource createLogTickUnits(Locale locale) {
908        TickUnits units = new TickUnits();
909        NumberFormat numberFormat = new LogFormat();
910        units.add(new NumberTickUnit(0.05, numberFormat, 2));
911        units.add(new NumberTickUnit(0.1, numberFormat, 10));
912        units.add(new NumberTickUnit(0.2, numberFormat, 2));
913        units.add(new NumberTickUnit(0.5, numberFormat, 5));
914        units.add(new NumberTickUnit(1, numberFormat, 10));
915        units.add(new NumberTickUnit(2, numberFormat, 10));
916        units.add(new NumberTickUnit(3, numberFormat, 15));
917        units.add(new NumberTickUnit(4, numberFormat, 20));
918        units.add(new NumberTickUnit(5, numberFormat, 25));
919        units.add(new NumberTickUnit(6, numberFormat));
920        units.add(new NumberTickUnit(7, numberFormat));
921        units.add(new NumberTickUnit(8, numberFormat));
922        units.add(new NumberTickUnit(9, numberFormat));
923        units.add(new NumberTickUnit(10, numberFormat));
924        return units;
925    }
926
927}