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