| /* | |
| * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle in the LICENSE file that accompanied this code. | |
| * | |
| * This code 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 | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| package javax.imageio; | |
| import java.awt.Dimension; | |
| import java.awt.Rectangle; | |
| import java.awt.image.BufferedImage; | |
| import java.awt.image.RenderedImage; | |
| import java.awt.image.Raster; | |
| import java.io.IOException; | |
| import java.util.ArrayList; | |
| import java.util.List; | |
| import java.util.Locale; | |
| import java.util.MissingResourceException; | |
| import java.util.ResourceBundle; | |
| import javax.imageio.event.IIOWriteWarningListener; | |
| import javax.imageio.event.IIOWriteProgressListener; | |
| import javax.imageio.metadata.IIOMetadata; | |
| import javax.imageio.stream.ImageOutputStream; | |
| import javax.imageio.spi.ImageWriterSpi; | |
| /** | |
| * An abstract superclass for encoding and writing images. This class | |
| * must be subclassed by classes that write out images in the context | |
| * of the Java Image I/O framework. | |
| * | |
| * <p> {@code ImageWriter} objects are normally instantiated by | |
| * the service provider class for the specific format. Service | |
| * provider classes are registered with the {@code IIORegistry}, | |
| * which uses them for format recognition and presentation of | |
| * available format readers and writers. | |
| * | |
| * @see ImageReader | |
| * @see ImageWriteParam | |
| * @see javax.imageio.spi.IIORegistry | |
| * @see javax.imageio.spi.ImageWriterSpi | |
| * | |
| */ | |
| public abstract class ImageWriter implements ImageTranscoder { | |
| /** | |
| * The {@code ImageWriterSpi} that instantiated this object, | |
| * or {@code null} if its identity is not known or none | |
| * exists. By default it is initialized to {@code null}. | |
| */ | |
| protected ImageWriterSpi originatingProvider = null; | |
| /** | |
| * The {@code ImageOutputStream} or other {@code Object} | |
| * set by {@code setOutput} and retrieved by | |
| * {@code getOutput}. By default it is initialized to | |
| * {@code null}. | |
| */ | |
| protected Object output = null; | |
| /** | |
| * An array of {@code Locale}s that may be used to localize | |
| * warning messages and compression setting values, or | |
| * {@code null} if localization is not supported. By default | |
| * it is initialized to {@code null}. | |
| */ | |
| protected Locale[] availableLocales = null; | |
| /** | |
| * The current {@code Locale} to be used for localization, or | |
| * {@code null} if none has been set. By default it is | |
| * initialized to {@code null}. | |
| */ | |
| protected Locale locale = null; | |
| /** | |
| * A {@code List} of currently registered | |
| * {@code IIOWriteWarningListener}s, initialized by default to | |
| * {@code null}, which is synonymous with an empty | |
| * {@code List}. | |
| */ | |
| protected List<IIOWriteWarningListener> warningListeners = null; | |
| /** | |
| * A {@code List} of {@code Locale}s, one for each | |
| * element of {@code warningListeners}, initialized by default | |
| * {@code null}, which is synonymous with an empty | |
| * {@code List}. | |
| */ | |
| protected List<Locale> warningLocales = null; | |
| /** | |
| * A {@code List} of currently registered | |
| * {@code IIOWriteProgressListener}s, initialized by default | |
| * {@code null}, which is synonymous with an empty | |
| * {@code List}. | |
| */ | |
| protected List<IIOWriteProgressListener> progressListeners = null; | |
| /** | |
| * If {@code true}, the current write operation should be | |
| * aborted. | |
| */ | |
| private boolean abortFlag = false; | |
| /** | |
| * Constructs an {@code ImageWriter} and sets its | |
| * {@code originatingProvider} instance variable to the | |
| * supplied value. | |
| * | |
| * <p> Subclasses that make use of extensions should provide a | |
| * constructor with signature {@code (ImageWriterSpi, Object)} | |
| * in order to retrieve the extension object. If | |
| * the extension object is unsuitable, an | |
| * {@code IllegalArgumentException} should be thrown. | |
| * | |
| * @param originatingProvider the {@code ImageWriterSpi} that | |
| * is constructing this object, or {@code null}. | |
| */ | |
| protected ImageWriter(ImageWriterSpi originatingProvider) { | |
| this.originatingProvider = originatingProvider; | |
| } | |
| /** | |
| * Returns the {@code ImageWriterSpi} object that created | |
| * this {@code ImageWriter}, or {@code null} if this | |
| * object was not created through the {@code IIORegistry}. | |
| * | |
| * <p> The default implementation returns the value of the | |
| * {@code originatingProvider} instance variable. | |
| * | |
| * @return an {@code ImageWriterSpi}, or {@code null}. | |
| * | |
| * @see ImageWriterSpi | |
| */ | |
| public ImageWriterSpi getOriginatingProvider() { | |
| return originatingProvider; | |
| } | |
| /** | |
| * Sets the destination to the given | |
| * {@code ImageOutputStream} or other {@code Object}. | |
| * The destination is assumed to be ready to accept data, and will | |
| * not be closed at the end of each write. This allows distributed | |
| * imaging applications to transmit a series of images over a | |
| * single network connection. If {@code output} is | |
| * {@code null}, any currently set output will be removed. | |
| * | |
| * <p> If {@code output} is an | |
| * {@code ImageOutputStream}, calls to the | |
| * {@code write}, {@code writeToSequence}, and | |
| * {@code prepareWriteEmpty}/{@code endWriteEmpty} | |
| * methods will preserve the existing contents of the stream. | |
| * Other write methods, such as {@code writeInsert}, | |
| * {@code replaceStreamMetadata}, | |
| * {@code replaceImageMetadata}, {@code replacePixels}, | |
| * {@code prepareInsertEmpty}/{@code endInsertEmpty}, | |
| * and {@code endWriteSequence}, require the full contents | |
| * of the stream to be readable and writable, and may alter any | |
| * portion of the stream. | |
| * | |
| * <p> Use of a general {@code Object} other than an | |
| * {@code ImageOutputStream} is intended for writers that | |
| * interact directly with an output device or imaging protocol. | |
| * The set of legal classes is advertised by the writer's service | |
| * provider's {@code getOutputTypes} method; most writers | |
| * will return a single-element array containing only | |
| * {@code ImageOutputStream.class} to indicate that they | |
| * accept only an {@code ImageOutputStream}. | |
| * | |
| * <p> The default implementation sets the {@code output} | |
| * instance variable to the value of {@code output} after | |
| * checking {@code output} against the set of classes | |
| * advertised by the originating provider, if there is one. | |
| * | |
| * @param output the {@code ImageOutputStream} or other | |
| * {@code Object} to use for future writing. | |
| * | |
| * @throws IllegalArgumentException if {@code output} is | |
| * not an instance of one of the classes returned by the | |
| * originating service provider's {@code getOutputTypes} | |
| * method. | |
| * | |
| * @see #getOutput | |
| */ | |
| public void setOutput(Object output) { | |
| if (output != null) { | |
| ImageWriterSpi provider = getOriginatingProvider(); | |
| if (provider != null) { | |
| Class<?>[] classes = provider.getOutputTypes(); | |
| boolean found = false; | |
| for (int i = 0; i < classes.length; i++) { | |
| if (classes[i].isInstance(output)) { | |
| found = true; | |
| break; | |
| } | |
| } | |
| if (!found) { | |
| throw new IllegalArgumentException("Illegal output type!"); | |
| } | |
| } | |
| } | |
| this.output = output; | |
| } | |
| /** | |
| * Returns the {@code ImageOutputStream} or other | |
| * {@code Object} set by the most recent call to the | |
| * {@code setOutput} method. If no destination has been | |
| * set, {@code null} is returned. | |
| * | |
| * <p> The default implementation returns the value of the | |
| * {@code output} instance variable. | |
| * | |
| * @return the {@code Object} that was specified using | |
| * {@code setOutput}, or {@code null}. | |
| * | |
| * @see #setOutput | |
| */ | |
| public Object getOutput() { | |
| return output; | |
| } | |
| // Localization | |
| /** | |
| * Returns an array of {@code Locale}s that may be used to | |
| * localize warning listeners and compression settings. A return | |
| * value of {@code null} indicates that localization is not | |
| * supported. | |
| * | |
| * <p> The default implementation returns a clone of the | |
| * {@code availableLocales} instance variable if it is | |
| * non-{@code null}, or else returns {@code null}. | |
| * | |
| * @return an array of {@code Locale}s that may be used as | |
| * arguments to {@code setLocale}, or {@code null}. | |
| */ | |
| public Locale[] getAvailableLocales() { | |
| return (availableLocales == null) ? | |
| null : availableLocales.clone(); | |
| } | |
| /** | |
| * Sets the current {@code Locale} of this | |
| * {@code ImageWriter} to the given value. A value of | |
| * {@code null} removes any previous setting, and indicates | |
| * that the writer should localize as it sees fit. | |
| * | |
| * <p> The default implementation checks {@code locale} | |
| * against the values returned by | |
| * {@code getAvailableLocales}, and sets the | |
| * {@code locale} instance variable if it is found. If | |
| * {@code locale} is {@code null}, the instance variable | |
| * is set to {@code null} without any checking. | |
| * | |
| * @param locale the desired {@code Locale}, or | |
| * {@code null}. | |
| * | |
| * @throws IllegalArgumentException if {@code locale} is | |
| * non-{@code null} but is not one of the values returned by | |
| * {@code getAvailableLocales}. | |
| * | |
| * @see #getLocale | |
| */ | |
| public void setLocale(Locale locale) { | |
| if (locale != null) { | |
| Locale[] locales = getAvailableLocales(); | |
| boolean found = false; | |
| if (locales != null) { | |
| for (int i = 0; i < locales.length; i++) { | |
| if (locale.equals(locales[i])) { | |
| found = true; | |
| break; | |
| } | |
| } | |
| } | |
| if (!found) { | |
| throw new IllegalArgumentException("Invalid locale!"); | |
| } | |
| } | |
| this.locale = locale; | |
| } | |
| /** | |
| * Returns the currently set {@code Locale}, or | |
| * {@code null} if none has been set. | |
| * | |
| * <p> The default implementation returns the value of the | |
| * {@code locale} instance variable. | |
| * | |
| * @return the current {@code Locale}, or {@code null}. | |
| * | |
| * @see #setLocale | |
| */ | |
| public Locale getLocale() { | |
| return locale; | |
| } | |
| // Write params | |
| /** | |
| * Returns a new {@code ImageWriteParam} object of the | |
| * appropriate type for this file format containing default | |
| * values, that is, those values that would be used | |
| * if no {@code ImageWriteParam} object were specified. This | |
| * is useful as a starting point for tweaking just a few parameters | |
| * and otherwise leaving the default settings alone. | |
| * | |
| * <p> The default implementation constructs and returns a new | |
| * {@code ImageWriteParam} object that does not allow tiling, | |
| * progressive encoding, or compression, and that will be | |
| * localized for the current {@code Locale} (<i>i.e.</i>, | |
| * what you would get by calling | |
| * {@code new ImageWriteParam(getLocale())}. | |
| * | |
| * <p> Individual plug-ins may return an instance of | |
| * {@code ImageWriteParam} with additional optional features | |
| * enabled, or they may return an instance of a plug-in specific | |
| * subclass of {@code ImageWriteParam}. | |
| * | |
| * @return a new {@code ImageWriteParam} object containing | |
| * default values. | |
| */ | |
| public ImageWriteParam getDefaultWriteParam() { | |
| return new ImageWriteParam(getLocale()); | |
| } | |
| // Metadata | |
| /** | |
| * Returns an {@code IIOMetadata} object containing default | |
| * values for encoding a stream of images. The contents of the | |
| * object may be manipulated using either the XML tree structure | |
| * returned by the {@code IIOMetadata.getAsTree} method, an | |
| * {@code IIOMetadataController} object, or via plug-in | |
| * specific interfaces, and the resulting data supplied to one of | |
| * the {@code write} methods that take a stream metadata | |
| * parameter. | |
| * | |
| * <p> An optional {@code ImageWriteParam} may be supplied | |
| * for cases where it may affect the structure of the stream | |
| * metadata. | |
| * | |
| * <p> If the supplied {@code ImageWriteParam} contains | |
| * optional setting values not supported by this writer (<i>e.g.</i> | |
| * progressive encoding or any format-specific settings), they | |
| * will be ignored. | |
| * | |
| * <p> Writers that do not make use of stream metadata | |
| * (<i>e.g.</i>, writers for single-image formats) should return | |
| * {@code null}. | |
| * | |
| * @param param an {@code ImageWriteParam} that will be used to | |
| * encode the image, or {@code null}. | |
| * | |
| * @return an {@code IIOMetadata} object. | |
| */ | |
| public abstract IIOMetadata | |
| getDefaultStreamMetadata(ImageWriteParam param); | |
| /** | |
| * Returns an {@code IIOMetadata} object containing default | |
| * values for encoding an image of the given type. The contents | |
| * of the object may be manipulated using either the XML tree | |
| * structure returned by the {@code IIOMetadata.getAsTree} | |
| * method, an {@code IIOMetadataController} object, or via | |
| * plug-in specific interfaces, and the resulting data supplied to | |
| * one of the {@code write} methods that take a stream | |
| * metadata parameter. | |
| * | |
| * <p> An optional {@code ImageWriteParam} may be supplied | |
| * for cases where it may affect the structure of the image | |
| * metadata. | |
| * | |
| * <p> If the supplied {@code ImageWriteParam} contains | |
| * optional setting values not supported by this writer (<i>e.g.</i> | |
| * progressive encoding or any format-specific settings), they | |
| * will be ignored. | |
| * | |
| * @param imageType an {@code ImageTypeSpecifier} indicating the | |
| * format of the image to be written later. | |
| * @param param an {@code ImageWriteParam} that will be used to | |
| * encode the image, or {@code null}. | |
| * | |
| * @return an {@code IIOMetadata} object. | |
| */ | |
| public abstract IIOMetadata | |
| getDefaultImageMetadata(ImageTypeSpecifier imageType, | |
| ImageWriteParam param); | |
| // comment inherited | |
| public abstract IIOMetadata convertStreamMetadata(IIOMetadata inData, | |
| ImageWriteParam param); | |
| // comment inherited | |
| public abstract IIOMetadata | |
| convertImageMetadata(IIOMetadata inData, | |
| ImageTypeSpecifier imageType, | |
| ImageWriteParam param); | |
| // Thumbnails | |
| /** | |
| * Returns the number of thumbnails supported by the format being | |
| * written, given the image type and any additional write | |
| * parameters and metadata objects that will be used during | |
| * encoding. A return value of {@code -1} indicates that | |
| * insufficient information is available. | |
| * | |
| * <p> An {@code ImageWriteParam} may optionally be supplied | |
| * for cases where it may affect thumbnail handling. | |
| * | |
| * <p> If the supplied {@code ImageWriteParam} contains | |
| * optional setting values not supported by this writer (<i>e.g.</i> | |
| * progressive encoding or any format-specific settings), they | |
| * will be ignored. | |
| * | |
| * <p> The default implementation returns 0. | |
| * | |
| * @param imageType an {@code ImageTypeSpecifier} indicating | |
| * the type of image to be written, or {@code null}. | |
| * @param param the {@code ImageWriteParam} that will be used for | |
| * writing, or {@code null}. | |
| * @param streamMetadata an {@code IIOMetadata} object that will | |
| * be used for writing, or {@code null}. | |
| * @param imageMetadata an {@code IIOMetadata} object that will | |
| * be used for writing, or {@code null}. | |
| * | |
| * @return the number of thumbnails that may be written given the | |
| * supplied parameters, or {@code -1} if insufficient | |
| * information is available. | |
| */ | |
| public int getNumThumbnailsSupported(ImageTypeSpecifier imageType, | |
| ImageWriteParam param, | |
| IIOMetadata streamMetadata, | |
| IIOMetadata imageMetadata) { | |
| return 0; | |
| } | |
| /** | |
| * Returns an array of {@code Dimension}s indicating the | |
| * legal size ranges for thumbnail images as they will be encoded | |
| * in the output file or stream. This information is merely | |
| * advisory; the writer will resize any supplied thumbnails as | |
| * necessary. | |
| * | |
| * <p> The information is returned as a set of pairs; the first | |
| * element of a pair contains an (inclusive) minimum width and | |
| * height, and the second element contains an (inclusive) maximum | |
| * width and height. Together, each pair defines a valid range of | |
| * sizes. To specify a fixed size, the same width and height will | |
| * appear for both elements. A return value of {@code null} | |
| * indicates that the size is arbitrary or unknown. | |
| * | |
| * <p> An {@code ImageWriteParam} may optionally be supplied | |
| * for cases where it may affect thumbnail handling. | |
| * | |
| * <p> If the supplied {@code ImageWriteParam} contains | |
| * optional setting values not supported by this writer (<i>e.g.</i> | |
| * progressive encoding or any format-specific settings), they | |
| * will be ignored. | |
| * | |
| * <p> The default implementation returns {@code null}. | |
| * | |
| * @param imageType an {@code ImageTypeSpecifier} indicating the | |
| * type of image to be written, or {@code null}. | |
| * @param param the {@code ImageWriteParam} that will be used for | |
| * writing, or {@code null}. | |
| * @param streamMetadata an {@code IIOMetadata} object that will | |
| * be used for writing, or {@code null}. | |
| * @param imageMetadata an {@code IIOMetadata} object that will | |
| * be used for writing, or {@code null}. | |
| * | |
| * @return an array of {@code Dimension}s with an even length | |
| * of at least two, or {@code null}. | |
| */ | |
| public Dimension[] getPreferredThumbnailSizes(ImageTypeSpecifier imageType, | |
| ImageWriteParam param, | |
| IIOMetadata streamMetadata, | |
| IIOMetadata imageMetadata) { | |
| return null; | |
| } | |
| /** | |
| * Returns {@code true} if the methods that take an | |
| * {@code IIOImage} parameter are capable of dealing with a | |
| * {@code Raster} (as opposed to {@code RenderedImage}) | |
| * source image. If this method returns {@code false}, then | |
| * those methods will throw an | |
| * {@code UnsupportedOperationException} if supplied with an | |
| * {@code IIOImage} containing a {@code Raster}. | |
| * | |
| * <p> The default implementation returns {@code false}. | |
| * | |
| * @return {@code true} if {@code Raster} sources are | |
| * supported. | |
| */ | |
| public boolean canWriteRasters() { | |
| return false; | |
| } | |
| /** | |
| * Appends a complete image stream containing a single image and | |
| * associated stream and image metadata and thumbnails to the | |
| * output. Any necessary header information is included. If the | |
| * output is an {@code ImageOutputStream}, its existing | |
| * contents prior to the current seek position are not affected, | |
| * and need not be readable or writable. | |
| * | |
| * <p> The output must have been set beforehand using the | |
| * {@code setOutput} method. | |
| * | |
| * <p> Stream metadata may optionally be supplied; if it is | |
| * {@code null}, default stream metadata will be used. | |
| * | |
| * <p> If {@code canWriteRasters} returns {@code true}, | |
| * the {@code IIOImage} may contain a {@code Raster} | |
| * source. Otherwise, it must contain a | |
| * {@code RenderedImage} source. | |
| * | |
| * <p> The supplied thumbnails will be resized if needed, and any | |
| * thumbnails in excess of the supported number will be ignored. | |
| * If the format requires additional thumbnails that are not | |
| * provided, the writer should generate them internally. | |
| * | |
| * <p> An {@code ImageWriteParam} may | |
| * optionally be supplied to control the writing process. If | |
| * {@code param} is {@code null}, a default write param | |
| * will be used. | |
| * | |
| * <p> If the supplied {@code ImageWriteParam} contains | |
| * optional setting values not supported by this writer (<i>e.g.</i> | |
| * progressive encoding or any format-specific settings), they | |
| * will be ignored. | |
| * | |
| * @param streamMetadata an {@code IIOMetadata} object representing | |
| * stream metadata, or {@code null} to use default values. | |
| * @param image an {@code IIOImage} object containing an | |
| * image, thumbnails, and metadata to be written. | |
| * @param param an {@code ImageWriteParam}, or | |
| * {@code null} to use a default | |
| * {@code ImageWriteParam}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if {@code image} | |
| * contains a {@code Raster} and {@code canWriteRasters} | |
| * returns {@code false}. | |
| * @throws IllegalArgumentException if {@code image} is | |
| * {@code null}. | |
| * @throws IOException if an error occurs during writing. | |
| */ | |
| public abstract void write(IIOMetadata streamMetadata, | |
| IIOImage image, | |
| ImageWriteParam param) throws IOException; | |
| /** | |
| * Appends a complete image stream containing a single image with | |
| * default metadata and thumbnails to the output. This method is | |
| * a shorthand for {@code write(null, image, null)}. | |
| * | |
| * @param image an {@code IIOImage} object containing an | |
| * image, thumbnails, and metadata to be written. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws IllegalArgumentException if {@code image} is | |
| * {@code null}. | |
| * @throws UnsupportedOperationException if {@code image} | |
| * contains a {@code Raster} and {@code canWriteRasters} | |
| * returns {@code false}. | |
| * @throws IOException if an error occurs during writing. | |
| */ | |
| public void write(IIOImage image) throws IOException { | |
| write(null, image, null); | |
| } | |
| /** | |
| * Appends a complete image stream consisting of a single image | |
| * with default metadata and thumbnails to the output. This | |
| * method is a shorthand for | |
| * {@code write(null, new IIOImage(image, null, null), null)}. | |
| * | |
| * @param image a {@code RenderedImage} to be written. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws IllegalArgumentException if {@code image} is | |
| * {@code null}. | |
| * @throws IOException if an error occurs during writing. | |
| */ | |
| public void write(RenderedImage image) throws IOException { | |
| write(null, new IIOImage(image, null, null), null); | |
| } | |
| // Check that the output has been set, then throw an | |
| // UnsupportedOperationException. | |
| private void unsupported() { | |
| if (getOutput() == null) { | |
| throw new IllegalStateException("getOutput() == null!"); | |
| } | |
| throw new UnsupportedOperationException("Unsupported write variant!"); | |
| } | |
| // Sequence writes | |
| /** | |
| * Returns {@code true} if the writer is able to append an | |
| * image to an image stream that already contains header | |
| * information and possibly prior images. | |
| * | |
| * <p> If {@code canWriteSequence} returns {@code false}, | |
| * {@code writeToSequence} and {@code endWriteSequence} | |
| * will throw an {@code UnsupportedOperationException}. | |
| * | |
| * <p> The default implementation returns {@code false}. | |
| * | |
| * @return {@code true} if images may be appended sequentially. | |
| */ | |
| public boolean canWriteSequence() { | |
| return false; | |
| } | |
| /** | |
| * Prepares a stream to accept a series of subsequent | |
| * {@code writeToSequence} calls, using the provided stream | |
| * metadata object. The metadata will be written to the stream if | |
| * it should precede the image data. If the argument is {@code null}, | |
| * default stream metadata is used. | |
| * | |
| * <p> If the output is an {@code ImageOutputStream}, the existing | |
| * contents of the output prior to the current seek position are | |
| * flushed, and need not be readable or writable. If the format | |
| * requires that {@code endWriteSequence} be able to rewind to | |
| * patch up the header information, such as for a sequence of images | |
| * in a single TIFF file, then the metadata written by this method | |
| * must remain in a writable portion of the stream. Other formats | |
| * may flush the stream after this method and after each image. | |
| * | |
| * <p> If {@code canWriteSequence} returns {@code false}, | |
| * this method will throw an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * <p> The output must have been set beforehand using either | |
| * the {@code setOutput} method. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param streamMetadata A stream metadata object, or {@code null}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canWriteSequence} returns {@code false}. | |
| * @throws IOException if an error occurs writing the stream | |
| * metadata. | |
| */ | |
| public void prepareWriteSequence(IIOMetadata streamMetadata) | |
| throws IOException { | |
| unsupported(); | |
| } | |
| /** | |
| * Appends a single image and possibly associated metadata and | |
| * thumbnails, to the output. If the output is an | |
| * {@code ImageOutputStream}, the existing contents of the | |
| * output prior to the current seek position may be flushed, and | |
| * need not be readable or writable, unless the plug-in needs to | |
| * be able to patch up the header information when | |
| * {@code endWriteSequence} is called (<i>e.g.</i> TIFF). | |
| * | |
| * <p> If {@code canWriteSequence} returns {@code false}, | |
| * this method will throw an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * <p> The output must have been set beforehand using | |
| * the {@code setOutput} method. | |
| * | |
| * <p> {@code prepareWriteSequence} must have been called | |
| * beforehand, or an {@code IllegalStateException} is thrown. | |
| * | |
| * <p> If {@code canWriteRasters} returns {@code true}, | |
| * the {@code IIOImage} may contain a {@code Raster} | |
| * source. Otherwise, it must contain a | |
| * {@code RenderedImage} source. | |
| * | |
| * <p> The supplied thumbnails will be resized if needed, and any | |
| * thumbnails in excess of the supported number will be ignored. | |
| * If the format requires additional thumbnails that are not | |
| * provided, the writer will generate them internally. | |
| * | |
| * <p> An {@code ImageWriteParam} may optionally be supplied | |
| * to control the writing process. If {@code param} is | |
| * {@code null}, a default write param will be used. | |
| * | |
| * <p> If the supplied {@code ImageWriteParam} contains | |
| * optional setting values not supported by this writer (<i>e.g.</i> | |
| * progressive encoding or any format-specific settings), they | |
| * will be ignored. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param image an {@code IIOImage} object containing an | |
| * image, thumbnails, and metadata to be written. | |
| * @param param an {@code ImageWriteParam}, or | |
| * {@code null} to use a default | |
| * {@code ImageWriteParam}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set, or {@code prepareWriteSequence} has not been called. | |
| * @throws UnsupportedOperationException if | |
| * {@code canWriteSequence} returns {@code false}. | |
| * @throws IllegalArgumentException if {@code image} is | |
| * {@code null}. | |
| * @throws UnsupportedOperationException if {@code image} | |
| * contains a {@code Raster} and {@code canWriteRasters} | |
| * returns {@code false}. | |
| * @throws IOException if an error occurs during writing. | |
| */ | |
| public void writeToSequence(IIOImage image, ImageWriteParam param) | |
| throws IOException { | |
| unsupported(); | |
| } | |
| /** | |
| * Completes the writing of a sequence of images begun with | |
| * {@code prepareWriteSequence}. Any stream metadata that | |
| * should come at the end of the sequence of images is written out, | |
| * and any header information at the beginning of the sequence is | |
| * patched up if necessary. If the output is an | |
| * {@code ImageOutputStream}, data through the stream metadata | |
| * at the end of the sequence are flushed and need not be readable | |
| * or writable. | |
| * | |
| * <p> If {@code canWriteSequence} returns {@code false}, | |
| * this method will throw an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set, or {@code prepareWriteSequence} has not been called. | |
| * @throws UnsupportedOperationException if | |
| * {@code canWriteSequence} returns {@code false}. | |
| * @throws IOException if an error occurs during writing. | |
| */ | |
| public void endWriteSequence() throws IOException { | |
| unsupported(); | |
| } | |
| // Metadata replacement | |
| /** | |
| * Returns {@code true} if it is possible to replace the | |
| * stream metadata already present in the output. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise returns {@code false}. | |
| * | |
| * @return {@code true} if replacement of stream metadata is | |
| * allowed. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws IOException if an I/O error occurs during the query. | |
| */ | |
| public boolean canReplaceStreamMetadata() throws IOException { | |
| if (getOutput() == null) { | |
| throw new IllegalStateException("getOutput() == null!"); | |
| } | |
| return false; | |
| } | |
| /** | |
| * Replaces the stream metadata in the output with new | |
| * information. If the output is an | |
| * {@code ImageOutputStream}, the prior contents of the | |
| * stream are examined and possibly edited to make room for the | |
| * new data. All of the prior contents of the output must be | |
| * available for reading and writing. | |
| * | |
| * <p> If {@code canReplaceStreamMetadata} returns | |
| * {@code false}, an | |
| * {@code UnsupportedOperationException} will be thrown. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param streamMetadata an {@code IIOMetadata} object representing | |
| * stream metadata, or {@code null} to use default values. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if the | |
| * {@code canReplaceStreamMetadata} returns | |
| * {@code false}. modes do not include | |
| * @throws IOException if an error occurs during writing. | |
| */ | |
| public void replaceStreamMetadata(IIOMetadata streamMetadata) | |
| throws IOException { | |
| unsupported(); | |
| } | |
| /** | |
| * Returns {@code true} if it is possible to replace the | |
| * image metadata associated with an existing image with index | |
| * {@code imageIndex}. If this method returns | |
| * {@code false}, a call to | |
| * {@code replaceImageMetadata(imageIndex)} will throw an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * <p> A writer that does not support any image metadata | |
| * replacement may return {@code false} without performing | |
| * bounds checking on the index. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise returns {@code false} | |
| * without checking the value of {@code imageIndex}. | |
| * | |
| * @param imageIndex the index of the image whose metadata is to | |
| * be replaced. | |
| * | |
| * @return {@code true} if the image metadata of the given | |
| * image can be replaced. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws IndexOutOfBoundsException if the writer supports | |
| * image metadata replacement in general, but | |
| * {@code imageIndex} is less than 0 or greater than the | |
| * largest available index. | |
| * @throws IOException if an I/O error occurs during the query. | |
| */ | |
| public boolean canReplaceImageMetadata(int imageIndex) | |
| throws IOException { | |
| if (getOutput() == null) { | |
| throw new IllegalStateException("getOutput() == null!"); | |
| } | |
| return false; | |
| } | |
| /** | |
| * Replaces the image metadata associated with an existing image. | |
| * | |
| * <p> If {@code canReplaceImageMetadata(imageIndex)} returns | |
| * {@code false}, an | |
| * {@code UnsupportedOperationException} will be thrown. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param imageIndex the index of the image whose metadata is to | |
| * be replaced. | |
| * @param imageMetadata an {@code IIOMetadata} object | |
| * representing image metadata, or {@code null}. | |
| * | |
| * @throws IllegalStateException if the output has not been | |
| * set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canReplaceImageMetadata} returns | |
| * {@code false}. | |
| * @throws IndexOutOfBoundsException if {@code imageIndex} | |
| * is less than 0 or greater than the largest available index. | |
| * @throws IOException if an error occurs during writing. | |
| */ | |
| public void replaceImageMetadata(int imageIndex, | |
| IIOMetadata imageMetadata) | |
| throws IOException { | |
| unsupported(); | |
| } | |
| // Image insertion | |
| /** | |
| * Returns {@code true} if the writer supports the insertion | |
| * of a new image at the given index. Existing images with | |
| * indices greater than or equal to the insertion index will have | |
| * their indices increased by 1. A value for | |
| * {@code imageIndex} of {@code -1} may be used to | |
| * signify an index one larger than the current largest index. | |
| * | |
| * <p> A writer that does not support any image insertion may | |
| * return {@code false} without performing bounds checking on | |
| * the index. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise returns {@code false} | |
| * without checking the value of {@code imageIndex}. | |
| * | |
| * @param imageIndex the index at which the image is to be | |
| * inserted. | |
| * | |
| * @return {@code true} if an image may be inserted at the | |
| * given index. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws IndexOutOfBoundsException if the writer supports | |
| * image insertion in general, but {@code imageIndex} is less | |
| * than -1 or greater than the largest available index. | |
| * @throws IOException if an I/O error occurs during the query. | |
| */ | |
| public boolean canInsertImage(int imageIndex) throws IOException { | |
| if (getOutput() == null) { | |
| throw new IllegalStateException("getOutput() == null!"); | |
| } | |
| return false; | |
| } | |
| /** | |
| * Inserts a new image into an existing image stream. Existing | |
| * images with an index greater than {@code imageIndex} are | |
| * preserved, and their indices are each increased by 1. A value | |
| * for {@code imageIndex} of -1 may be used to signify an | |
| * index one larger than the previous largest index; that is, it | |
| * will cause the image to be logically appended to the end of the | |
| * sequence. If the output is an {@code ImageOutputStream}, | |
| * the entirety of the stream must be both readable and writeable. | |
| * | |
| * <p> If {@code canInsertImage(imageIndex)} returns | |
| * {@code false}, an | |
| * {@code UnsupportedOperationException} will be thrown. | |
| * | |
| * <p> An {@code ImageWriteParam} may optionally be supplied | |
| * to control the writing process. If {@code param} is | |
| * {@code null}, a default write param will be used. | |
| * | |
| * <p> If the supplied {@code ImageWriteParam} contains | |
| * optional setting values not supported by this writer (<i>e.g.</i> | |
| * progressive encoding or any format-specific settings), they | |
| * will be ignored. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param imageIndex the index at which to write the image. | |
| * @param image an {@code IIOImage} object containing an | |
| * image, thumbnails, and metadata to be written. | |
| * @param param an {@code ImageWriteParam}, or | |
| * {@code null} to use a default | |
| * {@code ImageWriteParam}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canInsertImage(imageIndex)} returns {@code false}. | |
| * @throws IllegalArgumentException if {@code image} is | |
| * {@code null}. | |
| * @throws IndexOutOfBoundsException if {@code imageIndex} | |
| * is less than -1 or greater than the largest available index. | |
| * @throws UnsupportedOperationException if {@code image} | |
| * contains a {@code Raster} and {@code canWriteRasters} | |
| * returns {@code false}. | |
| * @throws IOException if an error occurs during writing. | |
| */ | |
| public void writeInsert(int imageIndex, | |
| IIOImage image, | |
| ImageWriteParam param) throws IOException { | |
| unsupported(); | |
| } | |
| // Image removal | |
| /** | |
| * Returns {@code true} if the writer supports the removal | |
| * of an existing image at the given index. Existing images with | |
| * indices greater than the insertion index will have | |
| * their indices decreased by 1. | |
| * | |
| * <p> A writer that does not support any image removal may | |
| * return {@code false} without performing bounds checking on | |
| * the index. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise returns {@code false} | |
| * without checking the value of {@code imageIndex}. | |
| * | |
| * @param imageIndex the index of the image to be removed. | |
| * | |
| * @return {@code true} if it is possible to remove the given | |
| * image. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws IndexOutOfBoundsException if the writer supports | |
| * image removal in general, but {@code imageIndex} is less | |
| * than 0 or greater than the largest available index. | |
| * @throws IOException if an I/O error occurs during the | |
| * query. | |
| */ | |
| public boolean canRemoveImage(int imageIndex) throws IOException { | |
| if (getOutput() == null) { | |
| throw new IllegalStateException("getOutput() == null!"); | |
| } | |
| return false; | |
| } | |
| /** | |
| * Removes an image from the stream. | |
| * | |
| * <p> If {@code canRemoveImage(imageIndex)} returns false, | |
| * an {@code UnsupportedOperationException} will be thrown. | |
| * | |
| * <p> The removal may or may not cause a reduction in the actual | |
| * file size. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param imageIndex the index of the image to be removed. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canRemoveImage(imageIndex)} returns {@code false}. | |
| * @throws IndexOutOfBoundsException if {@code imageIndex} | |
| * is less than 0 or greater than the largest available index. | |
| * @throws IOException if an I/O error occurs during the | |
| * removal. | |
| */ | |
| public void removeImage(int imageIndex) throws IOException { | |
| unsupported(); | |
| } | |
| // Empty images | |
| /** | |
| * Returns {@code true} if the writer supports the writing of | |
| * a complete image stream consisting of a single image with | |
| * undefined pixel values and associated metadata and thumbnails | |
| * to the output. The pixel values may be defined by future | |
| * calls to the {@code replacePixels} methods. If the output | |
| * is an {@code ImageOutputStream}, its existing contents | |
| * prior to the current seek position are not affected, and need | |
| * not be readable or writable. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise returns {@code false}. | |
| * | |
| * @return {@code true} if the writing of complete image | |
| * stream with contents to be defined later is supported. | |
| * | |
| * @throws IllegalStateException if the output has not been | |
| * set. | |
| * @throws IOException if an I/O error occurs during the | |
| * query. | |
| */ | |
| public boolean canWriteEmpty() throws IOException { | |
| if (getOutput() == null) { | |
| throw new IllegalStateException("getOutput() == null!"); | |
| } | |
| return false; | |
| } | |
| /** | |
| * Begins the writing of a complete image stream, consisting of a | |
| * single image with undefined pixel values and associated | |
| * metadata and thumbnails, to the output. The pixel values will | |
| * be defined by future calls to the {@code replacePixels} | |
| * methods. If the output is an {@code ImageOutputStream}, | |
| * its existing contents prior to the current seek position are | |
| * not affected, and need not be readable or writable. | |
| * | |
| * <p> The writing is not complete until a call to | |
| * {@code endWriteEmpty} occurs. Calls to | |
| * {@code prepareReplacePixels}, {@code replacePixels}, | |
| * and {@code endReplacePixels} may occur between calls to | |
| * {@code prepareWriteEmpty} and {@code endWriteEmpty}. | |
| * However, calls to {@code prepareWriteEmpty} cannot be | |
| * nested, and calls to {@code prepareWriteEmpty} and | |
| * {@code prepareInsertEmpty} may not be interspersed. | |
| * | |
| * <p> If {@code canWriteEmpty} returns {@code false}, | |
| * an {@code UnsupportedOperationException} will be thrown. | |
| * | |
| * <p> An {@code ImageWriteParam} may optionally be supplied | |
| * to control the writing process. If {@code param} is | |
| * {@code null}, a default write param will be used. | |
| * | |
| * <p> If the supplied {@code ImageWriteParam} contains | |
| * optional setting values not supported by this writer (<i>e.g.</i> | |
| * progressive encoding or any format-specific settings), they | |
| * will be ignored. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param streamMetadata an {@code IIOMetadata} object representing | |
| * stream metadata, or {@code null} to use default values. | |
| * @param imageType an {@code ImageTypeSpecifier} describing | |
| * the layout of the image. | |
| * @param width the width of the image. | |
| * @param height the height of the image. | |
| * @param imageMetadata an {@code IIOMetadata} object | |
| * representing image metadata, or {@code null}. | |
| * @param thumbnails a {@code List} of | |
| * {@code BufferedImage} thumbnails for this image, or | |
| * {@code null}. | |
| * @param param an {@code ImageWriteParam}, or | |
| * {@code null} to use a default | |
| * {@code ImageWriteParam}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canWriteEmpty} returns {@code false}. | |
| * @throws IllegalStateException if a previous call to | |
| * {@code prepareWriteEmpty} has been made without a | |
| * corresponding call to {@code endWriteEmpty}. | |
| * @throws IllegalStateException if a previous call to | |
| * {@code prepareInsertEmpty} has been made without a | |
| * corresponding call to {@code endInsertEmpty}. | |
| * @throws IllegalArgumentException if {@code imageType} | |
| * is {@code null} or {@code thumbnails} contains | |
| * {@code null} references or objects other than | |
| * {@code BufferedImage}s. | |
| * @throws IllegalArgumentException if width or height are less | |
| * than 1. | |
| * @throws IOException if an I/O error occurs during writing. | |
| */ | |
| public void prepareWriteEmpty(IIOMetadata streamMetadata, | |
| ImageTypeSpecifier imageType, | |
| int width, int height, | |
| IIOMetadata imageMetadata, | |
| List<? extends BufferedImage> thumbnails, | |
| ImageWriteParam param) throws IOException { | |
| unsupported(); | |
| } | |
| /** | |
| * Completes the writing of a new image that was begun with a | |
| * prior call to {@code prepareWriteEmpty}. | |
| * | |
| * <p> If {@code canWriteEmpty()} returns {@code false}, | |
| * an {@code UnsupportedOperationException} will be thrown. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canWriteEmpty(imageIndex)} returns | |
| * {@code false}. | |
| * @throws IllegalStateException if a previous call to | |
| * {@code prepareWriteEmpty} without a corresponding call to | |
| * {@code endWriteEmpty} has not been made. | |
| * @throws IllegalStateException if a previous call to | |
| * {@code prepareInsertEmpty} without a corresponding call to | |
| * {@code endInsertEmpty} has been made. | |
| * @throws IllegalStateException if a call to | |
| * {@code prepareReiplacePixels} has been made without a | |
| * matching call to {@code endReplacePixels}. | |
| * @throws IOException if an I/O error occurs during writing. | |
| */ | |
| public void endWriteEmpty() throws IOException { | |
| if (getOutput() == null) { | |
| throw new IllegalStateException("getOutput() == null!"); | |
| } | |
| throw new IllegalStateException("No call to prepareWriteEmpty!"); | |
| } | |
| /** | |
| * Returns {@code true} if the writer supports the insertion | |
| * of a new, empty image at the given index. The pixel values of | |
| * the image are undefined, and may be specified in pieces using | |
| * the {@code replacePixels} methods. Existing images with | |
| * indices greater than or equal to the insertion index will have | |
| * their indices increased by 1. A value for | |
| * {@code imageIndex} of {@code -1} may be used to | |
| * signify an index one larger than the current largest index. | |
| * | |
| * <p> A writer that does not support insertion of empty images | |
| * may return {@code false} without performing bounds | |
| * checking on the index. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise returns {@code false} | |
| * without checking the value of {@code imageIndex}. | |
| * | |
| * @param imageIndex the index at which the image is to be | |
| * inserted. | |
| * | |
| * @return {@code true} if an empty image may be inserted at | |
| * the given index. | |
| * | |
| * @throws IllegalStateException if the output has not been | |
| * set. | |
| * @throws IndexOutOfBoundsException if the writer supports | |
| * empty image insertion in general, but {@code imageIndex} | |
| * is less than -1 or greater than the largest available index. | |
| * @throws IOException if an I/O error occurs during the | |
| * query. | |
| */ | |
| public boolean canInsertEmpty(int imageIndex) throws IOException { | |
| if (getOutput() == null) { | |
| throw new IllegalStateException("getOutput() == null!"); | |
| } | |
| return false; | |
| } | |
| /** | |
| * Begins the insertion of a new image with undefined pixel values | |
| * into an existing image stream. Existing images with an index | |
| * greater than {@code imageIndex} are preserved, and their | |
| * indices are each increased by 1. A value for | |
| * {@code imageIndex} of -1 may be used to signify an index | |
| * one larger than the previous largest index; that is, it will | |
| * cause the image to be logically appended to the end of the | |
| * sequence. If the output is an {@code ImageOutputStream}, | |
| * the entirety of the stream must be both readable and writeable. | |
| * | |
| * <p> The image contents may be | |
| * supplied later using the {@code replacePixels} method. | |
| * The insertion is not complete until a call to | |
| * {@code endInsertEmpty} occurs. Calls to | |
| * {@code prepareReplacePixels}, {@code replacePixels}, | |
| * and {@code endReplacePixels} may occur between calls to | |
| * {@code prepareInsertEmpty} and | |
| * {@code endInsertEmpty}. However, calls to | |
| * {@code prepareInsertEmpty} cannot be nested, and calls to | |
| * {@code prepareWriteEmpty} and | |
| * {@code prepareInsertEmpty} may not be interspersed. | |
| * | |
| * <p> If {@code canInsertEmpty(imageIndex)} returns | |
| * {@code false}, an | |
| * {@code UnsupportedOperationException} will be thrown. | |
| * | |
| * <p> An {@code ImageWriteParam} may optionally be supplied | |
| * to control the writing process. If {@code param} is | |
| * {@code null}, a default write param will be used. | |
| * | |
| * <p> If the supplied {@code ImageWriteParam} contains | |
| * optional setting values not supported by this writer (<i>e.g.</i> | |
| * progressive encoding or any format-specific settings), they | |
| * will be ignored. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param imageIndex the index at which to write the image. | |
| * @param imageType an {@code ImageTypeSpecifier} describing | |
| * the layout of the image. | |
| * @param width the width of the image. | |
| * @param height the height of the image. | |
| * @param imageMetadata an {@code IIOMetadata} object | |
| * representing image metadata, or {@code null}. | |
| * @param thumbnails a {@code List} of | |
| * {@code BufferedImage} thumbnails for this image, or | |
| * {@code null}. | |
| * @param param an {@code ImageWriteParam}, or | |
| * {@code null} to use a default | |
| * {@code ImageWriteParam}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canInsertEmpty(imageIndex)} returns | |
| * {@code false}. | |
| * @throws IndexOutOfBoundsException if {@code imageIndex} | |
| * is less than -1 or greater than the largest available index. | |
| * @throws IllegalStateException if a previous call to | |
| * {@code prepareInsertEmpty} has been made without a | |
| * corresponding call to {@code endInsertEmpty}. | |
| * @throws IllegalStateException if a previous call to | |
| * {@code prepareWriteEmpty} has been made without a | |
| * corresponding call to {@code endWriteEmpty}. | |
| * @throws IllegalArgumentException if {@code imageType} | |
| * is {@code null} or {@code thumbnails} contains | |
| * {@code null} references or objects other than | |
| * {@code BufferedImage}s. | |
| * @throws IllegalArgumentException if width or height are less | |
| * than 1. | |
| * @throws IOException if an I/O error occurs during writing. | |
| */ | |
| public void prepareInsertEmpty(int imageIndex, | |
| ImageTypeSpecifier imageType, | |
| int width, int height, | |
| IIOMetadata imageMetadata, | |
| List<? extends BufferedImage> thumbnails, | |
| ImageWriteParam param) throws IOException { | |
| unsupported(); | |
| } | |
| /** | |
| * Completes the insertion of a new image that was begun with a | |
| * prior call to {@code prepareInsertEmpty}. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canInsertEmpty(imageIndex)} returns | |
| * {@code false}. | |
| * @throws IllegalStateException if a previous call to | |
| * {@code prepareInsertEmpty} without a corresponding call to | |
| * {@code endInsertEmpty} has not been made. | |
| * @throws IllegalStateException if a previous call to | |
| * {@code prepareWriteEmpty} without a corresponding call to | |
| * {@code endWriteEmpty} has been made. | |
| * @throws IllegalStateException if a call to | |
| * {@code prepareReplacePixels} has been made without a | |
| * matching call to {@code endReplacePixels}. | |
| * @throws IOException if an I/O error occurs during writing. | |
| */ | |
| public void endInsertEmpty() throws IOException { | |
| unsupported(); | |
| } | |
| // Pixel replacement | |
| /** | |
| * Returns {@code true} if the writer allows pixels of the | |
| * given image to be replaced using the {@code replacePixels} | |
| * methods. | |
| * | |
| * <p> A writer that does not support any pixel replacement may | |
| * return {@code false} without performing bounds checking on | |
| * the index. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise returns {@code false} | |
| * without checking the value of {@code imageIndex}. | |
| * | |
| * @param imageIndex the index of the image whose pixels are to be | |
| * replaced. | |
| * | |
| * @return {@code true} if the pixels of the given | |
| * image can be replaced. | |
| * | |
| * @throws IllegalStateException if the output has not been | |
| * set. | |
| * @throws IndexOutOfBoundsException if the writer supports | |
| * pixel replacement in general, but {@code imageIndex} is | |
| * less than 0 or greater than the largest available index. | |
| * @throws IOException if an I/O error occurs during the query. | |
| */ | |
| public boolean canReplacePixels(int imageIndex) throws IOException { | |
| if (getOutput() == null) { | |
| throw new IllegalStateException("getOutput() == null!"); | |
| } | |
| return false; | |
| } | |
| /** | |
| * Prepares the writer to handle a series of calls to the | |
| * {@code replacePixels} methods. The affected pixel area | |
| * will be clipped against the supplied | |
| * | |
| * <p> If {@code canReplacePixels} returns | |
| * {@code false}, and | |
| * {@code UnsupportedOperationException} will be thrown. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param imageIndex the index of the image whose pixels are to be | |
| * replaced. | |
| * @param region a {@code Rectangle} that will be used to clip | |
| * future pixel regions. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canReplacePixels(imageIndex)} returns | |
| * {@code false}. | |
| * @throws IndexOutOfBoundsException if {@code imageIndex} | |
| * is less than 0 or greater than the largest available index. | |
| * @throws IllegalStateException if there is a previous call to | |
| * {@code prepareReplacePixels} without a matching call to | |
| * {@code endReplacePixels} (<i>i.e.</i>, nesting is not | |
| * allowed). | |
| * @throws IllegalArgumentException if {@code region} is | |
| * {@code null} or has a width or height less than 1. | |
| * @throws IOException if an I/O error occurs during the | |
| * preparation. | |
| */ | |
| public void prepareReplacePixels(int imageIndex, | |
| Rectangle region) throws IOException { | |
| unsupported(); | |
| } | |
| /** | |
| * Replaces a portion of an image already present in the output | |
| * with a portion of the given image. The image data must match, | |
| * or be convertible to, the image layout of the existing image. | |
| * | |
| * <p> The destination region is specified in the | |
| * {@code param} argument, and will be clipped to the image | |
| * boundaries and the region supplied to | |
| * {@code prepareReplacePixels}. At least one pixel of the | |
| * source must not be clipped, or an exception is thrown. | |
| * | |
| * <p> An {@code ImageWriteParam} may optionally be supplied | |
| * to control the writing process. If {@code param} is | |
| * {@code null}, a default write param will be used. | |
| * | |
| * <p> If the supplied {@code ImageWriteParam} contains | |
| * optional setting values not supported by this writer (<i>e.g.</i> | |
| * progressive encoding or any format-specific settings), they | |
| * will be ignored. | |
| * | |
| * <p> This method may only be called after a call to | |
| * {@code prepareReplacePixels}, or else an | |
| * {@code IllegalStateException} will be thrown. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param image a {@code RenderedImage} containing source | |
| * pixels. | |
| * @param param an {@code ImageWriteParam}, or | |
| * {@code null} to use a default | |
| * {@code ImageWriteParam}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canReplacePixels(imageIndex)} returns | |
| * {@code false}. | |
| * @throws IllegalStateException if there is no previous call to | |
| * {@code prepareReplacePixels} without a matching call to | |
| * {@code endReplacePixels}. | |
| * @throws IllegalArgumentException if any of the following are true: | |
| * <ul> | |
| * <li> {@code image} is {@code null}. | |
| * <li> the intersected region does not contain at least one pixel. | |
| * <li> the layout of {@code image} does not match, or this | |
| * writer cannot convert it to, the existing image layout. | |
| * </ul> | |
| * @throws IOException if an I/O error occurs during writing. | |
| */ | |
| public void replacePixels(RenderedImage image, ImageWriteParam param) | |
| throws IOException { | |
| unsupported(); | |
| } | |
| /** | |
| * Replaces a portion of an image already present in the output | |
| * with a portion of the given {@code Raster}. The image | |
| * data must match, or be convertible to, the image layout of the | |
| * existing image. | |
| * | |
| * <p> An {@code ImageWriteParam} may optionally be supplied | |
| * to control the writing process. If {@code param} is | |
| * {@code null}, a default write param will be used. | |
| * | |
| * <p> The destination region is specified in the | |
| * {@code param} argument, and will be clipped to the image | |
| * boundaries and the region supplied to | |
| * {@code prepareReplacePixels}. At least one pixel of the | |
| * source must not be clipped, or an exception is thrown. | |
| * | |
| * <p> If the supplied {@code ImageWriteParam} contains | |
| * optional setting values not supported by this writer (<i>e.g.</i> | |
| * progressive encoding or any format-specific settings), they | |
| * will be ignored. | |
| * | |
| * <p> This method may only be called after a call to | |
| * {@code prepareReplacePixels}, or else an | |
| * {@code IllegalStateException} will be thrown. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @param raster a {@code Raster} containing source | |
| * pixels. | |
| * @param param an {@code ImageWriteParam}, or | |
| * {@code null} to use a default | |
| * {@code ImageWriteParam}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canReplacePixels(imageIndex)} returns | |
| * {@code false}. | |
| * @throws IllegalStateException if there is no previous call to | |
| * {@code prepareReplacePixels} without a matching call to | |
| * {@code endReplacePixels}. | |
| * @throws UnsupportedOperationException if | |
| * {@code canWriteRasters} returns {@code false}. | |
| * @throws IllegalArgumentException if any of the following are true: | |
| * <ul> | |
| * <li> {@code raster} is {@code null}. | |
| * <li> the intersected region does not contain at least one pixel. | |
| * <li> the layout of {@code raster} does not match, or this | |
| * writer cannot convert it to, the existing image layout. | |
| * </ul> | |
| * @throws IOException if an I/O error occurs during writing. | |
| */ | |
| public void replacePixels(Raster raster, ImageWriteParam param) | |
| throws IOException { | |
| unsupported(); | |
| } | |
| /** | |
| * Terminates a sequence of calls to {@code replacePixels}. | |
| * | |
| * <p> If {@code canReplacePixels} returns | |
| * {@code false}, and | |
| * {@code UnsupportedOperationException} will be thrown. | |
| * | |
| * <p> The default implementation throws an | |
| * {@code IllegalStateException} if the output is | |
| * {@code null}, and otherwise throws an | |
| * {@code UnsupportedOperationException}. | |
| * | |
| * @throws IllegalStateException if the output has not | |
| * been set. | |
| * @throws UnsupportedOperationException if | |
| * {@code canReplacePixels(imageIndex)} returns | |
| * {@code false}. | |
| * @throws IllegalStateException if there is no previous call | |
| * to {@code prepareReplacePixels} without a matching call to | |
| * {@code endReplacePixels}. | |
| * @throws IOException if an I/O error occurs during writing. | |
| */ | |
| public void endReplacePixels() throws IOException { | |
| unsupported(); | |
| } | |
| // Abort | |
| /** | |
| * Requests that any current write operation be aborted. The | |
| * contents of the output following the abort will be undefined. | |
| * | |
| * <p> Writers should call {@code clearAbortRequest} at the | |
| * beginning of each write operation, and poll the value of | |
| * {@code abortRequested} regularly during the write. | |
| */ | |
| public synchronized void abort() { | |
| this.abortFlag = true; | |
| } | |
| /** | |
| * Returns {@code true} if a request to abort the current | |
| * write operation has been made since the writer was instantiated or | |
| * {@code clearAbortRequest} was called. | |
| * | |
| * @return {@code true} if the current write operation should | |
| * be aborted. | |
| * | |
| * @see #abort | |
| * @see #clearAbortRequest | |
| */ | |
| protected synchronized boolean abortRequested() { | |
| return this.abortFlag; | |
| } | |
| /** | |
| * Clears any previous abort request. After this method has been | |
| * called, {@code abortRequested} will return | |
| * {@code false}. | |
| * | |
| * @see #abort | |
| * @see #abortRequested | |
| */ | |
| protected synchronized void clearAbortRequest() { | |
| this.abortFlag = false; | |
| } | |
| // Listeners | |
| /** | |
| * Adds an {@code IIOWriteWarningListener} to the list of | |
| * registered warning listeners. If {@code listener} is | |
| * {@code null}, no exception will be thrown and no action | |
| * will be taken. Messages sent to the given listener will be | |
| * localized, if possible, to match the current | |
| * {@code Locale}. If no {@code Locale} has been set, | |
| * warning messages may be localized as the writer sees fit. | |
| * | |
| * @param listener an {@code IIOWriteWarningListener} to be | |
| * registered. | |
| * | |
| * @see #removeIIOWriteWarningListener | |
| */ | |
| public void addIIOWriteWarningListener(IIOWriteWarningListener listener) { | |
| if (listener == null) { | |
| return; | |
| } | |
| warningListeners = ImageReader.addToList(warningListeners, listener); | |
| warningLocales = ImageReader.addToList(warningLocales, getLocale()); | |
| } | |
| /** | |
| * Removes an {@code IIOWriteWarningListener} from the list | |
| * of registered warning listeners. If the listener was not | |
| * previously registered, or if {@code listener} is | |
| * {@code null}, no exception will be thrown and no action | |
| * will be taken. | |
| * | |
| * @param listener an {@code IIOWriteWarningListener} to be | |
| * deregistered. | |
| * | |
| * @see #addIIOWriteWarningListener | |
| */ | |
| public | |
| void removeIIOWriteWarningListener(IIOWriteWarningListener listener) { | |
| if (listener == null || warningListeners == null) { | |
| return; | |
| } | |
| int index = warningListeners.indexOf(listener); | |
| if (index != -1) { | |
| warningListeners.remove(index); | |
| warningLocales.remove(index); | |
| if (warningListeners.size() == 0) { | |
| warningListeners = null; | |
| warningLocales = null; | |
| } | |
| } | |
| } | |
| /** | |
| * Removes all currently registered | |
| * {@code IIOWriteWarningListener} objects. | |
| * | |
| * <p> The default implementation sets the | |
| * {@code warningListeners} and {@code warningLocales} | |
| * instance variables to {@code null}. | |
| */ | |
| public void removeAllIIOWriteWarningListeners() { | |
| this.warningListeners = null; | |
| this.warningLocales = null; | |
| } | |
| /** | |
| * Adds an {@code IIOWriteProgressListener} to the list of | |
| * registered progress listeners. If {@code listener} is | |
| * {@code null}, no exception will be thrown and no action | |
| * will be taken. | |
| * | |
| * @param listener an {@code IIOWriteProgressListener} to be | |
| * registered. | |
| * | |
| * @see #removeIIOWriteProgressListener | |
| */ | |
| public void | |
| addIIOWriteProgressListener(IIOWriteProgressListener listener) { | |
| if (listener == null) { | |
| return; | |
| } | |
| progressListeners = ImageReader.addToList(progressListeners, listener); | |
| } | |
| /** | |
| * Removes an {@code IIOWriteProgressListener} from the list | |
| * of registered progress listeners. If the listener was not | |
| * previously registered, or if {@code listener} is | |
| * {@code null}, no exception will be thrown and no action | |
| * will be taken. | |
| * | |
| * @param listener an {@code IIOWriteProgressListener} to be | |
| * deregistered. | |
| * | |
| * @see #addIIOWriteProgressListener | |
| */ | |
| public void | |
| removeIIOWriteProgressListener(IIOWriteProgressListener listener) { | |
| if (listener == null || progressListeners == null) { | |
| return; | |
| } | |
| progressListeners = | |
| ImageReader.removeFromList(progressListeners, listener); | |
| } | |
| /** | |
| * Removes all currently registered | |
| * {@code IIOWriteProgressListener} objects. | |
| * | |
| * <p> The default implementation sets the | |
| * {@code progressListeners} instance variable to | |
| * {@code null}. | |
| */ | |
| public void removeAllIIOWriteProgressListeners() { | |
| this.progressListeners = null; | |
| } | |
| /** | |
| * Broadcasts the start of an image write to all registered | |
| * {@code IIOWriteProgressListener}s by calling their | |
| * {@code imageStarted} method. Subclasses may use this | |
| * method as a convenience. | |
| * | |
| * @param imageIndex the index of the image about to be written. | |
| */ | |
| protected void processImageStarted(int imageIndex) { | |
| if (progressListeners == null) { | |
| return; | |
| } | |
| int numListeners = progressListeners.size(); | |
| for (int i = 0; i < numListeners; i++) { | |
| IIOWriteProgressListener listener = | |
| progressListeners.get(i); | |
| listener.imageStarted(this, imageIndex); | |
| } | |
| } | |
| /** | |
| * Broadcasts the current percentage of image completion to all | |
| * registered {@code IIOWriteProgressListener}s by calling | |
| * their {@code imageProgress} method. Subclasses may use | |
| * this method as a convenience. | |
| * | |
| * @param percentageDone the current percentage of completion, | |
| * as a {@code float}. | |
| */ | |
| protected void processImageProgress(float percentageDone) { | |
| if (progressListeners == null) { | |
| return; | |
| } | |
| int numListeners = progressListeners.size(); | |
| for (int i = 0; i < numListeners; i++) { | |
| IIOWriteProgressListener listener = | |
| progressListeners.get(i); | |
| listener.imageProgress(this, percentageDone); | |
| } | |
| } | |
| /** | |
| * Broadcasts the completion of an image write to all registered | |
| * {@code IIOWriteProgressListener}s by calling their | |
| * {@code imageComplete} method. Subclasses may use this | |
| * method as a convenience. | |
| */ | |
| protected void processImageComplete() { | |
| if (progressListeners == null) { | |
| return; | |
| } | |
| int numListeners = progressListeners.size(); | |
| for (int i = 0; i < numListeners; i++) { | |
| IIOWriteProgressListener listener = | |
| progressListeners.get(i); | |
| listener.imageComplete(this); | |
| } | |
| } | |
| /** | |
| * Broadcasts the start of a thumbnail write to all registered | |
| * {@code IIOWriteProgressListener}s by calling their | |
| * {@code thumbnailStarted} method. Subclasses may use this | |
| * method as a convenience. | |
| * | |
| * @param imageIndex the index of the image associated with the | |
| * thumbnail. | |
| * @param thumbnailIndex the index of the thumbnail. | |
| */ | |
| protected void processThumbnailStarted(int imageIndex, | |
| int thumbnailIndex) { | |
| if (progressListeners == null) { | |
| return; | |
| } | |
| int numListeners = progressListeners.size(); | |
| for (int i = 0; i < numListeners; i++) { | |
| IIOWriteProgressListener listener = | |
| progressListeners.get(i); | |
| listener.thumbnailStarted(this, imageIndex, thumbnailIndex); | |
| } | |
| } | |
| /** | |
| * Broadcasts the current percentage of thumbnail completion to | |
| * all registered {@code IIOWriteProgressListener}s by calling | |
| * their {@code thumbnailProgress} method. Subclasses may | |
| * use this method as a convenience. | |
| * | |
| * @param percentageDone the current percentage of completion, | |
| * as a {@code float}. | |
| */ | |
| protected void processThumbnailProgress(float percentageDone) { | |
| if (progressListeners == null) { | |
| return; | |
| } | |
| int numListeners = progressListeners.size(); | |
| for (int i = 0; i < numListeners; i++) { | |
| IIOWriteProgressListener listener = | |
| progressListeners.get(i); | |
| listener.thumbnailProgress(this, percentageDone); | |
| } | |
| } | |
| /** | |
| * Broadcasts the completion of a thumbnail write to all registered | |
| * {@code IIOWriteProgressListener}s by calling their | |
| * {@code thumbnailComplete} method. Subclasses may use this | |
| * method as a convenience. | |
| */ | |
| protected void processThumbnailComplete() { | |
| if (progressListeners == null) { | |
| return; | |
| } | |
| int numListeners = progressListeners.size(); | |
| for (int i = 0; i < numListeners; i++) { | |
| IIOWriteProgressListener listener = | |
| progressListeners.get(i); | |
| listener.thumbnailComplete(this); | |
| } | |
| } | |
| /** | |
| * Broadcasts that the write has been aborted to all registered | |
| * {@code IIOWriteProgressListener}s by calling their | |
| * {@code writeAborted} method. Subclasses may use this | |
| * method as a convenience. | |
| */ | |
| protected void processWriteAborted() { | |
| if (progressListeners == null) { | |
| return; | |
| } | |
| int numListeners = progressListeners.size(); | |
| for (int i = 0; i < numListeners; i++) { | |
| IIOWriteProgressListener listener = | |
| progressListeners.get(i); | |
| listener.writeAborted(this); | |
| } | |
| } | |
| /** | |
| * Broadcasts a warning message to all registered | |
| * {@code IIOWriteWarningListener}s by calling their | |
| * {@code warningOccurred} method. Subclasses may use this | |
| * method as a convenience. | |
| * | |
| * @param imageIndex the index of the image on which the warning | |
| * occurred. | |
| * @param warning the warning message. | |
| * | |
| * @throws IllegalArgumentException if {@code warning} | |
| * is {@code null}. | |
| */ | |
| protected void processWarningOccurred(int imageIndex, | |
| String warning) { | |
| if (warningListeners == null) { | |
| return; | |
| } | |
| if (warning == null) { | |
| throw new IllegalArgumentException("warning == null!"); | |
| } | |
| int numListeners = warningListeners.size(); | |
| for (int i = 0; i < numListeners; i++) { | |
| IIOWriteWarningListener listener = | |
| warningListeners.get(i); | |
| listener.warningOccurred(this, imageIndex, warning); | |
| } | |
| } | |
| /** | |
| * Broadcasts a localized warning message to all registered | |
| * {@code IIOWriteWarningListener}s by calling their | |
| * {@code warningOccurred} method with a string taken | |
| * from a {@code ResourceBundle}. Subclasses may use this | |
| * method as a convenience. | |
| * | |
| * @param imageIndex the index of the image on which the warning | |
| * occurred. | |
| * @param baseName the base name of a set of | |
| * {@code ResourceBundle}s containing localized warning | |
| * messages. | |
| * @param keyword the keyword used to index the warning message | |
| * within the set of {@code ResourceBundle}s. | |
| * | |
| * @throws IllegalArgumentException if {@code baseName} | |
| * is {@code null}. | |
| * @throws IllegalArgumentException if {@code keyword} | |
| * is {@code null}. | |
| * @throws IllegalArgumentException if no appropriate | |
| * {@code ResourceBundle} may be located. | |
| * @throws IllegalArgumentException if the named resource is | |
| * not found in the located {@code ResourceBundle}. | |
| * @throws IllegalArgumentException if the object retrieved | |
| * from the {@code ResourceBundle} is not a | |
| * {@code String}. | |
| */ | |
| protected void processWarningOccurred(int imageIndex, | |
| String baseName, | |
| String keyword) { | |
| if (warningListeners == null) { | |
| return; | |
| } | |
| if (baseName == null) { | |
| throw new IllegalArgumentException("baseName == null!"); | |
| } | |
| if (keyword == null) { | |
| throw new IllegalArgumentException("keyword == null!"); | |
| } | |
| int numListeners = warningListeners.size(); | |
| for (int i = 0; i < numListeners; i++) { | |
| IIOWriteWarningListener listener = | |
| warningListeners.get(i); | |
| Locale locale = warningLocales.get(i); | |
| if (locale == null) { | |
| locale = Locale.getDefault(); | |
| } | |
| /* | |
| * Only the plugin knows the messages that are provided, so we | |
| * can always locate the resource bundles from the same loader | |
| * as that for the plugin code itself. | |
| */ | |
| ResourceBundle bundle = null; | |
| try { | |
| bundle = ResourceBundle.getBundle(baseName, locale, this.getClass().getModule()); | |
| } catch (MissingResourceException mre) { | |
| throw new IllegalArgumentException("Bundle not found!", mre); | |
| } | |
| String warning = null; | |
| try { | |
| warning = bundle.getString(keyword); | |
| } catch (ClassCastException cce) { | |
| throw new IllegalArgumentException("Resource is not a String!", cce); | |
| } catch (MissingResourceException mre) { | |
| throw new IllegalArgumentException("Resource is missing!", mre); | |
| } | |
| listener.warningOccurred(this, imageIndex, warning); | |
| } | |
| } | |
| // State management | |
| /** | |
| * Restores the {@code ImageWriter} to its initial state. | |
| * | |
| * <p> The default implementation calls | |
| * {@code setOutput(null)}, {@code setLocale(null)}, | |
| * {@code removeAllIIOWriteWarningListeners()}, | |
| * {@code removeAllIIOWriteProgressListeners()}, and | |
| * {@code clearAbortRequest}. | |
| */ | |
| public void reset() { | |
| setOutput(null); | |
| setLocale(null); | |
| removeAllIIOWriteWarningListeners(); | |
| removeAllIIOWriteProgressListeners(); | |
| clearAbortRequest(); | |
| } | |
| /** | |
| * Allows any resources held by this object to be released. The | |
| * result of calling any other method (other than | |
| * {@code finalize}) subsequent to a call to this method | |
| * is undefined. | |
| * | |
| * <p>It is important for applications to call this method when they | |
| * know they will no longer be using this {@code ImageWriter}. | |
| * Otherwise, the writer may continue to hold on to resources | |
| * indefinitely. | |
| * | |
| * <p>The default implementation of this method in the superclass does | |
| * nothing. Subclass implementations should ensure that all resources, | |
| * especially native resources, are released. | |
| */ | |
| public void dispose() { | |
| } | |
| } |