Frames | No Frames |
1: /* =========================================================== 2: * JFreeChart : a free chart library for the Java(tm) platform 3: * =========================================================== 4: * 5: * (C) Copyright 2000-2008, 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: * StackedBarRenderer.java 29: * ----------------------- 30: * (C) Copyright 2000-2008, by Object Refinery Limited and Contributors. 31: * 32: * Original Author: David Gilbert (for Object Refinery Limited); 33: * Contributor(s): Richard Atkinson; 34: * Thierry Saura; 35: * Christian W. Zuckschwerdt; 36: * 37: * Changes 38: * ------- 39: * 19-Oct-2001 : Version 1 (DG); 40: * 22-Oct-2001 : Renamed DataSource.java --> Dataset.java etc. (DG); 41: * 23-Oct-2001 : Changed intro and trail gaps on bar plots to use percentage of 42: * available space rather than a fixed number of units (DG); 43: * 15-Nov-2001 : Modified to allow for null data values (DG); 44: * 22-Nov-2001 : Modified to allow for negative data values (DG); 45: * 13-Dec-2001 : Added tooltips (DG); 46: * 16-Jan-2002 : Fixed bug for single category datasets (DG); 47: * 15-Feb-2002 : Added isStacked() method (DG); 48: * 14-Mar-2002 : Modified to implement the CategoryItemRenderer interface (DG); 49: * 24-May-2002 : Incorporated tooltips into chart entities (DG); 50: * 11-Jun-2002 : Added check for (permitted) null info object, bug and fix 51: * reported by David Basten. Also updated Javadocs. (DG); 52: * 25-Jun-2002 : Removed redundant import (DG); 53: * 26-Jun-2002 : Small change to entity (DG); 54: * 05-Aug-2002 : Small modification to drawCategoryItem method to support URLs 55: * for HTML image maps (RA); 56: * 08-Aug-2002 : Added optional linking lines, contributed by Thierry 57: * Saura (DG); 58: * 26-Sep-2002 : Fixed errors reported by Checkstyle (DG); 59: * 24-Oct-2002 : Amendments for changes in CategoryDataset interface and 60: * CategoryToolTipGenerator interface (DG); 61: * 05-Nov-2002 : Replaced references to CategoryDataset with TableDataset (DG); 62: * 26-Nov-2002 : Replaced isStacked() method with getRangeType() method (DG); 63: * 17-Jan-2003 : Moved plot classes to a separate package (DG); 64: * 25-Mar-2003 : Implemented Serializable (DG); 65: * 12-May-2003 : Merged horizontal and vertical stacked bar renderers (DG); 66: * 30-Jul-2003 : Modified entity constructor (CZ); 67: * 08-Sep-2003 : Fixed bug 799668 (isBarOutlineDrawn() ignored) (DG); 68: * 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG); 69: * 21-Oct-2003 : Moved bar width into renderer state (DG); 70: * 26-Nov-2003 : Added code to respect maxBarWidth attribute (DG); 71: * 05-Nov-2004 : Changed to a two-pass renderer so that item labels are not 72: * overwritten by other bars (DG); 73: * 07-Jan-2005 : Renamed getRangeExtent() --> findRangeBounds() (DG); 74: * 29-Mar-2005 : Modified drawItem() method so that a zero value is handled 75: * within the code for positive rather than negative values (DG); 76: * 20-Apr-2005 : Renamed CategoryLabelGenerator 77: * --> CategoryItemLabelGenerator (DG); 78: * 17-May-2005 : Added flag to allow rendering values as percentages - inspired 79: * by patch 1200886 submitted by John Xiao (DG); 80: * 09-Jun-2005 : Added accessor methods for the renderAsPercentages flag, 81: * provided equals() method, and use addItemEntity from 82: * superclass (DG); 83: * 09-Jun-2005 : Added support for GradientPaint - see bug report 1215670 (DG); 84: * 22-Sep-2005 : Renamed getMaxBarWidth() --> getMaximumBarWidth() (DG); 85: * 29-Sep-2005 : Use outline stroke in drawItem method - see bug report 86: * 1304139 (DG); 87: * ------------- JFREECHART 1.0.x --------------------------------------------- 88: * 11-Oct-2006 : Source reformatting (DG); 89: * 90: */ 91: 92: package org.jfree.chart.renderer.category; 93: 94: import java.awt.GradientPaint; 95: import java.awt.Graphics2D; 96: import java.awt.Paint; 97: import java.awt.geom.Rectangle2D; 98: import java.io.Serializable; 99: 100: import org.jfree.chart.axis.CategoryAxis; 101: import org.jfree.chart.axis.ValueAxis; 102: import org.jfree.chart.entity.EntityCollection; 103: import org.jfree.chart.event.RendererChangeEvent; 104: import org.jfree.chart.labels.CategoryItemLabelGenerator; 105: import org.jfree.chart.labels.ItemLabelAnchor; 106: import org.jfree.chart.labels.ItemLabelPosition; 107: import org.jfree.chart.plot.CategoryPlot; 108: import org.jfree.chart.plot.PlotOrientation; 109: import org.jfree.data.DataUtilities; 110: import org.jfree.data.Range; 111: import org.jfree.data.category.CategoryDataset; 112: import org.jfree.data.general.DatasetUtilities; 113: import org.jfree.ui.GradientPaintTransformer; 114: import org.jfree.ui.RectangleEdge; 115: import org.jfree.ui.TextAnchor; 116: import org.jfree.util.PublicCloneable; 117: 118: /** 119: * A stacked bar renderer for use with the 120: * {@link org.jfree.chart.plot.CategoryPlot} class. 121: */ 122: public class StackedBarRenderer extends BarRenderer 123: implements Cloneable, PublicCloneable, Serializable { 124: 125: /** For serialization. */ 126: static final long serialVersionUID = 6402943811500067531L; 127: 128: /** A flag that controls whether the bars display values or percentages. */ 129: private boolean renderAsPercentages; 130: 131: /** 132: * Creates a new renderer. By default, the renderer has no tool tip 133: * generator and no URL generator. These defaults have been chosen to 134: * minimise the processing required to generate a default chart. If you 135: * require tool tips or URLs, then you can easily add the required 136: * generators. 137: */ 138: public StackedBarRenderer() { 139: this(false); 140: } 141: 142: /** 143: * Creates a new renderer. 144: * 145: * @param renderAsPercentages a flag that controls whether the data values 146: * are rendered as percentages. 147: */ 148: public StackedBarRenderer(boolean renderAsPercentages) { 149: super(); 150: this.renderAsPercentages = renderAsPercentages; 151: 152: // set the default item label positions, which will only be used if 153: // the user requests visible item labels... 154: ItemLabelPosition p = new ItemLabelPosition(ItemLabelAnchor.CENTER, 155: TextAnchor.CENTER); 156: setBasePositiveItemLabelPosition(p); 157: setBaseNegativeItemLabelPosition(p); 158: setPositiveItemLabelPositionFallback(null); 159: setNegativeItemLabelPositionFallback(null); 160: } 161: 162: /** 163: * Returns <code>true</code> if the renderer displays each item value as 164: * a percentage (so that the stacked bars add to 100%), and 165: * <code>false</code> otherwise. 166: * 167: * @return A boolean. 168: * 169: * @see #setRenderAsPercentages(boolean) 170: */ 171: public boolean getRenderAsPercentages() { 172: return this.renderAsPercentages; 173: } 174: 175: /** 176: * Sets the flag that controls whether the renderer displays each item 177: * value as a percentage (so that the stacked bars add to 100%), and sends 178: * a {@link RendererChangeEvent} to all registered listeners. 179: * 180: * @param asPercentages the flag. 181: * 182: * @see #getRenderAsPercentages() 183: */ 184: public void setRenderAsPercentages(boolean asPercentages) { 185: this.renderAsPercentages = asPercentages; 186: fireChangeEvent(); 187: } 188: 189: /** 190: * Returns the number of passes (<code>2</code>) required by this renderer. 191: * The first pass is used to draw the bars, the second pass is used to 192: * draw the item labels (if visible). 193: * 194: * @return The number of passes required by the renderer. 195: */ 196: public int getPassCount() { 197: return 2; 198: } 199: 200: /** 201: * Returns the range of values the renderer requires to display all the 202: * items from the specified dataset. 203: * 204: * @param dataset the dataset (<code>null</code> permitted). 205: * 206: * @return The range (or <code>null</code> if the dataset is empty). 207: */ 208: public Range findRangeBounds(CategoryDataset dataset) { 209: if (this.renderAsPercentages) { 210: return new Range(0.0, 1.0); 211: } 212: else { 213: return DatasetUtilities.findStackedRangeBounds(dataset, getBase()); 214: } 215: } 216: 217: /** 218: * Calculates the bar width and stores it in the renderer state. 219: * 220: * @param plot the plot. 221: * @param dataArea the data area. 222: * @param rendererIndex the renderer index. 223: * @param state the renderer state. 224: */ 225: protected void calculateBarWidth(CategoryPlot plot, 226: Rectangle2D dataArea, 227: int rendererIndex, 228: CategoryItemRendererState state) { 229: 230: // calculate the bar width 231: CategoryAxis xAxis = plot.getDomainAxisForDataset(rendererIndex); 232: CategoryDataset data = plot.getDataset(rendererIndex); 233: if (data != null) { 234: PlotOrientation orientation = plot.getOrientation(); 235: double space = 0.0; 236: if (orientation == PlotOrientation.HORIZONTAL) { 237: space = dataArea.getHeight(); 238: } 239: else if (orientation == PlotOrientation.VERTICAL) { 240: space = dataArea.getWidth(); 241: } 242: double maxWidth = space * getMaximumBarWidth(); 243: int columns = data.getColumnCount(); 244: double categoryMargin = 0.0; 245: if (columns > 1) { 246: categoryMargin = xAxis.getCategoryMargin(); 247: } 248: 249: double used = space * (1 - xAxis.getLowerMargin() 250: - xAxis.getUpperMargin() 251: - categoryMargin); 252: if (columns > 0) { 253: state.setBarWidth(Math.min(used / columns, maxWidth)); 254: } 255: else { 256: state.setBarWidth(Math.min(used, maxWidth)); 257: } 258: } 259: 260: } 261: 262: /** 263: * Draws a stacked bar for a specific item. 264: * 265: * @param g2 the graphics device. 266: * @param state the renderer state. 267: * @param dataArea the plot area. 268: * @param plot the plot. 269: * @param domainAxis the domain (category) axis. 270: * @param rangeAxis the range (value) axis. 271: * @param dataset the data. 272: * @param row the row index (zero-based). 273: * @param column the column index (zero-based). 274: * @param pass the pass index. 275: */ 276: public void drawItem(Graphics2D g2, 277: CategoryItemRendererState state, 278: Rectangle2D dataArea, 279: CategoryPlot plot, 280: CategoryAxis domainAxis, 281: ValueAxis rangeAxis, 282: CategoryDataset dataset, 283: int row, 284: int column, 285: int pass) { 286: 287: // nothing is drawn for null values... 288: Number dataValue = dataset.getValue(row, column); 289: if (dataValue == null) { 290: return; 291: } 292: 293: double value = dataValue.doubleValue(); 294: double total = 0.0; // only needed if calculating percentages 295: if (this.renderAsPercentages) { 296: total = DataUtilities.calculateColumnTotal(dataset, column); 297: value = value / total; 298: } 299: 300: PlotOrientation orientation = plot.getOrientation(); 301: double barW0 = domainAxis.getCategoryMiddle(column, getColumnCount(), 302: dataArea, plot.getDomainAxisEdge()) 303: - state.getBarWidth() / 2.0; 304: 305: double positiveBase = getBase(); 306: double negativeBase = positiveBase; 307: 308: for (int i = 0; i < row; i++) { 309: Number v = dataset.getValue(i, column); 310: if (v != null) { 311: double d = v.doubleValue(); 312: if (this.renderAsPercentages) { 313: d = d / total; 314: } 315: if (d > 0) { 316: positiveBase = positiveBase + d; 317: } 318: else { 319: negativeBase = negativeBase + d; 320: } 321: } 322: } 323: 324: double translatedBase; 325: double translatedValue; 326: RectangleEdge location = plot.getRangeAxisEdge(); 327: if (value >= 0.0) { 328: translatedBase = rangeAxis.valueToJava2D(positiveBase, dataArea, 329: location); 330: translatedValue = rangeAxis.valueToJava2D(positiveBase + value, 331: dataArea, location); 332: } 333: else { 334: translatedBase = rangeAxis.valueToJava2D(negativeBase, dataArea, 335: location); 336: translatedValue = rangeAxis.valueToJava2D(negativeBase + value, 337: dataArea, location); 338: } 339: double barL0 = Math.min(translatedBase, translatedValue); 340: double barLength = Math.max(Math.abs(translatedValue - translatedBase), 341: getMinimumBarLength()); 342: 343: Rectangle2D bar = null; 344: if (orientation == PlotOrientation.HORIZONTAL) { 345: bar = new Rectangle2D.Double(barL0, barW0, barLength, 346: state.getBarWidth()); 347: } 348: else { 349: bar = new Rectangle2D.Double(barW0, barL0, state.getBarWidth(), 350: barLength); 351: } 352: if (pass == 0) { 353: Paint itemPaint = getItemPaint(row, column); 354: GradientPaintTransformer t = getGradientPaintTransformer(); 355: if (t != null && itemPaint instanceof GradientPaint) { 356: itemPaint = t.transform((GradientPaint) itemPaint, bar); 357: } 358: g2.setPaint(itemPaint); 359: g2.fill(bar); 360: if (isDrawBarOutline() 361: && state.getBarWidth() > BAR_OUTLINE_WIDTH_THRESHOLD) { 362: g2.setStroke(getItemOutlineStroke(row, column)); 363: g2.setPaint(getItemOutlinePaint(row, column)); 364: g2.draw(bar); 365: } 366: 367: // add an item entity, if this information is being collected 368: EntityCollection entities = state.getEntityCollection(); 369: if (entities != null) { 370: addItemEntity(entities, dataset, row, column, bar); 371: } 372: } 373: else if (pass == 1) { 374: CategoryItemLabelGenerator generator = getItemLabelGenerator(row, 375: column); 376: if (generator != null && isItemLabelVisible(row, column)) { 377: drawItemLabel(g2, dataset, row, column, plot, generator, bar, 378: (value < 0.0)); 379: } 380: } 381: } 382: 383: /** 384: * Tests this renderer for equality with an arbitrary object. 385: * 386: * @param obj the object (<code>null</code> permitted). 387: * 388: * @return A boolean. 389: */ 390: public boolean equals(Object obj) { 391: if (obj == this) { 392: return true; 393: } 394: if (!(obj instanceof StackedBarRenderer)) { 395: return false; 396: } 397: StackedBarRenderer that = (StackedBarRenderer) obj; 398: if (this.renderAsPercentages != that.renderAsPercentages) { 399: return false; 400: } 401: return super.equals(obj); 402: } 403: 404: }