< prev index next >

src/java.desktop/share/classes/java/awt/image/ColorModel.java

Print this page

        

@@ -35,112 +35,112 @@
 import java.util.Collections;
 import java.util.Map;
 import java.util.WeakHashMap;
 
 /**
- * The <code>ColorModel</code> abstract class encapsulates the
+ * The {@code ColorModel} abstract class encapsulates the
  * methods for translating a pixel value to color components
  * (for example, red, green, and blue) and an alpha component.
  * In order to render an image to the screen, a printer, or another
  * image, pixel values must be converted to color and alpha components.
  * As arguments to or return values from methods of this class,
  * pixels are represented as 32-bit ints or as arrays of primitive types.
  * The number, order, and interpretation of color components for a
- * <code>ColorModel</code> is specified by its <code>ColorSpace</code>.
- * A <code>ColorModel</code> used with pixel data that does not include
+ * {@code ColorModel} is specified by its {@code ColorSpace}.
+ * A {@code ColorModel} used with pixel data that does not include
  * alpha information treats all pixels as opaque, which is an alpha
  * value of 1.0.
  * <p>
- * This <code>ColorModel</code> class supports two representations of
+ * This {@code ColorModel} class supports two representations of
  * pixel values.  A pixel value can be a single 32-bit int or an
  * array of primitive types.  The Java(tm) Platform 1.0 and 1.1 APIs
- * represented pixels as single <code>byte</code> or single
- * <code>int</code> values.  For purposes of the <code>ColorModel</code>
+ * represented pixels as single {@code byte} or single
+ * {@code int} values.  For purposes of the {@code ColorModel}
  * class, pixel value arguments were passed as ints.  The Java(tm) 2
  * Platform API introduced additional classes for representing images.
  * With {@link BufferedImage} or {@link RenderedImage}
  * objects, based on {@link Raster} and {@link SampleModel} classes, pixel
  * values might not be conveniently representable as a single int.
- * Consequently, <code>ColorModel</code> now has methods that accept
+ * Consequently, {@code ColorModel} now has methods that accept
  * pixel values represented as arrays of primitive types.  The primitive
- * type used by a particular <code>ColorModel</code> object is called its
+ * type used by a particular {@code ColorModel} object is called its
  * transfer type.
  * <p>
- * <code>ColorModel</code> objects used with images for which pixel values
+ * {@code ColorModel} objects used with images for which pixel values
  * are not conveniently representable as a single int throw an
  * {@link IllegalArgumentException} when methods taking a single int pixel
- * argument are called.  Subclasses of <code>ColorModel</code> must
+ * argument are called.  Subclasses of {@code ColorModel} must
  * specify the conditions under which this occurs.  This does not
  * occur with {@link DirectColorModel} or {@link IndexColorModel} objects.
  * <p>
  * Currently, the transfer types supported by the Java 2D(tm) API are
  * DataBuffer.TYPE_BYTE, DataBuffer.TYPE_USHORT, DataBuffer.TYPE_INT,
  * DataBuffer.TYPE_SHORT, DataBuffer.TYPE_FLOAT, and DataBuffer.TYPE_DOUBLE.
  * Most rendering operations will perform much faster when using ColorModels
  * and images based on the first three of these types.  In addition, some
  * image filtering operations are not supported for ColorModels and
  * images based on the latter three types.
- * The transfer type for a particular <code>ColorModel</code> object is
+ * The transfer type for a particular {@code ColorModel} object is
  * specified when the object is created, either explicitly or by default.
- * All subclasses of <code>ColorModel</code> must specify what the
+ * All subclasses of {@code ColorModel} must specify what the
  * possible transfer types are and how the number of elements in the
  * primitive arrays representing pixels is determined.
  * <p>
- * For <code>BufferedImages</code>, the transfer type of its
- * <code>Raster</code> and of the <code>Raster</code> object's
- * <code>SampleModel</code> (available from the
- * <code>getTransferType</code> methods of these classes) must match that
- * of the <code>ColorModel</code>.  The number of elements in an array
- * representing a pixel for the <code>Raster</code> and
- * <code>SampleModel</code> (available from the
- * <code>getNumDataElements</code> methods of these classes) must match
- * that of the <code>ColorModel</code>.
+ * For {@code BufferedImages}, the transfer type of its
+ * {@code Raster} and of the {@code Raster} object's
+ * {@code SampleModel} (available from the
+ * {@code getTransferType} methods of these classes) must match that
+ * of the {@code ColorModel}.  The number of elements in an array
+ * representing a pixel for the {@code Raster} and
+ * {@code SampleModel} (available from the
+ * {@code getNumDataElements} methods of these classes) must match
+ * that of the {@code ColorModel}.
  * <p>
  * The algorithm used to convert from pixel values to color and alpha
  * components varies by subclass.  For example, there is not necessarily
  * a one-to-one correspondence between samples obtained from the
- * <code>SampleModel</code> of a <code>BufferedImage</code> object's
- * <code>Raster</code> and color/alpha components.  Even when
+ * {@code SampleModel} of a {@code BufferedImage} object's
+ * {@code Raster} and color/alpha components.  Even when
  * there is such a correspondence, the number of bits in a sample is not
  * necessarily the same as the number of bits in the corresponding color/alpha
  * component.  Each subclass must specify how the translation from
  * pixel values to color/alpha components is done.
  * <p>
- * Methods in the <code>ColorModel</code> class use two different
+ * Methods in the {@code ColorModel} class use two different
  * representations of color and alpha components - a normalized form
  * and an unnormalized form.  In the normalized form, each component is a
- * <code>float</code> value between some minimum and maximum values.  For
+ * {@code float} value between some minimum and maximum values.  For
  * the alpha component, the minimum is 0.0 and the maximum is 1.0.  For
  * color components the minimum and maximum values for each component can
- * be obtained from the <code>ColorSpace</code> object.  These values
+ * be obtained from the {@code ColorSpace} object.  These values
  * will often be 0.0 and 1.0 (e.g. normalized component values for the
  * default sRGB color space range from 0.0 to 1.0), but some color spaces
  * have component values with different upper and lower limits.  These
- * limits can be obtained using the <code>getMinValue</code> and
- * <code>getMaxValue</code> methods of the <code>ColorSpace</code>
+ * limits can be obtained using the {@code getMinValue} and
+ * {@code getMaxValue} methods of the {@code ColorSpace}
  * class.  Normalized color component values are not premultiplied.
- * All <code>ColorModels</code> must support the normalized form.
+ * All {@code ColorModels} must support the normalized form.
  * <p>
  * In the unnormalized
  * form, each component is an unsigned integral value between 0 and
  * 2<sup>n</sup> - 1, where n is the number of significant bits for a
  * particular component.  If pixel values for a particular
- * <code>ColorModel</code> represent color samples premultiplied by
+ * {@code ColorModel} represent color samples premultiplied by
  * the alpha sample, unnormalized color component values are
  * also premultiplied.  The unnormalized form is used only with instances
- * of <code>ColorModel</code> whose <code>ColorSpace</code> has minimum
+ * of {@code ColorModel} whose {@code ColorSpace} has minimum
  * component values of 0.0 for all components and maximum values of
  * 1.0 for all components.
  * The unnormalized form for color and alpha components can be a convenient
- * representation for <code>ColorModels</code> whose normalized component
+ * representation for {@code ColorModels} whose normalized component
  * values all lie
  * between 0.0 and 1.0.  In such cases the integral value 0 maps to 0.0 and
  * the value 2<sup>n</sup> - 1 maps to 1.0.  In other cases, such as
  * when the normalized component values can be either negative or positive,
- * the unnormalized form is not convenient.  Such <code>ColorModel</code>
+ * the unnormalized form is not convenient.  Such {@code ColorModel}
  * objects throw an {@link IllegalArgumentException} when methods involving
- * an unnormalized argument are called.  Subclasses of <code>ColorModel</code>
+ * an unnormalized argument are called.  Subclasses of {@code ColorModel}
  * must specify the conditions under which this occurs.
  *
  * @see IndexColorModel
  * @see ComponentColorModel
  * @see PackedColorModel

@@ -220,23 +220,23 @@
         initIDs();
     }
     private static ColorModel RGBdefault;
 
     /**
-     * Returns a <code>DirectColorModel</code> that describes the default
+     * Returns a {@code DirectColorModel} that describes the default
      * format for integer RGB values used in many of the methods in the
      * AWT image interfaces for the convenience of the programmer.
      * The color space is the default {@link ColorSpace}, sRGB.
      * The format for the RGB values is an integer with 8 bits
      * each of alpha, red, green, and blue color components ordered
      * correspondingly from the most significant byte to the least
      * significant byte, as in:  0xAARRGGBB.  Color components are
      * not premultiplied by the alpha component.  This format does not
      * necessarily represent the native or the most efficient
-     * <code>ColorModel</code> for a particular device or for all images.
+     * {@code ColorModel} for a particular device or for all images.
      * It is merely used as a common color model format.
-     * @return a <code>DirectColorModel</code>object describing default
+     * @return a {@code DirectColorModel} object describing default
      *          RGB values.
      */
     public static ColorModel getRGBdefault() {
         if (RGBdefault == null) {
             RGBdefault = new DirectColorModel(32,

@@ -248,13 +248,13 @@
         }
         return RGBdefault;
     }
 
     /**
-     * Constructs a <code>ColorModel</code> that translates pixels of the
+     * Constructs a {@code ColorModel} that translates pixels of the
      * specified number of bits to color/alpha components.  The color
-     * space is the default RGB <code>ColorSpace</code>, which is sRGB.
+     * space is the default RGB {@code ColorSpace}, which is sRGB.
      * Pixel values are assumed to include alpha information.  If color
      * and alpha information are represented in the pixel value as
      * separate spatial bands, the color bands are assumed not to be
      * premultiplied with the alpha value. The transparency type is
      * java.awt.Transparency.TRANSLUCENT.  The transfer type will be the

@@ -265,11 +265,11 @@
      * number of bits per color and alpha component, any subclass calling
      * this constructor should override any method that requires this
      * information.
      * @param bits the number of bits of a pixel
      * @throws IllegalArgumentException if the number
-     *          of bits in <code>bits</code> is less than 1
+     *          of bits in {@code bits} is less than 1
      */
     public ColorModel(int bits) {
         pixel_bits = bits;
         if (bits < 1) {
             throw new IllegalArgumentException("Number of bits must be > 0");

@@ -280,53 +280,53 @@
         // REMIND: make sure transferType is set correctly
         transferType = ColorModel.getDefaultTransferType(bits);
     }
 
     /**
-     * Constructs a <code>ColorModel</code> that translates pixel values
+     * Constructs a {@code ColorModel} that translates pixel values
      * to color/alpha components.  Color components will be in the
-     * specified <code>ColorSpace</code>. <code>pixel_bits</code> is the
+     * specified {@code ColorSpace}. {@code pixel_bits} is the
      * number of bits in the pixel values.  The bits array
      * specifies the number of significant bits per color and alpha component.
      * Its length should be the number of components in the
-     * <code>ColorSpace</code> if there is no alpha information in the
+     * {@code ColorSpace} if there is no alpha information in the
      * pixel values, or one more than this number if there is alpha
-     * information.  <code>hasAlpha</code> indicates whether or not alpha
-     * information is present.  The <code>boolean</code>
-     * <code>isAlphaPremultiplied</code> specifies how to interpret pixel
+     * information.  {@code hasAlpha} indicates whether or not alpha
+     * information is present.  The {@code boolean}
+     * {@code isAlphaPremultiplied} specifies how to interpret pixel
      * values in which color and alpha information are represented as
-     * separate spatial bands.  If the <code>boolean</code>
-     * is <code>true</code>, color samples are assumed to have been
-     * multiplied by the alpha sample.  The <code>transparency</code>
+     * separate spatial bands.  If the {@code boolean}
+     * is {@code true}, color samples are assumed to have been
+     * multiplied by the alpha sample.  The {@code transparency}
      * specifies what alpha values can be represented by this color model.
      * The transfer type is the type of primitive array used to represent
      * pixel values.  Note that the bits array contains the number of
      * significant bits per color/alpha component after the translation
      * from pixel values.  For example, for an
-     * <code>IndexColorModel</code> with <code>pixel_bits</code> equal to
+     * {@code IndexColorModel} with {@code pixel_bits} equal to
      * 16, the bits array might have four elements with each element set
      * to 8.
      * @param pixel_bits the number of bits in the pixel values
      * @param bits array that specifies the number of significant bits
      *          per color and alpha component
-     * @param cspace the specified <code>ColorSpace</code>
-     * @param hasAlpha <code>true</code> if alpha information is present;
-     *          <code>false</code> otherwise
-     * @param isAlphaPremultiplied <code>true</code> if color samples are
+     * @param cspace the specified {@code ColorSpace}
+     * @param hasAlpha {@code true} if alpha information is present;
+     *          {@code false} otherwise
+     * @param isAlphaPremultiplied {@code true} if color samples are
      *          assumed to be premultiplied by the alpha samples;
-     *          <code>false</code> otherwise
+     *          {@code false} otherwise
      * @param transparency what alpha values can be represented by this
      *          color model
      * @param transferType the type of the array used to represent pixel
      *          values
      * @throws IllegalArgumentException if the length of
      *          the bit array is less than the number of color or alpha
-     *          components in this <code>ColorModel</code>, or if the
+     *          components in this {@code ColorModel}, or if the
      *          transparency is not a valid value.
      * @throws IllegalArgumentException if the sum of the number
-     *          of bits in <code>bits</code> is less than 1 or if
-     *          any of the elements in <code>bits</code> is less than 0.
+     *          of bits in {@code bits} is less than 1 or if
+     *          any of the elements in {@code bits} is less than 0.
      * @see java.awt.Transparency
      */
     protected ColorModel(int pixel_bits, int[] bits, ColorSpace cspace,
                          boolean hasAlpha,
                          boolean isAlphaPremultiplied,

@@ -397,36 +397,36 @@
         this.transferType = transferType;
     }
 
     /**
      * Returns whether or not alpha is supported in this
-     * <code>ColorModel</code>.
-     * @return <code>true</code> if alpha is supported in this
-     * <code>ColorModel</code>; <code>false</code> otherwise.
+     * {@code ColorModel}.
+     * @return {@code true} if alpha is supported in this
+     * {@code ColorModel}; {@code false} otherwise.
      */
     public final boolean hasAlpha() {
         return supportsAlpha;
     }
 
     /**
      * Returns whether or not the alpha has been premultiplied in the
-     * pixel values to be translated by this <code>ColorModel</code>.
-     * If the boolean is <code>true</code>, this <code>ColorModel</code>
+     * pixel values to be translated by this {@code ColorModel}.
+     * If the boolean is {@code true}, this {@code ColorModel}
      * is to be used to interpret pixel values in which color and alpha
      * information are represented as separate spatial bands, and color
      * samples are assumed to have been multiplied by the
      * alpha sample.
-     * @return <code>true</code> if the alpha values are premultiplied
+     * @return {@code true} if the alpha values are premultiplied
      *          in the pixel values to be translated by this
-     *          <code>ColorModel</code>; <code>false</code> otherwise.
+     *          {@code ColorModel}; {@code false} otherwise.
      */
     public final boolean isAlphaPremultiplied() {
         return isAlphaPremultiplied;
     }
 
     /**
-     * Returns the transfer type of this <code>ColorModel</code>.
+     * Returns the transfer type of this {@code ColorModel}.
      * The transfer type is the type of primitive array used to represent
      * pixel values as arrays.
      * @return the transfer type.
      * @since 1.3
      */

@@ -434,34 +434,34 @@
         return transferType;
     }
 
     /**
      * Returns the number of bits per pixel described by this
-     * <code>ColorModel</code>.
+     * {@code ColorModel}.
      * @return the number of bits per pixel.
      */
     public int getPixelSize() {
         return pixel_bits;
     }
 
     /**
      * Returns the number of bits for the specified color/alpha component.
      * Color components are indexed in the order specified by the
-     * <code>ColorSpace</code>.  Typically, this order reflects the name
+     * {@code ColorSpace}.  Typically, this order reflects the name
      * of the color space type. For example, for TYPE_RGB, index 0
      * corresponds to red, index 1 to green, and index 2
-     * to blue.  If this <code>ColorModel</code> supports alpha, the alpha
+     * to blue.  If this {@code ColorModel} supports alpha, the alpha
      * component corresponds to the index following the last color
      * component.
      * @param componentIdx the index of the color/alpha component
      * @return the number of bits for the color/alpha component at the
      *          specified index.
-     * @throws ArrayIndexOutOfBoundsException if <code>componentIdx</code>
+     * @throws ArrayIndexOutOfBoundsException if {@code componentIdx}
      *         is greater than the number of components or
      *         less than zero
      * @throws NullPointerException if the number of bits array is
-     *         <code>null</code>
+     *         {@code null}
      */
     public int getComponentSize(int componentIdx) {
         // REMIND:
         if (nBits == null) {
             throw new NullPointerException("Number of bits array is null.");

@@ -471,11 +471,11 @@
     }
 
     /**
      * Returns an array of the number of bits per color/alpha component.
      * The array contains the color components in the order specified by the
-     * <code>ColorSpace</code>, followed by the alpha component, if
+     * {@code ColorSpace}, followed by the alpha component, if
      * present.
      * @return an array of the number of bits per color/alpha component
      */
     public int[] getComponentSize() {
         if (nBits != null) {

@@ -486,48 +486,48 @@
     }
 
     /**
      * Returns the transparency.  Returns either OPAQUE, BITMASK,
      * or TRANSLUCENT.
-     * @return the transparency of this <code>ColorModel</code>.
+     * @return the transparency of this {@code ColorModel}.
      * @see Transparency#OPAQUE
      * @see Transparency#BITMASK
      * @see Transparency#TRANSLUCENT
      */
     public int getTransparency() {
         return transparency;
     }
 
     /**
      * Returns the number of components, including alpha, in this
-     * <code>ColorModel</code>.  This is equal to the number of color
+     * {@code ColorModel}.  This is equal to the number of color
      * components, optionally plus one, if there is an alpha component.
-     * @return the number of components in this <code>ColorModel</code>
+     * @return the number of components in this {@code ColorModel}
      */
     public int getNumComponents() {
         return numComponents;
     }
 
     /**
      * Returns the number of color components in this
-     * <code>ColorModel</code>.
+     * {@code ColorModel}.
      * This is the number of components returned by
      * {@link ColorSpace#getNumComponents}.
      * @return the number of color components in this
-     * <code>ColorModel</code>.
+     * {@code ColorModel}.
      * @see ColorSpace#getNumComponents
      */
     public int getNumColorComponents() {
         return numColorComponents;
     }
 
     /**
      * Returns the red color component for the specified pixel, scaled
      * from 0 to 255 in the default RGB ColorSpace, sRGB.  A color conversion
      * is done if necessary.  The pixel value is specified as an int.
-     * An <code>IllegalArgumentException</code> is thrown if pixel
-     * values for this <code>ColorModel</code> are not conveniently
+     * An {@code IllegalArgumentException} is thrown if pixel
+     * values for this {@code ColorModel} are not conveniently
      * representable as a single int.  The returned value is not a
      * pre-multiplied value.  For example, if the
      * alpha is premultiplied, this method divides it out before returning
      * the value.  If the alpha value is 0, the red value is 0.
      * @param pixel a specified pixel

@@ -537,12 +537,12 @@
 
     /**
      * Returns the green color component for the specified pixel, scaled
      * from 0 to 255 in the default RGB ColorSpace, sRGB.  A color conversion
      * is done if necessary.  The pixel value is specified as an int.
-     * An <code>IllegalArgumentException</code> is thrown if pixel
-     * values for this <code>ColorModel</code> are not conveniently
+     * An {@code IllegalArgumentException} is thrown if pixel
+     * values for this {@code ColorModel} are not conveniently
      * representable as a single int.  The returned value is a non
      * pre-multiplied value.  For example, if the alpha is premultiplied,
      * this method divides it out before returning
      * the value.  If the alpha value is 0, the green value is 0.
      * @param pixel the specified pixel

@@ -552,12 +552,12 @@
 
     /**
      * Returns the blue color component for the specified pixel, scaled
      * from 0 to 255 in the default RGB ColorSpace, sRGB.  A color conversion
      * is done if necessary.  The pixel value is specified as an int.
-     * An <code>IllegalArgumentException</code> is thrown if pixel values
-     * for this <code>ColorModel</code> are not conveniently representable
+     * An {@code IllegalArgumentException} is thrown if pixel values
+     * for this {@code ColorModel} are not conveniently representable
      * as a single int.  The returned value is a non pre-multiplied
      * value, for example, if the alpha is premultiplied, this method
      * divides it out before returning the value.  If the alpha value is
      * 0, the blue value is 0.
      * @param pixel the specified pixel

@@ -566,24 +566,24 @@
     public abstract int getBlue(int pixel);
 
     /**
      * Returns the alpha component for the specified pixel, scaled
      * from 0 to 255.  The pixel value is specified as an int.
-     * An <code>IllegalArgumentException</code> is thrown if pixel
-     * values for this <code>ColorModel</code> are not conveniently
+     * An {@code IllegalArgumentException} is thrown if pixel
+     * values for this {@code ColorModel} are not conveniently
      * representable as a single int.
      * @param pixel the specified pixel
      * @return the value of alpha component of the specified pixel.
      */
     public abstract int getAlpha(int pixel);
 
     /**
      * Returns the color/alpha components of the pixel in the default
      * RGB color model format.  A color conversion is done if necessary.
      * The pixel value is specified as an int.
-     * An <code>IllegalArgumentException</code> thrown if pixel values
-     * for this <code>ColorModel</code> are not conveniently representable
+     * An {@code IllegalArgumentException} thrown if pixel values
+     * for this {@code ColorModel} are not conveniently representable
      * as a single int.  The returned value is in a non
      * pre-multiplied format. For example, if the alpha is premultiplied,
      * this method divides it out of the color components.  If the alpha
      * value is 0, the color values are 0.
      * @param pixel the specified pixel

@@ -598,43 +598,43 @@
             | (getBlue(pixel) << 0);
     }
 
     /**
      * Returns the red color component for the specified pixel, scaled
-     * from 0 to 255 in the default RGB <code>ColorSpace</code>, sRGB.  A
+     * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB.  A
      * color conversion is done if necessary.  The pixel value is
      * specified by an array of data elements of type transferType passed
      * in as an object reference.  The returned value is a non
      * pre-multiplied value.  For example, if alpha is premultiplied,
      * this method divides it out before returning
      * the value.  If the alpha value is 0, the red value is 0.
-     * If <code>inData</code> is not a primitive array of type
-     * transferType, a <code>ClassCastException</code> is thrown.  An
-     * <code>ArrayIndexOutOfBoundsException</code> is thrown if
-     * <code>inData</code> is not large enough to hold a pixel value for
-     * this <code>ColorModel</code>.
-     * If this <code>transferType</code> is not supported, a
-     * <code>UnsupportedOperationException</code> will be
+     * If {@code inData} is not a primitive array of type
+     * transferType, a {@code ClassCastException} is thrown.  An
+     * {@code ArrayIndexOutOfBoundsException} is thrown if
+     * {@code inData} is not large enough to hold a pixel value for
+     * this {@code ColorModel}.
+     * If this {@code transferType} is not supported, a
+     * {@code UnsupportedOperationException} will be
      * thrown.  Since
-     * <code>ColorModel</code> is an abstract class, any instance
+     * {@code ColorModel} is an abstract class, any instance
      * must be an instance of a subclass.  Subclasses inherit the
      * implementation of this method and if they don't override it, this
      * method throws an exception if the subclass uses a
-     * <code>transferType</code> other than
-     * <code>DataBuffer.TYPE_BYTE</code>,
-     * <code>DataBuffer.TYPE_USHORT</code>, or
-     * <code>DataBuffer.TYPE_INT</code>.
+     * {@code transferType} other than
+     * {@code DataBuffer.TYPE_BYTE},
+     * {@code DataBuffer.TYPE_USHORT}, or
+     * {@code DataBuffer.TYPE_INT}.
      * @param inData an array of pixel values
      * @return the value of the red component of the specified pixel.
-     * @throws ClassCastException if <code>inData</code>
-     *  is not a primitive array of type <code>transferType</code>
+     * @throws ClassCastException if {@code inData}
+     *  is not a primitive array of type {@code transferType}
      * @throws ArrayIndexOutOfBoundsException if
-     *  <code>inData</code> is not large enough to hold a pixel value
-     *  for this <code>ColorModel</code>
+     *  {@code inData} is not large enough to hold a pixel value
+     *  for this {@code ColorModel}
      * @throws UnsupportedOperationException if this
-     *  <code>transferType</code> is not supported by this
-     *  <code>ColorModel</code>
+     *  {@code transferType} is not supported by this
+     *  {@code ColorModel}
      */
     public int getRed(Object inData) {
         int pixel=0,length=0;
         switch (transferType) {
             case DataBuffer.TYPE_BYTE:

@@ -665,43 +665,43 @@
         }
     }
 
     /**
      * Returns the green color component for the specified pixel, scaled
-     * from 0 to 255 in the default RGB <code>ColorSpace</code>, sRGB.  A
+     * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB.  A
      * color conversion is done if necessary.  The pixel value is
      * specified by an array of data elements of type transferType passed
      * in as an object reference.  The returned value will be a non
      * pre-multiplied value.  For example, if the alpha is premultiplied,
      * this method divides it out before returning the value.  If the
-     * alpha value is 0, the green value is 0.  If <code>inData</code> is
+     * alpha value is 0, the green value is 0.  If {@code inData} is
      * not a primitive array of type transferType, a
-     * <code>ClassCastException</code> is thrown.  An
-     * <code>ArrayIndexOutOfBoundsException</code> is thrown if
-     * <code>inData</code> is not large enough to hold a pixel value for
-     * this <code>ColorModel</code>.
-     * If this <code>transferType</code> is not supported, a
-     * <code>UnsupportedOperationException</code> will be
+     * {@code ClassCastException} is thrown.  An
+     * {@code ArrayIndexOutOfBoundsException} is thrown if
+     * {@code inData} is not large enough to hold a pixel value for
+     * this {@code ColorModel}.
+     * If this {@code transferType} is not supported, a
+     * {@code UnsupportedOperationException} will be
      * thrown.  Since
-     * <code>ColorModel</code> is an abstract class, any instance
+     * {@code ColorModel} is an abstract class, any instance
      * must be an instance of a subclass.  Subclasses inherit the
      * implementation of this method and if they don't override it, this
      * method throws an exception if the subclass uses a
-     * <code>transferType</code> other than
-     * <code>DataBuffer.TYPE_BYTE</code>,
-     * <code>DataBuffer.TYPE_USHORT</code>, or
-     * <code>DataBuffer.TYPE_INT</code>.
+     * {@code transferType} other than
+     * {@code DataBuffer.TYPE_BYTE},
+     * {@code DataBuffer.TYPE_USHORT}, or
+     * {@code DataBuffer.TYPE_INT}.
      * @param inData an array of pixel values
      * @return the value of the green component of the specified pixel.
-     * @throws ClassCastException if <code>inData</code>
-     *  is not a primitive array of type <code>transferType</code>
+     * @throws ClassCastException if {@code inData}
+     *  is not a primitive array of type {@code transferType}
      * @throws ArrayIndexOutOfBoundsException if
-     *  <code>inData</code> is not large enough to hold a pixel value
-     *  for this <code>ColorModel</code>
+     *  {@code inData} is not large enough to hold a pixel value
+     *  for this {@code ColorModel}
      * @throws UnsupportedOperationException if this
-     *  <code>transferType</code> is not supported by this
-     *  <code>ColorModel</code>
+     *  {@code transferType} is not supported by this
+     *  {@code ColorModel}
      */
     public int getGreen(Object inData) {
         int pixel=0,length=0;
         switch (transferType) {
             case DataBuffer.TYPE_BYTE:

@@ -732,43 +732,43 @@
         }
     }
 
     /**
      * Returns the blue color component for the specified pixel, scaled
-     * from 0 to 255 in the default RGB <code>ColorSpace</code>, sRGB.  A
+     * from 0 to 255 in the default RGB {@code ColorSpace}, sRGB.  A
      * color conversion is done if necessary.  The pixel value is
      * specified by an array of data elements of type transferType passed
      * in as an object reference.  The returned value is a non
      * pre-multiplied value.  For example, if the alpha is premultiplied,
      * this method divides it out before returning the value.  If the
      * alpha value is 0, the blue value will be 0.  If
-     * <code>inData</code> is not a primitive array of type transferType,
-     * a <code>ClassCastException</code> is thrown.  An
-     * <code>ArrayIndexOutOfBoundsException</code> is
-     * thrown if <code>inData</code> is not large enough to hold a pixel
-     * value for this <code>ColorModel</code>.
-     * If this <code>transferType</code> is not supported, a
-     * <code>UnsupportedOperationException</code> will be
+     * {@code inData} is not a primitive array of type transferType,
+     * a {@code ClassCastException} is thrown.  An
+     * {@code ArrayIndexOutOfBoundsException} is
+     * thrown if {@code inData} is not large enough to hold a pixel
+     * value for this {@code ColorModel}.
+     * If this {@code transferType} is not supported, a
+     * {@code UnsupportedOperationException} will be
      * thrown.  Since
-     * <code>ColorModel</code> is an abstract class, any instance
+     * {@code ColorModel} is an abstract class, any instance
      * must be an instance of a subclass.  Subclasses inherit the
      * implementation of this method and if they don't override it, this
      * method throws an exception if the subclass uses a
-     * <code>transferType</code> other than
-     * <code>DataBuffer.TYPE_BYTE</code>,
-     * <code>DataBuffer.TYPE_USHORT</code>, or
-     * <code>DataBuffer.TYPE_INT</code>.
+     * {@code transferType} other than
+     * {@code DataBuffer.TYPE_BYTE},
+     * {@code DataBuffer.TYPE_USHORT}, or
+     * {@code DataBuffer.TYPE_INT}.
      * @param inData an array of pixel values
      * @return the value of the blue component of the specified pixel.
-     * @throws ClassCastException if <code>inData</code>
-     *  is not a primitive array of type <code>transferType</code>
+     * @throws ClassCastException if {@code inData}
+     *  is not a primitive array of type {@code transferType}
      * @throws ArrayIndexOutOfBoundsException if
-     *  <code>inData</code> is not large enough to hold a pixel value
-     *  for this <code>ColorModel</code>
+     *  {@code inData} is not large enough to hold a pixel value
+     *  for this {@code ColorModel}
      * @throws UnsupportedOperationException if this
-     *  <code>transferType</code> is not supported by this
-     *  <code>ColorModel</code>
+     *  {@code transferType} is not supported by this
+     *  {@code ColorModel}
      */
     public int getBlue(Object inData) {
         int pixel=0,length=0;
         switch (transferType) {
             case DataBuffer.TYPE_BYTE:

@@ -802,36 +802,36 @@
     /**
      * Returns the alpha component for the specified pixel, scaled
      * from 0 to 255.  The pixel value is specified by an array of data
      * elements of type transferType passed in as an object reference.
      * If inData is not a primitive array of type transferType, a
-     * <code>ClassCastException</code> is thrown.  An
-     * <code>ArrayIndexOutOfBoundsException</code> is thrown if
-     * <code>inData</code> is not large enough to hold a pixel value for
-     * this <code>ColorModel</code>.
-     * If this <code>transferType</code> is not supported, a
-     * <code>UnsupportedOperationException</code> will be
+     * {@code ClassCastException} is thrown.  An
+     * {@code ArrayIndexOutOfBoundsException} is thrown if
+     * {@code inData} is not large enough to hold a pixel value for
+     * this {@code ColorModel}.
+     * If this {@code transferType} is not supported, a
+     * {@code UnsupportedOperationException} will be
      * thrown.  Since
-     * <code>ColorModel</code> is an abstract class, any instance
+     * {@code ColorModel} is an abstract class, any instance
      * must be an instance of a subclass.  Subclasses inherit the
      * implementation of this method and if they don't override it, this
      * method throws an exception if the subclass uses a
-     * <code>transferType</code> other than
-     * <code>DataBuffer.TYPE_BYTE</code>,
-     * <code>DataBuffer.TYPE_USHORT</code>, or
-     * <code>DataBuffer.TYPE_INT</code>.
+     * {@code transferType} other than
+     * {@code DataBuffer.TYPE_BYTE},
+     * {@code DataBuffer.TYPE_USHORT}, or
+     * {@code DataBuffer.TYPE_INT}.
      * @param inData the specified pixel
      * @return the alpha component of the specified pixel, scaled from
      * 0 to 255.
-     * @throws ClassCastException if <code>inData</code>
-     *  is not a primitive array of type <code>transferType</code>
+     * @throws ClassCastException if {@code inData}
+     *  is not a primitive array of type {@code transferType}
      * @throws ArrayIndexOutOfBoundsException if
-     *  <code>inData</code> is not large enough to hold a pixel value
-     *  for this <code>ColorModel</code>
+     *  {@code inData} is not large enough to hold a pixel value
+     *  for this {@code ColorModel}
      * @throws UnsupportedOperationException if this
-     *  <code>tranferType</code> is not supported by this
-     *  <code>ColorModel</code>
+     *  {@code tranferType} is not supported by this
+     *  {@code ColorModel}
      */
     public int getAlpha(Object inData) {
         int pixel=0,length=0;
         switch (transferType) {
             case DataBuffer.TYPE_BYTE:

@@ -866,14 +866,14 @@
      * Returns the color/alpha components for the specified pixel in the
      * default RGB color model format.  A color conversion is done if
      * necessary.  The pixel value is specified by an array of data
      * elements of type transferType passed in as an object reference.
      * If inData is not a primitive array of type transferType, a
-     * <code>ClassCastException</code> is thrown.  An
-     * <code>ArrayIndexOutOfBoundsException</code> is
-     * thrown if <code>inData</code> is not large enough to hold a pixel
-     * value for this <code>ColorModel</code>.
+     * {@code ClassCastException} is thrown.  An
+     * {@code ArrayIndexOutOfBoundsException} is
+     * thrown if {@code inData} is not large enough to hold a pixel
+     * value for this {@code ColorModel}.
      * The returned value will be in a non pre-multiplied format, i.e. if
      * the alpha is premultiplied, this method will divide it out of the
      * color components (if the alpha value is 0, the color values will be 0).
      * @param inData the specified pixel
      * @return the color and alpha components of the specified pixel.

@@ -886,123 +886,123 @@
             | (getBlue(inData) << 0);
     }
 
     /**
      * Returns a data element array representation of a pixel in this
-     * <code>ColorModel</code>, given an integer pixel representation in
+     * {@code ColorModel}, given an integer pixel representation in
      * the default RGB color model.
      * This array can then be passed to the
      * {@link WritableRaster#setDataElements} method of
      * a {@link WritableRaster} object.  If the pixel variable is
-     * <code>null</code>, a new array will be allocated.  If
-     * <code>pixel</code> is not
-     * <code>null</code>, it must be a primitive array of type
-     * <code>transferType</code>; otherwise, a
-     * <code>ClassCastException</code> is thrown.  An
-     * <code>ArrayIndexOutOfBoundsException</code> is thrown if
-     * <code>pixel</code> is
+     * {@code null}, a new array will be allocated.  If
+     * {@code pixel} is not
+     * {@code null}, it must be a primitive array of type
+     * {@code transferType}; otherwise, a
+     * {@code ClassCastException} is thrown.  An
+     * {@code ArrayIndexOutOfBoundsException} is thrown if
+     * {@code pixel} is
      * not large enough to hold a pixel value for this
-     * <code>ColorModel</code>. The pixel array is returned.
-     * If this <code>transferType</code> is not supported, a
-     * <code>UnsupportedOperationException</code> will be
-     * thrown.  Since <code>ColorModel</code> is an abstract class,
+     * {@code ColorModel}. The pixel array is returned.
+     * If this {@code transferType} is not supported, a
+     * {@code UnsupportedOperationException} will be
+     * thrown.  Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  Subclasses must
      * override this method since the implementation in this abstract
-     * class throws an <code>UnsupportedOperationException</code>.
+     * class throws an {@code UnsupportedOperationException}.
      * @param rgb the integer pixel representation in the default RGB
      * color model
      * @param pixel the specified pixel
      * @return an array representation of the specified pixel in this
-     *  <code>ColorModel</code>.
-     * @throws ClassCastException if <code>pixel</code>
-     *  is not a primitive array of type <code>transferType</code>
+     *  {@code ColorModel}.
+     * @throws ClassCastException if {@code pixel}
+     *  is not a primitive array of type {@code transferType}
      * @throws ArrayIndexOutOfBoundsException if
-     *  <code>pixel</code> is not large enough to hold a pixel value
-     *  for this <code>ColorModel</code>
+     *  {@code pixel} is not large enough to hold a pixel value
+     *  for this {@code ColorModel}
      * @throws UnsupportedOperationException if this
-     *  method is not supported by this <code>ColorModel</code>
+     *  method is not supported by this {@code ColorModel}
      * @see WritableRaster#setDataElements
      * @see SampleModel#setDataElements
      */
     public Object getDataElements(int rgb, Object pixel) {
         throw new UnsupportedOperationException
             ("This method is not supported by this color model.");
     }
 
     /**
      * Returns an array of unnormalized color/alpha components given a pixel
-     * in this <code>ColorModel</code>.  The pixel value is specified as
-     * an <code>int</code>.  An <code>IllegalArgumentException</code>
-     * will be thrown if pixel values for this <code>ColorModel</code> are
-     * not conveniently representable as a single <code>int</code> or if
-     * color component values for this <code>ColorModel</code> are not
+     * in this {@code ColorModel}.  The pixel value is specified as
+     * an {@code int}.  An {@code IllegalArgumentException}
+     * will be thrown if pixel values for this {@code ColorModel} are
+     * not conveniently representable as a single {@code int} or if
+     * color component values for this {@code ColorModel} are not
      * conveniently representable in the unnormalized form.
      * For example, this method can be used to retrieve the
      * components for a specific pixel value in a
-     * <code>DirectColorModel</code>.  If the components array is
-     * <code>null</code>, a new array will be allocated.  The
+     * {@code DirectColorModel}.  If the components array is
+     * {@code null}, a new array will be allocated.  The
      * components array will be returned.  Color/alpha components are
-     * stored in the components array starting at <code>offset</code>
+     * stored in the components array starting at {@code offset}
      * (even if the array is allocated by this method).  An
-     * <code>ArrayIndexOutOfBoundsException</code> is thrown if  the
-     * components array is not <code>null</code> and is not large
+     * {@code ArrayIndexOutOfBoundsException} is thrown if  the
+     * components array is not {@code null} and is not large
      * enough to hold all the color and alpha components (starting at offset).
-     * Since <code>ColorModel</code> is an abstract class,
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  Subclasses must
      * override this method since the implementation in this abstract
-     * class throws an <code>UnsupportedOperationException</code>.
+     * class throws an {@code UnsupportedOperationException}.
      * @param pixel the specified pixel
      * @param components the array to receive the color and alpha
      * components of the specified pixel
-     * @param offset the offset into the <code>components</code> array at
+     * @param offset the offset into the {@code components} array at
      * which to start storing the color and alpha components
      * @return an array containing the color and alpha components of the
      * specified pixel starting at the specified offset.
      * @throws UnsupportedOperationException if this
-     *          method is not supported by this <code>ColorModel</code>
+     *          method is not supported by this {@code ColorModel}
      */
     public int[] getComponents(int pixel, int[] components, int offset) {
         throw new UnsupportedOperationException
             ("This method is not supported by this color model.");
     }
 
     /**
      * Returns an array of unnormalized color/alpha components given a pixel
-     * in this <code>ColorModel</code>.  The pixel value is specified by
+     * in this {@code ColorModel}.  The pixel value is specified by
      * an array of data elements of type transferType passed in as an
-     * object reference.  If <code>pixel</code> is not a primitive array
-     * of type transferType, a <code>ClassCastException</code> is thrown.
-     * An <code>IllegalArgumentException</code> will be thrown if color
-     * component values for this <code>ColorModel</code> are not
+     * object reference.  If {@code pixel} is not a primitive array
+     * of type transferType, a {@code ClassCastException} is thrown.
+     * An {@code IllegalArgumentException} will be thrown if color
+     * component values for this {@code ColorModel} are not
      * conveniently representable in the unnormalized form.
-     * An <code>ArrayIndexOutOfBoundsException</code> is
-     * thrown if <code>pixel</code> is not large enough to hold a pixel
-     * value for this <code>ColorModel</code>.
+     * An {@code ArrayIndexOutOfBoundsException} is
+     * thrown if {@code pixel} is not large enough to hold a pixel
+     * value for this {@code ColorModel}.
      * This method can be used to retrieve the components for a specific
-     * pixel value in any <code>ColorModel</code>.  If the components
-     * array is <code>null</code>, a new array will be allocated.  The
+     * pixel value in any {@code ColorModel}.  If the components
+     * array is {@code null}, a new array will be allocated.  The
      * components array will be returned.  Color/alpha components are
-     * stored in the <code>components</code> array starting at
-     * <code>offset</code> (even if the array is allocated by this
-     * method).  An <code>ArrayIndexOutOfBoundsException</code>
-     * is thrown if  the components array is not <code>null</code> and is
+     * stored in the {@code components} array starting at
+     * {@code offset} (even if the array is allocated by this
+     * method).  An {@code ArrayIndexOutOfBoundsException}
+     * is thrown if  the components array is not {@code null} and is
      * not large enough to hold all the color and alpha components
-     * (starting at <code>offset</code>).
-     * Since <code>ColorModel</code> is an abstract class,
+     * (starting at {@code offset}).
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  Subclasses must
      * override this method since the implementation in this abstract
-     * class throws an <code>UnsupportedOperationException</code>.
+     * class throws an {@code UnsupportedOperationException}.
      * @param pixel the specified pixel
      * @param components an array that receives the color and alpha
      * components of the specified pixel
-     * @param offset the index into the <code>components</code> array at
+     * @param offset the index into the {@code components} array at
      * which to begin storing the color and alpha components of the
      * specified pixel
      * @return an array containing the color and alpha components of the
      * specified pixel starting at the specified offset.
      * @throws UnsupportedOperationException if this
-     *          method is not supported by this <code>ColorModel</code>
+     *          method is not supported by this {@code ColorModel}
      */
     public int[] getComponents(Object pixel, int[] components, int offset) {
         throw new UnsupportedOperationException
             ("This method is not supported by this color model.");
     }

@@ -1011,47 +1011,47 @@
      * Returns an array of all of the color/alpha components in unnormalized
      * form, given a normalized component array.  Unnormalized components
      * are unsigned integral values between 0 and 2<sup>n</sup> - 1, where
      * n is the number of bits for a particular component.  Normalized
      * components are float values between a per component minimum and
-     * maximum specified by the <code>ColorSpace</code> object for this
-     * <code>ColorModel</code>.  An <code>IllegalArgumentException</code>
+     * maximum specified by the {@code ColorSpace} object for this
+     * {@code ColorModel}.  An {@code IllegalArgumentException}
      * will be thrown if color component values for this
-     * <code>ColorModel</code> are not conveniently representable in the
+     * {@code ColorModel} are not conveniently representable in the
      * unnormalized form.  If the
-     * <code>components</code> array is <code>null</code>, a new array
-     * will be allocated.  The <code>components</code> array will
+     * {@code components} array is {@code null}, a new array
+     * will be allocated.  The {@code components} array will
      * be returned.  Color/alpha components are stored in the
-     * <code>components</code> array starting at <code>offset</code> (even
+     * {@code components} array starting at {@code offset} (even
      * if the array is allocated by this method). An
-     * <code>ArrayIndexOutOfBoundsException</code> is thrown if the
-     * <code>components</code> array is not <code>null</code> and is not
+     * {@code ArrayIndexOutOfBoundsException} is thrown if the
+     * {@code components} array is not {@code null} and is not
      * large enough to hold all the color and alpha
-     * components (starting at <code>offset</code>).  An
-     * <code>IllegalArgumentException</code> is thrown if the
-     * <code>normComponents</code> array is not large enough to hold
+     * components (starting at {@code offset}).  An
+     * {@code IllegalArgumentException} is thrown if the
+     * {@code normComponents} array is not large enough to hold
      * all the color and alpha components starting at
-     * <code>normOffset</code>.
+     * {@code normOffset}.
      * @param normComponents an array containing normalized components
-     * @param normOffset the offset into the <code>normComponents</code>
+     * @param normOffset the offset into the {@code normComponents}
      * array at which to start retrieving normalized components
      * @param components an array that receives the components from
-     * <code>normComponents</code>
-     * @param offset the index into <code>components</code> at which to
+     * {@code normComponents}
+     * @param offset the index into {@code components} at which to
      * begin storing normalized components from
-     * <code>normComponents</code>
+     * {@code normComponents}
      * @return an array containing unnormalized color and alpha
      * components.
      * @throws IllegalArgumentException If the component values for this
-     * <CODE>ColorModel</CODE> are not conveniently representable in the
+     * {@code ColorModel} are not conveniently representable in the
      * unnormalized form.
      * @throws IllegalArgumentException if the length of
-     *          <code>normComponents</code> minus <code>normOffset</code>
-     *          is less than <code>numComponents</code>
+     *          {@code normComponents} minus {@code normOffset}
+     *          is less than {@code numComponents}
      * @throws UnsupportedOperationException if the
-     *          constructor of this <code>ColorModel</code> called the
-     *          <code>super(bits)</code> constructor, but did not
+     *          constructor of this {@code ColorModel} called the
+     *          {@code super(bits)} constructor, but did not
      *          override this method.  See the constructor,
      *          {@link #ColorModel(int)}.
      */
     public int[] getUnnormalizedComponents(float[] normComponents,
                                            int normOffset,

@@ -1103,49 +1103,49 @@
      * Returns an array of all of the color/alpha components in normalized
      * form, given an unnormalized component array.  Unnormalized components
      * are unsigned integral values between 0 and 2<sup>n</sup> - 1, where
      * n is the number of bits for a particular component.  Normalized
      * components are float values between a per component minimum and
-     * maximum specified by the <code>ColorSpace</code> object for this
-     * <code>ColorModel</code>.  An <code>IllegalArgumentException</code>
+     * maximum specified by the {@code ColorSpace} object for this
+     * {@code ColorModel}.  An {@code IllegalArgumentException}
      * will be thrown if color component values for this
-     * <code>ColorModel</code> are not conveniently representable in the
+     * {@code ColorModel} are not conveniently representable in the
      * unnormalized form.  If the
-     * <code>normComponents</code> array is <code>null</code>, a new array
-     * will be allocated.  The <code>normComponents</code> array
+     * {@code normComponents} array is {@code null}, a new array
+     * will be allocated.  The {@code normComponents} array
      * will be returned.  Color/alpha components are stored in the
-     * <code>normComponents</code> array starting at
-     * <code>normOffset</code> (even if the array is allocated by this
-     * method).  An <code>ArrayIndexOutOfBoundsException</code> is thrown
-     * if the <code>normComponents</code> array is not <code>null</code>
+     * {@code normComponents} array starting at
+     * {@code normOffset} (even if the array is allocated by this
+     * method).  An {@code ArrayIndexOutOfBoundsException} is thrown
+     * if the {@code normComponents} array is not {@code null}
      * and is not large enough to hold all the color and alpha components
-     * (starting at <code>normOffset</code>).  An
-     * <code>IllegalArgumentException</code> is thrown if the
-     * <code>components</code> array is not large enough to hold all the
-     * color and alpha components starting at <code>offset</code>.
+     * (starting at {@code normOffset}).  An
+     * {@code IllegalArgumentException} is thrown if the
+     * {@code components} array is not large enough to hold all the
+     * color and alpha components starting at {@code offset}.
      * <p>
-     * Since <code>ColorModel</code> is an abstract class,
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  The default implementation
      * of this method in this abstract class assumes that component values
      * for this class are conveniently representable in the unnormalized
      * form.  Therefore, subclasses which may
      * have instances which do not support the unnormalized form must
      * override this method.
      * @param components an array containing unnormalized components
-     * @param offset the offset into the <code>components</code> array at
+     * @param offset the offset into the {@code components} array at
      * which to start retrieving unnormalized components
      * @param normComponents an array that receives the normalized components
-     * @param normOffset the index into <code>normComponents</code> at
+     * @param normOffset the index into {@code normComponents} at
      * which to begin storing normalized components
      * @return an array containing normalized color and alpha
      * components.
      * @throws IllegalArgumentException If the component values for this
-     * <CODE>ColorModel</CODE> are not conveniently representable in the
+     * {@code ColorModel} are not conveniently representable in the
      * unnormalized form.
      * @throws UnsupportedOperationException if the
-     *          constructor of this <code>ColorModel</code> called the
-     *          <code>super(bits)</code> constructor, but did not
+     *          constructor of this {@code ColorModel} called the
+     *          {@code super(bits)} constructor, but did not
      *          override this method.  See the constructor,
      *          {@link #ColorModel(int)}.
      * @throws UnsupportedOperationException if this method is unable
      *          to determine the number of bits per component
      */

@@ -1201,175 +1201,175 @@
 
         return normComponents;
     }
 
     /**
-     * Returns a pixel value represented as an <code>int</code> in this
-     * <code>ColorModel</code>, given an array of unnormalized color/alpha
+     * Returns a pixel value represented as an {@code int} in this
+     * {@code ColorModel}, given an array of unnormalized color/alpha
      * components.  This method will throw an
-     * <code>IllegalArgumentException</code> if component values for this
-     * <code>ColorModel</code> are not conveniently representable as a
-     * single <code>int</code> or if color component values for this
-     * <code>ColorModel</code> are not conveniently representable in the
+     * {@code IllegalArgumentException} if component values for this
+     * {@code ColorModel} are not conveniently representable as a
+     * single {@code int} or if color component values for this
+     * {@code ColorModel} are not conveniently representable in the
      * unnormalized form.  An
-     * <code>ArrayIndexOutOfBoundsException</code> is thrown if  the
-     * <code>components</code> array is not large enough to hold all the
-     * color and alpha components (starting at <code>offset</code>).
-     * Since <code>ColorModel</code> is an abstract class,
+     * {@code ArrayIndexOutOfBoundsException} is thrown if  the
+     * {@code components} array is not large enough to hold all the
+     * color and alpha components (starting at {@code offset}).
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  Subclasses must
      * override this method since the implementation in this abstract
-     * class throws an <code>UnsupportedOperationException</code>.
+     * class throws an {@code UnsupportedOperationException}.
      * @param components an array of unnormalized color and alpha
      * components
-     * @param offset the index into <code>components</code> at which to
+     * @param offset the index into {@code components} at which to
      * begin retrieving the color and alpha components
-     * @return an <code>int</code> pixel value in this
-     * <code>ColorModel</code> corresponding to the specified components.
+     * @return an {@code int} pixel value in this
+     * {@code ColorModel} corresponding to the specified components.
      * @throws IllegalArgumentException if
-     *  pixel values for this <code>ColorModel</code> are not
-     *  conveniently representable as a single <code>int</code>
+     *  pixel values for this {@code ColorModel} are not
+     *  conveniently representable as a single {@code int}
      * @throws IllegalArgumentException if
-     *  component values for this <code>ColorModel</code> are not
+     *  component values for this {@code ColorModel} are not
      *  conveniently representable in the unnormalized form
      * @throws ArrayIndexOutOfBoundsException if
-     *  the <code>components</code> array is not large enough to
+     *  the {@code components} array is not large enough to
      *  hold all of the color and alpha components starting at
-     *  <code>offset</code>
+     *  {@code offset}
      * @throws UnsupportedOperationException if this
-     *  method is not supported by this <code>ColorModel</code>
+     *  method is not supported by this {@code ColorModel}
      */
     public int getDataElement(int[] components, int offset) {
         throw new UnsupportedOperationException("This method is not supported "+
                                     "by this color model.");
     }
 
     /**
      * Returns a data element array representation of a pixel in this
-     * <code>ColorModel</code>, given an array of unnormalized color/alpha
+     * {@code ColorModel}, given an array of unnormalized color/alpha
      * components.  This array can then be passed to the
-     * <code>setDataElements</code> method of a <code>WritableRaster</code>
-     * object.  This method will throw an <code>IllegalArgumentException</code>
-     * if color component values for this <code>ColorModel</code> are not
+     * {@code setDataElements} method of a {@code WritableRaster}
+     * object.  This method will throw an {@code IllegalArgumentException}
+     * if color component values for this {@code ColorModel} are not
      * conveniently representable in the unnormalized form.
-     * An <code>ArrayIndexOutOfBoundsException</code> is thrown
-     * if the <code>components</code> array is not large enough to hold
+     * An {@code ArrayIndexOutOfBoundsException} is thrown
+     * if the {@code components} array is not large enough to hold
      * all the color and alpha components (starting at
-     * <code>offset</code>).  If the <code>obj</code> variable is
-     * <code>null</code>, a new array will be allocated.  If
-     * <code>obj</code> is not <code>null</code>, it must be a primitive
+     * {@code offset}).  If the {@code obj} variable is
+     * {@code null}, a new array will be allocated.  If
+     * {@code obj} is not {@code null}, it must be a primitive
      * array of type transferType; otherwise, a
-     * <code>ClassCastException</code> is thrown.  An
-     * <code>ArrayIndexOutOfBoundsException</code> is thrown if
-     * <code>obj</code> is not large enough to hold a pixel value for this
-     * <code>ColorModel</code>.
-     * Since <code>ColorModel</code> is an abstract class,
+     * {@code ClassCastException} is thrown.  An
+     * {@code ArrayIndexOutOfBoundsException} is thrown if
+     * {@code obj} is not large enough to hold a pixel value for this
+     * {@code ColorModel}.
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  Subclasses must
      * override this method since the implementation in this abstract
-     * class throws an <code>UnsupportedOperationException</code>.
+     * class throws an {@code UnsupportedOperationException}.
      * @param components an array of unnormalized color and alpha
      * components
-     * @param offset the index into <code>components</code> at which to
+     * @param offset the index into {@code components} at which to
      * begin retrieving color and alpha components
-     * @param obj the <code>Object</code> representing an array of color
+     * @param obj the {@code Object} representing an array of color
      * and alpha components
-     * @return an <code>Object</code> representing an array of color and
+     * @return an {@code Object} representing an array of color and
      * alpha components.
-     * @throws ClassCastException if <code>obj</code>
-     *  is not a primitive array of type <code>transferType</code>
+     * @throws ClassCastException if {@code obj}
+     *  is not a primitive array of type {@code transferType}
      * @throws ArrayIndexOutOfBoundsException if
-     *  <code>obj</code> is not large enough to hold a pixel value
-     *  for this <code>ColorModel</code> or the <code>components</code>
+     *  {@code obj} is not large enough to hold a pixel value
+     *  for this {@code ColorModel} or the {@code components}
      *  array is not large enough to hold all of the color and alpha
-     *  components starting at <code>offset</code>
+     *  components starting at {@code offset}
      * @throws IllegalArgumentException if
-     *  component values for this <code>ColorModel</code> are not
+     *  component values for this {@code ColorModel} are not
      *  conveniently representable in the unnormalized form
      * @throws UnsupportedOperationException if this
-     *  method is not supported by this <code>ColorModel</code>
+     *  method is not supported by this {@code ColorModel}
      * @see WritableRaster#setDataElements
      * @see SampleModel#setDataElements
      */
     public Object getDataElements(int[] components, int offset, Object obj) {
         throw new UnsupportedOperationException("This method has not been implemented "+
                                     "for this color model.");
     }
 
     /**
-     * Returns a pixel value represented as an <code>int</code> in this
-     * <code>ColorModel</code>, given an array of normalized color/alpha
+     * Returns a pixel value represented as an {@code int} in this
+     * {@code ColorModel}, given an array of normalized color/alpha
      * components.  This method will throw an
-     * <code>IllegalArgumentException</code> if pixel values for this
-     * <code>ColorModel</code> are not conveniently representable as a
-     * single <code>int</code>.  An
-     * <code>ArrayIndexOutOfBoundsException</code> is thrown if  the
-     * <code>normComponents</code> array is not large enough to hold all the
-     * color and alpha components (starting at <code>normOffset</code>).
-     * Since <code>ColorModel</code> is an abstract class,
+     * {@code IllegalArgumentException} if pixel values for this
+     * {@code ColorModel} are not conveniently representable as a
+     * single {@code int}.  An
+     * {@code ArrayIndexOutOfBoundsException} is thrown if  the
+     * {@code normComponents} array is not large enough to hold all the
+     * color and alpha components (starting at {@code normOffset}).
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  The default implementation
      * of this method in this abstract class first converts from the
      * normalized form to the unnormalized form and then calls
-     * <code>getDataElement(int[], int)</code>.  Subclasses which may
+     * {@code getDataElement(int[], int)}.  Subclasses which may
      * have instances which do not support the unnormalized form must
      * override this method.
      * @param normComponents an array of normalized color and alpha
      * components
-     * @param normOffset the index into <code>normComponents</code> at which to
+     * @param normOffset the index into {@code normComponents} at which to
      * begin retrieving the color and alpha components
-     * @return an <code>int</code> pixel value in this
-     * <code>ColorModel</code> corresponding to the specified components.
+     * @return an {@code int} pixel value in this
+     * {@code ColorModel} corresponding to the specified components.
      * @throws IllegalArgumentException if
-     *  pixel values for this <code>ColorModel</code> are not
-     *  conveniently representable as a single <code>int</code>
+     *  pixel values for this {@code ColorModel} are not
+     *  conveniently representable as a single {@code int}
      * @throws ArrayIndexOutOfBoundsException if
-     *  the <code>normComponents</code> array is not large enough to
+     *  the {@code normComponents} array is not large enough to
      *  hold all of the color and alpha components starting at
-     *  <code>normOffset</code>
+     *  {@code normOffset}
      * @since 1.4
      */
     public int getDataElement(float[] normComponents, int normOffset) {
         int components[] = getUnnormalizedComponents(normComponents,
                                                      normOffset, null, 0);
         return getDataElement(components, 0);
     }
 
     /**
      * Returns a data element array representation of a pixel in this
-     * <code>ColorModel</code>, given an array of normalized color/alpha
+     * {@code ColorModel}, given an array of normalized color/alpha
      * components.  This array can then be passed to the
-     * <code>setDataElements</code> method of a <code>WritableRaster</code>
-     * object.  An <code>ArrayIndexOutOfBoundsException</code> is thrown
-     * if the <code>normComponents</code> array is not large enough to hold
+     * {@code setDataElements} method of a {@code WritableRaster}
+     * object.  An {@code ArrayIndexOutOfBoundsException} is thrown
+     * if the {@code normComponents} array is not large enough to hold
      * all the color and alpha components (starting at
-     * <code>normOffset</code>).  If the <code>obj</code> variable is
-     * <code>null</code>, a new array will be allocated.  If
-     * <code>obj</code> is not <code>null</code>, it must be a primitive
+     * {@code normOffset}).  If the {@code obj} variable is
+     * {@code null}, a new array will be allocated.  If
+     * {@code obj} is not {@code null}, it must be a primitive
      * array of type transferType; otherwise, a
-     * <code>ClassCastException</code> is thrown.  An
-     * <code>ArrayIndexOutOfBoundsException</code> is thrown if
-     * <code>obj</code> is not large enough to hold a pixel value for this
-     * <code>ColorModel</code>.
-     * Since <code>ColorModel</code> is an abstract class,
+     * {@code ClassCastException} is thrown.  An
+     * {@code ArrayIndexOutOfBoundsException} is thrown if
+     * {@code obj} is not large enough to hold a pixel value for this
+     * {@code ColorModel}.
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  The default implementation
      * of this method in this abstract class first converts from the
      * normalized form to the unnormalized form and then calls
-     * <code>getDataElement(int[], int, Object)</code>.  Subclasses which may
+     * {@code getDataElement(int[], int, Object)}.  Subclasses which may
      * have instances which do not support the unnormalized form must
      * override this method.
      * @param normComponents an array of normalized color and alpha
      * components
-     * @param normOffset the index into <code>normComponents</code> at which to
+     * @param normOffset the index into {@code normComponents} at which to
      * begin retrieving color and alpha components
      * @param obj a primitive data array to hold the returned pixel
-     * @return an <code>Object</code> which is a primitive data array
+     * @return an {@code Object} which is a primitive data array
      * representation of a pixel
-     * @throws ClassCastException if <code>obj</code>
-     *  is not a primitive array of type <code>transferType</code>
+     * @throws ClassCastException if {@code obj}
+     *  is not a primitive array of type {@code transferType}
      * @throws ArrayIndexOutOfBoundsException if
-     *  <code>obj</code> is not large enough to hold a pixel value
-     *  for this <code>ColorModel</code> or the <code>normComponents</code>
+     *  {@code obj} is not large enough to hold a pixel value
+     *  for this {@code ColorModel} or the {@code normComponents}
      *  array is not large enough to hold all of the color and alpha
-     *  components starting at <code>normOffset</code>
+     *  components starting at {@code normOffset}
      * @see WritableRaster#setDataElements
      * @see SampleModel#setDataElements
      * @since 1.4
      */
     public Object getDataElements(float[] normComponents, int normOffset,

@@ -1379,55 +1379,55 @@
         return getDataElements(components, 0, obj);
     }
 
     /**
      * Returns an array of all of the color/alpha components in normalized
-     * form, given a pixel in this <code>ColorModel</code>.  The pixel
+     * form, given a pixel in this {@code ColorModel}.  The pixel
      * value is specified by an array of data elements of type transferType
      * passed in as an object reference.  If pixel is not a primitive array
-     * of type transferType, a <code>ClassCastException</code> is thrown.
-     * An <code>ArrayIndexOutOfBoundsException</code> is thrown if
-     * <code>pixel</code> is not large enough to hold a pixel value for this
-     * <code>ColorModel</code>.
+     * of type transferType, a {@code ClassCastException} is thrown.
+     * An {@code ArrayIndexOutOfBoundsException} is thrown if
+     * {@code pixel} is not large enough to hold a pixel value for this
+     * {@code ColorModel}.
      * Normalized components are float values between a per component minimum
-     * and maximum specified by the <code>ColorSpace</code> object for this
-     * <code>ColorModel</code>.  If the
-     * <code>normComponents</code> array is <code>null</code>, a new array
-     * will be allocated.  The <code>normComponents</code> array
+     * and maximum specified by the {@code ColorSpace} object for this
+     * {@code ColorModel}.  If the
+     * {@code normComponents} array is {@code null}, a new array
+     * will be allocated.  The {@code normComponents} array
      * will be returned.  Color/alpha components are stored in the
-     * <code>normComponents</code> array starting at
-     * <code>normOffset</code> (even if the array is allocated by this
-     * method).  An <code>ArrayIndexOutOfBoundsException</code> is thrown
-     * if the <code>normComponents</code> array is not <code>null</code>
+     * {@code normComponents} array starting at
+     * {@code normOffset} (even if the array is allocated by this
+     * method).  An {@code ArrayIndexOutOfBoundsException} is thrown
+     * if the {@code normComponents} array is not {@code null}
      * and is not large enough to hold all the color and alpha components
-     * (starting at <code>normOffset</code>).
-     * Since <code>ColorModel</code> is an abstract class,
+     * (starting at {@code normOffset}).
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  The default implementation
      * of this method in this abstract class first retrieves color and alpha
      * components in the unnormalized form using
-     * <code>getComponents(Object, int[], int)</code> and then calls
-     * <code>getNormalizedComponents(int[], int, float[], int)</code>.
+     * {@code getComponents(Object, int[], int)} and then calls
+     * {@code getNormalizedComponents(int[], int, float[], int)}.
      * Subclasses which may
      * have instances which do not support the unnormalized form must
      * override this method.
      * @param pixel the specified pixel
      * @param normComponents an array to receive the normalized components
-     * @param normOffset the offset into the <code>normComponents</code>
+     * @param normOffset the offset into the {@code normComponents}
      * array at which to start storing normalized components
      * @return an array containing normalized color and alpha
      * components.
-     * @throws ClassCastException if <code>pixel</code> is not a primitive
+     * @throws ClassCastException if {@code pixel} is not a primitive
      *          array of type transferType
      * @throws ArrayIndexOutOfBoundsException if
-     *          <code>normComponents</code> is not large enough to hold all
-     *          color and alpha components starting at <code>normOffset</code>
+     *          {@code normComponents} is not large enough to hold all
+     *          color and alpha components starting at {@code normOffset}
      * @throws ArrayIndexOutOfBoundsException if
-     *          <code>pixel</code> is not large enough to hold a pixel
-     *          value for this <code>ColorModel</code>.
+     *          {@code pixel} is not large enough to hold a pixel
+     *          value for this {@code ColorModel}.
      * @throws UnsupportedOperationException if the
-     *          constructor of this <code>ColorModel</code> called the
-     *          <code>super(bits)</code> constructor, but did not
+     *          constructor of this {@code ColorModel} called the
+     *          {@code super(bits)} constructor, but did not
      *          override this method.  See the constructor,
      *          {@link #ColorModel(int)}.
      * @throws UnsupportedOperationException if this method is unable
      *          to determine the number of bits per component
      * @since 1.4

@@ -1439,17 +1439,17 @@
         return getNormalizedComponents(components, 0,
                                        normComponents, normOffset);
     }
 
     /**
-     * Tests if the specified <code>Object</code> is an instance of
-     * <code>ColorModel</code> and if it equals this
-     * <code>ColorModel</code>.
-     * @param obj the <code>Object</code> to test for equality
-     * @return <code>true</code> if the specified <code>Object</code>
-     * is an instance of <code>ColorModel</code> and equals this
-     * <code>ColorModel</code>; <code>false</code> otherwise.
+     * Tests if the specified {@code Object} is an instance of
+     * {@code ColorModel} and if it equals this
+     * {@code ColorModel}.
+     * @param obj the {@code Object} to test for equality
+     * @return {@code true} if the specified {@code Object}
+     * is an instance of {@code ColorModel} and equals this
+     * {@code ColorModel}; {@code false} otherwise.
      */
     public boolean equals(Object obj) {
         if (!(obj instanceof ColorModel)) {
             return false;
         }

@@ -1505,171 +1505,171 @@
 
         return result;
     }
 
     /**
-     * Returns the <code>ColorSpace</code> associated with this
-     * <code>ColorModel</code>.
-     * @return the <code>ColorSpace</code> of this
-     * <code>ColorModel</code>.
+     * Returns the {@code ColorSpace} associated with this
+     * {@code ColorModel}.
+     * @return the {@code ColorSpace} of this
+     * {@code ColorModel}.
      */
     public final ColorSpace getColorSpace() {
         return colorSpace;
     }
 
     /**
      * Forces the raster data to match the state specified in the
-     * <code>isAlphaPremultiplied</code> variable, assuming the data is
-     * currently correctly described by this <code>ColorModel</code>.  It
+     * {@code isAlphaPremultiplied} variable, assuming the data is
+     * currently correctly described by this {@code ColorModel}.  It
      * may multiply or divide the color raster data by alpha, or do
      * nothing if the data is in the correct state.  If the data needs to
      * be coerced, this method will also return an instance of this
-     * <code>ColorModel</code> with the <code>isAlphaPremultiplied</code>
+     * {@code ColorModel} with the {@code isAlphaPremultiplied}
      * flag set appropriately.  This method will throw a
-     * <code>UnsupportedOperationException</code> if it is not supported
-     * by this <code>ColorModel</code>.
-     * Since <code>ColorModel</code> is an abstract class,
+     * {@code UnsupportedOperationException} if it is not supported
+     * by this {@code ColorModel}.
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  Subclasses must
      * override this method since the implementation in this abstract
-     * class throws an <code>UnsupportedOperationException</code>.
-     * @param raster the <code>WritableRaster</code> data
-     * @param isAlphaPremultiplied <code>true</code> if the alpha is
-     * premultiplied; <code>false</code> otherwise
-     * @return a <code>ColorModel</code> object that represents the
+     * class throws an {@code UnsupportedOperationException}.
+     * @param raster the {@code WritableRaster} data
+     * @param isAlphaPremultiplied {@code true} if the alpha is
+     * premultiplied; {@code false} otherwise
+     * @return a {@code ColorModel} object that represents the
      * coerced data.
      */
     public ColorModel coerceData (WritableRaster raster,
                                   boolean isAlphaPremultiplied) {
         throw new UnsupportedOperationException
             ("This method is not supported by this color model");
     }
 
     /**
-      * Returns <code>true</code> if <code>raster</code> is compatible
-      * with this <code>ColorModel</code> and <code>false</code> if it is
+      * Returns {@code true} if {@code raster} is compatible
+      * with this {@code ColorModel} and {@code false} if it is
       * not.
-      * Since <code>ColorModel</code> is an abstract class,
+      * Since {@code ColorModel} is an abstract class,
       * any instance is an instance of a subclass.  Subclasses must
       * override this method since the implementation in this abstract
-      * class throws an <code>UnsupportedOperationException</code>.
+      * class throws an {@code UnsupportedOperationException}.
       * @param raster the {@link Raster} object to test for compatibility
-      * @return <code>true</code> if <code>raster</code> is compatible
-      * with this <code>ColorModel</code>.
+      * @return {@code true} if {@code raster} is compatible
+      * with this {@code ColorModel}.
       * @throws UnsupportedOperationException if this
       *         method has not been implemented for this
-      *         <code>ColorModel</code>
+      *         {@code ColorModel}
       */
     public boolean isCompatibleRaster(Raster raster) {
         throw new UnsupportedOperationException(
             "This method has not been implemented for this ColorModel.");
     }
 
     /**
-     * Creates a <code>WritableRaster</code> with the specified width and
-     * height that has a data layout (<code>SampleModel</code>) compatible
-     * with this <code>ColorModel</code>.
-     * Since <code>ColorModel</code> is an abstract class,
+     * Creates a {@code WritableRaster} with the specified width and
+     * height that has a data layout ({@code SampleModel}) compatible
+     * with this {@code ColorModel}.
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  Subclasses must
      * override this method since the implementation in this abstract
-     * class throws an <code>UnsupportedOperationException</code>.
-     * @param w the width to apply to the new <code>WritableRaster</code>
-     * @param h the height to apply to the new <code>WritableRaster</code>
-     * @return a <code>WritableRaster</code> object with the specified
+     * class throws an {@code UnsupportedOperationException}.
+     * @param w the width to apply to the new {@code WritableRaster}
+     * @param h the height to apply to the new {@code WritableRaster}
+     * @return a {@code WritableRaster} object with the specified
      * width and height.
      * @throws UnsupportedOperationException if this
-     *          method is not supported by this <code>ColorModel</code>
+     *          method is not supported by this {@code ColorModel}
      * @see WritableRaster
      * @see SampleModel
      */
     public WritableRaster createCompatibleWritableRaster(int w, int h) {
         throw new UnsupportedOperationException
             ("This method is not supported by this color model");
     }
 
     /**
-     * Creates a <code>SampleModel</code> with the specified width and
+     * Creates a {@code SampleModel} with the specified width and
      * height that has a data layout compatible with this
-     * <code>ColorModel</code>.
-     * Since <code>ColorModel</code> is an abstract class,
+     * {@code ColorModel}.
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  Subclasses must
      * override this method since the implementation in this abstract
-     * class throws an <code>UnsupportedOperationException</code>.
-     * @param w the width to apply to the new <code>SampleModel</code>
-     * @param h the height to apply to the new <code>SampleModel</code>
-     * @return a <code>SampleModel</code> object with the specified
+     * class throws an {@code UnsupportedOperationException}.
+     * @param w the width to apply to the new {@code SampleModel}
+     * @param h the height to apply to the new {@code SampleModel}
+     * @return a {@code SampleModel} object with the specified
      * width and height.
      * @throws UnsupportedOperationException if this
-     *          method is not supported by this <code>ColorModel</code>
+     *          method is not supported by this {@code ColorModel}
      * @see SampleModel
      */
     public SampleModel createCompatibleSampleModel(int w, int h) {
         throw new UnsupportedOperationException
             ("This method is not supported by this color model");
     }
 
-    /** Checks if the <code>SampleModel</code> is compatible with this
-     * <code>ColorModel</code>.
-     * Since <code>ColorModel</code> is an abstract class,
+    /** Checks if the {@code SampleModel} is compatible with this
+     * {@code ColorModel}.
+     * Since {@code ColorModel} is an abstract class,
      * any instance is an instance of a subclass.  Subclasses must
      * override this method since the implementation in this abstract
-     * class throws an <code>UnsupportedOperationException</code>.
-     * @param sm the specified <code>SampleModel</code>
-     * @return <code>true</code> if the specified <code>SampleModel</code>
-     * is compatible with this <code>ColorModel</code>; <code>false</code>
+     * class throws an {@code UnsupportedOperationException}.
+     * @param sm the specified {@code SampleModel}
+     * @return {@code true} if the specified {@code SampleModel}
+     * is compatible with this {@code ColorModel}; {@code false}
      * otherwise.
      * @throws UnsupportedOperationException if this
-     *          method is not supported by this <code>ColorModel</code>
+     *          method is not supported by this {@code ColorModel}
      * @see SampleModel
      */
     public boolean isCompatibleSampleModel(SampleModel sm) {
         throw new UnsupportedOperationException
             ("This method is not supported by this color model");
     }
 
     /**
      * Disposes of system resources associated with this
-     * <code>ColorModel</code> once this <code>ColorModel</code> is no
+     * {@code ColorModel} once this {@code ColorModel} is no
      * longer referenced.
      */
     public void finalize() {
     }
 
 
     /**
-     * Returns a <code>Raster</code> representing the alpha channel of an
-     * image, extracted from the input <code>Raster</code>, provided that
-     * pixel values of this <code>ColorModel</code> represent color and
+     * Returns a {@code Raster} representing the alpha channel of an
+     * image, extracted from the input {@code Raster}, provided that
+     * pixel values of this {@code ColorModel} represent color and
      * alpha information as separate spatial bands (e.g.
-     * {@link ComponentColorModel} and <code>DirectColorModel</code>).
-     * This method assumes that <code>Raster</code> objects associated
-     * with such a <code>ColorModel</code> store the alpha band, if
-     * present, as the last band of image data.  Returns <code>null</code>
+     * {@link ComponentColorModel} and {@code DirectColorModel}).
+     * This method assumes that {@code Raster} objects associated
+     * with such a {@code ColorModel} store the alpha band, if
+     * present, as the last band of image data.  Returns {@code null}
      * if there is no separate spatial alpha channel associated with this
-     * <code>ColorModel</code>.  If this is an
-     * <code>IndexColorModel</code> which has alpha in the lookup table,
-     * this method will return <code>null</code> since
+     * {@code ColorModel}.  If this is an
+     * {@code IndexColorModel} which has alpha in the lookup table,
+     * this method will return {@code null} since
      * there is no spatially discrete alpha channel.
-     * This method will create a new <code>Raster</code> (but will share
+     * This method will create a new {@code Raster} (but will share
      * the data array).
-     * Since <code>ColorModel</code> is an abstract class, any instance
+     * Since {@code ColorModel} is an abstract class, any instance
      * is an instance of a subclass.  Subclasses must override this
-     * method to get any behavior other than returning <code>null</code>
+     * method to get any behavior other than returning {@code null}
      * because the implementation in this abstract class returns
-     * <code>null</code>.
-     * @param raster the specified <code>Raster</code>
-     * @return a <code>Raster</code> representing the alpha channel of
-     * an image, obtained from the specified <code>Raster</code>.
+     * {@code null}.
+     * @param raster the specified {@code Raster}
+     * @return a {@code Raster} representing the alpha channel of
+     * an image, obtained from the specified {@code Raster}.
      */
     public WritableRaster getAlphaRaster(WritableRaster raster) {
         return null;
     }
 
     /**
-     * Returns the <code>String</code> representation of the contents of
-     * this <code>ColorModel</code>object.
-     * @return a <code>String</code> representing the contents of this
-     * <code>ColorModel</code> object.
+     * Returns the {@code String} representation of the contents of
+     * this {@code ColorModel} object.
+     * @return a {@code String} representing the contents of this
+     * {@code ColorModel} object.
      */
     public String toString() {
        return new String("ColorModel: #pixelBits = "+pixel_bits
                          + " numComponents = "+numComponents
                          + " color space = "+colorSpace
< prev index next >