public StackedBarRenderer() 
{
                                                           
        this(false);
}

Creates a new renderer. By default, the renderer has no tool tip generator and no URL generator. These defaults have been chosen to minimise the processing required to generate a default chart. If you require tool tips or URLs, then you can easily add the required generators.

 public StackedBarRenderer(boolean renderAsPercentages) 
{
        super();
        this.renderAsPercentages = renderAsPercentages;
        // set the default item label positions, which will only be used if
        // the user requests visible item labels...
        ItemLabelPosition p = new ItemLabelPosition(ItemLabelAnchor.CENTER,
                TextAnchor.CENTER);
        setBasePositiveItemLabelPosition(p);
        setBaseNegativeItemLabelPosition(p);
        setPositiveItemLabelPositionFallback(null);
        setNegativeItemLabelPositionFallback(null);
}

Creates a new renderer.

Parameters:

renderAsPercentages - a flag that controls whether the data values are rendered as percentages.

 protected  void calculateBarWidth(CategoryPlot plot,
    Rectangle2D dataArea,
    int rendererIndex,
    CategoryItemRendererState state) 
{
        // calculate the bar width
        CategoryAxis xAxis = plot.getDomainAxisForDataset(rendererIndex);
        CategoryDataset data = plot.getDataset(rendererIndex);
        if (data != null) {
            PlotOrientation orientation = plot.getOrientation();
            double space = 0.0;
            if (orientation == PlotOrientation.HORIZONTAL) {
                space = dataArea.getHeight();
            }
            else if (orientation == PlotOrientation.VERTICAL) {
                space = dataArea.getWidth();
            }
            double maxWidth = space * getMaximumBarWidth();
            int columns = data.getColumnCount();
            double categoryMargin = 0.0;
            if (columns  > 1) {
                categoryMargin = xAxis.getCategoryMargin();
            }
            double used = space * (1 - xAxis.getLowerMargin()
                                     - xAxis.getUpperMargin()
                                     - categoryMargin);
            if (columns  > 0) {
                state.setBarWidth(Math.min(used / columns, maxWidth));
            }
            else {
                state.setBarWidth(Math.min(used, maxWidth));
            }
        }
}

Calculates the bar width and stores it in the renderer state.

 public  void drawItem(Graphics2D g2,
    CategoryItemRendererState state,
    Rectangle2D dataArea,
    CategoryPlot plot,
    CategoryAxis domainAxis,
    ValueAxis rangeAxis,
    CategoryDataset dataset,
    int row,
    int column,
    int pass) 
{
        // nothing is drawn for null values...
        Number dataValue = dataset.getValue(row, column);
        if (dataValue == null) {
            return;
        }
        double value = dataValue.doubleValue();
        double total = 0.0;  // only needed if calculating percentages
        if (this.renderAsPercentages) {
            total = DataUtilities.calculateColumnTotal(dataset, column);
            value = value / total;
        }
        PlotOrientation orientation = plot.getOrientation();
        double barW0 = domainAxis.getCategoryMiddle(column, getColumnCount(),
                dataArea, plot.getDomainAxisEdge())
                - state.getBarWidth() / 2.0;
        double positiveBase = getBase();
        double negativeBase = positiveBase;
        for (int i = 0; i <  row; i++) {
            Number v = dataset.getValue(i, column);
            if (v != null) {
                double d = v.doubleValue();
                if (this.renderAsPercentages) {
                    d = d / total;
                }
                if (d  > 0) {
                    positiveBase = positiveBase + d;
                }
                else {
                    negativeBase = negativeBase + d;
                }
            }
        }
        double translatedBase;
        double translatedValue;
        RectangleEdge location = plot.getRangeAxisEdge();
        if (value  >= 0.0) {
            translatedBase = rangeAxis.valueToJava2D(positiveBase, dataArea,
                    location);
            translatedValue = rangeAxis.valueToJava2D(positiveBase + value,
                    dataArea, location);
        }
        else {
            translatedBase = rangeAxis.valueToJava2D(negativeBase, dataArea,
                    location);
            translatedValue = rangeAxis.valueToJava2D(negativeBase + value,
                    dataArea, location);
        }
        double barL0 = Math.min(translatedBase, translatedValue);
        double barLength = Math.max(Math.abs(translatedValue - translatedBase),
                getMinimumBarLength());
        Rectangle2D bar = null;
        if (orientation == PlotOrientation.HORIZONTAL) {
            bar = new Rectangle2D.Double(barL0, barW0, barLength,
                    state.getBarWidth());
        }
        else {
            bar = new Rectangle2D.Double(barW0, barL0, state.getBarWidth(),
                    barLength);
        }
        if (pass == 0) {
            Paint itemPaint = getItemPaint(row, column);
            GradientPaintTransformer t = getGradientPaintTransformer();
            if (t != null && itemPaint instanceof GradientPaint) {
                itemPaint = t.transform((GradientPaint) itemPaint, bar);
            }
            g2.setPaint(itemPaint);
            g2.fill(bar);
            if (isDrawBarOutline()
                    && state.getBarWidth()  > BAR_OUTLINE_WIDTH_THRESHOLD) {
                g2.setStroke(getItemOutlineStroke(row, column));
                g2.setPaint(getItemOutlinePaint(row, column));
                g2.draw(bar);
            }
            // add an item entity, if this information is being collected
            EntityCollection entities = state.getEntityCollection();
            if (entities != null) {
                addItemEntity(entities, dataset, row, column, bar);
            }
        }
        else if (pass == 1) {
            CategoryItemLabelGenerator generator = getItemLabelGenerator(row,
                    column);
            if (generator != null && isItemLabelVisible(row, column)) {
                drawItemLabel(g2, dataset, row, column, plot, generator, bar,
                        (value <  0.0));
            }
        }
}

Draws a stacked bar for a specific item.

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

Tests this renderer for equality with an arbitrary object.

 public Range findRangeBounds(CategoryDataset dataset) 
{
        if (this.renderAsPercentages) {
            return new Range(0.0, 1.0);
        }
        else {
            return DatasetUtilities.findStackedRangeBounds(dataset, getBase());
        }
}

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

 public int getPassCount() 
{
        return 2;
}

Returns the number of passes (2) required by this renderer. The first pass is used to draw the bars, the second pass is used to draw the item labels (if visible).

 public boolean getRenderAsPercentages() 
{
        return this.renderAsPercentages;
}

Returns true if the renderer displays each item value as a percentage (so that the stacked bars add to 100%), and false otherwise.

 public  void setRenderAsPercentages(boolean asPercentages) 
{
        this.renderAsPercentages = asPercentages;
        fireChangeEvent();
}

Sets the flag that controls whether the renderer displays each item value as a percentage (so that the stacked bars add to 100%), and sends a RendererChangeEvent to all registered listeners.