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