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