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