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