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