mirror of git://gcc.gnu.org/git/gcc.git
1391 lines
45 KiB
Java
1391 lines
45 KiB
Java
/* ImageWriter.java -- Encodes raster images.
|
|
Copyright (C) 2004, 2005 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
|
|
package javax.imageio;
|
|
|
|
import java.awt.Dimension;
|
|
import java.awt.Rectangle;
|
|
import java.awt.image.BufferedImage;
|
|
import java.awt.image.Raster;
|
|
import java.awt.image.RenderedImage;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.ResourceBundle;
|
|
import java.util.MissingResourceException;
|
|
|
|
import javax.imageio.event.IIOWriteProgressListener;
|
|
import javax.imageio.event.IIOWriteWarningListener;
|
|
import javax.imageio.metadata.IIOMetadata;
|
|
|
|
import javax.imageio.spi.ImageWriterSpi;
|
|
|
|
/**
|
|
* A class for encoding images within the ImageIO framework.
|
|
*
|
|
* An ImageWriter for a given format is instantiated by an
|
|
* ImageWriterSpi for that format. ImageWriterSpis are registered
|
|
* with the IIORegistry.
|
|
*
|
|
* The ImageWriter API supports writing animated images that may have
|
|
* multiple frames; to support such images many methods take an index
|
|
* parameter.
|
|
*
|
|
* Images may also be written in multiple passes, where each
|
|
* successive pass increases the level of detail in the destination
|
|
* image.
|
|
*/
|
|
public abstract class ImageWriter
|
|
implements ImageTranscoder
|
|
{
|
|
private boolean aborted;
|
|
|
|
/**
|
|
* All locales available for localization of warning messages, or
|
|
* null if localization is not supported.
|
|
*/
|
|
protected Locale[] availableLocales = null;
|
|
|
|
/**
|
|
* The current locale used to localize warning messages, or null if
|
|
* no locale has been set.
|
|
*/
|
|
protected Locale locale = null;
|
|
|
|
/**
|
|
* The image writer SPI that instantiated this writer.
|
|
*/
|
|
protected ImageWriterSpi originatingProvider = null;
|
|
|
|
/**
|
|
* An ImageInputStream to which image data is written.
|
|
*/
|
|
protected Object output = null;
|
|
|
|
/**
|
|
* A list of installed progress listeners. Initially null, meaning
|
|
* no installed listeners.
|
|
*/
|
|
protected List<IIOWriteProgressListener> progressListeners = null;
|
|
|
|
/**
|
|
* A list of installed warning listeners. Initially null, meaning
|
|
* no installed listeners.
|
|
*/
|
|
protected List<IIOWriteWarningListener> warningListeners = null;
|
|
|
|
/**
|
|
* A list of warning locales corresponding with the list of
|
|
* installed warning listeners. Initially null, meaning no locales.
|
|
*/
|
|
protected List<Locale> warningLocales = null;
|
|
|
|
/**
|
|
* Construct an image writer.
|
|
*
|
|
* @param originatingProvider the provider that is constructing this
|
|
* image writer, or null
|
|
*/
|
|
protected ImageWriter(ImageWriterSpi originatingProvider)
|
|
{
|
|
this.originatingProvider = originatingProvider;
|
|
}
|
|
|
|
/**
|
|
* Throw an IllegalStateException if output is null.
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
*/
|
|
private void checkOutputSet()
|
|
{
|
|
if (output == null)
|
|
throw new IllegalStateException("no output set");
|
|
}
|
|
|
|
/**
|
|
* Request that writing be aborted. The unwritten portions of the
|
|
* destination image will be undefined.
|
|
*
|
|
* Writers should clear the abort flag before starting a write
|
|
* operation, then poll it periodically during the write operation.
|
|
*/
|
|
public void abort()
|
|
{
|
|
aborted = true;
|
|
}
|
|
|
|
/**
|
|
* Check if the abort flag is set.
|
|
*
|
|
* @return true if the current write operation should be aborted,
|
|
* false otherwise
|
|
*/
|
|
protected boolean abortRequested()
|
|
{
|
|
return aborted;
|
|
}
|
|
|
|
/**
|
|
* Install a write progress listener. This method will return
|
|
* immediately if listener is null.
|
|
*
|
|
* @param listener a write progress listener or null
|
|
*/
|
|
public void addIIOWriteProgressListener(IIOWriteProgressListener listener)
|
|
{
|
|
if (listener == null)
|
|
return;
|
|
if (progressListeners == null)
|
|
progressListeners = new ArrayList ();
|
|
progressListeners.add(listener);
|
|
}
|
|
|
|
/**
|
|
* Install a write warning listener. This method will return
|
|
* immediately if listener is null. Warning messages sent to this
|
|
* listener will be localized using the current locale. If the
|
|
* current locale is null then this writer will select a sensible
|
|
* default.
|
|
*
|
|
* @param listener a write warning listener
|
|
*/
|
|
public void addIIOWriteWarningListener (IIOWriteWarningListener listener)
|
|
{
|
|
if (listener == null)
|
|
return;
|
|
if (warningListeners == null)
|
|
warningListeners = new ArrayList ();
|
|
warningListeners.add(listener);
|
|
}
|
|
|
|
/**
|
|
* Check whether a new empty image can be inserted at the given
|
|
* frame index. Pixel values may be filled in later using the
|
|
* replacePixels methods. Indices greater than the insertion index
|
|
* will be incremented. If imageIndex is -1, the image will be
|
|
* appended at the end of the current image list.
|
|
*
|
|
* @param imageIndex the frame index
|
|
*
|
|
* @return true if an empty image can be inserted at imageIndex,
|
|
* false otherwise
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception IndexOutOfBoundsException if imageIndex is less than
|
|
* -1 or greater than the last index in the current image list
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public boolean canInsertEmpty(int imageIndex)
|
|
throws IOException
|
|
{
|
|
checkOutputSet();
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check whether an image can be inserted at the given frame index.
|
|
* Indices greater than the insertion index will be incremented. If
|
|
* imageIndex is -1, the image will be appended at the end of the
|
|
* current image list.
|
|
*
|
|
* @param imageIndex the frame index
|
|
*
|
|
* @return true if an image can be inserted at imageIndex, false
|
|
* otherwise
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception IndexOutOfBoundsException if imageIndex is less than
|
|
* -1 or greater than the last index in the current image list
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public boolean canInsertImage(int imageIndex)
|
|
throws IOException
|
|
{
|
|
checkOutputSet();
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check whether an image can be removed from the given frame index.
|
|
* Indices greater than the removal index will be decremented.
|
|
*
|
|
* @param imageIndex the frame index
|
|
*
|
|
* @return true if an image can be removed from imageIndex, false
|
|
* otherwise
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0
|
|
* or greater than the last index in the current image list
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public boolean canRemoveImage(int imageIndex)
|
|
throws IOException
|
|
{
|
|
checkOutputSet();
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check whether the metadata associated the image at the given
|
|
* frame index can be replaced.
|
|
*
|
|
* @param imageIndex the frame index
|
|
*
|
|
* @return true if the metadata associated with the image at
|
|
* imageIndex can be replaced, false otherwise
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0
|
|
* or greater than the last index in the current image list
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public boolean canReplaceImageMetadata(int imageIndex)
|
|
throws IOException
|
|
{
|
|
checkOutputSet();
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check whether the pixels within the image at the given index can
|
|
* be replaced.
|
|
*
|
|
* @param imageIndex the frame index
|
|
*
|
|
* @return true if the pixels in the image at imageIndex can be
|
|
* replaced, false otherwise
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0
|
|
* or greater than the last index in the current image list
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public boolean canReplacePixels(int imageIndex)
|
|
throws IOException
|
|
{
|
|
checkOutputSet();
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check whether the metadata associated the entire image stream can
|
|
* be replaced.
|
|
*
|
|
* @return true if the stream metadata can be replaced, false
|
|
* otherwise
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public boolean canReplaceStreamMetadata()
|
|
throws IOException
|
|
{
|
|
checkOutputSet();
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check whether an entire empty image, including empty metadata and
|
|
* empty thumbnails, can be written to the output stream, leaving
|
|
* pixel values to be filled in later using the replacePixels
|
|
* methods.
|
|
*
|
|
* @return true if an entire empty image can be written before its
|
|
* contents are filled in, false otherwise
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public boolean canWriteEmpty()
|
|
throws IOException
|
|
{
|
|
checkOutputSet();
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if IIOImages containing raster data are supported.
|
|
*
|
|
* @return true if raster IIOImages are supported, false otherwise
|
|
*/
|
|
public boolean canWriteRasters()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check if an image can be appended at the end of the current list
|
|
* of images even if prior images have already been written.
|
|
*
|
|
* @return true if sequences of images can be written, false
|
|
* otherwise
|
|
*/
|
|
public boolean canWriteSequence()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Clear the abort flag.
|
|
*/
|
|
protected void clearAbortRequest()
|
|
{
|
|
aborted = false;
|
|
}
|
|
|
|
/**
|
|
* Convert IIOMetadata from an input reader format, returning an
|
|
* IIOMetadata suitable for use by an image writer.
|
|
*
|
|
* The ImageTypeSpecifier specifies the destination image type.
|
|
*
|
|
* An optional ImageWriteParam argument is available in case the
|
|
* image writing parameters affect the metadata conversion.
|
|
*
|
|
* @param inData the metadata coming from an image reader
|
|
* @param imageType the output image type of the writer
|
|
* @param param the image writing parameters or null
|
|
*
|
|
* @return the converted metadata that should be used by the image
|
|
* writer, or null if this ImageTranscoder has no knowledge of the
|
|
* input metadata
|
|
*
|
|
* @exception IllegalArgumentException if either inData or imageType
|
|
* is null
|
|
*/
|
|
public abstract IIOMetadata convertImageMetadata (IIOMetadata inData,
|
|
ImageTypeSpecifier imageType,
|
|
ImageWriteParam param);
|
|
|
|
/**
|
|
* Convert IIOMetadata from an input stream format, returning an
|
|
* IIOMetadata suitable for use by an image writer.
|
|
*
|
|
* An optional ImageWriteParam argument is available in case the
|
|
* image writing parameters affect the metadata conversion.
|
|
*
|
|
* @param inData the metadata coming from an input image stream
|
|
* @param param the image writing parameters or null
|
|
*
|
|
* @return the converted metadata that should be used by the image
|
|
* writer, or null if this ImageTranscoder has no knowledge of the
|
|
* input metadata
|
|
*
|
|
* @exception IllegalArgumentException if inData is null
|
|
*/
|
|
public abstract IIOMetadata convertStreamMetadata (IIOMetadata inData,
|
|
ImageWriteParam param);
|
|
|
|
/**
|
|
* Releases any resources allocated to this object. Subsequent
|
|
* calls to methods on this object will produce undefined results.
|
|
*
|
|
* The default implementation does nothing; subclasses should use
|
|
* this method ensure that native resources are released.
|
|
*/
|
|
public void dispose()
|
|
{
|
|
// The default implementation is empty. Subclasses have to overwrite it.
|
|
}
|
|
|
|
/**
|
|
* Retrieve the available locales. Return null if no locales are
|
|
* available or a clone of availableLocales.
|
|
*
|
|
* @return an array of locales or null
|
|
*/
|
|
public Locale[] getAvailableLocales()
|
|
{
|
|
return availableLocales;
|
|
}
|
|
|
|
/**
|
|
* Get a metadata object appropriate for encoding an image specified
|
|
* by the given image type specifier and optional image write
|
|
* parameters.
|
|
*
|
|
* @param imageType an image type specifier
|
|
* @param param image writing parameters, or null
|
|
*
|
|
* @return a metadata object appropriate for encoding an image of
|
|
* the given type with the given parameters
|
|
*/
|
|
public abstract IIOMetadata getDefaultImageMetadata (ImageTypeSpecifier imageType, ImageWriteParam param);
|
|
|
|
/**
|
|
* Get a metadata object appropriate for encoding the default image
|
|
* type handled by this writer, optionally considering image write
|
|
* parameters.
|
|
*
|
|
* @param param image writing parameters, or null
|
|
*
|
|
* @return a metadata object appropriate for encoding an image of
|
|
* the default type with the given parameters
|
|
*/
|
|
public abstract IIOMetadata getDefaultStreamMetadata (ImageWriteParam param);
|
|
|
|
/**
|
|
* Retrieve the default write parameters for this writer's image
|
|
* format.
|
|
*
|
|
* The default implementation returns new ImageWriteParam().
|
|
*
|
|
* @return image writing parameters
|
|
*/
|
|
public ImageWriteParam getDefaultWriteParam()
|
|
{
|
|
return new ImageWriteParam(getLocale());
|
|
}
|
|
|
|
/**
|
|
* Get this writer's locale. null is returned if the locale has not
|
|
* been set.
|
|
*
|
|
* @return this writer's locale, or null
|
|
*/
|
|
public Locale getLocale()
|
|
{
|
|
return locale;
|
|
}
|
|
|
|
/**
|
|
* Get the number of thumbnails supported by this image writer,
|
|
* based on the given image type, image writing parameters, and
|
|
* stream and image metadata. The image writing parameters are
|
|
* optional, in case they affect the number of thumbnails supported.
|
|
*
|
|
* @param imageType an image type specifier, or null
|
|
* @param param image writing parameters, or null
|
|
* @param streamMetadata the metadata associated with this stream,
|
|
* or null
|
|
* @param imageMetadata the metadata associated with this image, or
|
|
* null
|
|
*
|
|
* @return the number of thumbnails that this writer supports
|
|
* writing or -1 if the given information is insufficient
|
|
*/
|
|
public int getNumThumbnailsSupported (ImageTypeSpecifier imageType,
|
|
ImageWriteParam param,
|
|
IIOMetadata streamMetadata,
|
|
IIOMetadata imageMetadata)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Get the ImageWriterSpi that created this writer or null.
|
|
*
|
|
* @return an ImageWriterSpi, or null
|
|
*/
|
|
public ImageWriterSpi getOriginatingProvider()
|
|
{
|
|
return originatingProvider;
|
|
}
|
|
|
|
/**
|
|
* Get this reader's image output destination. null is returned if
|
|
* the image destination has not been set.
|
|
*
|
|
* @return an image output destination object, or null
|
|
*/
|
|
public Object getOutput()
|
|
{
|
|
return output;
|
|
}
|
|
|
|
/**
|
|
* Get the preferred sizes for thumbnails based on the given image
|
|
* type, image writing parameters, and stream and image metadata.
|
|
* The preferred sizes are returned in pairs of dimension values;
|
|
* the first value in the array is a dimension object representing
|
|
* the minimum thumbnail size, the second value is a dimension
|
|
* object representing a maximum thumbnail size. The writer can
|
|
* select a size within the range given by each pair, or it can
|
|
* ignore these size hints.
|
|
*
|
|
* @param imageType an image type specifier, or null
|
|
* @param param image writing parameters, or null
|
|
* @param streamMetadata the metadata associated with this stream,
|
|
* or null
|
|
* @param imageMetadata the metadata associated with this image, or
|
|
* null
|
|
*
|
|
* @return an array of dimension pairs whose length is a multiple of
|
|
* 2, or null if there is no preferred size (any size is allowed) or
|
|
* if the size is unknown (insufficient information was provided)
|
|
*/
|
|
public Dimension[] getPreferredThumbnailSizes (ImageTypeSpecifier imageType,
|
|
ImageWriteParam param,
|
|
IIOMetadata streamMetadata,
|
|
IIOMetadata imageMetadata)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Notifies all installed write progress listeners that image
|
|
* loading has completed by calling their imageComplete methods.
|
|
*/
|
|
protected void processImageComplete()
|
|
{
|
|
if (progressListeners != null)
|
|
{
|
|
Iterator it = progressListeners.iterator();
|
|
|
|
while (it.hasNext())
|
|
{
|
|
IIOWriteProgressListener listener =
|
|
(IIOWriteProgressListener) it.next();
|
|
listener.imageComplete(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notifies all installed write progress listeners that a certain
|
|
* percentage of the image has been loaded, by calling their
|
|
* imageProgress methods.
|
|
*
|
|
* @param percentageDone the percentage of image data that has been
|
|
* loaded
|
|
*/
|
|
protected void processImageProgress(float percentageDone)
|
|
{
|
|
if (progressListeners != null)
|
|
{
|
|
Iterator it = progressListeners.iterator();
|
|
|
|
while (it.hasNext())
|
|
{
|
|
IIOWriteProgressListener listener =
|
|
(IIOWriteProgressListener) it.next();
|
|
listener.imageProgress(this, percentageDone);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notifies all installed write progress listeners, by calling their
|
|
* imageStarted methods, that image loading has started on the given
|
|
* image.
|
|
*
|
|
* @param imageIndex the frame index of the image that has started
|
|
* loading
|
|
*/
|
|
protected void processImageStarted(int imageIndex)
|
|
{
|
|
if (progressListeners != null)
|
|
{
|
|
Iterator it = progressListeners.iterator();
|
|
|
|
while (it.hasNext())
|
|
{
|
|
IIOWriteProgressListener listener =
|
|
(IIOWriteProgressListener) it.next();
|
|
listener.imageStarted(this, imageIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notifies all installed write progress listeners, by calling their
|
|
* thumbnailComplete methods, that a thumbnail has completed
|
|
* loading.
|
|
*/
|
|
protected void processThumbnailComplete()
|
|
{
|
|
if (progressListeners != null)
|
|
{
|
|
Iterator it = progressListeners.iterator();
|
|
|
|
while (it.hasNext())
|
|
{
|
|
IIOWriteProgressListener listener =
|
|
(IIOWriteProgressListener) it.next();
|
|
listener.thumbnailComplete(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notifies all installed write progress listeners that a certain
|
|
* percentage of a thumbnail has been loaded, by calling their
|
|
* thumbnailProgress methods.
|
|
*
|
|
* @param percentageDone the percentage of thumbnail data that has
|
|
* been loaded
|
|
*/
|
|
protected void processThumbnailProgress(float percentageDone)
|
|
{
|
|
if (progressListeners != null)
|
|
{
|
|
Iterator it = progressListeners.iterator();
|
|
|
|
while (it.hasNext())
|
|
{
|
|
IIOWriteProgressListener listener =
|
|
(IIOWriteProgressListener) it.next();
|
|
listener.thumbnailProgress(this, percentageDone);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notifies all installed write progress listeners, by calling their
|
|
* imageStarted methods, that thumbnail loading has started on the
|
|
* given thumbnail of the given image.
|
|
*
|
|
* @param imageIndex the frame index of the image one of who's
|
|
* thumbnails has started loading
|
|
* @param thumbnailIndex the index of the thumbnail that has started
|
|
* loading
|
|
*/
|
|
protected void processThumbnailStarted(int imageIndex, int thumbnailIndex)
|
|
{
|
|
if (progressListeners != null)
|
|
{
|
|
Iterator it = progressListeners.iterator();
|
|
|
|
while (it.hasNext())
|
|
{
|
|
IIOWriteProgressListener listener =
|
|
(IIOWriteProgressListener) it.next();
|
|
listener.thumbnailStarted(this, imageIndex, thumbnailIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notifies all installed warning listeners, by calling their
|
|
* warningOccurred methods, that a warning message has been raised.
|
|
*
|
|
* @param imageIndex the index of the image that was being written
|
|
* when the warning was raised
|
|
* @param warning the warning message
|
|
*
|
|
* @exception IllegalArgumentException if warning is null
|
|
*/
|
|
protected void processWarningOccurred(int imageIndex, String warning)
|
|
{
|
|
if (warningListeners != null)
|
|
{
|
|
Iterator it = warningListeners.iterator();
|
|
|
|
while (it.hasNext())
|
|
{
|
|
IIOWriteWarningListener listener =
|
|
(IIOWriteWarningListener) it.next();
|
|
listener.warningOccurred(this, imageIndex, warning);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notify all installed warning listeners, by calling their
|
|
* warningOccurred methods, that a warning message has been raised.
|
|
* The warning message is retrieved from a resource bundle, using
|
|
* the given basename and keyword.
|
|
*
|
|
* @param imageIndex the index of the image that was being written
|
|
* when the warning was raised
|
|
* @param baseName the basename of the resource from which to
|
|
* retrieve the warning message
|
|
* @param keyword the keyword used to retrieve the warning from the
|
|
* resource bundle
|
|
*
|
|
* @exception IllegalArgumentException if either baseName or keyword
|
|
* is null
|
|
* @exception IllegalArgumentException if no resource bundle is
|
|
* found using baseName
|
|
* @exception IllegalArgumentException if the given keyword produces
|
|
* no results from the resource bundle
|
|
* @exception IllegalArgumentException if the retrieved object is
|
|
* not a String
|
|
*/
|
|
protected void processWarningOccurred(int imageIndex,
|
|
String baseName,
|
|
String keyword)
|
|
{
|
|
if (baseName == null || keyword == null)
|
|
throw new IllegalArgumentException ("null argument");
|
|
|
|
ResourceBundle b = null;
|
|
|
|
try
|
|
{
|
|
b = ResourceBundle.getBundle(baseName, getLocale());
|
|
}
|
|
catch (MissingResourceException e)
|
|
{
|
|
throw new IllegalArgumentException ("no resource bundle found");
|
|
}
|
|
|
|
Object str = null;
|
|
|
|
try
|
|
{
|
|
str = b.getObject(keyword);
|
|
}
|
|
catch (MissingResourceException e)
|
|
{
|
|
throw new IllegalArgumentException ("no results found for keyword");
|
|
}
|
|
|
|
if (! (str instanceof String))
|
|
throw new IllegalArgumentException ("retrieved object not a String");
|
|
|
|
String warning = (String) str;
|
|
|
|
if (warningListeners != null)
|
|
{
|
|
Iterator it = warningListeners.iterator();
|
|
|
|
while (it.hasNext())
|
|
{
|
|
IIOWriteWarningListener listener =
|
|
(IIOWriteWarningListener) it.next();
|
|
listener.warningOccurred(this, imageIndex, warning);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notifies all installed write progress listeners that image
|
|
* loading has been aborted by calling their writeAborted methods.
|
|
*/
|
|
protected void processWriteAborted()
|
|
{
|
|
if (progressListeners != null)
|
|
{
|
|
Iterator it = progressListeners.iterator();
|
|
|
|
while (it.hasNext())
|
|
{
|
|
IIOWriteProgressListener listener =
|
|
(IIOWriteProgressListener) it.next();
|
|
listener.writeAborted(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Uninstall all write progress listeners.
|
|
*/
|
|
public void removeAllIIOWriteProgressListeners()
|
|
{
|
|
if (progressListeners != null)
|
|
{
|
|
progressListeners.clear();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Uninstall all write warning listeners.
|
|
*/
|
|
public void removeAllIIOWriteWarningListeners()
|
|
{
|
|
if (progressListeners != null)
|
|
{
|
|
progressListeners.clear();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Uninstall the given write progress listener.
|
|
*
|
|
* @param listener the listener to remove
|
|
*/
|
|
public void removeIIOWriteProgressListener (IIOWriteProgressListener listener)
|
|
{
|
|
if (listener == null)
|
|
return;
|
|
if (progressListeners != null)
|
|
{
|
|
progressListeners.remove(listener);
|
|
}
|
|
}
|
|
/**
|
|
* Uninstall the given write warning listener.
|
|
*
|
|
* @param listener the listener to remove
|
|
*/
|
|
public void removeIIOWriteWarningListener (IIOWriteWarningListener listener)
|
|
{
|
|
if (listener == null)
|
|
return;
|
|
if (warningListeners != null)
|
|
{
|
|
warningListeners.remove(listener);
|
|
}
|
|
}
|
|
/**
|
|
* Reset this writer's internal state.
|
|
*/
|
|
public void reset()
|
|
{
|
|
setOutput(null);
|
|
setLocale(null);
|
|
removeAllIIOWriteWarningListeners();
|
|
removeAllIIOWriteProgressListeners();
|
|
clearAbortRequest();
|
|
}
|
|
|
|
/**
|
|
* Set the current locale or use the default locale.
|
|
*
|
|
* @param locale the locale to set, or null
|
|
*/
|
|
public void setLocale(Locale locale)
|
|
{
|
|
if (locale != null)
|
|
{
|
|
// Check if its a valid locale.
|
|
boolean found = false;
|
|
|
|
if (availableLocales != null)
|
|
for (int i = availableLocales.length - 1; i >= 0; --i)
|
|
if (availableLocales[i].equals(locale))
|
|
found = true;
|
|
|
|
if (! found)
|
|
throw new IllegalArgumentException("looale not available");
|
|
}
|
|
|
|
this.locale = locale;
|
|
}
|
|
|
|
/**
|
|
* Set the output destination of the given object. The output
|
|
* destination must be set before many methods can be called on this
|
|
* writer. (see all ImageWriter methods that throw
|
|
* IllegalStateException). If input is null then the current input
|
|
* source will be removed.
|
|
*
|
|
* @param output the output destination object
|
|
*
|
|
* @exception IllegalArgumentException if input is not a valid input
|
|
* source for this writer and is not an ImageInputStream
|
|
*/
|
|
public void setOutput(Object output)
|
|
{
|
|
if (output != null)
|
|
{
|
|
// Check if its a valid output object.
|
|
boolean found = false;
|
|
Class[] types = null;
|
|
|
|
if (originatingProvider != null)
|
|
types = originatingProvider.getOutputTypes();
|
|
|
|
if (types != null)
|
|
for (int i = types.length - 1; i >= 0; --i)
|
|
if (types[i].isInstance(output))
|
|
found = true;
|
|
|
|
if (! found)
|
|
throw new IllegalArgumentException("output type not available");
|
|
}
|
|
|
|
this.output = output;
|
|
}
|
|
|
|
/**
|
|
* Write an image stream, including thumbnails and metadata to the
|
|
* output stream. The output must have been set prior to this
|
|
* method being called. Metadata associated with the stream may be
|
|
* supplied, or it can be left null. IIOImage may contain raster
|
|
* data if this writer supports rasters, or it will contain a
|
|
* rendered image. Thumbnails are resized if need be. Image
|
|
* writing parameters may be specified to affect writing, or may be
|
|
* left null.
|
|
*
|
|
* @param streamMetadata metadata associated with this stream, or
|
|
* null
|
|
* @param image an IIOImage containing image data, metadata and
|
|
* thumbnails to be written
|
|
* @param param image writing parameters, or null
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if image contains raster
|
|
* data but this writer does not support rasters
|
|
* @exception IllegalArgumentException if image is null
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public abstract void write (IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param)
|
|
throws IOException;
|
|
|
|
/**
|
|
* Complete inserting an empty image in the output stream.
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if inserting empty
|
|
* images is not supported
|
|
* @exception IllegalArgumentException if a call to
|
|
* prepareInsertEmpty was not called previous to this method being
|
|
* called (a sequence of prepareInsertEmpty calls must be terminated
|
|
* by a call to endInsertEmpty)
|
|
* @exception IllegalArgumentException if prepareWriteEmpty was
|
|
* called before this method being called (without a terminating
|
|
* call to endWriteEmpty)
|
|
* @exception IllegalArgumentException if prepareReplacePixels was
|
|
* called before this method being called (without a terminating
|
|
* call to endReplacePixels)
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void endInsertEmpty ()
|
|
throws IOException
|
|
{
|
|
if (!canInsertEmpty(0))
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Complete replacing pixels in an image in the output stream.
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if replacing pixels is
|
|
* not supported by this writer
|
|
* @exception IllegalArgumentException if prepareReplacePixels was
|
|
* not called before this method being called
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void endReplacePixels ()
|
|
throws IOException
|
|
{
|
|
if (!canReplacePixels(0))
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Complete writing an empty image to the image output stream.
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if writing empty images
|
|
* is not supported
|
|
* @exception IllegalArgumentException if a call to
|
|
* prepareWriteEmpty was not called previous to this method being
|
|
* called (a sequence of prepareWriteEmpty calls must be terminated
|
|
* by a call to endWriteEmpty)
|
|
* @exception IllegalArgumentException if prepareInsertEmpty was
|
|
* called before this method being called (without a terminating
|
|
* call to endInsertEmpty)
|
|
* @exception IllegalArgumentException if prepareReplacePixels was
|
|
* called before this method being called (without a terminating
|
|
* call to endReplacePixels)
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void endWriteEmpty ()
|
|
throws IOException
|
|
{
|
|
if (!canWriteEmpty())
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Complete writing a sequence of images to the output stream. This
|
|
* method may patch header data and write out footer data.
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception IllegalStateException if prepareWriteSequence has not
|
|
* been called
|
|
* @exception UnsupportedOperationException if writing a sequence of
|
|
* images is not supported
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void endWriteSequence ()
|
|
throws IOException
|
|
{
|
|
checkOutputSet();
|
|
if (!canWriteSequence())
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Start inserting an empty image in the image output stream. All
|
|
* indices after the specified index are incremented. An index of
|
|
* -1 implies that the empty image should be appended to the end of
|
|
* the current image list.
|
|
*
|
|
* The insertion that this method call starts is not complete until
|
|
* endInsertEmpty is called. prepareInsertEmpty cannot be called
|
|
* again until endInsertEmpty is called and calls to
|
|
* prepareWriteEmpty and prepareInsertEmpty may not be intersperced.
|
|
*
|
|
* @param imageIndex the image index
|
|
* @param imageType the image type specifier
|
|
* @param width the image width
|
|
* @param height the image height
|
|
* @param imageMetadata the image metadata, or null
|
|
* @param thumbnails a list of thumbnails, or null
|
|
* @param param image write parameters, or null
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if inserting empty
|
|
* images is not supported
|
|
* @exception IndexOutOfBoundsException if imageIndex is less than
|
|
* -1 or greater than the last index in the current image list
|
|
* @exception IllegalStateException if a previous call to
|
|
* prepareInsertEmpty was made (without a terminating call to
|
|
* endInsertEmpty)
|
|
* @exception IllegalStateException if a previous call to
|
|
* prepareWriteEmpty was made (without a terminating call to
|
|
* endWriteEmpty)
|
|
* @exception IllegalArgumentException if imageType is null or
|
|
* thumbnails contain non-BufferedImage objects
|
|
* @exception IllegalArgumentException if either width or height is
|
|
* less than 1
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void prepareInsertEmpty (int imageIndex, ImageTypeSpecifier imageType,
|
|
int width, int height,
|
|
IIOMetadata imageMetadata,
|
|
List<? extends BufferedImage> thumbnails,
|
|
ImageWriteParam param)
|
|
throws IOException
|
|
{
|
|
if (!canInsertEmpty(imageIndex))
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Start the replacement of pixels within an image in the output
|
|
* stream. Output pixels will be clipped to lie within region.
|
|
*
|
|
* @param imageIndex the index of the image in which pixels are
|
|
* being replaced
|
|
* @param region the rectangle to which to limit pixel replacement
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if replacing pixels is
|
|
* not supported
|
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0
|
|
* or greater than the last index in the current image list
|
|
* @exception IllegalStateException if a previous call to
|
|
* prepareReplacePixels was made (without a terminating call to
|
|
* endReplacePixels)
|
|
* @exception IllegalArgumentException if either region.width or
|
|
* region.height is less than 1, or if region is null
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void prepareReplacePixels (int imageIndex, Rectangle region)
|
|
throws IOException
|
|
{
|
|
if (canReplacePixels(imageIndex))
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Start writing an empty image to the end of the image output
|
|
* stream.
|
|
*
|
|
* The writing that this method call starts is not complete until
|
|
* endWriteEmpty is called. prepareWritetEmpty cannot be called
|
|
* again until endWriteEmpty is called and calls to
|
|
* prepareWriteEmpty and prepareInsertEmpty may not be intersperced.
|
|
*
|
|
* @param streamMetadata metadata associated with the stream, or null
|
|
* @param imageType the image type specifier
|
|
* @param width the image width
|
|
* @param height the image height
|
|
* @param imageMetadata the image metadata, or null
|
|
* @param thumbnails a list of thumbnails, or null
|
|
* @param param image write parameters, or null
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if writing empty images
|
|
* is not supported
|
|
* @exception IndexOutOfBoundsException if imageIndex is less than
|
|
* -1 or greater than the last index in the current image list
|
|
* @exception IllegalStateException if a previous call to
|
|
* prepareInsertEmpty was made (without a terminating call to
|
|
* endInsertEmpty)
|
|
* @exception IllegalStateException if a previous call to
|
|
* prepareWriteEmpty was made (without a terminating call to
|
|
* endWriteEmpty)
|
|
* @exception IllegalArgumentException if imageType is null or
|
|
* thumbnails contain non-BufferedImage objects
|
|
* @exception IllegalArgumentException if either width or height is
|
|
* less than 1
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void prepareWriteEmpty (IIOMetadata streamMetadata,
|
|
ImageTypeSpecifier imageType,
|
|
int width, int height,
|
|
IIOMetadata imageMetadata,
|
|
List<? extends BufferedImage> thumbnails,
|
|
ImageWriteParam param)
|
|
throws IOException
|
|
{
|
|
if (!canWriteEmpty())
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Start the writing of a sequence of images.
|
|
*
|
|
* @param streamMetadata the stream metadata, or null
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if writing sequences of
|
|
* images is not supported
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void prepareWriteSequence (IIOMetadata streamMetadata)
|
|
throws IOException
|
|
{
|
|
checkOutputSet();
|
|
if (!canWriteSequence())
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Remove the image at the specified index from the output stream.
|
|
*
|
|
* @param imageIndex the frame index from which to remove the image
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if removing this image
|
|
* is not supported
|
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0
|
|
* or greater than the last index in the current image list
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void removeImage (int imageIndex)
|
|
throws IOException
|
|
{
|
|
if (!canRemoveImage(imageIndex))
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Replace the metadata associated with the image at the given
|
|
* index.
|
|
*
|
|
* @param imageIndex the index of the image whose metadata should be
|
|
* replaced
|
|
* @param imageMetadata the metadata, or null
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if replacing this
|
|
* image's metadata is not supported
|
|
* @exception IndexOutOfBoundsException if imageIndex is less than 0
|
|
* or greater than the last index in the current image list
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void replaceImageMetadata (int imageIndex, IIOMetadata imageMetadata)
|
|
throws IOException
|
|
{
|
|
if (!canReplaceImageMetadata(imageIndex))
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Replace a region of an image in the output stream with a portion
|
|
* of the given rendered image. The image data must be of the same
|
|
* type as that in the output stream. The destination region is
|
|
* given by the image writing parameters and the source region is
|
|
* the one given to prepareReplacePixels.
|
|
*
|
|
* @param image the rendered image with which to overwrite the image
|
|
* region in the stream
|
|
* @param param the image writing parameters
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if replacing pixels is
|
|
* not supported
|
|
* @exception IllegalStateException if prepareReplacePixels was not
|
|
* called before this method was called
|
|
* @exception IllegalArgumentException if image is null or if param
|
|
* is null or if the overlap of the source and destination regions
|
|
* contains no pixels or if the image types differ and no conversion
|
|
* is possible
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void replacePixels (RenderedImage image,
|
|
ImageWriteParam param)
|
|
throws IOException
|
|
{
|
|
if (!canReplacePixels(0))
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Replace a region of an image in the output stream with a portion
|
|
* of the given raster data. The image data must be of the same
|
|
* type as that in the output stream. The destination region is
|
|
* given by the image writing parameters and the source region is
|
|
* the one given to prepareReplacePixels.
|
|
*
|
|
* @param raster the raster data with which to overwrite the image
|
|
* region in the stream
|
|
* @param param the image writing parameters
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if replacing pixels is
|
|
* not supported
|
|
* @exception IllegalStateException if prepareReplacePixels was not
|
|
* called before this method was called
|
|
* @exception UnsupportedOperationException if raster data is not
|
|
* supported
|
|
* @exception IllegalArgumentException if raster is null or if param
|
|
* is null or if the overlap of the source and destination regions
|
|
* contains no pixels or if the image types differ and no conversion
|
|
* is possible
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void replacePixels (Raster raster, ImageWriteParam param)
|
|
throws IOException
|
|
{
|
|
if (!canReplacePixels(0))
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Replace the metadata associated with this image stream.
|
|
*
|
|
* @param streamMetadata the stream metadata, or null
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if replacing the stream
|
|
* metadata is not supported
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void replaceStreamMetadata (IIOMetadata streamMetadata)
|
|
throws IOException
|
|
{
|
|
if (!canReplaceStreamMetadata())
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Write a rendered image to the output stream.
|
|
*
|
|
* @param image a rendered image containing image data to be written
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception IllegalArgumentException if image is null
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void write (RenderedImage image)
|
|
throws IOException
|
|
{
|
|
checkOutputSet();
|
|
write (null, new IIOImage(image, null, null), null);
|
|
}
|
|
|
|
/**
|
|
* Write a image data, metadata and thumbnails to the output stream.
|
|
*
|
|
* @param image image data, metadata and thumbnails to be written
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if image contains raster
|
|
* data but this writer does not support rasters
|
|
* @exception IllegalArgumentException if image is null
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void write (IIOImage image)
|
|
throws IOException
|
|
{
|
|
checkOutputSet();
|
|
write (null, image, null);
|
|
}
|
|
|
|
/**
|
|
* Insert an image into the output stream. Indices greater than the
|
|
* specified index are incremented accordingly. Specifying an index
|
|
* of -1 causes the image to be appended at the end of the current
|
|
* image list.
|
|
*
|
|
* @param imageIndex the frame index at which to insert the image
|
|
* @param image the image data, metadata and thumbnails to be
|
|
* inserted
|
|
* @param param image write parameters, or null
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if image insertion is
|
|
* not supported
|
|
* @exception IllegalArgumentException if image is null
|
|
* @exception IndexOutOfBoundsException if imageIndex is less than
|
|
* -1 or greater than the last index in the current image list
|
|
* @exception UnsupportedOperationException if image contains raster
|
|
* data but this writer does not support rasters
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void writeInsert (int imageIndex, IIOImage image, ImageWriteParam param)
|
|
throws IOException
|
|
{
|
|
if (!canInsertImage(imageIndex))
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
/**
|
|
* Write a sequence of images, including thumbnails and metadata, to
|
|
* the output stream. The output must have been set prior to this
|
|
* method being called. Metadata associated with the stream may be
|
|
* supplied, or it can be left null. IIOImage may contain raster
|
|
* data if this writer supports rasters, or it will contain a
|
|
* rendered image. Thumbnails are resized if need be. Image
|
|
* writing parameters may be specified to affect writing, or may be
|
|
* left null.
|
|
*
|
|
* @param streamMetadata metadata associated with this stream, or
|
|
* null
|
|
* @param image an IIOImage containing image data, metadata and
|
|
* thumbnails to be written
|
|
* @param param image writing parameters, or null
|
|
*
|
|
* @exception IllegalStateException if output is null
|
|
* @exception UnsupportedOperationException if writing sequences of
|
|
* images is not supported
|
|
* @exception IllegalArgumentException if image is null
|
|
* @exception UnsupportedOperationException if image contains raster
|
|
* data but this writer does not support rasters
|
|
* @exception IOException if a write error occurs
|
|
*/
|
|
public void writeToSequence (IIOImage image, ImageWriteParam param)
|
|
throws IOException
|
|
{
|
|
if (!canWriteSequence())
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
}
|