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