    001/* ===========================================================
    002 * JFreeChart : a free chart library for the Java(tm) platform
    003 * ===========================================================
    004 *
    005 * (C) Copyright 2000-2011, 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 * [Oracle and Java are registered trademarks of Oracle and/or its affiliates.
    025 * Other names may be trademarks of their respective owners.]
    026 *
    027 * -----------------
    028 * ChartFactory.java
    029 * -----------------
    030 * (C) Copyright 2001-2009, by Object Refinery Limited and Contributors.
    031 *
    032 * Original Author:  David Gilbert (for Object Refinery Limited);
    033 * Contributor(s):   Serge V. Grachov;
    034 *                   Joao Guilherme Del Valle;
    035 *                   Bill Kelemen;
    036 *                   Jon Iles;
    037 *                   Jelai Wang;
    038 *                   Richard Atkinson;
    039 *                   David Browning (for Australian Institute of Marine
    040 *                       Science);
    041 *                   Benoit Xhenseval;
    042 *
    043 * Changes
    044 * -------
    045 * 19-Oct-2001 : Version 1, most methods transferred from JFreeChart.java (DG);
    046 * 22-Oct-2001 : Added methods to create stacked bar charts (DG);
    047 *               Renamed DataSource.java --> Dataset.java etc. (DG);
    048 * 31-Oct-2001 : Added 3D-effect vertical bar and stacked-bar charts,
    049 *               contributed by Serge V. Grachov (DG);
    050 * 07-Nov-2001 : Added a flag to control whether or not a legend is added to
    051 *               the chart (DG);
    052 * 17-Nov-2001 : For pie chart, changed dataset from CategoryDataset to
    053 *               PieDataset (DG);
    054 * 30-Nov-2001 : Removed try/catch handlers from chart creation, as the
    055 *               exception are now RuntimeExceptions, as suggested by Joao
    056 *               Guilherme Del Valle (DG);
    057 * 06-Dec-2001 : Added createCombinableXXXXXCharts methods (BK);
    058 * 12-Dec-2001 : Added createCandlestickChart() method (DG);
    059 * 13-Dec-2001 : Updated methods for charts with new renderers (DG);
    060 * 08-Jan-2002 : Added import for
    061 *               com.jrefinery.chart.combination.CombinedChart (DG);
    062 * 31-Jan-2002 : Changed the createCombinableVerticalXYBarChart() method to use
    063 *               renderer (DG);
    064 * 06-Feb-2002 : Added new method createWindPlot() (DG);
    065 * 23-Apr-2002 : Updates to the chart and plot constructor API (DG);
    066 * 21-May-2002 : Added new method createAreaChart() (JI);
    067 * 06-Jun-2002 : Added new method createGanttChart() (DG);
    068 * 11-Jun-2002 : Renamed createHorizontalStackedBarChart()
    069 *               --> createStackedHorizontalBarChart() for consistency (DG);
    070 * 06-Aug-2002 : Updated Javadoc comments (DG);
    071 * 21-Aug-2002 : Added createPieChart(CategoryDataset) method (DG);
    072 * 02-Oct-2002 : Fixed errors reported by Checkstyle (DG);
    073 * 09-Oct-2002 : Added methods including tooltips and URL flags (DG);
    074 * 06-Nov-2002 : Moved renderers into a separate package (DG);
    075 * 18-Nov-2002 : Changed CategoryDataset to TableDataset (DG);
    076 * 21-Mar-2003 : Incorporated HorizontalCategoryAxis3D, see bug id 685501 (DG);
    077 * 13-May-2003 : Merged some horizontal and vertical methods (DG);
    078 * 24-May-2003 : Added support for timeline in createHighLowChart (BK);
    079 * 07-Jul-2003 : Added createHistogram() method contributed by Jelai Wang (DG);
    080 * 27-Jul-2003 : Added createStackedAreaXYChart() method (RA);
    081 * 05-Aug-2003 : added new method createBoxAndWhiskerChart (DB);
    082 * 08-Sep-2003 : Changed ValueAxis API (DG);
    083 * 07-Oct-2003 : Added stepped area XY chart contributed by Matthias Rose (DG);
    084 * 06-Nov-2003 : Added createWaterfallChart() method (DG);
    085 * 20-Nov-2003 : Set rendering order for 3D bar charts to fix overlapping
    086 *               problems (DG);
    087 * 25-Nov-2003 : Added createWaferMapChart() method (DG);
    088 * 23-Dec-2003 : Renamed createPie3DChart() --> createPieChart3D for
    089 *               consistency (DG);
    090 * 20-Jan-2004 : Added createPolarChart() method (DG);
    091 * 28-Jan-2004 : Fixed bug (882890) with axis range in
    092 *               createStackedXYAreaChart() method (DG);
    093 * 25-Feb-2004 : Renamed XYToolTipGenerator --> XYItemLabelGenerator (DG);
    094 * 11-Mar-2004 : Updated for pie chart changes (DG);
    095 * 27-Apr-2004 : Added new createPieChart() method contributed by Benoit
    096 *               Xhenseval (see RFE 942195) (DG);
    097 * 11-May-2004 : Split StandardCategoryItemLabelGenerator
    098 *               --> StandardCategoryToolTipGenerator and
    099 *               StandardCategoryLabelGenerator (DG);
    100 * 06-Jan-2005 : Removed deprecated methods (DG);
    101 * 27-Jan-2005 : Added new constructor to LineAndShapeRenderer (DG);
    102 * 28-Feb-2005 : Added docs to createBubbleChart() method (DG);
    103 * 17-Mar-2005 : Added createRingPlot() method (DG);
    104 * 21-Apr-2005 : Replaced Insets with RectangleInsets (DG);
    105 * 29-Nov-2005 : Removed signal chart (DG);
    106 * ------------- JFREECHART 1.0.x ---------------------------------------------
    107 * 26-Jan-2006 : Corrected API docs for createScatterPlot() (DG);
    108 * 23-Aug-2006 : Modified createStackedXYAreaChart() to use
    109 *               StackedXYAreaRenderer2, because StackedXYAreaRenderer doesn't
    110 *               handle negative values (DG);
    111 * 27-Sep-2006 : Update createPieChart() method for deprecated code (DG);
    112 * 29-Nov-2006 : Update createXYBarChart() to use a time based tool tip
    113 *               generator is a DateAxis is requested (DG);
    114 * 17-Jan-2007 : Added createBoxAndWhiskerChart() method from patch 1603937
    115 *               submitted by Darren Jung (DG);
    116 * 10-Jul-2007 : Added new methods to create pie charts with locale for
    117 *               section label and tool tip formatting (DG);
    118 * 14-Aug-2008 : Added ChartTheme facility (DG);
    119 * 23-Oct-2008 : Check for legacy theme in setChartTheme() and reset default
    120 *               bar painters (DG);
    121 * 20-Dec-2008 : In createStackedAreaChart(), set category margin to 0.0 (DG);
    122 *
    123 */
    124
    125package org.jfree.chart;
    126
    127import java.awt.Color;
    128import java.awt.Font;
    129import java.text.DateFormat;
    130import java.text.NumberFormat;
    131import java.util.Iterator;
    132import java.util.List;
    133import java.util.Locale;
    134
    135import org.jfree.chart.axis.CategoryAxis;
    136import org.jfree.chart.axis.CategoryAxis3D;
    137import org.jfree.chart.axis.DateAxis;
    138import org.jfree.chart.axis.NumberAxis;
    139import org.jfree.chart.axis.NumberAxis3D;
    140import org.jfree.chart.axis.Timeline;
    141import org.jfree.chart.axis.ValueAxis;
    142import org.jfree.chart.labels.BoxAndWhiskerToolTipGenerator;
    143import org.jfree.chart.labels.HighLowItemLabelGenerator;
    144import org.jfree.chart.labels.IntervalCategoryToolTipGenerator;
    145import org.jfree.chart.labels.ItemLabelAnchor;
    146import org.jfree.chart.labels.ItemLabelPosition;
    147import org.jfree.chart.labels.PieToolTipGenerator;
    148import org.jfree.chart.labels.StandardCategoryToolTipGenerator;
    149import org.jfree.chart.labels.StandardPieSectionLabelGenerator;
    150import org.jfree.chart.labels.StandardPieToolTipGenerator;
    151import org.jfree.chart.labels.StandardXYToolTipGenerator;
    152import org.jfree.chart.labels.StandardXYZToolTipGenerator;
    153import org.jfree.chart.labels.XYToolTipGenerator;
    154import org.jfree.chart.plot.CategoryPlot;
    155import org.jfree.chart.plot.Marker;
    156import org.jfree.chart.plot.MultiplePiePlot;
    157import org.jfree.chart.plot.PiePlot;
    158import org.jfree.chart.plot.PiePlot3D;
    159import org.jfree.chart.plot.PlotOrientation;
    160import org.jfree.chart.plot.PolarPlot;
    161import org.jfree.chart.plot.RingPlot;
    162import org.jfree.chart.plot.ValueMarker;
    163import org.jfree.chart.plot.WaferMapPlot;
    164import org.jfree.chart.plot.XYPlot;
    165import org.jfree.chart.renderer.DefaultPolarItemRenderer;
    166import org.jfree.chart.renderer.WaferMapRenderer;
    167import org.jfree.chart.renderer.category.AreaRenderer;
    168import org.jfree.chart.renderer.category.BarRenderer;
    169import org.jfree.chart.renderer.category.BarRenderer3D;
    170import org.jfree.chart.renderer.category.BoxAndWhiskerRenderer;
    171import org.jfree.chart.renderer.category.CategoryItemRenderer;
    172import org.jfree.chart.renderer.category.GanttRenderer;
    173import org.jfree.chart.renderer.category.GradientBarPainter;
    174import org.jfree.chart.renderer.category.LineAndShapeRenderer;
    175import org.jfree.chart.renderer.category.LineRenderer3D;
    176import org.jfree.chart.renderer.category.StackedAreaRenderer;
    177import org.jfree.chart.renderer.category.StackedBarRenderer;
    178import org.jfree.chart.renderer.category.StackedBarRenderer3D;
    179import org.jfree.chart.renderer.category.StandardBarPainter;
    180import org.jfree.chart.renderer.category.WaterfallBarRenderer;
    181import org.jfree.chart.renderer.xy.CandlestickRenderer;
    182import org.jfree.chart.renderer.xy.GradientXYBarPainter;
    183import org.jfree.chart.renderer.xy.HighLowRenderer;
    184import org.jfree.chart.renderer.xy.StackedXYAreaRenderer2;
    185import org.jfree.chart.renderer.xy.StandardXYBarPainter;
    186import org.jfree.chart.renderer.xy.WindItemRenderer;
    187import org.jfree.chart.renderer.xy.XYAreaRenderer;
    188import org.jfree.chart.renderer.xy.XYBarRenderer;
    189import org.jfree.chart.renderer.xy.XYBoxAndWhiskerRenderer;
    190import org.jfree.chart.renderer.xy.XYBubbleRenderer;
    191import org.jfree.chart.renderer.xy.XYItemRenderer;
    192import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
    193import org.jfree.chart.renderer.xy.XYStepAreaRenderer;
    194import org.jfree.chart.renderer.xy.XYStepRenderer;
    195import org.jfree.chart.title.TextTitle;
    196import org.jfree.chart.urls.PieURLGenerator;
    197import org.jfree.chart.urls.StandardCategoryURLGenerator;
    198import org.jfree.chart.urls.StandardPieURLGenerator;
    199import org.jfree.chart.urls.StandardXYURLGenerator;
    200import org.jfree.chart.urls.StandardXYZURLGenerator;
    201import org.jfree.chart.urls.XYURLGenerator;
    202import org.jfree.data.category.CategoryDataset;
    203import org.jfree.data.category.IntervalCategoryDataset;
    204import org.jfree.data.general.DefaultPieDataset;
    205import org.jfree.data.general.PieDataset;
    206import org.jfree.data.general.WaferMapDataset;
    207import org.jfree.data.statistics.BoxAndWhiskerCategoryDataset;
    208import org.jfree.data.statistics.BoxAndWhiskerXYDataset;
    209import org.jfree.data.xy.IntervalXYDataset;
    210import org.jfree.data.xy.OHLCDataset;
    211import org.jfree.data.xy.TableXYDataset;
    212import org.jfree.data.xy.WindDataset;
    213import org.jfree.data.xy.XYDataset;
    214import org.jfree.data.xy.XYZDataset;
    215import org.jfree.ui.Layer;
    216import org.jfree.ui.RectangleEdge;
    217import org.jfree.ui.RectangleInsets;
    218import org.jfree.ui.TextAnchor;
    219import org.jfree.util.SortOrder;
    220import org.jfree.util.TableOrder;
    221
    222/**
    223 * A collection of utility methods for creating some standard charts with
    224 * JFreeChart.
    225 */
    226public abstract class ChartFactory {
    227
    228    /** The chart theme. */
    229    private static ChartTheme currentTheme = new StandardChartTheme("JFree");
    230
    231    /**
    232     * Returns the current chart theme used by the factory.
    233     *
    234     * @return The chart theme.
    235     *
    236     * @see #setChartTheme(ChartTheme)
    237     * @see ChartUtilities#applyCurrentTheme(JFreeChart)
    238     *
    239     * @since 1.0.11
    240     */
    241    public static ChartTheme getChartTheme() {
    242        return currentTheme;
    243    }
    244
    245    /**
    246     * Sets the current chart theme.  This will be applied to all new charts
    247     * created via methods in this class.
    248     *
    249     * @param theme  the theme (<code>null</code> not permitted).
    250     *
    251     * @see #getChartTheme()
    252     * @see ChartUtilities#applyCurrentTheme(JFreeChart)
    253     *
    254     * @since 1.0.11
    255     */
    256    public static void setChartTheme(ChartTheme theme) {
    257        if (theme == null) {
    258            throw new IllegalArgumentException("Null 'theme' argument.");
    259        }
    260        currentTheme = theme;
    261
    262        // here we do a check to see if the user is installing the "Legacy"
    263        // theme, and reset the bar painters in that case...
    264        if (theme instanceof StandardChartTheme) {
    265            StandardChartTheme sct = (StandardChartTheme) theme;
    266            if (sct.getName().equals("Legacy")) {
    267                BarRenderer.setDefaultBarPainter(new StandardBarPainter());
    268                XYBarRenderer.setDefaultBarPainter(new StandardXYBarPainter());
    269            }
    270            else {
    271                BarRenderer.setDefaultBarPainter(new GradientBarPainter());
    272                XYBarRenderer.setDefaultBarPainter(new GradientXYBarPainter());
    273            }
    274        }
    275    }
    276
    277    /**
    278     * Creates a pie chart with default settings.
    279     * <P>
    280     * The chart object returned by this method uses a {@link PiePlot} instance
    281     * as the plot.
    282     *
    283     * @param title  the chart title (<code>null</code> permitted).
    284     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    285     * @param legend  a flag specifying whether or not a legend is required.
    286     * @param tooltips  configure chart to generate tool tips?
    287     * @param locale  the locale (<code>null</code> not permitted).
    288     *
    289     * @return A pie chart.
    290     *
    291     * @since 1.0.7
    292     */
    293    public static JFreeChart createPieChart(String title, PieDataset dataset,
    294            boolean legend, boolean tooltips, Locale locale) {
    295
    296        PiePlot plot = new PiePlot(dataset);
    297        plot.setLabelGenerator(new StandardPieSectionLabelGenerator(locale));
    298        plot.setInsets(new RectangleInsets(0.0, 5.0, 5.0, 5.0));
    299        if (tooltips) {
    300            plot.setToolTipGenerator(new StandardPieToolTipGenerator(locale));
    301        }
    302        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    303                plot, legend);
    304        currentTheme.apply(chart);
    305        return chart;
    306
    307    }
    308
    309    /**
    310     * Creates a pie chart with default settings.
    311     * <P>
    312     * The chart object returned by this method uses a {@link PiePlot} instance
    313     * as the plot.
    314     *
    315     * @param title  the chart title (<code>null</code> permitted).
    316     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    317     * @param legend  a flag specifying whether or not a legend is required.
    318     * @param tooltips  configure chart to generate tool tips?
    319     * @param urls  configure chart to generate URLs?
    320     *
    321     * @return A pie chart.
    322     */
    323    public static JFreeChart createPieChart(String title,
    324                                            PieDataset dataset,
    325                                            boolean legend,
    326                                            boolean tooltips,
    327                                            boolean urls) {
    328
    329        PiePlot plot = new PiePlot(dataset);
    330        plot.setLabelGenerator(new StandardPieSectionLabelGenerator());
    331        plot.setInsets(new RectangleInsets(0.0, 5.0, 5.0, 5.0));
    332        if (tooltips) {
    333            plot.setToolTipGenerator(new StandardPieToolTipGenerator());
    334        }
    335        if (urls) {
    336            plot.setURLGenerator(new StandardPieURLGenerator());
    337        }
    338        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    339                plot, legend);
    340        currentTheme.apply(chart);
    341        return chart;
    342    }
    343
    344    /**
    345     * Creates a pie chart with default settings that compares 2 datasets.
    346     * The colour of each section will be determined by the move from the value
    347     * for the same key in <code>previousDataset</code>. ie if value1 > value2
    348     * then the section will be in green (unless <code>greenForIncrease</code>
    349     * is <code>false</code>, in which case it would be <code>red</code>).
    350     * Each section can have a shade of red or green as the difference can be
    351     * tailored between 0% (black) and percentDiffForMaxScale% (bright
    352     * red/green).
    353     * <p>
    354     * For instance if <code>percentDiffForMaxScale</code> is 10 (10%), a
    355     * difference of 5% will have a half shade of red/green, a difference of
    356     * 10% or more will have a maximum shade/brightness of red/green.
    357     * <P>
    358     * The chart object returned by this method uses a {@link PiePlot} instance
    359     * as the plot.
    360     * <p>
    361     * Written by <a href="mailto:opensource@objectlab.co.uk">Benoit
    362     * Xhenseval</a>.
    363     *
    364     * @param title  the chart title (<code>null</code> permitted).
    365     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    366     * @param previousDataset  the dataset for the last run, this will be used
    367     *                         to compare each key in the dataset
    368     * @param percentDiffForMaxScale scale goes from bright red/green to black,
    369     *                               percentDiffForMaxScale indicate the change
    370     *                               required to reach top scale.
    371     * @param greenForIncrease  an increase since previousDataset will be
    372     *                          displayed in green (decrease red) if true.
    373     * @param legend  a flag specifying whether or not a legend is required.
    374     * @param tooltips  configure chart to generate tool tips?
    375     * @param locale  the locale (<code>null</code> not permitted).
    376     * @param subTitle displays a subtitle with colour scheme if true
    377     * @param showDifference  create a new dataset that will show the %
    378     *                        difference between the two datasets.
    379     *
    380     * @return A pie chart.
    381     *
    382     * @since 1.0.7
    383     */
    384    public static JFreeChart createPieChart(String title, PieDataset dataset,
    385            PieDataset previousDataset, int percentDiffForMaxScale,
    386            boolean greenForIncrease, boolean legend, boolean tooltips,
    387            Locale locale, boolean subTitle, boolean showDifference) {
    388
    389        PiePlot plot = new PiePlot(dataset);
    390        plot.setLabelGenerator(new StandardPieSectionLabelGenerator(locale));
    391        plot.setInsets(new RectangleInsets(0.0, 5.0, 5.0, 5.0));
    392
    393        if (tooltips) {
    394            plot.setToolTipGenerator(new StandardPieToolTipGenerator(locale));
    395        }
    396
    397        List keys = dataset.getKeys();
    398        DefaultPieDataset series = null;
    399        if (showDifference) {
    400            series = new DefaultPieDataset();
    401        }
    402
    403        double colorPerPercent = 255.0 / percentDiffForMaxScale;
    404        for (Iterator it = keys.iterator(); it.hasNext();) {
    405            Comparable key = (Comparable) it.next();
    406            Number newValue = dataset.getValue(key);
    407            Number oldValue = previousDataset.getValue(key);
    408
    409            if (oldValue == null) {
    410                if (greenForIncrease) {
    411                    plot.setSectionPaint(key, Color.green);
    412                }
    413                else {
    414                    plot.setSectionPaint(key, Color.red);
    415                }
    416                if (showDifference) {
    417                    series.setValue(key + " (+100%)", newValue);
    418                }
    419            }
    420            else {
    421                double percentChange = (newValue.doubleValue()
    422                        / oldValue.doubleValue() - 1.0) * 100.0;
    423                double shade
    424                    = (Math.abs(percentChange) >= percentDiffForMaxScale ? 255
    425                    : Math.abs(percentChange) * colorPerPercent);
    426                if (greenForIncrease
    427                        && newValue.doubleValue() > oldValue.doubleValue()
    428                        || !greenForIncrease && newValue.doubleValue()
    429                        < oldValue.doubleValue()) {
    430                    plot.setSectionPaint(key, new Color(0, (int) shade, 0));
    431                }
    432                else {
    433                    plot.setSectionPaint(key, new Color((int) shade, 0, 0));
    434                }
    435                if (showDifference) {
    436                    series.setValue(key + " (" + (percentChange >= 0 ? "+" : "")
    437                            + NumberFormat.getPercentInstance().format(
    438                            percentChange / 100.0) + ")", newValue);
    439                }
    440            }
    441        }
    442
    443        if (showDifference) {
    444            plot.setDataset(series);
    445        }
    446
    447        JFreeChart chart =  new JFreeChart(title,
    448                JFreeChart.DEFAULT_TITLE_FONT, plot, legend);
    449
    450        if (subTitle) {
    451            TextTitle subtitle = null;
    452            subtitle = new TextTitle("Bright " + (greenForIncrease ? "red"
    453                    : "green") + "=change >=-" + percentDiffForMaxScale
    454                    + "%, Bright " + (!greenForIncrease ? "red" : "green")
    455                    + "=change >=+" + percentDiffForMaxScale + "%",
    456                    new Font("SansSerif", Font.PLAIN, 10));
    457            chart.addSubtitle(subtitle);
    458        }
    459        currentTheme.apply(chart);
    460        return chart;
    461    }
    462
    463    /**
    464     * Creates a pie chart with default settings that compares 2 datasets.
    465     * The colour of each section will be determined by the move from the value
    466     * for the same key in <code>previousDataset</code>. ie if value1 > value2
    467     * then the section will be in green (unless <code>greenForIncrease</code>
    468     * is <code>false</code>, in which case it would be <code>red</code>).
    469     * Each section can have a shade of red or green as the difference can be
    470     * tailored between 0% (black) and percentDiffForMaxScale% (bright
    471     * red/green).
    472     * <p>
    473     * For instance if <code>percentDiffForMaxScale</code> is 10 (10%), a
    474     * difference of 5% will have a half shade of red/green, a difference of
    475     * 10% or more will have a maximum shade/brightness of red/green.
    476     * <P>
    477     * The chart object returned by this method uses a {@link PiePlot} instance
    478     * as the plot.
    479     * <p>
    480     * Written by <a href="mailto:opensource@objectlab.co.uk">Benoit
    481     * Xhenseval</a>.
    482     *
    483     * @param title  the chart title (<code>null</code> permitted).
    484     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    485     * @param previousDataset  the dataset for the last run, this will be used
    486     *                         to compare each key in the dataset
    487     * @param percentDiffForMaxScale scale goes from bright red/green to black,
    488     *                               percentDiffForMaxScale indicate the change
    489     *                               required to reach top scale.
    490     * @param greenForIncrease  an increase since previousDataset will be
    491     *                          displayed in green (decrease red) if true.
    492     * @param legend  a flag specifying whether or not a legend is required.
    493     * @param tooltips  configure chart to generate tool tips?
    494     * @param urls  configure chart to generate URLs?
    495     * @param subTitle displays a subtitle with colour scheme if true
    496     * @param showDifference  create a new dataset that will show the %
    497     *                        difference between the two datasets.
    498     *
    499     * @return A pie chart.
    500     */
    501    public static JFreeChart createPieChart(String title,
    502                                            PieDataset dataset,
    503                                            PieDataset previousDataset,
    504                                            int percentDiffForMaxScale,
    505                                            boolean greenForIncrease,
    506                                            boolean legend,
    507                                            boolean tooltips,
    508                                            boolean urls,
    509                                            boolean subTitle,
    510                                            boolean showDifference) {
    511
    512        PiePlot plot = new PiePlot(dataset);
    513        plot.setLabelGenerator(new StandardPieSectionLabelGenerator());
    514        plot.setInsets(new RectangleInsets(0.0, 5.0, 5.0, 5.0));
    515
    516        if (tooltips) {
    517            plot.setToolTipGenerator(new StandardPieToolTipGenerator());
    518        }
    519        if (urls) {
    520            plot.setURLGenerator(new StandardPieURLGenerator());
    521        }
    522
    523        List keys = dataset.getKeys();
    524        DefaultPieDataset series = null;
    525        if (showDifference) {
    526            series = new DefaultPieDataset();
    527        }
    528
    529        double colorPerPercent = 255.0 / percentDiffForMaxScale;
    530        for (Iterator it = keys.iterator(); it.hasNext();) {
    531            Comparable key = (Comparable) it.next();
    532            Number newValue = dataset.getValue(key);
    533            Number oldValue = previousDataset.getValue(key);
    534
    535            if (oldValue == null) {
    536                if (greenForIncrease) {
    537                    plot.setSectionPaint(key, Color.green);
    538                }
    539                else {
    540                    plot.setSectionPaint(key, Color.red);
    541                }
    542                if (showDifference) {
    543                    series.setValue(key + " (+100%)", newValue);
    544                }
    545            }
    546            else {
    547                double percentChange = (newValue.doubleValue()
    548                        / oldValue.doubleValue() - 1.0) * 100.0;
    549                double shade
    550                    = (Math.abs(percentChange) >= percentDiffForMaxScale ? 255
    551                    : Math.abs(percentChange) * colorPerPercent);
    552                if (greenForIncrease
    553                        && newValue.doubleValue() > oldValue.doubleValue()
    554                        || !greenForIncrease && newValue.doubleValue()
    555                        < oldValue.doubleValue()) {
    556                    plot.setSectionPaint(key, new Color(0, (int) shade, 0));
    557                }
    558                else {
    559                    plot.setSectionPaint(key, new Color((int) shade, 0, 0));
    560                }
    561                if (showDifference) {
    562                    series.setValue(key + " (" + (percentChange >= 0 ? "+" : "")
    563                            + NumberFormat.getPercentInstance().format(
    564                            percentChange / 100.0) + ")", newValue);
    565                }
    566            }
    567        }
    568
    569        if (showDifference) {
    570            plot.setDataset(series);
    571        }
    572
    573        JFreeChart chart =  new JFreeChart(title,
    574                JFreeChart.DEFAULT_TITLE_FONT, plot, legend);
    575
    576        if (subTitle) {
    577            TextTitle subtitle = null;
    578            subtitle = new TextTitle("Bright " + (greenForIncrease ? "red"
    579                    : "green") + "=change >=-" + percentDiffForMaxScale
    580                    + "%, Bright " + (!greenForIncrease ? "red" : "green")
    581                    + "=change >=+" + percentDiffForMaxScale + "%",
    582                    new Font("SansSerif", Font.PLAIN, 10));
    583            chart.addSubtitle(subtitle);
    584        }
    585        currentTheme.apply(chart);
    586        return chart;
    587    }
    588
    589    /**
    590     * Creates a ring chart with default settings.
    591     * <P>
    592     * The chart object returned by this method uses a {@link RingPlot}
    593     * instance as the plot.
    594     *
    595     * @param title  the chart title (<code>null</code> permitted).
    596     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    597     * @param legend  a flag specifying whether or not a legend is required.
    598     * @param tooltips  configure chart to generate tool tips?
    599     * @param locale  the locale (<code>null</code> not permitted).
    600     *
    601     * @return A ring chart.
    602     *
    603     * @since 1.0.7
    604     */
    605    public static JFreeChart createRingChart(String title, PieDataset dataset,
    606            boolean legend, boolean tooltips, Locale locale) {
    607
    608        RingPlot plot = new RingPlot(dataset);
    609        plot.setLabelGenerator(new StandardPieSectionLabelGenerator(locale));
    610        plot.setInsets(new RectangleInsets(0.0, 5.0, 5.0, 5.0));
    611        if (tooltips) {
    612            plot.setToolTipGenerator(new StandardPieToolTipGenerator(locale));
    613        }
    614        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    615                plot, legend);
    616        currentTheme.apply(chart);
    617        return chart;
    618    }
    619
    620    /**
    621     * Creates a ring chart with default settings.
    622     * <P>
    623     * The chart object returned by this method uses a {@link RingPlot}
    624     * instance as the plot.
    625     *
    626     * @param title  the chart title (<code>null</code> permitted).
    627     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    628     * @param legend  a flag specifying whether or not a legend is required.
    629     * @param tooltips  configure chart to generate tool tips?
    630     * @param urls  configure chart to generate URLs?
    631     *
    632     * @return A ring chart.
    633     */
    634    public static JFreeChart createRingChart(String title,
    635                                             PieDataset dataset,
    636                                             boolean legend,
    637                                             boolean tooltips,
    638                                             boolean urls) {
    639
    640        RingPlot plot = new RingPlot(dataset);
    641        plot.setLabelGenerator(new StandardPieSectionLabelGenerator());
    642        plot.setInsets(new RectangleInsets(0.0, 5.0, 5.0, 5.0));
    643        if (tooltips) {
    644            plot.setToolTipGenerator(new StandardPieToolTipGenerator());
    645        }
    646        if (urls) {
    647            plot.setURLGenerator(new StandardPieURLGenerator());
    648        }
    649        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    650                plot, legend);
    651        currentTheme.apply(chart);
    652        return chart;
    653
    654    }
    655
    656    /**
    657     * Creates a chart that displays multiple pie plots.  The chart object
    658     * returned by this method uses a {@link MultiplePiePlot} instance as the
    659     * plot.
    660     *
    661     * @param title  the chart title (<code>null</code> permitted).
    662     * @param dataset  the dataset (<code>null</code> permitted).
    663     * @param order  the order that the data is extracted (by row or by column)
    664     *               (<code>null</code> not permitted).
    665     * @param legend  include a legend?
    666     * @param tooltips  generate tooltips?
    667     * @param urls  generate URLs?
    668     *
    669     * @return A chart.
    670     */
    671    public static JFreeChart createMultiplePieChart(String title,
    672                                                    CategoryDataset dataset,
    673                                                    TableOrder order,
    674                                                    boolean legend,
    675                                                    boolean tooltips,
    676                                                    boolean urls) {
    677
    678        if (order == null) {
    679            throw new IllegalArgumentException("Null 'order' argument.");
    680        }
    681        MultiplePiePlot plot = new MultiplePiePlot(dataset);
    682        plot.setDataExtractOrder(order);
    683        plot.setBackgroundPaint(null);
    684        plot.setOutlineStroke(null);
    685
    686        if (tooltips) {
    687            PieToolTipGenerator tooltipGenerator
    688                = new StandardPieToolTipGenerator();
    689            PiePlot pp = (PiePlot) plot.getPieChart().getPlot();
    690            pp.setToolTipGenerator(tooltipGenerator);
    691        }
    692
    693        if (urls) {
    694            PieURLGenerator urlGenerator = new StandardPieURLGenerator();
    695            PiePlot pp = (PiePlot) plot.getPieChart().getPlot();
    696            pp.setURLGenerator(urlGenerator);
    697        }
    698
    699        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    700                plot, legend);
    701        currentTheme.apply(chart);
    702        return chart;
    703
    704    }
    705
    706    /**
    707     * Creates a 3D pie chart using the specified dataset.  The chart object
    708     * returned by this method uses a {@link PiePlot3D} instance as the
    709     * plot.
    710     *
    711     * @param title  the chart title (<code>null</code> permitted).
    712     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    713     * @param legend  a flag specifying whether or not a legend is required.
    714     * @param tooltips  configure chart to generate tool tips?
    715     * @param locale  the locale (<code>null</code> not permitted).
    716     *
    717     * @return A pie chart.
    718     *
    719     * @since 1.0.7
    720     */
    721    public static JFreeChart createPieChart3D(String title, PieDataset dataset,
    722            boolean legend, boolean tooltips, Locale locale) {
    723
    724        PiePlot3D plot = new PiePlot3D(dataset);
    725        plot.setInsets(new RectangleInsets(0.0, 5.0, 5.0, 5.0));
    726        if (tooltips) {
    727            plot.setToolTipGenerator(new StandardPieToolTipGenerator(locale));
    728        }
    729        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    730                plot, legend);
    731        currentTheme.apply(chart);
    732        return chart;
    733
    734    }
    735
    736    /**
    737     * Creates a 3D pie chart using the specified dataset.  The chart object
    738     * returned by this method uses a {@link PiePlot3D} instance as the
    739     * plot.
    740     *
    741     * @param title  the chart title (<code>null</code> permitted).
    742     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    743     * @param legend  a flag specifying whether or not a legend is required.
    744     * @param tooltips  configure chart to generate tool tips?
    745     * @param urls  configure chart to generate URLs?
    746     *
    747     * @return A pie chart.
    748     */
    749    public static JFreeChart createPieChart3D(String title,
    750                                              PieDataset dataset,
    751                                              boolean legend,
    752                                              boolean tooltips,
    753                                              boolean urls) {
    754
    755        PiePlot3D plot = new PiePlot3D(dataset);
    756        plot.setInsets(new RectangleInsets(0.0, 5.0, 5.0, 5.0));
    757        if (tooltips) {
    758            plot.setToolTipGenerator(new StandardPieToolTipGenerator());
    759        }
    760        if (urls) {
    761            plot.setURLGenerator(new StandardPieURLGenerator());
    762        }
    763        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    764                plot, legend);
    765        currentTheme.apply(chart);
    766        return chart;
    767
    768    }
    769
    770    /**
    771     * Creates a chart that displays multiple pie plots.  The chart object
    772     * returned by this method uses a {@link MultiplePiePlot} instance as the
    773     * plot.
    774     *
    775     * @param title  the chart title (<code>null</code> permitted).
    776     * @param dataset  the dataset (<code>null</code> permitted).
    777     * @param order  the order that the data is extracted (by row or by column)
    778     *               (<code>null</code> not permitted).
    779     * @param legend  include a legend?
    780     * @param tooltips  generate tooltips?
    781     * @param urls  generate URLs?
    782     *
    783     * @return A chart.
    784     */
    785    public static JFreeChart createMultiplePieChart3D(String title,
    786                                                      CategoryDataset dataset,
    787                                                      TableOrder order,
    788                                                      boolean legend,
    789                                                      boolean tooltips,
    790                                                      boolean urls) {
    791
    792        if (order == null) {
    793            throw new IllegalArgumentException("Null 'order' argument.");
    794        }
    795        MultiplePiePlot plot = new MultiplePiePlot(dataset);
    796        plot.setDataExtractOrder(order);
    797        plot.setBackgroundPaint(null);
    798        plot.setOutlineStroke(null);
    799
    800        JFreeChart pieChart = new JFreeChart(new PiePlot3D(null));
    801        TextTitle seriesTitle = new TextTitle("Series Title",
    802                new Font("SansSerif", Font.BOLD, 12));
    803        seriesTitle.setPosition(RectangleEdge.BOTTOM);
    804        pieChart.setTitle(seriesTitle);
    805        pieChart.removeLegend();
    806        pieChart.setBackgroundPaint(null);
    807        plot.setPieChart(pieChart);
    808
    809        if (tooltips) {
    810            PieToolTipGenerator tooltipGenerator
    811                = new StandardPieToolTipGenerator();
    812            PiePlot pp = (PiePlot) plot.getPieChart().getPlot();
    813            pp.setToolTipGenerator(tooltipGenerator);
    814        }
    815
    816        if (urls) {
    817            PieURLGenerator urlGenerator = new StandardPieURLGenerator();
    818            PiePlot pp = (PiePlot) plot.getPieChart().getPlot();
    819            pp.setURLGenerator(urlGenerator);
    820        }
    821
    822        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    823                plot, legend);
    824        currentTheme.apply(chart);
    825        return chart;
    826
    827    }
    828
    829    /**
    830     * Creates a bar chart.  The chart object returned by this method uses a
    831     * {@link CategoryPlot} instance as the plot, with a {@link CategoryAxis}
    832     * for the domain axis, a {@link NumberAxis} as the range axis, and a
    833     * {@link BarRenderer} as the renderer.
    834     *
    835     * @param title  the chart title (<code>null</code> permitted).
    836     * @param categoryAxisLabel  the label for the category axis
    837     *                           (<code>null</code> permitted).
    838     * @param valueAxisLabel  the label for the value axis
    839     *                        (<code>null</code> permitted).
    840     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    841     * @param orientation  the plot orientation (horizontal or vertical)
    842     *                     (<code>null</code> not permitted).
    843     * @param legend  a flag specifying whether or not a legend is required.
    844     * @param tooltips  configure chart to generate tool tips?
    845     * @param urls  configure chart to generate URLs?
    846     *
    847     * @return A bar chart.
    848     */
    849    public static JFreeChart createBarChart(String title,
    850                                            String categoryAxisLabel,
    851                                            String valueAxisLabel,
    852                                            CategoryDataset dataset,
    853                                            PlotOrientation orientation,
    854                                            boolean legend,
    855                                            boolean tooltips,
    856                                            boolean urls) {
    857
    858        if (orientation == null) {
    859            throw new IllegalArgumentException("Null 'orientation' argument.");
    860        }
    861        CategoryAxis categoryAxis = new CategoryAxis(categoryAxisLabel);
    862        ValueAxis valueAxis = new NumberAxis(valueAxisLabel);
    863
    864        BarRenderer renderer = new BarRenderer();
    865        if (orientation == PlotOrientation.HORIZONTAL) {
    866            ItemLabelPosition position1 = new ItemLabelPosition(
    867                    ItemLabelAnchor.OUTSIDE3, TextAnchor.CENTER_LEFT);
    868            renderer.setBasePositiveItemLabelPosition(position1);
    869            ItemLabelPosition position2 = new ItemLabelPosition(
    870                    ItemLabelAnchor.OUTSIDE9, TextAnchor.CENTER_RIGHT);
    871            renderer.setBaseNegativeItemLabelPosition(position2);
    872         }
    873        else if (orientation == PlotOrientation.VERTICAL) {
    874            ItemLabelPosition position1 = new ItemLabelPosition(
    875                    ItemLabelAnchor.OUTSIDE12, TextAnchor.BOTTOM_CENTER);
    876            renderer.setBasePositiveItemLabelPosition(position1);
    877            ItemLabelPosition position2 = new ItemLabelPosition(
    878                    ItemLabelAnchor.OUTSIDE6, TextAnchor.TOP_CENTER);
    879            renderer.setBaseNegativeItemLabelPosition(position2);
    880        }
    881        if (tooltips) {
    882            renderer.setBaseToolTipGenerator(
    883                    new StandardCategoryToolTipGenerator());
    884        }
    885        if (urls) {
    886            renderer.setBaseItemURLGenerator(
    887                    new StandardCategoryURLGenerator());
    888        }
    889
    890        CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, valueAxis,
    891                renderer);
    892        plot.setOrientation(orientation);
    893        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    894                plot, legend);
    895        currentTheme.apply(chart);
    896        return chart;
    897
    898    }
    899
    900    /**
    901     * Creates a stacked bar chart with default settings.  The chart object
    902     * returned by this method uses a {@link CategoryPlot} instance as the
    903     * plot, with a {@link CategoryAxis} for the domain axis, a
    904     * {@link NumberAxis} as the range axis, and a {@link StackedBarRenderer}
    905     * as the renderer.
    906     *
    907     * @param title  the chart title (<code>null</code> permitted).
    908     * @param domainAxisLabel  the label for the category axis
    909     *                         (<code>null</code> permitted).
    910     * @param rangeAxisLabel  the label for the value axis
    911     *                        (<code>null</code> permitted).
    912     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    913     * @param orientation  the orientation of the chart (horizontal or
    914     *                     vertical) (<code>null</code> not permitted).
    915     * @param legend  a flag specifying whether or not a legend is required.
    916     * @param tooltips  configure chart to generate tool tips?
    917     * @param urls  configure chart to generate URLs?
    918     *
    919     * @return A stacked bar chart.
    920     */
    921    public static JFreeChart createStackedBarChart(String title,
    922                                                   String domainAxisLabel,
    923                                                   String rangeAxisLabel,
    924                                                   CategoryDataset dataset,
    925                                                   PlotOrientation orientation,
    926                                                   boolean legend,
    927                                                   boolean tooltips,
    928                                                   boolean urls) {
    929
    930        if (orientation == null) {
    931            throw new IllegalArgumentException("Null 'orientation' argument.");
    932        }
    933
    934        CategoryAxis categoryAxis = new CategoryAxis(domainAxisLabel);
    935        ValueAxis valueAxis = new NumberAxis(rangeAxisLabel);
    936
    937        StackedBarRenderer renderer = new StackedBarRenderer();
    938        if (tooltips) {
    939            renderer.setBaseToolTipGenerator(
    940                    new StandardCategoryToolTipGenerator());
    941        }
    942        if (urls) {
    943            renderer.setBaseItemURLGenerator(
    944                    new StandardCategoryURLGenerator());
    945        }
    946
    947        CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, valueAxis,
    948                renderer);
    949        plot.setOrientation(orientation);
    950        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    951                plot, legend);
    952        currentTheme.apply(chart);
    953        return chart;
    954
    955    }
    956
    957    /**
    958     * Creates a bar chart with a 3D effect. The chart object returned by this
    959     * method uses a {@link CategoryPlot} instance as the plot, with a
    960     * {@link CategoryAxis3D} for the domain axis, a {@link NumberAxis3D} as
    961     * the range axis, and a {@link BarRenderer3D} as the renderer.
    962     *
    963     * @param title  the chart title (<code>null</code> permitted).
    964     * @param categoryAxisLabel  the label for the category axis
    965     *                           (<code>null</code> permitted).
    966     * @param valueAxisLabel  the label for the value axis (<code>null</code>
    967     *                        permitted).
    968     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    969     * @param orientation  the plot orientation (horizontal or vertical)
    970     *                     (<code>null</code> not permitted).
    971     * @param legend  a flag specifying whether or not a legend is required.
    972     * @param tooltips  configure chart to generate tool tips?
    973     * @param urls  configure chart to generate URLs?
    974     *
    975     * @return A bar chart with a 3D effect.
    976     */
    977    public static JFreeChart createBarChart3D(String title,
    978                                              String categoryAxisLabel,
    979                                              String valueAxisLabel,
    980                                              CategoryDataset dataset,
    981                                              PlotOrientation orientation,
    982                                              boolean legend,
    983                                              boolean tooltips,
    984                                              boolean urls) {
    985
    986        if (orientation == null) {
    987            throw new IllegalArgumentException("Null 'orientation' argument.");
    988        }
    989        CategoryAxis categoryAxis = new CategoryAxis3D(categoryAxisLabel);
    990        ValueAxis valueAxis = new NumberAxis3D(valueAxisLabel);
    991
    992        BarRenderer3D renderer = new BarRenderer3D();
    993        if (tooltips) {
    994            renderer.setBaseToolTipGenerator(
    995                    new StandardCategoryToolTipGenerator());
    996        }
    997        if (urls) {
    998            renderer.setBaseItemURLGenerator(
    999                    new StandardCategoryURLGenerator());
    1000        }
    1001
    1002        CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, valueAxis,
    1003                renderer);
    1004        plot.setOrientation(orientation);
    1005        if (orientation == PlotOrientation.HORIZONTAL) {
    1006            // change rendering order to ensure that bar overlapping is the
    1007            // right way around
    1008            plot.setRowRenderingOrder(SortOrder.DESCENDING);
    1009            plot.setColumnRenderingOrder(SortOrder.DESCENDING);
    1010        }
    1011        plot.setForegroundAlpha(0.75f);
    1012
    1013        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1014                plot, legend);
    1015        currentTheme.apply(chart);
    1016        return chart;
    1017
    1018    }
    1019
    1020    /**
    1021     * Creates a stacked bar chart with a 3D effect and default settings. The
    1022     * chart object returned by this method uses a {@link CategoryPlot}
    1023     * instance as the plot, with a {@link CategoryAxis3D} for the domain axis,
    1024     * a {@link NumberAxis3D} as the range axis, and a
    1025     * {@link StackedBarRenderer3D} as the renderer.
    1026     *
    1027     * @param title  the chart title (<code>null</code> permitted).
    1028     * @param categoryAxisLabel  the label for the category axis
    1029     *                           (<code>null</code> permitted).
    1030     * @param valueAxisLabel  the label for the value axis (<code>null</code>
    1031     *                        permitted).
    1032     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1033     * @param orientation  the orientation (horizontal or vertical)
    1034     *                     (<code>null</code> not permitted).
    1035     * @param legend  a flag specifying whether or not a legend is required.
    1036     * @param tooltips  configure chart to generate tool tips?
    1037     * @param urls  configure chart to generate URLs?
    1038     *
    1039     * @return A stacked bar chart with a 3D effect.
    1040     */
    1041    public static JFreeChart createStackedBarChart3D(String title,
    1042                                                    String categoryAxisLabel,
    1043                                                    String valueAxisLabel,
    1044                                                    CategoryDataset dataset,
    1045                                                    PlotOrientation orientation,
    1046                                                    boolean legend,
    1047                                                    boolean tooltips,
    1048                                                    boolean urls) {
    1049
    1050        if (orientation == null) {
    1051            throw new IllegalArgumentException("Null 'orientation' argument.");
    1052        }
    1053        CategoryAxis categoryAxis = new CategoryAxis3D(categoryAxisLabel);
    1054        ValueAxis valueAxis = new NumberAxis3D(valueAxisLabel);
    1055
    1056        // create the renderer...
    1057        CategoryItemRenderer renderer = new StackedBarRenderer3D();
    1058        if (tooltips) {
    1059            renderer.setBaseToolTipGenerator(
    1060                    new StandardCategoryToolTipGenerator());
    1061        }
    1062        if (urls) {
    1063            renderer.setBaseItemURLGenerator(
    1064                    new StandardCategoryURLGenerator());
    1065        }
    1066
    1067        // create the plot...
    1068        CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, valueAxis,
    1069                renderer);
    1070        plot.setOrientation(orientation);
    1071        if (orientation == PlotOrientation.HORIZONTAL) {
    1072            // change rendering order to ensure that bar overlapping is the
    1073            // right way around
    1074            plot.setColumnRenderingOrder(SortOrder.DESCENDING);
    1075        }
    1076
    1077        // create the chart...
    1078        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1079                plot, legend);
    1080        currentTheme.apply(chart);
    1081        return chart;
    1082
    1083    }
    1084
    1085    /**
    1086     * Creates an area chart with default settings.  The chart object returned
    1087     * by this method uses a {@link CategoryPlot} instance as the plot, with a
    1088     * {@link CategoryAxis} for the domain axis, a {@link NumberAxis} as the
    1089     * range axis, and an {@link AreaRenderer} as the renderer.
    1090     *
    1091     * @param title  the chart title (<code>null</code> permitted).
    1092     * @param categoryAxisLabel  the label for the category axis
    1093     *                           (<code>null</code> permitted).
    1094     * @param valueAxisLabel  the label for the value axis (<code>null</code>
    1095     *                        permitted).
    1096     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1097     * @param orientation  the plot orientation (<code>null</code> not
    1098     *                     permitted).
    1099     * @param legend  a flag specifying whether or not a legend is required.
    1100     * @param tooltips  configure chart to generate tool tips?
    1101     * @param urls  configure chart to generate URLs?
    1102     *
    1103     * @return An area chart.
    1104     */
    1105    public static JFreeChart createAreaChart(String title,
    1106                                             String categoryAxisLabel,
    1107                                             String valueAxisLabel,
    1108                                             CategoryDataset dataset,
    1109                                             PlotOrientation orientation,
    1110                                             boolean legend,
    1111                                             boolean tooltips,
    1112                                             boolean urls) {
    1113
    1114        if (orientation == null) {
    1115            throw new IllegalArgumentException("Null 'orientation' argument.");
    1116        }
    1117        CategoryAxis categoryAxis = new CategoryAxis(categoryAxisLabel);
    1118        categoryAxis.setCategoryMargin(0.0);
    1119
    1120        ValueAxis valueAxis = new NumberAxis(valueAxisLabel);
    1121
    1122        AreaRenderer renderer = new AreaRenderer();
    1123        if (tooltips) {
    1124            renderer.setBaseToolTipGenerator(
    1125                    new StandardCategoryToolTipGenerator());
    1126        }
    1127        if (urls) {
    1128            renderer.setBaseItemURLGenerator(
    1129                    new StandardCategoryURLGenerator());
    1130        }
    1131
    1132        CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, valueAxis,
    1133                renderer);
    1134        plot.setOrientation(orientation);
    1135        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1136                plot, legend);
    1137        currentTheme.apply(chart);
    1138        return chart;
    1139
    1140    }
    1141
    1142    /**
    1143     * Creates a stacked area chart with default settings.  The chart object
    1144     * returned by this method uses a {@link CategoryPlot} instance as the
    1145     * plot, with a {@link CategoryAxis} for the domain axis, a
    1146     * {@link NumberAxis} as the range axis, and a {@link StackedAreaRenderer}
    1147     * as the renderer.
    1148     *
    1149     * @param title  the chart title (<code>null</code> permitted).
    1150     * @param categoryAxisLabel  the label for the category axis
    1151     *                           (<code>null</code> permitted).
    1152     * @param valueAxisLabel  the label for the value axis (<code>null</code>
    1153     *                        permitted).
    1154     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1155     * @param orientation  the plot orientation (horizontal or vertical)
    1156     *                     (<code>null</code> not permitted).
    1157     * @param legend  a flag specifying whether or not a legend is required.
    1158     * @param tooltips  configure chart to generate tool tips?
    1159     * @param urls  configure chart to generate URLs?
    1160     *
    1161     * @return A stacked area chart.
    1162     */
    1163    public static JFreeChart createStackedAreaChart(String title,
    1164            String categoryAxisLabel, String valueAxisLabel,
    1165            CategoryDataset dataset, PlotOrientation orientation,
    1166            boolean legend, boolean tooltips, boolean urls) {
    1167
    1168        if (orientation == null) {
    1169            throw new IllegalArgumentException("Null 'orientation' argument.");
    1170        }
    1171        CategoryAxis categoryAxis = new CategoryAxis(categoryAxisLabel);
    1172        categoryAxis.setCategoryMargin(0.0);
    1173        ValueAxis valueAxis = new NumberAxis(valueAxisLabel);
    1174
    1175        StackedAreaRenderer renderer = new StackedAreaRenderer();
    1176        if (tooltips) {
    1177            renderer.setBaseToolTipGenerator(
    1178                    new StandardCategoryToolTipGenerator());
    1179        }
    1180        if (urls) {
    1181            renderer.setBaseItemURLGenerator(
    1182                    new StandardCategoryURLGenerator());
    1183        }
    1184
    1185        CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, valueAxis,
    1186                renderer);
    1187        plot.setOrientation(orientation);
    1188        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1189                plot, legend);
    1190        currentTheme.apply(chart);
    1191        return chart;
    1192
    1193    }
    1194
    1195    /**
    1196     * Creates a line chart with default settings.  The chart object returned
    1197     * by this method uses a {@link CategoryPlot} instance as the plot, with a
    1198     * {@link CategoryAxis} for the domain axis, a {@link NumberAxis} as the
    1199     * range axis, and a {@link LineAndShapeRenderer} as the renderer.
    1200     *
    1201     * @param title  the chart title (<code>null</code> permitted).
    1202     * @param categoryAxisLabel  the label for the category axis
    1203     *                           (<code>null</code> permitted).
    1204     * @param valueAxisLabel  the label for the value axis (<code>null</code>
    1205     *                        permitted).
    1206     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1207     * @param orientation  the chart orientation (horizontal or vertical)
    1208     *                     (<code>null</code> not permitted).
    1209     * @param legend  a flag specifying whether or not a legend is required.
    1210     * @param tooltips  configure chart to generate tool tips?
    1211     * @param urls  configure chart to generate URLs?
    1212     *
    1213     * @return A line chart.
    1214     */
    1215    public static JFreeChart createLineChart(String title,
    1216                                             String categoryAxisLabel,
    1217                                             String valueAxisLabel,
    1218                                             CategoryDataset dataset,
    1219                                             PlotOrientation orientation,
    1220                                             boolean legend,
    1221                                             boolean tooltips,
    1222                                             boolean urls) {
    1223
    1224        if (orientation == null) {
    1225            throw new IllegalArgumentException("Null 'orientation' argument.");
    1226        }
    1227        CategoryAxis categoryAxis = new CategoryAxis(categoryAxisLabel);
    1228        ValueAxis valueAxis = new NumberAxis(valueAxisLabel);
    1229
    1230        LineAndShapeRenderer renderer = new LineAndShapeRenderer(true, false);
    1231        if (tooltips) {
    1232            renderer.setBaseToolTipGenerator(
    1233                    new StandardCategoryToolTipGenerator());
    1234        }
    1235        if (urls) {
    1236            renderer.setBaseItemURLGenerator(
    1237                    new StandardCategoryURLGenerator());
    1238        }
    1239        CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, valueAxis,
    1240                renderer);
    1241        plot.setOrientation(orientation);
    1242        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1243                plot, legend);
    1244        currentTheme.apply(chart);
    1245        return chart;
    1246
    1247    }
    1248
    1249    /**
    1250     * Creates a line chart with default settings. The chart object returned by
    1251     * this method uses a {@link CategoryPlot} instance as the plot, with a
    1252     * {@link CategoryAxis3D} for the domain axis, a {@link NumberAxis3D} as
    1253     * the range axis, and a {@link LineRenderer3D} as the renderer.
    1254     *
    1255     * @param title  the chart title (<code>null</code> permitted).
    1256     * @param categoryAxisLabel  the label for the category axis
    1257     *                           (<code>null</code> permitted).
    1258     * @param valueAxisLabel  the label for the value axis (<code>null</code>
    1259     *                        permitted).
    1260     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1261     * @param orientation  the chart orientation (horizontal or vertical)
    1262     *                     (<code>null</code> not permitted).
    1263     * @param legend  a flag specifying whether or not a legend is required.
    1264     * @param tooltips  configure chart to generate tool tips?
    1265     * @param urls  configure chart to generate URLs?
    1266     *
    1267     * @return A line chart.
    1268     */
    1269    public static JFreeChart createLineChart3D(String title,
    1270                                               String categoryAxisLabel,
    1271                                               String valueAxisLabel,
    1272                                               CategoryDataset dataset,
    1273                                               PlotOrientation orientation,
    1274                                               boolean legend,
    1275                                               boolean tooltips,
    1276                                               boolean urls) {
    1277
    1278        if (orientation == null) {
    1279            throw new IllegalArgumentException("Null 'orientation' argument.");
    1280        }
    1281        CategoryAxis categoryAxis = new CategoryAxis3D(categoryAxisLabel);
    1282        ValueAxis valueAxis = new NumberAxis3D(valueAxisLabel);
    1283
    1284        LineRenderer3D renderer = new LineRenderer3D();
    1285        if (tooltips) {
    1286            renderer.setBaseToolTipGenerator(
    1287                    new StandardCategoryToolTipGenerator());
    1288        }
    1289        if (urls) {
    1290            renderer.setBaseItemURLGenerator(
    1291                    new StandardCategoryURLGenerator());
    1292        }
    1293        CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, valueAxis,
    1294                renderer);
    1295        plot.setOrientation(orientation);
    1296        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1297                plot, legend);
    1298        currentTheme.apply(chart);
    1299        return chart;
    1300
    1301    }
    1302
    1303    /**
    1304     * Creates a Gantt chart using the supplied attributes plus default values
    1305     * where required.  The chart object returned by this method uses a
    1306     * {@link CategoryPlot} instance as the plot, with a {@link CategoryAxis}
    1307     * for the domain axis, a {@link DateAxis} as the range axis, and a
    1308     * {@link GanttRenderer} as the renderer.
    1309     *
    1310     * @param title  the chart title (<code>null</code> permitted).
    1311     * @param categoryAxisLabel  the label for the category axis
    1312     *                           (<code>null</code> permitted).
    1313     * @param dateAxisLabel  the label for the date axis
    1314     *                       (<code>null</code> permitted).
    1315     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1316     * @param legend  a flag specifying whether or not a legend is required.
    1317     * @param tooltips  configure chart to generate tool tips?
    1318     * @param urls  configure chart to generate URLs?
    1319     *
    1320     * @return A Gantt chart.
    1321     */
    1322    public static JFreeChart createGanttChart(String title,
    1323                                              String categoryAxisLabel,
    1324                                              String dateAxisLabel,
    1325                                              IntervalCategoryDataset dataset,
    1326                                              boolean legend,
    1327                                              boolean tooltips,
    1328                                              boolean urls) {
    1329
    1330        CategoryAxis categoryAxis = new CategoryAxis(categoryAxisLabel);
    1331        DateAxis dateAxis = new DateAxis(dateAxisLabel);
    1332
    1333        CategoryItemRenderer renderer = new GanttRenderer();
    1334        if (tooltips) {
    1335            renderer.setBaseToolTipGenerator(
    1336                    new IntervalCategoryToolTipGenerator(
    1337                    "{3} - {4}", DateFormat.getDateInstance()));
    1338        }
    1339        if (urls) {
    1340            renderer.setBaseItemURLGenerator(
    1341                    new StandardCategoryURLGenerator());
    1342        }
    1343
    1344        CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, dateAxis,
    1345                renderer);
    1346        plot.setOrientation(PlotOrientation.HORIZONTAL);
    1347        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1348                plot, legend);
    1349        currentTheme.apply(chart);
    1350        return chart;
    1351
    1352    }
    1353
    1354    /**
    1355     * Creates a waterfall chart.  The chart object returned by this method
    1356     * uses a {@link CategoryPlot} instance as the plot, with a
    1357     * {@link CategoryAxis} for the domain axis, a {@link NumberAxis} as the
    1358     * range axis, and a {@link WaterfallBarRenderer} as the renderer.
    1359     *
    1360     * @param title  the chart title (<code>null</code> permitted).
    1361     * @param categoryAxisLabel  the label for the category axis
    1362     *                           (<code>null</code> permitted).
    1363     * @param valueAxisLabel  the label for the value axis (<code>null</code>
    1364     *                        permitted).
    1365     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1366     * @param orientation  the plot orientation (horizontal or vertical)
    1367     *                     (<code>null</code> NOT permitted).
    1368     * @param legend  a flag specifying whether or not a legend is required.
    1369     * @param tooltips  configure chart to generate tool tips?
    1370     * @param urls  configure chart to generate URLs?
    1371     *
    1372     * @return A waterfall chart.
    1373     */
    1374    public static JFreeChart createWaterfallChart(String title,
    1375                                                  String categoryAxisLabel,
    1376                                                  String valueAxisLabel,
    1377                                                  CategoryDataset dataset,
    1378                                                  PlotOrientation orientation,
    1379                                                  boolean legend,
    1380                                                  boolean tooltips,
    1381                                                  boolean urls) {
    1382
    1383        if (orientation == null) {
    1384            throw new IllegalArgumentException("Null 'orientation' argument.");
    1385        }
    1386        CategoryAxis categoryAxis = new CategoryAxis(categoryAxisLabel);
    1387        categoryAxis.setCategoryMargin(0.0);
    1388
    1389        ValueAxis valueAxis = new NumberAxis(valueAxisLabel);
    1390
    1391        WaterfallBarRenderer renderer = new WaterfallBarRenderer();
    1392        if (orientation == PlotOrientation.HORIZONTAL) {
    1393            ItemLabelPosition position = new ItemLabelPosition(
    1394                    ItemLabelAnchor.CENTER, TextAnchor.CENTER,
    1395                    TextAnchor.CENTER, Math.PI / 2.0);
    1396            renderer.setBasePositiveItemLabelPosition(position);
    1397            renderer.setBaseNegativeItemLabelPosition(position);
    1398         }
    1399        else if (orientation == PlotOrientation.VERTICAL) {
    1400            ItemLabelPosition position = new ItemLabelPosition(
    1401                    ItemLabelAnchor.CENTER, TextAnchor.CENTER,
    1402                    TextAnchor.CENTER, 0.0);
    1403            renderer.setBasePositiveItemLabelPosition(position);
    1404            renderer.setBaseNegativeItemLabelPosition(position);
    1405        }
    1406        if (tooltips) {
    1407            StandardCategoryToolTipGenerator generator
    1408                = new StandardCategoryToolTipGenerator();
    1409            renderer.setBaseToolTipGenerator(generator);
    1410        }
    1411        if (urls) {
    1412            renderer.setBaseItemURLGenerator(
    1413                    new StandardCategoryURLGenerator());
    1414        }
    1415
    1416        CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, valueAxis,
    1417                renderer);
    1418        plot.clearRangeMarkers();
    1419        Marker baseline = new ValueMarker(0.0);
    1420        baseline.setPaint(Color.black);
    1421        plot.addRangeMarker(baseline, Layer.FOREGROUND);
    1422        plot.setOrientation(orientation);
    1423        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1424                plot, legend);
    1425        currentTheme.apply(chart);
    1426        return chart;
    1427
    1428    }
    1429
    1430    /**
    1431     * Creates a polar plot for the specified dataset (x-values interpreted as
    1432     * angles in degrees).  The chart object returned by this method uses a
    1433     * {@link PolarPlot} instance as the plot, with a {@link NumberAxis} for
    1434     * the radial axis.
    1435     *
    1436     * @param title  the chart title (<code>null</code> permitted).
    1437     * @param dataset  the dataset (<code>null</code> permitted).
    1438     * @param legend  legend required?
    1439     * @param tooltips  tooltips required?
    1440     * @param urls  URLs required?
    1441     *
    1442     * @return A chart.
    1443     */
    1444    public static JFreeChart createPolarChart(String title,
    1445                                              XYDataset dataset,
    1446                                              boolean legend,
    1447                                              boolean tooltips,
    1448                                              boolean urls) {
    1449
    1450        PolarPlot plot = new PolarPlot();
    1451        plot.setDataset(dataset);
    1452        NumberAxis rangeAxis = new NumberAxis();
    1453        rangeAxis.setAxisLineVisible(false);
    1454        rangeAxis.setTickMarksVisible(false);
    1455        rangeAxis.setTickLabelInsets(new RectangleInsets(0.0, 0.0, 0.0, 0.0));
    1456        plot.setAxis(rangeAxis);
    1457        plot.setRenderer(new DefaultPolarItemRenderer());
    1458        JFreeChart chart = new JFreeChart(
    1459                title, JFreeChart.DEFAULT_TITLE_FONT, plot, legend);
    1460        currentTheme.apply(chart);
    1461        return chart;
    1462
    1463    }
    1464
    1465    /**
    1466     * Creates a scatter plot with default settings.  The chart object
    1467     * returned by this method uses an {@link XYPlot} instance as the plot,
    1468     * with a {@link NumberAxis} for the domain axis, a  {@link NumberAxis}
    1469     * as the range axis, and an {@link XYLineAndShapeRenderer} as the
    1470     * renderer.
    1471     *
    1472     * @param title  the chart title (<code>null</code> permitted).
    1473     * @param xAxisLabel  a label for the X-axis (<code>null</code> permitted).
    1474     * @param yAxisLabel  a label for the Y-axis (<code>null</code> permitted).
    1475     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1476     * @param orientation  the plot orientation (horizontal or vertical)
    1477     *                     (<code>null</code> NOT permitted).
    1478     * @param legend  a flag specifying whether or not a legend is required.
    1479     * @param tooltips  configure chart to generate tool tips?
    1480     * @param urls  configure chart to generate URLs?
    1481     *
    1482     * @return A scatter plot.
    1483     */
    1484    public static JFreeChart createScatterPlot(String title, String xAxisLabel,
    1485            String yAxisLabel, XYDataset dataset, PlotOrientation orientation,
    1486            boolean legend, boolean tooltips, boolean urls) {
    1487
    1488        if (orientation == null) {
    1489            throw new IllegalArgumentException("Null 'orientation' argument.");
    1490        }
    1491        NumberAxis xAxis = new NumberAxis(xAxisLabel);
    1492        xAxis.setAutoRangeIncludesZero(false);
    1493        NumberAxis yAxis = new NumberAxis(yAxisLabel);
    1494        yAxis.setAutoRangeIncludesZero(false);
    1495
    1496        XYPlot plot = new XYPlot(dataset, xAxis, yAxis, null);
    1497
    1498        XYToolTipGenerator toolTipGenerator = null;
    1499        if (tooltips) {
    1500            toolTipGenerator = new StandardXYToolTipGenerator();
    1501        }
    1502
    1503        XYURLGenerator urlGenerator = null;
    1504        if (urls) {
    1505            urlGenerator = new StandardXYURLGenerator();
    1506        }
    1507        XYItemRenderer renderer = new XYLineAndShapeRenderer(false, true);
    1508        renderer.setBaseToolTipGenerator(toolTipGenerator);
    1509        renderer.setURLGenerator(urlGenerator);
    1510        plot.setRenderer(renderer);
    1511        plot.setOrientation(orientation);
    1512
    1513        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1514                plot, legend);
    1515        currentTheme.apply(chart);
    1516        return chart;
    1517
    1518    }
    1519
    1520    /**
    1521     * Creates and returns a default instance of an XY bar chart.
    1522     * <P>
    1523     * The chart object returned by this method uses an {@link XYPlot} instance
    1524     * as the plot, with a {@link DateAxis} for the domain axis, a
    1525     * {@link NumberAxis} as the range axis, and a {@link XYBarRenderer} as the
    1526     * renderer.
    1527     *
    1528     * @param title  the chart title (<code>null</code> permitted).
    1529     * @param xAxisLabel  a label for the X-axis (<code>null</code> permitted).
    1530     * @param dateAxis  make the domain axis display dates?
    1531     * @param yAxisLabel  a label for the Y-axis (<code>null</code> permitted).
    1532     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1533     * @param orientation  the orientation (horizontal or vertical)
    1534     *                     (<code>null</code> NOT permitted).
    1535     * @param legend  a flag specifying whether or not a legend is required.
    1536     * @param tooltips  configure chart to generate tool tips?
    1537     * @param urls  configure chart to generate URLs?
    1538     *
    1539     * @return An XY bar chart.
    1540     */
    1541    public static JFreeChart createXYBarChart(String title,
    1542                                              String xAxisLabel,
    1543                                              boolean dateAxis,
    1544                                              String yAxisLabel,
    1545                                              IntervalXYDataset dataset,
    1546                                              PlotOrientation orientation,
    1547                                              boolean legend,
    1548                                              boolean tooltips,
    1549                                              boolean urls) {
    1550
    1551        if (orientation == null) {
    1552            throw new IllegalArgumentException("Null 'orientation' argument.");
    1553        }
    1554        ValueAxis domainAxis = null;
    1555        if (dateAxis) {
    1556            domainAxis = new DateAxis(xAxisLabel);
    1557        }
    1558        else {
    1559            NumberAxis axis = new NumberAxis(xAxisLabel);
    1560            axis.setAutoRangeIncludesZero(false);
    1561            domainAxis = axis;
    1562        }
    1563        ValueAxis valueAxis = new NumberAxis(yAxisLabel);
    1564
    1565        XYBarRenderer renderer = new XYBarRenderer();
    1566        if (tooltips) {
    1567            XYToolTipGenerator tt;
    1568            if (dateAxis) {
    1569                tt = StandardXYToolTipGenerator.getTimeSeriesInstance();
    1570            }
    1571            else {
    1572                tt = new StandardXYToolTipGenerator();
    1573            }
    1574            renderer.setBaseToolTipGenerator(tt);
    1575        }
    1576        if (urls) {
    1577            renderer.setURLGenerator(new StandardXYURLGenerator());
    1578        }
    1579
    1580        XYPlot plot = new XYPlot(dataset, domainAxis, valueAxis, renderer);
    1581        plot.setOrientation(orientation);
    1582
    1583        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1584                plot, legend);
    1585        currentTheme.apply(chart);
    1586        return chart;
    1587
    1588    }
    1589
    1590    /**
    1591     * Creates an area chart using an {@link XYDataset}.
    1592     * <P>
    1593     * The chart object returned by this method uses an {@link XYPlot} instance
    1594     * as the plot, with a {@link NumberAxis} for the domain axis, a
    1595     * {@link NumberAxis} as the range axis, and a {@link XYAreaRenderer} as
    1596     * the renderer.
    1597     *
    1598     * @param title  the chart title (<code>null</code> permitted).
    1599     * @param xAxisLabel  a label for the X-axis (<code>null</code> permitted).
    1600     * @param yAxisLabel  a label for the Y-axis (<code>null</code> permitted).
    1601     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1602     * @param orientation  the plot orientation (horizontal or vertical)
    1603     *                     (<code>null</code> NOT permitted).
    1604     * @param legend  a flag specifying whether or not a legend is required.
    1605     * @param tooltips  configure chart to generate tool tips?
    1606     * @param urls  configure chart to generate URLs?
    1607     *
    1608     * @return An XY area chart.
    1609     */
    1610    public static JFreeChart createXYAreaChart(String title,
    1611                                               String xAxisLabel,
    1612                                               String yAxisLabel,
    1613                                               XYDataset dataset,
    1614                                               PlotOrientation orientation,
    1615                                               boolean legend,
    1616                                               boolean tooltips,
    1617                                               boolean urls) {
    1618
    1619        if (orientation == null) {
    1620            throw new IllegalArgumentException("Null 'orientation' argument.");
    1621        }
    1622        NumberAxis xAxis = new NumberAxis(xAxisLabel);
    1623        xAxis.setAutoRangeIncludesZero(false);
    1624        NumberAxis yAxis = new NumberAxis(yAxisLabel);
    1625        XYPlot plot = new XYPlot(dataset, xAxis, yAxis, null);
    1626        plot.setOrientation(orientation);
    1627        plot.setForegroundAlpha(0.5f);
    1628
    1629        XYToolTipGenerator tipGenerator = null;
    1630        if (tooltips) {
    1631            tipGenerator = new StandardXYToolTipGenerator();
    1632        }
    1633
    1634        XYURLGenerator urlGenerator = null;
    1635        if (urls) {
    1636            urlGenerator = new StandardXYURLGenerator();
    1637        }
    1638
    1639        plot.setRenderer(new XYAreaRenderer(XYAreaRenderer.AREA, tipGenerator,
    1640                urlGenerator));
    1641        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1642                plot, legend);
    1643        currentTheme.apply(chart);
    1644        return chart;
    1645
    1646    }
    1647
    1648    /**
    1649     * Creates a stacked XY area plot.  The chart object returned by this
    1650     * method uses an {@link XYPlot} instance as the plot, with a
    1651     * {@link NumberAxis} for the domain axis, a {@link NumberAxis} as the
    1652     * range axis, and a {@link StackedXYAreaRenderer2} as the renderer.
    1653     *
    1654     * @param title  the chart title (<code>null</code> permitted).
    1655     * @param xAxisLabel  a label for the X-axis (<code>null</code> permitted).
    1656     * @param yAxisLabel  a label for the Y-axis (<code>null</code> permitted).
    1657     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1658     * @param orientation  the plot orientation (horizontal or vertical)
    1659     *                     (<code>null</code> NOT permitted).
    1660     * @param legend  a flag specifying whether or not a legend is required.
    1661     * @param tooltips  configure chart to generate tool tips?
    1662     * @param urls  configure chart to generate URLs?
    1663     *
    1664     * @return A stacked XY area chart.
    1665     */
    1666    public static JFreeChart createStackedXYAreaChart(String title,
    1667                                                    String xAxisLabel,
    1668                                                    String yAxisLabel,
    1669                                                    TableXYDataset dataset,
    1670                                                    PlotOrientation orientation,
    1671                                                    boolean legend,
    1672                                                    boolean tooltips,
    1673                                                    boolean urls) {
    1674
    1675        if (orientation == null) {
    1676            throw new IllegalArgumentException("Null 'orientation' argument.");
    1677        }
    1678        NumberAxis xAxis = new NumberAxis(xAxisLabel);
    1679        xAxis.setAutoRangeIncludesZero(false);
    1680        xAxis.setLowerMargin(0.0);
    1681        xAxis.setUpperMargin(0.0);
    1682        NumberAxis yAxis = new NumberAxis(yAxisLabel);
    1683        XYToolTipGenerator toolTipGenerator = null;
    1684        if (tooltips) {
    1685            toolTipGenerator = new StandardXYToolTipGenerator();
    1686        }
    1687
    1688        XYURLGenerator urlGenerator = null;
    1689        if (urls) {
    1690            urlGenerator = new StandardXYURLGenerator();
    1691        }
    1692        StackedXYAreaRenderer2 renderer = new StackedXYAreaRenderer2(
    1693                toolTipGenerator, urlGenerator);
    1694        renderer.setOutline(true);
    1695        XYPlot plot = new XYPlot(dataset, xAxis, yAxis, renderer);
    1696        plot.setOrientation(orientation);
    1697
    1698        plot.setRangeAxis(yAxis);  // forces recalculation of the axis range
    1699
    1700        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1701                plot, legend);
    1702        currentTheme.apply(chart);
    1703        return chart;
    1704
    1705    }
    1706
    1707    /**
    1708     * Creates a line chart (based on an {@link XYDataset}) with default
    1709     * settings.
    1710     *
    1711     * @param title  the chart title (<code>null</code> permitted).
    1712     * @param xAxisLabel  a label for the X-axis (<code>null</code> permitted).
    1713     * @param yAxisLabel  a label for the Y-axis (<code>null</code> permitted).
    1714     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1715     * @param orientation  the plot orientation (horizontal or vertical)
    1716     *                     (<code>null</code> NOT permitted).
    1717     * @param legend  a flag specifying whether or not a legend is required.
    1718     * @param tooltips  configure chart to generate tool tips?
    1719     * @param urls  configure chart to generate URLs?
    1720     *
    1721     * @return The chart.
    1722     */
    1723    public static JFreeChart createXYLineChart(String title,
    1724                                               String xAxisLabel,
    1725                                               String yAxisLabel,
    1726                                               XYDataset dataset,
    1727                                               PlotOrientation orientation,
    1728                                               boolean legend,
    1729                                               boolean tooltips,
    1730                                               boolean urls) {
    1731
    1732        if (orientation == null) {
    1733            throw new IllegalArgumentException("Null 'orientation' argument.");
    1734        }
    1735        NumberAxis xAxis = new NumberAxis(xAxisLabel);
    1736        xAxis.setAutoRangeIncludesZero(false);
    1737        NumberAxis yAxis = new NumberAxis(yAxisLabel);
    1738        XYItemRenderer renderer = new XYLineAndShapeRenderer(true, false);
    1739        XYPlot plot = new XYPlot(dataset, xAxis, yAxis, renderer);
    1740        plot.setOrientation(orientation);
    1741        if (tooltips) {
    1742            renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
    1743        }
    1744        if (urls) {
    1745            renderer.setURLGenerator(new StandardXYURLGenerator());
    1746        }
    1747
    1748        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1749                plot, legend);
    1750        currentTheme.apply(chart);
    1751        return chart;
    1752
    1753    }
    1754
    1755    /**
    1756     * Creates a stepped XY plot with default settings.
    1757     *
    1758     * @param title  the chart title (<code>null</code> permitted).
    1759     * @param xAxisLabel  a label for the X-axis (<code>null</code> permitted).
    1760     * @param yAxisLabel  a label for the Y-axis (<code>null</code> permitted).
    1761     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1762     * @param orientation  the plot orientation (horizontal or vertical)
    1763     *                     (<code>null</code> NOT permitted).
    1764     * @param legend  a flag specifying whether or not a legend is required.
    1765     * @param tooltips  configure chart to generate tool tips?
    1766     * @param urls  configure chart to generate URLs?
    1767     *
    1768     * @return A chart.
    1769     */
    1770    public static JFreeChart createXYStepChart(String title,
    1771                                               String xAxisLabel,
    1772                                               String yAxisLabel,
    1773                                               XYDataset dataset,
    1774                                               PlotOrientation orientation,
    1775                                               boolean legend,
    1776                                               boolean tooltips,
    1777                                               boolean urls) {
    1778
    1779        if (orientation == null) {
    1780            throw new IllegalArgumentException("Null 'orientation' argument.");
    1781        }
    1782        DateAxis xAxis = new DateAxis(xAxisLabel);
    1783        NumberAxis yAxis = new NumberAxis(yAxisLabel);
    1784        yAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
    1785
    1786        XYToolTipGenerator toolTipGenerator = null;
    1787        if (tooltips) {
    1788            toolTipGenerator = new StandardXYToolTipGenerator();
    1789        }
    1790
    1791        XYURLGenerator urlGenerator = null;
    1792        if (urls) {
    1793            urlGenerator = new StandardXYURLGenerator();
    1794        }
    1795        XYItemRenderer renderer = new XYStepRenderer(toolTipGenerator,
    1796                urlGenerator);
    1797
    1798        XYPlot plot = new XYPlot(dataset, xAxis, yAxis, null);
    1799        plot.setRenderer(renderer);
    1800        plot.setOrientation(orientation);
    1801        plot.setDomainCrosshairVisible(false);
    1802        plot.setRangeCrosshairVisible(false);
    1803        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1804                plot, legend);
    1805        currentTheme.apply(chart);
    1806        return chart;
    1807
    1808    }
    1809
    1810    /**
    1811     * Creates a filled stepped XY plot with default settings.
    1812     *
    1813     * @param title  the chart title (<code>null</code> permitted).
    1814     * @param xAxisLabel  a label for the X-axis (<code>null</code> permitted).
    1815     * @param yAxisLabel  a label for the Y-axis (<code>null</code> permitted).
    1816     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1817     * @param orientation  the plot orientation (horizontal or vertical)
    1818     *                     (<code>null</code> NOT permitted).
    1819     * @param legend  a flag specifying whether or not a legend is required.
    1820     * @param tooltips  configure chart to generate tool tips?
    1821     * @param urls  configure chart to generate URLs?
    1822     *
    1823     * @return A chart.
    1824     */
    1825    public static JFreeChart createXYStepAreaChart(String title,
    1826                                                   String xAxisLabel,
    1827                                                   String yAxisLabel,
    1828                                                   XYDataset dataset,
    1829                                                   PlotOrientation orientation,
    1830                                                   boolean legend,
    1831                                                   boolean tooltips,
    1832                                                   boolean urls) {
    1833
    1834        if (orientation == null) {
    1835            throw new IllegalArgumentException("Null 'orientation' argument.");
    1836        }
    1837        NumberAxis xAxis = new NumberAxis(xAxisLabel);
    1838        xAxis.setAutoRangeIncludesZero(false);
    1839        NumberAxis yAxis = new NumberAxis(yAxisLabel);
    1840
    1841        XYToolTipGenerator toolTipGenerator = null;
    1842        if (tooltips) {
    1843            toolTipGenerator = new StandardXYToolTipGenerator();
    1844        }
    1845
    1846        XYURLGenerator urlGenerator = null;
    1847        if (urls) {
    1848            urlGenerator = new StandardXYURLGenerator();
    1849        }
    1850        XYItemRenderer renderer = new XYStepAreaRenderer(
    1851                XYStepAreaRenderer.AREA_AND_SHAPES, toolTipGenerator,
    1852                urlGenerator);
    1853
    1854        XYPlot plot = new XYPlot(dataset, xAxis, yAxis, null);
    1855        plot.setRenderer(renderer);
    1856        plot.setOrientation(orientation);
    1857        plot.setDomainCrosshairVisible(false);
    1858        plot.setRangeCrosshairVisible(false);
    1859        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1860                plot, legend);
    1861        currentTheme.apply(chart);
    1862        return chart;
    1863    }
    1864
    1865    /**
    1866     * Creates and returns a time series chart.  A time series chart is an
    1867     * {@link XYPlot} with a {@link DateAxis} for the x-axis and a
    1868     * {@link NumberAxis} for the y-axis.  The default renderer is an
    1869     * {@link XYLineAndShapeRenderer}.
    1870     * <P>
    1871     * A convenient dataset to use with this chart is a
    1872     * {@link org.jfree.data.time.TimeSeriesCollection}.
    1873     *
    1874     * @param title  the chart title (<code>null</code> permitted).
    1875     * @param timeAxisLabel  a label for the time axis (<code>null</code>
    1876     *                       permitted).
    1877     * @param valueAxisLabel  a label for the value axis (<code>null</code>
    1878     *                        permitted).
    1879     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1880     * @param legend  a flag specifying whether or not a legend is required.
    1881     * @param tooltips  configure chart to generate tool tips?
    1882     * @param urls  configure chart to generate URLs?
    1883     *
    1884     * @return A time series chart.
    1885     */
    1886    public static JFreeChart createTimeSeriesChart(String title,
    1887                                                   String timeAxisLabel,
    1888                                                   String valueAxisLabel,
    1889                                                   XYDataset dataset,
    1890                                                   boolean legend,
    1891                                                   boolean tooltips,
    1892                                                   boolean urls) {
    1893
    1894        ValueAxis timeAxis = new DateAxis(timeAxisLabel);
    1895        timeAxis.setLowerMargin(0.02);  // reduce the default margins
    1896        timeAxis.setUpperMargin(0.02);
    1897        NumberAxis valueAxis = new NumberAxis(valueAxisLabel);
    1898        valueAxis.setAutoRangeIncludesZero(false);  // override default
    1899        XYPlot plot = new XYPlot(dataset, timeAxis, valueAxis, null);
    1900
    1901        XYToolTipGenerator toolTipGenerator = null;
    1902        if (tooltips) {
    1903            toolTipGenerator
    1904                = StandardXYToolTipGenerator.getTimeSeriesInstance();
    1905        }
    1906
    1907        XYURLGenerator urlGenerator = null;
    1908        if (urls) {
    1909            urlGenerator = new StandardXYURLGenerator();
    1910        }
    1911
    1912        XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(true,
    1913                false);
    1914        renderer.setBaseToolTipGenerator(toolTipGenerator);
    1915        renderer.setURLGenerator(urlGenerator);
    1916        plot.setRenderer(renderer);
    1917
    1918        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1919                plot, legend);
    1920        currentTheme.apply(chart);
    1921        return chart;
    1922
    1923    }
    1924
    1925    /**
    1926     * Creates and returns a default instance of a candlesticks chart.
    1927     *
    1928     * @param title  the chart title (<code>null</code> permitted).
    1929     * @param timeAxisLabel  a label for the time axis (<code>null</code>
    1930     *                       permitted).
    1931     * @param valueAxisLabel  a label for the value axis (<code>null</code>
    1932     *                        permitted).
    1933     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1934     * @param legend  a flag specifying whether or not a legend is required.
    1935     *
    1936     * @return A candlestick chart.
    1937     */
    1938    public static JFreeChart createCandlestickChart(String title,
    1939                                                    String timeAxisLabel,
    1940                                                    String valueAxisLabel,
    1941                                                    OHLCDataset dataset,
    1942                                                    boolean legend) {
    1943
    1944        ValueAxis timeAxis = new DateAxis(timeAxisLabel);
    1945        NumberAxis valueAxis = new NumberAxis(valueAxisLabel);
    1946        XYPlot plot = new XYPlot(dataset, timeAxis, valueAxis, null);
    1947        plot.setRenderer(new CandlestickRenderer());
    1948        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1949                plot, legend);
    1950        currentTheme.apply(chart);
    1951        return chart;
    1952
    1953    }
    1954
    1955    /**
    1956     * Creates and returns a default instance of a high-low-open-close chart.
    1957     *
    1958     * @param title  the chart title (<code>null</code> permitted).
    1959     * @param timeAxisLabel  a label for the time axis (<code>null</code>
    1960     *                       permitted).
    1961     * @param valueAxisLabel  a label for the value axis (<code>null</code>
    1962     *                        permitted).
    1963     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1964     * @param legend  a flag specifying whether or not a legend is required.
    1965     *
    1966     * @return A high-low-open-close chart.
    1967     */
    1968    public static JFreeChart createHighLowChart(String title,
    1969                                                String timeAxisLabel,
    1970                                                String valueAxisLabel,
    1971                                                OHLCDataset dataset,
    1972                                                boolean legend) {
    1973
    1974        ValueAxis timeAxis = new DateAxis(timeAxisLabel);
    1975        NumberAxis valueAxis = new NumberAxis(valueAxisLabel);
    1976        HighLowRenderer renderer = new HighLowRenderer();
    1977        renderer.setBaseToolTipGenerator(new HighLowItemLabelGenerator());
    1978        XYPlot plot = new XYPlot(dataset, timeAxis, valueAxis, renderer);
    1979        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    1980                plot, legend);
    1981        currentTheme.apply(chart);
    1982        return chart;
    1983
    1984    }
    1985
    1986    /**
    1987     * Creates and returns a default instance of a high-low-open-close chart
    1988     * with a special timeline. This timeline can be a
    1989     * {@link org.jfree.chart.axis.SegmentedTimeline} such as the Monday
    1990     * through Friday timeline that will remove Saturdays and Sundays from
    1991     * the axis.
    1992     *
    1993     * @param title  the chart title (<code>null</code> permitted).
    1994     * @param timeAxisLabel  a label for the time axis (<code>null</code>
    1995     *                       permitted).
    1996     * @param valueAxisLabel  a label for the value axis (<code>null</code>
    1997     *                        permitted).
    1998     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    1999     * @param timeline  the timeline.
    2000     * @param legend  a flag specifying whether or not a legend is required.
    2001     *
    2002     * @return A high-low-open-close chart.
    2003     */
    2004    public static JFreeChart createHighLowChart(String title,
    2005                                                String timeAxisLabel,
    2006                                                String valueAxisLabel,
    2007                                                OHLCDataset dataset,
    2008                                                Timeline timeline,
    2009                                                boolean legend) {
    2010
    2011        DateAxis timeAxis = new DateAxis(timeAxisLabel);
    2012        timeAxis.setTimeline(timeline);
    2013        NumberAxis valueAxis = new NumberAxis(valueAxisLabel);
    2014        HighLowRenderer renderer = new HighLowRenderer();
    2015        renderer.setBaseToolTipGenerator(new HighLowItemLabelGenerator());
    2016        XYPlot plot = new XYPlot(dataset, timeAxis, valueAxis, renderer);
    2017        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    2018                plot, legend);
    2019        currentTheme.apply(chart);
    2020        return chart;
    2021
    2022    }
    2023
    2024    /**
    2025     * Creates a bubble chart with default settings.  The chart is composed of
    2026     * an {@link XYPlot}, with a {@link NumberAxis} for the domain axis,
    2027     * a {@link NumberAxis} for the range axis, and an {@link XYBubbleRenderer}
    2028     * to draw the data items.
    2029     *
    2030     * @param title  the chart title (<code>null</code> permitted).
    2031     * @param xAxisLabel  a label for the X-axis (<code>null</code> permitted).
    2032     * @param yAxisLabel  a label for the Y-axis (<code>null</code> permitted).
    2033     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    2034     * @param orientation  the orientation (horizontal or vertical)
    2035     *                     (<code>null</code> NOT permitted).
    2036     * @param legend  a flag specifying whether or not a legend is required.
    2037     * @param tooltips  configure chart to generate tool tips?
    2038     * @param urls  configure chart to generate URLs?
    2039     *
    2040     * @return A bubble chart.
    2041     */
    2042    public static JFreeChart createBubbleChart(String title,
    2043                                               String xAxisLabel,
    2044                                               String yAxisLabel,
    2045                                               XYZDataset dataset,
    2046                                               PlotOrientation orientation,
    2047                                               boolean legend,
    2048                                               boolean tooltips,
    2049                                               boolean urls) {
    2050
    2051        if (orientation == null) {
    2052            throw new IllegalArgumentException("Null 'orientation' argument.");
    2053        }
    2054        NumberAxis xAxis = new NumberAxis(xAxisLabel);
    2055        xAxis.setAutoRangeIncludesZero(false);
    2056        NumberAxis yAxis = new NumberAxis(yAxisLabel);
    2057        yAxis.setAutoRangeIncludesZero(false);
    2058
    2059        XYPlot plot = new XYPlot(dataset, xAxis, yAxis, null);
    2060
    2061        XYItemRenderer renderer = new XYBubbleRenderer(
    2062                XYBubbleRenderer.SCALE_ON_RANGE_AXIS);
    2063        if (tooltips) {
    2064            renderer.setBaseToolTipGenerator(new StandardXYZToolTipGenerator());
    2065        }
    2066        if (urls) {
    2067            renderer.setURLGenerator(new StandardXYZURLGenerator());
    2068        }
    2069        plot.setRenderer(renderer);
    2070        plot.setOrientation(orientation);
    2071
    2072        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    2073                plot, legend);
    2074        currentTheme.apply(chart);
    2075        return chart;
    2076
    2077    }
    2078
    2079    /**
    2080     * Creates a histogram chart.  This chart is constructed with an
    2081     * {@link XYPlot} using an {@link XYBarRenderer}.  The domain and range
    2082     * axes are {@link NumberAxis} instances.
    2083     *
    2084     * @param title  the chart title (<code>null</code> permitted).
    2085     * @param xAxisLabel  the x axis label (<code>null</code> permitted).
    2086     * @param yAxisLabel  the y axis label (<code>null</code> permitted).
    2087     * @param dataset  the dataset (<code>null</code> permitted).
    2088     * @param orientation  the orientation (horizontal or vertical)
    2089     *                     (<code>null</code> NOT permitted).
    2090     * @param legend  create a legend?
    2091     * @param tooltips  display tooltips?
    2092     * @param urls  generate URLs?
    2093     *
    2094     * @return The chart.
    2095     */
    2096    public static JFreeChart createHistogram(String title,
    2097            String xAxisLabel, String yAxisLabel, IntervalXYDataset dataset,
    2098            PlotOrientation orientation, boolean legend, boolean tooltips,
    2099            boolean urls) {
    2100
    2101        if (orientation == null) {
    2102            throw new IllegalArgumentException("Null 'orientation' argument.");
    2103        }
    2104        NumberAxis xAxis = new NumberAxis(xAxisLabel);
    2105        xAxis.setAutoRangeIncludesZero(false);
    2106        ValueAxis yAxis = new NumberAxis(yAxisLabel);
    2107
    2108        XYItemRenderer renderer = new XYBarRenderer();
    2109        if (tooltips) {
    2110            renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
    2111        }
    2112        if (urls) {
    2113            renderer.setURLGenerator(new StandardXYURLGenerator());
    2114        }
    2115
    2116        XYPlot plot = new XYPlot(dataset, xAxis, yAxis, renderer);
    2117        plot.setOrientation(orientation);
    2118        plot.setDomainZeroBaselineVisible(true);
    2119        plot.setRangeZeroBaselineVisible(true);
    2120        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    2121                plot, legend);
    2122        currentTheme.apply(chart);
    2123        return chart;
    2124
    2125    }
    2126
    2127    /**
    2128     * Creates and returns a default instance of a box and whisker chart
    2129     * based on data from a {@link BoxAndWhiskerCategoryDataset}.
    2130     *
    2131     * @param title  the chart title (<code>null</code> permitted).
    2132     * @param categoryAxisLabel  a label for the category axis
    2133     *     (<code>null</code> permitted).
    2134     * @param valueAxisLabel  a label for the value axis (<code>null</code>
    2135     *     permitted).
    2136     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    2137     * @param legend  a flag specifying whether or not a legend is required.
    2138     *
    2139     * @return A box and whisker chart.
    2140     *
    2141     * @since 1.0.4
    2142     */
    2143    public static JFreeChart createBoxAndWhiskerChart(String title,
    2144            String categoryAxisLabel, String valueAxisLabel,
    2145            BoxAndWhiskerCategoryDataset dataset, boolean legend) {
    2146
    2147        CategoryAxis categoryAxis = new CategoryAxis(categoryAxisLabel);
    2148        NumberAxis valueAxis = new NumberAxis(valueAxisLabel);
    2149        valueAxis.setAutoRangeIncludesZero(false);
    2150
    2151        BoxAndWhiskerRenderer renderer = new BoxAndWhiskerRenderer();
    2152        renderer.setBaseToolTipGenerator(new BoxAndWhiskerToolTipGenerator());
    2153
    2154        CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, valueAxis,
    2155                renderer);
    2156        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    2157                plot, legend);
    2158        currentTheme.apply(chart);
    2159        return chart;
    2160    }
    2161
    2162    /**
    2163     * Creates and returns a default instance of a box and whisker chart.
    2164     *
    2165     * @param title  the chart title (<code>null</code> permitted).
    2166     * @param timeAxisLabel  a label for the time axis (<code>null</code>
    2167     *                       permitted).
    2168     * @param valueAxisLabel  a label for the value axis (<code>null</code>
    2169     *                        permitted).
    2170     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    2171     * @param legend  a flag specifying whether or not a legend is required.
    2172     *
    2173     * @return A box and whisker chart.
    2174     */
    2175    public static JFreeChart createBoxAndWhiskerChart(String title,
    2176                                                 String timeAxisLabel,
    2177                                                 String valueAxisLabel,
    2178                                                 BoxAndWhiskerXYDataset dataset,
    2179                                                 boolean legend) {
    2180
    2181        ValueAxis timeAxis = new DateAxis(timeAxisLabel);
    2182        NumberAxis valueAxis = new NumberAxis(valueAxisLabel);
    2183        valueAxis.setAutoRangeIncludesZero(false);
    2184        XYBoxAndWhiskerRenderer renderer = new XYBoxAndWhiskerRenderer(10.0);
    2185        XYPlot plot = new XYPlot(dataset, timeAxis, valueAxis, renderer);
    2186        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    2187                plot, legend);
    2188        currentTheme.apply(chart);
    2189        return chart;
    2190
    2191    }
    2192
    2193    /**
    2194     * Creates a wind plot with default settings.
    2195     *
    2196     * @param title  the chart title (<code>null</code> permitted).
    2197     * @param xAxisLabel  a label for the x-axis (<code>null</code> permitted).
    2198     * @param yAxisLabel  a label for the y-axis (<code>null</code> permitted).
    2199     * @param dataset  the dataset for the chart (<code>null</code> permitted).
    2200     * @param legend  a flag that controls whether or not a legend is created.
    2201     * @param tooltips  configure chart to generate tool tips?
    2202     * @param urls  configure chart to generate URLs?
    2203     *
    2204     * @return A wind plot.
    2205     *
    2206     */
    2207    public static JFreeChart createWindPlot(String title,
    2208                                            String xAxisLabel,
    2209                                            String yAxisLabel,
    2210                                            WindDataset dataset,
    2211                                            boolean legend,
    2212                                            boolean tooltips,
    2213                                            boolean urls) {
    2214
    2215        ValueAxis xAxis = new DateAxis(xAxisLabel);
    2216        ValueAxis yAxis = new NumberAxis(yAxisLabel);
    2217        yAxis.setRange(-12.0, 12.0);
    2218
    2219        WindItemRenderer renderer = new WindItemRenderer();
    2220        if (tooltips) {
    2221            renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
    2222        }
    2223        if (urls) {
    2224            renderer.setURLGenerator(new StandardXYURLGenerator());
    2225        }
    2226        XYPlot plot = new XYPlot(dataset, xAxis, yAxis, renderer);
    2227        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    2228                plot, legend);
    2229        currentTheme.apply(chart);
    2230        return chart;
    2231
    2232    }
    2233
    2234    /**
    2235     * Creates a wafer map chart.
    2236     *
    2237     * @param title  the chart title (<code>null</code> permitted).
    2238     * @param dataset  the dataset (<code>null</code> permitted).
    2239     * @param orientation  the plot orientation (horizontal or vertical)
    2240     *                     (<code>null</code> NOT permitted.
    2241     * @param legend  display a legend?
    2242     * @param tooltips  generate tooltips?
    2243     * @param urls  generate URLs?
    2244     *
    2245     * @return A wafer map chart.
    2246     */
    2247    public static JFreeChart createWaferMapChart(String title,
    2248                                                 WaferMapDataset dataset,
    2249                                                 PlotOrientation orientation,
    2250                                                 boolean legend,
    2251                                                 boolean tooltips,
    2252                                                 boolean urls) {
    2253
    2254        if (orientation == null) {
    2255            throw new IllegalArgumentException("Null 'orientation' argument.");
    2256        }
    2257        WaferMapPlot plot = new WaferMapPlot(dataset);
    2258        WaferMapRenderer renderer = new WaferMapRenderer();
    2259        plot.setRenderer(renderer);
    2260
    2261        JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT,
    2262                plot, legend);
    2263        currentTheme.apply(chart);
    2264        return chart;
    2265    }
    2266
    2267}