/[classpath]/classpath/javax/imageio/ImageWriter.java
ViewVC logotype

Diff of /classpath/javax/imageio/ImageWriter.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.2.3 by gnu_andrew, Tue Aug 2 20:12:35 2005 UTC revision 1.1.2.4 by gnu_andrew, Wed Nov 2 00:43:39 2005 UTC
# Line 1  Line 1 
1  /* ImageWriter.java -- Encodes raster images.  /* ImageWriter.java -- Encodes raster images.
2     Copyright (C) 2004  Free Software Foundation, Inc.     Copyright (C) 2004, 2005  Free Software Foundation, Inc.
3    
4  This file is part of GNU Classpath.  This file is part of GNU Classpath.
5    
# Line 39  exception statement from your version. * Line 39  exception statement from your version. *
39  package javax.imageio;  package javax.imageio;
40    
41  import java.awt.Dimension;  import java.awt.Dimension;
42    import java.awt.Rectangle;
43    import java.awt.image.Raster;
44    import java.awt.image.RenderedImage;
45  import java.io.IOException;  import java.io.IOException;
46  import java.util.ArrayList;  import java.util.ArrayList;
47  import java.util.Iterator;  import java.util.Iterator;
48  import java.util.List;  import java.util.List;
49  import java.util.Locale;  import java.util.Locale;
50    import java.util.ResourceBundle;
51    import java.util.MissingResourceException;
52    
53  import javax.imageio.event.IIOWriteProgressListener;  import javax.imageio.event.IIOWriteProgressListener;
54  import javax.imageio.event.IIOWriteWarningListener;  import javax.imageio.event.IIOWriteWarningListener;
# Line 51  import javax.imageio.metadata.IIOMetadat Line 56  import javax.imageio.metadata.IIOMetadat
56    
57  import javax.imageio.spi.ImageWriterSpi;  import javax.imageio.spi.ImageWriterSpi;
58    
59    /**
60     * A class for encoding images within the ImageIO framework.
61     *
62     * An ImageWriter for a given format is instantiated by an
63     * ImageWriterSpi for that format.  ImageWriterSpis are registered
64     * with the IIORegistry.
65     *
66     * The ImageWriter API supports writing animated images that may have
67     * multiple frames; to support such images many methods take an index
68     * parameter.
69     *
70     * Images may also be written in multiple passes, where each
71     * successive pass increases the level of detail in the destination
72     * image.
73     */
74  public abstract class ImageWriter  public abstract class ImageWriter
75    implements ImageTranscoder    implements ImageTranscoder
76  {  {
77    private boolean aborted;    private boolean aborted;
78        
79    protected Locale[] availableLocales;    /**
80    protected Locale locale;     * All locales available for localization of warning messages, or
81    protected ImageWriterSpi originatingProvider;     * null if localization is not supported.
82    protected Object output;     */
83    protected List progressListeners = new ArrayList();    protected Locale[] availableLocales = null;
84    protected List warningListeners = new ArrayList();  
85    protected List warningLocales = new ArrayList();    /**
86       * The current locale used to localize warning messages, or null if
87       * no locale has been set.
88       */
89      protected Locale locale = null;
90    
91      /**
92       * The image writer SPI that instantiated this writer.
93       */
94      protected ImageWriterSpi originatingProvider = null;
95    
96      /**
97       * An ImageInputStream to which image data is written.
98       */
99      protected Object output = null;
100    
101      /**
102       * A list of installed progress listeners.  Initially null, meaning
103       * no installed listeners.
104       */
105      protected List progressListeners = null;
106    
107      /**
108       * A list of installed warning listeners.  Initially null, meaning
109       * no installed listeners.
110       */
111      protected List warningListeners = null;
112    
113      /**
114       * A list of warning locales corresponding with the list of
115       * installed warning listeners.  Initially null, meaning no locales.
116       */
117      protected List warningLocales = null;
118    
119      /**
120       * Construct an image writer.
121       *
122       * @param originatingProvider the provider that is constructing this
123       * image writer, or null
124       */
125    protected ImageWriter(ImageWriterSpi originatingProvider)    protected ImageWriter(ImageWriterSpi originatingProvider)
126    {    {
127      this.originatingProvider = originatingProvider;      this.originatingProvider = originatingProvider;
128    }    }
129    
130      /**
131       * Throw an IllegalStateException if output is null.
132       *
133       * @exception IllegalStateException if output is null
134       */
135    private void checkOutputSet()    private void checkOutputSet()
136    {    {
137      if (output == null)      if (output == null)
138        throw new IllegalStateException("no output set");        throw new IllegalStateException("no output set");
139    }    }
140        
141      /**
142       * Request that writing be aborted.  The unwritten portions of the
143       * destination image will be undefined.
144       *
145       * Writers should clear the abort flag before starting a write
146       * operation, then poll it periodically during the write operation.
147       */
148    public void abort()    public void abort()
149    {    {
150      aborted = true;      aborted = true;
151    }    }
152    
153      /**
154       * Check if the abort flag is set.
155       *
156       * @return true if the current write operation should be aborted,
157       * false otherwise
158       */
159    protected boolean abortRequested()    protected boolean abortRequested()
160    {    {
161      return aborted;      return aborted;
162    }    }
163    
164      /**
165       * Install a write progress listener.  This method will return
166       * immediately if listener is null.
167       *
168       * @param listener a write progress listener or null
169       */
170    public void addIIOWriteProgressListener(IIOWriteProgressListener listener)    public void addIIOWriteProgressListener(IIOWriteProgressListener listener)
171    {    {
172      if (listener == null)      if (listener == null)
173        return;        return;
174            if (progressListeners == null)
175          progressListeners = new ArrayList ();
176      progressListeners.add(listener);      progressListeners.add(listener);
177    }    }
178      
179      /**
180       * Install a write warning listener.  This method will return
181       * immediately if listener is null.  Warning messages sent to this
182       * listener will be localized using the current locale.  If the
183       * current locale is null then this writer will select a sensible
184       * default.
185       *
186       * @param listener a write warning listener
187       */
188    public void addIIOWriteWarningListener (IIOWriteWarningListener listener)    public void addIIOWriteWarningListener (IIOWriteWarningListener listener)
189    {    {
190      if (listener == null)      if (listener == null)
191        return;        return;
192            if (warningListeners == null)
193          warningListeners = new ArrayList ();
194      warningListeners.add(listener);      warningListeners.add(listener);
195    }    }
196    
197      /**
198       * Check whether a new empty image can be inserted at the given
199       * frame index.  Pixel values may be filled in later using the
200       * replacePixels methods.  Indices greater than the insertion index
201       * will be incremented.  If imageIndex is -1, the image will be
202       * appended at the end of the current image list.
203       *
204       * @param imageIndex the frame index
205       *
206       * @return true if an empty image can be inserted at imageIndex,
207       * false otherwise
208       *
209       * @exception IllegalStateException if output is null
210       * @exception IndexOutOfBoundsException if imageIndex is less than
211       * -1 or greater than the last index in the current image list
212       * @exception IOException if a write error occurs
213       */
214    public boolean canInsertEmpty(int imageIndex)    public boolean canInsertEmpty(int imageIndex)
215      throws IOException      throws IOException
216    {    {
# Line 108  public abstract class ImageWriter Line 218  public abstract class ImageWriter
218      return false;      return false;
219    }    }
220    
221      /**
222       * Check whether an image can be inserted at the given frame index.
223       * Indices greater than the insertion index will be incremented.  If
224       * imageIndex is -1, the image will be appended at the end of the
225       * current image list.
226       *
227       * @param imageIndex the frame index
228       *
229       * @return true if an image can be inserted at imageIndex, false
230       * otherwise
231       *
232       * @exception IllegalStateException if output is null
233       * @exception IndexOutOfBoundsException if imageIndex is less than
234       * -1 or greater than the last index in the current image list
235       * @exception IOException if a write error occurs
236       */
237    public boolean canInsertImage(int imageIndex)    public boolean canInsertImage(int imageIndex)
238      throws IOException      throws IOException
239    {    {
# Line 115  public abstract class ImageWriter Line 241  public abstract class ImageWriter
241      return false;      return false;
242    }    }
243    
244      /**
245       * Check whether an image can be removed from the given frame index.
246       * Indices greater than the removal index will be decremented.
247       *
248       * @param imageIndex the frame index
249       *
250       * @return true if an image can be removed from imageIndex, false
251       * otherwise
252       *
253       * @exception IllegalStateException if output is null
254       * @exception IndexOutOfBoundsException if imageIndex is less than 0
255       * or greater than the last index in the current image list
256       * @exception IOException if a write error occurs
257       */
258    public boolean canRemoveImage(int imageIndex)    public boolean canRemoveImage(int imageIndex)
259      throws IOException      throws IOException
260    {    {
# Line 122  public abstract class ImageWriter Line 262  public abstract class ImageWriter
262      return false;      return false;
263    }    }
264    
265      /**
266       * Check whether the metadata associated the image at the given
267       * frame index can be replaced.
268       *
269       * @param imageIndex the frame index
270       *
271       * @return true if the metadata associated with the image at
272       * imageIndex can be replaced, false otherwise
273       *
274       * @exception IllegalStateException if output is null
275       * @exception IndexOutOfBoundsException if imageIndex is less than 0
276       * or greater than the last index in the current image list
277       * @exception IOException if a write error occurs
278       */
279    public boolean canReplaceImageMetadata(int imageIndex)    public boolean canReplaceImageMetadata(int imageIndex)
280      throws IOException      throws IOException
281    {    {
# Line 129  public abstract class ImageWriter Line 283  public abstract class ImageWriter
283      return false;      return false;
284    }    }
285    
286      /**
287       * Check whether the pixels within the image at the given index can
288       * be replaced.
289       *
290       * @param imageIndex the frame index
291       *
292       * @return true if the pixels in the image at imageIndex can be
293       * replaced, false otherwise
294       *
295       * @exception IllegalStateException if output is null
296       * @exception IndexOutOfBoundsException if imageIndex is less than 0
297       * or greater than the last index in the current image list
298       * @exception IOException if a write error occurs
299       */
300    public boolean canReplacePixels(int imageIndex)    public boolean canReplacePixels(int imageIndex)
301      throws IOException      throws IOException
302    {    {
# Line 136  public abstract class ImageWriter Line 304  public abstract class ImageWriter
304      return false;      return false;
305    }    }
306    
307      /**
308       * Check whether the metadata associated the entire image stream can
309       * be replaced.
310       *
311       * @return true if the stream metadata can be replaced, false
312       * otherwise
313       *
314       * @exception IllegalStateException if output is null
315       * @exception IOException if a write error occurs
316       */
317    public boolean canReplaceStreamMetadata()    public boolean canReplaceStreamMetadata()
318      throws IOException      throws IOException
319    {    {
# Line 143  public abstract class ImageWriter Line 321  public abstract class ImageWriter
321      return false;      return false;
322    }    }
323    
324      /**
325       * Check whether an entire empty image, including empty metadata and
326       * empty thumbnails, can be written to the output stream, leaving
327       * pixel values to be filled in later using the replacePixels
328       * methods.
329       *
330       * @return true if an entire empty image can be written before its
331       * contents are filled in, false otherwise
332       *
333       * @exception IllegalStateException if output is null
334       * @exception IOException if a write error occurs
335       */
336    public boolean canWriteEmpty()    public boolean canWriteEmpty()
337      throws IOException      throws IOException
338    {    {
# Line 150  public abstract class ImageWriter Line 340  public abstract class ImageWriter
340      return false;      return false;
341    }    }
342    
343      /**
344       * Check if IIOImages containing raster data are supported.
345       *
346       * @return true if raster IIOImages are supported, false otherwise
347       */
348    public boolean canWriteRasters()    public boolean canWriteRasters()
349    {    {
350      return false;      return false;
351    }    }
352    
353      /**
354       * Check if an image can be appended at the end of the current list
355       * of images even if prior images have already been written.
356       *
357       * @return true if sequences of images can be written, false
358       * otherwise
359       */
360    public boolean canWriteSequence()    public boolean canWriteSequence()
361    {    {
362      return false;      return false;
363    }    }
364    
365      /**
366       * Clear the abort flag.
367       */
368    protected void clearAbortRequest()    protected void clearAbortRequest()
369    {    {
370      aborted = false;      aborted = false;
371    }    }
372      
373      /**
374       * Convert IIOMetadata from an input reader format, returning an
375       * IIOMetadata suitable for use by an image writer.
376       *
377       * The ImageTypeSpecifier specifies the destination image type.
378       *
379       * An optional ImageWriteParam argument is available in case the
380       * image writing parameters affect the metadata conversion.
381       *
382       * @param inData the metadata coming from an image reader
383       * @param imageType the output image type of the writer
384       * @param param the image writing parameters or null
385       *
386       * @return the converted metadata that should be used by the image
387       * writer, or null if this ImageTranscoder has no knowledge of the
388       * input metadata
389       *
390       * @exception IllegalArgumentException if either inData or imageType
391       * is null
392       */
393    public abstract IIOMetadata convertImageMetadata (IIOMetadata inData,    public abstract IIOMetadata convertImageMetadata (IIOMetadata inData,
394                                                      ImageTypeSpecifier imageType,                                                      ImageTypeSpecifier imageType,
395                                                      ImageWriteParam param);                                                      ImageWriteParam param);
396    
397      /**
398       * Convert IIOMetadata from an input stream format, returning an
399       * IIOMetadata suitable for use by an image writer.
400       *
401       * An optional ImageWriteParam argument is available in case the
402       * image writing parameters affect the metadata conversion.
403       *
404       * @param inData the metadata coming from an input image stream
405       * @param param the image writing parameters or null
406       *
407       * @return the converted metadata that should be used by the image
408       * writer, or null if this ImageTranscoder has no knowledge of the
409       * input metadata
410       *
411       * @exception IllegalArgumentException if inData is null
412       */
413    public abstract IIOMetadata convertStreamMetadata (IIOMetadata inData,    public abstract IIOMetadata convertStreamMetadata (IIOMetadata inData,
414                                                       ImageWriteParam param);                                                       ImageWriteParam param);
415    
416      /**
417       * Releases any resources allocated to this object.  Subsequent
418       * calls to methods on this object will produce undefined results.
419       *
420       * The default implementation does nothing; subclasses should use
421       * this method ensure that native resources are released.
422       */
423    public void dispose()    public void dispose()
424    {    {
425      // The default implementation is empty. Subclasses have to overwrite it.      // The default implementation is empty. Subclasses have to overwrite it.
426    }    }
427        
428      /**
429       * Retrieve the available locales.  Return null if no locales are
430       * available or a clone of availableLocales.
431       *
432       * @return an array of locales or null
433       */
434    public Locale[] getAvailableLocales()    public Locale[] getAvailableLocales()
435    {    {
436      return availableLocales;      return availableLocales;
437    }    }
438    
439      /**
440       * Get a metadata object appropriate for encoding an image specified
441       * by the given image type specifier and optional image write
442       * parameters.
443       *
444       * @param imageType an image type specifier
445       * @param param image writing parameters, or null
446       *
447       * @return a metadata object appropriate for encoding an image of
448       * the given type with the given parameters
449       */
450    public abstract IIOMetadata getDefaultImageMetadata (ImageTypeSpecifier imageType, ImageWriteParam param);    public abstract IIOMetadata getDefaultImageMetadata (ImageTypeSpecifier imageType, ImageWriteParam param);
451    
452      /**
453       * Get a metadata object appropriate for encoding the default image
454       * type handled by this writer, optionally considering image write
455       * parameters.
456       *
457       * @param param image writing parameters, or null
458       *
459       * @return a metadata object appropriate for encoding an image of
460       * the default type with the given parameters
461       */
462    public abstract IIOMetadata getDefaultStreamMetadata (ImageWriteParam param);    public abstract IIOMetadata getDefaultStreamMetadata (ImageWriteParam param);
463    
464      /**
465       * Retrieve the default write parameters for this writer's image
466       * format.
467       *
468       * The default implementation returns new ImageWriteParam().
469       *
470       * @return image writing parameters
471       */
472    public ImageWriteParam getDefaultWriteParam()    public ImageWriteParam getDefaultWriteParam()
473    {    {
474      return new ImageWriteParam(getLocale());      return new ImageWriteParam(getLocale());
475    }    }
476    
477      /**
478       * Get this writer's locale.  null is returned if the locale has not
479       * been set.
480       *
481       * @return this writer's locale, or null
482       */
483    public Locale getLocale()    public Locale getLocale()
484    {    {
485      return locale;      return locale;
486    }    }
487    
488    public int getNumThumbnailsSupported (ImageTypeSpecifier imageType, ImageWriteParam param,    /**
489                                          IIOMetadata streamMetadata, IIOMetadata imageMetadata)     * Get the number of thumbnails supported by this image writer,
490       * based on the given image type, image writing parameters, and
491       * stream and image metadata.  The image writing parameters are
492       * optional, in case they affect the number of thumbnails supported.
493       *
494       * @param imageType an image type specifier, or null
495       * @param param image writing parameters, or null
496       * @param streamMetadata the metadata associated with this stream,
497       * or null
498       * @param imageMetadata the metadata associated with this image, or
499       * null
500       *
501       * @return the number of thumbnails that this writer supports
502       * writing or -1 if the given information is insufficient
503       */
504      public int getNumThumbnailsSupported (ImageTypeSpecifier imageType,
505                                            ImageWriteParam param,
506                                            IIOMetadata streamMetadata,
507                                            IIOMetadata imageMetadata)
508    {    {
509      return 0;      return 0;
510    }    }
511    
512      /**
513       * Get the ImageWriterSpi that created this writer or null.
514       *
515       * @return an ImageWriterSpi, or null
516       */
517    public ImageWriterSpi getOriginatingProvider()    public ImageWriterSpi getOriginatingProvider()
518    {    {
519      return originatingProvider;      return originatingProvider;
520    }    }
521    
522      /**
523       * Get this reader's image output destination.  null is returned if
524       * the image destination has not been set.
525       *
526       * @return an image output destination object, or null
527       */
528    public Object getOutput()    public Object getOutput()
529    {    {
530      return output;      return output;
531    }    }
532    
533      /**
534       * Get the preferred sizes for thumbnails based on the given image
535       * type, image writing parameters, and stream and image metadata.
536       * The preferred sizes are returned in pairs of dimension values;
537       * the first value in the array is a dimension object representing
538       * the minimum thumbnail size, the second value is a dimension
539       * object representing a maximum thumbnail size.  The writer can
540       * select a size within the range given by each pair, or it can
541       * ignore these size hints.
542       *
543       * @param imageType an image type specifier, or null
544       * @param param image writing parameters, or null
545       * @param streamMetadata the metadata associated with this stream,
546       * or null
547       * @param imageMetadata the metadata associated with this image, or
548       * null
549       *
550       * @return an array of dimension pairs whose length is a multiple of
551       * 2, or null if there is no preferred size (any size is allowed) or
552       * if the size is unknown (insufficient information was provided)
553       */
554    public Dimension[] getPreferredThumbnailSizes (ImageTypeSpecifier imageType,    public Dimension[] getPreferredThumbnailSizes (ImageTypeSpecifier imageType,
555                                                   ImageWriteParam param,                                                   ImageWriteParam param,
556                                                   IIOMetadata streamMetadata,                                                   IIOMetadata streamMetadata,
# Line 220  public abstract class ImageWriter Line 559  public abstract class ImageWriter
559      return null;      return null;
560    }    }
561    
562      /**
563       * Notifies all installed write progress listeners that image
564       * loading has completed by calling their imageComplete methods.
565       */
566    protected void processImageComplete()    protected void processImageComplete()
567    {    {
568      Iterator it = progressListeners.iterator();      if (progressListeners != null)
   
     while (it.hasNext())  
569        {        {
570          IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();          Iterator it = progressListeners.iterator();
571          listener.imageComplete(this);  
572            while (it.hasNext())
573              {
574                IIOWriteProgressListener listener =
575                  (IIOWriteProgressListener) it.next();
576                listener.imageComplete(this);
577              }
578        }        }
579    }    }
580    
581      /**
582       * Notifies all installed write progress listeners that a certain
583       * percentage of the image has been loaded, by calling their
584       * imageProgress methods.
585       *
586       * @param percentageDone the percentage of image data that has been
587       * loaded
588       */
589    protected void processImageProgress(float percentageDone)    protected void processImageProgress(float percentageDone)
590    {    {
591      Iterator it = progressListeners.iterator();      if (progressListeners != null)
   
     while (it.hasNext())  
592        {        {
593          IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();          Iterator it = progressListeners.iterator();
594          listener.imageProgress(this, percentageDone);  
595            while (it.hasNext())
596              {
597                IIOWriteProgressListener listener =
598                  (IIOWriteProgressListener) it.next();
599                listener.imageProgress(this, percentageDone);
600              }
601        }        }
602    }    }
603    
604      /**
605       * Notifies all installed write progress listeners, by calling their
606       * imageStarted methods, that image loading has started on the given
607       * image.
608       *
609       * @param imageIndex the frame index of the image that has started
610       * loading
611       */
612    protected void processImageStarted(int imageIndex)    protected void processImageStarted(int imageIndex)
613    {    {
614      Iterator it = progressListeners.iterator();      if (progressListeners != null)
   
     while (it.hasNext())  
615        {        {
616          IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();          Iterator it = progressListeners.iterator();
617          listener.imageStarted(this, imageIndex);  
618            while (it.hasNext())
619              {
620                IIOWriteProgressListener listener =
621                  (IIOWriteProgressListener) it.next();
622                listener.imageStarted(this, imageIndex);
623              }
624        }        }
625    }    }
626    
627      /**
628       * Notifies all installed write progress listeners, by calling their
629       * thumbnailComplete methods, that a thumbnail has completed
630       * loading.
631       */
632    protected void processThumbnailComplete()    protected void processThumbnailComplete()
633    {    {
634      Iterator it = progressListeners.iterator();      if (progressListeners != null)
   
     while (it.hasNext())  
635        {        {
636          IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();          Iterator it = progressListeners.iterator();
637          listener.thumbnailComplete(this);  
638            while (it.hasNext())
639              {
640                IIOWriteProgressListener listener =
641                  (IIOWriteProgressListener) it.next();
642                listener.thumbnailComplete(this);
643              }
644        }        }
645    }    }
646    
647      /**
648       * Notifies all installed write progress listeners that a certain
649       * percentage of a thumbnail has been loaded, by calling their
650       * thumbnailProgress methods.
651       *
652       * @param percentageDone the percentage of thumbnail data that has
653       * been loaded
654       */
655    protected void processThumbnailProgress(float percentageDone)    protected void processThumbnailProgress(float percentageDone)
656    {    {
657      Iterator it = progressListeners.iterator();      if (progressListeners != null)
   
     while (it.hasNext())  
658        {        {
659          IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();          Iterator it = progressListeners.iterator();
660          listener.thumbnailProgress(this, percentageDone);  
661            while (it.hasNext())
662              {
663                IIOWriteProgressListener listener =
664                  (IIOWriteProgressListener) it.next();
665                listener.thumbnailProgress(this, percentageDone);
666              }
667        }        }
668    }    }
669    
670      /**
671       * Notifies all installed write progress listeners, by calling their
672       * imageStarted methods, that thumbnail loading has started on the
673       * given thumbnail of the given image.
674       *
675       * @param imageIndex the frame index of the image one of who's
676       * thumbnails has started loading
677       * @param thumbnailIndex the index of the thumbnail that has started
678       * loading
679       */
680    protected void processThumbnailStarted(int imageIndex, int thumbnailIndex)    protected void processThumbnailStarted(int imageIndex, int thumbnailIndex)
681    {    {
682      Iterator it = progressListeners.iterator();      if (progressListeners != null)
   
     while (it.hasNext())  
683        {        {
684          IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();          Iterator it = progressListeners.iterator();
685          listener.thumbnailStarted(this, imageIndex, thumbnailIndex);  
686            while (it.hasNext())
687              {
688                IIOWriteProgressListener listener =
689                  (IIOWriteProgressListener) it.next();
690                listener.thumbnailStarted(this, imageIndex, thumbnailIndex);
691              }
692        }        }
693    }    }
694    
695      /**
696       * Notifies all installed warning listeners, by calling their
697       * warningOccurred methods, that a warning message has been raised.
698       *
699       * @param imageIndex the index of the image that was being written
700       * when the warning was raised
701       * @param warning the warning message
702       *
703       * @exception IllegalArgumentException if warning is null
704       */
705    protected void processWarningOccurred(int imageIndex, String warning)    protected void processWarningOccurred(int imageIndex, String warning)
706    {    {
707      Iterator it = warningListeners.iterator();       if (warningListeners != null)
708          {
709            Iterator it = warningListeners.iterator();
710    
711            while (it.hasNext())
712              {
713                IIOWriteWarningListener listener =
714                  (IIOWriteWarningListener) it.next();
715                listener.warningOccurred(this, imageIndex, warning);
716              }
717          }
718      }
719    
720      /**
721       * Notify all installed warning listeners, by calling their
722       * warningOccurred methods, that a warning message has been raised.
723       * The warning message is retrieved from a resource bundle, using
724       * the given basename and keyword.
725       *
726       * @param imageIndex the index of the image that was being written
727       * when the warning was raised
728       * @param baseName the basename of the resource from which to
729       * retrieve the warning message
730       * @param keyword the keyword used to retrieve the warning from the
731       * resource bundle
732       *
733       * @exception IllegalArgumentException if either baseName or keyword
734       * is null
735       * @exception IllegalArgumentException if no resource bundle is
736       * found using baseName
737       * @exception IllegalArgumentException if the given keyword produces
738       * no results from the resource bundle
739       * @exception IllegalArgumentException if the retrieved object is
740       * not a String
741       */
742      protected void processWarningOccurred(int imageIndex,
743                                            String baseName,
744                                            String keyword)
745      {
746        if (baseName == null || keyword == null)
747          throw new IllegalArgumentException ("null argument");
748    
749        ResourceBundle b = null;
750    
751        try
752          {
753            b = ResourceBundle.getBundle(baseName, getLocale());
754          }
755        catch (MissingResourceException e)
756          {
757            throw new IllegalArgumentException ("no resource bundle found");
758          }
759    
760        Object str = null;
761    
762        try
763          {
764            str = b.getObject(keyword);
765          }
766        catch (MissingResourceException e)
767          {
768            throw new IllegalArgumentException ("no results found for keyword");
769          }
770    
771      while (it.hasNext())      if (! (str instanceof String))
772          throw new IllegalArgumentException ("retrieved object not a String");
773    
774        String warning = (String) str;
775    
776        if (warningListeners != null)
777        {        {
778          IIOWriteWarningListener listener = (IIOWriteWarningListener) it.next();          Iterator it = warningListeners.iterator();
779          listener.warningOccurred(this, imageIndex, warning);  
780            while (it.hasNext())
781              {
782                IIOWriteWarningListener listener =
783                  (IIOWriteWarningListener) it.next();
784                listener.warningOccurred(this, imageIndex, warning);
785              }
786        }        }
787    }    }
788    
789      /**
790       * Notifies all installed write progress listeners that image
791       * loading has been aborted by calling their writeAborted methods.
792       */
793    protected void processWriteAborted()    protected void processWriteAborted()
794    {    {
795      Iterator it = progressListeners.iterator();      if (progressListeners != null)
   
     while (it.hasNext())  
796        {        {
797          IIOWriteProgressListener listener = (IIOWriteProgressListener) it.next();          Iterator it = progressListeners.iterator();
798          listener.writeAborted(this);  
799            while (it.hasNext())
800              {
801                IIOWriteProgressListener listener =
802                  (IIOWriteProgressListener) it.next();
803                listener.writeAborted(this);
804              }
805        }        }
806    }    }
807    
808      /**
809       * Uninstall all write progress listeners.
810       */
811    public void removeAllIIOWriteProgressListeners()    public void removeAllIIOWriteProgressListeners()
812    {    {
813      progressListeners.clear();      if (progressListeners != null)
814          {
815            progressListeners.clear();
816          }
817    }    }
818    
819      /**
820       * Uninstall all write warning listeners.
821       */
822    public void removeAllIIOWriteWarningListeners()    public void removeAllIIOWriteWarningListeners()
823    {    {
824      progressListeners.clear();      if (progressListeners != null)
825          {
826            progressListeners.clear();
827          }
828    }    }
829      
830    public void removeIIOWriteProgressListener (IIOWriteProgressListener listener)    /**
831       * Uninstall the given write progress listener.
832       *
833       * @param listener the listener to remove
834       */
835      public void removeIIOWriteProgressListener (IIOWriteProgressListener listener)
836    {    {
837      if (listener == null)      if (listener == null)
838        return;        return;
839            if (progressListeners != null)
840      progressListeners.remove(listener);        {
841            progressListeners.remove(listener);
842          }
843    }    }
844        /**
845       * Uninstall the given write warning listener.
846       *
847       * @param listener the listener to remove
848       */
849    public void removeIIOWriteWarningListener (IIOWriteWarningListener listener)    public void removeIIOWriteWarningListener (IIOWriteWarningListener listener)
850    {    {
851      if (listener == null)      if (listener == null)
852        return;        return;
853            if (warningListeners != null)
854      warningListeners.remove(listener);        {
855            warningListeners.remove(listener);
856          }
857    }    }
858        /**
859       * Reset this writer's internal state.
860       */
861    public void reset()    public void reset()
862    {    {
863      setOutput(null);      setOutput(null);
# Line 343  public abstract class ImageWriter Line 867  public abstract class ImageWriter
867      clearAbortRequest();      clearAbortRequest();
868    }    }
869        
870      /**
871       * Set the current locale or use the default locale.
872       *
873       * @param locale the locale to set, or null
874       */
875    public void setLocale(Locale locale)    public void setLocale(Locale locale)
876    {    {
877      if (locale != null)      if (locale != null)
# Line 362  public abstract class ImageWriter Line 891  public abstract class ImageWriter
891      this.locale = locale;      this.locale = locale;
892    }    }
893    
894      /**
895       * Set the output destination of the given object.  The output
896       * destination must be set before many methods can be called on this
897       * writer. (see all ImageWriter methods that throw
898       * IllegalStateException).  If input is null then the current input
899       * source will be removed.
900       *
901       * @param input the output destination object
902       *
903       * @exception IllegalArgumentException if input is not a valid input
904       * source for this writer and is not an ImageInputStream
905       */
906    public void setOutput(Object output)    public void setOutput(Object output)
907    {    {
908      if (output != null)      if (output != null)
# Line 385  public abstract class ImageWriter Line 926  public abstract class ImageWriter
926      this.output = output;      this.output = output;
927    }    }
928    
929      /**
930       * Write an image stream, including thumbnails and metadata to the
931       * output stream.  The output must have been set prior to this
932       * method being called.  Metadata associated with the stream may be
933       * supplied, or it can be left null.  IIOImage may contain raster
934       * data if this writer supports rasters, or it will contain a
935       * rendered image.  Thumbnails are resized if need be.  Image
936       * writing parameters may be specified to affect writing, or may be
937       * left null.
938       *
939       * @param streamMetadata metadata associated with this stream, or
940       * null
941       * @param image an IIOImage containing image data, metadata and
942       * thumbnails to be written
943       * @param param image writing parameters, or null
944       *
945       * @exception IllegalStateException if output is null
946       * @exception UnsupportedOperationException if image contains raster
947       * data but this writer does not support rasters
948       * @exception IllegalArgumentException if image is null
949       * @exception IOException if a write error occurs
950       */
951    public abstract void write (IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param)    public abstract void write (IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param)
952      throws IOException;      throws IOException;
953    
954      /**
955       * Complete inserting an empty image in the output stream.
956       *
957       * @exception IllegalStateException if output is null
958       * @exception UnsupportedOperationException if inserting empty
959       * images is not supported
960       * @exception IllegalArgumentException if a call to
961       * prepareInsertEmpty was not called previous to this method being
962       * called (a sequence of prepareInsertEmpty calls must be terminated
963       * by a call to endInsertEmpty)
964       * @exception IllegalArgumentException if prepareWriteEmpty was
965       * called before this method being called (without a terminating
966       * call to endWriteEmpty)
967       * @exception IllegalArgumentException if prepareReplacePixels was
968       * called before this method being called (without a terminating
969       * call to endReplacePixels)
970       * @exception IOException if a write error occurs
971       */
972      public void endInsertEmpty ()
973        throws IOException
974      {
975        if (!canInsertEmpty(0))
976          throw new UnsupportedOperationException();
977      }
978    
979      /**
980       * Complete replacing pixels in an image in the output stream.
981       *
982       * @exception IllegalStateException if output is null
983       * @exception UnsupportedOperationException if replacing pixels is
984       * not supported by this writer
985       * @exception IllegalArgumentException if prepareReplacePixels was
986       * not called before this method being called
987       * @exception IOException if a write error occurs
988       */
989      public void endReplacePixels ()
990        throws IOException
991      {
992        if (!canReplacePixels(0))
993          throw new UnsupportedOperationException();
994      }
995    
996      /**
997       * Complete writing an empty image to the image output stream.
998       *
999       * @exception IllegalStateException if output is null
1000       * @exception UnsupportedOperationException if writing empty images
1001       * is not supported
1002       * @exception IllegalArgumentException if a call to
1003       * prepareWriteEmpty was not called previous to this method being
1004       * called (a sequence of prepareWriteEmpty calls must be terminated
1005       * by a call to endWriteEmpty)
1006       * @exception IllegalArgumentException if prepareInsertEmpty was
1007       * called before this method being called (without a terminating
1008       * call to endInsertEmpty)
1009       * @exception IllegalArgumentException if prepareReplacePixels was
1010       * called before this method being called (without a terminating
1011       * call to endReplacePixels)
1012       * @exception IOException if a write error occurs
1013       */
1014      public void endWriteEmpty ()
1015        throws IOException
1016      {
1017        if (!canWriteEmpty())
1018          throw new UnsupportedOperationException();
1019      }
1020    
1021      /**
1022       * Complete writing a sequence of images to the output stream.  This
1023       * method may patch header data and write out footer data.
1024       *
1025       * @exception IllegalStateException if output is null
1026       * @exception IllegalStateException if prepareWriteSequence has not
1027       * been called
1028       * @exception UnsupportedOperationException if writing a sequence of
1029       * images is not supported
1030       * @exception IOException if a write error occurs
1031       */
1032      public void endWriteSequence ()
1033        throws IOException
1034      {
1035        checkOutputSet();
1036        if (!canWriteSequence())
1037          throw new UnsupportedOperationException();
1038      }
1039    
1040      /**
1041       * Start inserting an empty image in the image output stream.  All
1042       * indices after the specified index are incremented.  An index of
1043       * -1 implies that the empty image should be appended to the end of
1044       * the current image list.
1045       *
1046       * The insertion that this method call starts is not complete until
1047       * endInsertEmpty is called.  prepareInsertEmpty cannot be called
1048       * again until endInsertEmpty is called and calls to
1049       * prepareWriteEmpty and prepareInsertEmpty may not be intersperced.
1050       *
1051       * @param imageIndex the image index
1052       * @param imageType the image type specifier
1053       * @param width the image width
1054       * @param height the image height
1055       * @param imageMetadata the image metadata, or null
1056       * @param thumbnails a list of thumbnails, or null
1057       * @param param image write parameters, or null
1058       *
1059       * @exception IllegalStateException if output is null
1060       * @exception UnsupportedOperationException if inserting empty
1061       * images is not supported
1062       * @exception IndexOutOfBoundsException if imageIndex is less than
1063       * -1 or greater than the last index in the current image list
1064       * @exception IllegalStateException if a previous call to
1065       * prepareInsertEmpty was made (without a terminating call to
1066       * endInsertEmpty)
1067       * @exception IllegalStateException if a previous call to
1068       * prepareWriteEmpty was made (without a terminating call to
1069       * endWriteEmpty)
1070       * @exception IllegalArgumentException if imageType is null or
1071       * thumbnails contain non-BufferedImage objects
1072       * @exception IllegalArgumentException if either width or height is
1073       * less than 1
1074       * @exception IOException if a write error occurs
1075       */
1076      public void prepareInsertEmpty (int imageIndex, ImageTypeSpecifier imageType,
1077                                      int width, int height,
1078                                      IIOMetadata imageMetadata,
1079                                      List thumbnails,
1080                                      ImageWriteParam param)
1081        throws IOException
1082      {
1083        if (!canInsertEmpty(imageIndex))
1084          throw new UnsupportedOperationException();
1085      }
1086    
1087      /**
1088       * Start the replacement of pixels within an image in the output
1089       * stream.  Output pixels will be clipped to lie within region.
1090       *
1091       * @param imageIndex the index of the image in which pixels are
1092       * being replaced
1093       * @param region the rectangle to which to limit pixel replacement
1094       *
1095       * @exception IllegalStateException if output is null
1096       * @exception UnsupportedOperationException if replacing pixels is
1097       * not supported
1098       * @exception IndexOutOfBoundsException if imageIndex is less than 0
1099       * or greater than the last index in the current image list
1100       * @exception IllegalStateException if a previous call to
1101       * prepareReplacePixels was made (without a terminating call to
1102       * endReplacePixels)
1103       * @exception IllegalArgumentException if either region.width or
1104       * region.height is less than 1, or if region is null
1105       * @exception IOException if a write error occurs
1106       */
1107      public void prepareReplacePixels (int imageIndex, Rectangle region)
1108        throws IOException
1109      {
1110        if (canReplacePixels(imageIndex))
1111          throw new UnsupportedOperationException();
1112      }
1113    
1114      /**
1115       * Start writing an empty image to the end of the image output
1116       * stream.
1117       *
1118       * The writing that this method call starts is not complete until
1119       * endWriteEmpty is called.  prepareWritetEmpty cannot be called
1120       * again until endWriteEmpty is called and calls to
1121       * prepareWriteEmpty and prepareInsertEmpty may not be intersperced.
1122       *
1123       * @param streamMetadata metadata associated with the stream, or null
1124       * @param imageType the image type specifier
1125       * @param width the image width
1126       * @param height the image height
1127       * @param imageMetadata the image metadata, or null
1128       * @param thumbnails a list of thumbnails, or null
1129       * @param param image write parameters, or null
1130       *
1131       * @exception IllegalStateException if output is null
1132       * @exception UnsupportedOperationException if writing empty images
1133       * is not supported
1134       * @exception IndexOutOfBoundsException if imageIndex is less than
1135       * -1 or greater than the last index in the current image list
1136       * @exception IllegalStateException if a previous call to
1137       * prepareInsertEmpty was made (without a terminating call to
1138       * endInsertEmpty)
1139       * @exception IllegalStateException if a previous call to
1140       * prepareWriteEmpty was made (without a terminating call to
1141       * endWriteEmpty)
1142       * @exception IllegalArgumentException if imageType is null or
1143       * thumbnails contain non-BufferedImage objects
1144       * @exception IllegalArgumentException if either width or height is
1145       * less than 1
1146       * @exception IOException if a write error occurs
1147       */
1148      public void prepareWriteEmpty (IIOMetadata streamMetadata,
1149                                     ImageTypeSpecifier imageType,
1150                                     int width, int height,
1151                                     IIOMetadata imageMetadata,
1152                                     List thumbnails,
1153                                     ImageWriteParam param)
1154        throws IOException
1155      {
1156        if (!canWriteEmpty())
1157          throw new UnsupportedOperationException();
1158      }
1159    
1160      /**
1161       * Start the writing of a sequence of images.
1162       *
1163       * @param streamMetadata the stream metadata, or null
1164       *
1165       * @exception IllegalStateException if output is null
1166       * @exception UnsupportedOperationException if writing sequences of
1167       * images is not supported
1168       * @exception IOException if a write error occurs
1169       */
1170      public void prepareWriteSequence (IIOMetadata streamMetadata)
1171        throws IOException
1172      {
1173        checkOutputSet();
1174        if (!canWriteSequence())
1175          throw new UnsupportedOperationException();
1176      }
1177    
1178      /**
1179       * Remove the image at the specified index from the output stream.
1180       *
1181       * @param imageIndex the frame index from which to remove the image
1182       *
1183       * @exception IllegalStateException if output is null
1184       * @exception UnsupportedOperationException if removing this image
1185       * is not supported
1186       * @exception IndexOutOfBoundsException if imageIndex is less than 0
1187       * or greater than the last index in the current image list
1188       * @exception IOException if a write error occurs
1189       */
1190      public void removeImage (int imageIndex)
1191        throws IOException
1192      {
1193        if (!canRemoveImage(imageIndex))
1194          throw new UnsupportedOperationException();
1195      }
1196    
1197      /**
1198       * Replace the metadata associated with the image at the given
1199       * index.
1200       *
1201       * @param imageIndex the index of the image whose metadata should be
1202       * replaced
1203       * @param imageMetadata the metadata, or null
1204       *
1205       * @exception IllegalStateException if output is null
1206       * @exception UnsupportedOperationException if replacing this
1207       * image's metadata is not supported
1208       * @exception IndexOutOfBoundsException if imageIndex is less than 0
1209       * or greater than the last index in the current image list
1210       * @exception IOException if a write error occurs
1211       */
1212      public void replaceImageMetadata (int imageIndex, IIOMetadata imageMetadata)
1213        throws IOException
1214      {
1215        if (!canReplaceImageMetadata(imageIndex))
1216          throw new UnsupportedOperationException();
1217      }
1218    
1219      /**
1220       * Replace a region of an image in the output stream with a portion
1221       * of the given rendered image.  The image data must be of the same
1222       * type as that in the output stream.  The destination region is
1223       * given by the image writing parameters and the source region is
1224       * the one given to prepareReplacePixels.
1225       *
1226       * @param image the rendered image with which to overwrite the image
1227       * region in the stream
1228       * @param param the image writing parameters
1229       *
1230       * @exception IllegalStateException if output is null
1231       * @exception UnsupportedOperationException if replacing pixels is
1232       * not supported
1233       * @exception IllegalStateException if prepareReplacePixels was not
1234       * called before this method was called
1235       * @exception IllegalArgumentException if image is null or if param
1236       * is null or if the overlap of the source and destination regions
1237       * contains no pixels or if the image types differ and no conversion
1238       * is possible
1239       * @exception IOException if a write error occurs
1240       */
1241      public void replacePixels (RenderedImage image,
1242                                 ImageWriteParam param)
1243        throws IOException
1244      {
1245        if (!canReplacePixels(0))
1246          throw new UnsupportedOperationException();
1247      }
1248    
1249      /**
1250       * Replace a region of an image in the output stream with a portion
1251       * of the given raster data.  The image data must be of the same
1252       * type as that in the output stream.  The destination region is
1253       * given by the image writing parameters and the source region is
1254       * the one given to prepareReplacePixels.
1255       *
1256       * @param raster the raster data with which to overwrite the image
1257       * region in the stream
1258       * @param param the image writing parameters
1259       *
1260       * @exception IllegalStateException if output is null
1261       * @exception UnsupportedOperationException if replacing pixels is
1262       * not supported
1263       * @exception IllegalStateException if prepareReplacePixels was not
1264       * called before this method was called
1265       * @exception UnsupportedOperationException if raster data is not
1266       * supported
1267       * @exception IllegalArgumentException if raster is null or if param
1268       * is null or if the overlap of the source and destination regions
1269       * contains no pixels or if the image types differ and no conversion
1270       * is possible
1271       * @exception IOException if a write error occurs
1272       */
1273      public void replacePixels (Raster raster, ImageWriteParam param)
1274        throws IOException
1275      {
1276        if (!canReplacePixels(0))
1277        throw new UnsupportedOperationException();
1278      }
1279    
1280      /**
1281       * Replace the metadata associated with this image stream.
1282       *
1283       * @param streamMetadata the stream metadata, or null
1284       *
1285       * @exception IllegalStateException if output is null
1286       * @exception UnsupportedOperationException if replacing the stream
1287       * metadata is not supported
1288       * @exception IOException if a write error occurs
1289       */
1290      public void replaceStreamMetadata (IIOMetadata streamMetadata)
1291        throws IOException
1292      {
1293        if (!canReplaceStreamMetadata())
1294          throw new UnsupportedOperationException();
1295      }
1296    
1297      /**
1298       * Write a rendered image to the output stream.
1299       *
1300       * @param image a rendered image containing image data to be written
1301       *
1302       * @exception IllegalStateException if output is null
1303       * @exception IllegalArgumentException if image is null
1304       * @exception IOException if a write error occurs
1305       */
1306      public void write (RenderedImage image)
1307        throws IOException
1308      {
1309        checkOutputSet();
1310        write (null, new IIOImage(image, null, null), null);
1311      }
1312    
1313      /**
1314       * Write a image data, metadata and thumbnails to the output stream.
1315       *
1316       * @param image image data, metadata and thumbnails to be written
1317       *
1318       * @exception IllegalStateException if output is null
1319       * @exception UnsupportedOperationException if image contains raster
1320       * data but this writer does not support rasters
1321       * @exception IllegalArgumentException if image is null
1322       * @exception IOException if a write error occurs
1323       */
1324      public void write (IIOImage image)
1325        throws IOException
1326      {
1327        checkOutputSet();
1328        write (null, image, null);
1329      }
1330    
1331      /**
1332       * Insert an image into the output stream.  Indices greater than the
1333       * specified index are incremented accordingly.  Specifying an index
1334       * of -1 causes the image to be appended at the end of the current
1335       * image list.
1336       *
1337       * @param imageIndex the frame index at which to insert the image
1338       * @param image the image data, metadata and thumbnails to be
1339       * inserted
1340       * @param the image write parameters, or null
1341       *
1342       * @exception IllegalStateException if output is null
1343       * @exception UnsupportedOperationException if image insertion is
1344       * not supported
1345       * @exception IllegalArgumentException if image is null
1346       * @exception IndexOutOfBoundsException if imageIndex is less than
1347       * -1 or greater than the last index in the current image list
1348       * @exception UnsupportedOperationException if image contains raster
1349       * data but this writer does not support rasters
1350       * @exception IOException if a write error occurs
1351       */
1352      public void writeInsert (int imageIndex, IIOImage image, ImageWriteParam param)
1353        throws IOException
1354      {
1355        if (!canInsertImage(imageIndex))
1356          throw new UnsupportedOperationException();
1357      }
1358    
1359      /**
1360       * Write a sequence of images, including thumbnails and metadata, to
1361       * the output stream.  The output must have been set prior to this
1362       * method being called.  Metadata associated with the stream may be
1363       * supplied, or it can be left null.  IIOImage may contain raster
1364       * data if this writer supports rasters, or it will contain a
1365       * rendered image.  Thumbnails are resized if need be.  Image
1366       * writing parameters may be specified to affect writing, or may be
1367       * left null.
1368       *
1369       * @param streamMetadata metadata associated with this stream, or
1370       * null
1371       * @param image an IIOImage containing image data, metadata and
1372       * thumbnails to be written
1373       * @param param image writing parameters, or null
1374       *
1375       * @exception IllegalStateException if output is null
1376       * @exception UnsupportedOperationException if writing sequences of
1377       * images is not supported
1378       * @exception IllegalArgumentException if image is null
1379       * @exception UnsupportedOperationException if image contains raster
1380       * data but this writer does not support rasters
1381       * @exception IOException if a write error occurs
1382       */
1383      public void writeToSequence (IIOImage image, ImageWriteParam param)
1384        throws IOException
1385      {
1386        if (!canWriteSequence())
1387          throw new UnsupportedOperationException();
1388      }
1389  }  }

Legend:
Removed from v.1.1.2.3  
changed lines
  Added in v.1.1.2.4

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26