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 060 package org.jfree.chart.axis; 061 062 import java.awt.Font; 063 import java.awt.FontMetrics; 064 import java.awt.Graphics2D; 065 import java.awt.font.FontRenderContext; 066 import java.awt.font.LineMetrics; 067 import java.awt.geom.Rectangle2D; 068 import java.text.DecimalFormat; 069 import java.text.NumberFormat; 070 import java.util.ArrayList; 071 import java.util.List; 072 import java.util.Locale; 073 074 import org.jfree.chart.event.AxisChangeEvent; 075 import org.jfree.chart.plot.Plot; 076 import org.jfree.chart.plot.PlotRenderingInfo; 077 import org.jfree.chart.plot.ValueAxisPlot; 078 import org.jfree.chart.util.LogFormat; 079 import org.jfree.data.Range; 080 import org.jfree.ui.RectangleEdge; 081 import org.jfree.ui.RectangleInsets; 082 import 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 */ 090 public 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 }