public XYStepAreaRenderer() 
{
             
        this(AREA);
}

Constructs a new renderer.

 public XYStepAreaRenderer(int type) 
{
        this(type, null, null);
}

Constructs a new renderer.

Parameters:

type - the type of the renderer.

 public XYStepAreaRenderer(int type,
    XYToolTipGenerator toolTipGenerator,
    XYURLGenerator urlGenerator) 
{
        super();
        setBaseToolTipGenerator(toolTipGenerator);
        setURLGenerator(urlGenerator);
        if (type == AREA) {
            this.plotArea = true;
        }
        else if (type == SHAPES) {
            this.shapesVisible = true;
        }
        else if (type == AREA_AND_SHAPES) {
            this.plotArea = true;
            this.shapesVisible = true;
        }
        this.showOutline = false;
}

Constructs a new renderer.

To specify the type of renderer, use one of the constants: AREA, SHAPES or AREA_AND_SHAPES.

Parameters:

type - the type of renderer.

toolTipGenerator - the tool tip generator to use (null permitted).

urlGenerator - the URL generator (null permitted).

 public Object clone() throws CloneNotSupportedException 
{
        return super.clone();
}

Returns a clone of the renderer.

 public  void drawItem(Graphics2D g2,
    XYItemRendererState state,
    Rectangle2D dataArea,
    PlotRenderingInfo info,
    XYPlot plot,
    ValueAxis domainAxis,
    ValueAxis rangeAxis,
    XYDataset dataset,
    int series,
    int item,
    CrosshairState crosshairState,
    int pass) 
{
        PlotOrientation orientation = plot.getOrientation();
        // Get the item count for the series, so that we can know which is the
        // end of the series.
        int itemCount = dataset.getItemCount(series);
        Paint paint = getItemPaint(series, item);
        Stroke seriesStroke = getItemStroke(series, item);
        g2.setPaint(paint);
        g2.setStroke(seriesStroke);
        // get the data point...
        double x1 = dataset.getXValue(series, item);
        double y1 = dataset.getYValue(series, item);
        double x = x1;
        double y = Double.isNaN(y1) ? getRangeBase() : y1;
        double transX1 = domainAxis.valueToJava2D(x, dataArea,
                plot.getDomainAxisEdge());
        double transY1 = rangeAxis.valueToJava2D(y, dataArea,
                plot.getRangeAxisEdge());
        // avoid possible sun.dc.pr.PRException: endPath: bad path
        transY1 = restrictValueToDataArea(transY1, plot, dataArea);
        if (this.pArea == null && !Double.isNaN(y1)) {
            // Create a new Area for the series
            this.pArea = new Polygon();
            // start from Y = rangeBase
            double transY2 = rangeAxis.valueToJava2D(getRangeBase(), dataArea,
                    plot.getRangeAxisEdge());
            // avoid possible sun.dc.pr.PRException: endPath: bad path
            transY2 = restrictValueToDataArea(transY2, plot, dataArea);
            // The first point is (x, this.baseYValue)
            if (orientation == PlotOrientation.VERTICAL) {
                this.pArea.addPoint((int) transX1, (int) transY2);
            }
            else if (orientation == PlotOrientation.HORIZONTAL) {
                this.pArea.addPoint((int) transY2, (int) transX1);
            }
        }
        double transX0 = 0;
        double transY0 = restrictValueToDataArea(getRangeBase(), plot,
                dataArea);
        double x0;
        double y0;
        if (item  > 0) {
            // get the previous data point...
            x0 = dataset.getXValue(series, item - 1);
            y0 = Double.isNaN(y1) ? y1 : dataset.getYValue(series, item - 1);
            x = x0;
            y = Double.isNaN(y0) ? getRangeBase() : y0;
            transX0 = domainAxis.valueToJava2D(x, dataArea,
                    plot.getDomainAxisEdge());
            transY0 = rangeAxis.valueToJava2D(y, dataArea,
                    plot.getRangeAxisEdge());
            // avoid possible sun.dc.pr.PRException: endPath: bad path
            transY0 = restrictValueToDataArea(transY0, plot, dataArea);
            if (Double.isNaN(y1)) {
                // NULL value - > insert point on base line
                // instead of 'step point'
                transX1 = transX0;
                transY0 = transY1;
            }
            if (transY0 != transY1) {
                // not just a horizontal bar but need to perform a 'step'.
                if (orientation == PlotOrientation.VERTICAL) {
                    this.pArea.addPoint((int) transX1, (int) transY0);
                }
                else if (orientation == PlotOrientation.HORIZONTAL) {
                    this.pArea.addPoint((int) transY0, (int) transX1);
                }
            }
        }
        Shape shape = null;
        if (!Double.isNaN(y1)) {
            // Add each point to Area (x, y)
            if (orientation == PlotOrientation.VERTICAL) {
                this.pArea.addPoint((int) transX1, (int) transY1);
            }
            else if (orientation == PlotOrientation.HORIZONTAL) {
                this.pArea.addPoint((int) transY1, (int) transX1);
            }
            if (getShapesVisible()) {
                shape = getItemShape(series, item);
                if (orientation == PlotOrientation.VERTICAL) {
                    shape = ShapeUtilities.createTranslatedShape(shape,
                            transX1, transY1);
                }
                else if (orientation == PlotOrientation.HORIZONTAL) {
                    shape = ShapeUtilities.createTranslatedShape(shape,
                            transY1, transX1);
                }
                if (isShapesFilled()) {
                    g2.fill(shape);
                }
                else {
                    g2.draw(shape);
                }
            }
            else {
                if (orientation == PlotOrientation.VERTICAL) {
                    shape = new Rectangle2D.Double(transX1 - 2, transY1 - 2,
                            4.0, 4.0);
                }
                else if (orientation == PlotOrientation.HORIZONTAL) {
                    shape = new Rectangle2D.Double(transY1 - 2, transX1 - 2,
                            4.0, 4.0);
                }
            }
        }
        // Check if the item is the last item for the series or if it
        // is a NULL value and number of items  > 0.  We can't draw an area for
        // a single point.
        if (getPlotArea() && item  > 0 && this.pArea != null
                          && (item == (itemCount - 1) || Double.isNaN(y1))) {
            double transY2 = rangeAxis.valueToJava2D(getRangeBase(), dataArea,
                    plot.getRangeAxisEdge());
            // avoid possible sun.dc.pr.PRException: endPath: bad path
            transY2 = restrictValueToDataArea(transY2, plot, dataArea);
            if (orientation == PlotOrientation.VERTICAL) {
                // Add the last point (x,0)
                this.pArea.addPoint((int) transX1, (int) transY2);
            }
            else if (orientation == PlotOrientation.HORIZONTAL) {
                // Add the last point (x,0)
                this.pArea.addPoint((int) transY2, (int) transX1);
            }
            // fill the polygon
            g2.fill(this.pArea);
            // draw an outline around the Area.
            if (isOutline()) {
                g2.setStroke(plot.getOutlineStroke());
                g2.setPaint(plot.getOutlinePaint());
                g2.draw(this.pArea);
            }
            // start new area when needed (see above)
            this.pArea = null;
        }
        // do we need to update the crosshair values?
        if (!Double.isNaN(y1)) {
            int domainAxisIndex = plot.getDomainAxisIndex(domainAxis);
            int rangeAxisIndex = plot.getRangeAxisIndex(rangeAxis);
            updateCrosshairValues(crosshairState, x1, y1, domainAxisIndex,
                    rangeAxisIndex, transX1, transY1, orientation);
        }
        // collect entity and tool tip information...
        EntityCollection entities = state.getEntityCollection();
        if (entities != null) {
            addEntity(entities, shape, dataset, series, item, transX1, transY1);
        }
}

Draws the visual representation of a single data item.

 public boolean equals(Object obj) 
{
        if (obj == this) {
            return true;
        }
        if (!(obj instanceof XYStepAreaRenderer)) {
            return false;
        }
        XYStepAreaRenderer that = (XYStepAreaRenderer) obj;
        if (this.showOutline != that.showOutline) {
            return false;
        }
        if (this.shapesVisible != that.shapesVisible) {
            return false;
        }
        if (this.shapesFilled != that.shapesFilled) {
            return false;
        }
        if (this.plotArea != that.plotArea) {
            return false;
        }
        if (this.rangeBase != that.rangeBase) {
            return false;
        }
        return super.equals(obj);
}

Tests this renderer for equality with an arbitrary object.

 public boolean getPlotArea() 
{
        return this.plotArea;
}

Returns true if Area is being plotted by the renderer.

 public double getRangeBase() 
{
        return this.rangeBase;
}

Returns the value on the range axis which defines the 'lower' border of the area.

 public boolean getShapesVisible() 
{
        return this.shapesVisible;
}

Returns true if shapes are being plotted by the renderer.

 public XYItemRendererState initialise(Graphics2D g2,
    Rectangle2D dataArea,
    XYPlot plot,
    XYDataset data,
    PlotRenderingInfo info) 
{
        XYItemRendererState state = super.initialise(g2, dataArea, plot, data,
                info);
        // disable visible items optimisation - it doesn't work for this
        // renderer...
        state.setProcessVisibleItemsOnly(false);
        return state;
}

Initialises the renderer. Here we calculate the Java2D y-coordinate for zero, since all the bars have their bases fixed at zero.

 public boolean isOutline() 
{
        return this.showOutline;
}

Returns a flag that controls whether or not outlines of the areas are drawn.

 public boolean isShapesFilled() 
{
        return this.shapesFilled;
}

Returns the flag that controls whether or not the shapes are filled.

 protected static double restrictValueToDataArea(double value,
    XYPlot plot,
    Rectangle2D dataArea) 
{
        double min = 0;
        double max = 0;
        if (plot.getOrientation() == PlotOrientation.VERTICAL) {
            min = dataArea.getMinY();
            max = dataArea.getMaxY();
        }
        else if (plot.getOrientation() ==  PlotOrientation.HORIZONTAL) {
            min = dataArea.getMinX();
            max = dataArea.getMaxX();
        }
        if (value <  min) {
            value = min;
        }
        else if (value  > max) {
            value = max;
        }
        return value;
}

Helper method which returns a value if it lies inside the visible dataArea and otherwise the corresponding coordinate on the border of the dataArea. The PlotOrientation is taken into account. Useful to avoid possible sun.dc.pr.PRException: endPath: bad path which occurs when trying to draw lines/shapes which in large part lie outside of the visible dataArea.

 public  void setOutline(boolean show) 
{
        this.showOutline = show;
        fireChangeEvent();
}

Sets a flag that controls whether or not outlines of the areas are drawn, and sends a RendererChangeEvent to all registered listeners.

 public  void setPlotArea(boolean flag) 
{
        this.plotArea = flag;
        fireChangeEvent();
}

Sets a flag that controls whether or not areas are drawn for each data item and sends a RendererChangeEvent to all registered listeners.

 public  void setRangeBase(double val) 
{
        this.rangeBase = val;
        fireChangeEvent();
}

Sets the value on the range axis which defines the default border of the area, and sends a RendererChangeEvent to all registered listeners. E.g. setRangeBase(Double.NEGATIVE_INFINITY) lets areas always reach the lower border of the plotArea.

 public  void setShapesFilled(boolean filled) 
{
        this.shapesFilled = filled;
        fireChangeEvent();
}

Sets the 'shapes filled' for ALL series and sends a RendererChangeEvent to all registered listeners.

 public  void setShapesVisible(boolean flag) 
{
        this.shapesVisible = flag;
        fireChangeEvent();
}

Sets the flag that controls whether or not shapes are displayed for each data item, and sends a RendererChangeEvent to all registered listeners.