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: * JFreeChart.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): Andrzej Porebski; 34: * David Li; 35: * Wolfgang Irler; 36: * Christian W. Zuckschwerdt; 37: * Klaus Rheinwald; 38: * Nicolas Brodu; 39: * 40: * NOTE: The above list of contributors lists only the people that have 41: * contributed to this source file (JFreeChart.java) - for a list of ALL 42: * contributors to the project, please see the README.txt file. 43: * 44: * Changes (from 20-Jun-2001) 45: * -------------------------- 46: * 20-Jun-2001 : Modifications submitted by Andrzej Porebski for legend 47: * placement; 48: * 21-Jun-2001 : Removed JFreeChart parameter from Plot constructors (DG); 49: * 22-Jun-2001 : Multiple titles added (original code by David Berry, with 50: * reworkings by DG); 51: * 18-Sep-2001 : Updated header (DG); 52: * 15-Oct-2001 : Moved data source classes into new package 53: * com.jrefinery.data.* (DG); 54: * 18-Oct-2001 : New factory method for creating VerticalXYBarChart (DG); 55: * 19-Oct-2001 : Moved series paint and stroke methods to the Plot class (DG); 56: * Moved static chart creation methods to new ChartFactory 57: * class (DG); 58: * 22-Oct-2001 : Renamed DataSource.java --> Dataset.java etc. (DG); 59: * Fixed bug where chart isn't registered with the dataset (DG); 60: * 07-Nov-2001 : Fixed bug where null title in constructor causes 61: * exception (DG); 62: * Tidied up event notification code (DG); 63: * 17-Nov-2001 : Added getLegendItemCount() method (DG); 64: * 21-Nov-2001 : Set clipping in draw method to ensure that nothing gets drawn 65: * outside the chart area (DG); 66: * 11-Dec-2001 : Added the createBufferedImage() method, taken from the 67: * JFreeChartServletDemo class (DG); 68: * 13-Dec-2001 : Added tooltips (DG); 69: * 16-Jan-2002 : Added handleClick() method (DG); 70: * 22-Jan-2002 : Fixed bug correlating legend labels with pie data (DG); 71: * 05-Feb-2002 : Removed redundant tooltips code (DG); 72: * 19-Feb-2002 : Added accessor methods for the backgroundImage and 73: * backgroundImageAlpha attributes (DG); 74: * 21-Feb-2002 : Added static fields for INFO, COPYRIGHT, LICENCE, CONTRIBUTORS 75: * and LIBRARIES. These can be used to display information about 76: * JFreeChart (DG); 77: * 06-Mar-2002 : Moved constants to JFreeChartConstants interface (DG); 78: * 18-Apr-2002 : PieDataset is no longer sorted (oldman); 79: * 23-Apr-2002 : Moved dataset to the Plot class (DG); 80: * 13-Jun-2002 : Added an extra draw() method (DG); 81: * 25-Jun-2002 : Implemented the Drawable interface and removed redundant 82: * imports (DG); 83: * 26-Jun-2002 : Added another createBufferedImage() method (DG); 84: * 18-Sep-2002 : Fixed issues reported by Checkstyle (DG); 85: * 23-Sep-2002 : Added new contributor (DG); 86: * 28-Oct-2002 : Created main title and subtitle list to replace existing title 87: * list (DG); 88: * 08-Jan-2003 : Added contributor (DG); 89: * 17-Jan-2003 : Added new constructor (DG); 90: * 22-Jan-2003 : Added ChartColor class by Cameron Riley, and background image 91: * alignment code by Christian W. Zuckschwerdt (DG); 92: * 11-Feb-2003 : Added flag to allow suppression of chart change events, based 93: * on a suggestion by Klaus Rheinwald (DG); 94: * 04-Mar-2003 : Added small fix for suppressed chart change events (see bug id 95: * 690865) (DG); 96: * 10-Mar-2003 : Added Benoit Xhenseval to contributors (DG); 97: * 26-Mar-2003 : Implemented Serializable (DG); 98: * 15-Jul-2003 : Added an optional border for the chart (DG); 99: * 11-Sep-2003 : Took care of listeners while cloning (NB); 100: * 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG); 101: * 22-Sep-2003 : Added nullpointer checks. 102: * 25-Sep-2003 : Added nullpointer checks too (NB). 103: * 03-Dec-2003 : Legends are now registered by this class instead of using the 104: * old constructor way (TM); 105: * 03-Dec-2003 : Added anchorPoint to draw() method (DG); 106: * 08-Jan-2004 : Reworked title code, introducing line wrapping (DG); 107: * 09-Feb-2004 : Created additional createBufferedImage() method (DG); 108: * 05-Apr-2004 : Added new createBufferedImage() method (DG); 109: * 27-May-2004 : Moved constants from JFreeChartConstants.java back to this 110: * class (DG); 111: * 25-Nov-2004 : Updates for changes to Title class (DG); 112: * 06-Jan-2005 : Change lookup for default background color (DG); 113: * 31-Jan-2005 : Added Don Elliott to contributors (DG); 114: * 02-Feb-2005 : Added clearSubtitles() method (DG); 115: * 03-Feb-2005 : Added Mofeed Shahin to contributors (DG); 116: * 08-Feb-2005 : Updated for RectangleConstraint changes (DG); 117: * 28-Mar-2005 : Renamed Legend --> OldLegend (DG); 118: * 12-Apr-2005 : Added methods to access legend(s) in subtitle list (DG); 119: * 13-Apr-2005 : Added removeLegend() and removeSubtitle() methods (DG); 120: * 20-Apr-2005 : Modified to collect chart entities from titles and 121: * subtitles (DG); 122: * 26-Apr-2005 : Removed LOGGER (DG); 123: * 06-Jun-2005 : Added addLegend() method and padding attribute, fixed equals() 124: * method (DG); 125: * 24-Nov-2005 : Removed OldLegend and related code - don't want to support 126: * this in 1.0.0 final (DG); 127: * ------------- JFREECHART 1.0.x --------------------------------------------- 128: * 27-Jan-2006 : Updated version number (DG); 129: * 07-Dec-2006 : Added some missing credits (DG); 130: * 17-Jan-2007 : Added Darren Jung to contributor list (DG); 131: * 05-Mar-2007 : Added Sergei Ivanov to the contributor list (DG); 132: * 16-Mar-2007 : Modified initial legend border (DG); 133: * 22-Mar-2007 : New methods for text anti-aliasing (DG); 134: * 16-May-2007 : Fixed argument check in getSubtitle(), copy list in 135: * get/setSubtitles(), and added new addSubtitle(int, Title) 136: * method (DG); 137: * 05-Jun-2007 : Add change listener to default legend (DG); 138: * 04-Dec-2007 : In createBufferedImage() methods, make the default image type 139: * BufferedImage.TYPE_INT_ARGB (thanks to Klaus Rheinwald) (DG); 140: * 05-Dec-2007 : Fixed bug 1749124 (not registering as listener with 141: * TextTitle) (DG); 142: * 23-Apr-2008 : Added new contributor (Diego Pierangeli) (DG); 143: * 16-May-2008 : Added new contributor (Michael Siemer) (DG); 144: * 145: */ 146: 147: package org.jfree.chart; 148: 149: import java.awt.AlphaComposite; 150: import java.awt.BasicStroke; 151: import java.awt.Color; 152: import java.awt.Composite; 153: import java.awt.Font; 154: import java.awt.Graphics2D; 155: import java.awt.Image; 156: import java.awt.Paint; 157: import java.awt.RenderingHints; 158: import java.awt.Shape; 159: import java.awt.Stroke; 160: import java.awt.geom.AffineTransform; 161: import java.awt.geom.Point2D; 162: import java.awt.geom.Rectangle2D; 163: import java.awt.image.BufferedImage; 164: import java.io.IOException; 165: import java.io.ObjectInputStream; 166: import java.io.ObjectOutputStream; 167: import java.io.Serializable; 168: import java.net.URL; 169: import java.util.ArrayList; 170: import java.util.Arrays; 171: import java.util.Iterator; 172: import java.util.List; 173: import java.util.ResourceBundle; 174: 175: import javax.swing.ImageIcon; 176: import javax.swing.UIManager; 177: import javax.swing.event.EventListenerList; 178: 179: import org.jfree.JCommon; 180: import org.jfree.chart.block.BlockParams; 181: import org.jfree.chart.block.EntityBlockResult; 182: import org.jfree.chart.block.LengthConstraintType; 183: import org.jfree.chart.block.LineBorder; 184: import org.jfree.chart.block.RectangleConstraint; 185: import org.jfree.chart.entity.EntityCollection; 186: import org.jfree.chart.event.ChartChangeEvent; 187: import org.jfree.chart.event.ChartChangeListener; 188: import org.jfree.chart.event.ChartProgressEvent; 189: import org.jfree.chart.event.ChartProgressListener; 190: import org.jfree.chart.event.PlotChangeEvent; 191: import org.jfree.chart.event.PlotChangeListener; 192: import org.jfree.chart.event.TitleChangeEvent; 193: import org.jfree.chart.event.TitleChangeListener; 194: import org.jfree.chart.plot.CategoryPlot; 195: import org.jfree.chart.plot.Plot; 196: import org.jfree.chart.plot.PlotRenderingInfo; 197: import org.jfree.chart.plot.XYPlot; 198: import org.jfree.chart.title.LegendTitle; 199: import org.jfree.chart.title.TextTitle; 200: import org.jfree.chart.title.Title; 201: import org.jfree.data.Range; 202: import org.jfree.io.SerialUtilities; 203: import org.jfree.ui.Align; 204: import org.jfree.ui.Drawable; 205: import org.jfree.ui.HorizontalAlignment; 206: import org.jfree.ui.RectangleEdge; 207: import org.jfree.ui.RectangleInsets; 208: import org.jfree.ui.Size2D; 209: import org.jfree.ui.VerticalAlignment; 210: import org.jfree.ui.about.Contributor; 211: import org.jfree.ui.about.Licences; 212: import org.jfree.ui.about.ProjectInfo; 213: import org.jfree.util.ObjectUtilities; 214: import org.jfree.util.PaintUtilities; 215: 216: /** 217: * A chart class implemented using the Java 2D APIs. The current version 218: * supports bar charts, line charts, pie charts and xy plots (including time 219: * series data). 220: * <P> 221: * JFreeChart coordinates several objects to achieve its aim of being able to 222: * draw a chart on a Java 2D graphics device: a list of {@link Title} objects 223: * (which often includes the chart's legend), a {@link Plot} and a 224: * {@link org.jfree.data.general.Dataset} (the plot in turn manages a 225: * domain axis and a range axis). 226: * <P> 227: * You should use a {@link ChartPanel} to display a chart in a GUI. 228: * <P> 229: * The {@link ChartFactory} class contains static methods for creating 230: * 'ready-made' charts. 231: * 232: * @see ChartPanel 233: * @see ChartFactory 234: * @see Title 235: * @see Plot 236: */ 237: public class JFreeChart implements Drawable, 238: TitleChangeListener, 239: PlotChangeListener, 240: Serializable, 241: Cloneable { 242: 243: /** For serialization. */ 244: private static final long serialVersionUID = -3470703747817429120L; 245: 246: /** Information about the project. */ 247: public static final ProjectInfo INFO = new JFreeChartInfo(); 248: 249: /** The default font for titles. */ 250: public static final Font DEFAULT_TITLE_FONT 251: = new Font("SansSerif", Font.BOLD, 18); 252: 253: /** The default background color. */ 254: public static final Paint DEFAULT_BACKGROUND_PAINT 255: = UIManager.getColor("Panel.background"); 256: 257: /** The default background image. */ 258: public static final Image DEFAULT_BACKGROUND_IMAGE = null; 259: 260: /** The default background image alignment. */ 261: public static final int DEFAULT_BACKGROUND_IMAGE_ALIGNMENT = Align.FIT; 262: 263: /** The default background image alpha. */ 264: public static final float DEFAULT_BACKGROUND_IMAGE_ALPHA = 0.5f; 265: 266: /** 267: * Rendering hints that will be used for chart drawing. This should never 268: * be <code>null</code>. 269: */ 270: private transient RenderingHints renderingHints; 271: 272: /** A flag that controls whether or not the chart border is drawn. */ 273: private boolean borderVisible; 274: 275: /** The stroke used to draw the chart border (if visible). */ 276: private transient Stroke borderStroke; 277: 278: /** The paint used to draw the chart border (if visible). */ 279: private transient Paint borderPaint; 280: 281: /** The padding between the chart border and the chart drawing area. */ 282: private RectangleInsets padding; 283: 284: /** The chart title (optional). */ 285: private TextTitle title; 286: 287: /** 288: * The chart subtitles (zero, one or many). This field should never be 289: * <code>null</code>. 290: */ 291: private List subtitles; 292: 293: /** Draws the visual representation of the data. */ 294: private Plot plot; 295: 296: /** Paint used to draw the background of the chart. */ 297: private transient Paint backgroundPaint; 298: 299: /** An optional background image for the chart. */ 300: private transient Image backgroundImage; // todo: not serialized yet 301: 302: /** The alignment for the background image. */ 303: private int backgroundImageAlignment = Align.FIT; 304: 305: /** The alpha transparency for the background image. */ 306: private float backgroundImageAlpha = 0.5f; 307: 308: /** Storage for registered change listeners. */ 309: private transient EventListenerList changeListeners; 310: 311: /** Storage for registered progress listeners. */ 312: private transient EventListenerList progressListeners; 313: 314: /** 315: * A flag that can be used to enable/disable notification of chart change 316: * events. 317: */ 318: private boolean notify; 319: 320: /** 321: * Creates a new chart based on the supplied plot. The chart will have 322: * a legend added automatically, but no title (although you can easily add 323: * one later). 324: * <br><br> 325: * Note that the {@link ChartFactory} class contains a range 326: * of static methods that will return ready-made charts, and often this 327: * is a more convenient way to create charts than using this constructor. 328: * 329: * @param plot the plot (<code>null</code> not permitted). 330: */ 331: public JFreeChart(Plot plot) { 332: this(null, null, plot, true); 333: } 334: 335: /** 336: * Creates a new chart with the given title and plot. A default font 337: * ({@link #DEFAULT_TITLE_FONT}) is used for the title, and the chart will 338: * have a legend added automatically. 339: * <br><br> 340: * Note that the {@link ChartFactory} class contains a range 341: * of static methods that will return ready-made charts, and often this 342: * is a more convenient way to create charts than using this constructor. 343: * 344: * @param title the chart title (<code>null</code> permitted). 345: * @param plot the plot (<code>null</code> not permitted). 346: */ 347: public JFreeChart(String title, Plot plot) { 348: this(title, JFreeChart.DEFAULT_TITLE_FONT, plot, true); 349: } 350: 351: /** 352: * Creates a new chart with the given title and plot. The 353: * <code>createLegend</code> argument specifies whether or not a legend 354: * should be added to the chart. 355: * <br><br> 356: * Note that the {@link ChartFactory} class contains a range 357: * of static methods that will return ready-made charts, and often this 358: * is a more convenient way to create charts than using this constructor. 359: * 360: * @param title the chart title (<code>null</code> permitted). 361: * @param titleFont the font for displaying the chart title 362: * (<code>null</code> permitted). 363: * @param plot controller of the visual representation of the data 364: * (<code>null</code> not permitted). 365: * @param createLegend a flag indicating whether or not a legend should 366: * be created for the chart. 367: */ 368: public JFreeChart(String title, Font titleFont, Plot plot, 369: boolean createLegend) { 370: 371: if (plot == null) { 372: throw new NullPointerException("Null 'plot' argument."); 373: } 374: 375: // create storage for listeners... 376: this.progressListeners = new EventListenerList(); 377: this.changeListeners = new EventListenerList(); 378: this.notify = true; // default is to notify listeners when the 379: // chart changes 380: 381: this.renderingHints = new RenderingHints( 382: RenderingHints.KEY_ANTIALIASING, 383: RenderingHints.VALUE_ANTIALIAS_ON); 384: 385: this.borderVisible = false; 386: this.borderStroke = new BasicStroke(1.0f); 387: this.borderPaint = Color.black; 388: 389: this.padding = RectangleInsets.ZERO_INSETS; 390: 391: this.plot = plot; 392: plot.addChangeListener(this); 393: 394: this.subtitles = new ArrayList(); 395: 396: // create a legend, if requested... 397: if (createLegend) { 398: LegendTitle legend = new LegendTitle(this.plot); 399: legend.setMargin(new RectangleInsets(1.0, 1.0, 1.0, 1.0)); 400: legend.setFrame(new LineBorder()); 401: legend.setBackgroundPaint(Color.white); 402: legend.setPosition(RectangleEdge.BOTTOM); 403: this.subtitles.add(legend); 404: legend.addChangeListener(this); 405: } 406: 407: // add the chart title, if one has been specified... 408: if (title != null) { 409: if (titleFont == null) { 410: titleFont = DEFAULT_TITLE_FONT; 411: } 412: this.title = new TextTitle(title, titleFont); 413: this.title.addChangeListener(this); 414: } 415: 416: this.backgroundPaint = DEFAULT_BACKGROUND_PAINT; 417: 418: this.backgroundImage = DEFAULT_BACKGROUND_IMAGE; 419: this.backgroundImageAlignment = DEFAULT_BACKGROUND_IMAGE_ALIGNMENT; 420: this.backgroundImageAlpha = DEFAULT_BACKGROUND_IMAGE_ALPHA; 421: 422: } 423: 424: /** 425: * Returns the collection of rendering hints for the chart. 426: * 427: * @return The rendering hints for the chart (never <code>null</code>). 428: * 429: * @see #setRenderingHints(RenderingHints) 430: */ 431: public RenderingHints getRenderingHints() { 432: return this.renderingHints; 433: } 434: 435: /** 436: * Sets the rendering hints for the chart. These will be added (using the 437: * Graphics2D.addRenderingHints() method) near the start of the 438: * JFreeChart.draw() method. 439: * 440: * @param renderingHints the rendering hints (<code>null</code> not 441: * permitted). 442: * 443: * @see #getRenderingHints() 444: */ 445: public void setRenderingHints(RenderingHints renderingHints) { 446: if (renderingHints == null) { 447: throw new NullPointerException("RenderingHints given are null"); 448: } 449: this.renderingHints = renderingHints; 450: fireChartChanged(); 451: } 452: 453: /** 454: * Returns a flag that controls whether or not a border is drawn around the 455: * outside of the chart. 456: * 457: * @return A boolean. 458: * 459: * @see #setBorderVisible(boolean) 460: */ 461: public boolean isBorderVisible() { 462: return this.borderVisible; 463: } 464: 465: /** 466: * Sets a flag that controls whether or not a border is drawn around the 467: * outside of the chart. 468: * 469: * @param visible the flag. 470: * 471: * @see #isBorderVisible() 472: */ 473: public void setBorderVisible(boolean visible) { 474: this.borderVisible = visible; 475: fireChartChanged(); 476: } 477: 478: /** 479: * Returns the stroke used to draw the chart border (if visible). 480: * 481: * @return The border stroke. 482: * 483: * @see #setBorderStroke(Stroke) 484: */ 485: public Stroke getBorderStroke() { 486: return this.borderStroke; 487: } 488: 489: /** 490: * Sets the stroke used to draw the chart border (if visible). 491: * 492: * @param stroke the stroke. 493: * 494: * @see #getBorderStroke() 495: */ 496: public void setBorderStroke(Stroke stroke) { 497: this.borderStroke = stroke; 498: fireChartChanged(); 499: } 500: 501: /** 502: * Returns the paint used to draw the chart border (if visible). 503: * 504: * @return The border paint. 505: * 506: * @see #setBorderPaint(Paint) 507: */ 508: public Paint getBorderPaint() { 509: return this.borderPaint; 510: } 511: 512: /** 513: * Sets the paint used to draw the chart border (if visible). 514: * 515: * @param paint the paint. 516: * 517: * @see #getBorderPaint() 518: */ 519: public void setBorderPaint(Paint paint) { 520: this.borderPaint = paint; 521: fireChartChanged(); 522: } 523: 524: /** 525: * Returns the padding between the chart border and the chart drawing area. 526: * 527: * @return The padding (never <code>null</code>). 528: * 529: * @see #setPadding(RectangleInsets) 530: */ 531: public RectangleInsets getPadding() { 532: return this.padding; 533: } 534: 535: /** 536: * Sets the padding between the chart border and the chart drawing area, 537: * and sends a {@link ChartChangeEvent} to all registered listeners. 538: * 539: * @param padding the padding (<code>null</code> not permitted). 540: * 541: * @see #getPadding() 542: */ 543: public void setPadding(RectangleInsets padding) { 544: if (padding == null) { 545: throw new IllegalArgumentException("Null 'padding' argument."); 546: } 547: this.padding = padding; 548: notifyListeners(new ChartChangeEvent(this)); 549: } 550: 551: /** 552: * Returns the main chart title. Very often a chart will have just one 553: * title, so we make this case simple by providing accessor methods for 554: * the main title. However, multiple titles are supported - see the 555: * {@link #addSubtitle(Title)} method. 556: * 557: * @return The chart title (possibly <code>null</code>). 558: * 559: * @see #setTitle(TextTitle) 560: */ 561: public TextTitle getTitle() { 562: return this.title; 563: } 564: 565: /** 566: * Sets the main title for the chart and sends a {@link ChartChangeEvent} 567: * to all registered listeners. If you do not want a title for the 568: * chart, set it to <code>null</code>. If you want more than one title on 569: * a chart, use the {@link #addSubtitle(Title)} method. 570: * 571: * @param title the title (<code>null</code> permitted). 572: * 573: * @see #getTitle() 574: */ 575: public void setTitle(TextTitle title) { 576: if (this.title != null) { 577: this.title.removeChangeListener(this); 578: } 579: this.title = title; 580: if (title != null) { 581: title.addChangeListener(this); 582: } 583: fireChartChanged(); 584: } 585: 586: /** 587: * Sets the chart title and sends a {@link ChartChangeEvent} to all 588: * registered listeners. This is a convenience method that ends up calling 589: * the {@link #setTitle(TextTitle)} method. If there is an existing title, 590: * its text is updated, otherwise a new title using the default font is 591: * added to the chart. If <code>text</code> is <code>null</code> the chart 592: * title is set to <code>null</code>. 593: * 594: * @param text the title text (<code>null</code> permitted). 595: * 596: * @see #getTitle() 597: */ 598: public void setTitle(String text) { 599: if (text != null) { 600: if (this.title == null) { 601: setTitle(new TextTitle(text, JFreeChart.DEFAULT_TITLE_FONT)); 602: } 603: else { 604: this.title.setText(text); 605: } 606: } 607: else { 608: setTitle((TextTitle) null); 609: } 610: } 611: 612: /** 613: * Adds a legend to the plot and sends a {@link ChartChangeEvent} to all 614: * registered listeners. 615: * 616: * @param legend the legend (<code>null</code> not permitted). 617: * 618: * @see #removeLegend() 619: */ 620: public void addLegend(LegendTitle legend) { 621: addSubtitle(legend); 622: } 623: 624: /** 625: * Returns the legend for the chart, if there is one. Note that a chart 626: * can have more than one legend - this method returns the first. 627: * 628: * @return The legend (possibly <code>null</code>). 629: * 630: * @see #getLegend(int) 631: */ 632: public LegendTitle getLegend() { 633: return getLegend(0); 634: } 635: 636: /** 637: * Returns the nth legend for a chart, or <code>null</code>. 638: * 639: * @param index the legend index (zero-based). 640: * 641: * @return The legend (possibly <code>null</code>). 642: * 643: * @see #addLegend(LegendTitle) 644: */ 645: public LegendTitle getLegend(int index) { 646: int seen = 0; 647: Iterator iterator = this.subtitles.iterator(); 648: while (iterator.hasNext()) { 649: Title subtitle = (Title) iterator.next(); 650: if (subtitle instanceof LegendTitle) { 651: if (seen == index) { 652: return (LegendTitle) subtitle; 653: } 654: else { 655: seen++; 656: } 657: } 658: } 659: return null; 660: } 661: 662: /** 663: * Removes the first legend in the chart and sends a 664: * {@link ChartChangeEvent} to all registered listeners. 665: * 666: * @see #getLegend() 667: */ 668: public void removeLegend() { 669: removeSubtitle(getLegend()); 670: } 671: 672: /** 673: * Returns the list of subtitles for the chart. 674: * 675: * @return The subtitle list (possibly empty, but never <code>null</code>). 676: * 677: * @see #setSubtitles(List) 678: */ 679: public List getSubtitles() { 680: return new ArrayList(this.subtitles); 681: } 682: 683: /** 684: * Sets the title list for the chart (completely replaces any existing 685: * titles) and sends a {@link ChartChangeEvent} to all registered 686: * listeners. 687: * 688: * @param subtitles the new list of subtitles (<code>null</code> not 689: * permitted). 690: * 691: * @see #getSubtitles() 692: */ 693: public void setSubtitles(List subtitles) { 694: if (subtitles == null) { 695: throw new NullPointerException("Null 'subtitles' argument."); 696: } 697: setNotify(false); 698: clearSubtitles(); 699: Iterator iterator = subtitles.iterator(); 700: while (iterator.hasNext()) { 701: Title t = (Title) iterator.next(); 702: if (t != null) { 703: addSubtitle(t); 704: } 705: } 706: setNotify(true); // this fires a ChartChangeEvent 707: } 708: 709: /** 710: * Returns the number of titles for the chart. 711: * 712: * @return The number of titles for the chart. 713: * 714: * @see #getSubtitles() 715: */ 716: public int getSubtitleCount() { 717: return this.subtitles.size(); 718: } 719: 720: /** 721: * Returns a chart subtitle. 722: * 723: * @param index the index of the chart subtitle (zero based). 724: * 725: * @return A chart subtitle. 726: * 727: * @see #addSubtitle(Title) 728: */ 729: public Title getSubtitle(int index) { 730: if ((index < 0) || (index >= getSubtitleCount())) { 731: throw new IllegalArgumentException("Index out of range."); 732: } 733: return (Title) this.subtitles.get(index); 734: } 735: 736: /** 737: * Adds a chart subtitle, and notifies registered listeners that the chart 738: * has been modified. 739: * 740: * @param subtitle the subtitle (<code>null</code> not permitted). 741: * 742: * @see #getSubtitle(int) 743: */ 744: public void addSubtitle(Title subtitle) { 745: if (subtitle == null) { 746: throw new IllegalArgumentException("Null 'subtitle' argument."); 747: } 748: this.subtitles.add(subtitle); 749: subtitle.addChangeListener(this); 750: fireChartChanged(); 751: } 752: 753: /** 754: * Adds a subtitle at a particular position in the subtitle list, and sends 755: * a {@link ChartChangeEvent} to all registered listeners. 756: * 757: * @param index the index (in the range 0 to {@link #getSubtitleCount()}). 758: * @param subtitle the subtitle to add (<code>null</code> not permitted). 759: * 760: * @since 1.0.6 761: */ 762: public void addSubtitle(int index, Title subtitle) { 763: if (index < 0 || index > getSubtitleCount()) { 764: throw new IllegalArgumentException( 765: "The 'index' argument is out of range."); 766: } 767: if (subtitle == null) { 768: throw new IllegalArgumentException("Null 'subtitle' argument."); 769: } 770: this.subtitles.add(index, subtitle); 771: subtitle.addChangeListener(this); 772: fireChartChanged(); 773: } 774: 775: /** 776: * Clears all subtitles from the chart and sends a {@link ChartChangeEvent} 777: * to all registered listeners. 778: * 779: * @see #addSubtitle(Title) 780: */ 781: public void clearSubtitles() { 782: Iterator iterator = this.subtitles.iterator(); 783: while (iterator.hasNext()) { 784: Title t = (Title) iterator.next(); 785: t.removeChangeListener(this); 786: } 787: this.subtitles.clear(); 788: fireChartChanged(); 789: } 790: 791: /** 792: * Removes the specified subtitle and sends a {@link ChartChangeEvent} to 793: * all registered listeners. 794: * 795: * @param title the title. 796: * 797: * @see #addSubtitle(Title) 798: */ 799: public void removeSubtitle(Title title) { 800: this.subtitles.remove(title); 801: fireChartChanged(); 802: } 803: 804: /** 805: * Returns the plot for the chart. The plot is a class responsible for 806: * coordinating the visual representation of the data, including the axes 807: * (if any). 808: * 809: * @return The plot. 810: */ 811: public Plot getPlot() { 812: return this.plot; 813: } 814: 815: /** 816: * Returns the plot cast as a {@link CategoryPlot}. 817: * <p> 818: * NOTE: if the plot is not an instance of {@link CategoryPlot}, then a 819: * <code>ClassCastException</code> is thrown. 820: * 821: * @return The plot. 822: * 823: * @see #getPlot() 824: */ 825: public CategoryPlot getCategoryPlot() { 826: return (CategoryPlot) this.plot; 827: } 828: 829: /** 830: * Returns the plot cast as an {@link XYPlot}. 831: * <p> 832: * NOTE: if the plot is not an instance of {@link XYPlot}, then a 833: * <code>ClassCastException</code> is thrown. 834: * 835: * @return The plot. 836: * 837: * @see #getPlot() 838: */ 839: public XYPlot getXYPlot() { 840: return (XYPlot) this.plot; 841: } 842: 843: /** 844: * Returns a flag that indicates whether or not anti-aliasing is used when 845: * the chart is drawn. 846: * 847: * @return The flag. 848: * 849: * @see #setAntiAlias(boolean) 850: */ 851: public boolean getAntiAlias() { 852: Object val = this.renderingHints.get(RenderingHints.KEY_ANTIALIASING); 853: return RenderingHints.VALUE_ANTIALIAS_ON.equals(val); 854: } 855: 856: /** 857: * Sets a flag that indicates whether or not anti-aliasing is used when the 858: * chart is drawn. 859: * <P> 860: * Anti-aliasing usually improves the appearance of charts, but is slower. 861: * 862: * @param flag the new value of the flag. 863: * 864: * @see #getAntiAlias() 865: */ 866: public void setAntiAlias(boolean flag) { 867: 868: Object val = this.renderingHints.get(RenderingHints.KEY_ANTIALIASING); 869: if (val == null) { 870: val = RenderingHints.VALUE_ANTIALIAS_DEFAULT; 871: } 872: if (!flag && RenderingHints.VALUE_ANTIALIAS_OFF.equals(val) 873: || flag && RenderingHints.VALUE_ANTIALIAS_ON.equals(val)) { 874: // no change, do nothing 875: return; 876: } 877: if (flag) { 878: this.renderingHints.put(RenderingHints.KEY_ANTIALIASING, 879: RenderingHints.VALUE_ANTIALIAS_ON); 880: } 881: else { 882: this.renderingHints.put(RenderingHints.KEY_ANTIALIASING, 883: RenderingHints.VALUE_ANTIALIAS_OFF); 884: } 885: fireChartChanged(); 886: 887: } 888: 889: /** 890: * Returns the current value stored in the rendering hints table for 891: * {@link RenderingHints#KEY_TEXT_ANTIALIASING}. 892: * 893: * @return The hint value (possibly <code>null</code>). 894: * 895: * @since 1.0.5 896: * 897: * @see #setTextAntiAlias(Object) 898: */ 899: public Object getTextAntiAlias() { 900: return this.renderingHints.get(RenderingHints.KEY_TEXT_ANTIALIASING); 901: } 902: 903: /** 904: * Sets the value in the rendering hints table for 905: * {@link RenderingHints#KEY_TEXT_ANTIALIASING} to either 906: * {@link RenderingHints#VALUE_TEXT_ANTIALIAS_ON} or 907: * {@link RenderingHints#VALUE_TEXT_ANTIALIAS_OFF}, then sends a 908: * {@link ChartChangeEvent} to all registered listeners. 909: * 910: * @param flag the new value of the flag. 911: * 912: * @since 1.0.5 913: * 914: * @see #getTextAntiAlias() 915: * @see #setTextAntiAlias(Object) 916: */ 917: public void setTextAntiAlias(boolean flag) { 918: if (flag) { 919: setTextAntiAlias(RenderingHints.VALUE_TEXT_ANTIALIAS_ON); 920: } 921: else { 922: setTextAntiAlias(RenderingHints.VALUE_TEXT_ANTIALIAS_OFF); 923: } 924: } 925: 926: /** 927: * Sets the value in the rendering hints table for 928: * {@link RenderingHints#KEY_TEXT_ANTIALIASING} and sends a 929: * {@link ChartChangeEvent} to all registered listeners. 930: * 931: * @param val the new value (<code>null</code> permitted). 932: * 933: * @since 1.0.5 934: * 935: * @see #getTextAntiAlias() 936: * @see #setTextAntiAlias(boolean) 937: */ 938: public void setTextAntiAlias(Object val) { 939: this.renderingHints.put(RenderingHints.KEY_TEXT_ANTIALIASING, val); 940: notifyListeners(new ChartChangeEvent(this)); 941: } 942: 943: /** 944: * Returns the paint used for the chart background. 945: * 946: * @return The paint (possibly <code>null</code>). 947: * 948: * @see #setBackgroundPaint(Paint) 949: */ 950: public Paint getBackgroundPaint() { 951: return this.backgroundPaint; 952: } 953: 954: /** 955: * Sets the paint used to fill the chart background and sends a 956: * {@link ChartChangeEvent} to all registered listeners. 957: * 958: * @param paint the paint (<code>null</code> permitted). 959: * 960: * @see #getBackgroundPaint() 961: */ 962: public void setBackgroundPaint(Paint paint) { 963: 964: if (this.backgroundPaint != null) { 965: if (!this.backgroundPaint.equals(paint)) { 966: this.backgroundPaint = paint; 967: fireChartChanged(); 968: } 969: } 970: else { 971: if (paint != null) { 972: this.backgroundPaint = paint; 973: fireChartChanged(); 974: } 975: } 976: 977: } 978: 979: /** 980: * Returns the background image for the chart, or <code>null</code> if 981: * there is no image. 982: * 983: * @return The image (possibly <code>null</code>). 984: * 985: * @see #setBackgroundImage(Image) 986: */ 987: public Image getBackgroundImage() { 988: return this.backgroundImage; 989: } 990: 991: /** 992: * Sets the background image for the chart and sends a 993: * {@link ChartChangeEvent} to all registered listeners. 994: * 995: * @param image the image (<code>null</code> permitted). 996: * 997: * @see #getBackgroundImage() 998: */ 999: public void setBackgroundImage(Image image) { 1000: 1001: if (this.backgroundImage != null) { 1002: if (!this.backgroundImage.equals(image)) { 1003: this.backgroundImage = image; 1004: fireChartChanged(); 1005: } 1006: } 1007: else { 1008: if (image != null) { 1009: this.backgroundImage = image; 1010: fireChartChanged(); 1011: } 1012: } 1013: 1014: } 1015: 1016: /** 1017: * Returns the background image alignment. Alignment constants are defined 1018: * in the <code>org.jfree.ui.Align</code> class in the JCommon class 1019: * library. 1020: * 1021: * @return The alignment. 1022: * 1023: * @see #setBackgroundImageAlignment(int) 1024: */ 1025: public int getBackgroundImageAlignment() { 1026: return this.backgroundImageAlignment; 1027: } 1028: 1029: /** 1030: * Sets the background alignment. Alignment options are defined by the 1031: * {@link org.jfree.ui.Align} class. 1032: * 1033: * @param alignment the alignment. 1034: * 1035: * @see #getBackgroundImageAlignment() 1036: */ 1037: public void setBackgroundImageAlignment(int alignment) { 1038: if (this.backgroundImageAlignment != alignment) { 1039: this.backgroundImageAlignment = alignment; 1040: fireChartChanged(); 1041: } 1042: } 1043: 1044: /** 1045: * Returns the alpha-transparency for the chart's background image. 1046: * 1047: * @return The alpha-transparency. 1048: * 1049: * @see #setBackgroundImageAlpha(float) 1050: */ 1051: public float getBackgroundImageAlpha() { 1052: return this.backgroundImageAlpha; 1053: } 1054: 1055: /** 1056: * Sets the alpha-transparency for the chart's background image. 1057: * Registered listeners are notified that the chart has been changed. 1058: * 1059: * @param alpha the alpha value. 1060: * 1061: * @see #getBackgroundImageAlpha() 1062: */ 1063: public void setBackgroundImageAlpha(float alpha) { 1064: 1065: if (this.backgroundImageAlpha != alpha) { 1066: this.backgroundImageAlpha = alpha; 1067: fireChartChanged(); 1068: } 1069: 1070: } 1071: 1072: /** 1073: * Returns a flag that controls whether or not change events are sent to 1074: * registered listeners. 1075: * 1076: * @return A boolean. 1077: * 1078: * @see #setNotify(boolean) 1079: */ 1080: public boolean isNotify() { 1081: return this.notify; 1082: } 1083: 1084: /** 1085: * Sets a flag that controls whether or not listeners receive 1086: * {@link ChartChangeEvent} notifications. 1087: * 1088: * @param notify a boolean. 1089: * 1090: * @see #isNotify() 1091: */ 1092: public void setNotify(boolean notify) { 1093: this.notify = notify; 1094: // if the flag is being set to true, there may be queued up changes... 1095: if (notify) { 1096: notifyListeners(new ChartChangeEvent(this)); 1097: } 1098: } 1099: 1100: /** 1101: * Draws the chart on a Java 2D graphics device (such as the screen or a 1102: * printer). 1103: * <P> 1104: * This method is the focus of the entire JFreeChart library. 1105: * 1106: * @param g2 the graphics device. 1107: * @param area the area within which the chart should be drawn. 1108: */ 1109: public void draw(Graphics2D g2, Rectangle2D area) { 1110: draw(g2, area, null, null); 1111: } 1112: 1113: /** 1114: * Draws the chart on a Java 2D graphics device (such as the screen or a 1115: * printer). This method is the focus of the entire JFreeChart library. 1116: * 1117: * @param g2 the graphics device. 1118: * @param area the area within which the chart should be drawn. 1119: * @param info records info about the drawing (null means collect no info). 1120: */ 1121: public void draw(Graphics2D g2, Rectangle2D area, ChartRenderingInfo info) { 1122: draw(g2, area, null, info); 1123: } 1124: 1125: /** 1126: * Draws the chart on a Java 2D graphics device (such as the screen or a 1127: * printer). 1128: * <P> 1129: * This method is the focus of the entire JFreeChart library. 1130: * 1131: * @param g2 the graphics device. 1132: * @param chartArea the area within which the chart should be drawn. 1133: * @param anchor the anchor point (in Java2D space) for the chart 1134: * (<code>null</code> permitted). 1135: * @param info records info about the drawing (null means collect no info). 1136: */ 1137: public void draw(Graphics2D g2, 1138: Rectangle2D chartArea, Point2D anchor, 1139: ChartRenderingInfo info) { 1140: 1141: notifyListeners(new ChartProgressEvent(this, this, 1142: ChartProgressEvent.DRAWING_STARTED, 0)); 1143: 1144: // record the chart area, if info is requested... 1145: if (info != null) { 1146: info.clear(); 1147: info.setChartArea(chartArea); 1148: } 1149: 1150: // ensure no drawing occurs outside chart area... 1151: Shape savedClip = g2.getClip(); 1152: g2.clip(chartArea); 1153: 1154: g2.addRenderingHints(this.renderingHints); 1155: 1156: // draw the chart background... 1157: if (this.backgroundPaint != null) { 1158: g2.setPaint(this.backgroundPaint); 1159: g2.fill(chartArea); 1160: } 1161: 1162: if (this.backgroundImage != null) { 1163: Composite originalComposite = g2.getComposite(); 1164: g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1165: this.backgroundImageAlpha)); 1166: Rectangle2D dest = new Rectangle2D.Double(0.0, 0.0, 1167: this.backgroundImage.getWidth(null), 1168: this.backgroundImage.getHeight(null)); 1169: Align.align(dest, chartArea, this.backgroundImageAlignment); 1170: g2.drawImage(this.backgroundImage, (int) dest.getX(), 1171: (int) dest.getY(), (int) dest.getWidth(), 1172: (int) dest.getHeight(), null); 1173: g2.setComposite(originalComposite); 1174: } 1175: 1176: if (isBorderVisible()) { 1177: Paint paint = getBorderPaint(); 1178: Stroke stroke = getBorderStroke(); 1179: if (paint != null && stroke != null) { 1180: Rectangle2D borderArea = new Rectangle2D.Double( 1181: chartArea.getX(), chartArea.getY(), 1182: chartArea.getWidth() - 1.0, chartArea.getHeight() 1183: - 1.0); 1184: g2.setPaint(paint); 1185: g2.setStroke(stroke); 1186: g2.draw(borderArea); 1187: } 1188: } 1189: 1190: // draw the title and subtitles... 1191: Rectangle2D nonTitleArea = new Rectangle2D.Double(); 1192: nonTitleArea.setRect(chartArea); 1193: this.padding.trim(nonTitleArea); 1194: 1195: EntityCollection entities = null; 1196: if (info != null) { 1197: entities = info.getEntityCollection(); 1198: } 1199: if (this.title != null) { 1200: EntityCollection e = drawTitle(this.title, g2, nonTitleArea, 1201: (entities != null)); 1202: if (e != null) { 1203: entities.addAll(e); 1204: } 1205: } 1206: 1207: Iterator iterator = this.subtitles.iterator(); 1208: while (iterator.hasNext()) { 1209: Title currentTitle = (Title) iterator.next(); 1210: EntityCollection e = drawTitle(currentTitle, g2, nonTitleArea, 1211: (entities != null)); 1212: if (e != null) { 1213: entities.addAll(e); 1214: } 1215: } 1216: 1217: Rectangle2D plotArea = nonTitleArea; 1218: 1219: // draw the plot (axes and data visualisation) 1220: PlotRenderingInfo plotInfo = null; 1221: if (info != null) { 1222: plotInfo = info.getPlotInfo(); 1223: } 1224: this.plot.draw(g2, plotArea, anchor, null, plotInfo); 1225: 1226: g2.setClip(savedClip); 1227: 1228: notifyListeners(new ChartProgressEvent(this, this, 1229: ChartProgressEvent.DRAWING_FINISHED, 100)); 1230: } 1231: 1232: /** 1233: * Creates a rectangle that is aligned to the frame. 1234: * 1235: * @param dimensions the dimensions for the rectangle. 1236: * @param frame the frame to align to. 1237: * @param hAlign the horizontal alignment. 1238: * @param vAlign the vertical alignment. 1239: * 1240: * @return A rectangle. 1241: */ 1242: private Rectangle2D createAlignedRectangle2D(Size2D dimensions, 1243: Rectangle2D frame, HorizontalAlignment hAlign, 1244: VerticalAlignment vAlign) { 1245: double x = Double.NaN; 1246: double y = Double.NaN; 1247: if (hAlign == HorizontalAlignment.LEFT) { 1248: x = frame.getX(); 1249: } 1250: else if (hAlign == HorizontalAlignment.CENTER) { 1251: x = frame.getCenterX() - (dimensions.width / 2.0); 1252: } 1253: else if (hAlign == HorizontalAlignment.RIGHT) { 1254: x = frame.getMaxX() - dimensions.width; 1255: } 1256: if (vAlign == VerticalAlignment.TOP) { 1257: y = frame.getY(); 1258: } 1259: else if (vAlign == VerticalAlignment.CENTER) { 1260: y = frame.getCenterY() - (dimensions.height / 2.0); 1261: } 1262: else if (vAlign == VerticalAlignment.BOTTOM) { 1263: y = frame.getMaxY() - dimensions.height; 1264: } 1265: 1266: return new Rectangle2D.Double(x, y, dimensions.width, 1267: dimensions.height); 1268: } 1269: 1270: /** 1271: * Draws a title. The title should be drawn at the top, bottom, left or 1272: * right of the specified area, and the area should be updated to reflect 1273: * the amount of space used by the title. 1274: * 1275: * @param t the title (<code>null</code> not permitted). 1276: * @param g2 the graphics device (<code>null</code> not permitted). 1277: * @param area the chart area, excluding any existing titles 1278: * (<code>null</code> not permitted). 1279: * @param entities a flag that controls whether or not an entity 1280: * collection is returned for the title. 1281: * 1282: * @return An entity collection for the title (possibly <code>null</code>). 1283: */ 1284: protected EntityCollection drawTitle(Title t, Graphics2D g2, 1285: Rectangle2D area, boolean entities) { 1286: 1287: if (t == null) { 1288: throw new IllegalArgumentException("Null 't' argument."); 1289: } 1290: if (area == null) { 1291: throw new IllegalArgumentException("Null 'area' argument."); 1292: } 1293: Rectangle2D titleArea = new Rectangle2D.Double(); 1294: RectangleEdge position = t.getPosition(); 1295: double ww = area.getWidth(); 1296: if (ww <= 0.0) { 1297: return null; 1298: } 1299: double hh = area.getHeight(); 1300: if (hh <= 0.0) { 1301: return null; 1302: } 1303: RectangleConstraint constraint = new RectangleConstraint(ww, 1304: new Range(0.0, ww), LengthConstraintType.RANGE, hh, 1305: new Range(0.0, hh), LengthConstraintType.RANGE); 1306: Object retValue = null; 1307: BlockParams p = new BlockParams(); 1308: p.setGenerateEntities(entities); 1309: if (position == RectangleEdge.TOP) { 1310: Size2D size = t.arrange(g2, constraint); 1311: titleArea = createAlignedRectangle2D(size, area, 1312: t.getHorizontalAlignment(), VerticalAlignment.TOP); 1313: retValue = t.draw(g2, titleArea, p); 1314: area.setRect(area.getX(), Math.min(area.getY() + size.height, 1315: area.getMaxY()), area.getWidth(), Math.max(area.getHeight() 1316: - size.height, 0)); 1317: } 1318: else if (position == RectangleEdge.BOTTOM) { 1319: Size2D size = t.arrange(g2, constraint); 1320: titleArea = createAlignedRectangle2D(size, area, 1321: t.getHorizontalAlignment(), VerticalAlignment.BOTTOM); 1322: retValue = t.draw(g2, titleArea, p); 1323: area.setRect(area.getX(), area.getY(), area.getWidth(), 1324: area.getHeight() - size.height); 1325: } 1326: else if (position == RectangleEdge.RIGHT) { 1327: Size2D size = t.arrange(g2, constraint); 1328: titleArea = createAlignedRectangle2D(size, area, 1329: HorizontalAlignment.RIGHT, t.getVerticalAlignment()); 1330: retValue = t.draw(g2, titleArea, p); 1331: area.setRect(area.getX(), area.getY(), area.getWidth() 1332: - size.width, area.getHeight()); 1333: } 1334: 1335: else if (position == RectangleEdge.LEFT) { 1336: Size2D size = t.arrange(g2, constraint); 1337: titleArea = createAlignedRectangle2D(size, area, 1338: HorizontalAlignment.LEFT, t.getVerticalAlignment()); 1339: retValue = t.draw(g2, titleArea, p); 1340: area.setRect(area.getX() + size.width, area.getY(), area.getWidth() 1341: - size.width, area.getHeight()); 1342: } 1343: else { 1344: throw new RuntimeException("Unrecognised title position."); 1345: } 1346: EntityCollection result = null; 1347: if (retValue instanceof EntityBlockResult) { 1348: EntityBlockResult ebr = (EntityBlockResult) retValue; 1349: result = ebr.getEntityCollection(); 1350: } 1351: return result; 1352: } 1353: 1354: /** 1355: * Creates and returns a buffered image into which the chart has been drawn. 1356: * 1357: * @param width the width. 1358: * @param height the height. 1359: * 1360: * @return A buffered image. 1361: */ 1362: public BufferedImage createBufferedImage(int width, int height) { 1363: return createBufferedImage(width, height, null); 1364: } 1365: 1366: /** 1367: * Creates and returns a buffered image into which the chart has been drawn. 1368: * 1369: * @param width the width. 1370: * @param height the height. 1371: * @param info carries back chart state information (<code>null</code> 1372: * permitted). 1373: * 1374: * @return A buffered image. 1375: */ 1376: public BufferedImage createBufferedImage(int width, int height, 1377: ChartRenderingInfo info) { 1378: return createBufferedImage(width, height, BufferedImage.TYPE_INT_ARGB, 1379: info); 1380: } 1381: 1382: /** 1383: * Creates and returns a buffered image into which the chart has been drawn. 1384: * 1385: * @param width the width. 1386: * @param height the height. 1387: * @param imageType the image type. 1388: * @param info carries back chart state information (<code>null</code> 1389: * permitted). 1390: * 1391: * @return A buffered image. 1392: */ 1393: public BufferedImage createBufferedImage(int width, int height, 1394: int imageType, 1395: ChartRenderingInfo info) { 1396: BufferedImage image = new BufferedImage(width, height, imageType); 1397: Graphics2D g2 = image.createGraphics(); 1398: draw(g2, new Rectangle2D.Double(0, 0, width, height), null, info); 1399: g2.dispose(); 1400: return image; 1401: } 1402: 1403: /** 1404: * Creates and returns a buffered image into which the chart has been drawn. 1405: * 1406: * @param imageWidth the image width. 1407: * @param imageHeight the image height. 1408: * @param drawWidth the width for drawing the chart (will be scaled to 1409: * fit image). 1410: * @param drawHeight the height for drawing the chart (will be scaled to 1411: * fit image). 1412: * @param info optional object for collection chart dimension and entity 1413: * information. 1414: * 1415: * @return A buffered image. 1416: */ 1417: public BufferedImage createBufferedImage(int imageWidth, 1418: int imageHeight, 1419: double drawWidth, 1420: double drawHeight, 1421: ChartRenderingInfo info) { 1422: 1423: BufferedImage image = new BufferedImage(imageWidth, imageHeight, 1424: BufferedImage.TYPE_INT_ARGB); 1425: Graphics2D g2 = image.createGraphics(); 1426: double scaleX = imageWidth / drawWidth; 1427: double scaleY = imageHeight / drawHeight; 1428: AffineTransform st = AffineTransform.getScaleInstance(scaleX, scaleY); 1429: g2.transform(st); 1430: draw(g2, new Rectangle2D.Double(0, 0, drawWidth, drawHeight), null, 1431: info); 1432: g2.dispose(); 1433: return image; 1434: 1435: } 1436: 1437: /** 1438: * Handles a 'click' on the chart. JFreeChart is not a UI component, so 1439: * some other object (for example, {@link ChartPanel}) needs to capture 1440: * the click event and pass it onto the JFreeChart object. 1441: * If you are not using JFreeChart in a client application, then this 1442: * method is not required. 1443: * 1444: * @param x x-coordinate of the click (in Java2D space). 1445: * @param y y-coordinate of the click (in Java2D space). 1446: * @param info contains chart dimension and entity information 1447: * (<code>null</code> not permitted). 1448: */ 1449: public void handleClick(int x, int y, ChartRenderingInfo info) { 1450: 1451: // pass the click on to the plot... 1452: // rely on the plot to post a plot change event and redraw the chart... 1453: this.plot.handleClick(x, y, info.getPlotInfo()); 1454: 1455: } 1456: 1457: /** 1458: * Registers an object for notification of changes to the chart. 1459: * 1460: * @param listener the listener (<code>null</code> not permitted). 1461: * 1462: * @see #removeChangeListener(ChartChangeListener) 1463: */ 1464: public void addChangeListener(ChartChangeListener listener) { 1465: if (listener == null) { 1466: throw new IllegalArgumentException("Null 'listener' argument."); 1467: } 1468: this.changeListeners.add(ChartChangeListener.class, listener); 1469: } 1470: 1471: /** 1472: * Deregisters an object for notification of changes to the chart. 1473: * 1474: * @param listener the listener (<code>null</code> not permitted) 1475: * 1476: * @see #addChangeListener(ChartChangeListener) 1477: */ 1478: public void removeChangeListener(ChartChangeListener listener) { 1479: if (listener == null) { 1480: throw new IllegalArgumentException("Null 'listener' argument."); 1481: } 1482: this.changeListeners.remove(ChartChangeListener.class, listener); 1483: } 1484: 1485: /** 1486: * Sends a default {@link ChartChangeEvent} to all registered listeners. 1487: * <P> 1488: * This method is for convenience only. 1489: */ 1490: public void fireChartChanged() { 1491: ChartChangeEvent event = new ChartChangeEvent(this); 1492: notifyListeners(event); 1493: } 1494: 1495: /** 1496: * Sends a {@link ChartChangeEvent} to all registered listeners. 1497: * 1498: * @param event information about the event that triggered the 1499: * notification. 1500: */ 1501: protected void notifyListeners(ChartChangeEvent event) { 1502: if (this.notify) { 1503: Object[] listeners = this.changeListeners.getListenerList(); 1504: for (int i = listeners.length - 2; i >= 0; i -= 2) { 1505: if (listeners[i] == ChartChangeListener.class) { 1506: ((ChartChangeListener) listeners[i + 1]).chartChanged( 1507: event); 1508: } 1509: } 1510: } 1511: } 1512: 1513: /** 1514: * Registers an object for notification of progress events relating to the 1515: * chart. 1516: * 1517: * @param listener the object being registered. 1518: * 1519: * @see #removeProgressListener(ChartProgressListener) 1520: */ 1521: public void addProgressListener(ChartProgressListener listener) { 1522: this.progressListeners.add(ChartProgressListener.class, listener); 1523: } 1524: 1525: /** 1526: * Deregisters an object for notification of changes to the chart. 1527: * 1528: * @param listener the object being deregistered. 1529: * 1530: * @see #addProgressListener(ChartProgressListener) 1531: */ 1532: public void removeProgressListener(ChartProgressListener listener) { 1533: this.progressListeners.remove(ChartProgressListener.class, listener); 1534: } 1535: 1536: /** 1537: * Sends a {@link ChartProgressEvent} to all registered listeners. 1538: * 1539: * @param event information about the event that triggered the 1540: * notification. 1541: */ 1542: protected void notifyListeners(ChartProgressEvent event) { 1543: 1544: Object[] listeners = this.progressListeners.getListenerList(); 1545: for (int i = listeners.length - 2; i >= 0; i -= 2) { 1546: if (listeners[i] == ChartProgressListener.class) { 1547: ((ChartProgressListener) listeners[i + 1]).chartProgress(event); 1548: } 1549: } 1550: 1551: } 1552: 1553: /** 1554: * Receives notification that a chart title has changed, and passes this 1555: * on to registered listeners. 1556: * 1557: * @param event information about the chart title change. 1558: */ 1559: public void titleChanged(TitleChangeEvent event) { 1560: event.setChart(this); 1561: notifyListeners(event); 1562: } 1563: 1564: /** 1565: * Receives notification that the plot has changed, and passes this on to 1566: * registered listeners. 1567: * 1568: * @param event information about the plot change. 1569: */ 1570: public void plotChanged(PlotChangeEvent event) { 1571: event.setChart(this); 1572: notifyListeners(event); 1573: } 1574: 1575: /** 1576: * Tests this chart for equality with another object. 1577: * 1578: * @param obj the object (<code>null</code> permitted). 1579: * 1580: * @return A boolean. 1581: */ 1582: public boolean equals(Object obj) { 1583: if (obj == this) { 1584: return true; 1585: } 1586: if (!(obj instanceof JFreeChart)) { 1587: return false; 1588: } 1589: JFreeChart that = (JFreeChart) obj; 1590: if (!this.renderingHints.equals(that.renderingHints)) { 1591: return false; 1592: } 1593: if (this.borderVisible != that.borderVisible) { 1594: return false; 1595: } 1596: if (!ObjectUtilities.equal(this.borderStroke, that.borderStroke)) { 1597: return false; 1598: } 1599: if (!PaintUtilities.equal(this.borderPaint, that.borderPaint)) { 1600: return false; 1601: } 1602: if (!this.padding.equals(that.padding)) { 1603: return false; 1604: } 1605: if (!ObjectUtilities.equal(this.title, that.title)) { 1606: return false; 1607: } 1608: if (!ObjectUtilities.equal(this.subtitles, that.subtitles)) { 1609: return false; 1610: } 1611: if (!ObjectUtilities.equal(this.plot, that.plot)) { 1612: return false; 1613: } 1614: if (!PaintUtilities.equal( 1615: this.backgroundPaint, that.backgroundPaint 1616: )) { 1617: return false; 1618: } 1619: if (!ObjectUtilities.equal(this.backgroundImage, 1620: that.backgroundImage)) { 1621: return false; 1622: } 1623: if (this.backgroundImageAlignment != that.backgroundImageAlignment) { 1624: return false; 1625: } 1626: if (this.backgroundImageAlpha != that.backgroundImageAlpha) { 1627: return false; 1628: } 1629: if (this.notify != that.notify) { 1630: return false; 1631: } 1632: return true; 1633: } 1634: 1635: /** 1636: * Provides serialization support. 1637: * 1638: * @param stream the output stream. 1639: * 1640: * @throws IOException if there is an I/O error. 1641: */ 1642: private void writeObject(ObjectOutputStream stream) throws IOException { 1643: stream.defaultWriteObject(); 1644: SerialUtilities.writeStroke(this.borderStroke, stream); 1645: SerialUtilities.writePaint(this.borderPaint, stream); 1646: SerialUtilities.writePaint(this.backgroundPaint, stream); 1647: } 1648: 1649: /** 1650: * Provides serialization support. 1651: * 1652: * @param stream the input stream. 1653: * 1654: * @throws IOException if there is an I/O error. 1655: * @throws ClassNotFoundException if there is a classpath problem. 1656: */ 1657: private void readObject(ObjectInputStream stream) 1658: throws IOException, ClassNotFoundException { 1659: stream.defaultReadObject(); 1660: this.borderStroke = SerialUtilities.readStroke(stream); 1661: this.borderPaint = SerialUtilities.readPaint(stream); 1662: this.backgroundPaint = SerialUtilities.readPaint(stream); 1663: this.progressListeners = new EventListenerList(); 1664: this.changeListeners = new EventListenerList(); 1665: this.renderingHints = new RenderingHints( 1666: RenderingHints.KEY_ANTIALIASING, 1667: RenderingHints.VALUE_ANTIALIAS_ON); 1668: 1669: // register as a listener with sub-components... 1670: if (this.title != null) { 1671: this.title.addChangeListener(this); 1672: } 1673: 1674: for (int i = 0; i < getSubtitleCount(); i++) { 1675: getSubtitle(i).addChangeListener(this); 1676: } 1677: this.plot.addChangeListener(this); 1678: } 1679: 1680: /** 1681: * Prints information about JFreeChart to standard output. 1682: * 1683: * @param args no arguments are honored. 1684: */ 1685: public static void main(String[] args) { 1686: System.out.println(JFreeChart.INFO.toString()); 1687: } 1688: 1689: /** 1690: * Clones the object, and takes care of listeners. 1691: * Note: caller shall register its own listeners on cloned graph. 1692: * 1693: * @return A clone. 1694: * 1695: * @throws CloneNotSupportedException if the chart is not cloneable. 1696: */ 1697: public Object clone() throws CloneNotSupportedException { 1698: JFreeChart chart = (JFreeChart) super.clone(); 1699: 1700: chart.renderingHints = (RenderingHints) this.renderingHints.clone(); 1701: // private boolean borderVisible; 1702: // private transient Stroke borderStroke; 1703: // private transient Paint borderPaint; 1704: 1705: if (this.title != null) { 1706: chart.title = (TextTitle) this.title.clone(); 1707: chart.title.addChangeListener(chart); 1708: } 1709: 1710: chart.subtitles = new ArrayList(); 1711: for (int i = 0; i < getSubtitleCount(); i++) { 1712: Title subtitle = (Title) getSubtitle(i).clone(); 1713: chart.subtitles.add(subtitle); 1714: subtitle.addChangeListener(chart); 1715: } 1716: 1717: if (this.plot != null) { 1718: chart.plot = (Plot) this.plot.clone(); 1719: chart.plot.addChangeListener(chart); 1720: } 1721: 1722: chart.progressListeners = new EventListenerList(); 1723: chart.changeListeners = new EventListenerList(); 1724: return chart; 1725: } 1726: 1727: } 1728: 1729: /** 1730: * Information about the JFreeChart project. One instance of this class is 1731: * assigned to <code>JFreeChart.INFO<code>. 1732: */ 1733: class JFreeChartInfo extends ProjectInfo { 1734: 1735: /** 1736: * Default constructor. 1737: */ 1738: public JFreeChartInfo() { 1739: 1740: // get a locale-specific resource bundle... 1741: String baseResourceClass 1742: = "org.jfree.chart.resources.JFreeChartResources"; 1743: ResourceBundle resources = ResourceBundle.getBundle(baseResourceClass); 1744: 1745: setName(resources.getString("project.name")); 1746: setVersion(resources.getString("project.version")); 1747: setInfo(resources.getString("project.info")); 1748: setCopyright(resources.getString("project.copyright")); 1749: setLogo(null); // load only when required 1750: setLicenceName("LGPL"); 1751: setLicenceText(Licences.getInstance().getLGPL()); 1752: 1753: setContributors(Arrays.asList( 1754: new Contributor[]{ 1755: new Contributor("Eric Alexander", "-"), 1756: new Contributor("Richard Atkinson", 1757: "richard_c_atkinson@ntlworld.com"), 1758: new Contributor("David Basten", "-"), 1759: new Contributor("David Berry", "-"), 1760: new Contributor("Chris Boek", "-"), 1761: new Contributor("Zoheb Borbora", "-"), 1762: new Contributor("Anthony Boulestreau", "-"), 1763: new Contributor("Jeremy Bowman", "-"), 1764: new Contributor("Nicolas Brodu", "-"), 1765: new Contributor("Jody Brownell", "-"), 1766: new Contributor("David Browning", "-"), 1767: new Contributor("Soren Caspersen", "-"), 1768: new Contributor("Chuanhao Chiu", "-"), 1769: new Contributor("Brian Cole", "-"), 1770: new Contributor("Pascal Collet", "-"), 1771: new Contributor("Martin Cordova", "-"), 1772: new Contributor("Paolo Cova", "-"), 1773: new Contributor("Mike Duffy", "-"), 1774: new Contributor("Don Elliott", "-"), 1775: new Contributor("David Forslund", "-"), 1776: new Contributor("Jonathan Gabbai", "-"), 1777: new Contributor("David Gilbert", 1778: "david.gilbert@object-refinery.com"), 1779: new Contributor("Serge V. Grachov", "-"), 1780: new Contributor("Daniel Gredler", "-"), 1781: new Contributor("Hans-Jurgen Greiner", "-"), 1782: new Contributor("Joao Guilherme Del Valle", "-"), 1783: new Contributor("Aiman Han", "-"), 1784: new Contributor("Cameron Hayne", "-"), 1785: new Contributor("Martin Hoeller", "-"), 1786: new Contributor("Jon Iles", "-"), 1787: new Contributor("Wolfgang Irler", "-"), 1788: new Contributor("Sergei Ivanov", "-"), 1789: new Contributor("Adriaan Joubert", "-"), 1790: new Contributor("Darren Jung", "-"), 1791: new Contributor("Xun Kang", "-"), 1792: new Contributor("Bill Kelemen", "-"), 1793: new Contributor("Norbert Kiesel", "-"), 1794: new Contributor("Gideon Krause", "-"), 1795: new Contributor("Pierre-Marie Le Biot", "-"), 1796: new Contributor("Arnaud Lelievre", "-"), 1797: new Contributor("Wolfgang Lenhard", "-"), 1798: new Contributor("David Li", "-"), 1799: new Contributor("Yan Liu", "-"), 1800: new Contributor("Tin Luu", "-"), 1801: new Contributor("Craig MacFarlane", "-"), 1802: new Contributor("Achilleus Mantzios", "-"), 1803: new Contributor("Thomas Meier", "-"), 1804: new Contributor("Jim Moore", "-"), 1805: new Contributor("Jonathan Nash", "-"), 1806: new Contributor("Barak Naveh", "-"), 1807: new Contributor("David M. O'Donnell", "-"), 1808: new Contributor("Krzysztof Paz", "-"), 1809: new Contributor("Tomer Peretz", "-"), 1810: new Contributor("Diego Pierangeli", "-"), 1811: new Contributor("Xavier Poinsard", "-"), 1812: new Contributor("Andrzej Porebski", "-"), 1813: new Contributor("Viktor Rajewski", "-"), 1814: new Contributor("Eduardo Ramalho", "-"), 1815: new Contributor("Michael Rauch", "-"), 1816: new Contributor("Cameron Riley", "-"), 1817: new Contributor("Klaus Rheinwald", "-"), 1818: new Contributor("Dan Rivett", "d.rivett@ukonline.co.uk"), 1819: new Contributor("Scott Sams", "-"), 1820: new Contributor("Michel Santos", "-"), 1821: new Contributor("Thierry Saura", "-"), 1822: new Contributor("Andreas Schneider", "-"), 1823: new Contributor("Jean-Luc SCHWAB", "-"), 1824: new Contributor("Bryan Scott", "-"), 1825: new Contributor("Tobias Selb", "-"), 1826: new Contributor("Mofeed Shahin", "-"), 1827: new Contributor("Michael Siemer", "-"), 1828: new Contributor("Pady Srinivasan", "-"), 1829: new Contributor("Greg Steckman", "-"), 1830: new Contributor("Gerald Struck", "-"), 1831: new Contributor("Roger Studner", "-"), 1832: new Contributor("Irv Thomae", "-"), 1833: new Contributor("Eric Thomas", "-"), 1834: new Contributor("Rich Unger", "-"), 1835: new Contributor("Daniel van Enckevort", "-"), 1836: new Contributor("Laurence Vanhelsuwe", "-"), 1837: new Contributor("Sylvain Vieujot", "-"), 1838: new Contributor("Ulrich Voigt", "-"), 1839: new Contributor("Jelai Wang", "-"), 1840: new Contributor("Mark Watson", "www.markwatson.com"), 1841: new Contributor("Alex Weber", "-"), 1842: new Contributor("Matthew Wright", "-"), 1843: new Contributor("Benoit Xhenseval", "-"), 1844: new Contributor("Christian W. Zuckschwerdt", 1845: "Christian.Zuckschwerdt@Informatik.Uni-Oldenburg.de"), 1846: new Contributor("Hari", "-"), 1847: new Contributor("Sam (oldman)", "-"), 1848: } 1849: )); 1850: 1851: addLibrary(JCommon.INFO); 1852: 1853: } 1854: 1855: /** 1856: * Returns the JFreeChart logo (a picture of a gorilla). 1857: * 1858: * @return The JFreeChart logo. 1859: */ 1860: public Image getLogo() { 1861: 1862: Image logo = super.getLogo(); 1863: if (logo == null) { 1864: URL imageURL = this.getClass().getClassLoader().getResource( 1865: "org/jfree/chart/gorilla.jpg"); 1866: if (imageURL != null) { 1867: ImageIcon temp = new ImageIcon(imageURL); 1868: // use ImageIcon because it waits for the image to load... 1869: logo = temp.getImage(); 1870: setLogo(logo); 1871: } 1872: } 1873: return logo; 1874: 1875: } 1876: 1877: }