< prev index next >

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

Print this page

        

@@ -43,25 +43,25 @@
 import sun.awt.image.OffScreenImageSource;
 import sun.awt.image.ShortComponentRaster;
 
 /**
  *
- * The <code>BufferedImage</code> subclass describes an {@link
+ * The {@code BufferedImage} subclass describes an {@link
  * java.awt.Image Image} with an accessible buffer of image data.
- * A <code>BufferedImage</code> is comprised of a {@link ColorModel} and a
+ * A {@code BufferedImage} is comprised of a {@link ColorModel} and a
  * {@link Raster} of image data.
  * The number and types of bands in the {@link SampleModel} of the
- * <code>Raster</code> must match the number and types required by the
- * <code>ColorModel</code> to represent its color and alpha components.
- * All <code>BufferedImage</code> objects have an upper left corner
- * coordinate of (0,&nbsp;0).  Any <code>Raster</code> used to construct a
- * <code>BufferedImage</code> must therefore have minX=0 and minY=0.
+ * {@code Raster} must match the number and types required by the
+ * {@code ColorModel} to represent its color and alpha components.
+ * All {@code BufferedImage} objects have an upper left corner
+ * coordinate of (0,&nbsp;0).  Any {@code Raster} used to construct a
+ * {@code BufferedImage} must therefore have minX=0 and minY=0.
  *
  * <p>
  * This class relies on the data fetching and setting methods
- * of <code>Raster</code>,
- * and on the color characterization methods of <code>ColorModel</code>.
+ * of {@code Raster},
+ * and on the color characterization methods of {@code ColorModel}.
  *
  * @see ColorModel
  * @see Raster
  * @see WritableRaster
  */

@@ -98,22 +98,22 @@
      */
     public static final int TYPE_INT_RGB = 1;
 
     /**
      * Represents an image with 8-bit RGBA color components packed into
-     * integer pixels.  The image has a <code>DirectColorModel</code>
+     * integer pixels.  The image has a {@code DirectColorModel}
      * with alpha. The color data in this image is considered not to be
      * premultiplied with alpha.  When this type is used as the
-     * <code>imageType</code> argument to a <code>BufferedImage</code>
+     * {@code imageType} argument to a {@code BufferedImage}
      * constructor, the created image is consistent with images
      * created in the JDK1.1 and earlier releases.
      */
     public static final int TYPE_INT_ARGB = 2;
 
     /**
      * Represents an image with 8-bit RGBA color components packed into
-     * integer pixels.  The image has a <code>DirectColorModel</code>
+     * integer pixels.  The image has a {@code DirectColorModel}
      * with alpha.  The color data in this image is considered to be
      * premultiplied with alpha.
      */
     public static final int TYPE_INT_ARGB_PRE = 3;
 

@@ -133,11 +133,11 @@
 
     /**
      * Represents an image with 8-bit RGB color components, corresponding
      * to a Windows-style BGR color model) with the colors Blue, Green,
      * and Red stored in 3 bytes.  There is no alpha.  The image has a
-     * <code>ComponentColorModel</code>.
+     * {@code ComponentColorModel}.
      * When data with non-opaque alpha is stored
      * in an image of this type,
      * the color data must be adjusted to a non-premultiplied form
      * and the alpha discarded,
      * as described in the

@@ -146,32 +146,32 @@
     public static final int TYPE_3BYTE_BGR = 5;
 
     /**
      * Represents an image with 8-bit RGBA color components with the colors
      * Blue, Green, and Red stored in 3 bytes and 1 byte of alpha.  The
-     * image has a <code>ComponentColorModel</code> with alpha.  The
+     * image has a {@code ComponentColorModel} with alpha.  The
      * color data in this image is considered not to be premultiplied with
      * alpha.  The byte data is interleaved in a single
      * byte array in the order A, B, G, R
      * from lower to higher byte addresses within each pixel.
      */
     public static final int TYPE_4BYTE_ABGR = 6;
 
     /**
      * Represents an image with 8-bit RGBA color components with the colors
      * Blue, Green, and Red stored in 3 bytes and 1 byte of alpha.  The
-     * image has a <code>ComponentColorModel</code> with alpha. The color
+     * image has a {@code ComponentColorModel} with alpha. The color
      * data in this image is considered to be premultiplied with alpha.
      * The byte data is interleaved in a single byte array in the order
      * A, B, G, R from lower to higher byte addresses within each pixel.
      */
     public static final int TYPE_4BYTE_ABGR_PRE = 7;
 
     /**
      * Represents an image with 5-6-5 RGB color components (5-bits red,
      * 6-bits green, 5-bits blue) with no alpha.  This image has
-     * a <code>DirectColorModel</code>.
+     * a {@code DirectColorModel}.
      * When data with non-opaque alpha is stored
      * in an image of this type,
      * the color data must be adjusted to a non-premultiplied form
      * and the alpha discarded,
      * as described in the

@@ -180,11 +180,11 @@
     public static final int TYPE_USHORT_565_RGB = 8;
 
     /**
      * Represents an image with 5-5-5 RGB color components (5-bits red,
      * 5-bits green, 5-bits blue) with no alpha.  This image has
-     * a <code>DirectColorModel</code>.
+     * a {@code DirectColorModel}.
      * When data with non-opaque alpha is stored
      * in an image of this type,
      * the color data must be adjusted to a non-premultiplied form
      * and the alpha discarded,
      * as described in the

@@ -192,11 +192,11 @@
      */
     public static final int TYPE_USHORT_555_RGB = 9;
 
     /**
      * Represents a unsigned byte grayscale image, non-indexed.  This
-     * image has a <code>ComponentColorModel</code> with a CS_GRAY
+     * image has a {@code ComponentColorModel} with a CS_GRAY
      * {@link ColorSpace}.
      * When data with non-opaque alpha is stored
      * in an image of this type,
      * the color data must be adjusted to a non-premultiplied form
      * and the alpha discarded,

@@ -205,12 +205,12 @@
      */
     public static final int TYPE_BYTE_GRAY = 10;
 
     /**
      * Represents an unsigned short grayscale image, non-indexed).  This
-     * image has a <code>ComponentColorModel</code> with a CS_GRAY
-     * <code>ColorSpace</code>.
+     * image has a {@code ComponentColorModel} with a CS_GRAY
+     * {@code ColorSpace}.
      * When data with non-opaque alpha is stored
      * in an image of this type,
      * the color data must be adjusted to a non-premultiplied form
      * and the alpha discarded,
      * as described in the

@@ -219,52 +219,52 @@
     public static final int TYPE_USHORT_GRAY = 11;
 
     /**
      * Represents an opaque byte-packed 1, 2, or 4 bit image.  The
      * image has an {@link IndexColorModel} without alpha.  When this
-     * type is used as the <code>imageType</code> argument to the
-     * <code>BufferedImage</code> constructor that takes an
-     * <code>imageType</code> argument but no <code>ColorModel</code>
+     * type is used as the {@code imageType} argument to the
+     * {@code BufferedImage} constructor that takes an
+     * {@code imageType} argument but no {@code ColorModel}
      * argument, a 1-bit image is created with an
-     * <code>IndexColorModel</code> with two colors in the default
-     * sRGB <code>ColorSpace</code>: {0,&nbsp;0,&nbsp;0} and
+     * {@code IndexColorModel} with two colors in the default
+     * sRGB {@code ColorSpace}: {0,&nbsp;0,&nbsp;0} and
      * {255,&nbsp;255,&nbsp;255}.
      *
      * <p> Images with 2 or 4 bits per pixel may be constructed via
-     * the <code>BufferedImage</code> constructor that takes a
-     * <code>ColorModel</code> argument by supplying a
-     * <code>ColorModel</code> with an appropriate map size.
+     * the {@code BufferedImage} constructor that takes a
+     * {@code ColorModel} argument by supplying a
+     * {@code ColorModel} with an appropriate map size.
      *
      * <p> Images with 8 bits per pixel should use the image types
-     * <code>TYPE_BYTE_INDEXED</code> or <code>TYPE_BYTE_GRAY</code>
-     * depending on their <code>ColorModel</code>.
+     * {@code TYPE_BYTE_INDEXED} or {@code TYPE_BYTE_GRAY}
+     * depending on their {@code ColorModel}.
 
      * <p> When color data is stored in an image of this type,
      * the closest color in the colormap is determined
-     * by the <code>IndexColorModel</code> and the resulting index is stored.
+     * by the {@code IndexColorModel} and the resulting index is stored.
      * Approximation and loss of alpha or color components
      * can result, depending on the colors in the
-     * <code>IndexColorModel</code> colormap.
+     * {@code IndexColorModel} colormap.
      */
     public static final int TYPE_BYTE_BINARY = 12;
 
     /**
      * Represents an indexed byte image.  When this type is used as the
-     * <code>imageType</code> argument to the <code>BufferedImage</code>
-     * constructor that takes an <code>imageType</code> argument
-     * but no <code>ColorModel</code> argument, an
-     * <code>IndexColorModel</code> is created with
+     * {@code imageType} argument to the {@code BufferedImage}
+     * constructor that takes an {@code imageType} argument
+     * but no {@code ColorModel} argument, an
+     * {@code IndexColorModel} is created with
      * a 256-color 6/6/6 color cube palette with the rest of the colors
      * from 216-255 populated by grayscale values in the
      * default sRGB ColorSpace.
      *
      * <p> When color data is stored in an image of this type,
      * the closest color in the colormap is determined
-     * by the <code>IndexColorModel</code> and the resulting index is stored.
+     * by the {@code IndexColorModel} and the resulting index is stored.
      * Approximation and loss of alpha or color components
      * can result, depending on the colors in the
-     * <code>IndexColorModel</code> colormap.
+     * {@code IndexColorModel} colormap.
      */
     public static final int TYPE_BYTE_INDEXED = 13;
 
     private static final int DCM_RED_MASK   = 0x00ff0000;
     private static final int DCM_GREEN_MASK = 0x0000ff00;

@@ -286,12 +286,12 @@
         ColorModel.loadLibraries();
         initIDs();
     }
 
     /**
-     * Constructs a <code>BufferedImage</code> of one of the predefined
-     * image types.  The <code>ColorSpace</code> for the image is the
+     * Constructs a {@code BufferedImage} of one of the predefined
+     * image types.  The {@code ColorSpace} for the image is the
      * default sRGB space.
      * @param width     width of the created image
      * @param height    height of the created image
      * @param imageType type of the created image
      * @see ColorSpace

@@ -504,11 +504,11 @@
 
         this.imageType = imageType;
     }
 
     /**
-     * Constructs a <code>BufferedImage</code> of one of the predefined
+     * Constructs a {@code BufferedImage} of one of the predefined
      * image types:
      * TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED.
      *
      * <p> If the image type is TYPE_BYTE_BINARY, the number of
      * entries in the color model is used to determine whether the

@@ -519,11 +519,11 @@
      * pixel.  Otherwise, an IllegalArgumentException will be thrown.
      *
      * @param width     width of the created image
      * @param height    height of the created image
      * @param imageType type of the created image
-     * @param cm        <code>IndexColorModel</code> of the created image
+     * @param cm        {@code IndexColorModel} of the created image
      * @throws IllegalArgumentException   if the imageType is not
      * TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED or if the imageType is
      * TYPE_BYTE_BINARY and the color map has more than 16 entries.
      * @see #TYPE_BYTE_BINARY
      * @see #TYPE_BYTE_INDEXED

@@ -574,35 +574,35 @@
         colorModel = cm;
         this.imageType = imageType;
     }
 
     /**
-     * Constructs a new <code>BufferedImage</code> with a specified
-     * <code>ColorModel</code> and <code>Raster</code>.  If the number and
-     * types of bands in the <code>SampleModel</code> of the
-     * <code>Raster</code> do not match the number and types required by
-     * the <code>ColorModel</code> to represent its color and alpha
+     * Constructs a new {@code BufferedImage} with a specified
+     * {@code ColorModel} and {@code Raster}.  If the number and
+     * types of bands in the {@code SampleModel} of the
+     * {@code Raster} do not match the number and types required by
+     * the {@code ColorModel} to represent its color and alpha
      * components, a {@link RasterFormatException} is thrown.  This
-     * method can multiply or divide the color <code>Raster</code> data by
-     * alpha to match the <code>alphaPremultiplied</code> state
-     * in the <code>ColorModel</code>.  Properties for this
-     * <code>BufferedImage</code> can be established by passing
-     * in a {@link Hashtable} of <code>String</code>/<code>Object</code>
+     * method can multiply or divide the color {@code Raster} data by
+     * alpha to match the {@code alphaPremultiplied} state
+     * in the {@code ColorModel}.  Properties for this
+     * {@code BufferedImage} can be established by passing
+     * in a {@link Hashtable} of {@code String}/{@code Object}
      * pairs.
-     * @param cm <code>ColorModel</code> for the new image
-     * @param raster     <code>Raster</code> for the image data
-     * @param isRasterPremultiplied   if <code>true</code>, the data in
+     * @param cm {@code ColorModel} for the new image
+     * @param raster     {@code Raster} for the image data
+     * @param isRasterPremultiplied   if {@code true}, the data in
      *                  the raster has been premultiplied with alpha.
-     * @param properties <code>Hashtable</code> of
-     *                  <code>String</code>/<code>Object</code> pairs.
+     * @param properties {@code Hashtable} of
+     *                  {@code String}/{@code Object} pairs.
      * @exception RasterFormatException if the number and
-     * types of bands in the <code>SampleModel</code> of the
-     * <code>Raster</code> do not match the number and types required by
-     * the <code>ColorModel</code> to represent its color and alpha
+     * types of bands in the {@code SampleModel} of the
+     * {@code Raster} do not match the number and types required by
+     * the {@code ColorModel} to represent its color and alpha
      * components.
      * @exception IllegalArgumentException if
-     *          <code>raster</code> is incompatible with <code>cm</code>
+     *          {@code raster} is incompatible with {@code cm}
      * @see ColorModel
      * @see Raster
      * @see WritableRaster
      */
 

@@ -822,11 +822,11 @@
     }
 
     /**
      * Returns the image type.  If it is not one of the known types,
      * TYPE_CUSTOM is returned.
-     * @return the image type of this <code>BufferedImage</code>.
+     * @return the image type of this {@code BufferedImage}.
      * @see #TYPE_INT_RGB
      * @see #TYPE_INT_ARGB
      * @see #TYPE_INT_ARGB_PRE
      * @see #TYPE_INT_BGR
      * @see #TYPE_3BYTE_BGR

@@ -843,64 +843,64 @@
     public int getType() {
         return imageType;
     }
 
     /**
-     * Returns the <code>ColorModel</code>.
-     * @return the <code>ColorModel</code> of this
-     *  <code>BufferedImage</code>.
+     * Returns the {@code ColorModel}.
+     * @return the {@code ColorModel} of this
+     *  {@code BufferedImage}.
      */
     public ColorModel getColorModel() {
         return colorModel;
     }
 
     /**
      * Returns the {@link WritableRaster}.
-     * @return the <code>WritableRaster</code> of this
-     *  <code>BufferedImage</code>.
+     * @return the {@code WritableRaster} of this
+     *  {@code BufferedImage}.
      */
     public WritableRaster getRaster() {
         return raster;
     }
 
 
     /**
-     * Returns a <code>WritableRaster</code> representing the alpha
-     * channel for <code>BufferedImage</code> objects
-     * with <code>ColorModel</code> objects that support a separate
-     * spatial alpha channel, such as <code>ComponentColorModel</code> and
-     * <code>DirectColorModel</code>.  Returns <code>null</code> if there
-     * is no alpha channel associated with the <code>ColorModel</code> in
+     * Returns a {@code WritableRaster} representing the alpha
+     * channel for {@code BufferedImage} objects
+     * with {@code ColorModel} objects that support a separate
+     * spatial alpha channel, such as {@code ComponentColorModel} and
+     * {@code DirectColorModel}.  Returns {@code null} if there
+     * is no alpha channel associated with the {@code ColorModel} in
      * this image.  This method assumes that for all
-     * <code>ColorModel</code> objects other than
-     * <code>IndexColorModel</code>, if the <code>ColorModel</code>
+     * {@code ColorModel} objects other than
+     * {@code IndexColorModel}, if the {@code ColorModel}
      * supports alpha, there is a separate alpha channel
      * which is stored as the last band of image data.
-     * If the image uses an <code>IndexColorModel</code> that
+     * If the image uses an {@code IndexColorModel} that
      * has alpha in the lookup table, this method returns
-     * <code>null</code> since there is no spatially discrete alpha
+     * {@code null} since there is no spatially discrete alpha
      * channel.  This method creates a new
-     * <code>WritableRaster</code>, but shares the data array.
-     * @return a <code>WritableRaster</code> or <code>null</code> if this
-     *          <code>BufferedImage</code> has no alpha channel associated
-     *          with its <code>ColorModel</code>.
+     * {@code WritableRaster}, but shares the data array.
+     * @return a {@code WritableRaster} or {@code null} if this
+     *          {@code BufferedImage} has no alpha channel associated
+     *          with its {@code ColorModel}.
      */
     public WritableRaster getAlphaRaster() {
         return colorModel.getAlphaRaster(raster);
     }
 
     /**
      * Returns an integer pixel in the default RGB color model
      * (TYPE_INT_ARGB) and default sRGB colorspace.  Color
      * conversion takes place if this default model does not match
-     * the image <code>ColorModel</code>.  There are only 8-bits of
+     * the image {@code ColorModel}.  There are only 8-bits of
      * precision for each color component in the returned data when using
      * this method.
      *
      * <p>
      *
-     * An <code>ArrayOutOfBoundsException</code> may be thrown
+     * An {@code ArrayOutOfBoundsException} may be thrown
      * if the coordinates are not in bounds.
      * However, explicit bounds checking is not guaranteed.
      *
      * @param x the X coordinate of the pixel from which to get
      *          the pixel in the default RGB color model and sRGB

@@ -920,32 +920,32 @@
     /**
      * Returns an array of integer pixels in the default RGB color model
      * (TYPE_INT_ARGB) and default sRGB color space,
      * from a portion of the image data.  Color conversion takes
      * place if the default model does not match the image
-     * <code>ColorModel</code>.  There are only 8-bits of precision for
+     * {@code ColorModel}.  There are only 8-bits of precision for
      * each color component in the returned data when
      * using this method.  With a specified coordinate (x,&nbsp;y) in the
      * image, the ARGB pixel can be accessed in this way:
      *
      * <pre>
      *    pixel   = rgbArray[offset + (y-startY)*scansize + (x-startX)]; </pre>
      *
      * <p>
      *
-     * An <code>ArrayOutOfBoundsException</code> may be thrown
+     * An {@code ArrayOutOfBoundsException} may be thrown
      * if the region is not in bounds.
      * However, explicit bounds checking is not guaranteed.
      *
      * @param startX      the starting X coordinate
      * @param startY      the starting Y coordinate
      * @param w           width of region
      * @param h           height of region
-     * @param rgbArray    if not <code>null</code>, the rgb pixels are
+     * @param rgbArray    if not {@code null}, the rgb pixels are
      *          written here
-     * @param offset      offset into the <code>rgbArray</code>
-     * @param scansize    scanline stride for the <code>rgbArray</code>
+     * @param offset      offset into the {@code rgbArray}
+     * @param scansize    scanline stride for the {@code rgbArray}
      * @return            array of RGB pixels.
      * @see #setRGB(int, int, int)
      * @see #setRGB(int, int, int, int, int[], int, int)
      */
     public int[] getRGB(int startX, int startY, int w, int h,

@@ -992,19 +992,19 @@
         return rgbArray;
     }
 
 
     /**
-     * Sets a pixel in this <code>BufferedImage</code> to the specified
+     * Sets a pixel in this {@code BufferedImage} to the specified
      * RGB value. The pixel is assumed to be in the default RGB color
      * model, TYPE_INT_ARGB, and default sRGB color space.  For images
-     * with an <code>IndexColorModel</code>, the index with the nearest
+     * with an {@code IndexColorModel}, the index with the nearest
      * color is chosen.
      *
      * <p>
      *
-     * An <code>ArrayOutOfBoundsException</code> may be thrown
+     * An {@code ArrayOutOfBoundsException} may be thrown
      * if the coordinates are not in bounds.
      * However, explicit bounds checking is not guaranteed.
      *
      * @param x the X coordinate of the pixel to set
      * @param y the Y coordinate of the pixel to set

@@ -1019,32 +1019,32 @@
     /**
      * Sets an array of integer pixels in the default RGB color model
      * (TYPE_INT_ARGB) and default sRGB color space,
      * into a portion of the image data.  Color conversion takes place
      * if the default model does not match the image
-     * <code>ColorModel</code>.  There are only 8-bits of precision for
+     * {@code ColorModel}.  There are only 8-bits of precision for
      * each color component in the returned data when
      * using this method.  With a specified coordinate (x,&nbsp;y) in the
      * this image, the ARGB pixel can be accessed in this way:
      * <pre>
      *    pixel   = rgbArray[offset + (y-startY)*scansize + (x-startX)];
      * </pre>
      * WARNING: No dithering takes place.
      *
      * <p>
      *
-     * An <code>ArrayOutOfBoundsException</code> may be thrown
+     * An {@code ArrayOutOfBoundsException} may be thrown
      * if the region is not in bounds.
      * However, explicit bounds checking is not guaranteed.
      *
      * @param startX      the starting X coordinate
      * @param startY      the starting Y coordinate
      * @param w           width of the region
      * @param h           height of the region
      * @param rgbArray    the rgb pixels
-     * @param offset      offset into the <code>rgbArray</code>
-     * @param scansize    scanline stride for the <code>rgbArray</code>
+     * @param offset      offset into the {@code rgbArray}
+     * @param scansize    scanline stride for the {@code rgbArray}
      * @see #getRGB(int, int)
      * @see #getRGB(int, int, int, int, int[], int, int)
      */
     public void setRGB(int startX, int startY, int w, int h,
                         int[] rgbArray, int offset, int scansize) {

@@ -1061,38 +1061,38 @@
         }
     }
 
 
     /**
-     * Returns the width of the <code>BufferedImage</code>.
-     * @return the width of this <code>BufferedImage</code>
+     * Returns the width of the {@code BufferedImage}.
+     * @return the width of this {@code BufferedImage}
      */
     public int getWidth() {
         return raster.getWidth();
     }
 
     /**
-     * Returns the height of the <code>BufferedImage</code>.
-     * @return the height of this <code>BufferedImage</code>
+     * Returns the height of the {@code BufferedImage}.
+     * @return the height of this {@code BufferedImage}
      */
     public int getHeight() {
         return raster.getHeight();
     }
 
     /**
-     * Returns the width of the <code>BufferedImage</code>.
+     * Returns the width of the {@code BufferedImage}.
      * @param observer ignored
-     * @return the width of this <code>BufferedImage</code>
+     * @return the width of this {@code BufferedImage}
      */
     public int getWidth(ImageObserver observer) {
         return raster.getWidth();
     }
 
     /**
-     * Returns the height of the <code>BufferedImage</code>.
+     * Returns the height of the {@code BufferedImage}.
      * @param observer ignored
-     * @return the height of this <code>BufferedImage</code>
+     * @return the height of this {@code BufferedImage}
      */
     public int getHeight(ImageObserver observer) {
         return raster.getHeight();
     }
 

@@ -1115,21 +1115,21 @@
 
     /**
      * Returns a property of the image by name.  Individual property names
      * are defined by the various image formats.  If a property is not
      * defined for a particular image, this method returns the
-     * <code>UndefinedProperty</code> field.  If the properties
+     * {@code UndefinedProperty} field.  If the properties
      * for this image are not yet known, then this method returns
-     * <code>null</code> and the <code>ImageObserver</code> object is
+     * {@code null} and the {@code ImageObserver} object is
      * notified later.  The property name "comment" should be used to
      * store an optional comment that can be presented to the user as a
      * description of the image, its source, or its author.
      * @param name the property name
-     * @param observer the <code>ImageObserver</code> that receives
+     * @param observer the {@code ImageObserver} that receives
      *  notification regarding image information
      * @return an {@link Object} that is the property referred to by the
-     *          specified <code>name</code> or <code>null</code> if the
+     *          specified {@code name} or {@code null} if the
      *          properties of this image are not yet known.
      * @throws NullPointerException if the property name is null.
      * @see ImageObserver
      * @see java.awt.Image#UndefinedProperty
      */

@@ -1138,12 +1138,12 @@
     }
 
     /**
      * Returns a property of the image by name.
      * @param name the property name
-     * @return an <code>Object</code> that is the property referred to by
-     *          the specified <code>name</code>.
+     * @return an {@code Object} that is the property referred to by
+     *          the specified {@code name}.
      * @throws NullPointerException if the property name is null.
      */
     public Object getProperty(String name) {
         if (name == null) {
             throw new NullPointerException("null property name is not allowed");

@@ -1160,44 +1160,44 @@
 
     /**
      * This method returns a {@link Graphics2D}, but is here
      * for backwards compatibility.  {@link #createGraphics() createGraphics} is more
      * convenient, since it is declared to return a
-     * <code>Graphics2D</code>.
-     * @return a <code>Graphics2D</code>, which can be used to draw into
+     * {@code Graphics2D}.
+     * @return a {@code Graphics2D}, which can be used to draw into
      *          this image.
      */
     public java.awt.Graphics getGraphics() {
         return createGraphics();
     }
 
     /**
-     * Creates a <code>Graphics2D</code>, which can be used to draw into
-     * this <code>BufferedImage</code>.
-     * @return a <code>Graphics2D</code>, used for drawing into this
+     * Creates a {@code Graphics2D}, which can be used to draw into
+     * this {@code BufferedImage}.
+     * @return a {@code Graphics2D}, used for drawing into this
      *          image.
      */
     public Graphics2D createGraphics() {
         GraphicsEnvironment env =
             GraphicsEnvironment.getLocalGraphicsEnvironment();
         return env.createGraphics(this);
     }
 
     /**
      * Returns a subimage defined by a specified rectangular region.
-     * The returned <code>BufferedImage</code> shares the same
+     * The returned {@code BufferedImage} shares the same
      * data array as the original image.
      * @param x the X coordinate of the upper-left corner of the
      *          specified rectangular region
      * @param y the Y coordinate of the upper-left corner of the
      *          specified rectangular region
      * @param w the width of the specified rectangular region
      * @param h the height of the specified rectangular region
-     * @return a <code>BufferedImage</code> that is the subimage of this
-     *          <code>BufferedImage</code>.
+     * @return a {@code BufferedImage} that is the subimage of this
+     *          {@code BufferedImage}.
      * @exception RasterFormatException if the specified
-     * area is not contained within this <code>BufferedImage</code>.
+     * area is not contained within this {@code BufferedImage}.
      */
     public BufferedImage getSubimage (int x, int y, int w, int h) {
         return new BufferedImage (colorModel,
                                   raster.createWritableChild(x, y, w, h,
                                                              0, 0, null),

@@ -1205,72 +1205,72 @@
                                   properties);
     }
 
     /**
      * Returns whether or not the alpha has been premultiplied.  It
-     * returns <code>false</code> if there is no alpha.
-     * @return <code>true</code> if the alpha has been premultiplied;
-     *          <code>false</code> otherwise.
+     * returns {@code false} if there is no alpha.
+     * @return {@code true} if the alpha has been premultiplied;
+     *          {@code false} otherwise.
      */
     public boolean isAlphaPremultiplied() {
         return colorModel.isAlphaPremultiplied();
     }
 
     /**
      * Forces the data to match the state specified in the
-     * <code>isAlphaPremultiplied</code> variable.  It may multiply or
+     * {@code isAlphaPremultiplied} variable.  It may multiply or
      * divide the color raster data by alpha, or do nothing if the data is
      * in the correct state.
-     * @param isAlphaPremultiplied <code>true</code> if the alpha has been
-     *          premultiplied; <code>false</code> otherwise.
+     * @param isAlphaPremultiplied {@code true} if the alpha has been
+     *          premultiplied; {@code false} otherwise.
      */
     public void coerceData (boolean isAlphaPremultiplied) {
         if (colorModel.hasAlpha() &&
             colorModel.isAlphaPremultiplied() != isAlphaPremultiplied) {
             // Make the color model do the conversion
             colorModel = colorModel.coerceData (raster, isAlphaPremultiplied);
         }
     }
 
     /**
-     * Returns a <code>String</code> representation of this
-     * <code>BufferedImage</code> object and its values.
-     * @return a <code>String</code> representing this
-     *          <code>BufferedImage</code>.
+     * Returns a {@code String} representation of this
+     * {@code BufferedImage} object and its values.
+     * @return a {@code String} representing this
+     *          {@code BufferedImage}.
      */
     public String toString() {
         return "BufferedImage@"+Integer.toHexString(hashCode())
             +": type = "+imageType
             +" "+colorModel+" "+raster;
     }
 
     /**
      * Returns a {@link Vector} of {@link RenderedImage} objects that are
      * the immediate sources, not the sources of these immediate sources,
-     * of image data for this <code>BufferedImage</code>.  This
-     * method returns <code>null</code> if the <code>BufferedImage</code>
+     * of image data for this {@code BufferedImage}.  This
+     * method returns {@code null} if the {@code BufferedImage}
      * has no information about its immediate sources.  It returns an
-     * empty <code>Vector</code> if the <code>BufferedImage</code> has no
+     * empty {@code Vector} if the {@code BufferedImage} has no
      * immediate sources.
-     * @return a <code>Vector</code> containing immediate sources of
-     *          this <code>BufferedImage</code> object's image date, or
-     *          <code>null</code> if this <code>BufferedImage</code> has
+     * @return a {@code Vector} containing immediate sources of
+     *          this {@code BufferedImage} object's image date, or
+     *          {@code null} if this {@code BufferedImage} has
      *          no information about its immediate sources, or an empty
-     *          <code>Vector</code> if this <code>BufferedImage</code>
+     *          {@code Vector} if this {@code BufferedImage}
      *          has no immediate sources.
      */
     public Vector<RenderedImage> getSources() {
         return null;
     }
 
     /**
      * Returns an array of names recognized by
      * {@link #getProperty(String) getProperty(String)}
-     * or <code>null</code>, if no property names are recognized.
-     * @return a <code>String</code> array containing all of the property
-     *          names that <code>getProperty(String)</code> recognizes;
-     *          or <code>null</code> if no property names are recognized.
+     * or {@code null}, if no property names are recognized.
+     * @return a {@code String} array containing all of the property
+     *          names that {@code getProperty(String)} recognizes;
+     *          or {@code null} if no property names are recognized.
      */
     public String[] getPropertyNames() {
         if (properties == null || properties.isEmpty()) {
             return null;
         }

@@ -1278,33 +1278,33 @@
         return keys.toArray(new String[keys.size()]);
     }
 
     /**
      * Returns the minimum x coordinate of this
-     * <code>BufferedImage</code>.  This is always zero.
+     * {@code BufferedImage}.  This is always zero.
      * @return the minimum x coordinate of this
-     *          <code>BufferedImage</code>.
+     *          {@code BufferedImage}.
      */
     public int getMinX() {
         return raster.getMinX();
     }
 
     /**
      * Returns the minimum y coordinate of this
-     * <code>BufferedImage</code>.  This is always zero.
+     * {@code BufferedImage}.  This is always zero.
      * @return the minimum y coordinate of this
-     *          <code>BufferedImage</code>.
+     *          {@code BufferedImage}.
      */
     public int getMinY() {
         return raster.getMinY();
     }
 
     /**
-     * Returns the <code>SampleModel</code> associated with this
-     * <code>BufferedImage</code>.
-     * @return the <code>SampleModel</code> of this
-     *          <code>BufferedImage</code>.
+     * Returns the {@code SampleModel} associated with this
+     * {@code BufferedImage}.
+     * @return the {@code SampleModel} of this
+     *          {@code BufferedImage}.
      */
     public SampleModel getSampleModel() {
         return raster.getSampleModel();
     }
 

@@ -1379,21 +1379,21 @@
     public int getTileGridYOffset() {
         return raster.getSampleModelTranslateY();
     }
 
     /**
-     * Returns tile (<code>tileX</code>,&nbsp;<code>tileY</code>).  Note
-     * that <code>tileX</code> and <code>tileY</code> are indices
-     * into the tile array, not pixel locations.  The <code>Raster</code>
+     * Returns tile ({@code tileX},&nbsp;{@code tileY}).  Note
+     * that {@code tileX} and {@code tileY} are indices
+     * into the tile array, not pixel locations.  The {@code Raster}
      * that is returned is live, which means that it is updated if the
      * image is changed.
      * @param tileX the x index of the requested tile in the tile array
      * @param tileY the y index of the requested tile in the tile array
-     * @return a <code>Raster</code> that is the tile defined by the
-     *          arguments <code>tileX</code> and <code>tileY</code>.
+     * @return a {@code Raster} that is the tile defined by the
+     *          arguments {@code tileX} and {@code tileY}.
      * @exception ArrayIndexOutOfBoundsException if both
-     *          <code>tileX</code> and <code>tileY</code> are not
+     *          {@code tileX} and {@code tileY} are not
      *          equal to 0
      */
     public Raster getTile(int tileX, int tileY) {
         if (tileX == 0 && tileY == 0) {
             return raster;

@@ -1401,14 +1401,14 @@
         throw new ArrayIndexOutOfBoundsException("BufferedImages only have"+
              " one tile with index 0,0");
     }
 
     /**
-     * Returns the image as one large tile.  The <code>Raster</code>
+     * Returns the image as one large tile.  The {@code Raster}
      * returned is a copy of the image data is not updated if the
      * image is changed.
-     * @return a <code>Raster</code> that is a copy of the image data.
+     * @return a {@code Raster} that is a copy of the image data.
      * @see #setData(Raster)
      */
     public Raster getData() {
 
         // REMIND : this allocates a whole new tile if raster is a

@@ -1432,17 +1432,17 @@
         return wr;
     }
 
     /**
      * Computes and returns an arbitrary region of the
-     * <code>BufferedImage</code>.  The <code>Raster</code> returned is a
+     * {@code BufferedImage}.  The {@code Raster} returned is a
      * copy of the image data and is not updated if the image is
      * changed.
-     * @param rect the region of the <code>BufferedImage</code> to be
+     * @param rect the region of the {@code BufferedImage} to be
      * returned.
-     * @return a <code>Raster</code> that is a copy of the image data of
-     *          the specified region of the <code>BufferedImage</code>
+     * @return a {@code Raster} that is a copy of the image data of
+     *          the specified region of the {@code BufferedImage}
      * @see #setData(Raster)
      */
     public Raster getData(Rectangle rect) {
         SampleModel sm = raster.getSampleModel();
         SampleModel nsm = sm.createCompatibleSampleModel(rect.width,

@@ -1463,22 +1463,22 @@
         return wr;
     }
 
     /**
      * Computes an arbitrary rectangular region of the
-     * <code>BufferedImage</code> and copies it into a specified
-     * <code>WritableRaster</code>.  The region to be computed is
+     * {@code BufferedImage} and copies it into a specified
+     * {@code WritableRaster}.  The region to be computed is
      * determined from the bounds of the specified
-     * <code>WritableRaster</code>.  The specified
-     * <code>WritableRaster</code> must have a
-     * <code>SampleModel</code> that is compatible with this image.  If
-     * <code>outRaster</code> is <code>null</code>,
-     * an appropriate <code>WritableRaster</code> is created.
-     * @param outRaster a <code>WritableRaster</code> to hold the returned
-     *          part of the image, or <code>null</code>
+     * {@code WritableRaster}.  The specified
+     * {@code WritableRaster} must have a
+     * {@code SampleModel} that is compatible with this image.  If
+     * {@code outRaster} is {@code null},
+     * an appropriate {@code WritableRaster} is created.
+     * @param outRaster a {@code WritableRaster} to hold the returned
+     *          part of the image, or {@code null}
      * @return a reference to the supplied or created
-     *          <code>WritableRaster</code>.
+     *          {@code WritableRaster}.
      */
     public WritableRaster copyData(WritableRaster outRaster) {
         if (outRaster == null) {
             return (WritableRaster) getData();
         }

@@ -1497,15 +1497,15 @@
         return outRaster;
     }
 
   /**
      * Sets a rectangular region of the image to the contents of the
-     * specified <code>Raster</code> <code>r</code>, which is
+     * specified {@code Raster r}, which is
      * assumed to be in the same coordinate space as the
-     * <code>BufferedImage</code>. The operation is clipped to the bounds
-     * of the <code>BufferedImage</code>.
-     * @param r the specified <code>Raster</code>
+     * {@code BufferedImage}. The operation is clipped to the bounds
+     * of the {@code BufferedImage}.
+     * @param r the specified {@code Raster}
      * @see #getData
      * @see #getData(Rectangle)
     */
     public void setData(Raster r) {
         int width = r.getWidth();

@@ -1546,24 +1546,24 @@
 
   /**
    * Removes a tile observer.  If the observer was not registered,
    * nothing happens.  If the observer was registered for multiple
    * notifications, it is now registered for one fewer notification.
-   * @param to the specified <code>TileObserver</code>.
+   * @param to the specified {@code TileObserver}.
    */
     public void removeTileObserver (TileObserver to) {
     }
 
     /**
      * Returns whether or not a tile is currently checked out for writing.
      * @param tileX the x index of the tile.
      * @param tileY the y index of the tile.
-     * @return <code>true</code> if the tile specified by the specified
-     *          indices is checked out for writing; <code>false</code>
+     * @return {@code true} if the tile specified by the specified
+     *          indices is checked out for writing; {@code false}
      *          otherwise.
      * @exception ArrayIndexOutOfBoundsException if both
-     *          <code>tileX</code> and <code>tileY</code> are not equal
+     *          {@code tileX} and {@code tileY} are not equal
      *          to 0
      */
     public boolean isTileWritable (int tileX, int tileY) {
         if (tileX == 0 && tileY == 0) {
             return true;

@@ -1571,14 +1571,14 @@
         throw new IllegalArgumentException("Only 1 tile in image");
     }
 
     /**
      * Returns an array of {@link Point} objects indicating which tiles
-     * are checked out for writing.  Returns <code>null</code> if none are
+     * are checked out for writing.  Returns {@code null} if none are
      * checked out.
-     * @return a <code>Point</code> array that indicates the tiles that
-     *          are checked out for writing, or <code>null</code> if no
+     * @return a {@code Point} array that indicates the tiles that
+     *          are checked out for writing, or {@code null} if no
      *          tiles are checked out for writing.
      */
     public Point[] getWritableTileIndices() {
         Point[] p = new Point[1];
         p[0] = new Point(0, 0);

@@ -1590,24 +1590,24 @@
      * Returns whether or not any tile is checked out for writing.
      * Semantically equivalent to
      * <pre>
      * (getWritableTileIndices() != null).
      * </pre>
-     * @return <code>true</code> if any tile is checked out for writing;
-     *          <code>false</code> otherwise.
+     * @return {@code true} if any tile is checked out for writing;
+     *          {@code false} otherwise.
      */
     public boolean hasTileWriters () {
         return true;
     }
 
   /**
    * Checks out a tile for writing.  All registered
-   * <code>TileObservers</code> are notified when a tile goes from having
+   * {@code TileObservers} are notified when a tile goes from having
    * no writers to having one writer.
    * @param tileX the x index of the tile
    * @param tileY the y index of the tile
-   * @return a <code>WritableRaster</code> that is the tile, indicated by
+   * @return a {@code WritableRaster} that is the tile, indicated by
    *            the specified indices, to be checked out for writing.
    */
     public WritableRaster getWritableTile (int tileX, int tileY) {
         return raster;
     }

@@ -1615,11 +1615,11 @@
   /**
    * Relinquishes permission to write to a tile.  If the caller
    * continues to write to the tile, the results are undefined.
    * Calls to this method should only appear in matching pairs
    * with calls to {@link #getWritableTile(int, int) getWritableTile(int, int)}.  Any other leads
-   * to undefined results.  All registered <code>TileObservers</code>
+   * to undefined results.  All registered {@code TileObservers}
    * are notified when a tile goes from having one writer to having no
    * writers.
    * @param tileX the x index of the tile
    * @param tileY the y index of the tile
    */

@@ -1627,11 +1627,11 @@
     }
 
     /**
      * Returns the transparency.  Returns either OPAQUE, BITMASK,
      * or TRANSLUCENT.
-     * @return the transparency of this <code>BufferedImage</code>.
+     * @return the transparency of this {@code BufferedImage}.
      * @see Transparency#OPAQUE
      * @see Transparency#BITMASK
      * @see Transparency#TRANSLUCENT
      * @since 1.5
      */
< prev index next >