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    }