001    /* ===========================================================
002     * JFreeChart : a free chart library for the Java(tm) platform
003     * ===========================================================
004     *
005     * (C) Copyright 2000-2005, 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-2005, 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.1 2005/10/25 16:50:20 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     *
072     */
073    
074    package org.jfree.chart;
075    
076    import java.awt.Graphics2D;
077    import java.awt.geom.AffineTransform;
078    import java.awt.geom.Rectangle2D;
079    import java.awt.image.BufferedImage;
080    import java.io.BufferedOutputStream;
081    import java.io.File;
082    import java.io.FileOutputStream;
083    import java.io.IOException;
084    import java.io.OutputStream;
085    import java.io.PrintWriter;
086    
087    import org.jfree.chart.imagemap.ImageMapUtilities;
088    import org.jfree.chart.imagemap.OverLIBToolTipTagFragmentGenerator;
089    import org.jfree.chart.imagemap.StandardToolTipTagFragmentGenerator;
090    import org.jfree.chart.imagemap.StandardURLTagFragmentGenerator;
091    import org.jfree.chart.imagemap.ToolTipTagFragmentGenerator;
092    import org.jfree.chart.imagemap.URLTagFragmentGenerator;
093    
094    import org.jfree.chart.encoders.EncoderUtil;
095    import org.jfree.chart.encoders.ImageFormat;
096    
097    /**
098     * A collection of utility methods for JFreeChart.  Includes methods for 
099     * converting charts to image formats (PNG and JPEG) plus creating simple HTML 
100     * image maps.
101     */
102    public abstract class ChartUtilities {
103    
104        /**
105         * Writes a chart to an output stream in PNG format.
106         *
107         * @param out  the output stream (<code>null</code> not permitted).
108         * @param chart  the chart (<code>null</code> not permitted).
109         * @param width  the image width.
110         * @param height  the image height.
111         *
112         * @throws IOException if there are any I/O errors.
113         */
114        public static void writeChartAsPNG(OutputStream out,
115                                           JFreeChart chart,
116                                           int width,
117                                           int height) throws IOException {
118    
119            // defer argument checking...
120            writeChartAsPNG(out, chart, width, height, null);
121    
122        }
123    
124        /**
125         * Writes a chart to an output stream in PNG format.
126         *
127         * @param out  the output stream (<code>null</code> not permitted).
128         * @param chart  the chart (<code>null</code> not permitted).
129         * @param width  the image width.
130         * @param height  the image height.
131         * @param encodeAlpha  encode alpha?
132         * @param compression  the compression level (0-9).
133         *
134         * @throws IOException if there are any I/O errors.
135         */
136        public static void writeChartAsPNG(OutputStream out,
137                                           JFreeChart chart,
138                                           int width,
139                                           int height,
140                                           boolean encodeAlpha,
141                                           int compression) throws IOException {
142    
143            // defer argument checking...
144            ChartUtilities.writeChartAsPNG(
145                out, chart, width, height, null, encodeAlpha, compression
146            );
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,
165                                           JFreeChart chart,
166                                           int width,
167                                           int height,
168                                           ChartRenderingInfo info) 
169            throws IOException {
170    
171            if (chart == null) {
172                throw new IllegalArgumentException("Null 'chart' argument.");
173            }
174            BufferedImage bufferedImage 
175                = chart.createBufferedImage(width, height, info);
176            EncoderUtil.writeBufferedImage(bufferedImage, ImageFormat.PNG, out);
177        }
178    
179        /**
180         * Writes a chart to an output stream in PNG format.  This method allows 
181         * you to pass in a {@link ChartRenderingInfo} object, to collect 
182         * information about the chart dimensions/entities.  You will need this 
183         * info if you want to create an HTML image map.
184         *
185         * @param out  the output stream (<code>null</code> not permitted).
186         * @param chart  the chart (<code>null</code> not permitted).
187         * @param width  the image width.
188         * @param height  the image height.
189         * @param info  carries back chart rendering info (<code>null</code> 
190         *              permitted).
191         * @param encodeAlpha  encode alpha?
192         * @param compression  the PNG compression level (0-9).
193         *
194         * @throws IOException if there are any I/O errors.
195         */
196        public static void writeChartAsPNG(OutputStream out,
197                                           JFreeChart chart,
198                                           int width, int height,
199                                           ChartRenderingInfo info,
200                                           boolean encodeAlpha,
201                                           int compression) throws IOException {
202    
203            if (out == null) {
204                throw new IllegalArgumentException("Null 'out' argument.");
205            }
206            if (chart == null) {
207                throw new IllegalArgumentException("Null 'chart' argument.");
208            }
209            BufferedImage chartImage = chart.createBufferedImage(
210                width, height, BufferedImage.TYPE_INT_ARGB, info
211            );
212            ChartUtilities.writeBufferedImageAsPNG(
213                out, chartImage, encodeAlpha, compression
214            );
215    
216        }
217    
218        /**
219         * Writes a scaled version of a chart to an output stream in PNG format.
220         *
221         * @param out  the output stream (<code>null</code> not permitted).
222         * @param chart  the chart (<code>null</code> not permitted).
223         * @param width  the unscaled chart width.
224         * @param height  the unscaled chart height.
225         * @param widthScaleFactor  the horizontal scale factor.
226         * @param heightScaleFactor  the vertical scale factor.
227         *
228         * @throws IOException if there are any I/O problems.
229         */
230        public static void writeScaledChartAsPNG(OutputStream out,
231                                                 JFreeChart chart,
232                                                 int width,
233                                                 int height,
234                                                 int widthScaleFactor,
235                                                 int heightScaleFactor) 
236            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(
260                (int) desiredWidth, (int) desiredHeight, BufferedImage.TYPE_INT_ARGB
261            );
262            Graphics2D g2 = image.createGraphics();
263    
264            if (scale) {
265                AffineTransform saved = g2.getTransform();
266                g2.transform(AffineTransform.getScaleInstance(scaleX, scaleY));
267                chart.draw(
268                    g2, new Rectangle2D.Double(0, 0, defaultWidth, defaultHeight), 
269                    null, null
270                );
271                g2.setTransform(saved);
272                g2.dispose();
273            }
274            else {
275                chart.draw(
276                    g2, new Rectangle2D.Double(0, 0, defaultWidth, defaultHeight), 
277                    null, null
278                );
279            }
280            out.write(encodeAsPNG(image));
281    
282        }
283    
284        /**
285         * Saves a chart to the specified file in PNG format.
286         *
287         * @param file  the file name (<code>null</code> not permitted).
288         * @param chart  the chart (<code>null</code> not permitted).
289         * @param width  the image width.
290         * @param height  the image height.
291         *
292         * @throws IOException if there are any I/O errors.
293         */
294        public static void saveChartAsPNG(File file,
295                                          JFreeChart chart,
296                                          int width,
297                                          int height) throws IOException {
298    
299            // defer argument checking...
300            saveChartAsPNG(file, chart, width, height, null);
301    
302        }
303    
304        /**
305         * Saves a chart to a file in PNG format.  This method allows you to pass 
306         * in a {@link ChartRenderingInfo} object, to collect information about the 
307         * chart dimensions/entities.  You will need this info if you want to 
308         * create an HTML image map.
309         *
310         * @param file  the file (<code>null</code> not permitted).
311         * @param chart  the chart (<code>null</code> not permitted).
312         * @param width  the image width.
313         * @param height  the image height.
314         * @param info  the chart rendering info (<code>null</code> permitted).
315         *
316         * @throws IOException if there are any I/O errors.
317         */
318        public static void saveChartAsPNG(File file,
319                                          JFreeChart chart,
320                                          int width,
321                                          int height,
322                                          ChartRenderingInfo info) 
323            throws IOException {
324    
325            if (file == null) {
326                throw new IllegalArgumentException("Null 'file' argument.");
327            }
328            OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
329            ChartUtilities.writeChartAsPNG(out, chart, width, height, info);
330            out.close();
331        }
332    
333        /**
334         * Saves a chart to a file in PNG format.  This method allows you to pass 
335         * in a {@link ChartRenderingInfo} object, to collect information about the 
336         * chart dimensions/entities.  You will need this info if you want to 
337         * create an HTML image map.
338         *
339         * @param file  the file (<code>null</code> not permitted).
340         * @param chart  the chart (<code>null</code> not permitted).
341         * @param width  the image width.
342         * @param height  the image height.
343         * @param info  the chart rendering info (<code>null</code> permitted).
344         * @param encodeAlpha  encode alpha?
345         * @param compression  the PNG compression level (0-9).
346         *
347         * @throws IOException if there are any I/O errors.
348         */
349        public static void saveChartAsPNG(File file,
350                                          JFreeChart chart,
351                                          int width,
352                                          int height,
353                                          ChartRenderingInfo info,
354                                          boolean encodeAlpha,
355                                          int compression) throws IOException {
356    
357            if (file == null) {
358                throw new IllegalArgumentException("Null 'file' argument.");
359            }
360            if (chart == null) {
361                throw new IllegalArgumentException("Null 'chart' argument.");
362            }
363    
364            OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
365            writeChartAsPNG(
366                out, chart, width, height, info, encodeAlpha, compression
367            );
368            out.close();
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 chart  the chart (<code>null</code> not permitted).
378         * @param width  the image width.
379         * @param height  the image height.
380         *
381         * @throws IOException if there are any I/O errors.
382         */
383        public static void writeChartAsJPEG(OutputStream out,
384                                            JFreeChart chart,
385                                            int width,
386                                            int height) throws IOException {
387    
388            // defer argument checking...
389            writeChartAsJPEG(out, chart, width, height, null);
390    
391        }
392    
393        /**
394         * Writes a chart to an output stream in JPEG format.  Please note that
395         * JPEG is a poor format for chart images, use PNG if possible.
396         *
397         * @param out  the output stream (<code>null</code> not permitted).
398         * @param quality  the quality setting.
399         * @param chart  the chart (<code>null</code> not permitted).
400         * @param width  the image width.
401         * @param height  the image height.
402         *
403         * @throws IOException if there are any I/O errors.
404         */
405        public static void writeChartAsJPEG(OutputStream out,
406                                            float quality,
407                                            JFreeChart chart,
408                                            int width,
409                                            int height) throws IOException {
410    
411            // defer argument checking...
412            ChartUtilities.writeChartAsJPEG(
413                out, quality, chart, width, height, null
414            );
415    
416        }
417    
418        /**
419         * Writes a chart to an output stream in JPEG format. This method allows 
420         * you to pass in a {@link ChartRenderingInfo} object, to collect 
421         * information about the chart dimensions/entities.  You will need this 
422         * info if you want to create an HTML image map.
423         *
424         * @param out  the output stream (<code>null</code> not permitted).
425         * @param chart  the chart (<code>null</code> not permitted).
426         * @param width  the image width.
427         * @param height  the image height.
428         * @param info  the chart rendering info (<code>null</code> permitted).
429         *
430         * @throws IOException if there are any I/O errors.
431         */
432        public static void writeChartAsJPEG(OutputStream out,
433                                            JFreeChart chart,
434                                            int width,
435                                            int height,
436                                            ChartRenderingInfo info) 
437            throws IOException {
438    
439            if (chart == null) {
440                throw new IllegalArgumentException("Null 'chart' argument.");
441            }
442            BufferedImage image = chart.createBufferedImage(width, height, info);
443            EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out);
444    
445        }
446    
447        /**
448         * Writes a chart to an output stream in JPEG format.  This method allows 
449         * you to pass in a {@link ChartRenderingInfo} object, to collect 
450         * information about the chart dimensions/entities.  You will need this 
451         * info if you want to create an HTML image map.
452         *
453         * @param out  the output stream (<code>null</code> not permitted).
454         * @param quality  the output quality (0.0f to 1.0f).
455         * @param chart  the chart (<code>null</code> not permitted).
456         * @param width  the image width.
457         * @param height  the image height.
458         * @param info  the chart rendering info (<code>null</code> permitted).
459         *
460         * @throws IOException if there are any I/O errors.
461         */
462        public static void writeChartAsJPEG(OutputStream out,
463                                            float quality,
464                                            JFreeChart chart,
465                                            int width,
466                                            int height,
467                                            ChartRenderingInfo info) 
468            throws IOException {
469    
470            if (chart == null) {
471                throw new IllegalArgumentException("Null 'chart' argument.");
472            }
473            BufferedImage image = chart.createBufferedImage(width, height, info);
474            EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out, quality);
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 chart  the chart (<code>null</code> not permitted).
483         * @param width  the image width.
484         * @param height  the image height.
485         *
486         * @throws IOException if there are any I/O errors.
487         */
488        public static void saveChartAsJPEG(File file,
489                                           JFreeChart chart,
490                                           int width,
491                                           int height) throws IOException {
492    
493            // defer argument checking...
494            saveChartAsJPEG(file, chart, width, height, null);
495    
496        }
497    
498        /**
499         * Saves a chart to a file in JPEG format.
500         *
501         * @param file  the file (<code>null</code> not permitted).
502         * @param quality  the JPEG quality setting.
503         * @param chart  the chart (<code>null</code> not permitted).
504         * @param width  the image width.
505         * @param height  the image height.
506         *
507         * @throws IOException if there are any I/O errors.
508         */
509        public static void saveChartAsJPEG(File file,
510                                           float quality,
511                                           JFreeChart chart,
512                                           int width,
513                                           int height) throws IOException {
514    
515            // defer argument checking...
516            saveChartAsJPEG(file, quality, chart, width, height, null);
517    
518        }
519    
520        /**
521         * Saves a chart to a file in JPEG format.  This method allows you to pass 
522         * in a {@link ChartRenderingInfo} object, to collect information about the 
523         * chart dimensions/entities.  You will need this info if you want to 
524         * create an HTML image map.
525         *
526         * @param file  the file name (<code>null</code> not permitted).
527         * @param chart  the chart (<code>null</code> not permitted).
528         * @param width  the image width.
529         * @param height  the image height.
530         * @param info  the chart rendering info (<code>null</code> permitted).
531         *
532         * @throws IOException if there are any I/O errors.
533         */
534        public static void saveChartAsJPEG(File file,
535                                           JFreeChart chart,
536                                           int width,
537                                           int height,
538                                           ChartRenderingInfo info) 
539            throws IOException {
540    
541            if (file == null) {
542                throw new IllegalArgumentException("Null 'file' argument.");
543            }
544            if (chart == null) {
545                throw new IllegalArgumentException("Null 'chart' argument.");
546            }
547            OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
548            writeChartAsJPEG(out, chart, width, height, info);
549            out.close();
550    
551        }
552    
553        /**
554         * Saves a chart to a file in JPEG format.  This method allows you to pass 
555         * in a {@link ChartRenderingInfo} object, to collect information about the 
556         * chart dimensions/entities.  You will need this info if you want to 
557         * create an HTML image map.
558         *
559         * @param file  the file name (<code>null</code> not permitted).
560         * @param quality  the quality setting.
561         * @param chart  the chart (<code>null</code> not permitted).
562         * @param width  the image width.
563         * @param height  the image height.
564         * @param info  the chart rendering info (<code>null</code> permitted).
565         *
566         * @throws IOException if there are any I/O errors.
567         */
568        public static void saveChartAsJPEG(File file,
569                                           float quality,
570                                           JFreeChart chart,
571                                           int width,
572                                           int height,
573                                           ChartRenderingInfo info) 
574            throws IOException {
575    
576            if (file == null) {
577                throw new IllegalArgumentException("Null 'file' argument.");
578            }
579            if (chart == null) {
580                throw new IllegalArgumentException("Null 'chart' argument.");
581            }
582            OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
583            writeChartAsJPEG(out, quality, chart, width, height, info);
584            out.close();
585    
586        }
587    
588        /**
589         * Writes a {@link BufferedImage} to an output stream in JPEG format.
590         *
591         * @param out  the output stream (<code>null</code> not permitted).
592         * @param image  the image (<code>null</code> not permitted).
593         *
594         * @throws IOException if there are any I/O errors.
595         */
596        public static void writeBufferedImageAsJPEG(OutputStream out, 
597                                                    BufferedImage image)
598            throws IOException {
599    
600            // defer argument checking...
601            writeBufferedImageAsJPEG(out, 0.75f, image);
602    
603        }
604    
605        /**
606         * Writes a {@link BufferedImage} to an output stream in JPEG format.
607         *
608         * @param out  the output stream (<code>null</code> not permitted).
609         * @param quality  the image quality (0.0f to 1.0f).
610         * @param image  the image (<code>null</code> not permitted).
611         *
612         * @throws IOException if there are any I/O errors.
613         */
614        public static void writeBufferedImageAsJPEG(OutputStream out, float quality,
615                                                    BufferedImage image) 
616            throws IOException {
617    
618            EncoderUtil.writeBufferedImage(image, ImageFormat.JPEG, out, quality);
619    
620        }
621    
622        /**
623         * Writes a {@link BufferedImage} to an output stream in PNG format.
624         *
625         * @param out  the output stream (<code>null</code> not permitted).
626         * @param image  the image (<code>null</code> not permitted).
627         *
628         * @throws IOException if there are any I/O errors.
629         */
630        public static void writeBufferedImageAsPNG(OutputStream out, 
631                                                   BufferedImage image)
632            throws IOException {
633    
634            EncoderUtil.writeBufferedImage(image, ImageFormat.PNG, out);
635    
636        }
637    
638        /**
639         * Writes a {@link BufferedImage} to an output stream in PNG format.
640         *
641         * @param out  the output stream (<code>null</code> not permitted).
642         * @param image  the image (<code>null</code> not permitted).
643         * @param encodeAlpha  encode alpha?
644         * @param compression  the compression level (0-9).
645         *
646         * @throws IOException if there are any I/O errors.
647         */
648        public static void writeBufferedImageAsPNG(OutputStream out,
649                                                   BufferedImage image,
650                                                   boolean encodeAlpha,
651                                                   int compression) 
652            throws IOException {
653    
654            EncoderUtil.writeBufferedImage(
655                image, ImageFormat.PNG, out, compression, encodeAlpha
656            );
657        }
658    
659        /**
660         * Encodes a {@link BufferedImage} to PNG format.
661         *
662         * @param image  the image (<code>null</code> not permitted).
663         *
664         * @return A byte array in PNG format.
665         * 
666         * @throws IOException if there is an I/O problem.
667         */
668        public static byte[] encodeAsPNG(BufferedImage image) throws IOException {
669            return EncoderUtil.encode(image, ImageFormat.PNG);
670        }
671    
672        /**
673         * Encodes a {@link BufferedImage} to PNG format.
674         *
675         * @param image  the image (<code>null</code> not permitted).
676         * @param encodeAlpha  encode alpha?
677         * @param compression  the PNG compression level (0-9).
678         *
679         * @return The byte array in PNG format.
680         * 
681         * @throws IOException if there is an I/O problem.
682         */
683        public static byte[] encodeAsPNG(BufferedImage image, boolean encodeAlpha, 
684                                         int compression) 
685            throws IOException {
686            return EncoderUtil.encode(
687                image, ImageFormat.PNG, compression, encodeAlpha
688            );
689        }
690    
691        /**
692         * Writes an image map to an output stream.
693         *
694         * @param writer  the writer (<code>null</code> not permitted).
695         * @param name  the map name (<code>null</code> not permitted).
696         * @param info  the chart rendering info (<code>null</code> not permitted).
697         * @param useOverLibForToolTips  whether to use OverLIB for tooltips
698         *                               (http://www.bosrup.com/web/overlib/).
699         *
700         * @throws IOException if there are any I/O errors.
701         */
702        public static void writeImageMap(PrintWriter writer,
703                                         String name,
704                                         ChartRenderingInfo info,
705                                         boolean useOverLibForToolTips) 
706            throws IOException {
707    
708            ToolTipTagFragmentGenerator toolTipTagFragmentGenerator = null;
709            if (useOverLibForToolTips) {
710                toolTipTagFragmentGenerator 
711                    = new OverLIBToolTipTagFragmentGenerator();
712            }
713            else {
714                toolTipTagFragmentGenerator 
715                    = new StandardToolTipTagFragmentGenerator();
716            }
717            ImageMapUtilities.writeImageMap(
718                writer, name, info, toolTipTagFragmentGenerator, 
719                new StandardURLTagFragmentGenerator()
720            );
721    
722        }
723    
724        /**
725         * Writes an image map to an output stream.
726         *
727         * @param writer  the writer (<code>null</code> not permitted).
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  the tool tip generator.
731         * @param urlTagFragmentGenerator  the url generator.
732         *
733         * @throws IOException if there are any I/O errors.
734         */
735        public static void writeImageMap(PrintWriter writer, String name, 
736                ChartRenderingInfo info, 
737                ToolTipTagFragmentGenerator toolTipTagFragmentGenerator,
738                URLTagFragmentGenerator urlTagFragmentGenerator)
739                throws IOException {
740    
741            writer.println(
742                ImageMapUtilities.getImageMap(
743                    name, info, toolTipTagFragmentGenerator, urlTagFragmentGenerator
744                )
745            );
746        }
747    
748        /**
749         * Creates an HTML image map.
750         *
751         * @param name  the map name (<code>null</code> not permitted).
752         * @param info  the chart rendering info (<code>null</code> not permitted).
753         *
754         * @return The map tag.
755         */
756        public static String getImageMap(String name, ChartRenderingInfo info) {
757            return ImageMapUtilities.getImageMap(
758                name,
759                info,
760                new StandardToolTipTagFragmentGenerator(),
761                new StandardURLTagFragmentGenerator()
762            );
763        }
764    
765        /**
766         * Creates an HTML image map.
767         *
768         * @param name  the map name (<code>null</code> not permitted).
769         * @param info  the chart rendering info (<code>null</code> not permitted).
770         * @param toolTipTagFragmentGenerator  the tool tip generator.
771         * @param urlTagFragmentGenerator  the url generator.
772         *
773         * @return The map tag.
774         */
775        public static String getImageMap(String name,
776                         ChartRenderingInfo info,
777                         ToolTipTagFragmentGenerator toolTipTagFragmentGenerator,
778                         URLTagFragmentGenerator urlTagFragmentGenerator) {
779    
780            return ImageMapUtilities.getImageMap(
781                name, info, toolTipTagFragmentGenerator, urlTagFragmentGenerator
782            );
783            
784        }
785    
786    }