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