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