001 /* =========================================================== 002 * JFreeChart : a free chart library for the Java(tm) platform 003 * =========================================================== 004 * 005 * (C) Copyright 2000-2007, by Object Refinery Limited and Contributors. 006 * 007 * Project Info: http://www.jfree.org/jfreechart/index.html 008 * 009 * This library is free software; you can redistribute it and/or modify it 010 * under the terms of the GNU Lesser General Public License as published by 011 * the Free Software Foundation; either version 2.1 of the License, or 012 * (at your option) any later version. 013 * 014 * This library is distributed in the hope that it will be useful, but 015 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 016 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 017 * License for more details. 018 * 019 * You should have received a copy of the GNU Lesser General Public 020 * License along with this library; if not, write to the Free Software 021 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 022 * USA. 023 * 024 * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 025 * in the United States and other countries.] 026 * 027 * ------------------- 028 * ChartUtilities.java 029 * ------------------- 030 * (C) Copyright 2001-2007, by Object Refinery Limited and Contributors. 031 * 032 * Original Author: David Gilbert (for Object Refinery Limited); 033 * Contributor(s): Wolfgang Irler; 034 * Richard Atkinson; 035 * Xavier Poinsard; 036 * 037 * $Id: ChartUtilities.java,v 1.4.2.4 2007/03/19 14:07:53 mungady Exp $ 038 * 039 * Changes 040 * ------- 041 * 11-Dec-2001 : Version 1. The JPEG method comes from Wolfgang Irler's 042 * JFreeChartServletDemo class (DG); 043 * 23-Jan-2002 : Changed saveChartAsXXX() methods to pass IOExceptions back to 044 * caller (DG); 045 * 26-Jun-2002 : Added image map methods (DG); 046 * 05-Aug-2002 : Added writeBufferedImage methods 047 * Modified writeImageMap method to support flexible image 048 * maps (RA); 049 * 26-Aug-2002 : Added saveChartAsJPEG and writeChartAsJPEG methods with info 050 * objects (RA); 051 * 05-Sep-2002 : Added writeImageMap() method to support OverLIB 052 * - http://www.bosrup.com/web/overlib (RA); 053 * 26-Sep-2002 : Fixed errors reported by Checkstyle (DG); 054 * 17-Oct-2002 : Exposed JPEG quality setting and PNG compression level as 055 * parameters (DG); 056 * 25-Oct-2002 : Fixed writeChartAsJPEG() empty method bug (DG); 057 * 13-Mar-2003 : Updated writeImageMap method as suggested by Xavier Poinsard 058 * (see Feature Request 688079) (DG); 059 * 12-Aug-2003 : Added support for custom image maps using 060 * ToolTipTagFragmentGenerator and URLTagFragmentGenerator (RA); 061 * 02-Sep-2003 : Separated PNG encoding from writing chart to an 062 * OutputStream (RA); 063 * 04-Dec-2003 : Chart draw() method modified to include anchor point (DG); 064 * 20-Feb-2004 : Edited Javadocs and added argument checking (DG); 065 * 05-Apr-2004 : Fixed problem with buffered image type (DG); 066 * 01-Aug-2004 : Modified to use EncoderUtil for all image encoding (RA); 067 * 02-Aug-2004 : Delegated image map related functionality to ImageMapUtil (RA); 068 * 13-Jan-2005 : Renamed ImageMapUtil --> ImageMapUtilities, removed method 069 * writeImageMap(PrintWriter, String, ChartRenderingInfo) which 070 * exists in ImageMapUtilities (DG); 071 * ------------- JFREECHART 1.0.x --------------------------------------------- 072 * 06-Feb-2006 : API doc update (DG); 073 * 19-Mar-2007 : Use try-finally to close output stream in saveChartAsXXX() 074 * methods (DG); 075 * 076 */ 077 078 package org.jfree.chart; 079 080 import java.awt.Graphics2D; 081 import java.awt.geom.AffineTransform; 082 import java.awt.geom.Rectangle2D; 083 import java.awt.image.BufferedImage; 084 import java.io.BufferedOutputStream; 085 import java.io.File; 086 import java.io.FileOutputStream; 087 import java.io.IOException; 088 import java.io.OutputStream; 089 import java.io.PrintWriter; 090 091 import org.jfree.chart.imagemap.ImageMapUtilities; 092 import org.jfree.chart.imagemap.OverLIBToolTipTagFragmentGenerator; 093 import org.jfree.chart.imagemap.StandardToolTipTagFragmentGenerator; 094 import org.jfree.chart.imagemap.StandardURLTagFragmentGenerator; 095 import org.jfree.chart.imagemap.ToolTipTagFragmentGenerator; 096 import org.jfree.chart.imagemap.URLTagFragmentGenerator; 097 098 import org.jfree.chart.encoders.EncoderUtil; 099 import org.jfree.chart.encoders.ImageFormat; 100 101 /** 102 * A collection of utility methods for JFreeChart. Includes methods for 103 * converting charts to image formats (PNG and JPEG) plus creating simple HTML 104 * image maps. 105 * 106 * @see ImageMapUtilities 107 */ 108 public abstract class ChartUtilities { 109 110 /** 111 * Writes a chart to an output stream in PNG format. 112 * 113 * @param out the output stream (<code>null</code> not permitted). 114 * @param chart the chart (<code>null</code> not permitted). 115 * @param width the image width. 116 * @param height the image height. 117 * 118 * @throws IOException if there are any I/O errors. 119 */ 120 public static void writeChartAsPNG(OutputStream out, JFreeChart chart, 121 int width, int height) throws IOException { 122 123 // defer argument checking... 124 writeChartAsPNG(out, chart, width, height, null); 125 126 } 127 128 /** 129 * Writes a chart to an output stream in PNG format. 130 * 131 * @param out the output stream (<code>null</code> not permitted). 132 * @param chart the chart (<code>null</code> not permitted). 133 * @param width the image width. 134 * @param height the image height. 135 * @param encodeAlpha encode alpha? 136 * @param compression the compression level (0-9). 137 * 138 * @throws IOException if there are any I/O errors. 139 */ 140 public static void writeChartAsPNG(OutputStream out, JFreeChart chart, 141 int width, int height, boolean encodeAlpha, int compression) 142 throws IOException { 143 144 // defer argument checking... 145 ChartUtilities.writeChartAsPNG(out, chart, width, height, null, 146 encodeAlpha, compression); 147 148 } 149 150 /** 151 * Writes a chart to an output stream in PNG format. This method allows 152 * you to pass in a {@link ChartRenderingInfo} object, to collect 153 * information about the chart dimensions/entities. You will need this 154 * info if you want to create an HTML image map. 155 * 156 * @param out the output stream (<code>null</code> not permitted). 157 * @param chart the chart (<code>null</code> not permitted). 158 * @param width the image width. 159 * @param height the image height. 160 * @param info the chart rendering info (<code>null</code> permitted). 161 * 162 * @throws IOException if there are any I/O errors. 163 */ 164 public static void writeChartAsPNG(OutputStream out, JFreeChart chart, 165 int width, int height, ChartRenderingInfo info) 166 throws IOException { 167 168 if (chart == null) { 169 throw new IllegalArgumentException("Null 'chart' argument."); 170 } 171 BufferedImage bufferedImage 172 = chart.createBufferedImage(width, height, info); 173 EncoderUtil.writeBufferedImage(bufferedImage, ImageFormat.PNG, out); 174 } 175 176 /** 177 * Writes a chart to an output stream in PNG format. This method allows 178 * you to pass in a {@link ChartRenderingInfo} object, to collect 179 * information about the chart dimensions/entities. You will need this 180 * info if you want to create an HTML image map. 181 * 182 * @param out the output stream (<code>null</code> not permitted). 183 * @param chart the chart (<code>null</code> not permitted). 184 * @param width the image width. 185 * @param height the image height. 186 * @param info carries back chart rendering info (<code>null</code> 187 * permitted). 188 * @param encodeAlpha encode alpha? 189 * @param compression the PNG compression level (0-9). 190 * 191 * @throws IOException if there are any I/O errors. 192 */ 193 public static void writeChartAsPNG(OutputStream out, JFreeChart chart, 194 int width, int height, ChartRenderingInfo info, 195 boolean encodeAlpha, int compression) throws IOException { 196 197 if (out == null) { 198 throw new IllegalArgumentException("Null 'out' argument."); 199 } 200 if (chart == null) { 201 throw new IllegalArgumentException("Null 'chart' argument."); 202 } 203 BufferedImage chartImage = chart.createBufferedImage(width, height, 204 BufferedImage.TYPE_INT_ARGB, info); 205 ChartUtilities.writeBufferedImageAsPNG(out, chartImage, encodeAlpha, 206 compression); 207 208 } 209 210 /** 211 * Writes a scaled version of a chart to an output stream in PNG format. 212 * 213 * @param out the output stream (<code>null</code> not permitted). 214 * @param chart the chart (<code>null</code> not permitted). 215 * @param width the unscaled chart width. 216 * @param height the unscaled chart height. 217 * @param widthScaleFactor the horizontal scale factor. 218 * @param heightScaleFactor the vertical scale factor. 219 * 220 * @throws IOException if there are any I/O problems. 221 */ 222 public static void writeScaledChartAsPNG(OutputStream out, 223 JFreeChart chart, int width, int height, int widthScaleFactor, 224 int heightScaleFactor) throws IOException { 225 226 if (out == null) { 227 throw new IllegalArgumentException("Null 'out' argument."); 228 } 229 if (chart == null) { 230 throw new IllegalArgumentException("Null 'chart' argument."); 231 } 232 233 double desiredWidth = width * widthScaleFactor; 234 double desiredHeight = height * heightScaleFactor; 235 double defaultWidth = width; 236 double defaultHeight = height; 237 boolean scale = false; 238 239 // get desired width and height from somewhere then... 240 if ((widthScaleFactor != 1) || (heightScaleFactor != 1)) { 241 scale = true; 242 } 243 244 double scaleX = desiredWidth / defaultWidth; 245 double scaleY = desiredHeight / defaultHeight; 246 247 BufferedImage image = new BufferedImage((int) desiredWidth, 248 (int) desiredHeight, BufferedImage.TYPE_INT_ARGB); 249 Graphics2D g2 = image.createGraphics(); 250 251 if (scale) { 252 AffineTransform saved = g2.getTransform(); 253 g2.transform(AffineTransform.getScaleInstance(scaleX, scaleY)); 254 chart.draw(g2, new Rectangle2D.Double(0, 0, defaultWidth, 255 defaultHeight), null, null); 256 g2.setTransform(saved); 257 g2.dispose(); 258 } 259 else { 260 chart.draw(g2, new Rectangle2D.Double(0, 0, defaultWidth, 261 defaultHeight), null, null); 262 } 263 out.write(encodeAsPNG(image)); 264 265 } 266 267 /** 268 * Saves a chart to the specified file in PNG format. 269 * 270 * @param file the file name (<code>null</code> not permitted). 271 * @param chart the chart (<code>null</code> not permitted). 272 * @param width the image width. 273 * @param height the image height. 274 * 275 * @throws IOException if there are any I/O errors. 276 */ 277 public static void saveChartAsPNG(File file, JFreeChart chart, 278 int width, int height) throws IOException { 279 280 // defer argument checking... 281 saveChartAsPNG(file, chart, width, height, null); 282 283 } 284 285 /** 286 * Saves a chart to a file in PNG format. This method allows you to pass 287 * in a {@link ChartRenderingInfo} object, to collect information about the 288 * chart dimensions/entities. You will need this info if you want to 289 * create an HTML image map. 290 * 291 * @param file the file (<code>null</code> not permitted). 292 * @param chart the chart (<code>null</code> not permitted). 293 * @param width the image width. 294 * @param height the image height. 295 * @param info the chart rendering info (<code>null</code> permitted). 296 * 297 * @throws IOException if there are any I/O errors. 298 */ 299 public static void saveChartAsPNG(File file, JFreeChart chart, 300 int width, int height, ChartRenderingInfo info) 301 throws IOException { 302 303 if (file == null) { 304 throw new IllegalArgumentException("Null 'file' argument."); 305 } 306 OutputStream out = new BufferedOutputStream(new FileOutputStream(file)); 307 try { 308 ChartUtilities.writeChartAsPNG(out, chart, width, height, info); 309 } 310 finally { 311 out.close(); 312 } 313 } 314 315 /** 316 * Saves a chart to a file in PNG format. This method allows you to pass 317 * in a {@link ChartRenderingInfo} object, to collect information about the 318 * chart dimensions/entities. You will need this info if you want to 319 * create an HTML image map. 320 * 321 * @param file the file (<code>null</code> not permitted). 322 * @param chart the chart (<code>null</code> not permitted). 323 * @param width the image width. 324 * @param height the image height. 325 * @param info the chart rendering info (<code>null</code> permitted). 326 * @param encodeAlpha encode alpha? 327 * @param compression the PNG compression level (0-9). 328 * 329 * @throws IOException if there are any I/O errors. 330 */ 331 public static void saveChartAsPNG(File file, JFreeChart chart, 332 int width, int height, ChartRenderingInfo info, boolean encodeAlpha, 333 int compression) throws IOException { 334 335 if (file == null) { 336 throw new IllegalArgumentException("Null 'file' argument."); 337 } 338 if (chart == null) { 339 throw new IllegalArgumentException("Null 'chart' argument."); 340 } 341 342 OutputStream out = new BufferedOutputStream(new FileOutputStream(file)); 343 try { 344 writeChartAsPNG(out, chart, width, height, info, encodeAlpha, 345 compression); 346 } 347 finally { 348 out.close(); 349 } 350 351 } 352 353 /** 354 * Writes a chart to an output stream in JPEG format. Please note that 355 * JPEG is a poor format for chart images, use PNG if possible. 356 * 357 * @param out the output stream (<code>null</code> not permitted). 358 * @param chart the chart (<code>null</code> not permitted). 359 * @param width the image width. 360 * @param height the image height. 361 * 362 * @throws IOException if there are any I/O errors. 363 */ 364 public static void writeChartAsJPEG(OutputStream out, 365 JFreeChart chart, int width, int height) throws IOException { 366 367 // defer argument checking... 368 writeChartAsJPEG(out, chart, width, height, null); 369 370 } 371 372 /** 373 * Writes a chart to an output stream in JPEG format. Please note that 374 * JPEG is a poor format for chart images, use PNG if possible. 375 * 376 * @param out the output stream (<code>null</code> not permitted). 377 * @param quality the quality setting. 378 * @param chart the chart (<code>null</code> not permitted). 379 * @param width the image width. 380 * @param height the image height. 381 * 382 * @throws IOException if there are any I/O errors. 383 */ 384 public static void writeChartAsJPEG(OutputStream out, float quality, 385 JFreeChart chart, int width, int height) throws IOException { 386 387 // defer argument checking... 388 ChartUtilities.writeChartAsJPEG(out, quality, chart, width, height, 389 null); 390 391 } 392 393 /** 394 * Writes a chart to an output stream in JPEG format. This method allows 395 * you to pass in a {@link ChartRenderingInfo} object, to collect 396 * information about the chart dimensions/entities. You will need this 397 * info if you want to create an HTML image map. 398 * 399 * @param out the output stream (<code>null</code> not permitted). 400 * @param chart the chart (<code>null</code> not permitted). 401 * @param width the image width. 402 * @param height the image height. 403 * @param info the chart rendering info (<code>null</code> permitted). 404 * 405 * @throws IOException if there are any I/O errors. 406 */ 407 public static void writeChartAsJPEG(OutputStream out, JFreeChart chart, 408 int width, int height, ChartRenderingInfo info) 409 throws IOException { 410 411 if (chart == null) { 412 throw new IllegalArgumentException("Null 'chart' argument."); 413 } 414 BufferedImage image = chart.createBufferedImage(width, height, info); 415 EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out); 416 417 } 418 419 /** 420 * Writes a chart to an output stream in JPEG format. This method allows 421 * you to pass in a {@link ChartRenderingInfo} object, to collect 422 * information about the chart dimensions/entities. You will need this 423 * info if you want to create an HTML image map. 424 * 425 * @param out the output stream (<code>null</code> not permitted). 426 * @param quality the output quality (0.0f to 1.0f). 427 * @param chart the chart (<code>null</code> not permitted). 428 * @param width the image width. 429 * @param height the image height. 430 * @param info the chart rendering info (<code>null</code> permitted). 431 * 432 * @throws IOException if there are any I/O errors. 433 */ 434 public static void writeChartAsJPEG(OutputStream out, float quality, 435 JFreeChart chart, int width, int height, ChartRenderingInfo info) 436 throws IOException { 437 438 if (chart == null) { 439 throw new IllegalArgumentException("Null 'chart' argument."); 440 } 441 BufferedImage image = chart.createBufferedImage(width, height, info); 442 EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out, quality); 443 444 } 445 446 /** 447 * Saves a chart to a file in JPEG format. 448 * 449 * @param file the file (<code>null</code> not permitted). 450 * @param chart the chart (<code>null</code> not permitted). 451 * @param width the image width. 452 * @param height the image height. 453 * 454 * @throws IOException if there are any I/O errors. 455 */ 456 public static void saveChartAsJPEG(File file, JFreeChart chart, 457 int width, int height) throws IOException { 458 459 // defer argument checking... 460 saveChartAsJPEG(file, chart, width, height, null); 461 462 } 463 464 /** 465 * Saves a chart to a file in JPEG format. 466 * 467 * @param file the file (<code>null</code> not permitted). 468 * @param quality the JPEG quality setting. 469 * @param chart the chart (<code>null</code> not permitted). 470 * @param width the image width. 471 * @param height the image height. 472 * 473 * @throws IOException if there are any I/O errors. 474 */ 475 public static void saveChartAsJPEG(File file, float quality, 476 JFreeChart chart, int width, int height) throws IOException { 477 478 // defer argument checking... 479 saveChartAsJPEG(file, quality, chart, width, height, null); 480 481 } 482 483 /** 484 * Saves a chart to a file in JPEG format. This method allows you to pass 485 * in a {@link ChartRenderingInfo} object, to collect information about the 486 * chart dimensions/entities. You will need this info if you want to 487 * create an HTML image map. 488 * 489 * @param file the file name (<code>null</code> not permitted). 490 * @param chart the chart (<code>null</code> not permitted). 491 * @param width the image width. 492 * @param height the image height. 493 * @param info the chart rendering info (<code>null</code> permitted). 494 * 495 * @throws IOException if there are any I/O errors. 496 */ 497 public static void saveChartAsJPEG(File file, JFreeChart chart, 498 int width, int height, ChartRenderingInfo info) throws IOException { 499 500 if (file == null) { 501 throw new IllegalArgumentException("Null 'file' argument."); 502 } 503 if (chart == null) { 504 throw new IllegalArgumentException("Null 'chart' argument."); 505 } 506 OutputStream out = new BufferedOutputStream(new FileOutputStream(file)); 507 try { 508 writeChartAsJPEG(out, chart, width, height, info); 509 } 510 finally { 511 out.close(); 512 } 513 514 } 515 516 /** 517 * Saves a chart to a file in JPEG format. This method allows you to pass 518 * in a {@link ChartRenderingInfo} object, to collect information about the 519 * chart dimensions/entities. You will need this info if you want to 520 * create an HTML image map. 521 * 522 * @param file the file name (<code>null</code> not permitted). 523 * @param quality the quality setting. 524 * @param chart the chart (<code>null</code> not permitted). 525 * @param width the image width. 526 * @param height the image height. 527 * @param info the chart rendering info (<code>null</code> permitted). 528 * 529 * @throws IOException if there are any I/O errors. 530 */ 531 public static void saveChartAsJPEG(File file, float quality, 532 JFreeChart chart, int width, int height, 533 ChartRenderingInfo info) throws IOException { 534 535 if (file == null) { 536 throw new IllegalArgumentException("Null 'file' argument."); 537 } 538 if (chart == null) { 539 throw new IllegalArgumentException("Null 'chart' argument."); 540 } 541 542 OutputStream out = new BufferedOutputStream(new FileOutputStream( 543 file)); 544 try { 545 writeChartAsJPEG(out, quality, chart, width, height, info); 546 } 547 finally { 548 out.close(); 549 } 550 551 } 552 553 /** 554 * Writes a {@link BufferedImage} to an output stream in JPEG format. 555 * 556 * @param out the output stream (<code>null</code> not permitted). 557 * @param image the image (<code>null</code> not permitted). 558 * 559 * @throws IOException if there are any I/O errors. 560 */ 561 public static void writeBufferedImageAsJPEG(OutputStream out, 562 BufferedImage image) throws IOException { 563 564 // defer argument checking... 565 writeBufferedImageAsJPEG(out, 0.75f, image); 566 567 } 568 569 /** 570 * Writes a {@link BufferedImage} to an output stream in JPEG format. 571 * 572 * @param out the output stream (<code>null</code> not permitted). 573 * @param quality the image quality (0.0f to 1.0f). 574 * @param image the image (<code>null</code> not permitted). 575 * 576 * @throws IOException if there are any I/O errors. 577 */ 578 public static void writeBufferedImageAsJPEG(OutputStream out, float quality, 579 BufferedImage image) throws IOException { 580 581 EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out, quality); 582 583 } 584 585 /** 586 * Writes a {@link BufferedImage} to an output stream in PNG format. 587 * 588 * @param out the output stream (<code>null</code> not permitted). 589 * @param image the image (<code>null</code> not permitted). 590 * 591 * @throws IOException if there are any I/O errors. 592 */ 593 public static void writeBufferedImageAsPNG(OutputStream out, 594 BufferedImage image) throws IOException { 595 596 EncoderUtil.writeBufferedImage(image, ImageFormat.PNG, out); 597 598 } 599 600 /** 601 * Writes a {@link BufferedImage} to an output stream in PNG format. 602 * 603 * @param out the output stream (<code>null</code> not permitted). 604 * @param image the image (<code>null</code> not permitted). 605 * @param encodeAlpha encode alpha? 606 * @param compression the compression level (0-9). 607 * 608 * @throws IOException if there are any I/O errors. 609 */ 610 public static void writeBufferedImageAsPNG(OutputStream out, 611 BufferedImage image, boolean encodeAlpha, int compression) 612 throws IOException { 613 614 EncoderUtil.writeBufferedImage(image, ImageFormat.PNG, out, 615 compression, encodeAlpha); 616 } 617 618 /** 619 * Encodes a {@link BufferedImage} to PNG format. 620 * 621 * @param image the image (<code>null</code> not permitted). 622 * 623 * @return A byte array in PNG format. 624 * 625 * @throws IOException if there is an I/O problem. 626 */ 627 public static byte[] encodeAsPNG(BufferedImage image) throws IOException { 628 return EncoderUtil.encode(image, ImageFormat.PNG); 629 } 630 631 /** 632 * Encodes a {@link BufferedImage} to PNG format. 633 * 634 * @param image the image (<code>null</code> not permitted). 635 * @param encodeAlpha encode alpha? 636 * @param compression the PNG compression level (0-9). 637 * 638 * @return The byte array in PNG format. 639 * 640 * @throws IOException if there is an I/O problem. 641 */ 642 public static byte[] encodeAsPNG(BufferedImage image, boolean encodeAlpha, 643 int compression) 644 throws IOException { 645 return EncoderUtil.encode(image, ImageFormat.PNG, compression, 646 encodeAlpha); 647 } 648 649 /** 650 * Writes an image map to an output stream. 651 * 652 * @param writer the writer (<code>null</code> not permitted). 653 * @param name the map name (<code>null</code> not permitted). 654 * @param info the chart rendering info (<code>null</code> not permitted). 655 * @param useOverLibForToolTips whether to use OverLIB for tooltips 656 * (http://www.bosrup.com/web/overlib/). 657 * 658 * @throws IOException if there are any I/O errors. 659 */ 660 public static void writeImageMap(PrintWriter writer, 661 String name, 662 ChartRenderingInfo info, 663 boolean useOverLibForToolTips) 664 throws IOException { 665 666 ToolTipTagFragmentGenerator toolTipTagFragmentGenerator = null; 667 if (useOverLibForToolTips) { 668 toolTipTagFragmentGenerator 669 = new OverLIBToolTipTagFragmentGenerator(); 670 } 671 else { 672 toolTipTagFragmentGenerator 673 = new StandardToolTipTagFragmentGenerator(); 674 } 675 ImageMapUtilities.writeImageMap(writer, name, info, 676 toolTipTagFragmentGenerator, 677 new StandardURLTagFragmentGenerator()); 678 679 } 680 681 /** 682 * Writes an image map to the specified writer. 683 * 684 * @param writer the writer (<code>null</code> not permitted). 685 * @param name the map name (<code>null</code> not permitted). 686 * @param info the chart rendering info (<code>null</code> not permitted). 687 * @param toolTipTagFragmentGenerator a generator for the HTML fragment 688 * that will contain the tooltip text (<code>null</code> not permitted 689 * if <code>info</code> contains tooltip information). 690 * @param urlTagFragmentGenerator a generator for the HTML fragment that 691 * will contain the URL reference (<code>null</code> not permitted if 692 * <code>info</code> contains URLs). 693 * 694 * @throws IOException if there are any I/O errors. 695 */ 696 public static void writeImageMap(PrintWriter writer, String name, 697 ChartRenderingInfo info, 698 ToolTipTagFragmentGenerator toolTipTagFragmentGenerator, 699 URLTagFragmentGenerator urlTagFragmentGenerator) 700 throws IOException { 701 702 writer.println(ImageMapUtilities.getImageMap(name, info, 703 toolTipTagFragmentGenerator, urlTagFragmentGenerator)); 704 } 705 706 /** 707 * Creates an HTML image map. This method maps to 708 * {@link ImageMapUtilities#getImageMap(String, ChartRenderingInfo, 709 * ToolTipTagFragmentGenerator, URLTagFragmentGenerator)}, using default 710 * generators. 711 * 712 * @param name the map name (<code>null</code> not permitted). 713 * @param info the chart rendering info (<code>null</code> not permitted). 714 * 715 * @return The map tag. 716 */ 717 public static String getImageMap(String name, ChartRenderingInfo info) { 718 return ImageMapUtilities.getImageMap(name, info, 719 new StandardToolTipTagFragmentGenerator(), 720 new StandardURLTagFragmentGenerator()); 721 } 722 723 /** 724 * Creates an HTML image map. This method maps directly to 725 * {@link ImageMapUtilities#getImageMap(String, ChartRenderingInfo, 726 * ToolTipTagFragmentGenerator, URLTagFragmentGenerator)}. 727 * 728 * @param name the map name (<code>null</code> not permitted). 729 * @param info the chart rendering info (<code>null</code> not permitted). 730 * @param toolTipTagFragmentGenerator a generator for the HTML fragment 731 * that will contain the tooltip text (<code>null</code> not permitted 732 * if <code>info</code> contains tooltip information). 733 * @param urlTagFragmentGenerator a generator for the HTML fragment that 734 * will contain the URL reference (<code>null</code> not permitted if 735 * <code>info</code> contains URLs). 736 * 737 * @return The map tag. 738 */ 739 public static String getImageMap(String name, ChartRenderingInfo info, 740 ToolTipTagFragmentGenerator toolTipTagFragmentGenerator, 741 URLTagFragmentGenerator urlTagFragmentGenerator) { 742 743 return ImageMapUtilities.getImageMap(name, info, 744 toolTipTagFragmentGenerator, urlTagFragmentGenerator); 745 746 } 747 748 }