Source for org.jfree.chart.renderer.xy.StackedXYBarRenderer

   1: /* ===========================================================
   2:  * JFreeChart : a free chart library for the Java(tm) platform
   3:  * ===========================================================
   4:  *
   5:  * (C) Copyright 2000-2007, by Object Refinery Limited and Contributors.
   6:  *
   7:  * Project Info:  http://www.jfree.org/jfreechart/index.html
   8:  *
   9:  * This library is free software; you can redistribute it and/or modify it 
  10:  * under the terms of the GNU Lesser General Public License as published by 
  11:  * the Free Software Foundation; either version 2.1 of the License, or 
  12:  * (at your option) any later version.
  13:  *
  14:  * This library is distributed in the hope that it will be useful, but 
  15:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
  16:  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
  17:  * License for more details.
  18:  *
  19:  * You should have received a copy of the GNU Lesser General Public
  20:  * License along with this library; if not, write to the Free Software
  21:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 
  22:  * USA.  
  23:  *
  24:  * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
  25:  * in the United States and other countries.]
  26:  *
  27:  * -------------------------
  28:  * StackedXYBarRenderer.java
  29:  * -------------------------
  30:  * (C) Copyright 2004-2007, by Andreas Schroeder and Contributors.
  31:  *
  32:  * Original Author:  Andreas Schroeder;
  33:  * Contributor(s):   David Gilbert (for Object Refinery Limited);
  34:  *
  35:  * Changes
  36:  * -------
  37:  * 01-Apr-2004 : Version 1 (AS);
  38:  * 15-Jul-2004 : Switched getX() with getXValue() and getY() with 
  39:  *               getYValue() (DG);
  40:  * 15-Aug-2004 : Added drawBarOutline to control draw/don't-draw bar 
  41:  *               outlines (BN);
  42:  * 10-Sep-2004 : drawBarOutline attribute is now inherited from XYBarRenderer 
  43:  *               and double primitives are retrieved from the dataset rather 
  44:  *               than Number objects (DG);
  45:  * 07-Jan-2005 : Updated for method name change in DatasetUtilities (DG);
  46:  * 25-Jan-2005 : Modified to handle negative values correctly (DG);
  47:  * ------------- JFREECHART 1.0.x ---------------------------------------------
  48:  * 06-Dec-2006 : Added support for GradientPaint (DG);
  49:  * 15-Mar-2007 : Added renderAsPercentages option (DG);
  50:  * 
  51:  */
  52: 
  53: package org.jfree.chart.renderer.xy;
  54: 
  55: import java.awt.GradientPaint;
  56: import java.awt.Graphics2D;
  57: import java.awt.Paint;
  58: import java.awt.geom.Rectangle2D;
  59: 
  60: import org.jfree.chart.axis.ValueAxis;
  61: import org.jfree.chart.entity.EntityCollection;
  62: import org.jfree.chart.event.RendererChangeEvent;
  63: import org.jfree.chart.labels.ItemLabelAnchor;
  64: import org.jfree.chart.labels.ItemLabelPosition;
  65: import org.jfree.chart.labels.XYItemLabelGenerator;
  66: import org.jfree.chart.plot.CrosshairState;
  67: import org.jfree.chart.plot.PlotOrientation;
  68: import org.jfree.chart.plot.PlotRenderingInfo;
  69: import org.jfree.chart.plot.XYPlot;
  70: import org.jfree.data.Range;
  71: import org.jfree.data.general.DatasetUtilities;
  72: import org.jfree.data.xy.IntervalXYDataset;
  73: import org.jfree.data.xy.TableXYDataset;
  74: import org.jfree.data.xy.XYDataset;
  75: import org.jfree.ui.RectangleEdge;
  76: import org.jfree.ui.TextAnchor;
  77: 
  78: /**
  79:  * A bar renderer that displays the series items stacked.
  80:  * The dataset used together with this renderer must be a
  81:  * {@link org.jfree.data.xy.IntervalXYDataset} and a
  82:  * {@link org.jfree.data.xy.TableXYDataset}. For example, the
  83:  * dataset class {@link org.jfree.data.xy.CategoryTableXYDataset}
  84:  * implements both interfaces.
  85:  */
  86: public class StackedXYBarRenderer extends XYBarRenderer {
  87:   
  88:     /** For serialization. */
  89:     private static final long serialVersionUID = -7049101055533436444L;
  90:     
  91:     /** A flag that controls whether the bars display values or percentages. */
  92:     private boolean renderAsPercentages;
  93: 
  94:     /**
  95:      * Creates a new renderer.
  96:      */
  97:     public StackedXYBarRenderer() {
  98:         this(0.0);
  99:     }
 100: 
 101:     /**
 102:      * Creates a new renderer.
 103:      *
 104:      * @param margin  the percentual amount of the bars that are cut away.
 105:      */
 106:     public StackedXYBarRenderer(double margin) {
 107:         super(margin);
 108:         this.renderAsPercentages = false;
 109:         
 110:         // set the default item label positions, which will only be used if 
 111:         // the user requests visible item labels...
 112:         ItemLabelPosition p = new ItemLabelPosition(ItemLabelAnchor.CENTER, 
 113:                 TextAnchor.CENTER);
 114:         setBasePositiveItemLabelPosition(p);
 115:         setBaseNegativeItemLabelPosition(p);
 116:         setPositiveItemLabelPositionFallback(null);
 117:         setNegativeItemLabelPositionFallback(null);
 118:     }
 119: 
 120:     /**
 121:      * Returns <code>true</code> if the renderer displays each item value as
 122:      * a percentage (so that the stacked bars add to 100%), and 
 123:      * <code>false</code> otherwise.
 124:      * 
 125:      * @return A boolean.
 126:      * 
 127:      * @see #setRenderAsPercentages(boolean)
 128:      * 
 129:      * @since 1.0.5
 130:      */
 131:     public boolean getRenderAsPercentages() {
 132:         return this.renderAsPercentages;   
 133:     }
 134:     
 135:     /**
 136:      * Sets the flag that controls whether the renderer displays each item
 137:      * value as a percentage (so that the stacked bars add to 100%), and sends
 138:      * a {@link RendererChangeEvent} to all registered listeners.
 139:      * 
 140:      * @param asPercentages  the flag.
 141:      * 
 142:      * @see #getRenderAsPercentages()
 143:      * 
 144:      * @since 1.0.5
 145:      */
 146:     public void setRenderAsPercentages(boolean asPercentages) {
 147:         this.renderAsPercentages = asPercentages; 
 148:         fireChangeEvent();
 149:     }
 150: 
 151:     /**
 152:      * Returns <code>2</code> to indicate that this renderer requires two 
 153:      * passes for drawing (item labels are drawn in the second pass so that 
 154:      * they always appear in front of all the bars).
 155:      * 
 156:      * @return <code>2</code>.
 157:      */
 158:     public int getPassCount() {
 159:         return 2;
 160:     }
 161: 
 162:     /**
 163:      * Initialises the renderer and returns a state object that should be 
 164:      * passed to all subsequent calls to the drawItem() method. Here there is 
 165:      * nothing to do.
 166:      *
 167:      * @param g2  the graphics device.
 168:      * @param dataArea  the area inside the axes.
 169:      * @param plot  the plot.
 170:      * @param data  the data.
 171:      * @param info  an optional info collection object to return data back to
 172:      *              the caller.
 173:      *
 174:      * @return A state object.
 175:      */
 176:     public XYItemRendererState initialise(Graphics2D g2,
 177:                                           Rectangle2D dataArea,
 178:                                           XYPlot plot,
 179:                                           XYDataset data,
 180:                                           PlotRenderingInfo info) {
 181:         return new XYBarRendererState(info);
 182:     }
 183: 
 184:     /**
 185:      * Returns the range of values the renderer requires to display all the 
 186:      * items from the specified dataset.
 187:      * 
 188:      * @param dataset  the dataset (<code>null</code> permitted).
 189:      * 
 190:      * @return The range (<code>null</code> if the dataset is <code>null</code>
 191:      *         or empty).
 192:      */
 193:     public Range findRangeBounds(XYDataset dataset) {
 194:         if (dataset != null) {
 195:             if (this.renderAsPercentages) {
 196:                 return new Range(0.0, 1.0);
 197:             }
 198:             else {
 199:                 return DatasetUtilities.findStackedRangeBounds(
 200:                         (TableXYDataset) dataset);
 201:             }
 202:         }
 203:         else {
 204:             return null;
 205:         }
 206:     }
 207: 
 208:     /**
 209:      * Draws the visual representation of a single data item.
 210:      *
 211:      * @param g2  the graphics device.
 212:      * @param state  the renderer state.
 213:      * @param dataArea  the area within which the plot is being drawn.
 214:      * @param info  collects information about the drawing.
 215:      * @param plot  the plot (can be used to obtain standard color information 
 216:      *              etc).
 217:      * @param domainAxis  the domain axis.
 218:      * @param rangeAxis  the range axis.
 219:      * @param dataset  the dataset.
 220:      * @param series  the series index (zero-based).
 221:      * @param item  the item index (zero-based).
 222:      * @param crosshairState  crosshair information for the plot 
 223:      *                        (<code>null</code> permitted).
 224:      * @param pass  the pass index.
 225:      */
 226:     public void drawItem(Graphics2D g2, 
 227:                          XYItemRendererState state,
 228:                          Rectangle2D dataArea,
 229:                          PlotRenderingInfo info,
 230:                          XYPlot plot,
 231:                          ValueAxis domainAxis,
 232:                          ValueAxis rangeAxis,
 233:                          XYDataset dataset,
 234:                          int series,
 235:                          int item,
 236:                          CrosshairState crosshairState,
 237:                          int pass) {
 238:         
 239:         if (!(dataset instanceof IntervalXYDataset 
 240:                 && dataset instanceof TableXYDataset)) {
 241:             String message = "dataset (type " + dataset.getClass().getName() 
 242:                 + ") has wrong type:";
 243:             boolean and = false;
 244:             if (!IntervalXYDataset.class.isAssignableFrom(dataset.getClass())) {
 245:                 message += " it is no IntervalXYDataset";
 246:                 and = true;
 247:             }
 248:             if (!TableXYDataset.class.isAssignableFrom(dataset.getClass())) {
 249:                 if (and) {
 250:                     message += " and";
 251:                 }
 252:                 message += " it is no TableXYDataset";
 253:             }
 254: 
 255:             throw new IllegalArgumentException(message);
 256:         }
 257: 
 258:         IntervalXYDataset intervalDataset = (IntervalXYDataset) dataset;
 259:         double value = intervalDataset.getYValue(series, item);
 260:         if (Double.isNaN(value)) {
 261:             return;
 262:         }
 263:         
 264:         // if we are rendering the values as percentages, we need to calculate
 265:         // the total for the current item.  Unfortunately here we end up 
 266:         // repeating the calculation more times than is strictly necessary -
 267:         // hopefully I'll come back to this and find a way to add the 
 268:         // total(s) to the renderer state.  The other problem is we implicitly
 269:         // assume the dataset has no negative values...perhaps that can be
 270:         // fixed too.
 271:         double total = 0.0;  
 272:         if (this.renderAsPercentages) {
 273:             total = DatasetUtilities.calculateStackTotal(
 274:                     (TableXYDataset) dataset, item);
 275:             value = value / total;
 276:         }
 277:         
 278:         double positiveBase = 0.0;
 279:         double negativeBase = 0.0;
 280:         
 281:         for (int i = 0; i < series; i++) {
 282:             double v = dataset.getYValue(i, item);
 283:             if (!Double.isNaN(v)) {
 284:                 if (this.renderAsPercentages) {
 285:                     v = v / total;
 286:                 }
 287:                 if (v > 0) {
 288:                     positiveBase = positiveBase + v;
 289:                 }
 290:                 else {
 291:                     negativeBase = negativeBase + v;
 292:                 }
 293:             }
 294:         }
 295: 
 296:         double translatedBase;
 297:         double translatedValue;
 298:         RectangleEdge edgeR = plot.getRangeAxisEdge();
 299:         if (value > 0.0) {
 300:             translatedBase = rangeAxis.valueToJava2D(positiveBase, dataArea, 
 301:                     edgeR);
 302:             translatedValue = rangeAxis.valueToJava2D(positiveBase + value, 
 303:                     dataArea, edgeR);
 304:         }
 305:         else {
 306:             translatedBase = rangeAxis.valueToJava2D(negativeBase, dataArea, 
 307:                     edgeR);
 308:             translatedValue = rangeAxis.valueToJava2D(negativeBase + value, 
 309:                     dataArea, edgeR);
 310:         }
 311: 
 312:         RectangleEdge edgeD = plot.getDomainAxisEdge();
 313:         double startX = intervalDataset.getStartXValue(series, item);
 314:         if (Double.isNaN(startX)) {
 315:             return;
 316:         }
 317:         double translatedStartX = domainAxis.valueToJava2D(startX, dataArea, 
 318:                 edgeD);
 319: 
 320:         double endX = intervalDataset.getEndXValue(series, item);
 321:         if (Double.isNaN(endX)) {
 322:             return;
 323:         }
 324:         double translatedEndX = domainAxis.valueToJava2D(endX, dataArea, edgeD);
 325: 
 326:         double translatedWidth = Math.max(1, Math.abs(translatedEndX 
 327:                 - translatedStartX));
 328:         double translatedHeight = Math.abs(translatedValue - translatedBase);
 329:         if (getMargin() > 0.0) {
 330:             double cut = translatedWidth * getMargin();
 331:             translatedWidth = translatedWidth - cut;
 332:             translatedStartX = translatedStartX + cut / 2;
 333:         }
 334: 
 335:         Rectangle2D bar = null;
 336:         PlotOrientation orientation = plot.getOrientation();
 337:         if (orientation == PlotOrientation.HORIZONTAL) {
 338:             bar = new Rectangle2D.Double(Math.min(translatedBase, 
 339:                     translatedValue), translatedEndX, translatedHeight,
 340:                     translatedWidth);
 341:         }
 342:         else if (orientation == PlotOrientation.VERTICAL) {
 343:             bar = new Rectangle2D.Double(translatedStartX,
 344:                     Math.min(translatedBase, translatedValue),
 345:                     translatedWidth, translatedHeight);
 346:         }
 347: 
 348:         if (pass == 0) {
 349:             Paint itemPaint = getItemPaint(series, item);
 350:             if (getGradientPaintTransformer() 
 351:                     != null && itemPaint instanceof GradientPaint) {
 352:                 GradientPaint gp = (GradientPaint) itemPaint;
 353:                 itemPaint = getGradientPaintTransformer().transform(gp, bar);
 354:             }
 355:             g2.setPaint(itemPaint);
 356:             g2.fill(bar);
 357:             if (isDrawBarOutline() 
 358:                     && Math.abs(translatedEndX - translatedStartX) > 3) {
 359:                 g2.setStroke(getItemStroke(series, item));
 360:                 g2.setPaint(getItemOutlinePaint(series, item));
 361:                 g2.draw(bar);
 362:             }
 363: 
 364:             // add an entity for the item...
 365:             if (info != null) {
 366:                 EntityCollection entities = info.getOwner()
 367:                         .getEntityCollection();
 368:                 if (entities != null) {
 369:                     addEntity(entities, bar, dataset, series, item, 
 370:                             bar.getCenterX(), bar.getCenterY());
 371:                 }
 372:             }
 373:         }
 374:         else if (pass == 1) {
 375:             // handle item label drawing, now that we know all the bars have
 376:             // been drawn...
 377:             if (isItemLabelVisible(series, item)) {
 378:                 XYItemLabelGenerator generator = getItemLabelGenerator(series, 
 379:                         item);
 380:                 drawItemLabel(g2, dataset, series, item, plot, generator, bar, 
 381:                         value < 0.0);
 382:             }
 383:         }
 384: 
 385:     }
 386:     
 387:     /**
 388:      * Tests this renderer for equality with an arbitrary object.
 389:      * 
 390:      * @param obj  the object (<code>null</code> permitted).
 391:      * 
 392:      * @return A boolean.
 393:      */
 394:     public boolean equals(Object obj) {
 395:         if (obj == this) {
 396:             return true;   
 397:         }
 398:         if (!(obj instanceof StackedXYBarRenderer)) {
 399:             return false;   
 400:         }
 401:         StackedXYBarRenderer that = (StackedXYBarRenderer) obj;
 402:         if (this.renderAsPercentages != that.renderAsPercentages) {
 403:             return false;   
 404:         }
 405:         return super.equals(obj);
 406:     }
 407:     
 408:     /**
 409:      * Returns a hash code for this instance.
 410:      * 
 411:      * @return A hash code.
 412:      */
 413:     public int hashCode() {
 414:         int result = super.hashCode();
 415:         result = result * 37 + (this.renderAsPercentages ? 1 : 0);
 416:         return result;
 417:     }
 418:     
 419: }