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