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 }