Source for org.jfree.chart.renderer.category.CategoryItemRenderer

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