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