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
152package org.jfree.chart;
153
154import java.awt.AlphaComposite;
155import java.awt.BasicStroke;
156import java.awt.Color;
157import java.awt.Composite;
158import java.awt.Font;
159import java.awt.Graphics2D;
160import java.awt.Image;
161import java.awt.Paint;
162import java.awt.RenderingHints;
163import java.awt.Shape;
164import java.awt.Stroke;
165import java.awt.geom.AffineTransform;
166import java.awt.geom.Point2D;
167import java.awt.geom.Rectangle2D;
168import java.awt.image.BufferedImage;
169import java.io.IOException;
170import java.io.ObjectInputStream;
171import java.io.ObjectOutputStream;
172import java.io.Serializable;
173import java.net.URL;
174import java.util.ArrayList;
175import java.util.Arrays;
176import java.util.Iterator;
177import java.util.List;
178import java.util.ResourceBundle;
179
180import javax.swing.ImageIcon;
181import javax.swing.UIManager;
182import javax.swing.event.EventListenerList;
183
184import org.jfree.JCommon;
185import org.jfree.chart.block.BlockParams;
186import org.jfree.chart.block.EntityBlockResult;
187import org.jfree.chart.block.LengthConstraintType;
188import org.jfree.chart.block.LineBorder;
189import org.jfree.chart.block.RectangleConstraint;
190import org.jfree.chart.entity.EntityCollection;
191import org.jfree.chart.entity.JFreeChartEntity;
192import org.jfree.chart.event.ChartChangeEvent;
193import org.jfree.chart.event.ChartChangeListener;
194import org.jfree.chart.event.ChartProgressEvent;
195import org.jfree.chart.event.ChartProgressListener;
196import org.jfree.chart.event.PlotChangeEvent;
197import org.jfree.chart.event.PlotChangeListener;
198import org.jfree.chart.event.TitleChangeEvent;
199import org.jfree.chart.event.TitleChangeListener;
200import org.jfree.chart.plot.CategoryPlot;
201import org.jfree.chart.plot.Plot;
202import org.jfree.chart.plot.PlotRenderingInfo;
203import org.jfree.chart.plot.XYPlot;
204import org.jfree.chart.title.LegendTitle;
205import org.jfree.chart.title.TextTitle;
206import org.jfree.chart.title.Title;
207import org.jfree.chart.util.ResourceBundleWrapper;
208import org.jfree.data.Range;
209import org.jfree.io.SerialUtilities;
210import org.jfree.ui.Align;
211import org.jfree.ui.Drawable;
212import org.jfree.ui.HorizontalAlignment;
213import org.jfree.ui.RectangleEdge;
214import org.jfree.ui.RectangleInsets;
215import org.jfree.ui.Size2D;
216import org.jfree.ui.VerticalAlignment;
217import org.jfree.ui.about.Contributor;
218import org.jfree.ui.about.Licences;
219import org.jfree.ui.about.ProjectInfo;
220import org.jfree.util.ObjectUtilities;
221import 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 */
244public 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 */
1744class 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}