    001    /* ===========================================================
    002     * JFreeChart : a free chart library for the Java(tm) platform
    003     * ===========================================================
    004     *
    005     * (C) Copyright 2000-2007, 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-2007, 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     * Changes
    037     * -------
    038     * 23-Oct-2001 : Version 1 (DG);
    039     * 16-Jan-2002 : Renamed HorizontalCategoryItemRenderer.java
    040     *               --> CategoryItemRenderer.java (DG);
    041     * 05-Feb-2002 : Changed return type of the drawCategoryItem method from void
    042     *               to Shape, as part of the tooltips implementation (DG)
    043     *
    044     *               NOTE (30-May-2002) : this has subsequently been changed back
    045     *               to void, tooltips are now collected along with entities in
    046     *               ChartRenderingInfo (DG);
    047     *
    048     * 14-Mar-2002 : Added the initialise method, and changed all bar plots to use
    049     *               this renderer (DG);
    050     * 23-May-2002 : Added ChartRenderingInfo to the initialise method (DG);
    051     * 29-May-2002 : Added the getAxisArea(Rectangle2D) method (DG);
    052     * 06-Jun-2002 : Updated Javadoc comments (DG);
    053     * 26-Jun-2002 : Added range axis to the initialise method (DG);
    054     * 24-Sep-2002 : Added getLegendItem() method (DG);
    055     * 23-Oct-2002 : Added methods to get/setToolTipGenerator (DG);
    056     * 05-Nov-2002 : Replaced references to CategoryDataset with TableDataset (DG);
    057     * 06-Nov-2002 : Added the domain axis to the drawCategoryItem method.  Renamed
    058     *               drawCategoryItem() --> drawItem() (DG);
    059     * 20-Nov-2002 : Changed signature of drawItem() method to reflect use of
    060     *               TableDataset (DG);
    061     * 26-Nov-2002 : Replaced the isStacked() method with the getRangeType()
    062     *               method (DG);
    063     * 08-Jan-2003 : Changed getSeriesCount() --> getRowCount() and
    064     *               getCategoryCount() --> getColumnCount() (DG);
    065     * 09-Jan-2003 : Changed name of grid-line methods (DG);
    066     * 21-Jan-2003 : Merged TableDataset with CategoryDataset (DG);
    067     * 10-Apr-2003 : Changed CategoryDataset to KeyedValues2DDataset in
    068     *               drawItem() method (DG);
    069     * 29-Apr-2003 : Eliminated Renderer interface (DG);
    070     * 02-Sep-2003 : Fix for bug 790407 (DG);
    071     * 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG);
    072     * 20-Oct-2003 : Added setOutlinePaint() method (DG);
    073     * 06-Feb-2004 : Added missing methods, and moved deprecated methods (DG);
    074     * 19-Feb-2004 : Added extra setXXXLabelsVisible() methods (DG);
    075     * 29-Apr-2004 : Changed Integer --> int in initialise() method (DG);
    076     * 18-May-2004 : Added methods for item label paint (DG);
    077     * 05-Nov-2004 : Added getPassCount() method and 'pass' parameter to drawItem()
    078     *               method (DG);
    079     * 07-Jan-2005 : Renamed getRangeExtent() --> findRangeBounds (DG);
    080     * 11-Jan-2005 : Removed deprecated code in preparation for 1.0.0 release (DG);
    081     * 23-Feb-2005 : Now extends LegendItemSource (DG);
    082     * 20-Apr-2005 : Renamed CategoryLabelGenerator
    083     *               --> CategoryItemLabelGenerator (DG);
    084     * 20-May-2005 : Added drawDomainMarker() method (DG);
    085     * ------------- JFREECHART 1.0.x ---------------------------------------------
    086     * 20-Feb-2007 : Updated API docs (DG);
    087     * 19-Apr-2007 : Deprecated seriesVisible and seriesVisibleInLegend flags (DG);
    088     * 20-Apr-2007 : Deprecated paint, fillPaint, outlinePaint, stroke,
    089     *               outlineStroke, shape, itemLabelsVisible, itemLabelFont,
    090     *               itemLabelPaint, positiveItemLabelPosition,
    091     *               negativeItemLabelPosition and createEntities override
    092     *               fields (DG);
    093     *
    094     */
    095
    096    package org.jfree.chart.renderer.category;
    097
    098    import java.awt.Font;
    099    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    }