jdk-sandbox: comparison jdk/src/java.desktop/share/classes/javax/imageio/ImageWriter.java

equal deleted inserted replaced

-:d69b38870195
+:ed476aba94de
 /**
 * 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</code> objects are normally instantiated by
+* <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</code>,
+* 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
 *
 */
 public abstract class ImageWriter implements ImageTranscoder {
 /**
-* The <code>ImageWriterSpi</code> that instantiated this object,
+* The {@code ImageWriterSpi} that instantiated this object,
-* or <code>null</code> if its identity is not known or none
+* or {@code null} if its identity is not known or none
-* exists.  By default it is initialized to <code>null</code>.
+* exists.  By default it is initialized to {@code null}.
 */
 protected ImageWriterSpi originatingProvider = null;
 /**
-* The <code>ImageOutputStream</code> or other <code>Object</code>
+* The {@code ImageOutputStream} or other {@code Object}
-* set by <code>setOutput</code> and retrieved by
+* set by {@code setOutput} and retrieved by
-* <code>getOutput</code>.  By default it is initialized to
+* {@code getOutput}.  By default it is initialized to
-* <code>null</code>.
+* {@code null}.
 */
 protected Object output = null;
 /**
-* An array of <code>Locale</code>s that may be used to localize
+* An array of {@code Locale}s that may be used to localize
 * warning messages and compression setting values, or
-* <code>null</code> if localization is not supported.  By default
+* {@code null} if localization is not supported.  By default
-* it is initialized to <code>null</code>.
+* it is initialized to {@code null}.
 */
 protected Locale[] availableLocales = null;
 /**
-* The current <code>Locale</code> to be used for localization, or
+* The current {@code Locale} to be used for localization, or
-* <code>null</code> if none has been set.  By default it is
+* {@code null} if none has been set.  By default it is
-* initialized to <code>null</code>.
+* initialized to {@code null}.
 */
 protected Locale locale = null;
 /**
-* A <code>List</code> of currently registered
+* A {@code List} of currently registered
-* <code>IIOWriteWarningListener</code>s, initialized by default to
+* {@code IIOWriteWarningListener}s, initialized by default to
-* <code>null</code>, which is synonymous with an empty
+* {@code null}, which is synonymous with an empty
-* <code>List</code>.
+* {@code List}.
 */
 protected List<IIOWriteWarningListener> warningListeners = null;
 /**
-* A <code>List</code> of <code>Locale</code>s, one for each
+* A {@code List} of {@code Locale}s, one for each
-* element of <code>warningListeners</code>, initialized by default
+* element of {@code warningListeners}, initialized by default
-* <code>null</code>, which is synonymous with an empty
+* {@code null}, which is synonymous with an empty
-* <code>List</code>.
+* {@code List}.
 */
 protected List<Locale> warningLocales = null;
 /**
-* A <code>List</code> of currently registered
+* A {@code List} of currently registered
-* <code>IIOWriteProgressListener</code>s, initialized by default
+* {@code IIOWriteProgressListener}s, initialized by default
-* <code>null</code>, which is synonymous with an empty
+* {@code null}, which is synonymous with an empty
-* <code>List</code>.
+* {@code List}.
 */
 protected List<IIOWriteProgressListener> progressListeners = null;
 /**
-* If <code>true</code>, the current write operation should be
+* If {@code true}, the current write operation should be
 * aborted.
 */
 private boolean abortFlag = false;
 /**
-* Constructs an <code>ImageWriter</code> and sets its
+* Constructs an {@code ImageWriter} and sets its
-* <code>originatingProvider</code> instance variable to the
+* {@code originatingProvider} instance variable to the
 * supplied value.
 *
 * <p> Subclasses that make use of extensions should provide a
-* constructor with signature <code>(ImageWriterSpi,
+* constructor with signature {@code (ImageWriterSpi, Object)}
-* Object)</code> in order to retrieve the extension object.  If
+* in order to retrieve the extension object.  If
 * the extension object is unsuitable, an
-* <code>IllegalArgumentException</code> should be thrown.
+* {@code IllegalArgumentException} should be thrown.
 *
-* @param originatingProvider the <code>ImageWriterSpi</code> that
+* @param originatingProvider the {@code ImageWriterSpi} that
-* is constructing this object, or <code>null</code>.
+* is constructing this object, or {@code null}.
 */
 protected ImageWriter(ImageWriterSpi originatingProvider) {
 this.originatingProvider = originatingProvider;
 }
 /**
-* Returns the <code>ImageWriterSpi</code> object that created
+* Returns the {@code ImageWriterSpi} object that created
-* this <code>ImageWriter</code>, or <code>null</code> if this
+* this {@code ImageWriter}, or {@code null} if this
-* object was not created through the <code>IIORegistry</code>.
+* object was not created through the {@code IIORegistry}.
 *
 * <p> The default implementation returns the value of the
-* <code>originatingProvider</code> instance variable.
+* {@code originatingProvider} instance variable.
 *
-* @return an <code>ImageWriterSpi</code>, or <code>null</code>.
+* @return an {@code ImageWriterSpi}, or {@code null}.
 *
 * @see ImageWriterSpi
 */
 public ImageWriterSpi getOriginatingProvider() {
 return originatingProvider;
 }
 /**
 * Sets the destination to the given
-* <code>ImageOutputStream</code> or other <code>Object</code>.
+* {@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</code> is
+* single network connection.  If {@code output} is
-* <code>null</code>, any currently set output will be removed.
+* {@code null}, any currently set output will be removed.
 *
-* <p> If <code>output</code> is an
+* <p> If {@code output} is an
-* <code>ImageOutputStream</code>, calls to the
+* {@code ImageOutputStream}, calls to the
-* <code>write</code>, <code>writeToSequence</code>, and
+* {@code write}, {@code writeToSequence}, and
-* <code>prepareWriteEmpty</code>/<code>endWriteEmpty</code>
+* {@code prepareWriteEmpty}/{@code endWriteEmpty}
 * methods will preserve the existing contents of the stream.
-* Other write methods, such as <code>writeInsert</code>,
+* Other write methods, such as {@code writeInsert},
-* <code>replaceStreamMetadata</code>,
+* {@code replaceStreamMetadata},
-* <code>replaceImageMetadata</code>, <code>replacePixels</code>,
+* {@code replaceImageMetadata}, {@code replacePixels},
-* <code>prepareInsertEmpty</code>/<code>endInsertEmpty</code>,
+* {@code prepareInsertEmpty}/{@code endInsertEmpty},
-* and <code>endWriteSequence</code>, require the full contents
+* 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</code> other than an
+* <p> Use of a general {@code Object} other than an
-* <code>ImageOutputStream</code> is intended for writers that
+* {@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</code> method; most writers
+* provider's {@code getOutputTypes} method; most writers
 * will return a single-element array containing only
-* <code>ImageOutputStream.class</code> to indicate that they
+* {@code ImageOutputStream.class} to indicate that they
-* accept only an <code>ImageOutputStream</code>.
+* accept only an {@code ImageOutputStream}.
 *
-* <p> The default implementation sets the <code>output</code>
+* <p> The default implementation sets the {@code output}
-* instance variable to the value of <code>output</code> after
+* instance variable to the value of {@code output} after
-* checking <code>output</code> against the set of classes
+* checking {@code output} against the set of classes
 * advertised by the originating provider, if there is one.
 *
-* @param output the <code>ImageOutputStream</code> or other
+* @param output the {@code ImageOutputStream} or other
-* <code>Object</code> to use for future writing.
+* {@code Object} to use for future writing.
 *
-* @exception IllegalArgumentException if <code>output</code> is
+* @exception IllegalArgumentException if {@code output} is
 * not an instance of one of the classes returned by the
-* originating service provider's <code>getOutputTypes</code>
+* originating service provider's {@code getOutputTypes}
 * method.
 *
 * @see #getOutput
 */
 public void setOutput(Object output) {
 this.output = output;
 }
 /**
-* Returns the <code>ImageOutputStream</code> or other
+* Returns the {@code ImageOutputStream} or other
-* <code>Object</code> set by the most recent call to the
+* {@code Object} set by the most recent call to the
-* <code>setOutput</code> method.  If no destination has been
+* {@code setOutput} method.  If no destination has been
-* set, <code>null</code> is returned.
+* set, {@code null} is returned.
 *
 * <p> The default implementation returns the value of the
-* <code>output</code> instance variable.
+* {@code output} instance variable.
 *
-* @return the <code>Object</code> that was specified using
+* @return the {@code Object} that was specified using
-* <code>setOutput</code>, or <code>null</code>.
+* {@code setOutput}, or {@code null}.
 *
 * @see #setOutput
 */
 public Object getOutput() {
 return output;
 }
 // Localization
 /**
-* Returns an array of <code>Locale</code>s that may be used to
+* Returns an array of {@code Locale}s that may be used to
 * localize warning listeners and compression settings.  A return
-* value of <code>null</code> indicates that localization is not
+* value of {@code null} indicates that localization is not
 * supported.
 *
 * <p> The default implementation returns a clone of the
-* <code>availableLocales</code> instance variable if it is
+* {@code availableLocales} instance variable if it is
-* non-<code>null</code>, or else returns <code>null</code>.
+* non-{@code null}, or else returns {@code null}.
 *
-* @return an array of <code>Locale</code>s that may be used as
+* @return an array of {@code Locale}s that may be used as
-* arguments to <code>setLocale</code>, or <code>null</code>.
+* arguments to {@code setLocale}, or {@code null}.
 */
 public Locale[] getAvailableLocales() {
 return (availableLocales == null) ?
 null : availableLocales.clone();
 }
 /**
-* Sets the current <code>Locale</code> of this
+* Sets the current {@code Locale} of this
-* <code>ImageWriter</code> to the given value.  A value of
+* {@code ImageWriter} to the given value.  A value of
-* <code>null</code> removes any previous setting, and indicates
+* {@code null} removes any previous setting, and indicates
 * that the writer should localize as it sees fit.
 *
-* <p> The default implementation checks <code>locale</code>
+* <p> The default implementation checks {@code locale}
 * against the values returned by
-* <code>getAvailableLocales</code>, and sets the
+* {@code getAvailableLocales}, and sets the
-* <code>locale</code> instance variable if it is found.  If
+* {@code locale} instance variable if it is found.  If
-* <code>locale</code> is <code>null</code>, the instance variable
+* {@code locale} is {@code null}, the instance variable
-* is set to <code>null</code> without any checking.
+* is set to {@code null} without any checking.
 *
-* @param locale the desired <code>Locale</code>, or
+* @param locale the desired {@code Locale}, or
-* <code>null</code>.
+* {@code null}.
 *
-* @exception IllegalArgumentException if <code>locale</code> is
+* @exception IllegalArgumentException if {@code locale} is
-* non-<code>null</code> but is not one of the values returned by
+* non-{@code null} but is not one of the values returned by
-* <code>getAvailableLocales</code>.
+* {@code getAvailableLocales}.
 *
 * @see #getLocale
 */
 public void setLocale(Locale locale) {
 if (locale != null) {
 }
 this.locale = locale;
 }
 /**
-* Returns the currently set <code>Locale</code>, or
+* Returns the currently set {@code Locale}, or
-* <code>null</code> if none has been set.
+* {@code null} if none has been set.
 *
 * <p> The default implementation returns the value of the
-* <code>locale</code> instance variable.
+* {@code locale} instance variable.
 *
-* @return the current <code>Locale</code>, or <code>null</code>.
+* @return the current {@code Locale}, or {@code null}.
 *
 * @see #setLocale
 */
 public Locale getLocale() {
 return locale;
 }
 // Write params
 /**
-* Returns a new <code>ImageWriteParam</code> object of the
+* 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</code> object were specified.  This
+* 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</code> object that does not allow tiling,
+* {@code ImageWriteParam} object that does not allow tiling,
 * progressive encoding, or compression, and that will be
-* localized for the current <code>Locale</code> (<i>i.e.</i>,
+* localized for the current {@code Locale} (<i>i.e.</i>,
-* what you would get by calling <code>new
+* what you would get by calling
-* ImageWriteParam(getLocale())</code>.
+* {@code new ImageWriteParam(getLocale())}.
 *
 * <p> Individual plug-ins may return an instance of
-* <code>ImageWriteParam</code> with additional optional features
+* {@code ImageWriteParam} with additional optional features
 * enabled, or they may return an instance of a plug-in specific
-* subclass of <code>ImageWriteParam</code>.
+* subclass of {@code ImageWriteParam}.
 *
-* @return a new <code>ImageWriteParam</code> object containing
+* @return a new {@code ImageWriteParam} object containing
 * default values.
 */
 public ImageWriteParam getDefaultWriteParam() {
 return new ImageWriteParam(getLocale());
 }
 // Metadata
 /**
-* Returns an <code>IIOMetadata</code> object containing default
+* 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</code> method, an
+* returned by the {@code IIOMetadata.getAsTree} method, an
-* <code>IIOMetadataController</code> object, or via plug-in
+* {@code IIOMetadataController} object, or via plug-in
 * specific interfaces, and the resulting data supplied to one of
-* the <code>write</code> methods that take a stream metadata
+* the {@code write} methods that take a stream metadata
 * parameter.
 *
-* <p> An optional <code>ImageWriteParam</code> may be supplied
+* <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</code> contains
+* <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</code>.
+* {@code null}.
 *
-* @param param an <code>ImageWriteParam</code> that will be used to
+* @param param an {@code ImageWriteParam} that will be used to
-* encode the image, or <code>null</code>.
+* encode the image, or {@code null}.
 *
-* @return an <code>IIOMetadata</code> object.
+* @return an {@code IIOMetadata} object.
 */
 public abstract IIOMetadata
 getDefaultStreamMetadata(ImageWriteParam param);
 /**
-* Returns an <code>IIOMetadata</code> object containing default
+* 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</code>
+* structure returned by the {@code IIOMetadata.getAsTree}
-* method, an <code>IIOMetadataController</code> object, or via
+* method, an {@code IIOMetadataController} object, or via
 * plug-in specific interfaces, and the resulting data supplied to
-* one of the <code>write</code> methods that take a stream
+* one of the {@code write} methods that take a stream
 * metadata parameter.
 *
-* <p> An optional <code>ImageWriteParam</code> may be supplied
+* <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</code> contains
+* <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</code> indicating the
+* @param imageType an {@code ImageTypeSpecifier} indicating the
 * format of the image to be written later.
-* @param param an <code>ImageWriteParam</code> that will be used to
+* @param param an {@code ImageWriteParam} that will be used to
-* encode the image, or <code>null</code>.
+* encode the image, or {@code null}.
 *
-* @return an <code>IIOMetadata</code> object.
+* @return an {@code IIOMetadata} object.
 */
 public abstract IIOMetadata
 getDefaultImageMetadata(ImageTypeSpecifier imageType,
 ImageWriteParam param);
 /**
 * 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</code> indicates that
+* encoding.  A return value of {@code -1} indicates that
 * insufficient information is available.
 *
-* <p> An <code>ImageWriteParam</code> may optionally be supplied
+* <p> An {@code ImageWriteParam} may optionally be supplied
 * for cases where it may affect thumbnail handling.
 *
-* <p> If the supplied <code>ImageWriteParam</code> contains
+* <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</code> indicating
+* @param imageType an {@code ImageTypeSpecifier} indicating
-* the type of image to be written, or <code>null</code>.
+* the type of image to be written, or {@code null}.
-* @param param the <code>ImageWriteParam</code> that will be used for
+* @param param the {@code ImageWriteParam} that will be used for
-* writing, or <code>null</code>.
+* writing, or {@code null}.
-* @param streamMetadata an <code>IIOMetadata</code> object that will
+* @param streamMetadata an {@code IIOMetadata} object that will
-* be used for writing, or <code>null</code>.
+* be used for writing, or {@code null}.
-* @param imageMetadata an <code>IIOMetadata</code> object that will
+* @param imageMetadata an {@code IIOMetadata} object that will
-* be used for writing, or <code>null</code>.
+* be used for writing, or {@code null}.
 *
 * @return the number of thumbnails that may be written given the
-* supplied parameters, or <code>-1</code> if insufficient
+* 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</code>s indicating the
+* 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</code>
+* appear for both elements.  A return value of {@code null}
 * indicates that the size is arbitrary or unknown.
 *
-* <p> An <code>ImageWriteParam</code> may optionally be supplied
+* <p> An {@code ImageWriteParam} may optionally be supplied
 * for cases where it may affect thumbnail handling.
 *
-* <p> If the supplied <code>ImageWriteParam</code> contains
+* <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</code>.
+* <p> The default implementation returns {@code null}.
 *
-* @param imageType an <code>ImageTypeSpecifier</code> indicating the
+* @param imageType an {@code ImageTypeSpecifier} indicating the
-* type of image to be written, or <code>null</code>.
+* type of image to be written, or {@code null}.
-* @param param the <code>ImageWriteParam</code> that will be used for
+* @param param the {@code ImageWriteParam} that will be used for
-* writing, or <code>null</code>.
+* writing, or {@code null}.
-* @param streamMetadata an <code>IIOMetadata</code> object that will
+* @param streamMetadata an {@code IIOMetadata} object that will
-* be used for writing, or <code>null</code>.
+* be used for writing, or {@code null}.
-* @param imageMetadata an <code>IIOMetadata</code> object that will
+* @param imageMetadata an {@code IIOMetadata} object that will
-* be used for writing, or <code>null</code>.
+* be used for writing, or {@code null}.
 *
-* @return an array of <code>Dimension</code>s with an even length
+* @return an array of {@code Dimension}s with an even length
-* of at least two, or <code>null</code>.
+* of at least two, or {@code null}.
 */
 public Dimension[] getPreferredThumbnailSizes(ImageTypeSpecifier imageType,
 ImageWriteParam param,
 IIOMetadata streamMetadata,
 IIOMetadata imageMetadata) {
 return null;
 }
 /**
-* Returns <code>true</code> if the methods that take an
+* Returns {@code true} if the methods that take an
-* <code>IIOImage</code> parameter are capable of dealing with a
+* {@code IIOImage} parameter are capable of dealing with a
-* <code>Raster</code> (as opposed to <code>RenderedImage</code>)
+* {@code Raster} (as opposed to {@code RenderedImage})
-* source image.  If this method returns <code>false</code>, then
+* source image.  If this method returns {@code false}, then
 * those methods will throw an
-* <code>UnsupportedOperationException</code> if supplied with an
+* {@code UnsupportedOperationException} if supplied with an
-* <code>IIOImage</code> containing a <code>Raster</code>.
+* {@code IIOImage} containing a {@code Raster}.
 *
-* <p> The default implementation returns <code>false</code>.
+* <p> The default implementation returns {@code false}.
 *
-* @return <code>true</code> if <code>Raster</code> sources are
+* @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</code>, its existing
+* 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</code> method.
+* {@code setOutput} method.
 *
 * <p> Stream metadata may optionally be supplied; if it is
-* <code>null</code>, default stream metadata will be used.
+* {@code null}, default stream metadata will be used.
 *
-* <p> If <code>canWriteRasters</code> returns <code>true</code>,
+* <p> If {@code canWriteRasters} returns {@code true},
-* the <code>IIOImage</code> may contain a <code>Raster</code>
+* the {@code IIOImage} may contain a {@code Raster}
 * source.  Otherwise, it must contain a
-* <code>RenderedImage</code> source.
+* {@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</code> may
+* <p>  An {@code ImageWriteParam} may
 * optionally be supplied to control the writing process.  If
-* <code>param</code> is <code>null</code>, a default write param
+* {@code param} is {@code null}, a default write param
 * will be used.
 *
-* <p> If the supplied <code>ImageWriteParam</code> contains
+* <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</code> object representing
+* @param streamMetadata an {@code IIOMetadata} object representing
-* stream metadata, or <code>null</code> to use default values.
+* stream metadata, or {@code null} to use default values.
-* @param image an <code>IIOImage</code> object containing an
+* @param image an {@code IIOImage} object containing an
 * image, thumbnails, and metadata to be written.
-* @param param an <code>ImageWriteParam</code>, or
+* @param param an {@code ImageWriteParam}, or
-* <code>null</code> to use a default
+* {@code null} to use a default
-* <code>ImageWriteParam</code>.
+* {@code ImageWriteParam}.
 *
 * @exception IllegalStateException if the output has not
 * been set.
-* @exception UnsupportedOperationException if <code>image</code>
+* @exception UnsupportedOperationException if {@code image}
-* contains a <code>Raster</code> and <code>canWriteRasters</code>
+* contains a {@code Raster} and {@code canWriteRasters}
-* returns <code>false</code>.
+* returns {@code false}.
-* @exception IllegalArgumentException if <code>image</code> is
+* @exception IllegalArgumentException if {@code image} is
-* <code>null</code>.
+* {@code null}.
 * @exception 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)</code>.
+* a shorthand for {@code write(null, image, null)}.
 *
-* @param image an <code>IIOImage</code> object containing an
+* @param image an {@code IIOImage} object containing an
 * image, thumbnails, and metadata to be written.
 *
 * @exception IllegalStateException if the output has not
 * been set.
-* @exception IllegalArgumentException if <code>image</code> is
+* @exception IllegalArgumentException if {@code image} is
-* <code>null</code>.
+* {@code null}.
-* @exception UnsupportedOperationException if <code>image</code>
+* @exception UnsupportedOperationException if {@code image}
-* contains a <code>Raster</code> and <code>canWriteRasters</code>
+* contains a {@code Raster} and {@code canWriteRasters}
-* returns <code>false</code>.
+* returns {@code false}.
 * @exception 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,
+* method is a shorthand for
-* null, null), null)</code>.
+* {@code write(null, new IIOImage(image, null, null), null)}.
 *
-* @param image a <code>RenderedImage</code> to be written.
+* @param image a {@code RenderedImage} to be written.
 *
 * @exception IllegalStateException if the output has not
 * been set.
-* @exception IllegalArgumentException if <code>image</code> is
+* @exception IllegalArgumentException if {@code image} is
-* <code>null</code>.
+* {@code null}.
 * @exception IOException if an error occurs during writing.
 */
 public void write(RenderedImage image) throws IOException {
 write(null, new IIOImage(image, null, null), null);
 }
 }
 // Sequence writes
 /**
-* Returns <code>true</code> if the writer is able to append an
+* 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</code> returns <code>false</code>,
+* <p> If {@code canWriteSequence} returns {@code false},
-* <code>writeToSequence</code> and <code>endWriteSequence</code>
+* {@code writeToSequence} and {@code endWriteSequence}
-* will throw an <code>UnsupportedOperationException</code>.
+* will throw an {@code UnsupportedOperationException}.
 *
-* <p> The default implementation returns <code>false</code>.
+* <p> The default implementation returns {@code false}.
 *
-* @return <code>true</code> if images may be appended sequentially.
+* @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</code> calls, using the provided stream
+* {@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</code>,
+* 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</code>, the existing
+* <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</code> be able to rewind to
+* 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</code> returns <code>false</code>,
+* <p> If {@code canWriteSequence} returns {@code false},
 * this method will throw an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * <p> The output must have been set beforehand using either
-* the <code>setOutput</code> method.
+* the {@code setOutput} method.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
-* @param streamMetadata A stream metadata object, or <code>null</code>.
+* @param streamMetadata A stream metadata object, or {@code null}.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if
-* <code>canWriteSequence</code> returns <code>false</code>.
+* {@code canWriteSequence} returns {@code false}.
 * @exception IOException if an error occurs writing the stream
 * metadata.
 */
 public void prepareWriteSequence(IIOMetadata streamMetadata)
 throws IOException {
 }
 /**
 * Appends a single image and possibly associated metadata and
 * thumbnails, to the output.  If the output is an
-* <code>ImageOutputStream</code>, the existing contents of the
+* {@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</code> is called (<i>e.g.</i> TIFF).
+* {@code endWriteSequence} is called (<i>e.g.</i> TIFF).
 *
-* <p> If <code>canWriteSequence</code> returns <code>false</code>,
+* <p> If {@code canWriteSequence} returns {@code false},
 * this method will throw an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * <p> The output must have been set beforehand using
-* the <code>setOutput</code> method.
+* the {@code setOutput} method.
 *
-* <p> <code>prepareWriteSequence</code> must have been called
+* <p> {@code prepareWriteSequence} must have been called
-* beforehand, or an <code>IllegalStateException</code> is thrown.
+* beforehand, or an {@code IllegalStateException} is thrown.
 *
-* <p> If <code>canWriteRasters</code> returns <code>true</code>,
+* <p> If {@code canWriteRasters} returns {@code true},
-* the <code>IIOImage</code> may contain a <code>Raster</code>
+* the {@code IIOImage} may contain a {@code Raster}
 * source.  Otherwise, it must contain a
-* <code>RenderedImage</code> source.
+* {@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</code> may optionally be supplied
+* <p> An {@code ImageWriteParam} may optionally be supplied
-* to control the writing process.  If <code>param</code> is
+* to control the writing process.  If {@code param} is
-* <code>null</code>, a default write param will be used.
+* {@code null}, a default write param will be used.
 *
-* <p> If the supplied <code>ImageWriteParam</code> contains
+* <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</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
-* @param image an <code>IIOImage</code> object containing an
+* @param image an {@code IIOImage} object containing an
 * image, thumbnails, and metadata to be written.
-* @param param an <code>ImageWriteParam</code>, or
+* @param param an {@code ImageWriteParam}, or
-* <code>null</code> to use a default
+* {@code null} to use a default
-* <code>ImageWriteParam</code>.
+* {@code ImageWriteParam}.
 *
 * @exception IllegalStateException if the output has not
-* been set, or <code>prepareWriteSequence</code> has not been called.
+* been set, or {@code prepareWriteSequence} has not been called.
 * @exception UnsupportedOperationException if
-* <code>canWriteSequence</code> returns <code>false</code>.
+* {@code canWriteSequence} returns {@code false}.
-* @exception IllegalArgumentException if <code>image</code> is
+* @exception IllegalArgumentException if {@code image} is
-* <code>null</code>.
+* {@code null}.
-* @exception UnsupportedOperationException if <code>image</code>
+* @exception UnsupportedOperationException if {@code image}
-* contains a <code>Raster</code> and <code>canWriteRasters</code>
+* contains a {@code Raster} and {@code canWriteRasters}
-* returns <code>false</code>.
+* returns {@code false}.
 * @exception 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</code>.  Any stream metadata that
+* {@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</code>, data through the stream metadata
+* {@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</code> returns <code>false</code>,
+* <p> If {@code canWriteSequence} returns {@code false},
 * this method will throw an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * @exception IllegalStateException if the output has not
-* been set, or <code>prepareWriteSequence</code> has not been called.
+* been set, or {@code prepareWriteSequence} has not been called.
 * @exception UnsupportedOperationException if
-* <code>canWriteSequence</code> returns <code>false</code>.
+* {@code canWriteSequence} returns {@code false}.
 * @exception IOException if an error occurs during writing.
 */
 public void endWriteSequence() throws IOException {
 unsupported();
 }
 // Metadata replacement
 /**
-* Returns <code>true</code> if it is possible to replace the
+* 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</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise returns <code>false</code>.
+* {@code null}, and otherwise returns {@code false}.
 *
-* @return <code>true</code> if replacement of stream metadata is
+* @return {@code true} if replacement of stream metadata is
 * allowed.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception IOException if an I/O error occurs during the query.
 }
 /**
 * Replaces the stream metadata in the output with new
 * information.  If the output is an
-* <code>ImageOutputStream</code>, the prior contents of the
+* {@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</code> returns
+* <p> If {@code canReplaceStreamMetadata} returns
-* <code>false</code>, an
+* {@code false}, an
-* <code>UnsupportedOperationException</code> will be thrown.
+* {@code UnsupportedOperationException} will be thrown.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
-* @param streamMetadata an <code>IIOMetadata</code> object representing
+* @param streamMetadata an {@code IIOMetadata} object representing
-* stream metadata, or <code>null</code> to use default values.
+* stream metadata, or {@code null} to use default values.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if the
-* <code>canReplaceStreamMetadata</code> returns
+* {@code canReplaceStreamMetadata} returns
-* <code>false</code>.  modes do not include
+* {@code false}.  modes do not include
 * @exception IOException if an error occurs during writing.
 */
 public void replaceStreamMetadata(IIOMetadata streamMetadata)
 throws IOException {
 unsupported();
 }
 /**
-* Returns <code>true</code> if it is possible to replace the
+* Returns {@code true} if it is possible to replace the
 * image metadata associated with an existing image with index
-* <code>imageIndex</code>.  If this method returns
+* {@code imageIndex}.  If this method returns
-* <code>false</code>, a call to
+* {@code false}, a call to
-* <code>replaceImageMetadata(imageIndex)</code> will throw an
+* {@code replaceImageMetadata(imageIndex)} will throw an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * <p> A writer that does not support any image metadata
-* replacement may return <code>false</code> without performing
+* replacement may return {@code false} without performing
 * bounds checking on the index.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise returns <code>false</code>
+* {@code null}, and otherwise returns {@code false}
-* without checking the value of <code>imageIndex</code>.
+* without checking the value of {@code imageIndex}.
 *
 * @param imageIndex the index of the image whose metadata is to
 * be replaced.
 *
-* @return <code>true</code> if the image metadata of the given
+* @return {@code true} if the image metadata of the given
 * image can be replaced.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception IndexOutOfBoundsException if the writer supports
 * image metadata replacement in general, but
-* <code>imageIndex</code> is less than 0 or greater than the
+* {@code imageIndex} is less than 0 or greater than the
 * largest available index.
 * @exception IOException if an I/O error occurs during the query.
 */
 public boolean canReplaceImageMetadata(int imageIndex)
 throws IOException {
 }
 /**
 * Replaces the image metadata associated with an existing image.
 *
-* <p> If <code>canReplaceImageMetadata(imageIndex)</code> returns
+* <p> If {@code canReplaceImageMetadata(imageIndex)} returns
-* <code>false</code>, an
+* {@code false}, an
-* <code>UnsupportedOperationException</code> will be thrown.
+* {@code UnsupportedOperationException} will be thrown.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * @param imageIndex the index of the image whose metadata is to
 * be replaced.
-* @param imageMetadata an <code>IIOMetadata</code> object
+* @param imageMetadata an {@code IIOMetadata} object
-* representing image metadata, or <code>null</code>.
+* representing image metadata, or {@code null}.
 *
 * @exception IllegalStateException if the output has not been
 * set.
 * @exception UnsupportedOperationException if
-* <code>canReplaceImageMetadata</code> returns
+* {@code canReplaceImageMetadata} returns
-* <code>false</code>.
+* {@code false}.
-* @exception IndexOutOfBoundsException if <code>imageIndex</code>
+* @exception IndexOutOfBoundsException if {@code imageIndex}
 * is less than 0 or greater than the largest available index.
 * @exception IOException if an error occurs during writing.
 */
 public void replaceImageMetadata(int imageIndex,
 IIOMetadata imageMetadata)
 }
 // Image insertion
 /**
-* Returns <code>true</code> if the writer supports the 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</code> of <code>-1</code> may be used to
+* {@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</code> without performing bounds checking on
+* return {@code false} without performing bounds checking on
 * the index.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise returns <code>false</code>
+* {@code null}, and otherwise returns {@code false}
-* without checking the value of <code>imageIndex</code>.
+* without checking the value of {@code imageIndex}.
 *
 * @param imageIndex the index at which the image is to be
 * inserted.
 *
-* @return <code>true</code> if an image may be inserted at the
+* @return {@code true} if an image may be inserted at the
 * given index.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception IndexOutOfBoundsException if the writer supports
-* image insertion in general, but <code>imageIndex</code> is less
+* image insertion in general, but {@code imageIndex} is less
 * than -1 or greater than the largest available index.
 * @exception IOException if an I/O error occurs during the query.
 */
 public boolean canInsertImage(int imageIndex) throws IOException {
 if (getOutput() == null) {
 return false;
 }
 /**
 * Inserts a new image into an existing image stream.  Existing
-* images with an index greater than <code>imageIndex</code> are
+* images with an index greater than {@code imageIndex} are
 * preserved, and their indices are each increased by 1.  A value
-* for <code>imageIndex</code> of -1 may be used to signify an
+* 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</code>,
+* sequence.  If the output is an {@code ImageOutputStream},
 * the entirety of the stream must be both readable and writeable.
 *
-* <p> If <code>canInsertImage(imageIndex)</code> returns
+* <p> If {@code canInsertImage(imageIndex)} returns
-* <code>false</code>, an
+* {@code false}, an
-* <code>UnsupportedOperationException</code> will be thrown.
+* {@code UnsupportedOperationException} will be thrown.
 *
-* <p> An <code>ImageWriteParam</code> may optionally be supplied
+* <p> An {@code ImageWriteParam} may optionally be supplied
-* to control the writing process.  If <code>param</code> is
+* to control the writing process.  If {@code param} is
-* <code>null</code>, a default write param will be used.
+* {@code null}, a default write param will be used.
 *
-* <p> If the supplied <code>ImageWriteParam</code> contains
+* <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</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * @param imageIndex the index at which to write the image.
-* @param image an <code>IIOImage</code> object containing an
+* @param image an {@code IIOImage} object containing an
 * image, thumbnails, and metadata to be written.
-* @param param an <code>ImageWriteParam</code>, or
+* @param param an {@code ImageWriteParam}, or
-* <code>null</code> to use a default
+* {@code null} to use a default
-* <code>ImageWriteParam</code>.
+* {@code ImageWriteParam}.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if
-* <code>canInsertImage(imageIndex)</code> returns <code>false</code>.
+* {@code canInsertImage(imageIndex)} returns {@code false}.
-* @exception IllegalArgumentException if <code>image</code> is
+* @exception IllegalArgumentException if {@code image} is
-* <code>null</code>.
+* {@code null}.
-* @exception IndexOutOfBoundsException if <code>imageIndex</code>
+* @exception IndexOutOfBoundsException if {@code imageIndex}
 * is less than -1 or greater than the largest available index.
-* @exception UnsupportedOperationException if <code>image</code>
+* @exception UnsupportedOperationException if {@code image}
-* contains a <code>Raster</code> and <code>canWriteRasters</code>
+* contains a {@code Raster} and {@code canWriteRasters}
-* returns <code>false</code>.
+* returns {@code false}.
 * @exception IOException if an error occurs during writing.
 */
 public void writeInsert(int imageIndex,
 IIOImage image,
 ImageWriteParam param) throws IOException {
 }
 // Image removal
 /**
-* Returns <code>true</code> if the writer supports the 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</code> without performing bounds checking on
+* return {@code false} without performing bounds checking on
 * the index.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise returns <code>false</code>
+* {@code null}, and otherwise returns {@code false}
-* without checking the value of <code>imageIndex</code>.
+* without checking the value of {@code imageIndex}.
 *
 * @param imageIndex the index of the image to be removed.
 *
-* @return <code>true</code> if it is possible to remove the given
+* @return {@code true} if it is possible to remove the given
 * image.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception IndexOutOfBoundsException if the writer supports
-* image removal in general, but <code>imageIndex</code> is less
+* image removal in general, but {@code imageIndex} is less
 * than 0 or greater than the largest available index.
 * @exception IOException if an I/O error occurs during the
 * query.
 */
 public boolean canRemoveImage(int imageIndex) throws IOException {
 }
 /**
 * Removes an image from the stream.
 *
-* <p> If <code>canRemoveImage(imageIndex)</code> returns false,
+* <p> If {@code canRemoveImage(imageIndex)} returns false,
-* an <code>UnsupportedOperationException</code>will be thrown.
+* 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</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * @param imageIndex the index of the image to be removed.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if
-* <code>canRemoveImage(imageIndex)</code> returns <code>false</code>.
+* {@code canRemoveImage(imageIndex)} returns {@code false}.
-* @exception IndexOutOfBoundsException if <code>imageIndex</code>
+* @exception IndexOutOfBoundsException if {@code imageIndex}
 * is less than 0 or greater than the largest available index.
 * @exception IOException if an I/O error occurs during the
 * removal.
 */
 public void removeImage(int imageIndex) throws IOException {
 }
 // Empty images
 /**
-* Returns <code>true</code> if the writer supports the writing of
+* 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</code> methods.  If the output
+* calls to the {@code replacePixels} methods.  If the output
-* is an <code>ImageOutputStream</code>, its existing contents
+* 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</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise returns <code>false</code>.
+* {@code null}, and otherwise returns {@code false}.
 *
-* @return <code>true</code> if the writing of complete image
+* @return {@code true} if the writing of complete image
 * stream with contents to be defined later is supported.
 *
 * @exception IllegalStateException if the output has not been
 * set.
 * @exception IOException if an I/O error occurs during the
 /**
 * 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</code>
+* be defined by future calls to the {@code replacePixels}
-* methods.  If the output is an <code>ImageOutputStream</code>,
+* 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</code> occurs.  Calls to
+* {@code endWriteEmpty} occurs.  Calls to
-* <code>prepareReplacePixels</code>, <code>replacePixels</code>,
+* {@code prepareReplacePixels}, {@code replacePixels},
-* and <code>endReplacePixels</code> may occur between calls to
+* and {@code endReplacePixels} may occur between calls to
-* <code>prepareWriteEmpty</code> and <code>endWriteEmpty</code>.
+* {@code prepareWriteEmpty} and {@code endWriteEmpty}.
-* However, calls to <code>prepareWriteEmpty</code> cannot be
+* However, calls to {@code prepareWriteEmpty} cannot be
-* nested, and calls to <code>prepareWriteEmpty</code> and
+* nested, and calls to {@code prepareWriteEmpty} and
-* <code>prepareInsertEmpty</code> may not be interspersed.
+* {@code prepareInsertEmpty} may not be interspersed.
 *
-* <p> If <code>canWriteEmpty</code> returns <code>false</code>,
+* <p> If {@code canWriteEmpty} returns {@code false},
-* an <code>UnsupportedOperationException</code> will be thrown.
+* an {@code UnsupportedOperationException} will be thrown.
 *
-* <p> An <code>ImageWriteParam</code> may optionally be supplied
+* <p> An {@code ImageWriteParam} may optionally be supplied
-* to control the writing process.  If <code>param</code> is
+* to control the writing process.  If {@code param} is
-* <code>null</code>, a default write param will be used.
+* {@code null}, a default write param will be used.
 *
-* <p> If the supplied <code>ImageWriteParam</code> contains
+* <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</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
-* @param streamMetadata an <code>IIOMetadata</code> object representing
+* @param streamMetadata an {@code IIOMetadata} object representing
-* stream metadata, or <code>null</code> to use default values.
+* stream metadata, or {@code null} to use default values.
-* @param imageType an <code>ImageTypeSpecifier</code> describing
+* @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</code> object
+* @param imageMetadata an {@code IIOMetadata} object
-* representing image metadata, or <code>null</code>.
+* representing image metadata, or {@code null}.
-* @param thumbnails a <code>List</code> of
+* @param thumbnails a {@code List} of
-* <code>BufferedImage</code> thumbnails for this image, or
+* {@code BufferedImage} thumbnails for this image, or
-* <code>null</code>.
+* {@code null}.
-* @param param an <code>ImageWriteParam</code>, or
+* @param param an {@code ImageWriteParam}, or
-* <code>null</code> to use a default
+* {@code null} to use a default
-* <code>ImageWriteParam</code>.
+* {@code ImageWriteParam}.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if
-* <code>canWriteEmpty</code> returns <code>false</code>.
+* {@code canWriteEmpty} returns {@code false}.
 * @exception IllegalStateException if a previous call to
-* <code>prepareWriteEmpty</code> has been made without a
+* {@code prepareWriteEmpty} has been made without a
-* corresponding call to <code>endWriteEmpty</code>.
+* corresponding call to {@code endWriteEmpty}.
 * @exception IllegalStateException if a previous call to
-* <code>prepareInsertEmpty</code> has been made without a
+* {@code prepareInsertEmpty} has been made without a
-* corresponding call to <code>endInsertEmpty</code>.
+* corresponding call to {@code endInsertEmpty}.
-* @exception IllegalArgumentException if <code>imageType</code>
+* @exception IllegalArgumentException if {@code imageType}
-* is <code>null</code> or <code>thumbnails</code> contains
+* is {@code null} or {@code thumbnails} contains
-* <code>null</code> references or objects other than
+* {@code null} references or objects other than
-* <code>BufferedImage</code>s.
+* {@code BufferedImage}s.
 * @exception IllegalArgumentException if width or height are less
 * than 1.
 * @exception IOException if an I/O error occurs during writing.
 */
 public void prepareWriteEmpty(IIOMetadata streamMetadata,
 unsupported();
 }
 /**
 * Completes the writing of a new image that was begun with a
-* prior call to <code>prepareWriteEmpty</code>.
+* prior call to {@code prepareWriteEmpty}.
 *
-* <p> If <code>canWriteEmpty()</code> returns <code>false</code>,
+* <p> If {@code canWriteEmpty()} returns {@code false},
-* an <code>UnsupportedOperationException</code> will be thrown.
+* an {@code UnsupportedOperationException} will be thrown.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if
-* <code>canWriteEmpty(imageIndex)</code> returns
+* {@code canWriteEmpty(imageIndex)} returns
-* <code>false</code>.
+* {@code false}.
 * @exception IllegalStateException if a previous call to
-* <code>prepareWriteEmpty</code> without a corresponding call to
+* {@code prepareWriteEmpty} without a corresponding call to
-* <code>endWriteEmpty</code> has not been made.
+* {@code endWriteEmpty} has not been made.
 * @exception IllegalStateException if a previous call to
-* <code>prepareInsertEmpty</code> without a corresponding call to
+* {@code prepareInsertEmpty} without a corresponding call to
-* <code>endInsertEmpty</code> has been made.
+* {@code endInsertEmpty} has been made.
 * @exception IllegalStateException if a call to
-* <code>prepareReiplacePixels</code> has been made without a
+* {@code prepareReiplacePixels} has been made without a
-* matching call to <code>endReplacePixels</code>.
+* matching call to {@code endReplacePixels}.
 * @exception 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</code> if the writer supports the insertion
+* 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</code> methods.  Existing images with
+* 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</code> of <code>-1</code> may be used to
+* {@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</code> without performing bounds
+* may return {@code false} without performing bounds
 * checking on the index.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise returns <code>false</code>
+* {@code null}, and otherwise returns {@code false}
-* without checking the value of <code>imageIndex</code>.
+* without checking the value of {@code imageIndex}.
 *
 * @param imageIndex the index at which the image is to be
 * inserted.
 *
-* @return <code>true</code> if an empty image may be inserted at
+* @return {@code true} if an empty image may be inserted at
 * the given index.
 *
 * @exception IllegalStateException if the output has not been
 * set.
 * @exception IndexOutOfBoundsException if the writer supports
-* empty image insertion in general, but <code>imageIndex</code>
+* empty image insertion in general, but {@code imageIndex}
 * is less than -1 or greater than the largest available index.
 * @exception IOException if an I/O error occurs during the
 * query.
 */
 public boolean canInsertEmpty(int imageIndex) throws IOException {
 }
 /**
 * 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</code> are preserved, and their
+* greater than {@code imageIndex} are preserved, and their
 * indices are each increased by 1.  A value for
-* <code>imageIndex</code> of -1 may be used to signify an index
+* {@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</code>,
+* 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</code> method.
+* supplied later using the {@code replacePixels} method.
 * The insertion is not complete until a call to
-* <code>endInsertEmpty</code> occurs.  Calls to
+* {@code endInsertEmpty} occurs.  Calls to
-* <code>prepareReplacePixels</code>, <code>replacePixels</code>,
+* {@code prepareReplacePixels}, {@code replacePixels},
-* and <code>endReplacePixels</code> may occur between calls to
+* and {@code endReplacePixels} may occur between calls to
-* <code>prepareInsertEmpty</code> and
+* {@code prepareInsertEmpty} and
-* <code>endInsertEmpty</code>.  However, calls to
+* {@code endInsertEmpty}.  However, calls to
-* <code>prepareInsertEmpty</code> cannot be nested, and calls to
+* {@code prepareInsertEmpty} cannot be nested, and calls to
-* <code>prepareWriteEmpty</code> and
+* {@code prepareWriteEmpty} and
-* <code>prepareInsertEmpty</code> may not be interspersed.
+* {@code prepareInsertEmpty} may not be interspersed.
 *
-* <p> If <code>canInsertEmpty(imageIndex)</code> returns
+* <p> If {@code canInsertEmpty(imageIndex)} returns
-* <code>false</code>, an
+* {@code false}, an
-* <code>UnsupportedOperationException</code> will be thrown.
+* {@code UnsupportedOperationException} will be thrown.
 *
-* <p> An <code>ImageWriteParam</code> may optionally be supplied
+* <p> An {@code ImageWriteParam} may optionally be supplied
-* to control the writing process.  If <code>param</code> is
+* to control the writing process.  If {@code param} is
-* <code>null</code>, a default write param will be used.
+* {@code null}, a default write param will be used.
 *
-* <p> If the supplied <code>ImageWriteParam</code> contains
+* <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</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * @param imageIndex the index at which to write the image.
-* @param imageType an <code>ImageTypeSpecifier</code> describing
+* @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</code> object
+* @param imageMetadata an {@code IIOMetadata} object
-* representing image metadata, or <code>null</code>.
+* representing image metadata, or {@code null}.
-* @param thumbnails a <code>List</code> of
+* @param thumbnails a {@code List} of
-* <code>BufferedImage</code> thumbnails for this image, or
+* {@code BufferedImage} thumbnails for this image, or
-* <code>null</code>.
+* {@code null}.
-* @param param an <code>ImageWriteParam</code>, or
+* @param param an {@code ImageWriteParam}, or
-* <code>null</code> to use a default
+* {@code null} to use a default
-* <code>ImageWriteParam</code>.
+* {@code ImageWriteParam}.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if
-* <code>canInsertEmpty(imageIndex)</code> returns
+* {@code canInsertEmpty(imageIndex)} returns
-* <code>false</code>.
+* {@code false}.
-* @exception IndexOutOfBoundsException if <code>imageIndex</code>
+* @exception IndexOutOfBoundsException if {@code imageIndex}
 * is less than -1 or greater than the largest available index.
 * @exception IllegalStateException if a previous call to
-* <code>prepareInsertEmpty</code> has been made without a
+* {@code prepareInsertEmpty} has been made without a
-* corresponding call to <code>endInsertEmpty</code>.
+* corresponding call to {@code endInsertEmpty}.
 * @exception IllegalStateException if a previous call to
-* <code>prepareWriteEmpty</code> has been made without a
+* {@code prepareWriteEmpty} has been made without a
-* corresponding call to <code>endWriteEmpty</code>.
+* corresponding call to {@code endWriteEmpty}.
-* @exception IllegalArgumentException if <code>imageType</code>
+* @exception IllegalArgumentException if {@code imageType}
-* is <code>null</code> or <code>thumbnails</code> contains
+* is {@code null} or {@code thumbnails} contains
-* <code>null</code> references or objects other than
+* {@code null} references or objects other than
-* <code>BufferedImage</code>s.
+* {@code BufferedImage}s.
 * @exception IllegalArgumentException if width or height are less
 * than 1.
 * @exception IOException if an I/O error occurs during writing.
 */
 public void prepareInsertEmpty(int imageIndex,
 unsupported();
 }
 /**
 * Completes the insertion of a new image that was begun with a
-* prior call to <code>prepareInsertEmpty</code>.
+* prior call to {@code prepareInsertEmpty}.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if
-* <code>canInsertEmpty(imageIndex)</code> returns
+* {@code canInsertEmpty(imageIndex)} returns
-* <code>false</code>.
+* {@code false}.
 * @exception IllegalStateException if a previous call to
-* <code>prepareInsertEmpty</code> without a corresponding call to
+* {@code prepareInsertEmpty} without a corresponding call to
-* <code>endInsertEmpty</code> has not been made.
+* {@code endInsertEmpty} has not been made.
 * @exception IllegalStateException if a previous call to
-* <code>prepareWriteEmpty</code> without a corresponding call to
+* {@code prepareWriteEmpty} without a corresponding call to
-* <code>endWriteEmpty</code> has been made.
+* {@code endWriteEmpty} has been made.
 * @exception IllegalStateException if a call to
-* <code>prepareReplacePixels</code> has been made without a
+* {@code prepareReplacePixels} has been made without a
-* matching call to <code>endReplacePixels</code>.
+* matching call to {@code endReplacePixels}.
 * @exception IOException if an I/O error occurs during writing.
 */
 public void endInsertEmpty() throws IOException {
 unsupported();
 }
 // Pixel replacement
 /**
-* Returns <code>true</code> if the writer allows pixels of the
+* Returns {@code true} if the writer allows pixels of the
-* given image to be replaced using the <code>replacePixels</code>
+* given image to be replaced using the {@code replacePixels}
 * methods.
 *
 * <p> A writer that does not support any pixel replacement may
-* return <code>false</code> without performing bounds checking on
+* return {@code false} without performing bounds checking on
 * the index.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise returns <code>false</code>
+* {@code null}, and otherwise returns {@code false}
-* without checking the value of <code>imageIndex</code>.
+* without checking the value of {@code imageIndex}.
 *
 * @param imageIndex the index of the image whose pixels are to be
 * replaced.
 *
-* @return <code>true</code> if the pixels of the given
+* @return {@code true} if the pixels of the given
 * image can be replaced.
 *
 * @exception IllegalStateException if the output has not been
 * set.
 * @exception IndexOutOfBoundsException if the writer supports
-* pixel replacement in general, but <code>imageIndex</code> is
+* pixel replacement in general, but {@code imageIndex} is
 * less than 0 or greater than the largest available index.
 * @exception IOException if an I/O error occurs during the query.
 */
 public boolean canReplacePixels(int imageIndex) throws IOException {
 if (getOutput() == null) {
 return false;
 }
 /**
 * Prepares the writer to handle a series of calls to the
-* <code>replacePixels</code> methods.  The affected pixel area
+* {@code replacePixels} methods.  The affected pixel area
 * will be clipped against the supplied
 *
-* <p> If <code>canReplacePixels</code> returns
+* <p> If {@code canReplacePixels} returns
-* <code>false</code>, and
+* {@code false}, and
-* <code>UnsupportedOperationException</code> will be thrown.
+* {@code UnsupportedOperationException} will be thrown.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * @param imageIndex the index of the image whose pixels are to be
 * replaced.
-* @param region a <code>Rectangle</code> that will be used to clip
+* @param region a {@code Rectangle} that will be used to clip
 * future pixel regions.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if
-* <code>canReplacePixels(imageIndex)</code> returns
+* {@code canReplacePixels(imageIndex)} returns
-* <code>false</code>.
+* {@code false}.
-* @exception IndexOutOfBoundsException if <code>imageIndex</code>
+* @exception IndexOutOfBoundsException if {@code imageIndex}
 * is less than 0 or greater than the largest available index.
 * @exception IllegalStateException if there is a previous call to
-* <code>prepareReplacePixels</code> without a matching call to
+* {@code prepareReplacePixels} without a matching call to
-* <code>endReplacePixels</code> (<i>i.e.</i>, nesting is not
+* {@code endReplacePixels} (<i>i.e.</i>, nesting is not
 * allowed).
-* @exception IllegalArgumentException if <code>region</code> is
+* @exception IllegalArgumentException if {@code region} is
-* <code>null</code> or has a width or height less than 1.
+* {@code null} or has a width or height less than 1.
 * @exception IOException if an I/O error occurs during the
 * preparation.
 */
 public void prepareReplacePixels(int imageIndex,
 Rectangle region)  throws IOException {
 * 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</code> argument, and will be clipped to the image
+* {@code param} argument, and will be clipped to the image
 * boundaries and the region supplied to
-* <code>prepareReplacePixels</code>.  At least one pixel of the
+* {@code prepareReplacePixels}.  At least one pixel of the
 * source must not be clipped, or an exception is thrown.
 *
-* <p> An <code>ImageWriteParam</code> may optionally be supplied
+* <p> An {@code ImageWriteParam} may optionally be supplied
-* to control the writing process.  If <code>param</code> is
+* to control the writing process.  If {@code param} is
-* <code>null</code>, a default write param will be used.
+* {@code null}, a default write param will be used.
 *
-* <p> If the supplied <code>ImageWriteParam</code> contains
+* <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</code>, or else an
+* {@code prepareReplacePixels}, or else an
-* <code>IllegalStateException</code> will be thrown.
+* {@code IllegalStateException} will be thrown.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
-* @param image a <code>RenderedImage</code> containing source
+* @param image a {@code RenderedImage} containing source
 * pixels.
-* @param param an <code>ImageWriteParam</code>, or
+* @param param an {@code ImageWriteParam}, or
-* <code>null</code> to use a default
+* {@code null} to use a default
-* <code>ImageWriteParam</code>.
+* {@code ImageWriteParam}.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if
-* <code>canReplacePixels(imageIndex)</code> returns
+* {@code canReplacePixels(imageIndex)} returns
-* <code>false</code>.
+* {@code false}.
 * @exception IllegalStateException if there is no previous call to
-* <code>prepareReplacePixels</code> without a matching call to
+* {@code prepareReplacePixels} without a matching call to
-* <code>endReplacePixels</code>.
+* {@code endReplacePixels}.
 * @exception IllegalArgumentException if any of the following are true:
 * <ul>
-* <li> <code>image</code> is <code>null</code>.
+* <li> {@code image} is {@code null}.
-* <li> <code>param</code> is <code>null</code>.
+* <li> {@code param} is {@code null}.
 * <li> the intersected region does not contain at least one pixel.
-* <li> the layout of <code>image</code> does not match, or this
+* <li> the layout of {@code image} does not match, or this
 * writer cannot convert it to, the existing image layout.
 * </ul>
 * @exception IOException if an I/O error occurs during writing.
 */
 public void replacePixels(RenderedImage image, ImageWriteParam param)
 unsupported();
 }
 /**
 * Replaces a portion of an image already present in the output
-* with a portion of the given <code>Raster</code>.  The image
+* 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</code> may optionally be supplied
+* <p> An {@code ImageWriteParam} may optionally be supplied
-* to control the writing process.  If <code>param</code> is
+* to control the writing process.  If {@code param} is
-* <code>null</code>, a default write param will be used.
+* {@code null}, a default write param will be used.
 *
 * <p> The destination region is specified in the
-* <code>param</code> argument, and will be clipped to the image
+* {@code param} argument, and will be clipped to the image
 * boundaries and the region supplied to
-* <code>prepareReplacePixels</code>.  At least one pixel of the
+* {@code prepareReplacePixels}.  At least one pixel of the
 * source must not be clipped, or an exception is thrown.
 *
-* <p> If the supplied <code>ImageWriteParam</code> contains
+* <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</code>, or else an
+* {@code prepareReplacePixels}, or else an
-* <code>IllegalStateException</code> will be thrown.
+* {@code IllegalStateException} will be thrown.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
-* @param raster a <code>Raster</code> containing source
+* @param raster a {@code Raster} containing source
 * pixels.
-* @param param an <code>ImageWriteParam</code>, or
+* @param param an {@code ImageWriteParam}, or
-* <code>null</code> to use a default
+* {@code null} to use a default
-* <code>ImageWriteParam</code>.
+* {@code ImageWriteParam}.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if
-* <code>canReplacePixels(imageIndex)</code> returns
+* {@code canReplacePixels(imageIndex)} returns
-* <code>false</code>.
+* {@code false}.
 * @exception IllegalStateException if there is no previous call to
-* <code>prepareReplacePixels</code> without a matching call to
+* {@code prepareReplacePixels} without a matching call to
-* <code>endReplacePixels</code>.
+* {@code endReplacePixels}.
 * @exception UnsupportedOperationException if
-* <code>canWriteRasters</code> returns <code>false</code>.
+* {@code canWriteRasters} returns {@code false}.
 * @exception IllegalArgumentException if any of the following are true:
 * <ul>
-* <li> <code>raster</code> is <code>null</code>.
+* <li> {@code raster} is {@code null}.
-* <li> <code>param</code> is <code>null</code>.
+* <li> {@code param} is {@code null}.
 * <li> the intersected region does not contain at least one pixel.
-* <li> the layout of <code>raster</code> does not match, or this
+* <li> the layout of {@code raster} does not match, or this
 * writer cannot convert it to, the existing image layout.
 * </ul>
 * @exception 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</code>.
+* Terminates a sequence of calls to {@code replacePixels}.
 *
-* <p> If <code>canReplacePixels</code> returns
+* <p> If {@code canReplacePixels} returns
-* <code>false</code>, and
+* {@code false}, and
-* <code>UnsupportedOperationException</code> will be thrown.
+* {@code UnsupportedOperationException} will be thrown.
 *
 * <p> The default implementation throws an
-* <code>IllegalStateException</code> if the output is
+* {@code IllegalStateException} if the output is
-* <code>null</code>, and otherwise throws an
+* {@code null}, and otherwise throws an
-* <code>UnsupportedOperationException</code>.
+* {@code UnsupportedOperationException}.
 *
 * @exception IllegalStateException if the output has not
 * been set.
 * @exception UnsupportedOperationException if
-* <code>canReplacePixels(imageIndex)</code> returns
+* {@code canReplacePixels(imageIndex)} returns
-* <code>false</code>.
+* {@code false}.
 * @exception IllegalStateException if there is no previous call
-* to <code>prepareReplacePixels</code> without a matching call to
+* to {@code prepareReplacePixels} without a matching call to
-* <code>endReplacePixels</code>.
+* {@code endReplacePixels}.
 * @exception IOException if an I/O error occurs during writing.
 */
 public void endReplacePixels() throws IOException {
 unsupported();
 }
 /**
 * 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</code> at the
+* <p> Writers should call {@code clearAbortRequest} at the
 * beginning of each write operation, and poll the value of
-* <code>abortRequested</code> regularly during the write.
+* {@code abortRequested} regularly during the write.
 */
 public synchronized void abort() {
 this.abortFlag = true;
 }
 /**
-* Returns <code>true</code> if a request to abort the current
+* Returns {@code true} if a request to abort the current
 * write operation has been made since the writer was instantiated or
-* <code>clearAbortRequest</code> was called.
+* {@code clearAbortRequest} was called.
 *
-* @return <code>true</code> if the current write operation should
+* @return {@code true} if the current write operation should
 * be aborted.
 *
 * @see #abort
 * @see #clearAbortRequest
 */
 return this.abortFlag;
 }
 /**
 * Clears any previous abort request.  After this method has been
-* called, <code>abortRequested</code> will return
+* called, {@code abortRequested} will return
-* <code>false</code>.
+* {@code false}.
 *
 * @see #abort
 * @see #abortRequested
 */
 protected synchronized void clearAbortRequest() {
 }
 // Listeners
 /**
-* Adds an <code>IIOWriteWarningListener</code> to the list of
+* Adds an {@code IIOWriteWarningListener} to the list of
-* registered warning listeners.  If <code>listener</code> is
+* registered warning listeners.  If {@code listener} is
-* <code>null</code>, no exception will be thrown and no action
+* {@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</code>.  If no <code>Locale</code> has been set,
+* {@code Locale}.  If no {@code Locale} has been set,
 * warning messages may be localized as the writer sees fit.
 *
-* @param listener an <code>IIOWriteWarningListener</code> to be
+* @param listener an {@code IIOWriteWarningListener} to be
 * registered.
 *
 * @see #removeIIOWriteWarningListener
 */
 public void addIIOWriteWarningListener(IIOWriteWarningListener listener) {
 warningListeners = ImageReader.addToList(warningListeners, listener);
 warningLocales = ImageReader.addToList(warningLocales, getLocale());
 }
 /**
-* Removes an <code>IIOWriteWarningListener</code> from the list
+* Removes an {@code IIOWriteWarningListener} from the list
 * of registered warning listeners.  If the listener was not
-* previously registered, or if <code>listener</code> is
+* previously registered, or if {@code listener} is
-* <code>null</code>, no exception will be thrown and no action
+* {@code null}, no exception will be thrown and no action
 * will be taken.
 *
-* @param listener an <code>IIOWriteWarningListener</code> to be
+* @param listener an {@code IIOWriteWarningListener} to be
 * deregistered.
 *
 * @see #addIIOWriteWarningListener
 */
 public
 }
 }
 /**
 * Removes all currently registered
-* <code>IIOWriteWarningListener</code> objects.
+* {@code IIOWriteWarningListener} objects.
 *
 * <p> The default implementation sets the
-* <code>warningListeners</code> and <code>warningLocales</code>
+* {@code warningListeners} and {@code warningLocales}
-* instance variables to <code>null</code>.
+* instance variables to {@code null}.
 */
 public void removeAllIIOWriteWarningListeners() {
 this.warningListeners = null;
 this.warningLocales = null;
 }
 /**
-* Adds an <code>IIOWriteProgressListener</code> to the list of
+* Adds an {@code IIOWriteProgressListener} to the list of
-* registered progress listeners.  If <code>listener</code> is
+* registered progress listeners.  If {@code listener} is
-* <code>null</code>, no exception will be thrown and no action
+* {@code null}, no exception will be thrown and no action
 * will be taken.
 *
-* @param listener an <code>IIOWriteProgressListener</code> to be
+* @param listener an {@code IIOWriteProgressListener} to be
 * registered.
 *
 * @see #removeIIOWriteProgressListener
 */
 public void
 }
 progressListeners = ImageReader.addToList(progressListeners, listener);
 }
 /**
-* Removes an <code>IIOWriteProgressListener</code> from the list
+* Removes an {@code IIOWriteProgressListener} from the list
 * of registered progress listeners.  If the listener was not
-* previously registered, or if <code>listener</code> is
+* previously registered, or if {@code listener} is
-* <code>null</code>, no exception will be thrown and no action
+* {@code null}, no exception will be thrown and no action
 * will be taken.
 *
-* @param listener an <code>IIOWriteProgressListener</code> to be
+* @param listener an {@code IIOWriteProgressListener} to be
 * deregistered.
 *
 * @see #addIIOWriteProgressListener
 */
 public void
 ImageReader.removeFromList(progressListeners, listener);
 }
 /**
 * Removes all currently registered
-* <code>IIOWriteProgressListener</code> objects.
+* {@code IIOWriteProgressListener} objects.
 *
 * <p> The default implementation sets the
-* <code>progressListeners</code> instance variable to
+* {@code progressListeners} instance variable to
-* <code>null</code>.
+* {@code null}.
 */
 public void removeAllIIOWriteProgressListeners() {
 this.progressListeners = null;
 }
 /**
 * Broadcasts the start of an image write to all registered
-* <code>IIOWriteProgressListener</code>s by calling their
+* {@code IIOWriteProgressListener}s by calling their
-* <code>imageStarted</code> method.  Subclasses may use this
+* {@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) {
 }
 }
 /**
 * Broadcasts the current percentage of image completion to all
-* registered <code>IIOWriteProgressListener</code>s by calling
+* registered {@code IIOWriteProgressListener}s by calling
-* their <code>imageProgress</code> method.  Subclasses may use
+* their {@code imageProgress} method.  Subclasses may use
 * this method as a convenience.
 *
 * @param percentageDone the current percentage of completion,
-* as a <code>float</code>.
+* as a {@code float}.
 */
 protected void processImageProgress(float percentageDone) {
 if (progressListeners == null) {
 return;
 }
 }
 }
 /**
 * Broadcasts the completion of an image write to all registered
-* <code>IIOWriteProgressListener</code>s by calling their
+* {@code IIOWriteProgressListener}s by calling their
-* <code>imageComplete</code> method.  Subclasses may use this
+* {@code imageComplete} method.  Subclasses may use this
 * method as a convenience.
 */
 protected void processImageComplete() {
 if (progressListeners == null) {
 return;
 }
 }
 /**
 * Broadcasts the start of a thumbnail write to all registered
-* <code>IIOWriteProgressListener</code>s by calling their
+* {@code IIOWriteProgressListener}s by calling their
-* <code>thumbnailStarted</code> method.  Subclasses may use this
+* {@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.
 }
 }
 /**
 * Broadcasts the current percentage of thumbnail completion to
-* all registered <code>IIOWriteProgressListener</code>s by calling
+* all registered {@code IIOWriteProgressListener}s by calling
-* their <code>thumbnailProgress</code> method.  Subclasses may
+* their {@code thumbnailProgress} method.  Subclasses may
 * use this method as a convenience.
 *
 * @param percentageDone the current percentage of completion,
-* as a <code>float</code>.
+* as a {@code float}.
 */
 protected void processThumbnailProgress(float percentageDone) {
 if (progressListeners == null) {
 return;
 }
 }
 }
 /**
 * Broadcasts the completion of a thumbnail write to all registered
-* <code>IIOWriteProgressListener</code>s by calling their
+* {@code IIOWriteProgressListener}s by calling their
-* <code>thumbnailComplete</code> method.  Subclasses may use this
+* {@code thumbnailComplete} method.  Subclasses may use this
 * method as a convenience.
 */
 protected void processThumbnailComplete() {
 if (progressListeners == null) {
 return;
 }
 }
 /**
 * Broadcasts that the write has been aborted to all registered
-* <code>IIOWriteProgressListener</code>s by calling their
+* {@code IIOWriteProgressListener}s by calling their
-* <code>writeAborted</code> method.  Subclasses may use this
+* {@code writeAborted} method.  Subclasses may use this
 * method as a convenience.
 */
 protected void processWriteAborted() {
 if (progressListeners == null) {
 return;
 }
 }
 /**
 * Broadcasts a warning message to all registered
-* <code>IIOWriteWarningListener</code>s by calling their
+* {@code IIOWriteWarningListener}s by calling their
-* <code>warningOccurred</code> method.  Subclasses may use this
+* {@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.
 *
-* @exception IllegalArgumentException if <code>warning</code>
+* @exception IllegalArgumentException if {@code warning}
-* is <code>null</code>.
+* is {@code null}.
 */
 protected void processWarningOccurred(int imageIndex,
 String warning) {
 if (warningListeners == null) {
 return;
 }
 }
 /**
 * Broadcasts a localized warning message to all registered
-* <code>IIOWriteWarningListener</code>s by calling their
+* {@code IIOWriteWarningListener}s by calling their
-* <code>warningOccurred</code> method with a string taken
+* {@code warningOccurred} method with a string taken
-* from a <code>ResourceBundle</code>.  Subclasses may use this
+* 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</code>s containing localized warning
+* {@code ResourceBundle}s containing localized warning
 * messages.
 * @param keyword the keyword used to index the warning message
-* within the set of <code>ResourceBundle</code>s.
+* within the set of {@code ResourceBundle}s.
 *
-* @exception IllegalArgumentException if <code>baseName</code>
+* @exception IllegalArgumentException if {@code baseName}
-* is <code>null</code>.
+* is {@code null}.
-* @exception IllegalArgumentException if <code>keyword</code>
+* @exception IllegalArgumentException if {@code keyword}
-* is <code>null</code>.
+* is {@code null}.
 * @exception IllegalArgumentException if no appropriate
-* <code>ResourceBundle</code> may be located.
+* {@code ResourceBundle} may be located.
 * @exception IllegalArgumentException if the named resource is
-* not found in the located <code>ResourceBundle</code>.
+* not found in the located {@code ResourceBundle}.
 * @exception IllegalArgumentException if the object retrieved
-* from the <code>ResourceBundle</code> is not a
+* from the {@code ResourceBundle} is not a
-* <code>String</code>.
+* {@code String}.
 */
 protected void processWarningOccurred(int imageIndex,
 String baseName,
 String keyword) {
 if (warningListeners == null) {
 }
 // State management
 /**
-* Restores the <code>ImageWriter</code> to its initial state.
+* Restores the {@code ImageWriter} to its initial state.
 *
 * <p> The default implementation calls
-* <code>setOutput(null)</code>, <code>setLocale(null)</code>,
+* {@code setOutput(null)}, {@code setLocale(null)},
-* <code>removeAllIIOWriteWarningListeners()</code>,
+* {@code removeAllIIOWriteWarningListeners()},
-* <code>removeAllIIOWriteProgressListeners()</code>, and
+* {@code removeAllIIOWriteProgressListeners()}, and
-* <code>clearAbortRequest</code>.
+* {@code clearAbortRequest}.
 */
 public void reset() {
 setOutput(null);
 setLocale(null);
 removeAllIIOWriteWarningListeners();
 }
 /**
 * Allows any resources held by this object to be released.  The
 * result of calling any other method (other than
-* <code>finalize</code>) subsequent to a call to this method
+* {@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</code>.
+* 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,

changeset 35667	ed476aba94de
parent 25859	3317bb8137f4
child 35679	e4b92165fa8d