My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/javax/imageio/ImageWriter.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/imageio/ImageWriter.java+2037−0

@@ -0,0 +1,2037 @@
	1	/*
	2	* Copyright (c) 1999, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package javax.imageio;
	27
	28	import java.awt.Dimension;
	29	import java.awt.Rectangle;
	30	import java.awt.image.BufferedImage;
	31	import java.awt.image.RenderedImage;
	32	import java.awt.image.Raster;
	33	import java.io.IOException;
	34	import java.util.ArrayList;
	35	import java.util.List;
	36	import java.util.Locale;
	37	import java.util.MissingResourceException;
	38	import java.util.ResourceBundle;
	39	import javax.imageio.event.IIOWriteWarningListener;
	40	import javax.imageio.event.IIOWriteProgressListener;
	41	import javax.imageio.metadata.IIOMetadata;
	42	import javax.imageio.stream.ImageOutputStream;
	43	import javax.imageio.spi.ImageWriterSpi;
	44
	45	/**
	46	* An abstract superclass for encoding and writing images. This class
	47	* must be subclassed by classes that write out images in the context
	48	* of the Java Image I/O framework.
	49	*
	50	* <p> <code>ImageWriter</code> objects are normally instantiated by
	51	* the service provider class for the specific format. Service
	52	* provider classes are registered with the <code>IIORegistry</code>,
	53	* which uses them for format recognition and presentation of
	54	* available format readers and writers.
	55	*
	56	* <p>
	57	*
	58	* @see ImageReader
	59	* @see ImageWriteParam
	60	* @see javax.imageio.spi.IIORegistry
	61	* @see javax.imageio.spi.ImageWriterSpi
	62	*
	63	*/
	64	public abstract class ImageWriter implements ImageTranscoder {
	65
	66	/**
	67	* The <code>ImageWriterSpi</code> that instantiated this object,
	68	* or <code>null</code> if its identity is not known or none
	69	* exists. By default it is initialized to <code>null</code>.
	70	*/
	71	protected ImageWriterSpi originatingProvider = null;
	72
	73	/**
	74	* The <code>ImageOutputStream</code> or other <code>Object</code>
	75	* set by <code>setOutput</code> and retrieved by
	76	* <code>getOutput</code>. By default it is initialized to
	77	* <code>null</code>.
	78	*/
	79	protected Object output = null;
	80
	81	/**
	82	* An array of <code>Locale</code>s that may be used to localize
	83	* warning messages and compression setting values, or
	84	* <code>null</code> if localization is not supported. By default
	85	* it is initialized to <code>null</code>.
	86	*/
	87	protected Locale[] availableLocales = null;
	88
	89	/**
	90	* The current <code>Locale</code> to be used for localization, or
	91	* <code>null</code> if none has been set. By default it is
	92	* initialized to <code>null</code>.
	93	*/
	94	protected Locale locale = null;
	95
	96	/**
	97	* A <code>List</code> of currently registered
	98	* <code>IIOWriteWarningListener</code>s, initialized by default to
	99	* <code>null</code>, which is synonymous with an empty
	100	* <code>List</code>.
	101	*/
	102	protected List<IIOWriteWarningListener> warningListeners = null;
	103
	104	/**
	105	* A <code>List</code> of <code>Locale</code>s, one for each
	106	* element of <code>warningListeners</code>, initialized by default
	107	* <code>null</code>, which is synonymous with an empty
	108	* <code>List</code>.
	109	*/
	110	protected List<Locale> warningLocales = null;
	111
	112	/**
	113	* A <code>List</code> of currently registered
	114	* <code>IIOWriteProgressListener</code>s, initialized by default
	115	* <code>null</code>, which is synonymous with an empty
	116	* <code>List</code>.
	117	*/
	118	protected List<IIOWriteProgressListener> progressListeners = null;
	119
	120	/**
	121	* If <code>true</code>, the current write operation should be
	122	* aborted.
	123	*/
	124	private boolean abortFlag = false;
	125
	126	/**
	127	* Constructs an <code>ImageWriter</code> and sets its
	128	* <code>originatingProvider</code> instance variable to the
	129	* supplied value.
	130	*
	131	* <p> Subclasses that make use of extensions should provide a
	132	* constructor with signature <code>(ImageWriterSpi,
	133	* Object)</code> in order to retrieve the extension object. If
	134	* the extension object is unsuitable, an
	135	* <code>IllegalArgumentException</code> should be thrown.
	136	*
	137	* @param originatingProvider the <code>ImageWriterSpi</code> that
	138	* is constructing this object, or <code>null</code>.
	139	*/
	140	protected ImageWriter(ImageWriterSpi originatingProvider) {
	141	this.originatingProvider = originatingProvider;
	142	}
	143
	144	/**
	145	* Returns the <code>ImageWriterSpi</code> object that created
	146	* this <code>ImageWriter</code>, or <code>null</code> if this
	147	* object was not created through the <code>IIORegistry</code>.
	148	*
	149	* <p> The default implementation returns the value of the
	150	* <code>originatingProvider</code> instance variable.
	151	*
	152	* @return an <code>ImageWriterSpi</code>, or <code>null</code>.
	153	*
	154	* @see ImageWriterSpi
	155	*/
	156	public ImageWriterSpi getOriginatingProvider() {
	157	return originatingProvider;
	158	}
	159
	160	/**
	161	* Sets the destination to the given
	162	* <code>ImageOutputStream</code> or other <code>Object</code>.
	163	* The destination is assumed to be ready to accept data, and will
	164	* not be closed at the end of each write. This allows distributed
	165	* imaging applications to transmit a series of images over a
	166	* single network connection. If <code>output</code> is
	167	* <code>null</code>, any currently set output will be removed.
	168	*
	169	* <p> If <code>output</code> is an
	170	* <code>ImageOutputStream</code>, calls to the
	171	* <code>write</code>, <code>writeToSequence</code>, and
	172	* <code>prepareWriteEmpty</code>/<code>endWriteEmpty</code>
	173	* methods will preserve the existing contents of the stream.
	174	* Other write methods, such as <code>writeInsert</code>,
	175	* <code>replaceStreamMetadata</code>,
	176	* <code>replaceImageMetadata</code>, <code>replacePixels</code>,
	177	* <code>prepareInsertEmpty</code>/<code>endInsertEmpty</code>,
	178	* and <code>endWriteSequence</code>, require the full contents
	179	* of the stream to be readable and writable, and may alter any
	180	* portion of the stream.
	181	*
	182	* <p> Use of a general <code>Object</code> other than an
	183	* <code>ImageOutputStream</code> is intended for writers that
	184	* interact directly with an output device or imaging protocol.
	185	* The set of legal classes is advertised by the writer's service
	186	* provider's <code>getOutputTypes</code> method; most writers
	187	* will return a single-element array containing only
	188	* <code>ImageOutputStream.class</code> to indicate that they
	189	* accept only an <code>ImageOutputStream</code>.
	190	*
	191	* <p> The default implementation sets the <code>output</code>
	192	* instance variable to the value of <code>output</code> after
	193	* checking <code>output</code> against the set of classes
	194	* advertised by the originating provider, if there is one.
	195	*
	196	* @param output the <code>ImageOutputStream</code> or other
	197	* <code>Object</code> to use for future writing.
	198	*
	199	* @exception IllegalArgumentException if <code>output</code> is
	200	* not an instance of one of the classes returned by the
	201	* originating service provider's <code>getOutputTypes</code>
	202	* method.
	203	*
	204	* @see #getOutput
	205	*/
	206	public void setOutput(Object output) {
	207	if (output != null) {
	208	ImageWriterSpi provider = getOriginatingProvider();
	209	if (provider != null) {
	210	Class[] classes = provider.getOutputTypes();
	211	boolean found = false;
	212	for (int i = 0; i < classes.length; i++) {
	213	if (classes[i].isInstance(output)) {
	214	found = true;
	215	break;
	216	}
	217	}
	218	if (!found) {
	219	throw new IllegalArgumentException("Illegal output type!");
	220	}
	221	}
	222	}
	223
	224	this.output = output;
	225	}
	226
	227	/**
	228	* Returns the <code>ImageOutputStream</code> or other
	229	* <code>Object</code> set by the most recent call to the
	230	* <code>setOutput</code> method. If no destination has been
	231	* set, <code>null</code> is returned.
	232	*
	233	* <p> The default implementation returns the value of the
	234	* <code>output</code> instance variable.
	235	*
	236	* @return the <code>Object</code> that was specified using
	237	* <code>setOutput</code>, or <code>null</code>.
	238	*
	239	* @see #setOutput
	240	*/
	241	public Object getOutput() {
	242	return output;
	243	}
	244
	245	// Localization
	246
	247	/**
	248	* Returns an array of <code>Locale</code>s that may be used to
	249	* localize warning listeners and compression settings. A return
	250	* value of <code>null</code> indicates that localization is not
	251	* supported.
	252	*
	253	* <p> The default implementation returns a clone of the
	254	* <code>availableLocales</code> instance variable if it is
	255	* non-<code>null</code>, or else returns <code>null</code>.
	256	*
	257	* @return an array of <code>Locale</code>s that may be used as
	258	* arguments to <code>setLocale</code>, or <code>null</code>.
	259	*/
	260	public Locale[] getAvailableLocales() {
	261	return (availableLocales == null) ?
	262	null : (Locale[])availableLocales.clone();
	263	}
	264
	265	/**
	266	* Sets the current <code>Locale</code> of this
	267	* <code>ImageWriter</code> to the given value. A value of
	268	* <code>null</code> removes any previous setting, and indicates
	269	* that the writer should localize as it sees fit.
	270	*
	271	* <p> The default implementation checks <code>locale</code>
	272	* against the values returned by
	273	* <code>getAvailableLocales</code>, and sets the
	274	* <code>locale</code> instance variable if it is found. If
	275	* <code>locale</code> is <code>null</code>, the instance variable
	276	* is set to <code>null</code> without any checking.
	277	*
	278	* @param locale the desired <code>Locale</code>, or
	279	* <code>null</code>.
	280	*
	281	* @exception IllegalArgumentException if <code>locale</code> is
	282	* non-<code>null</code> but is not one of the values returned by
	283	* <code>getAvailableLocales</code>.
	284	*
	285	* @see #getLocale
	286	*/
	287	public void setLocale(Locale locale) {
	288	if (locale != null) {
	289	Locale[] locales = getAvailableLocales();
	290	boolean found = false;
	291	if (locales != null) {
	292	for (int i = 0; i < locales.length; i++) {
	293	if (locale.equals(locales[i])) {
	294	found = true;
	295	break;
	296	}
	297	}
	298	}
	299	if (!found) {
	300	throw new IllegalArgumentException("Invalid locale!");
	301	}
	302	}
	303	this.locale = locale;
	304	}
	305
	306	/**
	307	* Returns the currently set <code>Locale</code>, or
	308	* <code>null</code> if none has been set.
	309	*
	310	* <p> The default implementation returns the value of the
	311	* <code>locale</code> instance variable.
	312	*
	313	* @return the current <code>Locale</code>, or <code>null</code>.
	314	*
	315	* @see #setLocale
	316	*/
	317	public Locale getLocale() {
	318	return locale;
	319	}
	320
	321	// Write params
	322
	323	/**
	324	* Returns a new <code>ImageWriteParam</code> object of the
	325	* appropriate type for this file format containing default
	326	* values, that is, those values that would be used
	327	* if no <code>ImageWriteParam</code> object were specified. This
	328	* is useful as a starting point for tweaking just a few parameters
	329	* and otherwise leaving the default settings alone.
	330	*
	331	* <p> The default implementation constructs and returns a new
	332	* <code>ImageWriteParam</code> object that does not allow tiling,
	333	* progressive encoding, or compression, and that will be
	334	* localized for the current <code>Locale</code> (<i>i.e.</i>,
	335	* what you would get by calling <code>new
	336	* ImageWriteParam(getLocale())</code>.
	337	*
	338	* <p> Individual plug-ins may return an instance of
	339	* <code>ImageWriteParam</code> with additional optional features
	340	* enabled, or they may return an instance of a plug-in specific
	341	* subclass of <code>ImageWriteParam</code>.
	342	*
	343	* @return a new <code>ImageWriteParam</code> object containing
	344	* default values.
	345	*/
	346	public ImageWriteParam getDefaultWriteParam() {
	347	return new ImageWriteParam(getLocale());
	348	}
	349
	350	// Metadata
	351
	352	/**
	353	* Returns an <code>IIOMetadata</code> object containing default
	354	* values for encoding a stream of images. The contents of the
	355	* object may be manipulated using either the XML tree structure
	356	* returned by the <code>IIOMetadata.getAsTree</code> method, an
	357	* <code>IIOMetadataController</code> object, or via plug-in
	358	* specific interfaces, and the resulting data supplied to one of
	359	* the <code>write</code> methods that take a stream metadata
	360	* parameter.
	361	*
	362	* <p> An optional <code>ImageWriteParam</code> may be supplied
	363	* for cases where it may affect the structure of the stream
	364	* metadata.
	365	*
	366	* <p> If the supplied <code>ImageWriteParam</code> contains
	367	* optional setting values not supported by this writer (<i>e.g.</i>
	368	* progressive encoding or any format-specific settings), they
	369	* will be ignored.
	370	*
	371	* <p> Writers that do not make use of stream metadata
	372	* (<i>e.g.</i>, writers for single-image formats) should return
	373	* <code>null</code>.
	374	*
	375	* @param param an <code>ImageWriteParam</code> that will be used to
	376	* encode the image, or <code>null</code>.
	377	*
	378	* @return an <code>IIOMetadata</code> object.
	379	*/
	380	public abstract IIOMetadata
	381	getDefaultStreamMetadata(ImageWriteParam param);
	382
	383	/**
	384	* Returns an <code>IIOMetadata</code> object containing default
	385	* values for encoding an image of the given type. The contents
	386	* of the object may be manipulated using either the XML tree
	387	* structure returned by the <code>IIOMetadata.getAsTree</code>
	388	* method, an <code>IIOMetadataController</code> object, or via
	389	* plug-in specific interfaces, and the resulting data supplied to
	390	* one of the <code>write</code> methods that take a stream
	391	* metadata parameter.
	392	*
	393	* <p> An optional <code>ImageWriteParam</code> may be supplied
	394	* for cases where it may affect the structure of the image
	395	* metadata.
	396	*
	397	* <p> If the supplied <code>ImageWriteParam</code> contains
	398	* optional setting values not supported by this writer (<i>e.g.</i>
	399	* progressive encoding or any format-specific settings), they
	400	* will be ignored.
	401	*
	402	* @param imageType an <code>ImageTypeSpecifier</code> indicating the
	403	* format of the image to be written later.
	404	* @param param an <code>ImageWriteParam</code> that will be used to
	405	* encode the image, or <code>null</code>.
	406	*
	407	* @return an <code>IIOMetadata</code> object.
	408	*/
	409	public abstract IIOMetadata
	410	getDefaultImageMetadata(ImageTypeSpecifier imageType,
	411	ImageWriteParam param);
	412
	413	// comment inherited
	414	public abstract IIOMetadata convertStreamMetadata(IIOMetadata inData,
	415	ImageWriteParam param);
	416
	417	// comment inherited
	418	public abstract IIOMetadata
	419	convertImageMetadata(IIOMetadata inData,
	420	ImageTypeSpecifier imageType,
	421	ImageWriteParam param);
	422
	423	// Thumbnails
	424
	425	/**
	426	* Returns the number of thumbnails suported by the format being
	427	* written, given the image type and any additional write
	428	* parameters and metadata objects that will be used during
	429	* encoding. A return value of <code>-1</code> indicates that
	430	* insufficient information is available.
	431	*
	432	* <p> An <code>ImageWriteParam</code> may optionally be supplied
	433	* for cases where it may affect thumbnail handling.
	434	*
	435	* <p> If the supplied <code>ImageWriteParam</code> contains
	436	* optional setting values not supported by this writer (<i>e.g.</i>
	437	* progressive encoding or any format-specific settings), they
	438	* will be ignored.
	439	*
	440	* <p> The default implementation returns 0.
	441	*
	442	* @param imageType an <code>ImageTypeSpecifier</code> indicating
	443	* the type of image to be written, or <code>null</code>.
	444	* @param param the <code>ImageWriteParam</code> that will be used for
	445	* writing, or <code>null</code>.
	446	* @param streamMetadata an <code>IIOMetadata</code> object that will
	447	* be used for writing, or <code>null</code>.
	448	* @param imageMetadata an <code>IIOMetadata</code> object that will
	449	* be used for writing, or <code>null</code>.
	450	*
	451	* @return the number of thumbnails that may be written given the
	452	* supplied parameters, or <code>-1</code> if insufficient
	453	* information is available.
	454	*/
	455	public int getNumThumbnailsSupported(ImageTypeSpecifier imageType,
	456	ImageWriteParam param,
	457	IIOMetadata streamMetadata,
	458	IIOMetadata imageMetadata) {
	459	return 0;
	460	}
	461
	462	/**
	463	* Returns an array of <code>Dimension</code>s indicating the
	464	* legal size ranges for thumbnail images as they will be encoded
	465	* in the output file or stream. This information is merely
	466	* advisory; the writer will resize any supplied thumbnails as
	467	* necessary.
	468	*
	469	* <p> The information is returned as a set of pairs; the first
	470	* element of a pair contains an (inclusive) minimum width and
	471	* height, and the second element contains an (inclusive) maximum
	472	* width and height. Together, each pair defines a valid range of
	473	* sizes. To specify a fixed size, the same width and height will
	474	* appear for both elements. A return value of <code>null</code>
	475	* indicates that the size is arbitrary or unknown.
	476	*
	477	* <p> An <code>ImageWriteParam</code> may optionally be supplied
	478	* for cases where it may affect thumbnail handling.
	479	*
	480	* <p> If the supplied <code>ImageWriteParam</code> contains
	481	* optional setting values not supported by this writer (<i>e.g.</i>
	482	* progressive encoding or any format-specific settings), they
	483	* will be ignored.
	484	*
	485	* <p> The default implementation returns <code>null</code>.
	486	*
	487	* @param imageType an <code>ImageTypeSpecifier</code> indicating the
	488	* type of image to be written, or <code>null</code>.
	489	* @param param the <code>ImageWriteParam</code> that will be used for
	490	* writing, or <code>null</code>.
	491	* @param streamMetadata an <code>IIOMetadata</code> object that will
	492	* be used for writing, or <code>null</code>.
	493	* @param imageMetadata an <code>IIOMetadata</code> object that will
	494	* be used for writing, or <code>null</code>.
	495	*
	496	* @return an array of <code>Dimension</code>s with an even length
	497	* of at least two, or <code>null</code>.
	498	*/
	499	public Dimension[] getPreferredThumbnailSizes(ImageTypeSpecifier imageType,
	500	ImageWriteParam param,
	501	IIOMetadata streamMetadata,
	502	IIOMetadata imageMetadata) {
	503	return null;
	504	}
	505
	506	/**
	507	* Returns <code>true</code> if the methods that take an
	508	* <code>IIOImage</code> parameter are capable of dealing with a
	509	* <code>Raster</code> (as opposed to <code>RenderedImage</code>)
	510	* source image. If this method returns <code>false</code>, then
	511	* those methods will throw an
	512	* <code>UnsupportedOperationException</code> if supplied with an
	513	* <code>IIOImage</code> containing a <code>Raster</code>.
	514	*
	515	* <p> The default implementation returns <code>false</code>.
	516	*
	517	* @return <code>true</code> if <code>Raster</code> sources are
	518	* supported.
	519	*/
	520	public boolean canWriteRasters() {
	521	return false;
	522	}
	523
	524	/**
	525	* Appends a complete image stream containing a single image and
	526	* associated stream and image metadata and thumbnails to the
	527	* output. Any necessary header information is included. If the
	528	* output is an <code>ImageOutputStream</code>, its existing
	529	* contents prior to the current seek position are not affected,
	530	* and need not be readable or writable.
	531	*
	532	* <p> The output must have been set beforehand using the
	533	* <code>setOutput</code> method.
	534	*
	535	* <p> Stream metadata may optionally be supplied; if it is
	536	* <code>null</code>, default stream metadata will be used.
	537	*
	538	* <p> If <code>canWriteRasters</code> returns <code>true</code>,
	539	* the <code>IIOImage</code> may contain a <code>Raster</code>
	540	* source. Otherwise, it must contain a
	541	* <code>RenderedImage</code> source.
	542	*
	543	* <p> The supplied thumbnails will be resized if needed, and any
	544	* thumbnails in excess of the supported number will be ignored.
	545	* If the format requires additional thumbnails that are not
	546	* provided, the writer should generate them internally.
	547	*
	548	* <p> An <code>ImageWriteParam</code> may
	549	* optionally be supplied to control the writing process. If
	550	* <code>param</code> is <code>null</code>, a default write param
	551	* will be used.
	552	*
	553	* <p> If the supplied <code>ImageWriteParam</code> contains
	554	* optional setting values not supported by this writer (<i>e.g.</i>
	555	* progressive encoding or any format-specific settings), they
	556	* will be ignored.
	557	*
	558	* @param streamMetadata an <code>IIOMetadata</code> object representing
	559	* stream metadata, or <code>null</code> to use default values.
	560	* @param image an <code>IIOImage</code> object containing an
	561	* image, thumbnails, and metadata to be written.
	562	* @param param an <code>ImageWriteParam</code>, or
	563	* <code>null</code> to use a default
	564	* <code>ImageWriteParam</code>.
	565	*
	566	* @exception IllegalStateException if the output has not
	567	* been set.
	568	* @exception UnsupportedOperationException if <code>image</code>
	569	* contains a <code>Raster</code> and <code>canWriteRasters</code>
	570	* returns <code>false</code>.
	571	* @exception IllegalArgumentException if <code>image</code> is
	572	* <code>null</code>.
	573	* @exception IOException if an error occurs during writing.
	574	*/
	575	public abstract void write(IIOMetadata streamMetadata,
	576	IIOImage image,
	577	ImageWriteParam param) throws IOException;
	578
	579	/**
	580	* Appends a complete image stream containing a single image with
	581	* default metadata and thumbnails to the output. This method is
	582	* a shorthand for <code>write(null, image, null)</code>.
	583	*
	584	* @param image an <code>IIOImage</code> object containing an
	585	* image, thumbnails, and metadata to be written.
	586	*
	587	* @exception IllegalStateException if the output has not
	588	* been set.
	589	* @exception IllegalArgumentException if <code>image</code> is
	590	* <code>null</code>.
	591	* @exception UnsupportedOperationException if <code>image</code>
	592	* contains a <code>Raster</code> and <code>canWriteRasters</code>
	593	* returns <code>false</code>.
	594	* @exception IOException if an error occurs during writing.
	595	*/
	596	public void write(IIOImage image) throws IOException {
	597	write(null, image, null);
	598	}
	599
	600	/**
	601	* Appends a complete image stream consisting of a single image
	602	* with default metadata and thumbnails to the output. This
	603	* method is a shorthand for <code>write(null, new IIOImage(image,
	604	* null, null), null)</code>.
	605	*
	606	* @param image a <code>RenderedImage</code> to be written.
	607	*
	608	* @exception IllegalStateException if the output has not
	609	* been set.
	610	* @exception IllegalArgumentException if <code>image</code> is
	611	* <code>null</code>.
	612	* @exception IOException if an error occurs during writing.
	613	*/
	614	public void write(RenderedImage image) throws IOException {
	615	write(null, new IIOImage(image, null, null), null);
	616	}
	617
	618	// Check that the output has been set, then throw an
	619	// UnsupportedOperationException.
	620	private void unsupported() {
	621	if (getOutput() == null) {
	622	throw new IllegalStateException("getOutput() == null!");
	623	}
	624	throw new UnsupportedOperationException("Unsupported write variant!");
	625	}
	626
	627	// Sequence writes
	628
	629	/**
	630	* Returns <code>true</code> if the writer is able to append an
	631	* image to an image stream that already contains header
	632	* information and possibly prior images.
	633	*
	634	* <p> If <code>canWriteSequence</code> returns <code>false</code>,
	635	* <code>writeToSequence</code> and <code>endWriteSequence</code>
	636	* will throw an <code>UnsupportedOperationException</code>.
	637	*
	638	* <p> The default implementation returns <code>false</code>.
	639	*
	640	* @return <code>true</code> if images may be appended sequentially.
	641	*/
	642	public boolean canWriteSequence() {
	643	return false;
	644	}
	645
	646	/**
	647	* Prepares a stream to accept a series of subsequent
	648	* <code>writeToSequence</code> calls, using the provided stream
	649	* metadata object. The metadata will be written to the stream if
	650	* it should precede the image data. If the argument is <code>null</code>,
	651	* default stream metadata is used.
	652	*
	653	* <p> If the output is an <code>ImageOutputStream</code>, the existing
	654	* contents of the output prior to the current seek position are
	655	* flushed, and need not be readable or writable. If the format
	656	* requires that <code>endWriteSequence</code> be able to rewind to
	657	* patch up the header information, such as for a sequence of images
	658	* in a single TIFF file, then the metadata written by this method
	659	* must remain in a writable portion of the stream. Other formats
	660	* may flush the stream after this method and after each image.
	661	*
	662	* <p> If <code>canWriteSequence</code> returns <code>false</code>,
	663	* this method will throw an
	664	* <code>UnsupportedOperationException</code>.
	665	*
	666	* <p> The output must have been set beforehand using either
	667	* the <code>setOutput</code> method.
	668	*
	669	* <p> The default implementation throws an
	670	* <code>IllegalStateException</code> if the output is
	671	* <code>null</code>, and otherwise throws an
	672	* <code>UnsupportedOperationException</code>.
	673	*
	674	* @param streamMetadata A stream metadata object, or <code>null</code>.
	675	*
	676	* @exception IllegalStateException if the output has not
	677	* been set.
	678	* @exception UnsupportedOperationException if
	679	* <code>canWriteSequence</code> returns <code>false</code>.
	680	* @exception IOException if an error occurs writing the stream
	681	* metadata.
	682	*/
	683	public void prepareWriteSequence(IIOMetadata streamMetadata)
	684	throws IOException {
	685	unsupported();
	686	}
	687
	688	/**
	689	* Appends a single image and possibly associated metadata and
	690	* thumbnails, to the output. If the output is an
	691	* <code>ImageOutputStream</code>, the existing contents of the
	692	* output prior to the current seek position may be flushed, and
	693	* need not be readable or writable, unless the plug-in needs to
	694	* be able to patch up the header information when
	695	* <code>endWriteSequence</code> is called (<italic>e.g.</italic> TIFF).
	696	*
	697	* <p> If <code>canWriteSequence</code> returns <code>false</code>,
	698	* this method will throw an
	699	* <code>UnsupportedOperationException</code>.
	700	*
	701	* <p> The output must have been set beforehand using
	702	* the <code>setOutput</code> method.
	703	*
	704	* <p> <code>prepareWriteSequence</code> must have been called
	705	* beforehand, or an <code>IllegalStateException</code> is thrown.
	706	*
	707	* <p> If <code>canWriteRasters</code> returns <code>true</code>,
	708	* the <code>IIOImage</code> may contain a <code>Raster</code>
	709	* source. Otherwise, it must contain a
	710	* <code>RenderedImage</code> source.
	711	*
	712	* <p> The supplied thumbnails will be resized if needed, and any
	713	* thumbnails in excess of the supported number will be ignored.
	714	* If the format requires additional thumbnails that are not
	715	* provided, the writer will generate them internally.
	716	*
	717	* <p> An <code>ImageWriteParam</code> may optionally be supplied
	718	* to control the writing process. If <code>param</code> is
	719	* <code>null</code>, a default write param will be used.
	720	*
	721	* <p> If the supplied <code>ImageWriteParam</code> contains
	722	* optional setting values not supported by this writer (<i>e.g.</i>
	723	* progressive encoding or any format-specific settings), they
	724	* will be ignored.
	725	*
	726	* <p> The default implementation throws an
	727	* <code>IllegalStateException</code> if the output is
	728	* <code>null</code>, and otherwise throws an
	729	* <code>UnsupportedOperationException</code>.
	730	*
	731	* @param image an <code>IIOImage</code> object containing an
	732	* image, thumbnails, and metadata to be written.
	733	* @param param an <code>ImageWriteParam</code>, or
	734	* <code>null</code> to use a default
	735	* <code>ImageWriteParam</code>.
	736	*
	737	* @exception IllegalStateException if the output has not
	738	* been set, or <code>prepareWriteSequence</code> has not been called.
	739	* @exception UnsupportedOperationException if
	740	* <code>canWriteSequence</code> returns <code>false</code>.
	741	* @exception IllegalArgumentException if <code>image</code> is
	742	* <code>null</code>.
	743	* @exception UnsupportedOperationException if <code>image</code>
	744	* contains a <code>Raster</code> and <code>canWriteRasters</code>
	745	* returns <code>false</code>.
	746	* @exception IOException if an error occurs during writing.
	747	*/
	748	public void writeToSequence(IIOImage image, ImageWriteParam param)
	749	throws IOException {
	750	unsupported();
	751	}
	752
	753	/**
	754	* Completes the writing of a sequence of images begun with
	755	* <code>prepareWriteSequence</code>. Any stream metadata that
	756	* should come at the end of the sequence of images is written out,
	757	* and any header information at the beginning of the sequence is
	758	* patched up if necessary. If the output is an
	759	* <code>ImageOutputStream</code>, data through the stream metadata
	760	* at the end of the sequence are flushed and need not be readable
	761	* or writable.
	762	*
	763	* <p> If <code>canWriteSequence</code> returns <code>false</code>,
	764	* this method will throw an
	765	* <code>UnsupportedOperationException</code>.
	766	*
	767	* <p> The default implementation throws an
	768	* <code>IllegalStateException</code> if the output is
	769	* <code>null</code>, and otherwise throws an
	770	* <code>UnsupportedOperationException</code>.
	771	*
	772	* @exception IllegalStateException if the output has not
	773	* been set, or <code>prepareWriteSequence</code> has not been called.
	774	* @exception UnsupportedOperationException if
	775	* <code>canWriteSequence</code> returns <code>false</code>.
	776	* @exception IOException if an error occurs during writing.
	777	*/
	778	public void endWriteSequence() throws IOException {
	779	unsupported();
	780	}
	781
	782	// Metadata replacement
	783
	784	/**
	785	* Returns <code>true</code> if it is possible to replace the
	786	* stream metadata already present in the output.
	787	*
	788	* <p> The default implementation throws an
	789	* <code>IllegalStateException</code> if the output is
	790	* <code>null</code>, and otherwise returns <code>false</code>.
	791	*
	792	* @return <code>true</code> if replacement of stream metadata is
	793	* allowed.
	794	*
	795	* @exception IllegalStateException if the output has not
	796	* been set.
	797	* @exception IOException if an I/O error occurs during the query.
	798	*/
	799	public boolean canReplaceStreamMetadata() throws IOException {
	800	if (getOutput() == null) {
	801	throw new IllegalStateException("getOutput() == null!");
	802	}
	803	return false;
	804	}
	805
	806	/**
	807	* Replaces the stream metadata in the output with new
	808	* information. If the output is an
	809	* <code>ImageOutputStream</code>, the prior contents of the
	810	* stream are examined and possibly edited to make room for the
	811	* new data. All of the prior contents of the output must be
	812	* available for reading and writing.
	813	*
	814	* <p> If <code>canReplaceStreamMetadata</code> returns
	815	* <code>false</code>, an
	816	* <code>UnsupportedOperationException</code> will be thrown.
	817	*
	818	* <p> The default implementation throws an
	819	* <code>IllegalStateException</code> if the output is
	820	* <code>null</code>, and otherwise throws an
	821	* <code>UnsupportedOperationException</code>.
	822	*
	823	* @param streamMetadata an <code>IIOMetadata</code> object representing
	824	* stream metadata, or <code>null</code> to use default values.
	825	*
	826	* @exception IllegalStateException if the output has not
	827	* been set.
	828	* @exception UnsupportedOperationException if the
	829	* <code>canReplaceStreamMetadata</code> returns
	830	* <code>false</code>. modes do not include
	831	* @exception IOException if an error occurs during writing.
	832	*/
	833	public void replaceStreamMetadata(IIOMetadata streamMetadata)
	834	throws IOException {
	835	unsupported();
	836	}
	837
	838	/**
	839	* Returns <code>true</code> if it is possible to replace the
	840	* image metadata associated with an existing image with index
	841	* <code>imageIndex</code>. If this method returns
	842	* <code>false</code>, a call to
	843	* <code>replaceImageMetadata(imageIndex)</code> will throw an
	844	* <code>UnsupportedOperationException</code>.
	845	*
	846	* <p> A writer that does not support any image metadata
	847	* replacement may return <code>false</code> without performing
	848	* bounds checking on the index.
	849	*
	850	* <p> The default implementation throws an
	851	* <code>IllegalStateException</code> if the output is
	852	* <code>null</code>, and otherwise returns <code>false</code>
	853	* without checking the value of <code>imageIndex</code>.
	854	*
	855	* @param imageIndex the index of the image whose metadata is to
	856	* be replaced.
	857	*
	858	* @return <code>true</code> if the image metadata of the given
	859	* image can be replaced.
	860	*
	861	* @exception IllegalStateException if the output has not
	862	* been set.
	863	* @exception IndexOutOfBoundsException if the writer supports
	864	* image metadata replacement in general, but
	865	* <code>imageIndex</code> is less than 0 or greater than the
	866	* largest available index.
	867	* @exception IOException if an I/O error occurs during the query.
	868	*/
	869	public boolean canReplaceImageMetadata(int imageIndex)
	870	throws IOException {
	871	if (getOutput() == null) {
	872	throw new IllegalStateException("getOutput() == null!");
	873	}
	874	return false;
	875	}
	876
	877	/**
	878	* Replaces the image metadata associated with an existing image.
	879	*
	880	* <p> If <code>canReplaceImageMetadata(imageIndex)</code> returns
	881	* <code>false</code>, an
	882	* <code>UnsupportedOperationException</code> will be thrown.
	883	*
	884	* <p> The default implementation throws an
	885	* <code>IllegalStateException</code> if the output is
	886	* <code>null</code>, and otherwise throws an
	887	* <code>UnsupportedOperationException</code>.
	888	*
	889	* @param imageIndex the index of the image whose metadata is to
	890	* be replaced.
	891	* @param imageMetadata an <code>IIOMetadata</code> object
	892	* representing image metadata, or <code>null</code>.
	893	*
	894	* @exception IllegalStateException if the output has not been
	895	* set.
	896	* @exception UnsupportedOperationException if
	897	* <code>canReplaceImageMetadata</code> returns
	898	* <code>false</code>.
	899	* @exception IndexOutOfBoundsException if <code>imageIndex</code>
	900	* is less than 0 or greater than the largest available index.
	901	* @exception IOException if an error occurs during writing.
	902	*/
	903	public void replaceImageMetadata(int imageIndex,
	904	IIOMetadata imageMetadata)
	905	throws IOException {
	906	unsupported();
	907	}
	908
	909	// Image insertion
	910
	911	/**
	912	* Returns <code>true</code> if the writer supports the insertion
	913	* of a new image at the given index. Existing images with
	914	* indices greater than or equal to the insertion index will have
	915	* their indices increased by 1. A value for
	916	* <code>imageIndex</code> of <code>-1</code> may be used to
	917	* signify an index one larger than the current largest index.
	918	*
	919	* <p> A writer that does not support any image insertion may
	920	* return <code>false</code> without performing bounds checking on
	921	* the index.
	922	*
	923	* <p> The default implementation throws an
	924	* <code>IllegalStateException</code> if the output is
	925	* <code>null</code>, and otherwise returns <code>false</code>
	926	* withour checking the value of <code>imageIndex</code>.
	927	*
	928	* @param imageIndex the index at which the image is to be
	929	* inserted.
	930	*
	931	* @return <code>true</code> if an image may be inserted at the
	932	* given index.
	933	*
	934	* @exception IllegalStateException if the output has not
	935	* been set.
	936	* @exception IndexOutOfBoundsException if the writer supports
	937	* image insertion in general, but <code>imageIndex</code> is less
	938	* than -1 or greater than the largest available index.
	939	* @exception IOException if an I/O error occurs during the query.
	940	*/
	941	public boolean canInsertImage(int imageIndex) throws IOException {
	942	if (getOutput() == null) {
	943	throw new IllegalStateException("getOutput() == null!");
	944	}
	945	return false;
	946	}
	947
	948	/**
	949	* Inserts a new image into an existing image stream. Existing
	950	* images with an index greater than <code>imageIndex</code> are
	951	* preserved, and their indices are each increased by 1. A value
	952	* for <code>imageIndex</code> of -1 may be used to signify an
	953	* index one larger than the previous largest index; that is, it
	954	* will cause the image to be logically appended to the end of the
	955	* sequence. If the output is an <code>ImageOutputStream</code>,
	956	* the entirety of the stream must be both readable and writeable.
	957	*
	958	* <p> If <code>canInsertImage(imageIndex)</code> returns
	959	* <code>false</code>, an
	960	* <code>UnsupportedOperationException</code> will be thrown.
	961	*
	962	* <p> An <code>ImageWriteParam</code> may optionally be supplied
	963	* to control the writing process. If <code>param</code> is
	964	* <code>null</code>, a default write param will be used.
	965	*
	966	* <p> If the supplied <code>ImageWriteParam</code> contains
	967	* optional setting values not supported by this writer (<i>e.g.</i>
	968	* progressive encoding or any format-specific settings), they
	969	* will be ignored.
	970	*
	971	* <p> The default implementation throws an
	972	* <code>IllegalStateException</code> if the output is
	973	* <code>null</code>, and otherwise throws an
	974	* <code>UnsupportedOperationException</code>.
	975	*
	976	* @param imageIndex the index at which to write the image.
	977	* @param image an <code>IIOImage</code> object containing an
	978	* image, thumbnails, and metadata to be written.
	979	* @param param an <code>ImageWriteParam</code>, or
	980	* <code>null</code> to use a default
	981	* <code>ImageWriteParam</code>.
	982	*
	983	* @exception IllegalStateException if the output has not
	984	* been set.
	985	* @exception UnsupportedOperationException if
	986	* <code>canInsertImage(imageIndex)</code> returns <code>false</code>.
	987	* @exception IllegalArgumentException if <code>image</code> is
	988	* <code>null</code>.
	989	* @exception IndexOutOfBoundsException if <code>imageIndex</code>
	990	* is less than -1 or greater than the largest available index.
	991	* @exception UnsupportedOperationException if <code>image</code>
	992	* contains a <code>Raster</code> and <code>canWriteRasters</code>
	993	* returns <code>false</code>.
	994	* @exception IOException if an error occurs during writing.
	995	*/
	996	public void writeInsert(int imageIndex,
	997	IIOImage image,
	998	ImageWriteParam param) throws IOException {
	999	unsupported();
	1000	}
	1001
	1002	// Image removal
	1003
	1004	/**
	1005	* Returns <code>true</code> if the writer supports the removal
	1006	* of an existing image at the given index. Existing images with
	1007	* indices greater than the insertion index will have
	1008	* their indices decreased by 1.
	1009	*
	1010	* <p> A writer that does not support any image removal may
	1011	* return <code>false</code> without performing bounds checking on
	1012	* the index.
	1013	*
	1014	* <p> The default implementation throws an
	1015	* <code>IllegalStateException</code> if the output is
	1016	* <code>null</code>, and otherwise returns <code>false</code>
	1017	* without checking the value of <code>imageIndex</code>.
	1018	*
	1019	* @param imageIndex the index of the image to be removed.
	1020	*
	1021	* @return <code>true</code> if it is possible to remove the given
	1022	* image.
	1023	*
	1024	* @exception IllegalStateException if the output has not
	1025	* been set.
	1026	* @exception IndexOutOfBoundsException if the writer supports
	1027	* image removal in general, but <code>imageIndex</code> is less
	1028	* than 0 or greater than the largest available index.
	1029	* @exception IOException if an I/O error occurs during the
	1030	* query.
	1031	*/
	1032	public boolean canRemoveImage(int imageIndex) throws IOException {
	1033	if (getOutput() == null) {
	1034	throw new IllegalStateException("getOutput() == null!");
	1035	}
	1036	return false;
	1037	}
	1038
	1039	/**
	1040	* Removes an image from the stream.
	1041	*
	1042	* <p> If <code>canRemoveImage(imageIndex)</code> returns false,
	1043	* an <code>UnsupportedOperationException</code>will be thrown.
	1044	*
	1045	* <p> The removal may or may not cause a reduction in the actual
	1046	* file size.
	1047	*
	1048	* <p> The default implementation throws an
	1049	* <code>IllegalStateException</code> if the output is
	1050	* <code>null</code>, and otherwise throws an
	1051	* <code>UnsupportedOperationException</code>.
	1052	*
	1053	* @param imageIndex the index of the image to be removed.
	1054	*
	1055	* @exception IllegalStateException if the output has not
	1056	* been set.
	1057	* @exception UnsupportedOperationException if
	1058	* <code>canRemoveImage(imageIndex)</code> returns <code>false</code>.
	1059	* @exception IndexOutOfBoundsException if <code>imageIndex</code>
	1060	* is less than 0 or greater than the largest available index.
	1061	* @exception IOException if an I/O error occurs during the
	1062	* removal.
	1063	*/
	1064	public void removeImage(int imageIndex) throws IOException {
	1065	unsupported();
	1066	}
	1067
	1068	// Empty images
	1069
	1070	/**
	1071	* Returns <code>true</code> if the writer supports the writing of
	1072	* a complete image stream consisting of a single image with
	1073	* undefined pixel values and associated metadata and thumbnails
	1074	* to the output. The pixel values may be defined by future
	1075	* calls to the <code>replacePixels</code> methods. If the output
	1076	* is an <code>ImageOutputStream</code>, its existing contents
	1077	* prior to the current seek position are not affected, and need
	1078	* not be readable or writable.
	1079	*
	1080	* <p> The default implementation throws an
	1081	* <code>IllegalStateException</code> if the output is
	1082	* <code>null</code>, and otherwise returns <code>false</code>.
	1083	*
	1084	* @return <code>true</code> if the writing of complete image
	1085	* stream with contents to be defined later is supported.
	1086	*
	1087	* @exception IllegalStateException if the output has not been
	1088	* set.
	1089	* @exception IOException if an I/O error occurs during the
	1090	* query.
	1091	*/
	1092	public boolean canWriteEmpty() throws IOException {
	1093	if (getOutput() == null) {
	1094	throw new IllegalStateException("getOutput() == null!");
	1095	}
	1096	return false;
	1097	}
	1098
	1099	/**
	1100	* Begins the writing of a complete image stream, consisting of a
	1101	* single image with undefined pixel values and associated
	1102	* metadata and thumbnails, to the output. The pixel values will
	1103	* be defined by future calls to the <code>replacePixels</code>
	1104	* methods. If the output is an <code>ImageOutputStream</code>,
	1105	* its existing contents prior to the current seek position are
	1106	* not affected, and need not be readable or writable.
	1107	*
	1108	* <p> The writing is not complete until a call to
	1109	* <code>endWriteEmpty</code> occurs. Calls to
	1110	* <code>prepareReplacePixels</code>, <code>replacePixels</code>,
	1111	* and <code>endReplacePixels</code> may occur between calls to
	1112	* <code>prepareWriteEmpty</code> and <code>endWriteEmpty</code>.
	1113	* However, calls to <code>prepareWriteEmpty</code> cannot be
	1114	* nested, and calls to <code>prepareWriteEmpty</code> and
	1115	* <code>prepareInsertEmpty</code> may not be interspersed.
	1116	*
	1117	* <p> If <code>canWriteEmpty</code> returns <code>false</code>,
	1118	* an <code>UnsupportedOperationException</code> will be thrown.
	1119	*
	1120	* <p> An <code>ImageWriteParam</code> may optionally be supplied
	1121	* to control the writing process. If <code>param</code> is
	1122	* <code>null</code>, a default write param will be used.
	1123	*
	1124	* <p> If the supplied <code>ImageWriteParam</code> contains
	1125	* optional setting values not supported by this writer (<i>e.g.</i>
	1126	* progressive encoding or any format-specific settings), they
	1127	* will be ignored.
	1128	*
	1129	* <p> The default implementation throws an
	1130	* <code>IllegalStateException</code> if the output is
	1131	* <code>null</code>, and otherwise throws an
	1132	* <code>UnsupportedOperationException</code>.
	1133	*
	1134	* @param streamMetadata an <code>IIOMetadata</code> object representing
	1135	* stream metadata, or <code>null</code> to use default values.
	1136	* @param imageType an <code>ImageTypeSpecifier</code> describing
	1137	* the layout of the image.
	1138	* @param width the width of the image.
	1139	* @param height the height of the image.
	1140	* @param imageMetadata an <code>IIOMetadata</code> object
	1141	* representing image metadata, or <code>null</code>.
	1142	* @param thumbnails a <code>List</code> of
	1143	* <code>BufferedImage</code> thumbnails for this image, or
	1144	* <code>null</code>.
	1145	* @param param an <code>ImageWriteParam</code>, or
	1146	* <code>null</code> to use a default
	1147	* <code>ImageWriteParam</code>.
	1148	*
	1149	* @exception IllegalStateException if the output has not
	1150	* been set.
	1151	* @exception UnsupportedOperationException if
	1152	* <code>canWriteEmpty</code> returns <code>false</code>.
	1153	* @exception IllegalStateException if a previous call to
	1154	* <code>prepareWriteEmpty</code> has been made without a
	1155	* corresponding call to <code>endWriteEmpty</code>.
	1156	* @exception IllegalStateException if a previous call to
	1157	* <code>prepareInsertEmpty</code> has been made without a
	1158	* corresponding call to <code>endInsertEmpty</code>.
	1159	* @exception IllegalArgumentException if <code>imageType</code>
	1160	* is <code>null</code> or <code>thumbnails</code> contains
	1161	* <code>null</code> references or objects other than
	1162	* <code>BufferedImage</code>s.
	1163	* @exception IllegalArgumentException if width or height are less
	1164	* than 1.
	1165	* @exception IOException if an I/O error occurs during writing.
	1166	*/
	1167	public void prepareWriteEmpty(IIOMetadata streamMetadata,
	1168	ImageTypeSpecifier imageType,
	1169	int width, int height,
	1170	IIOMetadata imageMetadata,
	1171	List<? extends BufferedImage> thumbnails,
	1172	ImageWriteParam param) throws IOException {
	1173	unsupported();
	1174	}
	1175
	1176	/**
	1177	* Completes the writing of a new image that was begun with a
	1178	* prior call to <code>prepareWriteEmpty</code>.
	1179	*
	1180	* <p> If <code>canWriteEmpty()</code> returns <code>false</code>,
	1181	* an <code>UnsupportedOperationException</code> will be thrown.
	1182	*
	1183	* <p> The default implementation throws an
	1184	* <code>IllegalStateException</code> if the output is
	1185	* <code>null</code>, and otherwise throws an
	1186	* <code>UnsupportedOperationException</code>.
	1187	*
	1188	* @exception IllegalStateException if the output has not
	1189	* been set.
	1190	* @exception UnsupportedOperationException if
	1191	* <code>canWriteEmpty(imageIndex)</code> returns
	1192	* <code>false</code>.
	1193	* @exception IllegalStateException if a previous call to
	1194	* <code>prepareWriteEmpty</code> without a corresponding call to
	1195	* <code>endWriteEmpty</code> has not been made.
	1196	* @exception IllegalStateException if a previous call to
	1197	* <code>prepareInsertEmpty</code> without a corresponding call to
	1198	* <code>endInsertEmpty</code> has been made.
	1199	* @exception IllegalStateException if a call to
	1200	* <code>prepareReiplacePixels</code> has been made without a
	1201	* matching call to <code>endReplacePixels</code>.
	1202	* @exception IOException if an I/O error occurs during writing.
	1203	*/
	1204	public void endWriteEmpty() throws IOException {
	1205	if (getOutput() == null) {
	1206	throw new IllegalStateException("getOutput() == null!");
	1207	}
	1208	throw new IllegalStateException("No call to prepareWriteEmpty!");
	1209	}
	1210
	1211	/**
	1212	* Returns <code>true</code> if the writer supports the insertion
	1213	* of a new, empty image at the given index. The pixel values of
	1214	* the image are undefined, and may be specified in pieces using
	1215	* the <code>replacePixels</code> methods. Existing images with
	1216	* indices greater than or equal to the insertion index will have
	1217	* their indices increased by 1. A value for
	1218	* <code>imageIndex</code> of <code>-1</code> may be used to
	1219	* signify an index one larger than the current largest index.
	1220	*
	1221	* <p> A writer that does not support insertion of empty images
	1222	* may return <code>false</code> without performing bounds
	1223	* checking on the index.
	1224	*
	1225	* <p> The default implementation throws an
	1226	* <code>IllegalStateException</code> if the output is
	1227	* <code>null</code>, and otherwise returns <code>false</code>
	1228	* without checking the value of <code>imageIndex</code>.
	1229	*
	1230	* @param imageIndex the index at which the image is to be
	1231	* inserted.
	1232	*
	1233	* @return <code>true</code> if an empty image may be inserted at
	1234	* the given index.
	1235	*
	1236	* @exception IllegalStateException if the output has not been
	1237	* set.
	1238	* @exception IndexOutOfBoundsException if the writer supports
	1239	* empty image insertion in general, but <code>imageIndex</code>
	1240	* is less than -1 or greater than the largest available index.
	1241	* @exception IOException if an I/O error occurs during the
	1242	* query.
	1243	*/
	1244	public boolean canInsertEmpty(int imageIndex) throws IOException {
	1245	if (getOutput() == null) {
	1246	throw new IllegalStateException("getOutput() == null!");
	1247	}
	1248	return false;
	1249	}
	1250
	1251	/**
	1252	* Begins the insertion of a new image with undefined pixel values
	1253	* into an existing image stream. Existing images with an index
	1254	* greater than <code>imageIndex</code> are preserved, and their
	1255	* indices are each increased by 1. A value for
	1256	* <code>imageIndex</code> of -1 may be used to signify an index
	1257	* one larger than the previous largest index; that is, it will
	1258	* cause the image to be logically appended to the end of the
	1259	* sequence. If the output is an <code>ImageOutputStream</code>,
	1260	* the entirety of the stream must be both readable and writeable.
	1261	*
	1262	* <p> The image contents may be
	1263	* supplied later using the <code>replacePixels</code> method.
	1264	* The insertion is not complete until a call to
	1265	* <code>endInsertEmpty</code> occurs. Calls to
	1266	* <code>prepareReplacePixels</code>, <code>replacePixels</code>,
	1267	* and <code>endReplacePixels</code> may occur between calls to
	1268	* <code>prepareInsertEmpty</code> and
	1269	* <code>endInsertEmpty</code>. However, calls to
	1270	* <code>prepareInsertEmpty</code> cannot be nested, and calls to
	1271	* <code>prepareWriteEmpty</code> and
	1272	* <code>prepareInsertEmpty</code> may not be interspersed.
	1273	*
	1274	* <p> If <code>canInsertEmpty(imageIndex)</code> returns
	1275	* <code>false</code>, an
	1276	* <code>UnsupportedOperationException</code> will be thrown.
	1277	*
	1278	* <p> An <code>ImageWriteParam</code> may optionally be supplied
	1279	* to control the writing process. If <code>param</code> is
	1280	* <code>null</code>, a default write param will be used.
	1281	*
	1282	* <p> If the supplied <code>ImageWriteParam</code> contains
	1283	* optional setting values not supported by this writer (<i>e.g.</i>
	1284	* progressive encoding or any format-specific settings), they
	1285	* will be ignored.
	1286	*
	1287	* <p> The default implementation throws an
	1288	* <code>IllegalStateException</code> if the output is
	1289	* <code>null</code>, and otherwise throws an
	1290	* <code>UnsupportedOperationException</code>.
	1291	*
	1292	* @param imageIndex the index at which to write the image.
	1293	* @param imageType an <code>ImageTypeSpecifier</code> describing
	1294	* the layout of the image.
	1295	* @param width the width of the image.
	1296	* @param height the height of the image.
	1297	* @param imageMetadata an <code>IIOMetadata</code> object
	1298	* representing image metadata, or <code>null</code>.
	1299	* @param thumbnails a <code>List</code> of
	1300	* <code>BufferedImage</code> thumbnails for this image, or
	1301	* <code>null</code>.
	1302	* @param param an <code>ImageWriteParam</code>, or
	1303	* <code>null</code> to use a default
	1304	* <code>ImageWriteParam</code>.
	1305	*
	1306	* @exception IllegalStateException if the output has not
	1307	* been set.
	1308	* @exception UnsupportedOperationException if
	1309	* <code>canInsertEmpty(imageIndex)</code> returns
	1310	* <code>false</code>.
	1311	* @exception IndexOutOfBoundsException if <code>imageIndex</code>
	1312	* is less than -1 or greater than the largest available index.
	1313	* @exception IllegalStateException if a previous call to
	1314	* <code>prepareInsertEmpty</code> has been made without a
	1315	* corresponding call to <code>endInsertEmpty</code>.
	1316	* @exception IllegalStateException if a previous call to
	1317	* <code>prepareWriteEmpty</code> has been made without a
	1318	* corresponding call to <code>endWriteEmpty</code>.
	1319	* @exception IllegalArgumentException if <code>imageType</code>
	1320	* is <code>null</code> or <code>thumbnails</code> contains
	1321	* <code>null</code> references or objects other than
	1322	* <code>BufferedImage</code>s.
	1323	* @exception IllegalArgumentException if width or height are less
	1324	* than 1.
	1325	* @exception IOException if an I/O error occurs during writing.
	1326	*/
	1327	public void prepareInsertEmpty(int imageIndex,
	1328	ImageTypeSpecifier imageType,
	1329	int width, int height,
	1330	IIOMetadata imageMetadata,
	1331	List<? extends BufferedImage> thumbnails,
	1332	ImageWriteParam param) throws IOException {
	1333	unsupported();
	1334	}
	1335
	1336	/**
	1337	* Completes the insertion of a new image that was begun with a
	1338	* prior call to <code>prepareInsertEmpty</code>.
	1339	*
	1340	* <p> The default implementation throws an
	1341	* <code>IllegalStateException</code> if the output is
	1342	* <code>null</code>, and otherwise throws an
	1343	* <code>UnsupportedOperationException</code>.
	1344	*
	1345	* @exception IllegalStateException if the output has not
	1346	* been set.
	1347	* @exception UnsupportedOperationException if
	1348	* <code>canInsertEmpty(imageIndex)</code> returns
	1349	* <code>false</code>.
	1350	* @exception IllegalStateException if a previous call to
	1351	* <code>prepareInsertEmpty</code> without a corresponding call to
	1352	* <code>endInsertEmpty</code> has not been made.
	1353	* @exception IllegalStateException if a previous call to
	1354	* <code>prepareWriteEmpty</code> without a corresponding call to
	1355	* <code>endWriteEmpty</code> has been made.
	1356	* @exception IllegalStateException if a call to
	1357	* <code>prepareReplacePixels</code> has been made without a
	1358	* matching call to <code>endReplacePixels</code>.
	1359	* @exception IOException if an I/O error occurs during writing.
	1360	*/
	1361	public void endInsertEmpty() throws IOException {
	1362	unsupported();
	1363	}
	1364
	1365	// Pixel replacement
	1366
	1367	/**
	1368	* Returns <code>true</code> if the writer allows pixels of the
	1369	* given image to be replaced using the <code>replacePixels</code>
	1370	* methods.
	1371	*
	1372	* <p> A writer that does not support any pixel replacement may
	1373	* return <code>false</code> without performing bounds checking on
	1374	* the index.
	1375	*
	1376	* <p> The default implementation throws an
	1377	* <code>IllegalStateException</code> if the output is
	1378	* <code>null</code>, and otherwise returns <code>false</code>
	1379	* without checking the value of <code>imageIndex</code>.
	1380	*
	1381	* @param imageIndex the index of the image whose pixels are to be
	1382	* replaced.
	1383	*
	1384	* @return <code>true</code> if the pixels of the given
	1385	* image can be replaced.
	1386	*
	1387	* @exception IllegalStateException if the output has not been
	1388	* set.
	1389	* @exception IndexOutOfBoundsException if the writer supports
	1390	* pixel replacement in general, but <code>imageIndex</code> is
	1391	* less than 0 or greater than the largest available index.
	1392	* @exception IOException if an I/O error occurs during the query.
	1393	*/
	1394	public boolean canReplacePixels(int imageIndex) throws IOException {
	1395	if (getOutput() == null) {
	1396	throw new IllegalStateException("getOutput() == null!");
	1397	}
	1398	return false;
	1399	}
	1400
	1401	/**
	1402	* Prepares the writer to handle a series of calls to the
	1403	* <code>replacePixels</code> methods. The affected pixel area
	1404	* will be clipped against the supplied
	1405	*
	1406	* <p> If <code>canReplacePixels</code> returns
	1407	* <code>false</code>, and
	1408	* <code>UnsupportedOperationException</code> will be thrown.
	1409	*
	1410	* <p> The default implementation throws an
	1411	* <code>IllegalStateException</code> if the output is
	1412	* <code>null</code>, and otherwise throws an
	1413	* <code>UnsupportedOperationException</code>.
	1414	*
	1415	* @param imageIndex the index of the image whose pixels are to be
	1416	* replaced.
	1417	* @param region a <code>Rectangle</code> that will be used to clip
	1418	* future pixel regions.
	1419	*
	1420	* @exception IllegalStateException if the output has not
	1421	* been set.
	1422	* @exception UnsupportedOperationException if
	1423	* <code>canReplacePixels(imageIndex)</code> returns
	1424	* <code>false</code>.
	1425	* @exception IndexOutOfBoundsException if <code>imageIndex</code>
	1426	* is less than 0 or greater than the largest available index.
	1427	* @exception IllegalStateException if there is a previous call to
	1428	* <code>prepareReplacePixels</code> without a matching call to
	1429	* <code>endReplacePixels</code> (<i>i.e.</i>, nesting is not
	1430	* allowed).
	1431	* @exception IllegalArgumentException if <code>region</code> is
	1432	* <code>null</code> or has a width or height less than 1.
	1433	* @exception IOException if an I/O error occurs during the
	1434	* preparation.
	1435	*/
	1436	public void prepareReplacePixels(int imageIndex,
	1437	Rectangle region) throws IOException {
	1438	unsupported();
	1439	}
	1440
	1441	/**
	1442	* Replaces a portion of an image already present in the output
	1443	* with a portion of the given image. The image data must match,
	1444	* or be convertible to, the image layout of the existing image.
	1445	*
	1446	* <p> The destination region is specified in the
	1447	* <code>param</code> argument, and will be clipped to the image
	1448	* boundaries and the region supplied to
	1449	* <code>prepareReplacePixels</code>. At least one pixel of the
	1450	* source must not be clipped, or an exception is thrown.
	1451	*
	1452	* <p> An <code>ImageWriteParam</code> may optionally be supplied
	1453	* to control the writing process. If <code>param</code> is
	1454	* <code>null</code>, a default write param will be used.
	1455	*
	1456	* <p> If the supplied <code>ImageWriteParam</code> contains
	1457	* optional setting values not supported by this writer (<i>e.g.</i>
	1458	* progressive encoding or any format-specific settings), they
	1459	* will be ignored.
	1460	*
	1461	* <p> This method may only be called after a call to
	1462	* <code>prepareReplacePixels</code>, or else an
	1463	* <code>IllegalStateException</code> will be thrown.
	1464	*
	1465	* <p> The default implementation throws an
	1466	* <code>IllegalStateException</code> if the output is
	1467	* <code>null</code>, and otherwise throws an
	1468	* <code>UnsupportedOperationException</code>.
	1469	*
	1470	* @param image a <code>RenderedImage</code> containing source
	1471	* pixels.
	1472	* @param param an <code>ImageWriteParam</code>, or
	1473	* <code>null</code> to use a default
	1474	* <code>ImageWriteParam</code>.
	1475	*
	1476	* @exception IllegalStateException if the output has not
	1477	* been set.
	1478	* @exception UnsupportedOperationException if
	1479	* <code>canReplacePixels(imageIndex)</code> returns
	1480	* <code>false</code>.
	1481	* @exception IllegalStateException if there is no previous call to
	1482	* <code>prepareReplacePixels</code> without a matching call to
	1483	* <code>endReplacePixels</code>.
	1484	* @exception IllegalArgumentException if any of the following are true:
	1485	* <ul>
	1486	* <li> <code>image</code> is <code>null</code>.
	1487	* <li> <code>param</code> is <code>null</code>.
	1488	* <li> the intersected region does not contain at least one pixel.
	1489	* <li> the layout of <code>image</code> does not match, or this
	1490	* writer cannot convert it to, the existing image layout.
	1491	* </ul>
	1492	* @exception IOException if an I/O error occurs during writing.
	1493	*/
	1494	public void replacePixels(RenderedImage image, ImageWriteParam param)
	1495	throws IOException {
	1496	unsupported();
	1497	}
	1498
	1499	/**
	1500	* Replaces a portion of an image already present in the output
	1501	* with a portion of the given <code>Raster</code>. The image
	1502	* data must match, or be convertible to, the image layout of the
	1503	* existing image.
	1504	*
	1505	* <p> An <code>ImageWriteParam</code> may optionally be supplied
	1506	* to control the writing process. If <code>param</code> is
	1507	* <code>null</code>, a default write param will be used.
	1508	*
	1509	* <p> The destination region is specified in the
	1510	* <code>param</code> argument, and will be clipped to the image
	1511	* boundaries and the region supplied to
	1512	* <code>prepareReplacePixels</code>. At least one pixel of the
	1513	* source must not be clipped, or an exception is thrown.
	1514	*
	1515	* <p> If the supplied <code>ImageWriteParam</code> contains
	1516	* optional setting values not supported by this writer (<i>e.g.</i>
	1517	* progressive encoding or any format-specific settings), they
	1518	* will be ignored.
	1519	*
	1520	* <p> This method may only be called after a call to
	1521	* <code>prepareReplacePixels</code>, or else an
	1522	* <code>IllegalStateException</code> will be thrown.
	1523	*
	1524	* <p> The default implementation throws an
	1525	* <code>IllegalStateException</code> if the output is
	1526	* <code>null</code>, and otherwise throws an
	1527	* <code>UnsupportedOperationException</code>.
	1528	*
	1529	* @param raster a <code>Raster</code> containing source
	1530	* pixels.
	1531	* @param param an <code>ImageWriteParam</code>, or
	1532	* <code>null</code> to use a default
	1533	* <code>ImageWriteParam</code>.
	1534	*
	1535	* @exception IllegalStateException if the output has not
	1536	* been set.
	1537	* @exception UnsupportedOperationException if
	1538	* <code>canReplacePixels(imageIndex)</code> returns
	1539	* <code>false</code>.
	1540	* @exception IllegalStateException if there is no previous call to
	1541	* <code>prepareReplacePixels</code> without a matching call to
	1542	* <code>endReplacePixels</code>.
	1543	* @exception UnsupportedOperationException if
	1544	* <code>canWriteRasters</code> returns <code>false</code>.
	1545	* @exception IllegalArgumentException if any of the following are true:
	1546	* <ul>
	1547	* <li> <code>raster</code> is <code>null</code>.
	1548	* <li> <code>param</code> is <code>null</code>.
	1549	* <li> the intersected region does not contain at least one pixel.
	1550	* <li> the layout of <code>raster</code> does not match, or this
	1551	* writer cannot convert it to, the existing image layout.
	1552	* </ul>
	1553	* @exception IOException if an I/O error occurs during writing.
	1554	*/
	1555	public void replacePixels(Raster raster, ImageWriteParam param)
	1556	throws IOException {
	1557	unsupported();
	1558	}
	1559
	1560	/**
	1561	* Terminates a sequence of calls to <code>replacePixels</code>.
	1562	*
	1563	* <p> If <code>canReplacePixels</code> returns
	1564	* <code>false</code>, and
	1565	* <code>UnsupportedOperationException</code> will be thrown.
	1566	*
	1567	* <p> The default implementation throws an
	1568	* <code>IllegalStateException</code> if the output is
	1569	* <code>null</code>, and otherwise throws an
	1570	* <code>UnsupportedOperationException</code>.
	1571	*
	1572	* @exception IllegalStateException if the output has not
	1573	* been set.
	1574	* @exception UnsupportedOperationException if
	1575	* <code>canReplacePixels(imageIndex)</code> returns
	1576	* <code>false</code>.
	1577	* @exception IllegalStateException if there is no previous call
	1578	* to <code>prepareReplacePixels</code> without a matching call to
	1579	* <code>endReplacePixels</code>.
	1580	* @exception IOException if an I/O error occurs during writing.
	1581	*/
	1582	public void endReplacePixels() throws IOException {
	1583	unsupported();
	1584	}
	1585
	1586	// Abort
	1587
	1588	/**
	1589	* Requests that any current write operation be aborted. The
	1590	* contents of the output following the abort will be undefined.
	1591	*
	1592	* <p> Writers should call <code>clearAbortRequest</code> at the
	1593	* beginning of each write operation, and poll the value of
	1594	* <code>abortRequested</code> regularly during the write.
	1595	*/
	1596	public synchronized void abort() {
	1597	this.abortFlag = true;
	1598	}
	1599
	1600	/**
	1601	* Returns <code>true</code> if a request to abort the current
	1602	* write operation has been made since the writer was instantiated or
	1603	* <code>clearAbortRequest</code> was called.
	1604	*
	1605	* @return <code>true</code> if the current write operation should
	1606	* be aborted.
	1607	*
	1608	* @see #abort
	1609	* @see #clearAbortRequest
	1610	*/
	1611	protected synchronized boolean abortRequested() {
	1612	return this.abortFlag;
	1613	}
	1614
	1615	/**
	1616	* Clears any previous abort request. After this method has been
	1617	* called, <code>abortRequested</code> will return
	1618	* <code>false</code>.
	1619	*
	1620	* @see #abort
	1621	* @see #abortRequested
	1622	*/
	1623	protected synchronized void clearAbortRequest() {
	1624	this.abortFlag = false;
	1625	}
	1626
	1627	// Listeners
	1628
	1629	/**
	1630	* Adds an <code>IIOWriteWarningListener</code> to the list of
	1631	* registered warning listeners. If <code>listener</code> is
	1632	* <code>null</code>, no exception will be thrown and no action
	1633	* will be taken. Messages sent to the given listener will be
	1634	* localized, if possible, to match the current
	1635	* <code>Locale</code>. If no <code>Locale</code> has been set,
	1636	* warning messages may be localized as the writer sees fit.
	1637	*
	1638	* @param listener an <code>IIOWriteWarningListener</code> to be
	1639	* registered.
	1640	*
	1641	* @see #removeIIOWriteWarningListener
	1642	*/
	1643	public void addIIOWriteWarningListener(IIOWriteWarningListener listener) {
	1644	if (listener == null) {
	1645	return;
	1646	}
	1647	warningListeners = ImageReader.addToList(warningListeners, listener);
	1648	warningLocales = ImageReader.addToList(warningLocales, getLocale());
	1649	}
	1650
	1651	/**
	1652	* Removes an <code>IIOWriteWarningListener</code> from the list
	1653	* of registered warning listeners. If the listener was not
	1654	* previously registered, or if <code>listener</code> is
	1655	* <code>null</code>, no exception will be thrown and no action
	1656	* will be taken.
	1657	*
	1658	* @param listener an <code>IIOWriteWarningListener</code> to be
	1659	* deregistered.
	1660	*
	1661	* @see #addIIOWriteWarningListener
	1662	*/
	1663	public
	1664	void removeIIOWriteWarningListener(IIOWriteWarningListener listener) {
	1665	if (listener == null \|\| warningListeners == null) {
	1666	return;
	1667	}
	1668	int index = warningListeners.indexOf(listener);
	1669	if (index != -1) {
	1670	warningListeners.remove(index);
	1671	warningLocales.remove(index);
	1672	if (warningListeners.size() == 0) {
	1673	warningListeners = null;
	1674	warningLocales = null;
	1675	}
	1676	}
	1677	}
	1678
	1679	/**
	1680	* Removes all currently registered
	1681	* <code>IIOWriteWarningListener</code> objects.
	1682	*
	1683	* <p> The default implementation sets the
	1684	* <code>warningListeners</code> and <code>warningLocales</code>
	1685	* instance variables to <code>null</code>.
	1686	*/
	1687	public void removeAllIIOWriteWarningListeners() {
	1688	this.warningListeners = null;
	1689	this.warningLocales = null;
	1690	}
	1691
	1692	/**
	1693	* Adds an <code>IIOWriteProgressListener</code> to the list of
	1694	* registered progress listeners. If <code>listener</code> is
	1695	* <code>null</code>, no exception will be thrown and no action
	1696	* will be taken.
	1697	*
	1698	* @param listener an <code>IIOWriteProgressListener</code> to be
	1699	* registered.
	1700	*
	1701	* @see #removeIIOWriteProgressListener
	1702	*/
	1703	public void
	1704	addIIOWriteProgressListener(IIOWriteProgressListener listener) {
	1705	if (listener == null) {
	1706	return;
	1707	}
	1708	progressListeners = ImageReader.addToList(progressListeners, listener);
	1709	}
	1710
	1711	/**
	1712	* Removes an <code>IIOWriteProgressListener</code> from the list
	1713	* of registered progress listeners. If the listener was not
	1714	* previously registered, or if <code>listener</code> is
	1715	* <code>null</code>, no exception will be thrown and no action
	1716	* will be taken.
	1717	*
	1718	* @param listener an <code>IIOWriteProgressListener</code> to be
	1719	* deregistered.
	1720	*
	1721	* @see #addIIOWriteProgressListener
	1722	*/
	1723	public void
	1724	removeIIOWriteProgressListener(IIOWriteProgressListener listener) {
	1725	if (listener == null \|\| progressListeners == null) {
	1726	return;
	1727	}
	1728	progressListeners =
	1729	ImageReader.removeFromList(progressListeners, listener);
	1730	}
	1731
	1732	/**
	1733	* Removes all currently registered
	1734	* <code>IIOWriteProgressListener</code> objects.
	1735	*
	1736	* <p> The default implementation sets the
	1737	* <code>progressListeners</code> instance variable to
	1738	* <code>null</code>.
	1739	*/
	1740	public void removeAllIIOWriteProgressListeners() {
	1741	this.progressListeners = null;
	1742	}
	1743
	1744	/**
	1745	* Broadcasts the start of an image write to all registered
	1746	* <code>IIOWriteProgressListener</code>s by calling their
	1747	* <code>imageStarted</code> method. Subclasses may use this
	1748	* method as a convenience.
	1749	*
	1750	* @param imageIndex the index of the image about to be written.
	1751	*/
	1752	protected void processImageStarted(int imageIndex) {
	1753	if (progressListeners == null) {
	1754	return;
	1755	}
	1756	int numListeners = progressListeners.size();
	1757	for (int i = 0; i < numListeners; i++) {
	1758	IIOWriteProgressListener listener =
	1759	(IIOWriteProgressListener)progressListeners.get(i);
	1760	listener.imageStarted(this, imageIndex);
	1761	}
	1762	}
	1763
	1764	/**
	1765	* Broadcasts the current percentage of image completion to all
	1766	* registered <code>IIOWriteProgressListener</code>s by calling
	1767	* their <code>imageProgress</code> method. Subclasses may use
	1768	* this method as a convenience.
	1769	*
	1770	* @param percentageDone the current percentage of completion,
	1771	* as a <code>float</code>.
	1772	*/
	1773	protected void processImageProgress(float percentageDone) {
	1774	if (progressListeners == null) {
	1775	return;
	1776	}
	1777	int numListeners = progressListeners.size();
	1778	for (int i = 0; i < numListeners; i++) {
	1779	IIOWriteProgressListener listener =
	1780	(IIOWriteProgressListener)progressListeners.get(i);
	1781	listener.imageProgress(this, percentageDone);
	1782	}
	1783	}
	1784
	1785	/**
	1786	* Broadcasts the completion of an image write to all registered
	1787	* <code>IIOWriteProgressListener</code>s by calling their
	1788	* <code>imageComplete</code> method. Subclasses may use this
	1789	* method as a convenience.
	1790	*/
	1791	protected void processImageComplete() {
	1792	if (progressListeners == null) {
	1793	return;
	1794	}
	1795	int numListeners = progressListeners.size();
	1796	for (int i = 0; i < numListeners; i++) {
	1797	IIOWriteProgressListener listener =
	1798	(IIOWriteProgressListener)progressListeners.get(i);
	1799	listener.imageComplete(this);
	1800	}
	1801	}
	1802
	1803	/**
	1804	* Broadcasts the start of a thumbnail write to all registered
	1805	* <code>IIOWriteProgressListener</code>s by calling their
	1806	* <code>thumbnailStarted</code> method. Subclasses may use this
	1807	* method as a convenience.
	1808	*
	1809	* @param imageIndex the index of the image associated with the
	1810	* thumbnail.
	1811	* @param thumbnailIndex the index of the thumbnail.
	1812	*/
	1813	protected void processThumbnailStarted(int imageIndex,
	1814	int thumbnailIndex) {
	1815	if (progressListeners == null) {
	1816	return;
	1817	}
	1818	int numListeners = progressListeners.size();
	1819	for (int i = 0; i < numListeners; i++) {
	1820	IIOWriteProgressListener listener =
	1821	(IIOWriteProgressListener)progressListeners.get(i);
	1822	listener.thumbnailStarted(this, imageIndex, thumbnailIndex);
	1823	}
	1824	}
	1825
	1826	/**
	1827	* Broadcasts the current percentage of thumbnail completion to
	1828	* all registered <code>IIOWriteProgressListener</code>s by calling
	1829	* their <code>thumbnailProgress</code> method. Subclasses may
	1830	* use this method as a convenience.
	1831	*
	1832	* @param percentageDone the current percentage of completion,
	1833	* as a <code>float</code>.
	1834	*/
	1835	protected void processThumbnailProgress(float percentageDone) {
	1836	if (progressListeners == null) {
	1837	return;
	1838	}
	1839	int numListeners = progressListeners.size();
	1840	for (int i = 0; i < numListeners; i++) {
	1841	IIOWriteProgressListener listener =
	1842	(IIOWriteProgressListener)progressListeners.get(i);
	1843	listener.thumbnailProgress(this, percentageDone);
	1844	}
	1845	}
	1846
	1847	/**
	1848	* Broadcasts the completion of a thumbnail write to all registered
	1849	* <code>IIOWriteProgressListener</code>s by calling their
	1850	* <code>thumbnailComplete</code> method. Subclasses may use this
	1851	* method as a convenience.
	1852	*/
	1853	protected void processThumbnailComplete() {
	1854	if (progressListeners == null) {
	1855	return;
	1856	}
	1857	int numListeners = progressListeners.size();
	1858	for (int i = 0; i < numListeners; i++) {
	1859	IIOWriteProgressListener listener =
	1860	(IIOWriteProgressListener)progressListeners.get(i);
	1861	listener.thumbnailComplete(this);
	1862	}
	1863	}
	1864
	1865	/**
	1866	* Broadcasts that the write has been aborted to all registered
	1867	* <code>IIOWriteProgressListener</code>s by calling their
	1868	* <code>writeAborted</code> method. Subclasses may use this
	1869	* method as a convenience.
	1870	*/
	1871	protected void processWriteAborted() {
	1872	if (progressListeners == null) {
	1873	return;
	1874	}
	1875	int numListeners = progressListeners.size();
	1876	for (int i = 0; i < numListeners; i++) {
	1877	IIOWriteProgressListener listener =
	1878	(IIOWriteProgressListener)progressListeners.get(i);
	1879	listener.writeAborted(this);
	1880	}
	1881	}
	1882
	1883	/**
	1884	* Broadcasts a warning message to all registered
	1885	* <code>IIOWriteWarningListener</code>s by calling their
	1886	* <code>warningOccurred</code> method. Subclasses may use this
	1887	* method as a convenience.
	1888	*
	1889	* @param imageIndex the index of the image on which the warning
	1890	* occurred.
	1891	* @param warning the warning message.
	1892	*
	1893	* @exception IllegalArgumentException if <code>warning</code>
	1894	* is <code>null</code>.
	1895	*/
	1896	protected void processWarningOccurred(int imageIndex,
	1897	String warning) {
	1898	if (warningListeners == null) {
	1899	return;
	1900	}
	1901	if (warning == null) {
	1902	throw new IllegalArgumentException("warning == null!");
	1903	}
	1904	int numListeners = warningListeners.size();
	1905	for (int i = 0; i < numListeners; i++) {
	1906	IIOWriteWarningListener listener =
	1907	(IIOWriteWarningListener)warningListeners.get(i);
	1908
	1909	listener.warningOccurred(this, imageIndex, warning);
	1910	}
	1911	}
	1912
	1913	/**
	1914	* Broadcasts a localized warning message to all registered
	1915	* <code>IIOWriteWarningListener</code>s by calling their
	1916	* <code>warningOccurred</code> method with a string taken
	1917	* from a <code>ResourceBundle</code>. Subclasses may use this
	1918	* method as a convenience.
	1919	*
	1920	* @param imageIndex the index of the image on which the warning
	1921	* occurred.
	1922	* @param baseName the base name of a set of
	1923	* <code>ResourceBundle</code>s containing localized warning
	1924	* messages.
	1925	* @param keyword the keyword used to index the warning message
	1926	* within the set of <code>ResourceBundle</code>s.
	1927	*
	1928	* @exception IllegalArgumentException if <code>baseName</code>
	1929	* is <code>null</code>.
	1930	* @exception IllegalArgumentException if <code>keyword</code>
	1931	* is <code>null</code>.
	1932	* @exception IllegalArgumentException if no appropriate
	1933	* <code>ResourceBundle</code> may be located.
	1934	* @exception IllegalArgumentException if the named resource is
	1935	* not found in the located <code>ResourceBundle</code>.
	1936	* @exception IllegalArgumentException if the object retrieved
	1937	* from the <code>ResourceBundle</code> is not a
	1938	* <code>String</code>.
	1939	*/
	1940	protected void processWarningOccurred(int imageIndex,
	1941	String baseName,
	1942	String keyword) {
	1943	if (warningListeners == null) {
	1944	return;
	1945	}
	1946	if (baseName == null) {
	1947	throw new IllegalArgumentException("baseName == null!");
	1948	}
	1949	if (keyword == null) {
	1950	throw new IllegalArgumentException("keyword == null!");
	1951	}
	1952	int numListeners = warningListeners.size();
	1953	for (int i = 0; i < numListeners; i++) {
	1954	IIOWriteWarningListener listener =
	1955	(IIOWriteWarningListener)warningListeners.get(i);
	1956	Locale locale = (Locale)warningLocales.get(i);
	1957	if (locale == null) {
	1958	locale = Locale.getDefault();
	1959	}
	1960
	1961	/**
	1962	* If an applet supplies an implementation of ImageWriter and
	1963	* resource bundles, then the resource bundle will need to be
	1964	* accessed via the applet class loader. So first try the context
	1965	* class loader to locate the resource bundle.
	1966	* If that throws MissingResourceException, then try the
	1967	* system class loader.
	1968	*/
	1969	ClassLoader loader = (ClassLoader)
	1970	java.security.AccessController.doPrivileged(
	1971	new java.security.PrivilegedAction() {
	1972	public Object run() {
	1973	return Thread.currentThread().getContextClassLoader();
	1974	}
	1975	});
	1976
	1977	ResourceBundle bundle = null;
	1978	try {
	1979	bundle = ResourceBundle.getBundle(baseName, locale, loader);
	1980	} catch (MissingResourceException mre) {
	1981	try {
	1982	bundle = ResourceBundle.getBundle(baseName, locale);
	1983	} catch (MissingResourceException mre1) {
	1984	throw new IllegalArgumentException("Bundle not found!");
	1985	}
	1986	}
	1987
	1988	String warning = null;
	1989	try {
	1990	warning = bundle.getString(keyword);
	1991	} catch (ClassCastException cce) {
	1992	throw new IllegalArgumentException("Resource is not a String!");
	1993	} catch (MissingResourceException mre) {
	1994	throw new IllegalArgumentException("Resource is missing!");
	1995	}
	1996
	1997	listener.warningOccurred(this, imageIndex, warning);
	1998	}
	1999	}
	2000
	2001	// State management
	2002
	2003	/**
	2004	* Restores the <code>ImageWriter</code> to its initial state.
	2005	*
	2006	* <p> The default implementation calls
	2007	* <code>setOutput(null)</code>, <code>setLocale(null)</code>,
	2008	* <code>removeAllIIOWriteWarningListeners()</code>,
	2009	* <code>removeAllIIOWriteProgressListeners()</code>, and
	2010	* <code>clearAbortRequest</code>.
	2011	*/
	2012	public void reset() {
	2013	setOutput(null);
	2014	setLocale(null);
	2015	removeAllIIOWriteWarningListeners();
	2016	removeAllIIOWriteProgressListeners();
	2017	clearAbortRequest();
	2018	}
	2019
	2020	/**
	2021	* Allows any resources held by this object to be released. The
	2022	* result of calling any other method (other than
	2023	* <code>finalize</code>) subsequent to a call to this method
	2024	* is undefined.
	2025	*
	2026	* <p>It is important for applications to call this method when they
	2027	* know they will no longer be using this <code>ImageWriter</code>.
	2028	* Otherwise, the writer may continue to hold on to resources
	2029	* indefinitely.
	2030	*
	2031	* <p>The default implementation of this method in the superclass does
	2032	* nothing. Subclass implementations should ensure that all resources,
	2033	* especially native resources, are released.
	2034	*/
	2035	public void dispose() {
	2036	}
	2037	}