public AbstractRenderer() 
{
           
        this.seriesVisible = null;
        this.seriesVisibleList = new BooleanList();
        this.baseSeriesVisible = true;
        this.seriesVisibleInLegend = null;
        this.seriesVisibleInLegendList = new BooleanList();
        this.baseSeriesVisibleInLegend = true;
        this.paint = null;
        this.paintList = new PaintList();
        this.basePaint = DEFAULT_PAINT;
        this.autoPopulateSeriesPaint = true;
        this.fillPaint = null;
        this.fillPaintList = new PaintList();
        this.baseFillPaint = Color.white;
        this.autoPopulateSeriesFillPaint = false;
        this.outlinePaint = null;
        this.outlinePaintList = new PaintList();
        this.baseOutlinePaint = DEFAULT_OUTLINE_PAINT;
        this.autoPopulateSeriesOutlinePaint = false;
        this.stroke = null;
        this.strokeList = new StrokeList();
        this.baseStroke = DEFAULT_STROKE;
        this.autoPopulateSeriesStroke = false;
        this.outlineStroke = null;
        this.outlineStrokeList = new StrokeList();
        this.baseOutlineStroke = DEFAULT_OUTLINE_STROKE;
        this.autoPopulateSeriesOutlineStroke = false;
        this.shape = null;
        this.shapeList = new ShapeList();
        this.baseShape = DEFAULT_SHAPE;
        this.autoPopulateSeriesShape = true;
        this.itemLabelsVisible = null;
        this.itemLabelsVisibleList = new BooleanList();
        this.baseItemLabelsVisible = Boolean.FALSE;
        this.itemLabelFont = null;
        this.itemLabelFontList = new ObjectList();
        this.baseItemLabelFont = new Font("SansSerif", Font.PLAIN, 10);
        this.itemLabelPaint = null;
        this.itemLabelPaintList = new PaintList();
        this.baseItemLabelPaint = Color.black;
        this.positiveItemLabelPosition = null;
        this.positiveItemLabelPositionList = new ObjectList();
        this.basePositiveItemLabelPosition = new ItemLabelPosition(
                ItemLabelAnchor.OUTSIDE12, TextAnchor.BOTTOM_CENTER);
        this.negativeItemLabelPosition = null;
        this.negativeItemLabelPositionList = new ObjectList();
        this.baseNegativeItemLabelPosition = new ItemLabelPosition(
                ItemLabelAnchor.OUTSIDE6, TextAnchor.TOP_CENTER);
        this.createEntities = null;
        this.createEntitiesList = new BooleanList();
        this.baseCreateEntities = true;
        this.listenerList = new EventListenerList();
}

Default constructor.

 public  void addChangeListener(RendererChangeListener listener) 
{
        if (listener == null) {
            throw new IllegalArgumentException("Null 'listener' argument.");
        }
        this.listenerList.add(RendererChangeListener.class, listener);
}

Registers an object to receive notification of changes to the renderer.

 protected Point2D calculateLabelAnchorPoint(ItemLabelAnchor anchor,
    double x,
    double y,
    PlotOrientation orientation) 
{
                                            
        Point2D result = null;
        if (anchor == ItemLabelAnchor.CENTER) {
            result = new Point2D.Double(x, y);
        }
        else if (anchor == ItemLabelAnchor.INSIDE1) {
            result = new Point2D.Double(x + OPP * this.itemLabelAnchorOffset,
                    y - ADJ * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.INSIDE2) {
            result = new Point2D.Double(x + ADJ * this.itemLabelAnchorOffset,
                    y - OPP * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.INSIDE3) {
            result = new Point2D.Double(x + this.itemLabelAnchorOffset, y);
        }
        else if (anchor == ItemLabelAnchor.INSIDE4) {
            result = new Point2D.Double(x + ADJ * this.itemLabelAnchorOffset,
                    y + OPP * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.INSIDE5) {
            result = new Point2D.Double(x + OPP * this.itemLabelAnchorOffset,
                    y + ADJ * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.INSIDE6) {
            result = new Point2D.Double(x, y + this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.INSIDE7) {
            result = new Point2D.Double(x - OPP * this.itemLabelAnchorOffset,
                    y + ADJ * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.INSIDE8) {
            result = new Point2D.Double(x - ADJ * this.itemLabelAnchorOffset,
                    y + OPP * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.INSIDE9) {
            result = new Point2D.Double(x - this.itemLabelAnchorOffset, y);
        }
        else if (anchor == ItemLabelAnchor.INSIDE10) {
            result = new Point2D.Double(x - ADJ * this.itemLabelAnchorOffset,
                    y - OPP * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.INSIDE11) {
            result = new Point2D.Double(x - OPP * this.itemLabelAnchorOffset,
                    y - ADJ * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.INSIDE12) {
            result = new Point2D.Double(x, y - this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE1) {
            result = new Point2D.Double(
                    x + 2.0 * OPP * this.itemLabelAnchorOffset,
                    y - 2.0 * ADJ * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE2) {
            result = new Point2D.Double(
                    x + 2.0 * ADJ * this.itemLabelAnchorOffset,
                    y - 2.0 * OPP * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE3) {
            result = new Point2D.Double(x + 2.0 * this.itemLabelAnchorOffset,
                    y);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE4) {
            result = new Point2D.Double(
                    x + 2.0 * ADJ * this.itemLabelAnchorOffset,
                    y + 2.0 * OPP * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE5) {
            result = new Point2D.Double(
                    x + 2.0 * OPP * this.itemLabelAnchorOffset,
                    y + 2.0 * ADJ * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE6) {
            result = new Point2D.Double(x,
                    y + 2.0 * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE7) {
            result = new Point2D.Double(
                    x - 2.0 * OPP * this.itemLabelAnchorOffset,
                    y + 2.0 * ADJ * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE8) {
            result = new Point2D.Double(
                    x - 2.0 * ADJ * this.itemLabelAnchorOffset,
                    y + 2.0 * OPP * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE9) {
            result = new Point2D.Double(x - 2.0 * this.itemLabelAnchorOffset,
                    y);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE10) {
            result = new Point2D.Double(
                    x - 2.0 * ADJ * this.itemLabelAnchorOffset,
                    y - 2.0 * OPP * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE11) {
            result = new Point2D.Double(
                x - 2.0 * OPP * this.itemLabelAnchorOffset,
                y - 2.0 * ADJ * this.itemLabelAnchorOffset);
        }
        else if (anchor == ItemLabelAnchor.OUTSIDE12) {
            result = new Point2D.Double(x,
                    y - 2.0 * this.itemLabelAnchorOffset);
        }
        return result;
}

Calculates the item label anchor point.

 protected Object clone() throws CloneNotSupportedException 
{
        AbstractRenderer clone = (AbstractRenderer) super.clone();
        if (this.seriesVisibleList != null) {
            clone.seriesVisibleList
                    = (BooleanList) this.seriesVisibleList.clone();
        }
        if (this.seriesVisibleInLegendList != null) {
            clone.seriesVisibleInLegendList
                    = (BooleanList) this.seriesVisibleInLegendList.clone();
        }
        // 'paint' : immutable, no need to clone reference
        if (this.paintList != null) {
            clone.paintList = (PaintList) this.paintList.clone();
        }
        // 'basePaint' : immutable, no need to clone reference
        if (this.fillPaintList != null) {
            clone.fillPaintList = (PaintList) this.fillPaintList.clone();
        }
        // 'outlinePaint' : immutable, no need to clone reference
        if (this.outlinePaintList != null) {
            clone.outlinePaintList = (PaintList) this.outlinePaintList.clone();
        }
        // 'baseOutlinePaint' : immutable, no need to clone reference
        // 'stroke' : immutable, no need to clone reference
        if (this.strokeList != null) {
            clone.strokeList = (StrokeList) this.strokeList.clone();
        }
        // 'baseStroke' : immutable, no need to clone reference
        // 'outlineStroke' : immutable, no need to clone reference
        if (this.outlineStrokeList != null) {
            clone.outlineStrokeList
                = (StrokeList) this.outlineStrokeList.clone();
        }
        // 'baseOutlineStroke' : immutable, no need to clone reference
        if (this.shape != null) {
            clone.shape = ShapeUtilities.clone(this.shape);
        }
        if (this.shapeList != null) {
            clone.shapeList = (ShapeList) this.shapeList.clone();
        }
        if (this.baseShape != null) {
            clone.baseShape = ShapeUtilities.clone(this.baseShape);
        }
        // 'itemLabelsVisible' : immutable, no need to clone reference
        if (this.itemLabelsVisibleList != null) {
            clone.itemLabelsVisibleList
                = (BooleanList) this.itemLabelsVisibleList.clone();
        }
        // 'basePaint' : immutable, no need to clone reference
        // 'itemLabelFont' : immutable, no need to clone reference
        if (this.itemLabelFontList != null) {
            clone.itemLabelFontList
                = (ObjectList) this.itemLabelFontList.clone();
        }
        // 'baseItemLabelFont' : immutable, no need to clone reference
        // 'itemLabelPaint' : immutable, no need to clone reference
        if (this.itemLabelPaintList != null) {
            clone.itemLabelPaintList
                = (PaintList) this.itemLabelPaintList.clone();
        }
        // 'baseItemLabelPaint' : immutable, no need to clone reference
        // 'postiveItemLabelAnchor' : immutable, no need to clone reference
        if (this.positiveItemLabelPositionList != null) {
            clone.positiveItemLabelPositionList
                = (ObjectList) this.positiveItemLabelPositionList.clone();
        }
        // 'baseItemLabelAnchor' : immutable, no need to clone reference
        // 'negativeItemLabelAnchor' : immutable, no need to clone reference
        if (this.negativeItemLabelPositionList != null) {
            clone.negativeItemLabelPositionList
                = (ObjectList) this.negativeItemLabelPositionList.clone();
        }
        // 'baseNegativeItemLabelAnchor' : immutable, no need to clone reference
        if (this.createEntitiesList != null) {
            clone.createEntitiesList
                    = (BooleanList) this.createEntitiesList.clone();
        }
        clone.listenerList = new EventListenerList();
        clone.event = null;
        return clone;
}

Returns an independent copy of the renderer.

 public boolean equals(Object obj) 
{
        if (obj == this) {
            return true;
        }
        if (!(obj instanceof AbstractRenderer)) {
            return false;
        }
        AbstractRenderer that = (AbstractRenderer) obj;
        if (!ObjectUtilities.equal(this.seriesVisible, that.seriesVisible)) {
            return false;
        }
        if (!this.seriesVisibleList.equals(that.seriesVisibleList)) {
            return false;
        }
        if (this.baseSeriesVisible != that.baseSeriesVisible) {
            return false;
        }
        if (!ObjectUtilities.equal(this.seriesVisibleInLegend,
                that.seriesVisibleInLegend)) {
            return false;
        }
        if (!this.seriesVisibleInLegendList.equals(
                that.seriesVisibleInLegendList)) {
            return false;
        }
        if (this.baseSeriesVisibleInLegend != that.baseSeriesVisibleInLegend) {
            return false;
        }
        if (!PaintUtilities.equal(this.paint, that.paint)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.paintList, that.paintList)) {
            return false;
        }
        if (!PaintUtilities.equal(this.basePaint, that.basePaint)) {
            return false;
        }
        if (!PaintUtilities.equal(this.fillPaint, that.fillPaint)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.fillPaintList, that.fillPaintList)) {
            return false;
        }
        if (!PaintUtilities.equal(this.baseFillPaint, that.baseFillPaint)) {
            return false;
        }
        if (!PaintUtilities.equal(this.outlinePaint, that.outlinePaint)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.outlinePaintList,
                that.outlinePaintList)) {
            return false;
        }
        if (!PaintUtilities.equal(this.baseOutlinePaint,
                that.baseOutlinePaint)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.stroke, that.stroke)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.strokeList, that.strokeList)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.baseStroke, that.baseStroke)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.outlineStroke, that.outlineStroke)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.outlineStrokeList,
                that.outlineStrokeList)) {
            return false;
        }
        if (!ObjectUtilities.equal(
            this.baseOutlineStroke, that.baseOutlineStroke)
        ) {
            return false;
        }
        if (!ObjectUtilities.equal(this.shape, that.shape)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.shapeList, that.shapeList)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.baseShape, that.baseShape)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.itemLabelsVisible,
                that.itemLabelsVisible)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.itemLabelsVisibleList,
                that.itemLabelsVisibleList)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.baseItemLabelsVisible,
                that.baseItemLabelsVisible)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.itemLabelFont, that.itemLabelFont)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.itemLabelFontList,
                that.itemLabelFontList)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.baseItemLabelFont,
                that.baseItemLabelFont)) {
            return false;
        }
        if (!PaintUtilities.equal(this.itemLabelPaint, that.itemLabelPaint)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.itemLabelPaintList,
                that.itemLabelPaintList)) {
            return false;
        }
        if (!PaintUtilities.equal(this.baseItemLabelPaint,
                that.baseItemLabelPaint)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.positiveItemLabelPosition,
                that.positiveItemLabelPosition)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.positiveItemLabelPositionList,
                that.positiveItemLabelPositionList)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.basePositiveItemLabelPosition,
                that.basePositiveItemLabelPosition)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.negativeItemLabelPosition,
                that.negativeItemLabelPosition)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.negativeItemLabelPositionList,
                that.negativeItemLabelPositionList)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.baseNegativeItemLabelPosition,
                that.baseNegativeItemLabelPosition)) {
            return false;
        }
        if (this.itemLabelAnchorOffset != that.itemLabelAnchorOffset) {
            return false;
        }
        if (!ObjectUtilities.equal(this.createEntities, that.createEntities)) {
            return false;
        }
        if (!ObjectUtilities.equal(this.createEntitiesList,
                that.createEntitiesList)) {
            return false;
        }
        if (this.baseCreateEntities != that.baseCreateEntities) {
            return false;
        }
        return true;
}

Tests this renderer for equality with another object.

 protected  void fireChangeEvent() 
{
        // the commented out code would be better, but only if
        // RendererChangeEvent is immutable, which it isn't.  See if there is
        // a way to fix this...
        //if (this.event == null) {
        //    this.event = new RendererChangeEvent(this);
        //}
        //notifyListeners(this.event);
        notifyListeners(new RendererChangeEvent(this));
}

Sends a RendererChangeEvent to all registered listeners.

 public boolean getAutoPopulateSeriesFillPaint() 
{
        return this.autoPopulateSeriesFillPaint;
}

Returns the flag that controls whether or not the series fill paint list is automatically populated when #lookupSeriesFillPaint(int) is called.

 public boolean getAutoPopulateSeriesOutlinePaint() 
{
        return this.autoPopulateSeriesOutlinePaint;
}

Returns the flag that controls whether or not the series outline paint list is automatically populated when #lookupSeriesOutlinePaint(int) is called.

 public boolean getAutoPopulateSeriesOutlineStroke() 
{
        return this.autoPopulateSeriesOutlineStroke;
}

Returns the flag that controls whether or not the series outline stroke list is automatically populated when #lookupSeriesOutlineStroke(int) is called.

 public boolean getAutoPopulateSeriesPaint() 
{
        return this.autoPopulateSeriesPaint;
}

Returns the flag that controls whether or not the series paint list is automatically populated when #lookupSeriesPaint(int) is called.

 public boolean getAutoPopulateSeriesShape() 
{
        return this.autoPopulateSeriesShape;
}

Returns the flag that controls whether or not the series shape list is automatically populated when #lookupSeriesShape(int) is called.

 public boolean getAutoPopulateSeriesStroke() 
{
        return this.autoPopulateSeriesStroke;
}

Returns the flag that controls whether or not the series stroke list is automatically populated when #lookupSeriesStroke(int) is called.

 public boolean getBaseCreateEntities() 
{
        return this.baseCreateEntities;
}

Returns the base visibility for all series.

 public Paint getBaseFillPaint() 
{
        return this.baseFillPaint;
}

Returns the base fill paint.

 public Font getBaseItemLabelFont() 
{
        return this.baseItemLabelFont;
}

Returns the base item label font (this is used when no other font setting is available).

 public Paint getBaseItemLabelPaint() 
{
        return this.baseItemLabelPaint;
}

Returns the base item label paint.

 public Boolean getBaseItemLabelsVisible() 
{
        // this should have been defined as a boolean primitive, because
        // allowing null values is a nuisance...but it is part of the final
        // API now, so we'll have to support it.
        return this.baseItemLabelsVisible;
}

Returns the base setting for item label visibility. A null result should be interpreted as equivalent to Boolean.FALSE.

 public ItemLabelPosition getBaseNegativeItemLabelPosition() 
{
        return this.baseNegativeItemLabelPosition;
}

Returns the base item label position for negative values.

 public Paint getBaseOutlinePaint() 
{
        return this.baseOutlinePaint;
}

Returns the base outline paint.

 public Stroke getBaseOutlineStroke() 
{
        return this.baseOutlineStroke;
}

Returns the base outline stroke.

 public Paint getBasePaint() 
{
        return this.basePaint;
}

Returns the base paint.

 public ItemLabelPosition getBasePositiveItemLabelPosition() 
{
        return this.basePositiveItemLabelPosition;
}

Returns the base positive item label position.

 public boolean getBaseSeriesVisible() 
{
        return this.baseSeriesVisible;
}

Returns the base visibility for all series.

 public boolean getBaseSeriesVisibleInLegend() 
{
        return this.baseSeriesVisibleInLegend;
}

Returns the base visibility in the legend for all series.

 public Shape getBaseShape() 
{
        return this.baseShape;
}

Returns the base shape.

 public Stroke getBaseStroke() 
{
        return this.baseStroke;
}

Returns the base stroke.

 public Boolean getCreateEntities() 
{
        return this.createEntities;
}

Returns the flag that controls whether or not chart entities are created for the items in ALL series. This flag overrides the per series and default settings - you must set it to null if you want the other settings to apply.

 abstract public DrawingSupplier getDrawingSupplier()
Returns the drawing supplier from the plot.

 public boolean getItemCreateEntity(int series,
    int item) 
{
        if (this.createEntities != null) {
            return this.createEntities.booleanValue();
        }
        else {
            Boolean b = getSeriesCreateEntities(series);
            if (b != null) {
                return b.booleanValue();
            }
            else {
                return this.baseCreateEntities;
            }
        }
}

Returns a boolean that indicates whether or not the specified item should have a chart entity created for it.

 public Paint getItemFillPaint(int row,
    int column) 
{
        return lookupSeriesFillPaint(row);
}

Returns the paint used to fill data items as they are drawn. The default implementation passes control to the #lookupSeriesFillPaint(int) method - you can override this method if you require different behaviour.

 public double getItemLabelAnchorOffset() 
{
        return this.itemLabelAnchorOffset;
}

Returns the item label anchor offset.

 public Font getItemLabelFont() 
{
        return this.itemLabelFont;
}

Returns the font used for all item labels. This may be null, in which case the per series font settings will apply.

 public Font getItemLabelFont(int row,
    int column) 
{
        Font result = this.itemLabelFont;
        if (result == null) {
            result = getSeriesItemLabelFont(row);
            if (result == null) {
                result = this.baseItemLabelFont;
            }
        }
        return result;
}

Returns the font for an item label.

 public Paint getItemLabelPaint() 
{
        return this.itemLabelPaint;
}

Returns the paint used for all item labels. This may be null, in which case the per series paint settings will apply.

 public Paint getItemLabelPaint(int row,
    int column) 
{
        Paint result = this.itemLabelPaint;
        if (result == null) {
            result = getSeriesItemLabelPaint(row);
            if (result == null) {
                result = this.baseItemLabelPaint;
            }
        }
        return result;
}

Returns the paint used to draw an item label.

 public Paint getItemOutlinePaint(int row,
    int column) 
{
        return lookupSeriesOutlinePaint(row);
}

Returns the paint used to outline data items as they are drawn.

The default implementation passes control to the #lookupSeriesOutlinePaint method. You can override this method if you require different behaviour.

 public Stroke getItemOutlineStroke(int row,
    int column) 
{
        return lookupSeriesOutlineStroke(row);
}

Returns the stroke used to outline data items. The default implementation passes control to the #lookupSeriesOutlineStroke(int) method. You can override this method if you require different behaviour.

 public Paint getItemPaint(int row,
    int column) 
{
        return lookupSeriesPaint(row);
}

Returns the paint used to fill data items as they are drawn.

The default implementation passes control to the lookupSeriesPaint() method. You can override this method if you require different behaviour.

 public Shape getItemShape(int row,
    int column) 
{
        return lookupSeriesShape(row);
}

Returns a shape used to represent a data item.

The default implementation passes control to the getSeriesShape method. You can override this method if you require different behaviour.

 public Stroke getItemStroke(int row,
    int column) 
{
        return lookupSeriesStroke(row);
}

Returns the stroke used to draw data items.

The default implementation passes control to the getSeriesStroke method. You can override this method if you require different behaviour.

 public boolean getItemVisible(int series,
    int item) 
{
        return isSeriesVisible(series);
}

Returns a boolean that indicates whether or not the specified item should be drawn (this is typically used to hide an entire series).

 public ItemLabelPosition getNegativeItemLabelPosition() 
{
        return this.negativeItemLabelPosition;
}

Returns the item label position for negative values in ALL series.

 public ItemLabelPosition getNegativeItemLabelPosition(int row,
    int column) 
{
        return getSeriesNegativeItemLabelPosition(row);
}

Returns the item label position for negative values. This method can be overridden to provide customisation of the item label position for individual data items.

 public ItemLabelPosition getPositiveItemLabelPosition() 
{
        return this.positiveItemLabelPosition;
}

Returns the item label position for positive values in ALL series.

 public ItemLabelPosition getPositiveItemLabelPosition(int row,
    int column) 
{
        return getSeriesPositiveItemLabelPosition(row);
}

Returns the item label position for positive values.

 public Boolean getSeriesCreateEntities(int series) 
{
        return this.createEntitiesList.getBoolean(series);
}

Returns the flag that controls whether entities are created for a series.

 public Paint getSeriesFillPaint(int series) 
{
        return this.fillPaintList.getPaint(series);
}

Returns the paint used to fill an item drawn by the renderer.

 public Font getSeriesItemLabelFont(int series) 
{
        return (Font) this.itemLabelFontList.get(series);
}

Returns the font for all the item labels in a series.

 public Paint getSeriesItemLabelPaint(int series) 
{
        return this.itemLabelPaintList.getPaint(series);
}

Returns the paint used to draw the item labels for a series.

 public ItemLabelPosition getSeriesNegativeItemLabelPosition(int series) 
{
        // return the override, if there is one...
        if (this.negativeItemLabelPosition != null) {
            return this.negativeItemLabelPosition;
        }
        // otherwise look up the position list
        ItemLabelPosition position = (ItemLabelPosition)
            this.negativeItemLabelPositionList.get(series);
        if (position == null) {
            position = this.baseNegativeItemLabelPosition;
        }
        return position;
}

Returns the item label position for all negative values in a series.

 public Paint getSeriesOutlinePaint(int series) 
{
        return this.outlinePaintList.getPaint(series);
}

Returns the paint used to outline an item drawn by the renderer.

 public Stroke getSeriesOutlineStroke(int series) 
{
        return this.outlineStrokeList.getStroke(series);
}

Returns the stroke used to outline the items in a series.

 public Paint getSeriesPaint(int series) 
{
        return this.paintList.getPaint(series);
}

Returns the paint used to fill an item drawn by the renderer.

 public ItemLabelPosition getSeriesPositiveItemLabelPosition(int series) 
{
        // return the override, if there is one...
        if (this.positiveItemLabelPosition != null) {
            return this.positiveItemLabelPosition;
        }
        // otherwise look up the position table
        ItemLabelPosition position = (ItemLabelPosition)
            this.positiveItemLabelPositionList.get(series);
        if (position == null) {
            position = this.basePositiveItemLabelPosition;
        }
        return position;
}

Returns the item label position for all positive values in a series.

 public Shape getSeriesShape(int series) 
{
        return this.shapeList.getShape(series);
}

Returns a shape used to represent the items in a series.

 public Stroke getSeriesStroke(int series) 
{
        return this.strokeList.getStroke(series);
}

Returns the stroke used to draw the items in a series.

 public Boolean getSeriesVisible() 
{
        return this.seriesVisible;
}

Returns the flag that controls the visibility of ALL series. This flag overrides the per series and default settings - you must set it to null if you want the other settings to apply.

 public Boolean getSeriesVisible(int series) 
{
        return this.seriesVisibleList.getBoolean(series);
}

Returns the flag that controls whether a series is visible.

 public Boolean getSeriesVisibleInLegend() 
{
        return this.seriesVisibleInLegend;
}

Returns the flag that controls the visibility of ALL series in the legend. This flag overrides the per series and default settings - you must set it to null if you want the other settings to apply.

 public Boolean getSeriesVisibleInLegend(int series) 
{
        return this.seriesVisibleInLegendList.getBoolean(series);
}

Returns the flag that controls whether a series is visible in the legend. This method returns only the "per series" settings - to incorporate the override and base settings as well, you need to use the #isSeriesVisibleInLegend(int) method.

 public boolean hasListener(EventListener listener) 
{
        List list = Arrays.asList(this.listenerList.getListenerList());
        return list.contains(listener);
}

Returns true if the specified object is registered with the dataset as a listener. Most applications won't need to call this method, it exists mainly for use by unit testing code.

 public int hashCode() 
{
        int result = 193;
        result = HashUtilities.hashCode(result, this.seriesVisibleList);
        result = HashUtilities.hashCode(result, this.baseSeriesVisible);
        result = HashUtilities.hashCode(result, this.seriesVisibleInLegendList);
        result = HashUtilities.hashCode(result, this.baseSeriesVisibleInLegend);
        result = HashUtilities.hashCode(result, this.paintList);
        result = HashUtilities.hashCode(result, this.basePaint);
        result = HashUtilities.hashCode(result, this.fillPaintList);
        result = HashUtilities.hashCode(result, this.baseFillPaint);
        result = HashUtilities.hashCode(result, this.outlinePaintList);
        result = HashUtilities.hashCode(result, this.baseOutlinePaint);
        result = HashUtilities.hashCode(result, this.strokeList);
        result = HashUtilities.hashCode(result, this.baseStroke);
        result = HashUtilities.hashCode(result, this.outlineStrokeList);
        result = HashUtilities.hashCode(result, this.baseOutlineStroke);
        // shapeList
        // baseShape
        result = HashUtilities.hashCode(result, this.itemLabelsVisibleList);
        result = HashUtilities.hashCode(result, this.baseItemLabelsVisible);
        // itemLabelFontList
        // baseItemLabelFont
        // itemLabelPaintList
        // baseItemLabelPaint
        // positiveItemLabelPositionList
        // basePositiveItemLabelPosition
        // negativeItemLabelPositionList
        // baseNegativeItemLabelPosition
        // itemLabelAnchorOffset
        // createEntityList
        // baseCreateEntities
        return result;
}

Returns a hashcode for the renderer.

 public boolean isItemLabelVisible(int row,
    int column) 
{
        return isSeriesItemLabelsVisible(row);
}

Returns true if an item label is visible, and false otherwise.

 public boolean isSeriesItemLabelsVisible(int series) 
{
        // return the override, if there is one...
        if (this.itemLabelsVisible != null) {
            return this.itemLabelsVisible.booleanValue();
        }
        // otherwise look up the boolean table
        Boolean b = this.itemLabelsVisibleList.getBoolean(series);
        if (b == null) {
            b = this.baseItemLabelsVisible;
        }
        if (b == null) {
            b = Boolean.FALSE;
        }
        return b.booleanValue();
}

Returns true if the item labels for a series are visible, and false otherwise.

 public boolean isSeriesVisible(int series) 
{
        boolean result = this.baseSeriesVisible;
        if (this.seriesVisible != null) {
            result = this.seriesVisible.booleanValue();
        }
        else {
            Boolean b = this.seriesVisibleList.getBoolean(series);
            if (b != null) {
                result = b.booleanValue();
            }
        }
        return result;
}

Returns a boolean that indicates whether or not the specified series should be drawn.

 public boolean isSeriesVisibleInLegend(int series) 
{
        boolean result = this.baseSeriesVisibleInLegend;
        if (this.seriesVisibleInLegend != null) {
            result = this.seriesVisibleInLegend.booleanValue();
        }
        else {
            Boolean b = this.seriesVisibleInLegendList.getBoolean(series);
            if (b != null) {
                result = b.booleanValue();
            }
        }
        return result;
}

Returns true if the series should be shown in the legend, and false otherwise.

 public Paint lookupSeriesFillPaint(int series) 
{
        // return the override, if there is one...
        if (this.fillPaint != null) {
            return this.fillPaint;
        }
        // otherwise look up the paint table
        Paint seriesFillPaint = getSeriesFillPaint(series);
        if (seriesFillPaint == null && this.autoPopulateSeriesFillPaint) {
            DrawingSupplier supplier = getDrawingSupplier();
            if (supplier != null) {
                seriesFillPaint = supplier.getNextFillPaint();
                setSeriesFillPaint(series, seriesFillPaint, false);
            }
        }
        if (seriesFillPaint == null) {
            seriesFillPaint = this.baseFillPaint;
        }
        return seriesFillPaint;
}

Returns the paint used to fill an item drawn by the renderer.

 public Paint lookupSeriesOutlinePaint(int series) 
{
        // return the override, if there is one...
        if (this.outlinePaint != null) {
            return this.outlinePaint;
        }
        // otherwise look up the paint table
        Paint seriesOutlinePaint = getSeriesOutlinePaint(series);
        if (seriesOutlinePaint == null && this.autoPopulateSeriesOutlinePaint) {
            DrawingSupplier supplier = getDrawingSupplier();
            if (supplier != null) {
                seriesOutlinePaint = supplier.getNextOutlinePaint();
                setSeriesOutlinePaint(series, seriesOutlinePaint, false);
            }
        }
        if (seriesOutlinePaint == null) {
            seriesOutlinePaint = this.baseOutlinePaint;
        }
        return seriesOutlinePaint;
}

Returns the paint used to outline an item drawn by the renderer.

 public Stroke lookupSeriesOutlineStroke(int series) 
{
        // return the override, if there is one...
        if (this.outlineStroke != null) {
            return this.outlineStroke;
        }
        // otherwise look up the stroke table
        Stroke result = getSeriesOutlineStroke(series);
        if (result == null && this.autoPopulateSeriesOutlineStroke) {
            DrawingSupplier supplier = getDrawingSupplier();
            if (supplier != null) {
                result = supplier.getNextOutlineStroke();
                setSeriesOutlineStroke(series, result, false);
            }
        }
        if (result == null) {
            result = this.baseOutlineStroke;
        }
        return result;
}

Returns the stroke used to outline the items in a series.

 public Paint lookupSeriesPaint(int series) 
{
        // return the override, if there is one...
        if (this.paint != null) {
            return this.paint;
        }
        // otherwise look up the paint list
        Paint seriesPaint = getSeriesPaint(series);
        if (seriesPaint == null && this.autoPopulateSeriesPaint) {
            DrawingSupplier supplier = getDrawingSupplier();
            if (supplier != null) {
                seriesPaint = supplier.getNextPaint();
                setSeriesPaint(series, seriesPaint, false);
            }
        }
        if (seriesPaint == null) {
            seriesPaint = this.basePaint;
        }
        return seriesPaint;
}

Returns the paint used to fill an item drawn by the renderer.

 public Shape lookupSeriesShape(int series) 
{
        // return the override, if there is one...
        if (this.shape != null) {
            return this.shape;
        }
        // otherwise look up the shape list
        Shape result = getSeriesShape(series);
        if (result == null && this.autoPopulateSeriesShape) {
            DrawingSupplier supplier = getDrawingSupplier();
            if (supplier != null) {
                result = supplier.getNextShape();
                setSeriesShape(series, result, false);
            }
        }
        if (result == null) {
            result = this.baseShape;
        }
        return result;
}

Returns a shape used to represent the items in a series.

 public Stroke lookupSeriesStroke(int series) 
{
        // return the override, if there is one...
        if (this.stroke != null) {
            return this.stroke;
        }
        // otherwise look up the paint table
        Stroke result = getSeriesStroke(series);
        if (result == null && this.autoPopulateSeriesStroke) {
            DrawingSupplier supplier = getDrawingSupplier();
            if (supplier != null) {
                result = supplier.getNextStroke();
                setSeriesStroke(series, result, false);
            }
        }
        if (result == null) {
            result = this.baseStroke;
        }
        return result;
}

Returns the stroke used to draw the items in a series.

 public  void notifyListeners(RendererChangeEvent event) 
{
        Object[] ls = this.listenerList.getListenerList();
        for (int i = ls.length - 2; i  >= 0; i -= 2) {
            if (ls[i] == RendererChangeListener.class) {
                ((RendererChangeListener) ls[i + 1]).rendererChanged(event);
            }
        }
}

Notifies all registered listeners that the renderer has been modified.

 public  void removeChangeListener(RendererChangeListener listener) 
{
        if (listener == null) {
            throw new IllegalArgumentException("Null 'listener' argument.");
        }
        this.listenerList.remove(RendererChangeListener.class, listener);
}

Deregisters an object so that it no longer receives notification of changes to the renderer.

 public  void setAutoPopulateSeriesFillPaint(boolean auto) 
{
        this.autoPopulateSeriesFillPaint = auto;
}

Sets the flag that controls whether or not the series fill paint list is automatically populated when #lookupSeriesFillPaint(int) is called.

 public  void setAutoPopulateSeriesOutlinePaint(boolean auto) 
{
        this.autoPopulateSeriesOutlinePaint = auto;
}

Sets the flag that controls whether or not the series outline paint list is automatically populated when #lookupSeriesOutlinePaint(int) is called.

 public  void setAutoPopulateSeriesOutlineStroke(boolean auto) 
{
        this.autoPopulateSeriesOutlineStroke = auto;
}

Sets the flag that controls whether or not the series outline stroke list is automatically populated when #lookupSeriesOutlineStroke(int) is called.

 public  void setAutoPopulateSeriesPaint(boolean auto) 
{
        this.autoPopulateSeriesPaint = auto;
}

Sets the flag that controls whether or not the series paint list is automatically populated when #lookupSeriesPaint(int) is called.

 public  void setAutoPopulateSeriesShape(boolean auto) 
{
        this.autoPopulateSeriesShape = auto;
}

Sets the flag that controls whether or not the series shape list is automatically populated when #lookupSeriesShape(int) is called.

 public  void setAutoPopulateSeriesStroke(boolean auto) 
{
        this.autoPopulateSeriesStroke = auto;
}

Sets the flag that controls whether or not the series stroke list is automatically populated when #lookupSeriesStroke(int) is called.

 public  void setBaseCreateEntities(boolean create) 
{
        // defer argument checking...
        setBaseCreateEntities(create, true);
}

Sets the base flag that controls whether entities are created for a series, and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseCreateEntities(boolean create,
    boolean notify) 
{
        this.baseCreateEntities = create;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base flag that controls whether entities are created and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBaseFillPaint(Paint paint) 
{
        // defer argument checking...
        setBaseFillPaint(paint, true);
}

Sets the base fill paint and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseFillPaint(Paint paint,
    boolean notify) 
{
        if (paint == null) {
            throw new IllegalArgumentException("Null 'paint' argument.");
        }
        this.baseFillPaint = paint;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base fill paint and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBaseItemLabelFont(Font font) 
{
        if (font == null) {
            throw new IllegalArgumentException("Null 'font' argument.");
        }
        setBaseItemLabelFont(font, true);
}

Sets the base item label font and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseItemLabelFont(Font font,
    boolean notify) 
{
        this.baseItemLabelFont = font;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base item label font and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBaseItemLabelPaint(Paint paint) 
{
        // defer argument checking...
        setBaseItemLabelPaint(paint, true);
}

Sets the base item label paint and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseItemLabelPaint(Paint paint,
    boolean notify) 
{
        if (paint == null) {
            throw new IllegalArgumentException("Null 'paint' argument.");
        }
        this.baseItemLabelPaint = paint;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base item label paint and, if requested, sends a RendererChangeEvent to all registered listeners..

 public  void setBaseItemLabelsVisible(boolean visible) 
{
        setBaseItemLabelsVisible(BooleanUtilities.valueOf(visible));
}

Sets the base flag that controls whether or not item labels are visible, and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseItemLabelsVisible(Boolean visible) 
{
        setBaseItemLabelsVisible(visible, true);
}

Sets the base setting for item label visibility and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseItemLabelsVisible(Boolean visible,
    boolean notify) 
{
        this.baseItemLabelsVisible = visible;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base visibility for item labels and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBaseNegativeItemLabelPosition(ItemLabelPosition position) 
{
        setBaseNegativeItemLabelPosition(position, true);
}

Sets the base item label position for negative values and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseNegativeItemLabelPosition(ItemLabelPosition position,
    boolean notify) 
{
        if (position == null) {
            throw new IllegalArgumentException("Null 'position' argument.");
        }
        this.baseNegativeItemLabelPosition = position;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base negative item label position and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBaseOutlinePaint(Paint paint) 
{
        // defer argument checking...
        setBaseOutlinePaint(paint, true);
}

Sets the base outline paint and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseOutlinePaint(Paint paint,
    boolean notify) 
{
        if (paint == null) {
            throw new IllegalArgumentException("Null 'paint' argument.");
        }
        this.baseOutlinePaint = paint;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base outline paint and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBaseOutlineStroke(Stroke stroke) 
{
        setBaseOutlineStroke(stroke, true);
}

Sets the base outline stroke and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseOutlineStroke(Stroke stroke,
    boolean notify) 
{
        if (stroke == null) {
            throw new IllegalArgumentException("Null 'stroke' argument.");
        }
        this.baseOutlineStroke = stroke;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base outline stroke and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBasePaint(Paint paint) 
{
        // defer argument checking...
        setBasePaint(paint, true);
}

Sets the base paint and sends a RendererChangeEvent to all registered listeners.

 public  void setBasePaint(Paint paint,
    boolean notify) 
{
        this.basePaint = paint;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base paint and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBasePositiveItemLabelPosition(ItemLabelPosition position) 
{
        // defer argument checking...
        setBasePositiveItemLabelPosition(position, true);
}

Sets the base positive item label position.

 public  void setBasePositiveItemLabelPosition(ItemLabelPosition position,
    boolean notify) 
{
        if (position == null) {
            throw new IllegalArgumentException("Null 'position' argument.");
        }
        this.basePositiveItemLabelPosition = position;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base positive item label position and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBaseSeriesVisible(boolean visible) 
{
        // defer argument checking...
        setBaseSeriesVisible(visible, true);
}

Sets the base visibility and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseSeriesVisible(boolean visible,
    boolean notify) 
{
        this.baseSeriesVisible = visible;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base visibility and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBaseSeriesVisibleInLegend(boolean visible) 
{
        // defer argument checking...
        setBaseSeriesVisibleInLegend(visible, true);
}

Sets the base visibility in the legend and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseSeriesVisibleInLegend(boolean visible,
    boolean notify) 
{
        this.baseSeriesVisibleInLegend = visible;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base visibility in the legend and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBaseShape(Shape shape) 
{
        // defer argument checking...
        setBaseShape(shape, true);
}

Sets the base shape and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseShape(Shape shape,
    boolean notify) 
{
        if (shape == null) {
            throw new IllegalArgumentException("Null 'shape' argument.");
        }
        this.baseShape = shape;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base shape and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setBaseStroke(Stroke stroke) 
{
        // defer argument checking...
        setBaseStroke(stroke, true);
}

Sets the base stroke and sends a RendererChangeEvent to all registered listeners.

 public  void setBaseStroke(Stroke stroke,
    boolean notify) 
{
        if (stroke == null) {
            throw new IllegalArgumentException("Null 'stroke' argument.");
        }
        this.baseStroke = stroke;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the base stroke and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setCreateEntities(Boolean create) 
{
         setCreateEntities(create, true);
}

Sets the flag that controls whether or not chart entities are created for the items in ALL series, and sends a RendererChangeEvent to all registered listeners. This flag overrides the per series and default settings - you must set it to null if you want the other settings to apply.

 public  void setCreateEntities(Boolean create,
    boolean notify) 
{
        this.createEntities = create;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the flag that controls whether or not chart entities are created for the items in ALL series, and sends a RendererChangeEvent to all registered listeners. This flag overrides the per series and default settings - you must set it to null if you want the other settings to apply.

 public  void setFillPaint(Paint paint) 
{
        setFillPaint(paint, true);
}

Sets the fill paint for ALL series (optional).

 public  void setFillPaint(Paint paint,
    boolean notify) 
{
        this.fillPaint = paint;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the fill paint for ALL series and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setItemLabelAnchorOffset(double offset) 
{
        this.itemLabelAnchorOffset = offset;
        fireChangeEvent();
}

Sets the item label anchor offset.

 public  void setItemLabelFont(Font font) 
{
        setItemLabelFont(font, true);
}

Sets the item label font for ALL series and sends a RendererChangeEvent to all registered listeners. You can set this to null if you prefer to set the font on a per series basis.

 public  void setItemLabelFont(Font font,
    boolean notify) 
{
        this.itemLabelFont = font;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the item label font for ALL series and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setItemLabelPaint(Paint paint) 
{
        setItemLabelPaint(paint, true);
}

Sets the item label paint for ALL series and sends a RendererChangeEvent to all registered listeners.

 public  void setItemLabelPaint(Paint paint,
    boolean notify) 
{
        this.itemLabelPaint = paint;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the item label paint for ALL series and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setItemLabelsVisible(boolean visible) 
{
        setItemLabelsVisible(BooleanUtilities.valueOf(visible));
        // The following alternative is only supported in JDK 1.4 - we support
        // JDK 1.3.1 onwards
        // setItemLabelsVisible(Boolean.valueOf(visible));
}

Sets the visibility of the item labels for ALL series.

 public  void setItemLabelsVisible(Boolean visible) 
{
        setItemLabelsVisible(visible, true);
}

Sets the visibility of the item labels for ALL series (optional).

 public  void setItemLabelsVisible(Boolean visible,
    boolean notify) 
{
        this.itemLabelsVisible = visible;
        if (notify) {
            fireChangeEvent();
        }
}

Sets the visibility of item labels for ALL series and, if requested, sends a RendererChangeEvent to all registered listeners.

 public  void setNegativeItemLabelPosition(ItemLabelPosition position)