001 /* =========================================================== 002 * JFreeChart : a free chart library for the Java(tm) platform 003 * =========================================================== 004 * 005 * (C) Copyright 2000-2008, by Object Refinery Limited and Contributors. 006 * 007 * Project Info: http://www.jfree.org/jfreechart/index.html 008 * 009 * This library is free software; you can redistribute it and/or modify it 010 * under the terms of the GNU Lesser General Public License as published by 011 * the Free Software Foundation; either version 2.1 of the License, or 012 * (at your option) any later version. 013 * 014 * This library is distributed in the hope that it will be useful, but 015 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 016 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 017 * License for more details. 018 * 019 * You should have received a copy of the GNU Lesser General Public 020 * License along with this library; if not, write to the Free Software 021 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 022 * USA. 023 * 024 * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 025 * in the United States and other countries.] 026 * 027 * ----------------------- 028 * StandardChartTheme.java 029 * ----------------------- 030 * (C) Copyright 2008, by Object Refinery Limited. 031 * 032 * Original Author: David Gilbert (for Object Refinery Limited); 033 * Contributor(s): -; 034 * 035 * Changes 036 * ------- 037 * 14-Aug-2008 : Version 1 (DG); 038 * 039 */ 040 041 package org.jfree.chart; 042 043 import java.awt.BasicStroke; 044 import java.awt.Color; 045 import java.awt.Font; 046 import java.awt.Paint; 047 import java.awt.Stroke; 048 import java.io.IOException; 049 import java.io.ObjectInputStream; 050 import java.io.ObjectOutputStream; 051 import java.io.Serializable; 052 import java.util.Iterator; 053 import java.util.List; 054 055 import org.jfree.chart.annotations.XYAnnotation; 056 import org.jfree.chart.annotations.XYTextAnnotation; 057 import org.jfree.chart.axis.CategoryAxis; 058 import org.jfree.chart.axis.PeriodAxis; 059 import org.jfree.chart.axis.PeriodAxisLabelInfo; 060 import org.jfree.chart.axis.SubCategoryAxis; 061 import org.jfree.chart.axis.SymbolAxis; 062 import org.jfree.chart.axis.ValueAxis; 063 import org.jfree.chart.block.Block; 064 import org.jfree.chart.block.BlockContainer; 065 import org.jfree.chart.block.LabelBlock; 066 import org.jfree.chart.plot.CategoryPlot; 067 import org.jfree.chart.plot.CombinedDomainCategoryPlot; 068 import org.jfree.chart.plot.CombinedDomainXYPlot; 069 import org.jfree.chart.plot.CombinedRangeCategoryPlot; 070 import org.jfree.chart.plot.CombinedRangeXYPlot; 071 import org.jfree.chart.plot.DefaultDrawingSupplier; 072 import org.jfree.chart.plot.DrawingSupplier; 073 import org.jfree.chart.plot.FastScatterPlot; 074 import org.jfree.chart.plot.MeterPlot; 075 import org.jfree.chart.plot.MultiplePiePlot; 076 import org.jfree.chart.plot.PieLabelLinkStyle; 077 import org.jfree.chart.plot.PiePlot; 078 import org.jfree.chart.plot.Plot; 079 import org.jfree.chart.plot.PolarPlot; 080 import org.jfree.chart.plot.SpiderWebPlot; 081 import org.jfree.chart.plot.ThermometerPlot; 082 import org.jfree.chart.plot.XYPlot; 083 import org.jfree.chart.renderer.AbstractRenderer; 084 import org.jfree.chart.renderer.category.BarPainter; 085 import org.jfree.chart.renderer.category.BarRenderer; 086 import org.jfree.chart.renderer.category.BarRenderer3D; 087 import org.jfree.chart.renderer.category.CategoryItemRenderer; 088 import org.jfree.chart.renderer.category.GradientBarPainter; 089 import org.jfree.chart.renderer.category.LineRenderer3D; 090 import org.jfree.chart.renderer.category.MinMaxCategoryRenderer; 091 import org.jfree.chart.renderer.category.StatisticalBarRenderer; 092 import org.jfree.chart.renderer.xy.GradientXYBarPainter; 093 import org.jfree.chart.renderer.xy.XYBarPainter; 094 import org.jfree.chart.renderer.xy.XYBarRenderer; 095 import org.jfree.chart.renderer.xy.XYItemRenderer; 096 import org.jfree.chart.title.CompositeTitle; 097 import org.jfree.chart.title.LegendTitle; 098 import org.jfree.chart.title.PaintScaleLegend; 099 import org.jfree.chart.title.TextTitle; 100 import org.jfree.chart.title.Title; 101 import org.jfree.io.SerialUtilities; 102 import org.jfree.ui.RectangleInsets; 103 import org.jfree.util.PaintUtilities; 104 import org.jfree.util.PublicCloneable; 105 106 /** 107 * A default implementation of the {@link ChartTheme} interface. This 108 * implementation just collects a whole bunch of chart attributes and mimics 109 * the manual process of applying each attribute to the right sub-object 110 * within the JFreeChart instance. It's not elegant code, but it works. 111 * 112 * @since 1.0.11 113 */ 114 public class StandardChartTheme implements ChartTheme, Cloneable, 115 PublicCloneable, Serializable { 116 117 /** The name of this theme. */ 118 private String name; 119 120 /** 121 * The largest font size. Use for the main chart title. 122 */ 123 private Font extraLargeFont; 124 125 /** 126 * A large font. Used for subtitles. 127 */ 128 private Font largeFont; 129 130 /** 131 * The regular font size. Used for axis tick labels, legend items etc. 132 */ 133 private Font regularFont; 134 135 /** 136 * The small font size. 137 */ 138 private Font smallFont; 139 140 /** The paint used to display the main chart title. */ 141 private transient Paint titlePaint; 142 143 /** The paint used to display subtitles. */ 144 private transient Paint subtitlePaint; 145 146 /** The background paint for the chart. */ 147 private transient Paint chartBackgroundPaint; 148 149 /** The legend background paint. */ 150 private transient Paint legendBackgroundPaint; 151 152 /** The legend item paint. */ 153 private transient Paint legendItemPaint; 154 155 /** The drawing supplier. */ 156 private DrawingSupplier drawingSupplier; 157 158 /** The background paint for the plot. */ 159 private transient Paint plotBackgroundPaint; 160 161 /** The plot outline paint. */ 162 private transient Paint plotOutlinePaint; 163 164 /** The label link style for pie charts. */ 165 private PieLabelLinkStyle labelLinkStyle; 166 167 /** The label link paint for pie charts. */ 168 private transient Paint labelLinkPaint; 169 170 /** The domain grid line paint. */ 171 private transient Paint domainGridlinePaint; 172 173 /** The range grid line paint. */ 174 private transient Paint rangeGridlinePaint; 175 176 /** The crosshair paint. */ 177 private transient Paint crosshairPaint; 178 179 /** The axis offsets. */ 180 private RectangleInsets axisOffset; 181 182 /** The axis label paint. */ 183 private transient Paint axisLabelPaint; 184 185 /** The tick label paint. */ 186 private transient Paint tickLabelPaint; 187 188 /** The item label paint. */ 189 private transient Paint itemLabelPaint; 190 191 /** 192 * A flag that controls whether or not shadows are visible (for example, 193 * in a bar renderer). 194 */ 195 private boolean shadowVisible; 196 197 /** The shadow paint. */ 198 private transient Paint shadowPaint; 199 200 /** The bar painter. */ 201 private BarPainter barPainter; 202 203 /** The XY bar painter. */ 204 private XYBarPainter xyBarPainter; 205 206 /** The thermometer paint. */ 207 private transient Paint thermometerPaint; 208 209 /** 210 * The paint used to fill the interior of the 'walls' in the background 211 * of a plot with a 3D effect. Applied to BarRenderer3D. 212 */ 213 private transient Paint wallPaint; 214 215 /** The error indicator paint for the {@link StatisticalBarRenderer}. */ 216 private transient Paint errorIndicatorPaint; 217 218 /** The grid band paint for a {@link SymbolAxis}. */ 219 private transient Paint gridBandPaint = SymbolAxis.DEFAULT_GRID_BAND_PAINT; 220 221 /** The grid band alternate paint for a {@link SymbolAxis}. */ 222 private transient Paint gridBandAlternatePaint 223 = SymbolAxis.DEFAULT_GRID_BAND_ALTERNATE_PAINT; 224 225 /** 226 * Creates and returns the default 'JFree' chart theme. 227 * 228 * @return A chart theme. 229 */ 230 public static ChartTheme createJFreeTheme() { 231 return new StandardChartTheme("JFree"); 232 } 233 234 /** 235 * Creates and returns a theme called "Darkness". In this theme, the 236 * charts have a black background. 237 * 238 * @return The "Darkness" theme. 239 */ 240 public static ChartTheme createDarknessTheme() { 241 StandardChartTheme theme = new StandardChartTheme("Darkness"); 242 theme.titlePaint = Color.white; 243 theme.subtitlePaint = Color.white; 244 theme.legendBackgroundPaint = Color.black; 245 theme.legendItemPaint = Color.white; 246 theme.chartBackgroundPaint = Color.black; 247 theme.plotBackgroundPaint = Color.black; 248 theme.plotOutlinePaint = Color.yellow; 249 theme.crosshairPaint = Color.red; 250 theme.labelLinkPaint = Color.lightGray; 251 theme.tickLabelPaint = Color.white; 252 theme.axisLabelPaint = Color.white; 253 theme.shadowPaint = Color.darkGray; 254 theme.itemLabelPaint = Color.white; 255 theme.drawingSupplier = new DefaultDrawingSupplier( 256 new Paint[] { Color.decode("0xFFFF00"), 257 Color.decode("0x0036CC"), Color.decode("0xFF0000"), 258 Color.decode("0xFFFF7F"), Color.decode("0x6681CC"), 259 Color.decode("0xFF7F7F"), Color.decode("0xFFFFBF"), 260 Color.decode("0x99A6CC"), Color.decode("0xFFBFBF"), 261 Color.decode("0xA9A938"), Color.decode("0x2D4587")}, 262 new Paint[] { Color.decode("0xFFFF00"), 263 Color.decode("0x0036CC")}, 264 new Stroke[] { new BasicStroke(2.0f)}, 265 new Stroke[] { new BasicStroke(0.5f)}, 266 DefaultDrawingSupplier.DEFAULT_SHAPE_SEQUENCE); 267 theme.wallPaint = Color.darkGray; 268 theme.errorIndicatorPaint = Color.lightGray; 269 theme.gridBandPaint = new Color(255, 255, 255, 20); 270 theme.gridBandAlternatePaint = new Color(255, 255, 255, 40); 271 return theme; 272 } 273 /** 274 * Creates and returns a {@link ChartTheme} that doesn't apply any changes 275 * to the JFreeChart defaults. This produces the "legacy" look for 276 * JFreeChart. 277 * 278 * @return A legacy theme. 279 */ 280 public static ChartTheme createLegacyTheme() { 281 StandardChartTheme theme = new StandardChartTheme("Legacy") { 282 public void apply(JFreeChart chart) { 283 // do nothing at all 284 } 285 }; 286 return theme; 287 } 288 289 /** 290 * Creates a new default instance. 291 * 292 * @param name the name of the theme (<code>null</code> not permitted). 293 */ 294 public StandardChartTheme(String name) { 295 if (name == null) { 296 throw new IllegalArgumentException("Null 'name' argument."); 297 } 298 this.name = name; 299 this.extraLargeFont = new Font("Tahoma", Font.BOLD, 20); 300 this.largeFont = new Font("Tahoma", Font.BOLD, 14); 301 this.regularFont = new Font("Tahoma", Font.PLAIN, 12); 302 this.smallFont = new Font("Tahoma", Font.PLAIN, 10); 303 this.titlePaint = Color.black; 304 this.subtitlePaint = Color.black; 305 this.legendBackgroundPaint = Color.white; 306 this.legendItemPaint = Color.darkGray; 307 this.chartBackgroundPaint = Color.white; 308 this.drawingSupplier = new DefaultDrawingSupplier(); 309 this.plotBackgroundPaint = Color.lightGray; 310 this.plotOutlinePaint = Color.black; 311 this.labelLinkPaint = Color.black; 312 this.labelLinkStyle = PieLabelLinkStyle.CUBIC_CURVE; 313 this.axisOffset = new RectangleInsets(4, 4, 4, 4); 314 this.domainGridlinePaint = Color.white; 315 this.rangeGridlinePaint = Color.white; 316 this.crosshairPaint = Color.blue; 317 this.axisLabelPaint = Color.darkGray; 318 this.tickLabelPaint = Color.darkGray; 319 this.barPainter = new GradientBarPainter(); 320 this.xyBarPainter = new GradientXYBarPainter(); 321 this.shadowVisible = true; 322 this.shadowPaint = Color.gray; 323 this.itemLabelPaint = Color.black; 324 this.thermometerPaint = Color.white; 325 this.wallPaint = BarRenderer3D.DEFAULT_WALL_PAINT; 326 this.errorIndicatorPaint = Color.black; 327 } 328 329 /** 330 * Returns the largest font for this theme. 331 * 332 * @return The largest font for this theme. 333 * 334 * @see #setExtraLargeFont(Font) 335 */ 336 public Font getExtraLargeFont() { 337 return this.extraLargeFont; 338 } 339 340 /** 341 * Sets the largest font for this theme. 342 * 343 * @param font the font (<code>null</code> not permitted). 344 * 345 * @see #getExtraLargeFont() 346 */ 347 public void setExtraLargeFont(Font font) { 348 if (font == null) { 349 throw new IllegalArgumentException("Null 'font' argument."); 350 } 351 this.extraLargeFont = font; 352 } 353 354 /** 355 * Returns the large font for this theme. 356 * 357 * @return The large font (never <code>null</code>). 358 * 359 * @see #setLargeFont(Font) 360 */ 361 public Font getLargeFont() { 362 return this.largeFont; 363 } 364 365 /** 366 * Sets the large font for this theme. 367 * 368 * @param font the font (<code>null</code> not permitted). 369 * 370 * @see #getLargeFont() 371 */ 372 public void setLargeFont(Font font) { 373 this.largeFont = font; 374 } 375 376 /** 377 * Returns the regular font. 378 * 379 * @return The regular font (never <code>null</code>). 380 * 381 * @see #setRegularFont(Font) 382 */ 383 public Font getRegularFont() { 384 return this.regularFont; 385 } 386 387 /** 388 * Sets the regular font for this theme. 389 * 390 * @param font the font (<code>null</code> not permitted). 391 * 392 * @see #getRegularFont() 393 */ 394 public void setRegularFont(Font font) { 395 this.regularFont = font; 396 } 397 398 /** 399 * Returns the title paint. 400 * 401 * @return The title paint (never <code>null</code>). 402 * 403 * @see #setTitlePaint(Paint) 404 */ 405 public Paint getTitlePaint() { 406 return this.titlePaint; 407 } 408 409 /** 410 * Sets the title paint. 411 * 412 * @param paint the paint (<code>null</code> not permitted). 413 * 414 * @see #getTitlePaint() 415 */ 416 public void setTitlePaint(Paint paint) { 417 if (paint == null) { 418 throw new IllegalArgumentException("Null 'paint' argument."); 419 } 420 this.titlePaint = paint; 421 } 422 423 /** 424 * Returns the subtitle paint. 425 * 426 * @return The subtitle paint (never <code>null</code>). 427 * 428 * @see #setSubtitlePaint(Paint) 429 */ 430 public Paint getSubtitlePaint() { 431 return this.subtitlePaint; 432 } 433 434 /** 435 * Sets the subtitle paint. 436 * 437 * @param paint the paint (<code>null</code> not permitted). 438 * 439 * @see #getSubtitlePaint() 440 */ 441 public void setSubtitlePaint(Paint paint) { 442 if (paint == null) { 443 throw new IllegalArgumentException("Null 'paint' argument."); 444 } 445 this.subtitlePaint = paint; 446 } 447 448 /** 449 * Returns the chart background paint. 450 * 451 * @return The chart background paint (never <code>null</code>). 452 * 453 * @see #setChartBackgroundPaint(Paint) 454 */ 455 public Paint getChartBackgroundPaint() { 456 return this.chartBackgroundPaint; 457 } 458 459 /** 460 * Sets the chart background paint. 461 * 462 * @param paint the paint (<code>null</code> not permitted). 463 * 464 * @see #getChartBackgroundPaint() 465 */ 466 public void setChartBackgroundPaint(Paint paint) { 467 if (paint == null) { 468 throw new IllegalArgumentException("Null 'paint' argument."); 469 } 470 this.chartBackgroundPaint = paint; 471 } 472 473 /** 474 * Returns the legend background paint. 475 * 476 * @return The legend background paint (never <code>null</code>). 477 * 478 * @see #setLegendBackgroundPaint(Paint) 479 */ 480 public Paint getLegendBackgroundPaint() { 481 return this.legendBackgroundPaint; 482 } 483 484 /** 485 * Sets the legend background paint. 486 * 487 * @param paint the paint (<code>null</code> not permitted). 488 * 489 * @see #getLegendBackgroundPaint() 490 */ 491 public void setLegendBackgroundPaint(Paint paint) { 492 if (paint == null) { 493 throw new IllegalArgumentException("Null 'paint' argument."); 494 } 495 this.legendBackgroundPaint = paint; 496 } 497 498 /** 499 * Returns the legend item paint. 500 * 501 * @return The legend item paint (never <code>null</code>). 502 * 503 * @see #setLegendItemPaint(Paint) 504 */ 505 public Paint getLegendItemPaint() { 506 return this.legendItemPaint; 507 } 508 509 /** 510 * Sets the legend item paint. 511 * 512 * @param paint the paint (<code>null</code> not permitted). 513 * 514 * @see #getLegendItemPaint() 515 */ 516 public void setLegendItemPaint(Paint paint) { 517 if (paint == null) { 518 throw new IllegalArgumentException("Null 'paint' argument."); 519 } 520 this.legendItemPaint = paint; 521 } 522 523 /** 524 * Returns the plot background paint. 525 * 526 * @return The plot background paint (never <code>null</code>). 527 * 528 * @see #setPlotBackgroundPaint(Paint) 529 */ 530 public Paint getPlotBackgroundPaint() { 531 return this.plotBackgroundPaint; 532 } 533 534 /** 535 * Sets the plot background paint. 536 * 537 * @param paint the paint (<code>null</code> not permitted). 538 * 539 * @see #getPlotBackgroundPaint() 540 */ 541 public void setPlotBackgroundPaint(Paint paint) { 542 if (paint == null) { 543 throw new IllegalArgumentException("Null 'paint' argument."); 544 } 545 this.plotBackgroundPaint = paint; 546 } 547 548 /** 549 * Returns the plot outline paint. 550 * 551 * @return The plot outline paint (never <code>null</code>). 552 * 553 * @see #setPlotOutlinePaint(Paint) 554 */ 555 public Paint getPlotOutlinePaint() { 556 return this.plotOutlinePaint; 557 } 558 559 /** 560 * Sets the plot outline paint. 561 * 562 * @param paint the paint (<code>null</code> not permitted). 563 * 564 * @see #getPlotOutlinePaint() 565 */ 566 public void setPlotOutlinePaint(Paint paint) { 567 if (paint == null) { 568 throw new IllegalArgumentException("Null 'paint' argument."); 569 } 570 this.plotOutlinePaint = paint; 571 } 572 573 /** 574 * Returns the label link style for pie charts. 575 * 576 * @return The label link style (never <code>null</code>). 577 * 578 * @see #setLabelLinkStyle(PieLabelLinkStyle) 579 */ 580 public PieLabelLinkStyle getLabelLinkStyle() { 581 return this.labelLinkStyle; 582 } 583 584 /** 585 * Sets the label link style for pie charts. 586 * 587 * @param style the style (<code>null</code> not permitted). 588 * 589 * @see #getLabelLinkStyle() 590 */ 591 public void setLabelLinkStyle(PieLabelLinkStyle style) { 592 if (style == null) { 593 throw new IllegalArgumentException("Null 'style' argument."); 594 } 595 this.labelLinkStyle = style; 596 } 597 598 /** 599 * Returns the label link paint for pie charts. 600 * 601 * @return The label link paint (never <code>null</code>). 602 * 603 * @see #setLabelLinkPaint(Paint) 604 */ 605 public Paint getLabelLinkPaint() { 606 return this.labelLinkPaint; 607 } 608 609 /** 610 * Sets the label link paint for pie charts. 611 * 612 * @param paint the paint (<code>null</code> not permitted). 613 * 614 * @see #getLabelLinkPaint() 615 */ 616 public void setLabelLinkPaint(Paint paint) { 617 if (paint == null) { 618 throw new IllegalArgumentException("Null 'paint' argument."); 619 } 620 this.labelLinkPaint = paint; 621 } 622 623 /** 624 * Returns the domain grid line paint. 625 * 626 * @return The domain grid line paint (never <code>null<code>). 627 * 628 * @see #setDomainGridlinePaint(Paint) 629 */ 630 public Paint getDomainGridlinePaint() { 631 return this.domainGridlinePaint; 632 } 633 634 /** 635 * Sets the domain grid line paint. 636 * 637 * @param paint the paint (<code>null</code> not permitted). 638 * 639 * @see #getDomainGridlinePaint() 640 */ 641 public void setDomainGridlinePaint(Paint paint) { 642 if (paint == null) { 643 throw new IllegalArgumentException("Null 'paint' argument."); 644 } 645 this.domainGridlinePaint = paint; 646 } 647 648 /** 649 * Returns the range grid line paint. 650 * 651 * @return The range grid line paint (never <code>null</code>). 652 * 653 * @see #setRangeGridlinePaint(Paint) 654 */ 655 public Paint getRangeGridlinePaint() { 656 return this.rangeGridlinePaint; 657 } 658 659 /** 660 * Sets the range grid line paint. 661 * 662 * @param paint the paint (<code>null</code> not permitted). 663 * 664 * @see #getRangeGridlinePaint() 665 */ 666 public void setRangeGridlinePaint(Paint paint) { 667 if (paint == null) { 668 throw new IllegalArgumentException("Null 'paint' argument."); 669 } 670 this.rangeGridlinePaint = paint; 671 } 672 673 /** 674 * Returns the crosshair paint. 675 * 676 * @return The crosshair paint. 677 */ 678 public Paint getCrosshairPaint() { 679 return this.crosshairPaint; 680 } 681 682 /** 683 * Sets the crosshair paint. 684 * 685 * @param paint the paint (<code>null</code> not permitted). 686 */ 687 public void setCrosshairPaint(Paint paint) { 688 if (paint == null) { 689 throw new IllegalArgumentException("Null 'paint' argument."); 690 } 691 this.crosshairPaint = paint; 692 } 693 694 /** 695 * Returns the axis offsets. 696 * 697 * @return The axis offsets (never <code>null</code>). 698 * 699 * @see #setAxisOffset(RectangleInsets) 700 */ 701 public RectangleInsets getAxisOffset() { 702 return this.axisOffset; 703 } 704 705 /** 706 * Sets the axis offset. 707 * 708 * @param offset the offset (<code>null</code> not permitted). 709 * 710 * @see #getAxisOffset() 711 */ 712 public void setAxisOffset(RectangleInsets offset) { 713 if (offset == null) { 714 throw new IllegalArgumentException("Null 'offset' argument."); 715 } 716 this.axisOffset = offset; 717 } 718 719 /** 720 * Returns the axis label paint. 721 * 722 * @return The axis label paint (never <code>null</code>). 723 * 724 * @see #setAxisLabelPaint(Paint) 725 */ 726 public Paint getAxisLabelPaint() { 727 return this.axisLabelPaint; 728 } 729 730 /** 731 * Sets the axis label paint. 732 * 733 * @param paint the paint (<code>null</code> not permitted). 734 * 735 * @see #getAxisLabelPaint() 736 */ 737 public void setAxisLabelPaint(Paint paint) { 738 if (paint == null) { 739 throw new IllegalArgumentException("Null 'paint' argument."); 740 } 741 this.axisLabelPaint = paint; 742 } 743 744 /** 745 * Returns the tick label paint. 746 * 747 * @return The tick label paint (never <code>null</code>). 748 * 749 * @see #setTickLabelPaint(Paint) 750 */ 751 public Paint getTickLabelPaint() { 752 return this.tickLabelPaint; 753 } 754 755 /** 756 * Sets the tick label paint. 757 * 758 * @param paint the paint (<code>null</code> not permitted). 759 * 760 * @see #getTickLabelPaint() 761 */ 762 public void setTickLabelPaint(Paint paint) { 763 if (paint == null) { 764 throw new IllegalArgumentException("Null 'paint' argument."); 765 } 766 this.tickLabelPaint = paint; 767 } 768 769 /** 770 * Returns the item label paint. 771 * 772 * @return The item label paint (never <code>null</code>). 773 * 774 * @see #setItemLabelPaint(Paint) 775 */ 776 public Paint getItemLabelPaint() { 777 return this.itemLabelPaint; 778 } 779 780 /** 781 * Sets the item label paint. 782 * 783 * @param paint the paint (<code>null</code> not permitted). 784 * 785 * @see #getItemLabelPaint() 786 */ 787 public void setItemLabelPaint(Paint paint) { 788 if (paint == null) { 789 throw new IllegalArgumentException("Null 'paint' argument."); 790 } 791 this.itemLabelPaint = paint; 792 } 793 794 /** 795 * Returns the shadow visibility flag. 796 * 797 * @return The shadow visibility flag. 798 * 799 * @see #setShadowVisible(boolean) 800 */ 801 public boolean isShadowVisible() { 802 return this.shadowVisible; 803 } 804 805 /** 806 * Sets the shadow visibility flag. 807 * 808 * @param visible the flag. 809 * 810 * @see #isShadowVisible() 811 */ 812 public void setShadowVisible(boolean visible) { 813 this.shadowVisible = visible; 814 } 815 816 /** 817 * Returns the shadow paint. 818 * 819 * @return The shadow paint (never <code>null</code>). 820 * 821 * @see #setShadowPaint(Paint) 822 */ 823 public Paint getShadowPaint() { 824 return this.shadowPaint; 825 } 826 827 /** 828 * Sets the shadow paint. 829 * 830 * @param paint the paint (<code>null</code> not permitted). 831 * 832 * @see #getShadowPaint() 833 */ 834 public void setShadowPaint(Paint paint) { 835 if (paint == null) { 836 throw new IllegalArgumentException("Null 'paint' argument."); 837 } 838 this.shadowPaint = paint; 839 } 840 841 /** 842 * Returns the bar painter. 843 * 844 * @return The bar painter (never <code>null</code>). 845 * 846 * @see #setBarPainter(BarPainter) 847 */ 848 public BarPainter getBarPainter() { 849 return this.barPainter; 850 } 851 852 /** 853 * Sets the bar painter. 854 * 855 * @param painter the painter (<code>null</code> not permitted). 856 * 857 * @see #getBarPainter() 858 */ 859 public void setBarPainter(BarPainter painter) { 860 if (painter == null) { 861 throw new IllegalArgumentException("Null 'painter' argument."); 862 } 863 this.barPainter = painter; 864 } 865 866 /** 867 * Returns the XY bar painter. 868 * 869 * @return The XY bar painter (never <code>null</code>). 870 * 871 * @see #setXYBarPainter(XYBarPainter) 872 */ 873 public XYBarPainter getXYBarPainter() { 874 return this.xyBarPainter; 875 } 876 877 /** 878 * Sets the XY bar painter. 879 * 880 * @param painter the painter (<code>null</code> not permitted). 881 * 882 * @see #getXYBarPainter() 883 */ 884 public void setXYBarPainter(XYBarPainter painter) { 885 if (painter == null) { 886 throw new IllegalArgumentException("Null 'painter' argument."); 887 } 888 this.xyBarPainter = painter; 889 } 890 891 /** 892 * Returns the thermometer paint. 893 * 894 * @return The thermometer paint (never <code>null</code>). 895 * 896 * @see #setThermometerPaint(Paint) 897 */ 898 public Paint getThermometerPaint() { 899 return this.thermometerPaint; 900 } 901 902 /** 903 * Sets the thermometer paint. 904 * 905 * @param paint the paint (<code>null</code> not permitted). 906 * 907 * @see #getThermometerPaint() 908 */ 909 public void setThermometerPaint(Paint paint) { 910 if (paint == null) { 911 throw new IllegalArgumentException("Null 'paint' argument."); 912 } 913 this.thermometerPaint = paint; 914 } 915 916 /** 917 * Returns the wall paint for charts with a 3D effect. 918 * 919 * @return The wall paint (never <code>null</code>). 920 * 921 * @see #setWallPaint(Paint) 922 */ 923 public Paint getWallPaint() { 924 return this.wallPaint; 925 } 926 927 /** 928 * Sets the wall paint for charts with a 3D effect. 929 * 930 * @param paint the paint (<code>null</code> not permitted). 931 * 932 * @see #getWallPaint() 933 */ 934 public void setWallPaint(Paint paint) { 935 if (paint == null) { 936 throw new IllegalArgumentException("Null 'paint' argument."); 937 } 938 this.wallPaint = paint; 939 } 940 941 /** 942 * Returns the error indicator paint. 943 * 944 * @return The error indicator paint (never <code>null</code>). 945 * 946 * @see #setErrorIndicatorPaint(Paint) 947 */ 948 public Paint getErrorIndicatorPaint() { 949 return this.errorIndicatorPaint; 950 } 951 952 /** 953 * Sets the error indicator paint. 954 * 955 * @param paint the paint (<code>null</code> not permitted). 956 * 957 * @see #getErrorIndicatorPaint() 958 */ 959 public void setErrorIndicatorPaint(Paint paint) { 960 if (paint == null) { 961 throw new IllegalArgumentException("Null 'paint' argument."); 962 } 963 this.errorIndicatorPaint = paint; 964 } 965 966 /** 967 * Returns the grid band paint. 968 * 969 * @return The grid band paint (never <code>null</code>). 970 * 971 * @see #setGridBandPaint(Paint) 972 */ 973 public Paint getGridBandPaint() { 974 return this.gridBandPaint; 975 } 976 977 /** 978 * Sets the grid band paint. 979 * 980 * @param paint the paint (<code>null</code> not permitted). 981 * 982 * @see #getGridBandPaint() 983 */ 984 public void setGridBandPaint(Paint paint) { 985 if (paint == null) { 986 throw new IllegalArgumentException("Null 'paint' argument."); 987 } 988 this.gridBandPaint = paint; 989 } 990 991 /** 992 * Returns the grid band alternate paint (used for a {@link SymbolAxis}). 993 * 994 * @return The paint (never <code>null</code>). 995 * 996 * @see #setGridBandAlternatePaint(Paint) 997 */ 998 public Paint getGridBandAlternatePaint() { 999 return this.gridBandAlternatePaint; 1000 } 1001 1002 /** 1003 * Sets the grid band alternate paint (used for a {@link SymbolAxis}). 1004 * 1005 * @param paint the paint (<code>null</code> not permitted). 1006 * 1007 * @see #getGridBandAlternatePaint() 1008 */ 1009 public void setGridBandAlternatePaint(Paint paint) { 1010 if (paint == null) { 1011 throw new IllegalArgumentException("Null 'paint' argument."); 1012 } 1013 this.gridBandAlternatePaint = paint; 1014 } 1015 1016 /** 1017 * Returns the name of this theme. 1018 * 1019 * @return The name of this theme. 1020 */ 1021 public String getName() { 1022 return this.name; 1023 } 1024 1025 /** 1026 * Returns a clone of the drawing supplier for this theme. 1027 * 1028 * @return A clone of the drawing supplier. 1029 */ 1030 public DrawingSupplier getDrawingSupplier() { 1031 DrawingSupplier result = null; 1032 if (this.drawingSupplier instanceof PublicCloneable) { 1033 PublicCloneable pc = (PublicCloneable) this.drawingSupplier; 1034 try { 1035 result = (DrawingSupplier) pc.clone(); 1036 } 1037 catch (CloneNotSupportedException e) { 1038 e.printStackTrace(); 1039 } 1040 } 1041 return result; 1042 } 1043 1044 /** 1045 * Sets the drawing supplier for this theme. 1046 * 1047 * @param supplier the supplier (<code>null</code> not permitted). 1048 * 1049 * @see #getDrawingSupplier() 1050 */ 1051 public void setDrawingSupplier(DrawingSupplier supplier) { 1052 if (supplier == null) { 1053 throw new IllegalArgumentException("Null 'supplier' argument."); 1054 } 1055 this.drawingSupplier = supplier; 1056 } 1057 1058 /** 1059 * Applies this theme to the supplied chart. 1060 * 1061 * @param chart the chart (<code>null</code> not permitted). 1062 */ 1063 public void apply(JFreeChart chart) { 1064 if (chart == null) { 1065 throw new IllegalArgumentException("Null 'chart' argument."); 1066 } 1067 TextTitle title = chart.getTitle(); 1068 if (title != null) { 1069 title.setFont(this.extraLargeFont); 1070 title.setPaint(this.titlePaint); 1071 } 1072 1073 int subtitleCount = chart.getSubtitleCount(); 1074 for (int i = 0; i < subtitleCount; i++) { 1075 applyToTitle(chart.getSubtitle(i)); 1076 } 1077 1078 chart.setBackgroundPaint(this.chartBackgroundPaint); 1079 1080 // now process the plot if there is one 1081 Plot plot = chart.getPlot(); 1082 if (plot != null) { 1083 applyToPlot(plot); 1084 } 1085 } 1086 1087 /** 1088 * Applies the attributes of this theme to the specified title. 1089 * 1090 * @param title the title. 1091 */ 1092 protected void applyToTitle(Title title) { 1093 if (title instanceof TextTitle) { 1094 TextTitle tt = (TextTitle) title; 1095 tt.setFont(this.largeFont); 1096 tt.setPaint(this.subtitlePaint); 1097 } 1098 else if (title instanceof LegendTitle) { 1099 LegendTitle lt = (LegendTitle) title; 1100 if (lt.getBackgroundPaint() != null) { 1101 lt.setBackgroundPaint(this.legendBackgroundPaint); 1102 } 1103 lt.setItemFont(this.regularFont); 1104 lt.setItemPaint(this.legendItemPaint); 1105 if (lt.getWrapper() != null) { 1106 applyToBlockContainer(lt.getWrapper()); 1107 } 1108 } 1109 else if (title instanceof PaintScaleLegend) { 1110 PaintScaleLegend psl = (PaintScaleLegend) title; 1111 psl.setBackgroundPaint(this.legendBackgroundPaint); 1112 ValueAxis axis = psl.getAxis(); 1113 if (axis != null) { 1114 applyToValueAxis(axis); 1115 } 1116 } 1117 else if (title instanceof CompositeTitle) { 1118 CompositeTitle ct = (CompositeTitle) title; 1119 BlockContainer bc = ct.getContainer(); 1120 List blocks = bc.getBlocks(); 1121 Iterator iterator = blocks.iterator(); 1122 while (iterator.hasNext()) { 1123 Block b = (Block) iterator.next(); 1124 if (b instanceof Title) { 1125 applyToTitle((Title) b); 1126 } 1127 } 1128 } 1129 } 1130 1131 /** 1132 * Applies the attributes of this theme to the specified container. 1133 * 1134 * @param bc a block container (<code>null</code> not permitted). 1135 */ 1136 protected void applyToBlockContainer(BlockContainer bc) { 1137 Iterator iterator = bc.getBlocks().iterator(); 1138 while (iterator.hasNext()) { 1139 Block b = (Block) iterator.next(); 1140 applyToBlock(b); 1141 } 1142 } 1143 1144 /** 1145 * Applies the attributes of this theme to the specified block. 1146 * 1147 * @param b the block. 1148 */ 1149 protected void applyToBlock(Block b) { 1150 if (b instanceof Title) { 1151 applyToTitle((Title) b); 1152 } 1153 else if (b instanceof LabelBlock) { 1154 LabelBlock lb = (LabelBlock) b; 1155 lb.setFont(this.regularFont); 1156 lb.setPaint(this.legendItemPaint); 1157 } 1158 } 1159 1160 /** 1161 * Applies the attributes of this theme to a plot. 1162 * 1163 * @param plot the plot (<code>null</code>). 1164 */ 1165 protected void applyToPlot(Plot plot) { 1166 if (plot == null) { 1167 throw new IllegalArgumentException("Null 'plot' argument."); 1168 } 1169 if (plot.getDrawingSupplier() != null) { 1170 plot.setDrawingSupplier(getDrawingSupplier()); 1171 } 1172 if (plot.getBackgroundPaint() != null) { 1173 plot.setBackgroundPaint(this.plotBackgroundPaint); 1174 } 1175 plot.setOutlinePaint(this.plotOutlinePaint); 1176 1177 // now handle specific plot types (and yes, I know this is some 1178 // really ugly code that has to be manually updated any time a new 1179 // plot type is added - I should have written something much cooler, 1180 // but I didn't and neither did anyone else). 1181 if (plot instanceof PiePlot) { 1182 applyToPiePlot((PiePlot) plot); 1183 } 1184 else if (plot instanceof MultiplePiePlot) { 1185 applyToMultiplePiePlot((MultiplePiePlot) plot); 1186 } 1187 else if (plot instanceof CategoryPlot) { 1188 applyToCategoryPlot((CategoryPlot) plot); 1189 } 1190 else if (plot instanceof XYPlot) { 1191 applyToXYPlot((XYPlot) plot); 1192 } 1193 else if (plot instanceof FastScatterPlot) { 1194 applyToFastScatterPlot((FastScatterPlot) plot); 1195 } 1196 else if (plot instanceof MeterPlot) { 1197 applyToMeterPlot((MeterPlot) plot); 1198 } 1199 else if (plot instanceof ThermometerPlot) { 1200 applyToThermometerPlot((ThermometerPlot) plot); 1201 } 1202 else if (plot instanceof SpiderWebPlot) { 1203 applyToSpiderWebPlot((SpiderWebPlot) plot); 1204 } 1205 else if (plot instanceof PolarPlot) { 1206 applyToPolarPlot((PolarPlot) plot); 1207 } 1208 } 1209 1210 /** 1211 * Applies the attributes of this theme to a {@link PiePlot} instance. 1212 * This method also clears any set values for the section paint, outline 1213 * etc, so that the theme's {@link DrawingSupplier} will be used. 1214 * 1215 * @param plot the plot (<code>null</code> not permitted). 1216 */ 1217 protected void applyToPiePlot(PiePlot plot) { 1218 plot.setLabelLinkPaint(this.labelLinkPaint); 1219 plot.setLabelLinkStyle(this.labelLinkStyle); 1220 plot.setLabelFont(this.regularFont); 1221 1222 // clear the section attributes so that the theme's DrawingSupplier 1223 // will be used 1224 if (plot.getAutoPopulateSectionPaint()) { 1225 plot.clearSectionPaints(false); 1226 } 1227 if (plot.getAutoPopulateSectionOutlinePaint()) { 1228 plot.clearSectionOutlinePaints(false); 1229 } 1230 if (plot.getAutoPopulateSectionOutlineStroke()) { 1231 plot.clearSectionOutlineStrokes(false); 1232 } 1233 } 1234 1235 /** 1236 * Applies the attributes of this theme to a {@link MultiplePiePlot}. 1237 * 1238 * @param plot the plot (<code>null</code> not permitted). 1239 */ 1240 protected void applyToMultiplePiePlot(MultiplePiePlot plot) { 1241 apply(plot.getPieChart()); 1242 } 1243 1244 /** 1245 * Applies the attributes of this theme to a {@link CategoryPlot}. 1246 * 1247 * @param plot the plot (<code>null</code> not permitted). 1248 */ 1249 protected void applyToCategoryPlot(CategoryPlot plot) { 1250 plot.setAxisOffset(this.axisOffset); 1251 plot.setDomainGridlinePaint(this.domainGridlinePaint); 1252 plot.setRangeGridlinePaint(this.rangeGridlinePaint); 1253 1254 // process all domain axes 1255 int domainAxisCount = plot.getDomainAxisCount(); 1256 for (int i = 0; i < domainAxisCount; i++) { 1257 CategoryAxis axis = (CategoryAxis) plot.getDomainAxis(i); 1258 if (axis != null) { 1259 applyToCategoryAxis(axis); 1260 } 1261 } 1262 1263 // process all range axes 1264 int rangeAxisCount = plot.getRangeAxisCount(); 1265 for (int i = 0; i < rangeAxisCount; i++) { 1266 ValueAxis axis = (ValueAxis) plot.getRangeAxis(i); 1267 if (axis != null) { 1268 applyToValueAxis(axis); 1269 } 1270 } 1271 1272 // process all renderers 1273 int rendererCount = plot.getRendererCount(); 1274 for (int i = 0; i < rendererCount; i++) { 1275 CategoryItemRenderer r = plot.getRenderer(i); 1276 if (r != null) { 1277 applyToCategoryItemRenderer(r); 1278 } 1279 } 1280 1281 if (plot instanceof CombinedDomainCategoryPlot) { 1282 CombinedDomainCategoryPlot cp = (CombinedDomainCategoryPlot) plot; 1283 Iterator iterator = cp.getSubplots().iterator(); 1284 while (iterator.hasNext()) { 1285 CategoryPlot subplot = (CategoryPlot) iterator.next(); 1286 if (subplot != null) { 1287 applyToPlot(subplot); 1288 } 1289 } 1290 } 1291 if (plot instanceof CombinedRangeCategoryPlot) { 1292 CombinedRangeCategoryPlot cp = (CombinedRangeCategoryPlot) plot; 1293 Iterator iterator = cp.getSubplots().iterator(); 1294 while (iterator.hasNext()) { 1295 CategoryPlot subplot = (CategoryPlot) iterator.next(); 1296 if (subplot != null) { 1297 applyToPlot(subplot); 1298 } 1299 } 1300 } 1301 } 1302 1303 /** 1304 * Applies the attributes of this theme to a {@link XYPlot}. 1305 * 1306 * @param plot the plot (<code>null</code> not permitted). 1307 */ 1308 protected void applyToXYPlot(XYPlot plot) { 1309 plot.setAxisOffset(this.axisOffset); 1310 plot.setDomainGridlinePaint(this.domainGridlinePaint); 1311 plot.setRangeGridlinePaint(this.rangeGridlinePaint); 1312 plot.setDomainCrosshairPaint(this.crosshairPaint); 1313 plot.setRangeCrosshairPaint(this.crosshairPaint); 1314 // process all domain axes 1315 int domainAxisCount = plot.getDomainAxisCount(); 1316 for (int i = 0; i < domainAxisCount; i++) { 1317 ValueAxis axis = (ValueAxis) plot.getDomainAxis(i); 1318 if (axis != null) { 1319 applyToValueAxis(axis); 1320 } 1321 } 1322 1323 // process all range axes 1324 int rangeAxisCount = plot.getRangeAxisCount(); 1325 for (int i = 0; i < rangeAxisCount; i++) { 1326 ValueAxis axis = (ValueAxis) plot.getRangeAxis(i); 1327 if (axis != null) { 1328 applyToValueAxis(axis); 1329 } 1330 } 1331 1332 // process all renderers 1333 int rendererCount = plot.getRendererCount(); 1334 for (int i = 0; i < rendererCount; i++) { 1335 XYItemRenderer r = plot.getRenderer(i); 1336 if (r != null) { 1337 applyToXYItemRenderer(r); 1338 } 1339 } 1340 1341 // process all annotations 1342 Iterator iter = plot.getAnnotations().iterator(); 1343 while (iter.hasNext()) { 1344 XYAnnotation a = (XYAnnotation) iter.next(); 1345 applyToXYAnnotation(a); 1346 } 1347 1348 if (plot instanceof CombinedDomainXYPlot) { 1349 CombinedDomainXYPlot cp = (CombinedDomainXYPlot) plot; 1350 Iterator iterator = cp.getSubplots().iterator(); 1351 while (iterator.hasNext()) { 1352 XYPlot subplot = (XYPlot) iterator.next(); 1353 if (subplot != null) { 1354 applyToPlot(subplot); 1355 } 1356 } 1357 } 1358 if (plot instanceof CombinedRangeXYPlot) { 1359 CombinedRangeXYPlot cp = (CombinedRangeXYPlot) plot; 1360 Iterator iterator = cp.getSubplots().iterator(); 1361 while (iterator.hasNext()) { 1362 XYPlot subplot = (XYPlot) iterator.next(); 1363 if (subplot != null) { 1364 applyToPlot(subplot); 1365 } 1366 } 1367 } 1368 } 1369 1370 /** 1371 * Applies the attributes of this theme to a {@link FastScatterPlot}. 1372 * @param plot 1373 */ 1374 protected void applyToFastScatterPlot(FastScatterPlot plot) { 1375 plot.setDomainGridlinePaint(this.domainGridlinePaint); 1376 plot.setRangeGridlinePaint(this.rangeGridlinePaint); 1377 ValueAxis xAxis = plot.getDomainAxis(); 1378 if (xAxis != null) { 1379 applyToValueAxis(xAxis); 1380 } 1381 ValueAxis yAxis = plot.getRangeAxis(); 1382 if (yAxis != null) { 1383 applyToValueAxis(yAxis); 1384 } 1385 1386 } 1387 1388 /** 1389 * Applies the attributes of this theme to a {@link PolarPlot}. This 1390 * method is called from the {@link #applyToPlot(Plot)} method. 1391 * 1392 * @param plot the plot (<code>null</code> not permitted). 1393 */ 1394 protected void applyToPolarPlot(PolarPlot plot) { 1395 plot.setAngleLabelFont(this.regularFont); 1396 plot.setAngleLabelPaint(this.tickLabelPaint); 1397 plot.setAngleGridlinePaint(this.domainGridlinePaint); 1398 plot.setRadiusGridlinePaint(this.rangeGridlinePaint); 1399 ValueAxis axis = plot.getAxis(); 1400 if (axis != null) { 1401 applyToValueAxis(axis); 1402 } 1403 } 1404 1405 /** 1406 * Applies the attributes of this theme to a {@link SpiderWebPlot}. 1407 * 1408 * @param plot the plot (<code>null</code> not permitted). 1409 */ 1410 protected void applyToSpiderWebPlot(SpiderWebPlot plot) { 1411 plot.setLabelFont(this.regularFont); 1412 plot.setLabelPaint(this.axisLabelPaint); 1413 plot.setAxisLinePaint(this.axisLabelPaint); 1414 } 1415 1416 /** 1417 * Applies the attributes of this theme to a {@link MeterPlot}. 1418 * 1419 * @param plot the plot (<code>null</code> not permitted). 1420 */ 1421 protected void applyToMeterPlot(MeterPlot plot) { 1422 plot.setDialBackgroundPaint(this.plotBackgroundPaint); 1423 plot.setValueFont(this.largeFont); 1424 plot.setValuePaint(this.axisLabelPaint); 1425 plot.setDialOutlinePaint(this.plotOutlinePaint); 1426 plot.setNeedlePaint(this.thermometerPaint); 1427 plot.setTickLabelFont(this.regularFont); 1428 plot.setTickLabelPaint(this.tickLabelPaint); 1429 } 1430 1431 /** 1432 * Applies the attributes for this theme to a {@link ThermometerPlot}. 1433 * This method is called from the {@link #applyToPlot(Plot)} method. 1434 * 1435 * @param plot the plot. 1436 */ 1437 protected void applyToThermometerPlot(ThermometerPlot plot) { 1438 plot.setValueFont(this.largeFont); 1439 plot.setThermometerPaint(this.thermometerPaint); 1440 ValueAxis axis = plot.getRangeAxis(); 1441 if (axis != null) { 1442 applyToValueAxis(axis); 1443 } 1444 } 1445 1446 /** 1447 * Applies the attributes for this theme to a {@link CategoryAxis}. 1448 * 1449 * @param axis the axis (<code>null</code> not permitted). 1450 */ 1451 protected void applyToCategoryAxis(CategoryAxis axis) { 1452 axis.setLabelFont(this.largeFont); 1453 axis.setLabelPaint(this.axisLabelPaint); 1454 axis.setTickLabelFont(this.regularFont); 1455 axis.setTickLabelPaint(this.tickLabelPaint); 1456 if (axis instanceof SubCategoryAxis) { 1457 SubCategoryAxis sca = (SubCategoryAxis) axis; 1458 sca.setSubLabelFont(this.regularFont); 1459 sca.setSubLabelPaint(this.tickLabelPaint); 1460 } 1461 } 1462 1463 /** 1464 * Applies the attributes for this theme to a {@link ValueAxis}. 1465 * 1466 * @param axis the axis (<code>null</code> not permitted). 1467 */ 1468 protected void applyToValueAxis(ValueAxis axis) { 1469 axis.setLabelFont(this.largeFont); 1470 axis.setLabelPaint(this.axisLabelPaint); 1471 axis.setTickLabelFont(this.regularFont); 1472 axis.setTickLabelPaint(this.tickLabelPaint); 1473 if (axis instanceof SymbolAxis) { 1474 applyToSymbolAxis((SymbolAxis) axis); 1475 } 1476 if (axis instanceof PeriodAxis) { 1477 applyToPeriodAxis((PeriodAxis) axis); 1478 } 1479 } 1480 1481 /** 1482 * Applies the attributes for this theme to a {@link SymbolAxis}. 1483 * 1484 * @param axis the axis (<code>null</code> not permitted). 1485 */ 1486 protected void applyToSymbolAxis(SymbolAxis axis) { 1487 axis.setGridBandPaint(this.gridBandPaint); 1488 axis.setGridBandAlternatePaint(this.gridBandAlternatePaint); 1489 } 1490 1491 /** 1492 * Applies the attributes for this theme to a {@link PeriodAxis}. 1493 * 1494 * @param axis the axis (<code>null</code> not permitted). 1495 */ 1496 protected void applyToPeriodAxis(PeriodAxis axis) { 1497 PeriodAxisLabelInfo[] info = axis.getLabelInfo(); 1498 for (int i = 0; i < info.length; i++) { 1499 PeriodAxisLabelInfo e = info[i]; 1500 PeriodAxisLabelInfo n = new PeriodAxisLabelInfo(e.getPeriodClass(), 1501 e.getDateFormat(), e.getPadding(), this.regularFont, 1502 this.tickLabelPaint, e.getDrawDividers(), 1503 e.getDividerStroke(), e.getDividerPaint()); 1504 info[i] = n; 1505 } 1506 axis.setLabelInfo(info); 1507 } 1508 1509 /** 1510 * Applies the attributes for this theme to an {@link AbstractRenderer}. 1511 * 1512 * @param renderer the renderer (<code>null</code> not permitted). 1513 */ 1514 protected void applyToAbstractRenderer(AbstractRenderer renderer) { 1515 if (renderer.getAutoPopulateSeriesPaint()) { 1516 renderer.clearSeriesPaints(false); 1517 } 1518 if (renderer.getAutoPopulateSeriesStroke()) { 1519 renderer.clearSeriesStrokes(false); 1520 } 1521 } 1522 1523 /** 1524 * Applies the settings of this theme to the specified renderer. 1525 * 1526 * @param renderer the renderer (<code>null</code> not permitted). 1527 */ 1528 protected void applyToCategoryItemRenderer(CategoryItemRenderer renderer) { 1529 if (renderer == null) { 1530 throw new IllegalArgumentException("Null 'renderer' argument."); 1531 } 1532 1533 if (renderer instanceof AbstractRenderer) { 1534 applyToAbstractRenderer((AbstractRenderer) renderer); 1535 } 1536 1537 renderer.setBaseItemLabelFont(this.regularFont); 1538 renderer.setBaseItemLabelPaint(this.itemLabelPaint); 1539 1540 // now we handle some special cases - yes, UGLY code alert! 1541 1542 // BarRenderer 1543 if (renderer instanceof BarRenderer) { 1544 BarRenderer br = (BarRenderer) renderer; 1545 br.setBarPainter(this.barPainter); 1546 br.setShadowVisible(this.shadowVisible); 1547 br.setShadowPaint(this.shadowPaint); 1548 } 1549 1550 // BarRenderer3D 1551 if (renderer instanceof BarRenderer3D) { 1552 BarRenderer3D br3d = (BarRenderer3D) renderer; 1553 br3d.setWallPaint(this.wallPaint); 1554 } 1555 1556 // LineRenderer3D 1557 if (renderer instanceof LineRenderer3D) { 1558 LineRenderer3D lr3d = (LineRenderer3D) renderer; 1559 lr3d.setWallPaint(this.wallPaint); 1560 } 1561 1562 // StatisticalBarRenderer 1563 if (renderer instanceof StatisticalBarRenderer) { 1564 StatisticalBarRenderer sbr = (StatisticalBarRenderer) renderer; 1565 sbr.setErrorIndicatorPaint(this.errorIndicatorPaint); 1566 } 1567 1568 // MinMaxCategoryRenderer 1569 if (renderer instanceof MinMaxCategoryRenderer) { 1570 MinMaxCategoryRenderer mmcr = (MinMaxCategoryRenderer) renderer; 1571 mmcr.setGroupPaint(this.errorIndicatorPaint); 1572 } 1573 } 1574 1575 /** 1576 * Applies the settings of this theme to the specified renderer. 1577 * 1578 * @param renderer the renderer (<code>null</code> not permitted). 1579 */ 1580 protected void applyToXYItemRenderer(XYItemRenderer renderer) { 1581 if (renderer == null) { 1582 throw new IllegalArgumentException("Null 'renderer' argument."); 1583 } 1584 if (renderer instanceof AbstractRenderer) { 1585 applyToAbstractRenderer((AbstractRenderer) renderer); 1586 } 1587 renderer.setBaseItemLabelFont(this.regularFont); 1588 renderer.setBaseItemLabelPaint(this.itemLabelPaint); 1589 if (renderer instanceof XYBarRenderer) { 1590 XYBarRenderer br = (XYBarRenderer) renderer; 1591 br.setBarPainter(this.xyBarPainter); 1592 br.setShadowVisible(this.shadowVisible); 1593 } 1594 } 1595 1596 /** 1597 * Applies the settings of this theme to the specified annotation. 1598 * 1599 * @param annotation the annotation. 1600 */ 1601 protected void applyToXYAnnotation(XYAnnotation annotation) { 1602 if (annotation == null) { 1603 throw new IllegalArgumentException("Null 'annotation' argument."); 1604 } 1605 if (annotation instanceof XYTextAnnotation) { 1606 XYTextAnnotation xyta = (XYTextAnnotation) annotation; 1607 xyta.setFont(this.smallFont); 1608 xyta.setPaint(this.itemLabelPaint); 1609 } 1610 } 1611 1612 /** 1613 * Tests this theme for equality with an arbitrary object. 1614 * 1615 * @param obj the object (<code>null</code> permitted). 1616 * 1617 * @return A boolean. 1618 */ 1619 public boolean equals(Object obj) { 1620 if (obj == this) { 1621 return true; 1622 } 1623 if (!(obj instanceof StandardChartTheme)) { 1624 return false; 1625 } 1626 StandardChartTheme that = (StandardChartTheme) obj; 1627 if (!this.name.equals(that.name)) { 1628 return false; 1629 } 1630 if (!this.extraLargeFont.equals(that.extraLargeFont)) { 1631 return false; 1632 } 1633 if (!this.largeFont.equals(that.largeFont)) { 1634 return false; 1635 } 1636 if (!this.regularFont.equals(that.regularFont)) { 1637 return false; 1638 } 1639 if (!this.smallFont.equals(that.smallFont)) { 1640 return false; 1641 } 1642 if (!PaintUtilities.equal(this.titlePaint, that.titlePaint)) { 1643 return false; 1644 } 1645 if (!PaintUtilities.equal(this.subtitlePaint, that.subtitlePaint)) { 1646 return false; 1647 } 1648 if (!PaintUtilities.equal(this.chartBackgroundPaint, 1649 that.chartBackgroundPaint)) { 1650 return false; 1651 } 1652 if (!PaintUtilities.equal(this.legendBackgroundPaint, 1653 that.legendBackgroundPaint)) { 1654 return false; 1655 } 1656 if (!PaintUtilities.equal(this.legendItemPaint, that.legendItemPaint)) { 1657 return false; 1658 } 1659 if (!this.drawingSupplier.equals(that.drawingSupplier)) { 1660 return false; 1661 } 1662 if (!PaintUtilities.equal(this.plotBackgroundPaint, 1663 that.plotBackgroundPaint)) { 1664 return false; 1665 } 1666 if (!PaintUtilities.equal(this.plotOutlinePaint, 1667 that.plotOutlinePaint)) { 1668 return false; 1669 } 1670 if (!this.labelLinkStyle.equals(that.labelLinkStyle)) { 1671 return false; 1672 } 1673 if (!PaintUtilities.equal(this.labelLinkPaint, that.labelLinkPaint)) { 1674 return false; 1675 } 1676 if (!PaintUtilities.equal(this.domainGridlinePaint, 1677 that.domainGridlinePaint)) { 1678 return false; 1679 } 1680 if (!PaintUtilities.equal(this.rangeGridlinePaint, 1681 that.rangeGridlinePaint)) { 1682 return false; 1683 } 1684 if (!PaintUtilities.equal(this.crosshairPaint, that.crosshairPaint)) { 1685 return false; 1686 } 1687 if (!this.axisOffset.equals(that.axisOffset)) { 1688 return false; 1689 } 1690 if (!PaintUtilities.equal(this.axisLabelPaint, that.axisLabelPaint)) { 1691 return false; 1692 } 1693 if (!PaintUtilities.equal(this.tickLabelPaint, that.tickLabelPaint)) { 1694 return false; 1695 } 1696 if (!PaintUtilities.equal(this.itemLabelPaint, that.itemLabelPaint)) { 1697 return false; 1698 } 1699 if (this.shadowVisible != that.shadowVisible) { 1700 return false; 1701 } 1702 if (!PaintUtilities.equal(this.shadowPaint, that.shadowPaint)) { 1703 return false; 1704 } 1705 if (!this.barPainter.equals(that.barPainter)) { 1706 return false; 1707 } 1708 if (!this.xyBarPainter.equals(that.xyBarPainter)) { 1709 return false; 1710 } 1711 if (!PaintUtilities.equal(this.thermometerPaint, 1712 that.thermometerPaint)) { 1713 return false; 1714 } 1715 if (!PaintUtilities.equal(this.wallPaint, that.wallPaint)) { 1716 return false; 1717 } 1718 if (!PaintUtilities.equal(this.errorIndicatorPaint, 1719 that.errorIndicatorPaint)) { 1720 return false; 1721 } 1722 if (!PaintUtilities.equal(this.gridBandPaint, that.gridBandPaint)) { 1723 return false; 1724 } 1725 if (!PaintUtilities.equal(this.gridBandAlternatePaint, 1726 that.gridBandAlternatePaint)) { 1727 return false; 1728 } 1729 return true; 1730 } 1731 1732 /** 1733 * Returns a clone of this theme. 1734 * 1735 * @return A clone. 1736 * 1737 * @throws CloneNotSupportedException if the theme cannot be cloned. 1738 */ 1739 public Object clone() throws CloneNotSupportedException { 1740 return super.clone(); 1741 } 1742 1743 /** 1744 * Provides serialization support. 1745 * 1746 * @param stream the output stream (<code>null</code> not permitted). 1747 * 1748 * @throws IOException if there is an I/O error. 1749 */ 1750 private void writeObject(ObjectOutputStream stream) throws IOException { 1751 stream.defaultWriteObject(); 1752 SerialUtilities.writePaint(this.titlePaint, stream); 1753 SerialUtilities.writePaint(this.subtitlePaint, stream); 1754 SerialUtilities.writePaint(this.chartBackgroundPaint, stream); 1755 SerialUtilities.writePaint(this.legendBackgroundPaint, stream); 1756 SerialUtilities.writePaint(this.legendItemPaint, stream); 1757 SerialUtilities.writePaint(this.plotBackgroundPaint, stream); 1758 SerialUtilities.writePaint(this.plotOutlinePaint, stream); 1759 SerialUtilities.writePaint(this.labelLinkPaint, stream); 1760 SerialUtilities.writePaint(this.domainGridlinePaint, stream); 1761 SerialUtilities.writePaint(this.rangeGridlinePaint, stream); 1762 SerialUtilities.writePaint(this.crosshairPaint, stream); 1763 SerialUtilities.writePaint(this.axisLabelPaint, stream); 1764 SerialUtilities.writePaint(this.tickLabelPaint, stream); 1765 SerialUtilities.writePaint(this.itemLabelPaint, stream); 1766 SerialUtilities.writePaint(this.shadowPaint, stream); 1767 SerialUtilities.writePaint(this.thermometerPaint, stream); 1768 SerialUtilities.writePaint(this.wallPaint, stream); 1769 SerialUtilities.writePaint(this.errorIndicatorPaint, stream); 1770 SerialUtilities.writePaint(this.gridBandPaint, stream); 1771 SerialUtilities.writePaint(this.gridBandAlternatePaint, stream); 1772 } 1773 1774 /** 1775 * Provides serialization support. 1776 * 1777 * @param stream the input stream (<code>null</code> not permitted). 1778 * 1779 * @throws IOException if there is an I/O error. 1780 * @throws ClassNotFoundException if there is a classpath problem. 1781 */ 1782 private void readObject(ObjectInputStream stream) 1783 throws IOException, ClassNotFoundException { 1784 stream.defaultReadObject(); 1785 this.titlePaint = SerialUtilities.readPaint(stream); 1786 this.subtitlePaint = SerialUtilities.readPaint(stream); 1787 this.chartBackgroundPaint = SerialUtilities.readPaint(stream); 1788 this.legendBackgroundPaint = SerialUtilities.readPaint(stream); 1789 this.legendItemPaint = SerialUtilities.readPaint(stream); 1790 this.plotBackgroundPaint = SerialUtilities.readPaint(stream); 1791 this.plotOutlinePaint = SerialUtilities.readPaint(stream); 1792 this.labelLinkPaint = SerialUtilities.readPaint(stream); 1793 this.domainGridlinePaint = SerialUtilities.readPaint(stream); 1794 this.rangeGridlinePaint = SerialUtilities.readPaint(stream); 1795 this.crosshairPaint = SerialUtilities.readPaint(stream); 1796 this.axisLabelPaint = SerialUtilities.readPaint(stream); 1797 this.tickLabelPaint = SerialUtilities.readPaint(stream); 1798 this.itemLabelPaint = SerialUtilities.readPaint(stream); 1799 this.shadowPaint = SerialUtilities.readPaint(stream); 1800 this.thermometerPaint = SerialUtilities.readPaint(stream); 1801 this.wallPaint = SerialUtilities.readPaint(stream); 1802 this.errorIndicatorPaint = SerialUtilities.readPaint(stream); 1803 this.gridBandPaint = SerialUtilities.readPaint(stream); 1804 this.gridBandAlternatePaint = SerialUtilities.readPaint(stream); 1805 } 1806 1807 }