| Frames | No Frames |
1: /* =========================================================== 2: * JFreeChart : a free chart library for the Java(tm) platform 3: * =========================================================== 4: * 5: * (C) Copyright 2000-2007, by Object Refinery Limited and Contributors. 6: * 7: * Project Info: http://www.jfree.org/jfreechart/index.html 8: * 9: * This library is free software; you can redistribute it and/or modify it 10: * under the terms of the GNU Lesser General Public License as published by 11: * the Free Software Foundation; either version 2.1 of the License, or 12: * (at your option) any later version. 13: * 14: * This library is distributed in the hope that it will be useful, but 15: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 16: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 17: * License for more details. 18: * 19: * You should have received a copy of the GNU Lesser General Public 20: * License along with this library; if not, write to the Free Software 21: * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 22: * USA. 23: * 24: * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 25: * in the United States and other countries.] 26: * 27: * ------------------------- 28: * CategoryItemRenderer.java 29: * ------------------------- 30: * 31: * (C) Copyright 2001-2007, by Object Refinery Limited and Contributors. 32: * 33: * Original Author: David Gilbert (for Object Refinery Limited); 34: * Contributor(s): Mark Watson (www.markwatson.com); 35: * 36: * $Id: CategoryItemRenderer.java,v 1.10.2.2 2007/02/20 15:38:56 mungady Exp $ 37: * 38: * Changes 39: * ------- 40: * 23-Oct-2001 : Version 1 (DG); 41: * 16-Jan-2002 : Renamed HorizontalCategoryItemRenderer.java 42: * --> CategoryItemRenderer.java (DG); 43: * 05-Feb-2002 : Changed return type of the drawCategoryItem method from void 44: * to Shape, as part of the tooltips implementation (DG) 45: * 46: * NOTE (30-May-2002) : this has subsequently been changed back 47: * to void, tooltips are now collected along with entities in 48: * ChartRenderingInfo (DG); 49: * 50: * 14-Mar-2002 : Added the initialise method, and changed all bar plots to use 51: * this renderer (DG); 52: * 23-May-2002 : Added ChartRenderingInfo to the initialise method (DG); 53: * 29-May-2002 : Added the getAxisArea(Rectangle2D) method (DG); 54: * 06-Jun-2002 : Updated Javadoc comments (DG); 55: * 26-Jun-2002 : Added range axis to the initialise method (DG); 56: * 24-Sep-2002 : Added getLegendItem() method (DG); 57: * 23-Oct-2002 : Added methods to get/setToolTipGenerator (DG); 58: * 05-Nov-2002 : Replaced references to CategoryDataset with TableDataset (DG); 59: * 06-Nov-2002 : Added the domain axis to the drawCategoryItem method. Renamed 60: * drawCategoryItem() --> drawItem() (DG); 61: * 20-Nov-2002 : Changed signature of drawItem() method to reflect use of 62: * TableDataset (DG); 63: * 26-Nov-2002 : Replaced the isStacked() method with the getRangeType() 64: * method (DG); 65: * 08-Jan-2003 : Changed getSeriesCount() --> getRowCount() and 66: * getCategoryCount() --> getColumnCount() (DG); 67: * 09-Jan-2003 : Changed name of grid-line methods (DG); 68: * 21-Jan-2003 : Merged TableDataset with CategoryDataset (DG); 69: * 10-Apr-2003 : Changed CategoryDataset to KeyedValues2DDataset in 70: * drawItem() method (DG); 71: * 29-Apr-2003 : Eliminated Renderer interface (DG); 72: * 02-Sep-2003 : Fix for bug 790407 (DG); 73: * 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG); 74: * 20-Oct-2003 : Added setOutlinePaint() method (DG); 75: * 06-Feb-2004 : Added missing methods, and moved deprecated methods (DG); 76: * 19-Feb-2004 : Added extra setXXXLabelsVisible() methods (DG); 77: * 29-Apr-2004 : Changed Integer --> int in initialise() method (DG); 78: * 18-May-2004 : Added methods for item label paint (DG); 79: * 05-Nov-2004 : Added getPassCount() method and 'pass' parameter to drawItem() 80: * method (DG); 81: * 07-Jan-2005 : Renamed getRangeExtent() --> findRangeBounds (DG); 82: * 11-Jan-2005 : Removed deprecated code in preparation for 1.0.0 release (DG); 83: * 23-Feb-2005 : Now extends LegendItemSource (DG); 84: * 20-Apr-2005 : Renamed CategoryLabelGenerator 85: * --> CategoryItemLabelGenerator (DG); 86: * 20-May-2005 : Added drawDomainMarker() method (DG); 87: * ------------- JFREECHART 1.0.x --------------------------------------------- 88: * 20-Feb-2007 : Updated API docs (DG); 89: * 90: */ 91: 92: package org.jfree.chart.renderer.category; 93: 94: import java.awt.Font; 95: import java.awt.Graphics2D; 96: import java.awt.Paint; 97: import java.awt.Shape; 98: import java.awt.Stroke; 99: import java.awt.geom.Rectangle2D; 100: 101: import org.jfree.chart.LegendItem; 102: import org.jfree.chart.LegendItemSource; 103: import org.jfree.chart.axis.CategoryAxis; 104: import org.jfree.chart.axis.ValueAxis; 105: import org.jfree.chart.event.RendererChangeEvent; 106: import org.jfree.chart.event.RendererChangeListener; 107: import org.jfree.chart.labels.CategoryItemLabelGenerator; 108: import org.jfree.chart.labels.CategoryToolTipGenerator; 109: import org.jfree.chart.labels.ItemLabelPosition; 110: import org.jfree.chart.plot.CategoryMarker; 111: import org.jfree.chart.plot.CategoryPlot; 112: import org.jfree.chart.plot.Marker; 113: import org.jfree.chart.plot.PlotRenderingInfo; 114: import org.jfree.chart.urls.CategoryURLGenerator; 115: import org.jfree.data.Range; 116: import org.jfree.data.category.CategoryDataset; 117: 118: /** 119: * A plug-in object that is used by the {@link CategoryPlot} class to display 120: * individual data items from a {@link CategoryDataset}. 121: * <p> 122: * This interface defines the methods that must be provided by all renderers. 123: * If you are implementing a custom renderer, you should consider extending the 124: * {@link AbstractCategoryItemRenderer} class. 125: * <p> 126: * Most renderer attributes are defined using a "three layer" approach. When 127: * looking up an attribute (for example, the outline paint) the renderer first 128: * checks to see if there is a setting (in layer 0) that applies to ALL items 129: * that the renderer draws. If there is, that setting is used, but if it is 130: * <code>null</code> the renderer looks up the next layer, which contains 131: * "per series" settings for the attribute (many attributes are defined on a 132: * per series basis, so this is the layer that is most commonly used). If the 133: * layer 1 setting is <code>null</code>, the renderer will look up the final 134: * layer, which provides a default or "base" setting. Some attributes allow 135: * the base setting to be <code>null</code>, while other attributes enforce 136: * non-<code>null</code> values. 137: */ 138: 139: public interface CategoryItemRenderer extends LegendItemSource { 140: 141: /** 142: * Returns the number of passes through the dataset required by the 143: * renderer. Usually this will be one, but some renderers may use 144: * a second or third pass to overlay items on top of things that were 145: * drawn in an earlier pass. 146: * 147: * @return The pass count. 148: */ 149: public int getPassCount(); 150: 151: /** 152: * Returns the plot that the renderer has been assigned to (where 153: * <code>null</code> indicates that the renderer is not currently assigned 154: * to a plot). 155: * 156: * @return The plot (possibly <code>null</code>). 157: * 158: * @see #setPlot(CategoryPlot) 159: */ 160: public CategoryPlot getPlot(); 161: 162: /** 163: * Sets the plot that the renderer has been assigned to. This method is 164: * usually called by the {@link CategoryPlot}, in normal usage you 165: * shouldn't need to call this method directly. 166: * 167: * @param plot the plot (<code>null</code> not permitted). 168: * 169: * @see #getPlot() 170: */ 171: public void setPlot(CategoryPlot plot); 172: 173: /** 174: * Adds a change listener. 175: * 176: * @param listener the listener. 177: * 178: * @see #removeChangeListener(RendererChangeListener) 179: */ 180: public void addChangeListener(RendererChangeListener listener); 181: 182: /** 183: * Removes a change listener. 184: * 185: * @param listener the listener. 186: * 187: * @see #addChangeListener(RendererChangeListener) 188: */ 189: public void removeChangeListener(RendererChangeListener listener); 190: 191: /** 192: * Returns the range of values the renderer requires to display all the 193: * items from the specified dataset. 194: * 195: * @param dataset the dataset (<code>null</code> permitted). 196: * 197: * @return The range (or <code>null</code> if the dataset is 198: * <code>null</code> or empty). 199: */ 200: public Range findRangeBounds(CategoryDataset dataset); 201: 202: /** 203: * Initialises the renderer. This method will be called before the first 204: * item is rendered, giving the renderer an opportunity to initialise any 205: * state information it wants to maintain. The renderer can do nothing if 206: * it chooses. 207: * 208: * @param g2 the graphics device. 209: * @param dataArea the area inside the axes. 210: * @param plot the plot. 211: * @param rendererIndex the renderer index. 212: * @param info collects chart rendering information for return to caller. 213: * 214: * @return A state object (maintains state information relevant to one 215: * chart drawing). 216: */ 217: public CategoryItemRendererState initialise(Graphics2D g2, 218: Rectangle2D dataArea, 219: CategoryPlot plot, 220: int rendererIndex, 221: PlotRenderingInfo info); 222: 223: /** 224: * Returns a boolean that indicates whether or not the specified item 225: * should be drawn (this is typically used to hide an entire series). 226: * 227: * @param series the series index. 228: * @param item the item index. 229: * 230: * @return A boolean. 231: */ 232: public boolean getItemVisible(int series, int item); 233: 234: /** 235: * Returns a boolean that indicates whether or not the specified series 236: * should be drawn (this is typically used to hide an entire series). 237: * 238: * @param series the series index. 239: * 240: * @return A boolean. 241: */ 242: public boolean isSeriesVisible(int series); 243: 244: /** 245: * Returns the flag that controls the visibility of ALL series. This flag 246: * overrides the per series and default settings - you must set it to 247: * <code>null</code> if you want the other settings to apply. 248: * 249: * @return The flag (possibly <code>null</code>). 250: * 251: * @see #setSeriesVisible(Boolean) 252: */ 253: public Boolean getSeriesVisible(); 254: 255: /** 256: * Sets the flag that controls the visibility of ALL series and sends a 257: * {@link RendererChangeEvent} to all registered listeners. This flag 258: * overrides the per series and default settings - you must set it to 259: * <code>null</code> if you want the other settings to apply. 260: * 261: * @param visible the flag (<code>null</code> permitted). 262: * 263: * @see #getSeriesVisible() 264: */ 265: public void setSeriesVisible(Boolean visible); 266: 267: /** 268: * Sets the flag that controls the visibility of ALL series and sends a 269: * {@link RendererChangeEvent} to all registered listeners. This flag 270: * overrides the per series and default settings - you must set it to 271: * <code>null</code> if you want the other settings to apply. 272: * 273: * @param visible the flag (<code>null</code> permitted). 274: * @param notify notify listeners? 275: * 276: * @see #getSeriesVisible() 277: */ 278: public void setSeriesVisible(Boolean visible, boolean notify); 279: 280: /** 281: * Returns the flag that controls whether a series is visible. 282: * 283: * @param series the series index (zero-based). 284: * 285: * @return The flag (possibly <code>null</code>). 286: * 287: * @see #setSeriesVisible(int, Boolean) 288: */ 289: public Boolean getSeriesVisible(int series); 290: 291: /** 292: * Sets the flag that controls whether a series is visible and sends a 293: * {@link RendererChangeEvent} to all registered listeners. 294: * 295: * @param series the series index (zero-based). 296: * @param visible the flag (<code>null</code> permitted). 297: * 298: * @see #getSeriesVisible(int) 299: */ 300: public void setSeriesVisible(int series, Boolean visible); 301: 302: /** 303: * Sets the flag that controls whether a series is visible and, if 304: * requested, sends a {@link RendererChangeEvent} to all registered 305: * listeners. 306: * 307: * @param series the series index. 308: * @param visible the flag (<code>null</code> permitted). 309: * @param notify notify listeners? 310: * 311: * @see #getSeriesVisible(int) 312: */ 313: public void setSeriesVisible(int series, Boolean visible, boolean notify); 314: 315: /** 316: * Returns the base visibility for all series. 317: * 318: * @return The base visibility. 319: * 320: * @see #setBaseSeriesVisible(boolean) 321: */ 322: public boolean getBaseSeriesVisible(); 323: 324: /** 325: * Sets the base visibility and sends a {@link RendererChangeEvent} to all 326: * registered listeners. 327: * 328: * @param visible the flag. 329: * 330: * @see #getBaseSeriesVisible() 331: */ 332: public void setBaseSeriesVisible(boolean visible); 333: 334: /** 335: * Sets the base visibility and, if requested, sends 336: * a {@link RendererChangeEvent} to all registered listeners. 337: * 338: * @param visible the visibility. 339: * @param notify notify listeners? 340: * 341: * @see #getBaseSeriesVisible() 342: */ 343: public void setBaseSeriesVisible(boolean visible, boolean notify); 344: 345: // SERIES VISIBLE IN LEGEND (not yet respected by all renderers) 346: 347: /** 348: * Returns <code>true</code> if the series should be shown in the legend, 349: * and <code>false</code> otherwise. 350: * 351: * @param series the series index. 352: * 353: * @return A boolean. 354: */ 355: public boolean isSeriesVisibleInLegend(int series); 356: 357: /** 358: * Returns the flag that controls the visibility of ALL series in the 359: * legend. This flag overrides the per series and default settings - you 360: * must set it to <code>null</code> if you want the other settings to 361: * apply. 362: * 363: * @return The flag (possibly <code>null</code>). 364: * 365: * @see #setSeriesVisibleInLegend(Boolean) 366: */ 367: public Boolean getSeriesVisibleInLegend(); 368: 369: /** 370: * Sets the flag that controls the visibility of ALL series in the legend 371: * and sends a {@link RendererChangeEvent} to all registered listeners. 372: * This flag overrides the per series and default settings - you must set 373: * it to <code>null</code> if you want the other settings to apply. 374: * 375: * @param visible the flag (<code>null</code> permitted). 376: * 377: * @see #getSeriesVisibleInLegend() 378: */ 379: public void setSeriesVisibleInLegend(Boolean visible); 380: 381: /** 382: * Sets the flag that controls the visibility of ALL series in the legend 383: * and sends a {@link RendererChangeEvent} to all registered listeners. 384: * This flag overrides the per series and default settings - you must set 385: * it to <code>null</code> if you want the other settings to apply. 386: * 387: * @param visible the flag (<code>null</code> permitted). 388: * @param notify notify listeners? 389: * 390: * @see #getSeriesVisibleInLegend() 391: */ 392: public void setSeriesVisibleInLegend(Boolean visible, boolean notify); 393: 394: /** 395: * Returns the flag that controls whether a series is visible in the 396: * legend. This method returns only the "per series" settings - to 397: * incorporate the override and base settings as well, you need to use the 398: * {@link #isSeriesVisibleInLegend(int)} method. 399: * 400: * @param series the series index (zero-based). 401: * 402: * @return The flag (possibly <code>null</code>). 403: * 404: * @see #setSeriesVisibleInLegend(int, Boolean) 405: */ 406: public Boolean getSeriesVisibleInLegend(int series); 407: 408: /** 409: * Sets the flag that controls whether a series is visible in the legend 410: * and sends a {@link RendererChangeEvent} to all registered listeners. 411: * 412: * @param series the series index (zero-based). 413: * @param visible the flag (<code>null</code> permitted). 414: * 415: * @see #getSeriesVisibleInLegend(int) 416: */ 417: public void setSeriesVisibleInLegend(int series, Boolean visible); 418: 419: /** 420: * Sets the flag that controls whether a series is visible in the legend 421: * and, if requested, sends a {@link RendererChangeEvent} to all registered 422: * listeners. 423: * 424: * @param series the series index. 425: * @param visible the flag (<code>null</code> permitted). 426: * @param notify notify listeners? 427: * 428: * @see #getSeriesVisibleInLegend(int) 429: */ 430: public void setSeriesVisibleInLegend(int series, Boolean visible, 431: boolean notify); 432: 433: /** 434: * Returns the base visibility in the legend for all series. 435: * 436: * @return The base visibility. 437: * 438: * @see #setBaseSeriesVisibleInLegend(boolean) 439: */ 440: public boolean getBaseSeriesVisibleInLegend(); 441: 442: /** 443: * Sets the base visibility in the legend and sends a 444: * {@link RendererChangeEvent} to all registered listeners. 445: * 446: * @param visible the flag. 447: * 448: * @see #getBaseSeriesVisibleInLegend() 449: */ 450: public void setBaseSeriesVisibleInLegend(boolean visible); 451: 452: /** 453: * Sets the base visibility in the legend and, if requested, sends 454: * a {@link RendererChangeEvent} to all registered listeners. 455: * 456: * @param visible the visibility. 457: * @param notify notify listeners? 458: * 459: * @see #getBaseSeriesVisibleInLegend() 460: */ 461: public void setBaseSeriesVisibleInLegend(boolean visible, boolean notify); 462: 463: 464: //// PAINT ///////////////////////////////////////////////////////////////// 465: 466: /** 467: * Returns the paint used to fill data items as they are drawn. 468: * 469: * @param row the row (or series) index (zero-based). 470: * @param column the column (or category) index (zero-based). 471: * 472: * @return The paint (never <code>null</code>). 473: */ 474: public Paint getItemPaint(int row, int column); 475: 476: // FIXME: Why no getPaint() method? Probably just an oversight. 477: 478: /** 479: * Sets the paint to be used for ALL series, and sends a 480: * {@link RendererChangeEvent} to all registered listeners. If this is 481: * <code>null</code>, the renderer will use the paint for the series. 482: * 483: * @param paint the paint (<code>null</code> permitted). 484: */ 485: public void setPaint(Paint paint); 486: 487: /** 488: * Returns the paint used to fill an item drawn by the renderer. 489: * 490: * @param series the series index (zero-based). 491: * 492: * @return The paint (never <code>null</code>). 493: * 494: * @see #setSeriesPaint(int, Paint) 495: */ 496: public Paint getSeriesPaint(int series); 497: 498: /** 499: * Sets the paint used for a series and sends a {@link RendererChangeEvent} 500: * to all registered listeners. 501: * 502: * @param series the series index (zero-based). 503: * @param paint the paint (<code>null</code> permitted). 504: * 505: * @see #getSeriesPaint(int) 506: */ 507: public void setSeriesPaint(int series, Paint paint); 508: 509: /** 510: * Returns the base paint. 511: * 512: * @return The base paint (never <code>null</code>). 513: * 514: * @see #setBasePaint(Paint) 515: */ 516: public Paint getBasePaint(); 517: 518: /** 519: * Sets the base paint and sends a {@link RendererChangeEvent} to all 520: * registered listeners. 521: * 522: * @param paint the paint (<code>null</code> not permitted). 523: * 524: * @see #getBasePaint() 525: */ 526: public void setBasePaint(Paint paint); 527: 528: //// OUTLINE PAINT ///////////////////////////////////////////////////////// 529: 530: /** 531: * Returns the paint used to outline data items as they are drawn. 532: * 533: * @param row the row (or series) index (zero-based). 534: * @param column the column (or category) index (zero-based). 535: * 536: * @return The paint (never <code>null</code>). 537: */ 538: public Paint getItemOutlinePaint(int row, int column); 539: 540: // FIXME: Why no getOutlinePaint? Probably just an oversight. 541: 542: /** 543: * Sets the outline paint for ALL series (optional). 544: * 545: * @param paint the paint (<code>null</code> permitted). 546: */ 547: public void setOutlinePaint(Paint paint); 548: 549: /** 550: * Returns the paint used to outline an item drawn by the renderer. 551: * 552: * @param series the series (zero-based index). 553: * 554: * @return The paint (never <code>null</code>). 555: * 556: * @see #setSeriesOutlinePaint(int, Paint) 557: */ 558: public Paint getSeriesOutlinePaint(int series); 559: 560: /** 561: * Sets the paint used for a series outline and sends a 562: * {@link RendererChangeEvent} to all registered listeners. 563: * 564: * @param series the series index (zero-based). 565: * @param paint the paint (<code>null</code> permitted). 566: * 567: * @see #getSeriesOutlinePaint(int) 568: */ 569: public void setSeriesOutlinePaint(int series, Paint paint); 570: 571: /** 572: * Returns the base outline paint. 573: * 574: * @return The paint (never <code>null</code>). 575: * 576: * @see #setBaseOutlinePaint(Paint) 577: */ 578: public Paint getBaseOutlinePaint(); 579: 580: /** 581: * Sets the base outline paint and sends a {@link RendererChangeEvent} to 582: * all registered listeners. 583: * 584: * @param paint the paint (<code>null</code> not permitted). 585: * 586: * @see #getBaseOutlinePaint() 587: */ 588: public void setBaseOutlinePaint(Paint paint); 589: 590: //// STROKE //////////////////////////////////////////////////////////////// 591: 592: /** 593: * Returns the stroke used to draw data items. 594: * 595: * @param row the row (or series) index (zero-based). 596: * @param column the column (or category) index (zero-based). 597: * 598: * @return The stroke (never <code>null</code>). 599: */ 600: public Stroke getItemStroke(int row, int column); 601: 602: // FIXME: Why no getStroke? Probably just an oversight. 603: 604: /** 605: * Sets the stroke for ALL series and sends a {@link RendererChangeEvent} 606: * to all registered listeners. 607: * 608: * @param stroke the stroke (<code>null</code> permitted). 609: */ 610: public void setStroke(Stroke stroke); 611: 612: /** 613: * Returns the stroke used to draw the items in a series. 614: * 615: * @param series the series (zero-based index). 616: * 617: * @return The stroke (never <code>null</code>). 618: * 619: * @see #setSeriesStroke(int, Stroke) 620: */ 621: public Stroke getSeriesStroke(int series); 622: 623: /** 624: * Sets the stroke used for a series and sends a 625: * {@link RendererChangeEvent} to all registered listeners. 626: * 627: * @param series the series index (zero-based). 628: * @param stroke the stroke (<code>null</code> permitted). 629: * 630: * @see #getSeriesStroke(int) 631: */ 632: public void setSeriesStroke(int series, Stroke stroke); 633: 634: /** 635: * Returns the base stroke. 636: * 637: * @return The base stroke (never <code>null</code>). 638: * 639: * @see #setBaseStroke(Stroke) 640: */ 641: public Stroke getBaseStroke(); 642: 643: /** 644: * Sets the base stroke and sends a {@link RendererChangeEvent} to all 645: * registered listeners. 646: * 647: * @param stroke the stroke (<code>null</code> not permitted). 648: * 649: * @see #getBaseStroke() 650: */ 651: public void setBaseStroke(Stroke stroke); 652: 653: //// OUTLINE STROKE //////////////////////////////////////////////////////// 654: 655: /** 656: * Returns the stroke used to outline data items. 657: * <p> 658: * The default implementation passes control to the getSeriesOutlineStroke 659: * method. You can override this method if you require different behaviour. 660: * 661: * @param row the row (or series) index (zero-based). 662: * @param column the column (or category) index (zero-based). 663: * 664: * @return The stroke (never <code>null</code>). 665: */ 666: public Stroke getItemOutlineStroke(int row, int column); 667: 668: // FIXME: Why no getOutlineStroke? Probably just an oversight. 669: 670: /** 671: * Sets the outline stroke for ALL series and sends a 672: * {@link RendererChangeEvent} to all registered listeners. 673: * 674: * @param stroke the stroke (<code>null</code> permitted). 675: */ 676: public void setOutlineStroke(Stroke stroke); 677: 678: /** 679: * Returns the stroke used to outline the items in a series. 680: * 681: * @param series the series (zero-based index). 682: * 683: * @return The stroke (never <code>null</code>). 684: * 685: * @see #setSeriesOutlineStroke(int, Stroke) 686: */ 687: public Stroke getSeriesOutlineStroke(int series); 688: 689: /** 690: * Sets the outline stroke used for a series and sends a 691: * {@link RendererChangeEvent} to all registered listeners. 692: * 693: * @param series the series index (zero-based). 694: * @param stroke the stroke (<code>null</code> permitted). 695: * 696: * @see #getSeriesOutlineStroke(int) 697: */ 698: public void setSeriesOutlineStroke(int series, Stroke stroke); 699: 700: /** 701: * Returns the base outline stroke. 702: * 703: * @return The stroke (never <code>null</code>). 704: * 705: * @see #setBaseOutlineStroke(Stroke) 706: */ 707: public Stroke getBaseOutlineStroke(); 708: 709: /** 710: * Sets the base outline stroke and sends a {@link RendererChangeEvent} to 711: * all registered listeners. 712: * 713: * @param stroke the stroke (<code>null</code> not permitted). 714: * 715: * @see #getBaseOutlineStroke() 716: */ 717: public void setBaseOutlineStroke(Stroke stroke); 718: 719: //// SHAPE ///////////////////////////////////////////////////////////////// 720: 721: /** 722: * Returns a shape used to represent a data item. 723: * 724: * @param row the row (or series) index (zero-based). 725: * @param column the column (or category) index (zero-based). 726: * 727: * @return The shape (never <code>null</code>). 728: */ 729: public Shape getItemShape(int row, int column); 730: 731: // FIXME: Why no getShape()? Probably just an oversight. 732: 733: /** 734: * Sets the shape for ALL series (optional) and sends a 735: * {@link RendererChangeEvent} to all registered listeners. 736: * 737: * @param shape the shape (<code>null</code> permitted). 738: */ 739: public void setShape(Shape shape); 740: 741: /** 742: * Returns a shape used to represent the items in a series. 743: * 744: * @param series the series (zero-based index). 745: * 746: * @return The shape (never <code>null</code>). 747: * 748: * @see #setSeriesShape(int, Shape) 749: */ 750: public Shape getSeriesShape(int series); 751: 752: /** 753: * Sets the shape used for a series and sends a {@link RendererChangeEvent} 754: * to all registered listeners. 755: * 756: * @param series the series index (zero-based). 757: * @param shape the shape (<code>null</code> permitted). 758: * 759: * @see #getSeriesShape(int) 760: */ 761: public void setSeriesShape(int series, Shape shape); 762: 763: /** 764: * Returns the base shape. 765: * 766: * @return The shape (never <code>null</code>). 767: * 768: * @see #setBaseShape(Shape) 769: */ 770: public Shape getBaseShape(); 771: 772: /** 773: * Sets the base shape and sends a {@link RendererChangeEvent} to all 774: * registered listeners. 775: * 776: * @param shape the shape (<code>null</code> not permitted). 777: * 778: * @see #getBaseShape() 779: */ 780: public void setBaseShape(Shape shape); 781: 782: // ITEM LABELS VISIBLE 783: 784: /** 785: * Returns <code>true</code> if an item label is visible, and 786: * <code>false</code> otherwise. 787: * 788: * @param row the row index (zero-based). 789: * @param column the column index (zero-based). 790: * 791: * @return A boolean. 792: */ 793: public boolean isItemLabelVisible(int row, int column); 794: 795: // FIXME: Why no isItemLabelsVisible()? Probably just an oversight. 796: 797: /** 798: * Sets a flag that controls whether or not the item labels for ALL series 799: * are visible. 800: * 801: * @param visible the flag. 802: * 803: * @see #setItemLabelsVisible(Boolean) 804: */ 805: public void setItemLabelsVisible(boolean visible); 806: 807: /** 808: * Sets a flag that controls whether or not the item labels for ALL series 809: * are visible. 810: * 811: * @param visible the flag (<code>null</code> permitted). 812: * 813: * @see #setItemLabelsVisible(boolean) 814: */ 815: public void setItemLabelsVisible(Boolean visible); 816: 817: /** 818: * Sets the visibility of item labels for ALL series and, if requested, 819: * sends a {@link RendererChangeEvent} to all registered listeners. 820: * 821: * @param visible a flag that controls whether or not the item labels are 822: * visible (<code>null</code> permitted). 823: * @param notify a flag that controls whether or not listeners are 824: * notified. 825: */ 826: public void setItemLabelsVisible(Boolean visible, boolean notify); 827: 828: /** 829: * Returns <code>true</code> if the item labels for a series are visible, 830: * and <code>false</code> otherwise. 831: * 832: * @param series the series index (zero-based). 833: * 834: * @return A boolean. 835: * 836: * @see #setSeriesItemLabelsVisible(int, Boolean) 837: */ 838: public boolean isSeriesItemLabelsVisible(int series); 839: 840: /** 841: * Sets a flag that controls the visibility of the item labels for a series. 842: * 843: * @param series the series index (zero-based). 844: * @param visible the flag. 845: * 846: * @see #isSeriesItemLabelsVisible(int) 847: */ 848: public void setSeriesItemLabelsVisible(int series, boolean visible); 849: 850: /** 851: * Sets a flag that controls the visibility of the item labels for a series. 852: * 853: * @param series the series index (zero-based). 854: * @param visible the flag (<code>null</code> permitted). 855: * 856: * @see #isSeriesItemLabelsVisible(int) 857: */ 858: public void setSeriesItemLabelsVisible(int series, Boolean visible); 859: 860: /** 861: * Sets the visibility of item labels for a series and, if requested, sends 862: * a {@link RendererChangeEvent} to all registered listeners. 863: * 864: * @param series the series index (zero-based). 865: * @param visible the visible flag. 866: * @param notify a flag that controls whether or not listeners are 867: * notified. 868: * 869: * @see #isSeriesItemLabelsVisible(int) 870: */ 871: public void setSeriesItemLabelsVisible(int series, Boolean visible, 872: boolean notify); 873: 874: /** 875: * Returns the base setting for item label visibility. 876: * 877: * @return A flag (possibly <code>null</code>). 878: * 879: * @see #setBaseItemLabelsVisible(Boolean) 880: */ 881: public Boolean getBaseItemLabelsVisible(); 882: 883: /** 884: * Sets the base flag that controls whether or not item labels are visible. 885: * 886: * @param visible the flag. 887: * 888: * @see #getBaseItemLabelsVisible() 889: */ 890: public void setBaseItemLabelsVisible(boolean visible); 891: 892: /** 893: * Sets the base setting for item label visibility. 894: * 895: * @param visible the flag (<code>null</code> permitted). 896: * 897: * @see #getBaseItemLabelsVisible() 898: */ 899: public void setBaseItemLabelsVisible(Boolean visible); 900: 901: /** 902: * Sets the base visibility for item labels and, if requested, sends a 903: * {@link RendererChangeEvent} to all registered listeners. 904: * 905: * @param visible the visibility flag. 906: * @param notify a flag that controls whether or not listeners are 907: * notified. 908: * 909: * @see #getBaseItemLabelsVisible() 910: */ 911: public void setBaseItemLabelsVisible(Boolean visible, boolean notify); 912: 913: // ITEM LABEL GENERATOR 914: 915: /** 916: * Returns the item label generator for the specified data item. 917: * 918: * @param series the series index (zero-based). 919: * @param item the item index (zero-based). 920: * 921: * @return The generator (possibly <code>null</code>). 922: */ 923: public CategoryItemLabelGenerator getItemLabelGenerator(int series, 924: int item); 925: 926: // FIXME: Why no getItemLabelGenerator()? Probably just an oversight. 927: 928: /** 929: * Sets the item label generator for ALL series and sends a 930: * {@link RendererChangeEvent} to all registered listeners. This overrides 931: * the per-series settings. 932: * 933: * @param generator the generator (<code>null</code> permitted). 934: */ 935: public void setItemLabelGenerator(CategoryItemLabelGenerator generator); 936: 937: /** 938: * Returns the item label generator for a series. 939: * 940: * @param series the series index (zero-based). 941: * 942: * @return The label generator (possibly <code>null</code>). 943: * 944: * @see #setSeriesItemLabelGenerator(int, CategoryItemLabelGenerator) 945: */ 946: public CategoryItemLabelGenerator getSeriesItemLabelGenerator(int series); 947: 948: /** 949: * Sets the item label generator for a series and sends a 950: * {@link RendererChangeEvent} to all registered listeners. 951: * 952: * @param series the series index (zero-based). 953: * @param generator the generator. 954: * 955: * @see #getSeriesItemLabelGenerator(int) 956: */ 957: public void setSeriesItemLabelGenerator( 958: int series, CategoryItemLabelGenerator generator); 959: 960: /** 961: * Returns the base item label generator. 962: * 963: * @return The generator (possibly <code>null</code>). 964: * 965: * @see #setBaseItemLabelGenerator(CategoryItemLabelGenerator) 966: */ 967: public CategoryItemLabelGenerator getBaseItemLabelGenerator(); 968: 969: /** 970: * Sets the base item label generator and sends a 971: * {@link RendererChangeEvent} to all registered listeners. 972: * 973: * @param generator the generator (<code>null</code> permitted). 974: * 975: * @see #getBaseItemLabelGenerator() 976: */ 977: public void setBaseItemLabelGenerator(CategoryItemLabelGenerator generator); 978: 979: // TOOL TIP GENERATOR 980: 981: /** 982: * Returns the tool tip generator that should be used for the specified 983: * item. This method looks up the generator using the "three-layer" 984: * approach outlined in the general description of this interface. 985: * 986: * @param row the row index (zero-based). 987: * @param column the column index (zero-based). 988: * 989: * @return The generator (possibly <code>null</code>). 990: */ 991: public CategoryToolTipGenerator getToolTipGenerator(int row, int column); 992: 993: /** 994: * Returns the tool tip generator that will be used for ALL items in the 995: * dataset (the "layer 0" generator). 996: * 997: * @return A tool tip generator (possibly <code>null</code>). 998: * 999: * @see #setToolTipGenerator(CategoryToolTipGenerator) 1000: */ 1001: public CategoryToolTipGenerator getToolTipGenerator(); 1002: 1003: /** 1004: * Sets the tool tip generator for ALL series and sends a 1005: * {@link org.jfree.chart.event.RendererChangeEvent} to all registered 1006: * listeners. 1007: * 1008: * @param generator the generator (<code>null</code> permitted). 1009: * 1010: * @see #getToolTipGenerator() 1011: */ 1012: public void setToolTipGenerator(CategoryToolTipGenerator generator); 1013: 1014: /** 1015: * Returns the tool tip generator for the specified series (a "layer 1" 1016: * generator). 1017: * 1018: * @param series the series index (zero-based). 1019: * 1020: * @return The tool tip generator (possibly <code>null</code>). 1021: * 1022: * @see #setSeriesToolTipGenerator(int, CategoryToolTipGenerator) 1023: */ 1024: public CategoryToolTipGenerator getSeriesToolTipGenerator(int series); 1025: 1026: /** 1027: * Sets the tool tip generator for a series and sends a 1028: * {@link org.jfree.chart.event.RendererChangeEvent} to all registered 1029: * listeners. 1030: * 1031: * @param series the series index (zero-based). 1032: * @param generator the generator (<code>null</code> permitted). 1033: * 1034: * @see #getSeriesToolTipGenerator(int) 1035: */ 1036: public void setSeriesToolTipGenerator(int series, 1037: CategoryToolTipGenerator generator); 1038: 1039: /** 1040: * Returns the base tool tip generator (the "layer 2" generator). 1041: * 1042: * @return The tool tip generator (possibly <code>null</code>). 1043: * 1044: * @see #setBaseToolTipGenerator(CategoryToolTipGenerator) 1045: */ 1046: public CategoryToolTipGenerator getBaseToolTipGenerator(); 1047: 1048: /** 1049: * Sets the base tool tip generator and sends a 1050: * {@link org.jfree.chart.event.RendererChangeEvent} to all registered 1051: * listeners. 1052: * 1053: * @param generator the generator (<code>null</code> permitted). 1054: * 1055: * @see #getBaseToolTipGenerator() 1056: */ 1057: public void setBaseToolTipGenerator(CategoryToolTipGenerator generator); 1058: 1059: //// ITEM LABEL FONT ////////////////////////////////////////////////////// 1060: 1061: /** 1062: * Returns the font for an item label. 1063: * 1064: * @param row the row index (zero-based). 1065: * @param column the column index (zero-based). 1066: * 1067: * @return The font (never <code>null</code>). 1068: */ 1069: public Font getItemLabelFont(int row, int column); 1070: 1071: /** 1072: * Returns the font used for all item labels. This may be 1073: * <code>null</code>, in which case the per series font settings will apply. 1074: * 1075: * @return The font (possibly <code>null</code>). 1076: * 1077: * @see #setItemLabelFont(Font) 1078: */ 1079: public Font getItemLabelFont(); 1080: 1081: /** 1082: * Sets the item label font for ALL series and sends a 1083: * {@link RendererChangeEvent} to all registered listeners. You can set 1084: * this to <code>null</code> if you prefer to set the font on a per series 1085: * basis. 1086: * 1087: * @param font the font (<code>null</code> permitted). 1088: * 1089: * @see #getItemLabelFont() 1090: */ 1091: public void setItemLabelFont(Font font); 1092: 1093: /** 1094: * Returns the font for all the item labels in a series. 1095: * 1096: * @param series the series index (zero-based). 1097: * 1098: * @return The font (possibly <code>null</code>). 1099: * 1100: * @see #setSeriesItemLabelFont(int, Font) 1101: */ 1102: public Font getSeriesItemLabelFont(int series); 1103: 1104: /** 1105: * Sets the item label font for a series and sends a 1106: * {@link RendererChangeEvent} to all registered listeners. 1107: * 1108: * @param series the series index (zero-based). 1109: * @param font the font (<code>null</code> permitted). 1110: * 1111: * @see #getSeriesItemLabelFont(int) 1112: */ 1113: public void setSeriesItemLabelFont(int series, Font font); 1114: 1115: /** 1116: * Returns the base item label font (this is used when no other font 1117: * setting is available). 1118: * 1119: * @return The font (<code>never</code> null). 1120: * 1121: * @see #setBaseItemLabelFont(Font) 1122: */ 1123: public Font getBaseItemLabelFont(); 1124: 1125: /** 1126: * Sets the base item label font and sends a {@link RendererChangeEvent} 1127: * to all registered listeners. 1128: * 1129: * @param font the font (<code>null</code> not permitted). 1130: * 1131: * @see #getBaseItemLabelFont() 1132: */ 1133: public void setBaseItemLabelFont(Font font); 1134: 1135: //// ITEM LABEL PAINT ///////////////////////////////////////////////////// 1136: 1137: /** 1138: * Returns the paint used to draw an item label. 1139: * 1140: * @param row the row index (zero based). 1141: * @param column the column index (zero based). 1142: * 1143: * @return The paint (never <code>null</code>). 1144: */ 1145: public Paint getItemLabelPaint(int row, int column); 1146: 1147: /** 1148: * Returns the paint used for all item labels. This may be 1149: * <code>null</code>, in which case the per series paint settings will 1150: * apply. 1151: * 1152: * @return The paint (possibly <code>null</code>). 1153: * 1154: * @see #setItemLabelPaint(Paint) 1155: */ 1156: public Paint getItemLabelPaint(); 1157: 1158: /** 1159: * Sets the item label paint for ALL series and sends a 1160: * {@link RendererChangeEvent} to all registered listeners. 1161: * 1162: * @param paint the paint (<code>null</code> permitted). 1163: * 1164: * @see #getItemLabelPaint() 1165: */ 1166: public void setItemLabelPaint(Paint paint); 1167: 1168: /** 1169: * Returns the paint used to draw the item labels for a series. 1170: * 1171: * @param series the series index (zero based). 1172: * 1173: * @return The paint (possibly <code>null<code>). 1174: * 1175: * @see #setSeriesItemLabelPaint(int, Paint) 1176: */ 1177: public Paint getSeriesItemLabelPaint(int series); 1178: 1179: /** 1180: * Sets the item label paint for a series and sends a 1181: * {@link RendererChangeEvent} to all registered listeners. 1182: * 1183: * @param series the series (zero based index). 1184: * @param paint the paint (<code>null</code> permitted). 1185: * 1186: * @see #getSeriesItemLabelPaint(int) 1187: */ 1188: public void setSeriesItemLabelPaint(int series, Paint paint); 1189: 1190: /** 1191: * Returns the base item label paint. 1192: * 1193: * @return The paint (never <code>null<code>). 1194: * 1195: * @see #setBaseItemLabelPaint(Paint) 1196: */ 1197: public Paint getBaseItemLabelPaint(); 1198: 1199: /** 1200: * Sets the base item label paint and sends a {@link RendererChangeEvent} 1201: * to all registered listeners. 1202: * 1203: * @param paint the paint (<code>null</code> not permitted). 1204: * 1205: * @see #getBaseItemLabelPaint() 1206: */ 1207: public void setBaseItemLabelPaint(Paint paint); 1208: 1209: // POSITIVE ITEM LABEL POSITION... 1210: 1211: /** 1212: * Returns the item label position for positive values. 1213: * 1214: * @param row the row index (zero-based). 1215: * @param column the column index (zero-based). 1216: * 1217: * @return The item label position (never <code>null</code>). 1218: */ 1219: public ItemLabelPosition getPositiveItemLabelPosition(int row, int column); 1220: 1221: /** 1222: * Returns the item label position for positive values in ALL series. 1223: * 1224: * @return The item label position (possibly <code>null</code>). 1225: * 1226: * @see #setPositiveItemLabelPosition(ItemLabelPosition) 1227: */ 1228: public ItemLabelPosition getPositiveItemLabelPosition(); 1229: 1230: /** 1231: * Sets the item label position for positive values in ALL series, and 1232: * sends a {@link RendererChangeEvent} to all registered listeners. You 1233: * need to set this to <code>null</code> to expose the settings for 1234: * individual series. 1235: * 1236: * @param position the position (<code>null</code> permitted). 1237: * 1238: * @see #getPositiveItemLabelPosition() 1239: */ 1240: public void setPositiveItemLabelPosition(ItemLabelPosition position); 1241: 1242: /** 1243: * Sets the positive item label position for ALL series and (if requested) 1244: * sends a {@link RendererChangeEvent} to all registered listeners. 1245: * 1246: * @param position the position (<code>null</code> permitted). 1247: * @param notify notify registered listeners? 1248: * 1249: * @see #getPositiveItemLabelPosition() 1250: */ 1251: public void setPositiveItemLabelPosition(ItemLabelPosition position, 1252: boolean notify); 1253: 1254: /** 1255: * Returns the item label position for all positive values in a series. 1256: * 1257: * @param series the series index (zero-based). 1258: * 1259: * @return The item label position. 1260: * 1261: * @see #setSeriesPositiveItemLabelPosition(int, ItemLabelPosition) 1262: */ 1263: public ItemLabelPosition getSeriesPositiveItemLabelPosition(int series); 1264: 1265: /** 1266: * Sets the item label position for all positive values in a series and 1267: * sends a {@link RendererChangeEvent} to all registered listeners. 1268: * 1269: * @param series the series index (zero-based). 1270: * @param position the position (<code>null</code> permitted). 1271: * 1272: * @see #getSeriesPositiveItemLabelPosition(int) 1273: */ 1274: public void setSeriesPositiveItemLabelPosition(int series, 1275: ItemLabelPosition position); 1276: 1277: /** 1278: * Sets the item label position for all positive values in a series and (if 1279: * requested) sends a {@link RendererChangeEvent} to all registered 1280: * listeners. 1281: * 1282: * @param series the series index (zero-based). 1283: * @param position the position (<code>null</code> permitted). 1284: * @param notify notify registered listeners? 1285: * 1286: * @see #getSeriesPositiveItemLabelPosition(int) 1287: */ 1288: public void setSeriesPositiveItemLabelPosition(int series, 1289: ItemLabelPosition position, 1290: boolean notify); 1291: 1292: /** 1293: * Returns the base positive item label position. 1294: * 1295: * @return The position. 1296: * 1297: * @see #setBasePositiveItemLabelPosition(ItemLabelPosition) 1298: */ 1299: public ItemLabelPosition getBasePositiveItemLabelPosition(); 1300: 1301: /** 1302: * Sets the base positive item label position. 1303: * 1304: * @param position the position. 1305: * 1306: * @see #getBasePositiveItemLabelPosition() 1307: */ 1308: public void setBasePositiveItemLabelPosition(ItemLabelPosition position); 1309: 1310: /** 1311: * Sets the base positive item label position and, if requested, sends a 1312: * {@link RendererChangeEvent} to all registered listeners. 1313: * 1314: * @param position the position. 1315: * @param notify notify registered listeners? 1316: * 1317: * @see #getBasePositiveItemLabelPosition() 1318: */ 1319: public void setBasePositiveItemLabelPosition(ItemLabelPosition position, 1320: boolean notify); 1321: 1322: 1323: // NEGATIVE ITEM LABEL POSITION... 1324: 1325: /** 1326: * Returns the item label position for negative values. This method can be 1327: * overridden to provide customisation of the item label position for 1328: * individual data items. 1329: * 1330: * @param row the row index (zero-based). 1331: * @param column the column (zero-based). 1332: * 1333: * @return The item label position. 1334: */ 1335: public ItemLabelPosition getNegativeItemLabelPosition(int row, int column); 1336: 1337: /** 1338: * Returns the item label position for negative values in ALL series. 1339: * 1340: * @return The item label position (possibly <code>null</code>). 1341: * 1342: * @see #setNegativeItemLabelPosition(ItemLabelPosition) 1343: */ 1344: public ItemLabelPosition getNegativeItemLabelPosition(); 1345: 1346: /** 1347: * Sets the item label position for negative values in ALL series, and 1348: * sends a {@link RendererChangeEvent} to all registered listeners. You 1349: * need to set this to <code>null</code> to expose the settings for 1350: * individual series. 1351: * 1352: * @param position the position (<code>null</code> permitted). 1353: * 1354: * @see #getNegativeItemLabelPosition() 1355: */ 1356: public void setNegativeItemLabelPosition(ItemLabelPosition position); 1357: 1358: /** 1359: * Sets the item label position for negative values in ALL series and (if 1360: * requested) sends a {@link RendererChangeEvent} to all registered 1361: * listeners. 1362: * 1363: * @param position the position (<code>null</code> permitted). 1364: * @param notify notify registered listeners? 1365: * 1366: * @see #getNegativeItemLabelPosition() 1367: */ 1368: public void setNegativeItemLabelPosition(ItemLabelPosition position, 1369: boolean notify); 1370: 1371: /** 1372: * Returns the item label position for all negative values in a series. 1373: * 1374: * @param series the series index (zero-based). 1375: * 1376: * @return The item label position. 1377: * 1378: * @see #setSeriesNegativeItemLabelPosition(int, ItemLabelPosition) 1379: */ 1380: public ItemLabelPosition getSeriesNegativeItemLabelPosition(int series); 1381: 1382: /** 1383: * Sets the item label position for negative values in a series and sends a 1384: * {@link RendererChangeEvent} to all registered listeners. 1385: * 1386: * @param series the series index (zero-based). 1387: * @param position the position (<code>null</code> permitted). 1388: * 1389: * @see #getSeriesNegativeItemLabelPosition(int) 1390: */ 1391: public void setSeriesNegativeItemLabelPosition(int series, 1392: ItemLabelPosition position); 1393: 1394: /** 1395: * Sets the item label position for negative values in a series and (if 1396: * requested) sends a {@link RendererChangeEvent} to all registered 1397: * listeners. 1398: * 1399: * @param series the series index (zero-based). 1400: * @param position the position (<code>null</code> permitted). 1401: * @param notify notify registered listeners? 1402: * 1403: * @see #getSeriesNegativeItemLabelPosition(int) 1404: */ 1405: public void setSeriesNegativeItemLabelPosition(int series, 1406: ItemLabelPosition position, 1407: boolean notify); 1408: 1409: /** 1410: * Returns the base item label position for negative values. 1411: * 1412: * @return The position. 1413: * 1414: * @see #setBaseNegativeItemLabelPosition(ItemLabelPosition) 1415: */ 1416: public ItemLabelPosition getBaseNegativeItemLabelPosition(); 1417: 1418: /** 1419: * Sets the base item label position for negative values and sends a 1420: * {@link RendererChangeEvent} to all registered listeners. 1421: * 1422: * @param position the position. 1423: * 1424: * @see #getBaseNegativeItemLabelPosition() 1425: */ 1426: public void setBaseNegativeItemLabelPosition(ItemLabelPosition position); 1427: 1428: /** 1429: * Sets the base negative item label position and, if requested, sends a 1430: * {@link RendererChangeEvent} to all registered listeners. 1431: * 1432: * @param position the position. 1433: * @param notify notify registered listeners? 1434: * 1435: * @see #getBaseNegativeItemLabelPosition() 1436: */ 1437: public void setBaseNegativeItemLabelPosition(ItemLabelPosition position, 1438: boolean notify); 1439: 1440: // ITEM URL GENERATOR 1441: 1442: /** 1443: * Returns the URL generator for an item. 1444: * 1445: * @param series the series index (zero-based). 1446: * @param item the item index (zero-based). 1447: * 1448: * @return The item URL generator. 1449: */ 1450: public CategoryURLGenerator getItemURLGenerator(int series, int item); 1451: 1452: /** 1453: * Sets the item URL generator for ALL series. 1454: * 1455: * @param generator the generator. 1456: * 1457: * @see #getSeriesItemURLGenerator(int) 1458: */ 1459: public void setItemURLGenerator(CategoryURLGenerator generator); 1460: 1461: /** 1462: * Returns the item URL generator for a series. 1463: * 1464: * @param series the series index (zero-based). 1465: * 1466: * @return The URL generator. 1467: * 1468: * @see #setSeriesItemURLGenerator(int, CategoryURLGenerator) 1469: */ 1470: public CategoryURLGenerator getSeriesItemURLGenerator(int series); 1471: 1472: /** 1473: * Sets the item URL generator for a series. 1474: * 1475: * @param series the series index (zero-based). 1476: * @param generator the generator. 1477: * 1478: * @see #getSeriesItemURLGenerator(int) 1479: */ 1480: public void setSeriesItemURLGenerator(int series, 1481: CategoryURLGenerator generator); 1482: 1483: /** 1484: * Returns the base item URL generator. 1485: * 1486: * @return The item URL generator (possibly <code>null</code>). 1487: * 1488: * @see #setBaseItemURLGenerator(CategoryURLGenerator) 1489: */ 1490: public CategoryURLGenerator getBaseItemURLGenerator(); 1491: 1492: /** 1493: * Sets the base item URL generator and sends a {@link RendererChangeEvent} 1494: * to all registered listeners. 1495: * 1496: * @param generator the item URL generator (<code>null</code> permitted). 1497: * 1498: * @see #getBaseItemURLGenerator() 1499: */ 1500: public void setBaseItemURLGenerator(CategoryURLGenerator generator); 1501: 1502: /** 1503: * Returns a legend item for a series. 1504: * 1505: * @param datasetIndex the dataset index (zero-based). 1506: * @param series the series (zero-based index). 1507: * 1508: * @return The legend item (possibly <code>null</code>). 1509: */ 1510: public LegendItem getLegendItem(int datasetIndex, int series); 1511: 1512: /** 1513: * Draws a background for the data area. 1514: * 1515: * @param g2 the graphics device. 1516: * @param plot the plot. 1517: * @param dataArea the data area. 1518: */ 1519: public void drawBackground(Graphics2D g2, 1520: CategoryPlot plot, 1521: Rectangle2D dataArea); 1522: 1523: /** 1524: * Draws an outline for the data area. 1525: * 1526: * @param g2 the graphics device. 1527: * @param plot the plot. 1528: * @param dataArea the data area. 1529: */ 1530: public void drawOutline(Graphics2D g2, 1531: CategoryPlot plot, 1532: Rectangle2D dataArea); 1533: 1534: /** 1535: * Draws a single data item. 1536: * 1537: * @param g2 the graphics device. 1538: * @param state state information for one chart. 1539: * @param dataArea the data plot area. 1540: * @param plot the plot. 1541: * @param domainAxis the domain axis. 1542: * @param rangeAxis the range axis. 1543: * @param dataset the data. 1544: * @param row the row index (zero-based). 1545: * @param column the column index (zero-based). 1546: * @param pass the pass index. 1547: */ 1548: public void drawItem(Graphics2D g2, 1549: CategoryItemRendererState state, 1550: Rectangle2D dataArea, 1551: CategoryPlot plot, 1552: CategoryAxis domainAxis, 1553: ValueAxis rangeAxis, 1554: CategoryDataset dataset, 1555: int row, 1556: int column, 1557: int pass); 1558: 1559: /** 1560: * Draws a grid line against the domain axis. 1561: * 1562: * @param g2 the graphics device. 1563: * @param plot the plot. 1564: * @param dataArea the area for plotting data (not yet adjusted for any 1565: * 3D effect). 1566: * @param value the value. 1567: * 1568: * @see #drawRangeGridline(Graphics2D, CategoryPlot, ValueAxis, 1569: * Rectangle2D, double) 1570: */ 1571: public void drawDomainGridline(Graphics2D g2, 1572: CategoryPlot plot, 1573: Rectangle2D dataArea, 1574: double value); 1575: 1576: /** 1577: * Draws a grid line against the range axis. 1578: * 1579: * @param g2 the graphics device. 1580: * @param plot the plot. 1581: * @param axis the value axis. 1582: * @param dataArea the area for plotting data (not yet adjusted for any 1583: * 3D effect). 1584: * @param value the value. 1585: * 1586: * @see #drawDomainGridline(Graphics2D, CategoryPlot, Rectangle2D, double) 1587: */ 1588: public void drawRangeGridline(Graphics2D g2, 1589: CategoryPlot plot, 1590: ValueAxis axis, 1591: Rectangle2D dataArea, 1592: double value); 1593: 1594: /** 1595: * Draws a line (or some other marker) to indicate a particular category on 1596: * the domain axis. 1597: * 1598: * @param g2 the graphics device. 1599: * @param plot the plot. 1600: * @param axis the category axis. 1601: * @param marker the marker. 1602: * @param dataArea the area for plotting data (not including 3D effect). 1603: * 1604: * @see #drawRangeMarker(Graphics2D, CategoryPlot, ValueAxis, Marker, 1605: * Rectangle2D) 1606: */ 1607: public void drawDomainMarker(Graphics2D g2, 1608: CategoryPlot plot, 1609: CategoryAxis axis, 1610: CategoryMarker marker, 1611: Rectangle2D dataArea); 1612: 1613: /** 1614: * Draws a line (or some other marker) to indicate a particular value on 1615: * the range axis. 1616: * 1617: * @param g2 the graphics device. 1618: * @param plot the plot. 1619: * @param axis the value axis. 1620: * @param marker the marker. 1621: * @param dataArea the area for plotting data (not including 3D effect). 1622: * 1623: * @see #drawDomainMarker(Graphics2D, CategoryPlot, CategoryAxis, 1624: * CategoryMarker, Rectangle2D) 1625: */ 1626: public void drawRangeMarker(Graphics2D g2, 1627: CategoryPlot plot, 1628: ValueAxis axis, 1629: Marker marker, 1630: Rectangle2D dataArea); 1631: 1632: }