Java tutorial
/* =========================================================== * JFreeChart : a free chart library for the Java(tm) platform * =========================================================== * * (C) Copyright 2000-2014, by Object Refinery Limited and Contributors. * * Project Info: http://www.jfree.org/jfreechart/index.html * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation; either version 2.1 of the License, or * (at your option) any later version. * * This library is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public * License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, * USA. * * [Oracle and Java are registered trademarks of Oracle and/or its affiliates. * Other names may be trademarks of their respective owners.] * * --------------- * JFreeChart.java * --------------- * (C) Copyright 2000-2014, by Object Refinery Limited and Contributors. * * Original Author: David Gilbert (for Object Refinery Limited); * Contributor(s): Andrzej Porebski; * David Li; * Wolfgang Irler; * Christian W. Zuckschwerdt; * Klaus Rheinwald; * Nicolas Brodu; * Peter Kolb (patch 2603321); * * NOTE: The above list of contributors lists only the people that have * contributed to this source file (JFreeChart.java) - for a list of ALL * contributors to the project, please see the README.txt file. * * Changes (from 20-Jun-2001) * -------------------------- * 20-Jun-2001 : Modifications submitted by Andrzej Porebski for legend * placement; * 21-Jun-2001 : Removed JFreeChart parameter from Plot constructors (DG); * 22-Jun-2001 : Multiple titles added (original code by David Berry, with * reworkings by DG); * 18-Sep-2001 : Updated header (DG); * 15-Oct-2001 : Moved data source classes into new package * com.jrefinery.data.* (DG); * 18-Oct-2001 : New factory method for creating VerticalXYBarChart (DG); * 19-Oct-2001 : Moved series paint and stroke methods to the Plot class (DG); * Moved static chart creation methods to new ChartFactory * class (DG); * 22-Oct-2001 : Renamed DataSource.java --> Dataset.java etc. (DG); * Fixed bug where chart isn't registered with the dataset (DG); * 07-Nov-2001 : Fixed bug where null title in constructor causes * exception (DG); * Tidied up event notification code (DG); * 17-Nov-2001 : Added getLegendItemCount() method (DG); * 21-Nov-2001 : Set clipping in draw method to ensure that nothing gets drawn * outside the chart area (DG); * 11-Dec-2001 : Added the createBufferedImage() method, taken from the * JFreeChartServletDemo class (DG); * 13-Dec-2001 : Added tooltips (DG); * 16-Jan-2002 : Added handleClick() method (DG); * 22-Jan-2002 : Fixed bug correlating legend labels with pie data (DG); * 05-Feb-2002 : Removed redundant tooltips code (DG); * 19-Feb-2002 : Added accessor methods for the backgroundImage and * backgroundImageAlpha attributes (DG); * 21-Feb-2002 : Added static fields for INFO, COPYRIGHT, LICENCE, CONTRIBUTORS * and LIBRARIES. These can be used to display information about * JFreeChart (DG); * 06-Mar-2002 : Moved constants to JFreeChartConstants interface (DG); * 18-Apr-2002 : PieDataset is no longer sorted (oldman); * 23-Apr-2002 : Moved dataset to the Plot class (DG); * 13-Jun-2002 : Added an extra draw() method (DG); * 25-Jun-2002 : Implemented the Drawable interface and removed redundant * imports (DG); * 26-Jun-2002 : Added another createBufferedImage() method (DG); * 18-Sep-2002 : Fixed issues reported by Checkstyle (DG); * 23-Sep-2002 : Added new contributor (DG); * 28-Oct-2002 : Created main title and subtitle list to replace existing title * list (DG); * 08-Jan-2003 : Added contributor (DG); * 17-Jan-2003 : Added new constructor (DG); * 22-Jan-2003 : Added ChartColor class by Cameron Riley, and background image * alignment code by Christian W. Zuckschwerdt (DG); * 11-Feb-2003 : Added flag to allow suppression of chart change events, based * on a suggestion by Klaus Rheinwald (DG); * 04-Mar-2003 : Added small fix for suppressed chart change events (see bug id * 690865) (DG); * 10-Mar-2003 : Added Benoit Xhenseval to contributors (DG); * 26-Mar-2003 : Implemented Serializable (DG); * 15-Jul-2003 : Added an optional border for the chart (DG); * 11-Sep-2003 : Took care of listeners while cloning (NB); * 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG); * 22-Sep-2003 : Added nullpointer checks. * 25-Sep-2003 : Added nullpointer checks too (NB). * 03-Dec-2003 : Legends are now registered by this class instead of using the * old constructor way (TM); * 03-Dec-2003 : Added anchorPoint to draw() method (DG); * 08-Jan-2004 : Reworked title code, introducing line wrapping (DG); * 09-Feb-2004 : Created additional createBufferedImage() method (DG); * 05-Apr-2004 : Added new createBufferedImage() method (DG); * 27-May-2004 : Moved constants from JFreeChartConstants.java back to this * class (DG); * 25-Nov-2004 : Updates for changes to Title class (DG); * 06-Jan-2005 : Change lookup for default background color (DG); * 31-Jan-2005 : Added Don Elliott to contributors (DG); * 02-Feb-2005 : Added clearSubtitles() method (DG); * 03-Feb-2005 : Added Mofeed Shahin to contributors (DG); * 08-Feb-2005 : Updated for RectangleConstraint changes (DG); * 28-Mar-2005 : Renamed Legend --> OldLegend (DG); * 12-Apr-2005 : Added methods to access legend(s) in subtitle list (DG); * 13-Apr-2005 : Added removeLegend() and removeSubtitle() methods (DG); * 20-Apr-2005 : Modified to collect chart entities from titles and * subtitles (DG); * 26-Apr-2005 : Removed LOGGER (DG); * 06-Jun-2005 : Added addLegend() method and padding attribute, fixed equals() * method (DG); * 24-Nov-2005 : Removed OldLegend and related code - don't want to support * this in 1.0.0 final (DG); * ------------- JFREECHART 1.0.x --------------------------------------------- * 27-Jan-2006 : Updated version number (DG); * 07-Dec-2006 : Added some missing credits (DG); * 17-Jan-2007 : Added Darren Jung to contributor list (DG); * 05-Mar-2007 : Added Sergei Ivanov to the contributor list (DG); * 16-Mar-2007 : Modified initial legend border (DG); * 22-Mar-2007 : New methods for text anti-aliasing (DG); * 16-May-2007 : Fixed argument check in getSubtitle(), copy list in * get/setSubtitles(), and added new addSubtitle(int, Title) * method (DG); * 05-Jun-2007 : Add change listener to default legend (DG); * 04-Dec-2007 : In createBufferedImage() methods, make the default image type * BufferedImage.TYPE_INT_ARGB (thanks to Klaus Rheinwald) (DG); * 05-Dec-2007 : Fixed bug 1749124 (not registering as listener with * TextTitle) (DG); * 23-Apr-2008 : Added new contributor (Diego Pierangeli) (DG); * 16-May-2008 : Added new contributor (Michael Siemer) (DG); * 19-Sep-2008 : Check for title visibility (DG); * 18-Dec-2008 : Use ResourceBundleWrapper - see patch 1607918 by * Jess Thrysoee (DG); * 19-Mar-2009 : Added entity support - see patch 2603321 by Peter Kolb (DG); * 19-May-2009 : Fixed FindBugs warnings, patch by Michal Wozniak (DG); * 29-Jun-2009 : Check visibility flag in main title (DG); * 02-Jul-2013 : Use ParamChecks class (DG); * 21-Jun-2014 : Set default hint value for stroke control (DG); * */ package org.jfree.chart; import java.awt.AlphaComposite; import java.awt.BasicStroke; import java.awt.Color; import java.awt.Composite; import java.awt.Font; import java.awt.Graphics2D; import java.awt.Image; import java.awt.Paint; import java.awt.RenderingHints; import java.awt.Shape; import java.awt.Stroke; import java.awt.geom.AffineTransform; import java.awt.geom.Point2D; import java.awt.geom.Rectangle2D; import java.awt.image.BufferedImage; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.net.URL; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.List; import java.util.ResourceBundle; import javax.swing.ImageIcon; import javax.swing.UIManager; import javax.swing.event.EventListenerList; import org.jfree.JCommon; import org.jfree.chart.block.BlockParams; import org.jfree.chart.block.EntityBlockResult; import org.jfree.chart.block.LengthConstraintType; import org.jfree.chart.block.LineBorder; import org.jfree.chart.block.RectangleConstraint; import org.jfree.chart.entity.EntityCollection; import org.jfree.chart.entity.JFreeChartEntity; import org.jfree.chart.event.ChartChangeEvent; import org.jfree.chart.event.ChartChangeListener; import org.jfree.chart.event.ChartProgressEvent; import org.jfree.chart.event.ChartProgressListener; import org.jfree.chart.event.PlotChangeEvent; import org.jfree.chart.event.PlotChangeListener; import org.jfree.chart.event.TitleChangeEvent; import org.jfree.chart.event.TitleChangeListener; import org.jfree.chart.plot.CategoryPlot; import org.jfree.chart.plot.Plot; import org.jfree.chart.plot.PlotRenderingInfo; import org.jfree.chart.plot.XYPlot; import org.jfree.chart.title.LegendTitle; import org.jfree.chart.title.TextTitle; import org.jfree.chart.title.Title; import org.jfree.chart.util.ParamChecks; import org.jfree.chart.util.ResourceBundleWrapper; import org.jfree.data.Range; import org.jfree.io.SerialUtilities; import org.jfree.ui.Align; import org.jfree.ui.Drawable; import org.jfree.ui.HorizontalAlignment; import org.jfree.ui.RectangleEdge; import org.jfree.ui.RectangleInsets; import org.jfree.ui.Size2D; import org.jfree.ui.VerticalAlignment; import org.jfree.ui.about.Contributor; import org.jfree.ui.about.Licences; import org.jfree.ui.about.ProjectInfo; import org.jfree.util.ObjectUtilities; import org.jfree.util.PaintUtilities; /** * A chart class implemented using the Java 2D APIs. The current version * supports bar charts, line charts, pie charts and xy plots (including time * series data). * <P> * JFreeChart coordinates several objects to achieve its aim of being able to * draw a chart on a Java 2D graphics device: a list of {@link Title} objects * (which often includes the chart's legend), a {@link Plot} and a * {@link org.jfree.data.general.Dataset} (the plot in turn manages a * domain axis and a range axis). * <P> * You should use a {@link ChartPanel} to display a chart in a GUI. * <P> * The {@link ChartFactory} class contains static methods for creating * 'ready-made' charts. * * @see ChartPanel * @see ChartFactory * @see Title * @see Plot */ public class JFreeChart implements Drawable, TitleChangeListener, PlotChangeListener, Serializable, Cloneable { /** For serialization. */ private static final long serialVersionUID = -3470703747817429120L; /** Information about the project. */ public static final ProjectInfo INFO = new JFreeChartInfo(); /** The default font for titles. */ public static final Font DEFAULT_TITLE_FONT = new Font("SansSerif", Font.BOLD, 18); /** The default background color. */ public static final Paint DEFAULT_BACKGROUND_PAINT = UIManager.getColor("Panel.background"); /** The default background image. */ public static final Image DEFAULT_BACKGROUND_IMAGE = null; /** The default background image alignment. */ public static final int DEFAULT_BACKGROUND_IMAGE_ALIGNMENT = Align.FIT; /** The default background image alpha. */ public static final float DEFAULT_BACKGROUND_IMAGE_ALPHA = 0.5f; /** * The key for a rendering hint that can suppress the generation of a * shadow effect when drawing the chart. The hint value must be a * Boolean. * * @since 1.0.16 */ public static final RenderingHints.Key KEY_SUPPRESS_SHADOW_GENERATION = new RenderingHints.Key(0) { @Override public boolean isCompatibleValue(Object val) { return val instanceof Boolean; } }; /** * Rendering hints that will be used for chart drawing. This should never * be <code>null</code>. */ private transient RenderingHints renderingHints; /** A flag that controls whether or not the chart border is drawn. */ private boolean borderVisible; /** The stroke used to draw the chart border (if visible). */ private transient Stroke borderStroke; /** The paint used to draw the chart border (if visible). */ private transient Paint borderPaint; /** The padding between the chart border and the chart drawing area. */ private RectangleInsets padding; /** The chart title (optional). */ private TextTitle title; /** * The chart subtitles (zero, one or many). This field should never be * <code>null</code>. */ private List subtitles; /** Draws the visual representation of the data. */ private Plot plot; /** Paint used to draw the background of the chart. */ private transient Paint backgroundPaint; /** An optional background image for the chart. */ private transient Image backgroundImage; // todo: not serialized yet /** The alignment for the background image. */ private int backgroundImageAlignment = Align.FIT; /** The alpha transparency for the background image. */ private float backgroundImageAlpha = 0.5f; /** Storage for registered change listeners. */ private transient EventListenerList changeListeners; /** Storage for registered progress listeners. */ private transient EventListenerList progressListeners; /** * A flag that can be used to enable/disable notification of chart change * events. */ private boolean notify; /** * Creates a new chart based on the supplied plot. The chart will have * a legend added automatically, but no title (although you can easily add * one later). * <br><br> * Note that the {@link ChartFactory} class contains a range * of static methods that will return ready-made charts, and often this * is a more convenient way to create charts than using this constructor. * * @param plot the plot (<code>null</code> not permitted). */ public JFreeChart(Plot plot) { this(null, null, plot, true); } /** * Creates a new chart with the given title and plot. A default font * ({@link #DEFAULT_TITLE_FONT}) is used for the title, and the chart will * have a legend added automatically. * <br><br> * Note that the {@link ChartFactory} class contains a range * of static methods that will return ready-made charts, and often this * is a more convenient way to create charts than using this constructor. * * @param title the chart title (<code>null</code> permitted). * @param plot the plot (<code>null</code> not permitted). */ public JFreeChart(String title, Plot plot) { this(title, JFreeChart.DEFAULT_TITLE_FONT, plot, true); } /** * Creates a new chart with the given title and plot. The * <code>createLegend</code> argument specifies whether or not a legend * should be added to the chart. * <br><br> * Note that the {@link ChartFactory} class contains a range * of static methods that will return ready-made charts, and often this * is a more convenient way to create charts than using this constructor. * * @param title the chart title (<code>null</code> permitted). * @param titleFont the font for displaying the chart title * (<code>null</code> permitted). * @param plot controller of the visual representation of the data * (<code>null</code> not permitted). * @param createLegend a flag indicating whether or not a legend should * be created for the chart. */ public JFreeChart(String title, Font titleFont, Plot plot, boolean createLegend) { ParamChecks.nullNotPermitted(plot, "plot"); // create storage for listeners... this.progressListeners = new EventListenerList(); this.changeListeners = new EventListenerList(); this.notify = true; // default is to notify listeners when the // chart changes this.renderingHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); // added the following hint because of // http://stackoverflow.com/questions/7785082/ this.renderingHints.put(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE); this.borderVisible = false; this.borderStroke = new BasicStroke(1.0f); this.borderPaint = Color.black; this.padding = RectangleInsets.ZERO_INSETS; this.plot = plot; plot.addChangeListener(this); this.subtitles = new ArrayList(); // create a legend, if requested... if (createLegend) { LegendTitle legend = new LegendTitle(this.plot); legend.setMargin(new RectangleInsets(1.0, 1.0, 1.0, 1.0)); legend.setFrame(new LineBorder()); legend.setBackgroundPaint(Color.white); legend.setPosition(RectangleEdge.BOTTOM); this.subtitles.add(legend); legend.addChangeListener(this); } // add the chart title, if one has been specified... if (title != null) { if (titleFont == null) { titleFont = DEFAULT_TITLE_FONT; } this.title = new TextTitle(title, titleFont); this.title.addChangeListener(this); } this.backgroundPaint = DEFAULT_BACKGROUND_PAINT; this.backgroundImage = DEFAULT_BACKGROUND_IMAGE; this.backgroundImageAlignment = DEFAULT_BACKGROUND_IMAGE_ALIGNMENT; this.backgroundImageAlpha = DEFAULT_BACKGROUND_IMAGE_ALPHA; } /** * Returns the collection of rendering hints for the chart. * * @return The rendering hints for the chart (never <code>null</code>). * * @see #setRenderingHints(RenderingHints) */ public RenderingHints getRenderingHints() { return this.renderingHints; } /** * Sets the rendering hints for the chart. These will be added (using the * {@code Graphics2D.addRenderingHints()} method) near the start of the * {@code JFreeChart.draw()} method. * * @param renderingHints the rendering hints ({@code null} not permitted). * * @see #getRenderingHints() */ public void setRenderingHints(RenderingHints renderingHints) { ParamChecks.nullNotPermitted(renderingHints, "renderingHints"); this.renderingHints = renderingHints; fireChartChanged(); } /** * Returns a flag that controls whether or not a border is drawn around the * outside of the chart. * * @return A boolean. * * @see #setBorderVisible(boolean) */ public boolean isBorderVisible() { return this.borderVisible; } /** * Sets a flag that controls whether or not a border is drawn around the * outside of the chart. * * @param visible the flag. * * @see #isBorderVisible() */ public void setBorderVisible(boolean visible) { this.borderVisible = visible; fireChartChanged(); } /** * Returns the stroke used to draw the chart border (if visible). * * @return The border stroke. * * @see #setBorderStroke(Stroke) */ public Stroke getBorderStroke() { return this.borderStroke; } /** * Sets the stroke used to draw the chart border (if visible). * * @param stroke the stroke. * * @see #getBorderStroke() */ public void setBorderStroke(Stroke stroke) { this.borderStroke = stroke; fireChartChanged(); } /** * Returns the paint used to draw the chart border (if visible). * * @return The border paint. * * @see #setBorderPaint(Paint) */ public Paint getBorderPaint() { return this.borderPaint; } /** * Sets the paint used to draw the chart border (if visible). * * @param paint the paint. * * @see #getBorderPaint() */ public void setBorderPaint(Paint paint) { this.borderPaint = paint; fireChartChanged(); } /** * Returns the padding between the chart border and the chart drawing area. * * @return The padding (never <code>null</code>). * * @see #setPadding(RectangleInsets) */ public RectangleInsets getPadding() { return this.padding; } /** * Sets the padding between the chart border and the chart drawing area, * and sends a {@link ChartChangeEvent} to all registered listeners. * * @param padding the padding (<code>null</code> not permitted). * * @see #getPadding() */ public void setPadding(RectangleInsets padding) { ParamChecks.nullNotPermitted(padding, "padding"); this.padding = padding; notifyListeners(new ChartChangeEvent(this)); } /** * Returns the main chart title. Very often a chart will have just one * title, so we make this case simple by providing accessor methods for * the main title. However, multiple titles are supported - see the * {@link #addSubtitle(Title)} method. * * @return The chart title (possibly <code>null</code>). * * @see #setTitle(TextTitle) */ public TextTitle getTitle() { return this.title; } /** * Sets the main title for the chart and sends a {@link ChartChangeEvent} * to all registered listeners. If you do not want a title for the * chart, set it to <code>null</code>. If you want more than one title on * a chart, use the {@link #addSubtitle(Title)} method. * * @param title the title (<code>null</code> permitted). * * @see #getTitle() */ public void setTitle(TextTitle title) { if (this.title != null) { this.title.removeChangeListener(this); } this.title = title; if (title != null) { title.addChangeListener(this); } fireChartChanged(); } /** * Sets the chart title and sends a {@link ChartChangeEvent} to all * registered listeners. This is a convenience method that ends up calling * the {@link #setTitle(TextTitle)} method. If there is an existing title, * its text is updated, otherwise a new title using the default font is * added to the chart. If <code>text</code> is <code>null</code> the chart * title is set to <code>null</code>. * * @param text the title text (<code>null</code> permitted). * * @see #getTitle() */ public void setTitle(String text) { if (text != null) { if (this.title == null) { setTitle(new TextTitle(text, JFreeChart.DEFAULT_TITLE_FONT)); } else { this.title.setText(text); } } else { setTitle((TextTitle) null); } } /** * Adds a legend to the plot and sends a {@link ChartChangeEvent} to all * registered listeners. * * @param legend the legend (<code>null</code> not permitted). * * @see #removeLegend() */ public void addLegend(LegendTitle legend) { addSubtitle(legend); } /** * Returns the legend for the chart, if there is one. Note that a chart * can have more than one legend - this method returns the first. * * @return The legend (possibly <code>null</code>). * * @see #getLegend(int) */ public LegendTitle getLegend() { return getLegend(0); } /** * Returns the nth legend for a chart, or <code>null</code>. * * @param index the legend index (zero-based). * * @return The legend (possibly <code>null</code>). * * @see #addLegend(LegendTitle) */ public LegendTitle getLegend(int index) { int seen = 0; Iterator iterator = this.subtitles.iterator(); while (iterator.hasNext()) { Title subtitle = (Title) iterator.next(); if (subtitle instanceof LegendTitle) { if (seen == index) { return (LegendTitle) subtitle; } else { seen++; } } } return null; } /** * Removes the first legend in the chart and sends a * {@link ChartChangeEvent} to all registered listeners. * * @see #getLegend() */ public void removeLegend() { removeSubtitle(getLegend()); } /** * Returns the list of subtitles for the chart. * * @return The subtitle list (possibly empty, but never <code>null</code>). * * @see #setSubtitles(List) */ public List getSubtitles() { return new ArrayList(this.subtitles); } /** * Sets the title list for the chart (completely replaces any existing * titles) and sends a {@link ChartChangeEvent} to all registered * listeners. * * @param subtitles the new list of subtitles (<code>null</code> not * permitted). * * @see #getSubtitles() */ public void setSubtitles(List subtitles) { if (subtitles == null) { throw new NullPointerException("Null 'subtitles' argument."); } setNotify(false); clearSubtitles(); Iterator iterator = subtitles.iterator(); while (iterator.hasNext()) { Title t = (Title) iterator.next(); if (t != null) { addSubtitle(t); } } setNotify(true); // this fires a ChartChangeEvent } /** * Returns the number of titles for the chart. * * @return The number of titles for the chart. * * @see #getSubtitles() */ public int getSubtitleCount() { return this.subtitles.size(); } /** * Returns a chart subtitle. * * @param index the index of the chart subtitle (zero based). * * @return A chart subtitle. * * @see #addSubtitle(Title) */ public Title getSubtitle(int index) { if ((index < 0) || (index >= getSubtitleCount())) { throw new IllegalArgumentException("Index out of range."); } return (Title) this.subtitles.get(index); } /** * Adds a chart subtitle, and notifies registered listeners that the chart * has been modified. * * @param subtitle the subtitle (<code>null</code> not permitted). * * @see #getSubtitle(int) */ public void addSubtitle(Title subtitle) { ParamChecks.nullNotPermitted(subtitle, "subtitle"); this.subtitles.add(subtitle); subtitle.addChangeListener(this); fireChartChanged(); } /** * Adds a subtitle at a particular position in the subtitle list, and sends * a {@link ChartChangeEvent} to all registered listeners. * * @param index the index (in the range 0 to {@link #getSubtitleCount()}). * @param subtitle the subtitle to add (<code>null</code> not permitted). * * @since 1.0.6 */ public void addSubtitle(int index, Title subtitle) { if (index < 0 || index > getSubtitleCount()) { throw new IllegalArgumentException("The 'index' argument is out of range."); } ParamChecks.nullNotPermitted(subtitle, "subtitle"); this.subtitles.add(index, subtitle); subtitle.addChangeListener(this); fireChartChanged(); } /** * Clears all subtitles from the chart and sends a {@link ChartChangeEvent} * to all registered listeners. * * @see #addSubtitle(Title) */ public void clearSubtitles() { Iterator iterator = this.subtitles.iterator(); while (iterator.hasNext()) { Title t = (Title) iterator.next(); t.removeChangeListener(this); } this.subtitles.clear(); fireChartChanged(); } /** * Removes the specified subtitle and sends a {@link ChartChangeEvent} to * all registered listeners. * * @param title the title. * * @see #addSubtitle(Title) */ public void removeSubtitle(Title title) { this.subtitles.remove(title); fireChartChanged(); } /** * Returns the plot for the chart. The plot is a class responsible for * coordinating the visual representation of the data, including the axes * (if any). * * @return The plot. */ public Plot getPlot() { return this.plot; } /** * Returns the plot cast as a {@link CategoryPlot}. * <p> * NOTE: if the plot is not an instance of {@link CategoryPlot}, then a * <code>ClassCastException</code> is thrown. * * @return The plot. * * @see #getPlot() */ public CategoryPlot getCategoryPlot() { return (CategoryPlot) this.plot; } /** * Returns the plot cast as an {@link XYPlot}. * <p> * NOTE: if the plot is not an instance of {@link XYPlot}, then a * <code>ClassCastException</code> is thrown. * * @return The plot. * * @see #getPlot() */ public XYPlot getXYPlot() { return (XYPlot) this.plot; } /** * Returns a flag that indicates whether or not anti-aliasing is used when * the chart is drawn. * * @return The flag. * * @see #setAntiAlias(boolean) */ public boolean getAntiAlias() { Object val = this.renderingHints.get(RenderingHints.KEY_ANTIALIASING); return RenderingHints.VALUE_ANTIALIAS_ON.equals(val); } /** * Sets a flag that indicates whether or not anti-aliasing is used when the * chart is drawn. * <P> * Anti-aliasing usually improves the appearance of charts, but is slower. * * @param flag the new value of the flag. * * @see #getAntiAlias() */ public void setAntiAlias(boolean flag) { Object hint = flag ? RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF; this.renderingHints.put(RenderingHints.KEY_ANTIALIASING, hint); fireChartChanged(); } /** * Returns the current value stored in the rendering hints table for * {@link RenderingHints#KEY_TEXT_ANTIALIASING}. * * @return The hint value (possibly <code>null</code>). * * @since 1.0.5 * * @see #setTextAntiAlias(Object) */ public Object getTextAntiAlias() { return this.renderingHints.get(RenderingHints.KEY_TEXT_ANTIALIASING); } /** * Sets the value in the rendering hints table for * {@link RenderingHints#KEY_TEXT_ANTIALIASING} to either * {@link RenderingHints#VALUE_TEXT_ANTIALIAS_ON} or * {@link RenderingHints#VALUE_TEXT_ANTIALIAS_OFF}, then sends a * {@link ChartChangeEvent} to all registered listeners. * * @param flag the new value of the flag. * * @since 1.0.5 * * @see #getTextAntiAlias() * @see #setTextAntiAlias(Object) */ public void setTextAntiAlias(boolean flag) { if (flag) { setTextAntiAlias(RenderingHints.VALUE_TEXT_ANTIALIAS_ON); } else { setTextAntiAlias(RenderingHints.VALUE_TEXT_ANTIALIAS_OFF); } } /** * Sets the value in the rendering hints table for * {@link RenderingHints#KEY_TEXT_ANTIALIASING} and sends a * {@link ChartChangeEvent} to all registered listeners. * * @param val the new value (<code>null</code> permitted). * * @since 1.0.5 * * @see #getTextAntiAlias() * @see #setTextAntiAlias(boolean) */ public void setTextAntiAlias(Object val) { this.renderingHints.put(RenderingHints.KEY_TEXT_ANTIALIASING, val); notifyListeners(new ChartChangeEvent(this)); } /** * Returns the paint used for the chart background. * * @return The paint (possibly <code>null</code>). * * @see #setBackgroundPaint(Paint) */ public Paint getBackgroundPaint() { return this.backgroundPaint; } /** * Sets the paint used to fill the chart background and sends a * {@link ChartChangeEvent} to all registered listeners. * * @param paint the paint (<code>null</code> permitted). * * @see #getBackgroundPaint() */ public void setBackgroundPaint(Paint paint) { if (this.backgroundPaint != null) { if (!this.backgroundPaint.equals(paint)) { this.backgroundPaint = paint; fireChartChanged(); } } else { if (paint != null) { this.backgroundPaint = paint; fireChartChanged(); } } } /** * Returns the background image for the chart, or <code>null</code> if * there is no image. * * @return The image (possibly <code>null</code>). * * @see #setBackgroundImage(Image) */ public Image getBackgroundImage() { return this.backgroundImage; } /** * Sets the background image for the chart and sends a * {@link ChartChangeEvent} to all registered listeners. * * @param image the image (<code>null</code> permitted). * * @see #getBackgroundImage() */ public void setBackgroundImage(Image image) { if (this.backgroundImage != null) { if (!this.backgroundImage.equals(image)) { this.backgroundImage = image; fireChartChanged(); } } else { if (image != null) { this.backgroundImage = image; fireChartChanged(); } } } /** * Returns the background image alignment. Alignment constants are defined * in the <code>org.jfree.ui.Align</code> class in the JCommon class * library. * * @return The alignment. * * @see #setBackgroundImageAlignment(int) */ public int getBackgroundImageAlignment() { return this.backgroundImageAlignment; } /** * Sets the background alignment. Alignment options are defined by the * {@link org.jfree.ui.Align} class. * * @param alignment the alignment. * * @see #getBackgroundImageAlignment() */ public void setBackgroundImageAlignment(int alignment) { if (this.backgroundImageAlignment != alignment) { this.backgroundImageAlignment = alignment; fireChartChanged(); } } /** * Returns the alpha-transparency for the chart's background image. * * @return The alpha-transparency. * * @see #setBackgroundImageAlpha(float) */ public float getBackgroundImageAlpha() { return this.backgroundImageAlpha; } /** * Sets the alpha-transparency for the chart's background image. * Registered listeners are notified that the chart has been changed. * * @param alpha the alpha value. * * @see #getBackgroundImageAlpha() */ public void setBackgroundImageAlpha(float alpha) { if (this.backgroundImageAlpha != alpha) { this.backgroundImageAlpha = alpha; fireChartChanged(); } } /** * Returns a flag that controls whether or not change events are sent to * registered listeners. * * @return A boolean. * * @see #setNotify(boolean) */ public boolean isNotify() { return this.notify; } /** * Sets a flag that controls whether or not listeners receive * {@link ChartChangeEvent} notifications. * * @param notify a boolean. * * @see #isNotify() */ public void setNotify(boolean notify) { this.notify = notify; // if the flag is being set to true, there may be queued up changes... if (notify) { notifyListeners(new ChartChangeEvent(this)); } } /** * Draws the chart on a Java 2D graphics device (such as the screen or a * printer). * <P> * This method is the focus of the entire JFreeChart library. * * @param g2 the graphics device. * @param area the area within which the chart should be drawn. */ @Override public void draw(Graphics2D g2, Rectangle2D area) { draw(g2, area, null, null); } /** * Draws the chart on a Java 2D graphics device (such as the screen or a * printer). This method is the focus of the entire JFreeChart library. * * @param g2 the graphics device. * @param area the area within which the chart should be drawn. * @param info records info about the drawing (null means collect no info). */ public void draw(Graphics2D g2, Rectangle2D area, ChartRenderingInfo info) { draw(g2, area, null, info); } /** * Draws the chart on a Java 2D graphics device (such as the screen or a * printer). * <P> * This method is the focus of the entire JFreeChart library. * * @param g2 the graphics device. * @param chartArea the area within which the chart should be drawn. * @param anchor the anchor point (in Java2D space) for the chart * (<code>null</code> permitted). * @param info records info about the drawing (null means collect no info). */ public void draw(Graphics2D g2, Rectangle2D chartArea, Point2D anchor, ChartRenderingInfo info) { notifyListeners(new ChartProgressEvent(this, this, ChartProgressEvent.DRAWING_STARTED, 0)); EntityCollection entities = null; // record the chart area, if info is requested... if (info != null) { info.clear(); info.setChartArea(chartArea); entities = info.getEntityCollection(); } if (entities != null) { entities.add(new JFreeChartEntity((Rectangle2D) chartArea.clone(), this)); } // ensure no drawing occurs outside chart area... Shape savedClip = g2.getClip(); g2.clip(chartArea); g2.addRenderingHints(this.renderingHints); // draw the chart background... if (this.backgroundPaint != null) { g2.setPaint(this.backgroundPaint); g2.fill(chartArea); } if (this.backgroundImage != null) { Composite originalComposite = g2.getComposite(); g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, this.backgroundImageAlpha)); Rectangle2D dest = new Rectangle2D.Double(0.0, 0.0, this.backgroundImage.getWidth(null), this.backgroundImage.getHeight(null)); Align.align(dest, chartArea, this.backgroundImageAlignment); g2.drawImage(this.backgroundImage, (int) dest.getX(), (int) dest.getY(), (int) dest.getWidth(), (int) dest.getHeight(), null); g2.setComposite(originalComposite); } if (isBorderVisible()) { Paint paint = getBorderPaint(); Stroke stroke = getBorderStroke(); if (paint != null && stroke != null) { Rectangle2D borderArea = new Rectangle2D.Double(chartArea.getX(), chartArea.getY(), chartArea.getWidth() - 1.0, chartArea.getHeight() - 1.0); g2.setPaint(paint); g2.setStroke(stroke); g2.draw(borderArea); } } // draw the title and subtitles... Rectangle2D nonTitleArea = new Rectangle2D.Double(); nonTitleArea.setRect(chartArea); this.padding.trim(nonTitleArea); if (this.title != null && this.title.isVisible()) { EntityCollection e = drawTitle(this.title, g2, nonTitleArea, (entities != null)); if (e != null && entities != null) { entities.addAll(e); } } Iterator iterator = this.subtitles.iterator(); while (iterator.hasNext()) { Title currentTitle = (Title) iterator.next(); if (currentTitle.isVisible()) { EntityCollection e = drawTitle(currentTitle, g2, nonTitleArea, (entities != null)); if (e != null && entities != null) { entities.addAll(e); } } } Rectangle2D plotArea = nonTitleArea; // draw the plot (axes and data visualisation) PlotRenderingInfo plotInfo = null; if (info != null) { plotInfo = info.getPlotInfo(); } this.plot.draw(g2, plotArea, anchor, null, plotInfo); g2.setClip(savedClip); notifyListeners(new ChartProgressEvent(this, this, ChartProgressEvent.DRAWING_FINISHED, 100)); } /** * Creates a rectangle that is aligned to the frame. * * @param dimensions the dimensions for the rectangle. * @param frame the frame to align to. * @param hAlign the horizontal alignment. * @param vAlign the vertical alignment. * * @return A rectangle. */ private Rectangle2D createAlignedRectangle2D(Size2D dimensions, Rectangle2D frame, HorizontalAlignment hAlign, VerticalAlignment vAlign) { double x = Double.NaN; double y = Double.NaN; if (hAlign == HorizontalAlignment.LEFT) { x = frame.getX(); } else if (hAlign == HorizontalAlignment.CENTER) { x = frame.getCenterX() - (dimensions.width / 2.0); } else if (hAlign == HorizontalAlignment.RIGHT) { x = frame.getMaxX() - dimensions.width; } if (vAlign == VerticalAlignment.TOP) { y = frame.getY(); } else if (vAlign == VerticalAlignment.CENTER) { y = frame.getCenterY() - (dimensions.height / 2.0); } else if (vAlign == VerticalAlignment.BOTTOM) { y = frame.getMaxY() - dimensions.height; } return new Rectangle2D.Double(x, y, dimensions.width, dimensions.height); } /** * Draws a title. The title should be drawn at the top, bottom, left or * right of the specified area, and the area should be updated to reflect * the amount of space used by the title. * * @param t the title (<code>null</code> not permitted). * @param g2 the graphics device (<code>null</code> not permitted). * @param area the chart area, excluding any existing titles * (<code>null</code> not permitted). * @param entities a flag that controls whether or not an entity * collection is returned for the title. * * @return An entity collection for the title (possibly <code>null</code>). */ protected EntityCollection drawTitle(Title t, Graphics2D g2, Rectangle2D area, boolean entities) { ParamChecks.nullNotPermitted(t, "t"); ParamChecks.nullNotPermitted(area, "area"); Rectangle2D titleArea; RectangleEdge position = t.getPosition(); double ww = area.getWidth(); if (ww <= 0.0) { return null; } double hh = area.getHeight(); if (hh <= 0.0) { return null; } RectangleConstraint constraint = new RectangleConstraint(ww, new Range(0.0, ww), LengthConstraintType.RANGE, hh, new Range(0.0, hh), LengthConstraintType.RANGE); Object retValue = null; BlockParams p = new BlockParams(); p.setGenerateEntities(entities); if (position == RectangleEdge.TOP) { Size2D size = t.arrange(g2, constraint); titleArea = createAlignedRectangle2D(size, area, t.getHorizontalAlignment(), VerticalAlignment.TOP); retValue = t.draw(g2, titleArea, p); area.setRect(area.getX(), Math.min(area.getY() + size.height, area.getMaxY()), area.getWidth(), Math.max(area.getHeight() - size.height, 0)); } else if (position == RectangleEdge.BOTTOM) { Size2D size = t.arrange(g2, constraint); titleArea = createAlignedRectangle2D(size, area, t.getHorizontalAlignment(), VerticalAlignment.BOTTOM); retValue = t.draw(g2, titleArea, p); area.setRect(area.getX(), area.getY(), area.getWidth(), area.getHeight() - size.height); } else if (position == RectangleEdge.RIGHT) { Size2D size = t.arrange(g2, constraint); titleArea = createAlignedRectangle2D(size, area, HorizontalAlignment.RIGHT, t.getVerticalAlignment()); retValue = t.draw(g2, titleArea, p); area.setRect(area.getX(), area.getY(), area.getWidth() - size.width, area.getHeight()); } else if (position == RectangleEdge.LEFT) { Size2D size = t.arrange(g2, constraint); titleArea = createAlignedRectangle2D(size, area, HorizontalAlignment.LEFT, t.getVerticalAlignment()); retValue = t.draw(g2, titleArea, p); area.setRect(area.getX() + size.width, area.getY(), area.getWidth() - size.width, area.getHeight()); } else { throw new RuntimeException("Unrecognised title position."); } EntityCollection result = null; if (retValue instanceof EntityBlockResult) { EntityBlockResult ebr = (EntityBlockResult) retValue; result = ebr.getEntityCollection(); } return result; } /** * Creates and returns a buffered image into which the chart has been drawn. * * @param width the width. * @param height the height. * * @return A buffered image. */ public BufferedImage createBufferedImage(int width, int height) { return createBufferedImage(width, height, null); } /** * Creates and returns a buffered image into which the chart has been drawn. * * @param width the width. * @param height the height. * @param info carries back chart state information (<code>null</code> * permitted). * * @return A buffered image. */ public BufferedImage createBufferedImage(int width, int height, ChartRenderingInfo info) { return createBufferedImage(width, height, BufferedImage.TYPE_INT_ARGB, info); } /** * Creates and returns a buffered image into which the chart has been drawn. * * @param width the width. * @param height the height. * @param imageType the image type. * @param info carries back chart state information (<code>null</code> * permitted). * * @return A buffered image. */ public BufferedImage createBufferedImage(int width, int height, int imageType, ChartRenderingInfo info) { BufferedImage image = new BufferedImage(width, height, imageType); Graphics2D g2 = image.createGraphics(); draw(g2, new Rectangle2D.Double(0, 0, width, height), null, info); g2.dispose(); return image; } /** * Creates and returns a buffered image into which the chart has been drawn. * * @param imageWidth the image width. * @param imageHeight the image height. * @param drawWidth the width for drawing the chart (will be scaled to * fit image). * @param drawHeight the height for drawing the chart (will be scaled to * fit image). * @param info optional object for collection chart dimension and entity * information. * * @return A buffered image. */ public BufferedImage createBufferedImage(int imageWidth, int imageHeight, double drawWidth, double drawHeight, ChartRenderingInfo info) { BufferedImage image = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_ARGB); Graphics2D g2 = image.createGraphics(); double scaleX = imageWidth / drawWidth; double scaleY = imageHeight / drawHeight; AffineTransform st = AffineTransform.getScaleInstance(scaleX, scaleY); g2.transform(st); draw(g2, new Rectangle2D.Double(0, 0, drawWidth, drawHeight), null, info); g2.dispose(); return image; } /** * Handles a 'click' on the chart. JFreeChart is not a UI component, so * some other object (for example, {@link ChartPanel}) needs to capture * the click event and pass it onto the JFreeChart object. * If you are not using JFreeChart in a client application, then this * method is not required. * * @param x x-coordinate of the click (in Java2D space). * @param y y-coordinate of the click (in Java2D space). * @param info contains chart dimension and entity information * (<code>null</code> not permitted). */ public void handleClick(int x, int y, ChartRenderingInfo info) { // pass the click on to the plot... // rely on the plot to post a plot change event and redraw the chart... this.plot.handleClick(x, y, info.getPlotInfo()); } /** * Registers an object for notification of changes to the chart. * * @param listener the listener (<code>null</code> not permitted). * * @see #removeChangeListener(ChartChangeListener) */ public void addChangeListener(ChartChangeListener listener) { ParamChecks.nullNotPermitted(listener, "listener"); this.changeListeners.add(ChartChangeListener.class, listener); } /** * Deregisters an object for notification of changes to the chart. * * @param listener the listener (<code>null</code> not permitted) * * @see #addChangeListener(ChartChangeListener) */ public void removeChangeListener(ChartChangeListener listener) { ParamChecks.nullNotPermitted(listener, "listener"); this.changeListeners.remove(ChartChangeListener.class, listener); } /** * Sends a default {@link ChartChangeEvent} to all registered listeners. * <P> * This method is for convenience only. */ public void fireChartChanged() { ChartChangeEvent event = new ChartChangeEvent(this); notifyListeners(event); } /** * Sends a {@link ChartChangeEvent} to all registered listeners. * * @param event information about the event that triggered the * notification. */ protected void notifyListeners(ChartChangeEvent event) { if (this.notify) { Object[] listeners = this.changeListeners.getListenerList(); for (int i = listeners.length - 2; i >= 0; i -= 2) { if (listeners[i] == ChartChangeListener.class) { ((ChartChangeListener) listeners[i + 1]).chartChanged(event); } } } } /** * Registers an object for notification of progress events relating to the * chart. * * @param listener the object being registered. * * @see #removeProgressListener(ChartProgressListener) */ public void addProgressListener(ChartProgressListener listener) { this.progressListeners.add(ChartProgressListener.class, listener); } /** * Deregisters an object for notification of changes to the chart. * * @param listener the object being deregistered. * * @see #addProgressListener(ChartProgressListener) */ public void removeProgressListener(ChartProgressListener listener) { this.progressListeners.remove(ChartProgressListener.class, listener); } /** * Sends a {@link ChartProgressEvent} to all registered listeners. * * @param event information about the event that triggered the * notification. */ protected void notifyListeners(ChartProgressEvent event) { Object[] listeners = this.progressListeners.getListenerList(); for (int i = listeners.length - 2; i >= 0; i -= 2) { if (listeners[i] == ChartProgressListener.class) { ((ChartProgressListener) listeners[i + 1]).chartProgress(event); } } } /** * Receives notification that a chart title has changed, and passes this * on to registered listeners. * * @param event information about the chart title change. */ @Override public void titleChanged(TitleChangeEvent event) { event.setChart(this); notifyListeners(event); } /** * Receives notification that the plot has changed, and passes this on to * registered listeners. * * @param event information about the plot change. */ @Override public void plotChanged(PlotChangeEvent event) { event.setChart(this); notifyListeners(event); } /** * Tests this chart for equality with another object. * * @param obj the object (<code>null</code> permitted). * * @return A boolean. */ @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof JFreeChart)) { return false; } JFreeChart that = (JFreeChart) obj; if (!this.renderingHints.equals(that.renderingHints)) { return false; } if (this.borderVisible != that.borderVisible) { return false; } if (!ObjectUtilities.equal(this.borderStroke, that.borderStroke)) { return false; } if (!PaintUtilities.equal(this.borderPaint, that.borderPaint)) { return false; } if (!this.padding.equals(that.padding)) { return false; } if (!ObjectUtilities.equal(this.title, that.title)) { return false; } if (!ObjectUtilities.equal(this.subtitles, that.subtitles)) { return false; } if (!ObjectUtilities.equal(this.plot, that.plot)) { return false; } if (!PaintUtilities.equal(this.backgroundPaint, that.backgroundPaint)) { return false; } if (!ObjectUtilities.equal(this.backgroundImage, that.backgroundImage)) { return false; } if (this.backgroundImageAlignment != that.backgroundImageAlignment) { return false; } if (this.backgroundImageAlpha != that.backgroundImageAlpha) { return false; } if (this.notify != that.notify) { return false; } return true; } /** * Provides serialization support. * * @param stream the output stream. * * @throws IOException if there is an I/O error. */ private void writeObject(ObjectOutputStream stream) throws IOException { stream.defaultWriteObject(); SerialUtilities.writeStroke(this.borderStroke, stream); SerialUtilities.writePaint(this.borderPaint, stream); SerialUtilities.writePaint(this.backgroundPaint, stream); } /** * Provides serialization support. * * @param stream the input stream. * * @throws IOException if there is an I/O error. * @throws ClassNotFoundException if there is a classpath problem. */ private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException { stream.defaultReadObject(); this.borderStroke = SerialUtilities.readStroke(stream); this.borderPaint = SerialUtilities.readPaint(stream); this.backgroundPaint = SerialUtilities.readPaint(stream); this.progressListeners = new EventListenerList(); this.changeListeners = new EventListenerList(); this.renderingHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); this.renderingHints.put(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE); // register as a listener with sub-components... if (this.title != null) { this.title.addChangeListener(this); } for (int i = 0; i < getSubtitleCount(); i++) { getSubtitle(i).addChangeListener(this); } this.plot.addChangeListener(this); } /** * Prints information about JFreeChart to standard output. * * @param args no arguments are honored. */ public static void main(String[] args) { System.out.println(JFreeChart.INFO.toString()); } /** * Clones the object, and takes care of listeners. * Note: caller shall register its own listeners on cloned graph. * * @return A clone. * * @throws CloneNotSupportedException if the chart is not cloneable. */ @Override public Object clone() throws CloneNotSupportedException { JFreeChart chart = (JFreeChart) super.clone(); chart.renderingHints = (RenderingHints) this.renderingHints.clone(); // private boolean borderVisible; // private transient Stroke borderStroke; // private transient Paint borderPaint; if (this.title != null) { chart.title = (TextTitle) this.title.clone(); chart.title.addChangeListener(chart); } chart.subtitles = new ArrayList(); for (int i = 0; i < getSubtitleCount(); i++) { Title subtitle = (Title) getSubtitle(i).clone(); chart.subtitles.add(subtitle); subtitle.addChangeListener(chart); } if (this.plot != null) { chart.plot = (Plot) this.plot.clone(); chart.plot.addChangeListener(chart); } chart.progressListeners = new EventListenerList(); chart.changeListeners = new EventListenerList(); return chart; } } /** * Information about the JFreeChart project. One instance of this class is * assigned to <code>JFreeChart.INFO</code>. */ class JFreeChartInfo extends ProjectInfo { /** * Default constructor. */ public JFreeChartInfo() { // get a locale-specific resource bundle... String baseResourceClass = "org.jfree.chart.resources.JFreeChartResources"; ResourceBundle resources = ResourceBundleWrapper.getBundle(baseResourceClass); setName(resources.getString("project.name")); setVersion(resources.getString("project.version")); setInfo(resources.getString("project.info")); setCopyright(resources.getString("project.copyright")); setLogo(null); // load only when required setLicenceName("LGPL"); setLicenceText(Licences.getInstance().getLGPL()); setContributors(Arrays.asList(new Contributor[] { new Contributor("Eric Alexander", "-"), new Contributor("Richard Atkinson", "richard_c_atkinson@ntlworld.com"), new Contributor("David Basten", "-"), new Contributor("David Berry", "-"), new Contributor("Chris Boek", "-"), new Contributor("Zoheb Borbora", "-"), new Contributor("Anthony Boulestreau", "-"), new Contributor("Jeremy Bowman", "-"), new Contributor("Nicolas Brodu", "-"), new Contributor("Jody Brownell", "-"), new Contributor("David Browning", "-"), new Contributor("Soren Caspersen", "-"), new Contributor("Chuanhao Chiu", "-"), new Contributor("Brian Cole", "-"), new Contributor("Pascal Collet", "-"), new Contributor("Martin Cordova", "-"), new Contributor("Paolo Cova", "-"), new Contributor("Greg Darke", "-"), new Contributor("Mike Duffy", "-"), new Contributor("Don Elliott", "-"), new Contributor("David Forslund", "-"), new Contributor("Jonathan Gabbai", "-"), new Contributor("David Gilbert", "david.gilbert@object-refinery.com"), new Contributor("Serge V. Grachov", "-"), new Contributor("Daniel Gredler", "-"), new Contributor("Hans-Jurgen Greiner", "-"), new Contributor("Joao Guilherme Del Valle", "-"), new Contributor("Aiman Han", "-"), new Contributor("Cameron Hayne", "-"), new Contributor("Martin Hoeller", "-"), new Contributor("Jon Iles", "-"), new Contributor("Wolfgang Irler", "-"), new Contributor("Sergei Ivanov", "-"), new Contributor("Adriaan Joubert", "-"), new Contributor("Darren Jung", "-"), new Contributor("Xun Kang", "-"), new Contributor("Bill Kelemen", "-"), new Contributor("Norbert Kiesel", "-"), new Contributor("Peter Kolb", "-"), new Contributor("Gideon Krause", "-"), new Contributor("Pierre-Marie Le Biot", "-"), new Contributor("Arnaud Lelievre", "-"), new Contributor("Wolfgang Lenhard", "-"), new Contributor("David Li", "-"), new Contributor("Yan Liu", "-"), new Contributor("Tin Luu", "-"), new Contributor("Craig MacFarlane", "-"), new Contributor("Achilleus Mantzios", "-"), new Contributor("Thomas Meier", "-"), new Contributor("Jim Moore", "-"), new Contributor("Jonathan Nash", "-"), new Contributor("Barak Naveh", "-"), new Contributor("David M. O'Donnell", "-"), new Contributor("Krzysztof Paz", "-"), new Contributor("Eric Penfold", "-"), new Contributor("Tomer Peretz", "-"), new Contributor("Diego Pierangeli", "-"), new Contributor("Xavier Poinsard", "-"), new Contributor("Andrzej Porebski", "-"), new Contributor("Viktor Rajewski", "-"), new Contributor("Eduardo Ramalho", "-"), new Contributor("Michael Rauch", "-"), new Contributor("Cameron Riley", "-"), new Contributor("Klaus Rheinwald", "-"), new Contributor("Dan Rivett", "d.rivett@ukonline.co.uk"), new Contributor("Scott Sams", "-"), new Contributor("Michel Santos", "-"), new Contributor("Thierry Saura", "-"), new Contributor("Andreas Schneider", "-"), new Contributor("Jean-Luc SCHWAB", "-"), new Contributor("Bryan Scott", "-"), new Contributor("Tobias Selb", "-"), new Contributor("Darshan Shah", "-"), new Contributor("Mofeed Shahin", "-"), new Contributor("Michael Siemer", "-"), new Contributor("Pady Srinivasan", "-"), new Contributor("Greg Steckman", "-"), new Contributor("Gerald Struck", "-"), new Contributor("Roger Studner", "-"), new Contributor("Irv Thomae", "-"), new Contributor("Eric Thomas", "-"), new Contributor("Rich Unger", "-"), new Contributor("Daniel van Enckevort", "-"), new Contributor("Laurence Vanhelsuwe", "-"), new Contributor("Sylvain Vieujot", "-"), new Contributor("Ulrich Voigt", "-"), new Contributor("Jelai Wang", "-"), new Contributor("Mark Watson", "www.markwatson.com"), new Contributor("Alex Weber", "-"), new Contributor("Matthew Wright", "-"), new Contributor("Benoit Xhenseval", "-"), new Contributor("Christian W. Zuckschwerdt", "Christian.Zuckschwerdt@Informatik.Uni-Oldenburg.de"), new Contributor("Hari", "-"), new Contributor("Sam (oldman)", "-"), new Contributor("Patrick Schlott", "-"), new Contributor("Christoph Schroeder", "-") })); addLibrary(JCommon.INFO); } /** * Returns the JFreeChart logo (a picture of a gorilla). * * @return The JFreeChart logo. */ @Override public Image getLogo() { Image logo = super.getLogo(); if (logo == null) { URL imageURL = this.getClass().getClassLoader().getResource("org/jfree/chart/gorilla.jpg"); if (imageURL != null) { ImageIcon temp = new ImageIcon(imageURL); // use ImageIcon because it waits for the image to load... logo = temp.getImage(); setLogo(logo); } } return logo; } }