content: /* ===========================================================
   * JFreeChart : a free chart library for the Java(tm) platform
   * ===========================================================
   *
   * (C) Copyright 2000-2013, by Object Refinery Limited and Contributors.
   *
   * Project Info:  http://www.jfree.org/jfreechart/index.html
   *
   * This library is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2.1 of the License, or
   * (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
   * License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
   * USA.
   *
   * [Oracle and Java are registered trademarks of Oracle and/or its affiliates.
   * Other names may be trademarks of their respective owners.]
   *
   * ------------
   * LogAxis.java
   * ------------
   * (C) Copyright 2006-2013, by Object Refinery Limited and Contributors.
   *
   * Original Author:  David Gilbert (for Object Refinery Limited);
   * Contributor(s):   Andrew Mickish (patch 1868745);
   *                   Peter Kolb (patches 1934255 and 2603321);
   *
   * Changes
   * -------
   * 24-Aug-2006 : Version 1 (DG);
   * 22-Mar-2007 : Use defaultAutoArrange attribute (DG);
   * 02-Aug-2007 : Fixed zooming bug, added support for margins (DG);
   * 14-Feb-2008 : Changed default minorTickCount to 9 - see bug report
   *               1892419 (DG);
   * 15-Feb-2008 : Applied a variation of patch 1868745 by Andrew Mickish to
   *               fix a labelling bug when the axis appears at the top or
   *               right of the chart (DG);
   * 19-Mar-2008 : Applied patch 1902418 by Andrew Mickish to fix bug in tick
   *               labels for vertical axis (DG);
   * 26-Mar-2008 : Changed createTickLabel() method from private to protected -
   *               see patch 1918209 by Andrew Mickish (DG);
   * 25-Sep-2008 : Moved minor tick fields up to superclass, see patch 1934255
   *               by Peter Kolb (DG);
   * 14-Jan-2009 : Fetch minor ticks from TickUnit, and corrected
   *               createLogTickUnits() (DG);
   * 21-Jan-2009 : No need to call setMinorTickCount() in constructor (DG);
   * 19-Mar-2009 : Added entity support - see patch 2603321 by Peter Kolb (DG);
   * 30-Mar-2009 : Added pan(double) method (DG);
   * 28-Oct-2011 : Fixed endless loop for 0 TickUnit, # 3429707 (MH);
   * 17-Jun-2012 : Removed JCommon dependencies (DG);
   *
   */
  
  package org.jfree.chart.axis;
  
  import java.awt.Font;
  import java.awt.FontMetrics;
  import java.awt.Graphics2D;
  import java.awt.font.FontRenderContext;
  import java.awt.font.LineMetrics;
  import java.awt.geom.Rectangle2D;
  import java.text.DecimalFormat;
  import java.text.NumberFormat;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Locale;
  
  import org.jfree.chart.ui.RectangleEdge;
  import org.jfree.chart.ui.RectangleInsets;
  import org.jfree.chart.ui.TextAnchor;
  import org.jfree.chart.event.AxisChangeEvent;
  import org.jfree.chart.plot.Plot;
  import org.jfree.chart.plot.PlotRenderingInfo;
  import org.jfree.chart.plot.ValueAxisPlot;
  import org.jfree.chart.util.LogFormat;
  import org.jfree.chart.util.ParamChecks;
  import org.jfree.data.Range;
  
  /**
   * A numerical axis that uses a logarithmic scale.  The class is an
   * alternative to the {@link LogarithmicAxis} class.
   *
   * @since 1.0.7
   */
  public class LogAxis extends ValueAxis {
  
      /** The logarithm base. */
      private double base = 10.0;
  
      /** The logarithm of the base value - cached for performance. */
      private double baseLog = Math.log(10.0);
  
      /**  The smallest value permitted on the axis. */
      private double smallestValue = 1E-100;
  
      /** The current tick unit. */
      private NumberTickUnit tickUnit;
  
      /** The override number format. */
      private NumberFormat numberFormatOverride;
  
      /**
       * Creates a new <code>LogAxis</code> with no label.
       */
      public LogAxis() {
          this(null);
      }
  
      /**
       * Creates a new <code>LogAxis</code> with the given label.
       *
       * @param label  the axis label (<code>null</code> permitted).
       */
      public LogAxis(String label) {
          super(label, createLogTickUnits(Locale.getDefault()));
          setDefaultAutoRange(new Range(0.01, 1.0));
          this.tickUnit = new NumberTickUnit(1.0, new DecimalFormat("0.#"), 9);
      }
  
      /**
       * Returns the base for the logarithm calculation.
       *
       * @return The base for the logarithm calculation.
       *
       * @see #setBase(double)
       */
      public double getBase() {
          return this.base;
      }
  
      /**
       * Sets the base for the logarithm calculation and sends an
       * {@link AxisChangeEvent} to all registered listeners.
       *
       * @param base  the base value (must be > 1.0).
       *
       * @see #getBase()
       */
      public void setBase(double base) {
          if (base <= 1.0) {
              throw new IllegalArgumentException("Requires 'base' > 1.0.");
          }
          this.base = base;
          this.baseLog = Math.log(base);
          fireChangeEvent();
      }
  
      /**
       * Returns the smallest value represented by the axis.
       *
       * @return The smallest value represented by the axis.
       *
       * @see #setSmallestValue(double)
       */
      public double getSmallestValue() {
          return this.smallestValue;
      }
  
      /**
       * Sets the smallest value represented by the axis and sends an
       * {@link AxisChangeEvent} to all registered listeners.
       *
       * @param value  the value.
       *
       * @see #getSmallestValue()
       */
      public void setSmallestValue(double value) {
          if (value <= 0.0) {
              throw new IllegalArgumentException("Requires 'value' > 0.0.");
          }
          this.smallestValue = value;
          notifyListeners(new AxisChangeEvent(this));
      }
  
      /**
       * Returns the current tick unit.
       *
       * @return The current tick unit.
       *
       * @see #setTickUnit(NumberTickUnit)
       */
      public NumberTickUnit getTickUnit() {
          return this.tickUnit;
      }
  
      /**
       * Sets the tick unit for the axis and sends an {@link AxisChangeEvent} to
       * all registered listeners.  A side effect of calling this method is that
       * the "auto-select" feature for tick units is switched off (you can
       * restore it using the {@link ValueAxis#setAutoTickUnitSelection(boolean)}
       * method).
       *
       * @param unit  the new tick unit (<code>null</code> not permitted).
       *
       * @see #getTickUnit()
       */
      public void setTickUnit(NumberTickUnit unit) {
          // defer argument checking...
          setTickUnit(unit, true, true);
      }
  
      /**
       * Sets the tick unit for the axis and, if requested, sends an
       * {@link AxisChangeEvent} to all registered listeners.  In addition, an
       * option is provided to turn off the "auto-select" feature for tick units
       * (you can restore it using the
       * {@link ValueAxis#setAutoTickUnitSelection(boolean)} method).
       *
       * @param unit  the new tick unit (<code>null</code> not permitted).
       * @param notify  notify listeners?
       * @param turnOffAutoSelect  turn off the auto-tick selection?
       *
       * @see #getTickUnit()
       */
      public void setTickUnit(NumberTickUnit unit, boolean notify,
                              boolean turnOffAutoSelect) {
  
          ParamChecks.nullNotPermitted(unit, "unit");
          this.tickUnit = unit;
          if (turnOffAutoSelect) {
              setAutoTickUnitSelection(false, false);
          }
          if (notify) {
              fireChangeEvent();
          }
  
      }
  
      /**
       * Returns the number format override.  If this is non-null, then it will
       * be used to format the numbers on the axis.
       *
       * @return The number formatter (possibly <code>null</code>).
       *
       * @see #setNumberFormatOverride(NumberFormat)
       */
      public NumberFormat getNumberFormatOverride() {
          return this.numberFormatOverride;
      }
  
      /**
       * Sets the number format override.  If this is non-null, then it will be
       * used to format the numbers on the axis.
       *
       * @param formatter  the number formatter (<code>null</code> permitted).
       *
       * @see #getNumberFormatOverride()
       */
      public void setNumberFormatOverride(NumberFormat formatter) {
          this.numberFormatOverride = formatter;
          notifyListeners(new AxisChangeEvent(this));
      }
  
      /**
       * Calculates the log of the given value, using the current base.
       *
       * @param value  the value.
       *
       * @return The log of the given value.
       *
       * @see #calculateValue(double)
       * @see #getBase()
       */
      public double calculateLog(double value) {
          return Math.log(value) / this.baseLog;
      }
  
      /**
       * Calculates the value from a given log.
       *
       * @param log  the log value.
       *
       * @return The value with the given log.
       *
       * @see #calculateLog(double)
       * @see #getBase()
       */
      public double calculateValue(double log) {
          return Math.pow(this.base, log);
      }
  
      /**
       * Converts a Java2D coordinate to an axis value, assuming that the
       * axis covers the specified <code>edge</code> of the <code>area</code>.
       *
       * @param java2DValue  the Java2D coordinate.
       * @param area  the area.
       * @param edge  the edge that the axis belongs to.
       *
       * @return A value along the axis scale.
       */
      @Override
      public double java2DToValue(double java2DValue, Rectangle2D area,
              RectangleEdge edge) {
  
          Range range = getRange();
          double axisMin = calculateLog(range.getLowerBound());
          double axisMax = calculateLog(range.getUpperBound());
  
          double min = 0.0;
          double max = 0.0;
          if (RectangleEdge.isTopOrBottom(edge)) {
              min = area.getX();
              max = area.getMaxX();
          }
          else if (RectangleEdge.isLeftOrRight(edge)) {
              min = area.getMaxY();
              max = area.getY();
          }
          double log = 0.0;
          if (isInverted()) {
              log = axisMax - (java2DValue - min) / (max - min)
                      * (axisMax - axisMin);
          }
          else {
              log = axisMin + (java2DValue - min) / (max - min)
                      * (axisMax - axisMin);
          }
          return calculateValue(log);
      }
  
      /**
       * Converts a value on the axis scale to a Java2D coordinate relative to
       * the given <code>area</code>, based on the axis running along the
       * specified <code>edge</code>.
       *
       * @param value  the data value.
       * @param area  the area.
       * @param edge  the edge.
       *
       * @return The Java2D coordinate corresponding to <code>value</code>.
       */
      @Override
      public double valueToJava2D(double value, Rectangle2D area,
              RectangleEdge edge) {
  
          Range range = getRange();
          double axisMin = calculateLog(range.getLowerBound());
          double axisMax = calculateLog(range.getUpperBound());
          value = calculateLog(value);
  
          double min = 0.0;
          double max = 0.0;
          if (RectangleEdge.isTopOrBottom(edge)) {
              min = area.getX();
              max = area.getMaxX();
          }
          else if (RectangleEdge.isLeftOrRight(edge)) {
              max = area.getMinY();
              min = area.getMaxY();
          }
          if (isInverted()) {
              return max
                     - ((value - axisMin) / (axisMax - axisMin)) * (max - min);
          }
          else {
              return min
                     + ((value - axisMin) / (axisMax - axisMin)) * (max - min);
          }
      }
  
      /**
       * Configures the axis.  This method is typically called when an axis
       * is assigned to a new plot.
       */
      @Override
      public void configure() {
          if (isAutoRange()) {
              autoAdjustRange();
          }
      }
  
      /**
       * Adjusts the axis range to match the data range that the axis is
       * required to display.
       */
      @Override
      protected void autoAdjustRange() {
          Plot plot = getPlot();
          if (plot == null) {
              return;  // no plot, no data
          }
  
          if (plot instanceof ValueAxisPlot) {
              ValueAxisPlot vap = (ValueAxisPlot) plot;
  
              Range r = vap.getDataRange(this);
              if (r == null) {
                  r = getDefaultAutoRange();
              }
  
              double upper = r.getUpperBound();
              double lower = Math.max(r.getLowerBound(), this.smallestValue);
              double range = upper - lower;
  
              // if fixed auto range, then derive lower bound...
              double fixedAutoRange = getFixedAutoRange();
              if (fixedAutoRange > 0.0) {
                  lower = Math.max(upper - fixedAutoRange, this.smallestValue);
              }
              else {
                  // ensure the autorange is at least <minRange> in size...
                  double minRange = getAutoRangeMinimumSize();
                  if (range < minRange) {
                      double expand = (minRange - range) / 2;
                      upper = upper + expand;
                      lower = lower - expand;
                  }
  
                  // apply the margins - these should apply to the exponent range
                  double logUpper = calculateLog(upper);
                  double logLower = calculateLog(lower);
                  double logRange = logUpper - logLower;
                  logUpper = logUpper + getUpperMargin() * logRange;
                  logLower = logLower - getLowerMargin() * logRange;
                  upper = calculateValue(logUpper);
                  lower = calculateValue(logLower);
              }
  
              setRange(new Range(lower, upper), false, false);
          }
  
      }
  
      /**
       * Draws the axis on a Java 2D graphics device (such as the screen or a
       * printer).
       *
       * @param g2  the graphics device (<code>null</code> not permitted).
       * @param cursor  the cursor location (determines where to draw the axis).
       * @param plotArea  the area within which the axes and plot should be drawn.
       * @param dataArea  the area within which the data should be drawn.
       * @param edge  the axis location (<code>null</code> not permitted).
       * @param plotState  collects information about the plot
       *                   (<code>null</code> permitted).
       *
       * @return The axis state (never <code>null</code>).
       */
      @Override
      public AxisState draw(Graphics2D g2, double cursor, Rectangle2D plotArea,
              Rectangle2D dataArea, RectangleEdge edge,
              PlotRenderingInfo plotState) {
  
          AxisState state;
          // if the axis is not visible, don't draw it...
          if (!isVisible()) {
              state = new AxisState(cursor);
              // even though the axis is not visible, we need ticks for the
              // gridlines...
              List<ValueTick> ticks = refreshTicks(g2, state, dataArea, edge);
              state.setTicks(ticks);
              return state;
          }
          state = drawTickMarksAndLabels(g2, cursor, plotArea, dataArea, edge);
          state = drawLabel(getLabel(), g2, plotArea, dataArea, edge, state);
          createAndAddEntity(cursor, state, dataArea, edge, plotState);
          return state;
      }
  
      /**
       * Calculates the positions of the tick labels for the axis, storing the
       * results in the tick label list (ready for drawing).
       *
       * @param g2  the graphics device.
       * @param state  the axis state.
       * @param dataArea  the area in which the plot should be drawn.
       * @param edge  the location of the axis.
       *
       * @return A list of ticks.
       *
       */
      @Override
      public List<ValueTick> refreshTicks(Graphics2D g2, AxisState state,
              Rectangle2D dataArea, RectangleEdge edge) {
  
          List<ValueTick> result = new java.util.ArrayList<ValueTick>();
          if (RectangleEdge.isTopOrBottom(edge)) {
              result = refreshTicksHorizontal(g2, dataArea, edge);
          }
          else if (RectangleEdge.isLeftOrRight(edge)) {
              result = refreshTicksVertical(g2, dataArea, edge);
          }
          return result;
  
      }
  
      /**
       * Returns a list of ticks for an axis at the top or bottom of the chart.
       *
       * @param g2  the graphics device.
       * @param dataArea  the data area.
       * @param edge  the edge.
       *
       * @return A list of ticks.
       */
      protected List<ValueTick> refreshTicksHorizontal(Graphics2D g2, Rectangle2D dataArea,
              RectangleEdge edge) {
  
          Range range = getRange();
          List<ValueTick> ticks = new ArrayList<ValueTick>();
          Font tickLabelFont = getTickLabelFont();
          g2.setFont(tickLabelFont);
          TextAnchor textAnchor;
          if (edge == RectangleEdge.TOP) {
              textAnchor = TextAnchor.BOTTOM_CENTER;
          }
          else {
              textAnchor = TextAnchor.TOP_CENTER;
          }
  
          if (isAutoTickUnitSelection()) {
              selectAutoTickUnit(g2, dataArea, edge);
          }
          int minorTickCount = this.tickUnit.getMinorTickCount();
          double start = Math.floor(calculateLog(getLowerBound()));
          double end = Math.ceil(calculateLog(getUpperBound()));
          double current = start;
          boolean hasTicks = (this.tickUnit.getSize() > 0.0)
                             && !Double.isInfinite(start);
          while (hasTicks && current <= end) {
              double v = calculateValue(current);
              if (range.contains(v)) {
                  ticks.add(new NumberTick(TickType.MAJOR, v, createTickLabel(v),
                          textAnchor, TextAnchor.CENTER, 0.0));
              }
              // add minor ticks (for gridlines)
              double next = Math.pow(this.base, current
                      + this.tickUnit.getSize());
              for (int i = 1; i < minorTickCount; i++) {
                  double minorV = v + i * ((next - v) / minorTickCount);
                  if (range.contains(minorV)) {
                      ticks.add(new NumberTick(TickType.MINOR, minorV, "",
                              textAnchor, TextAnchor.CENTER, 0.0));
                  }
              }
              current = current + this.tickUnit.getSize();
          }
          return ticks;
      }
  
      /**
       * Returns a list of ticks for an axis at the left or right of the chart.
       *
       * @param g2  the graphics device.
       * @param dataArea  the data area.
       * @param edge  the edge.
       *
       * @return A list of ticks.
       */
      protected List<ValueTick> refreshTicksVertical(Graphics2D g2, Rectangle2D dataArea,
              RectangleEdge edge) {
  
          Range range = getRange();
          List<ValueTick> ticks = new ArrayList<ValueTick>();
          Font tickLabelFont = getTickLabelFont();
          g2.setFont(tickLabelFont);
          TextAnchor textAnchor;
          if (edge == RectangleEdge.RIGHT) {
              textAnchor = TextAnchor.CENTER_LEFT;
          }
          else {
              textAnchor = TextAnchor.CENTER_RIGHT;
          }
  
          if (isAutoTickUnitSelection()) {
              selectAutoTickUnit(g2, dataArea, edge);
          }
          int minorTickCount = this.tickUnit.getMinorTickCount();
          double start = Math.floor(calculateLog(getLowerBound()));
          double end = Math.ceil(calculateLog(getUpperBound()));
          double current = start;
          boolean hasTicks = (this.tickUnit.getSize() > 0.0)
                             && !Double.isInfinite(start);
          while (hasTicks && current <= end) {
              double v = calculateValue(current);
              if (range.contains(v)) {
                  ticks.add(new NumberTick(TickType.MAJOR, v, createTickLabel(v),
                          textAnchor, TextAnchor.CENTER, 0.0));
              }
              // add minor ticks (for gridlines)
              double next = Math.pow(this.base, current
                      + this.tickUnit.getSize());
              for (int i = 1; i < minorTickCount; i++) {
                  double minorV = v + i * ((next - v) / minorTickCount);
                  if (range.contains(minorV)) {
                      ticks.add(new NumberTick(TickType.MINOR, minorV, "",
                              textAnchor, TextAnchor.CENTER, 0.0));
                  }
              }
              current = current + this.tickUnit.getSize();
          }
          return ticks;
      }
  
      /**
       * Selects an appropriate tick value for the axis.  The strategy is to
       * display as many ticks as possible (selected from an array of 'standard'
       * tick units) without the labels overlapping.
       *
       * @param g2  the graphics device.
       * @param dataArea  the area defined by the axes.
       * @param edge  the axis location.
       *
       * @since 1.0.7
       */
      protected void selectAutoTickUnit(Graphics2D g2, Rectangle2D dataArea,
              RectangleEdge edge) {
  
          if (RectangleEdge.isTopOrBottom(edge)) {
              selectHorizontalAutoTickUnit(g2, dataArea, edge);
          }
          else if (RectangleEdge.isLeftOrRight(edge)) {
              selectVerticalAutoTickUnit(g2, dataArea, edge);
          }
  
      }
  
      /**
       * Selects an appropriate tick value for the axis.  The strategy is to
       * display as many ticks as possible (selected from an array of 'standard'
       * tick units) without the labels overlapping.
       *
       * @param g2  the graphics device.
       * @param dataArea  the area defined by the axes.
       * @param edge  the axis location.
       *
       * @since 1.0.7
       */
     protected void selectHorizontalAutoTickUnit(Graphics2D g2,
             Rectangle2D dataArea, RectangleEdge edge) {
  
          double tickLabelWidth = estimateMaximumTickLabelWidth(g2,
                  getTickUnit());
  
          // start with the current tick unit...
          TickUnitSource tickUnits = getStandardTickUnits();
          TickUnit unit1 = tickUnits.getCeilingTickUnit(getTickUnit());
          double unit1Width = exponentLengthToJava2D(unit1.getSize(), dataArea,
                  edge);
  
          // then extrapolate...
          double guess = (tickLabelWidth / unit1Width) * unit1.getSize();
  
          NumberTickUnit unit2 = (NumberTickUnit)
                  tickUnits.getCeilingTickUnit(guess);
          double unit2Width = exponentLengthToJava2D(unit2.getSize(), dataArea,
                  edge);
  
          tickLabelWidth = estimateMaximumTickLabelWidth(g2, unit2);
          if (tickLabelWidth > unit2Width) {
              unit2 = (NumberTickUnit) tickUnits.getLargerTickUnit(unit2);
          }
  
          setTickUnit(unit2, false, false);
  
      }
  
      /**
       * Converts a length in data coordinates into the corresponding length in
       * Java2D coordinates.
       *
       * @param length  the length.
       * @param area  the plot area.
       * @param edge  the edge along which the axis lies.
       *
       * @return The length in Java2D coordinates.
       *
       * @since 1.0.7
       */
      public double exponentLengthToJava2D(double length, Rectangle2D area,
                                  RectangleEdge edge) {
          double one = valueToJava2D(calculateValue(1.0), area, edge);
          double l = valueToJava2D(calculateValue(length + 1.0), area, edge);
          return Math.abs(l - one);
      }
  
      /**
       * Selects an appropriate tick value for the axis.  The strategy is to
       * display as many ticks as possible (selected from an array of 'standard'
       * tick units) without the labels overlapping.
       *
       * @param g2  the graphics device.
       * @param dataArea  the area in which the plot should be drawn.
       * @param edge  the axis location.
       *
       * @since 1.0.7
       */
      protected void selectVerticalAutoTickUnit(Graphics2D g2,
                                                Rectangle2D dataArea,
                                                RectangleEdge edge) {
  
          double tickLabelHeight = estimateMaximumTickLabelHeight(g2);
  
          // start with the current tick unit...
          TickUnitSource tickUnits = getStandardTickUnits();
          TickUnit unit1 = tickUnits.getCeilingTickUnit(getTickUnit());
          double unitHeight = exponentLengthToJava2D(unit1.getSize(), dataArea,
                  edge);
  
          // then extrapolate...
          double guess = (tickLabelHeight / unitHeight) * unit1.getSize();
  
          NumberTickUnit unit2 = (NumberTickUnit)
                  tickUnits.getCeilingTickUnit(guess);
          double unit2Height = exponentLengthToJava2D(unit2.getSize(), dataArea,
                  edge);
  
          tickLabelHeight = estimateMaximumTickLabelHeight(g2);
          if (tickLabelHeight > unit2Height) {
              unit2 = (NumberTickUnit) tickUnits.getLargerTickUnit(unit2);
          }
  
          setTickUnit(unit2, false, false);
  
      }
  
      /**
       * Estimates the maximum tick label height.
       *
       * @param g2  the graphics device.
       *
       * @return The maximum height.
       *
       * @since 1.0.7
       */
      protected double estimateMaximumTickLabelHeight(Graphics2D g2) {
  
          RectangleInsets tickLabelInsets = getTickLabelInsets();
          double result = tickLabelInsets.getTop() + tickLabelInsets.getBottom();
  
          Font tickLabelFont = getTickLabelFont();
          FontRenderContext frc = g2.getFontRenderContext();
          result += tickLabelFont.getLineMetrics("123", frc).getHeight();
          return result;
  
      }
  
      /**
       * Estimates the maximum width of the tick labels, assuming the specified
       * tick unit is used.
       * <P>
       * Rather than computing the string bounds of every tick on the axis, we
       * just look at two values: the lower bound and the upper bound for the
       * axis.  These two values will usually be representative.
       *
       * @param g2  the graphics device.
       * @param unit  the tick unit to use for calculation.
       *
       * @return The estimated maximum width of the tick labels.
       *
       * @since 1.0.7
       */
      protected double estimateMaximumTickLabelWidth(Graphics2D g2,
                                                     TickUnit unit) {
  
          RectangleInsets tickLabelInsets = getTickLabelInsets();
          double result = tickLabelInsets.getLeft() + tickLabelInsets.getRight();
  
          if (isVerticalTickLabels()) {
              // all tick labels have the same width (equal to the height of the
              // font)...
              FontRenderContext frc = g2.getFontRenderContext();
              LineMetrics lm = getTickLabelFont().getLineMetrics("0", frc);
              result += lm.getHeight();
          }
          else {
              // look at lower and upper bounds...
              FontMetrics fm = g2.getFontMetrics(getTickLabelFont());
              Range range = getRange();
              double lower = range.getLowerBound();
              double upper = range.getUpperBound();
              String lowerStr, upperStr;
              NumberFormat formatter = getNumberFormatOverride();
              if (formatter != null) {
                  lowerStr = formatter.format(lower);
                  upperStr = formatter.format(upper);
              }
              else {
                  lowerStr = unit.valueToString(lower);
                  upperStr = unit.valueToString(upper);
              }
              double w1 = fm.stringWidth(lowerStr);
              double w2 = fm.stringWidth(upperStr);
              result += Math.max(w1, w2);
          }
  
          return result;
  
      }
  
      /**
       * Zooms in on the current range.
       *
       * @param lowerPercent  the new lower bound.
       * @param upperPercent  the new upper bound.
       */
      @Override
      public void zoomRange(double lowerPercent, double upperPercent) {
          Range range = getRange();
          double start = range.getLowerBound();
          double end = range.getUpperBound();
          double log1 = calculateLog(start);
          double log2 = calculateLog(end);
          double length = log2 - log1;
          Range adjusted;
          if (isInverted()) {
              double logA = log1 + length * (1 - upperPercent);
              double logB = log1 + length * (1 - lowerPercent);
              adjusted = new Range(calculateValue(logA), calculateValue(logB));
          }
          else {
              double logA = log1 + length * lowerPercent;
              double logB = log1 + length * upperPercent;
              adjusted = new Range(calculateValue(logA), calculateValue(logB));
          }
          setRange(adjusted);
      }
  
      /**
       * Slides the axis range by the specified percentage.
       *
       * @param percent  the percentage.
       *
       * @since 1.0.13
       */
      @Override
      public void pan(double percent) {
          Range range = getRange();
          double lower = range.getLowerBound();
          double upper = range.getUpperBound();
          double log1 = calculateLog(lower);
          double log2 = calculateLog(upper);
          double length = log2 - log1;
          double adj = length * percent;
          log1 = log1 + adj;
          log2 = log2 + adj;
          setRange(calculateValue(log1), calculateValue(log2));
      }
  
      /**
       * Creates a tick label for the specified value.  Note that this method
       * was 'private' prior to version 1.0.10.
       *
       * @param value  the value.
       *
       * @return The label.
       *
       * @since 1.0.10
       */
      protected String createTickLabel(double value) {
          if (this.numberFormatOverride != null) {
              return this.numberFormatOverride.format(value);
          }
          else {
              return this.tickUnit.valueToString(value);
          }
      }
  
      /**
       * Tests this axis for equality with an arbitrary object.
       *
       * @param obj  the object (<code>null</code> permitted).
       *
       * @return A boolean.
       */
      @Override
      public boolean equals(Object obj) {
          if (obj == this) {
              return true;
          }
          if (!(obj instanceof LogAxis)) {
              return false;
          }
          LogAxis that = (LogAxis) obj;
          if (this.base != that.base) {
              return false;
          }
          if (this.smallestValue != that.smallestValue) {
              return false;
          }
          return super.equals(obj);
      }
  
      /**
       * Returns a hash code for this instance.
       *
       * @return A hash code.
       */
      @Override
      public int hashCode() {
          int result = 193;
          long temp = Double.doubleToLongBits(this.base);
          result = 37 * result + (int) (temp ^ (temp >>> 32));
          temp = Double.doubleToLongBits(this.smallestValue);
          result = 37 * result + (int) (temp ^ (temp >>> 32));
          if (this.numberFormatOverride != null) {
              result = 37 * result + this.numberFormatOverride.hashCode();
          }
          result = 37 * result + this.tickUnit.hashCode();
          return result;
      }
  
      /**
       * Returns a collection of tick units for log (base 10) values.
       * Uses a given Locale to create the DecimalFormats.
       *
       * @param locale the locale to use to represent Numbers.
       *
       * @return A collection of tick units for integer values.
       *
       * @since 1.0.7
       */
      public static TickUnitSource createLogTickUnits(Locale locale) {
          TickUnits units = new TickUnits();
          NumberFormat numberFormat = new LogFormat();
          units.add(new NumberTickUnit(0.05, numberFormat, 2));
          units.add(new NumberTickUnit(0.1, numberFormat, 10));
          units.add(new NumberTickUnit(0.2, numberFormat, 2));
          units.add(new NumberTickUnit(0.5, numberFormat, 5));
          units.add(new NumberTickUnit(1, numberFormat, 10));
          units.add(new NumberTickUnit(2, numberFormat, 10));
          units.add(new NumberTickUnit(3, numberFormat, 15));
          units.add(new NumberTickUnit(4, numberFormat, 20));
          units.add(new NumberTickUnit(5, numberFormat, 25));
          units.add(new NumberTickUnit(6, numberFormat));
          units.add(new NumberTickUnit(7, numberFormat));
          units.add(new NumberTickUnit(8, numberFormat));
          units.add(new NumberTickUnit(9, numberFormat));
          units.add(new NumberTickUnit(10, numberFormat));
          return units;
      }
  
  }
  