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