public DeviationRenderer() 
{
        this(true, true);
}

Creates a new renderer that displays lines and shapes for the data items, as well as the shaded area for the y-interval.

 public DeviationRenderer(boolean lines,
    boolean shapes) 
{
        super(lines, shapes);
        super.setDrawSeriesLineAsPath(true);
        this.alpha = 0.5f;
}

Creates a new renderer.

Parameters:

lines - show lines between data items?

shapes - show a shape for each data item?

 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) 
{
        // do nothing if item is not visible
        if (!getItemVisible(series, item)) {
            return;
        }
        // first pass draws the shading
        if (pass == 0) {
            IntervalXYDataset intervalDataset = (IntervalXYDataset) dataset;
            State drState = (State) state;
            double x = intervalDataset.getXValue(series, item);
            double yLow = intervalDataset.getStartYValue(series, item);
            double yHigh  = intervalDataset.getEndYValue(series, item);
            RectangleEdge xAxisLocation = plot.getDomainAxisEdge();
            RectangleEdge yAxisLocation = plot.getRangeAxisEdge();
            double xx = domainAxis.valueToJava2D(x, dataArea, xAxisLocation);
            double yyLow = rangeAxis.valueToJava2D(yLow, dataArea,
                    yAxisLocation);
            double yyHigh = rangeAxis.valueToJava2D(yHigh, dataArea,
                    yAxisLocation);
            PlotOrientation orientation = plot.getOrientation();
            if (orientation == PlotOrientation.HORIZONTAL) {
                drState.lowerCoordinates.add(new double[] {yyLow, xx});
                drState.upperCoordinates.add(new double[] {yyHigh, xx});
            }
            else if (orientation == PlotOrientation.VERTICAL) {
                drState.lowerCoordinates.add(new double[] {xx, yyLow});
                drState.upperCoordinates.add(new double[] {xx, yyHigh});
            }
            if (item == (dataset.getItemCount(series) - 1)) {
                // last item in series, draw the lot...
                // set up the alpha-transparency...
                Composite originalComposite = g2.getComposite();
                g2.setComposite(AlphaComposite.getInstance(
                        AlphaComposite.SRC_OVER, this.alpha));
                g2.setPaint(getItemFillPaint(series, item));
                GeneralPath area = new GeneralPath();
                double[] coords = (double[]) drState.lowerCoordinates.get(0);
                area.moveTo((float) coords[0], (float) coords[1]);
                for (int i = 1; i <  drState.lowerCoordinates.size(); i++) {
                    coords = (double[]) drState.lowerCoordinates.get(i);
                    area.lineTo((float) coords[0], (float) coords[1]);
                }
                int count = drState.upperCoordinates.size();
                coords = (double[]) drState.upperCoordinates.get(count - 1);
                area.lineTo((float) coords[0], (float) coords[1]);
                for (int i = count - 2; i  >= 0; i--) {
                    coords = (double[]) drState.upperCoordinates.get(i);
                    area.lineTo((float) coords[0], (float) coords[1]);
                }
                area.closePath();
                g2.fill(area);
                g2.setComposite(originalComposite);
                drState.lowerCoordinates.clear();
                drState.upperCoordinates.clear();
            }
        }
        if (isLinePass(pass)) {
            // the following code handles the line for the y-values...it's
            // all done by code in the super class
            if (item == 0) {
                State s = (State) state;
                s.seriesPath.reset();
                s.setLastPointGood(false);
            }
            if (getItemLineVisible(series, item)) {
                drawPrimaryLineAsPath(state, g2, plot, dataset, pass,
                        series, item, domainAxis, rangeAxis, dataArea);
            }
        }
        // second pass adds shapes where the items are ..
        else if (isItemPass(pass)) {
            // setup for collecting optional entity info...
            EntityCollection entities = null;
            if (info != null) {
                entities = info.getOwner().getEntityCollection();
            }
            drawSecondaryPass(g2, plot, dataset, pass, series, item,
                    domainAxis, dataArea, rangeAxis, crosshairState, entities);
        }
}

Draws the visual representation of a single data item.

 public boolean equals(Object obj) 
{
        if (obj == this) {
            return true;
        }
        if (!(obj instanceof DeviationRenderer)) {
            return false;
        }
        DeviationRenderer that = (DeviationRenderer) obj;
        if (this.alpha != that.alpha) {
            return false;
        }
        return super.equals(obj);
}

Tests this renderer for equality with an arbitrary object.

 public Range findRangeBounds(XYDataset dataset) 
{
        if (dataset != null) {
            return DatasetUtilities.findRangeBounds(dataset, true);
        }
        else {
            return null;
        }
}

Returns the range of values the renderer requires to display all the items from the specified dataset.

 public float getAlpha() 
{
        return this.alpha;
}

Returns the alpha transparency for the background shading.

 public int getPassCount() 
{
        return 3;
}

Returns the number of passes (through the dataset) used by this renderer.

 public XYItemRendererState initialise(Graphics2D g2,
    Rectangle2D dataArea,
    XYPlot plot,
    XYDataset dataset,
    PlotRenderingInfo info) 
{
        State state = new State(info);
        state.seriesPath = new GeneralPath();
        state.setProcessVisibleItemsOnly(false);
        return state;
}

Initialises and returns a state object that can be passed to each invocation of the #drawItem method.

 protected boolean isItemPass(int pass) 
{
        return (pass == 2);
}

Returns true if this is the pass where the shapes are drawn.

 protected boolean isLinePass(int pass) 
{
        return (pass == 1);
}

Returns true if this is the pass where the lines are drawn.

 public  void setAlpha(float alpha) 
{
        if (alpha <  0.0f || alpha  > 1.0f) {
            throw new IllegalArgumentException(
                    "Requires 'alpha' in the range 0.0 to 1.0.");
        }
        this.alpha = alpha;
        fireChangeEvent();
}

Sets the alpha transparency for the background shading, and sends a RendererChangeEvent to all registered listeners.

 public  void setDrawSeriesLineAsPath(boolean flag) 
{
        // ignore
}

This method is overridden so that this flag cannot be changed---it is set to true for this renderer.