12 files changed, 1198 insertions, 541 deletions
diff --git a/libjava/classpath/java/awt/image/AffineTransformOp.java b/libjava/classpath/java/awt/image/AffineTransformOp.java
index f11066e..bb4b795 100644
--- a/libjava/classpath/java/awt/image/AffineTransformOp.java
+++ b/libjava/classpath/java/awt/image/AffineTransformOp.java
@@ -347,7 +347,7 @@ public class AffineTransformOp implements BufferedImageOp, RasterOp
      * @param dstPt destination point
      * @return the location of the transformed source point.
      */
-    public Point2D getPoint2D (Point2D srcPt, Point2D dstPt)
+    public final Point2D getPoint2D (Point2D srcPt, Point2D dstPt)
     {
       return transform.transform (srcPt, dstPt);
     }
diff --git a/libjava/classpath/java/awt/image/AreaAveragingScaleFilter.java b/libjava/classpath/java/awt/image/AreaAveragingScaleFilter.java
index 6333ce9..44d5cec 100644
--- a/libjava/classpath/java/awt/image/AreaAveragingScaleFilter.java
+++ b/libjava/classpath/java/awt/image/AreaAveragingScaleFilter.java
@@ -1,5 +1,5 @@
 /* AreaAveragingScaleFilter.java -- Java class for filtering images
-   Copyright (C) 1999 Free Software Foundation, Inc.
+   Copyright (C) 1999,2006 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -45,86 +45,225 @@ package java.awt.image;
  * points should give the desired results although Sun does not 
  * specify what the exact algorithm should be.
  * <br>
- * FIXME: Currently this filter does nothing and needs to be implemented.
  *
  * @author C. Brian Jones (cbj@gnu.org) 
  */
 public class AreaAveragingScaleFilter extends ReplicateScaleFilter
 {
-    /**
-     * Construct an instance of <code>AreaAveragingScaleFilter</code> which
-     * should be used in conjunction with a <code>FilteredImageSource</code>
-     * object.
-     * 
-     * @param width the width of the destination image
-     * @param height the height of the destination image
-     */
-    public AreaAveragingScaleFilter(int width, int height) {
-	super(width, height);
-    }
-
-    /**
-     * The <code>ImageProducer</code> should call this method with a
-     * bit mask of hints from any of <code>RANDOMPIXELORDER</code>,
-     * <code>TOPDOWNLEFTRIGHT</code>, <code>COMPLETESCANLINES</code>,
-     * <code>SINGLEPASS</code>, <code>SINGLEFRAME</code> from the 
-     * <code>ImageConsumer</code> interface.
-     * <br>
-     * FIXME - more than likely Sun's implementation desires 
-     * <code>TOPDOWNLEFTRIGHT</code> order and this method is overloaded here
-     * in order to assure that mask is part of the hints added to
-     * the consumer.
-     * 
-     * @param flags a bit mask of hints
-     * @see ImageConsumer
-     */
-    public void setHints(int flags)
-    {
-      if (consumer != null)
-	consumer.setHints(flags);
-    }
-
-    /**
-     * This function delivers a rectangle of pixels where any
-     * pixel(m,n) is stored in the array as a <code>byte</code> at
-     * index (n * scansize + m + offset).  
-     *
-     * @param x the x coordinate of the rectangle
-     * @param y the y coordinate of the rectangle
-     * @param w the width of the rectangle
-     * @param h the height of the rectangle
-     * @param model the <code>ColorModel</code> used to translate the pixels
-     * @param pixels the array of pixel values
-     * @param offset the index of the first pixels in the <code>pixels</code> array
-     * @param scansize the width to use in extracting pixels from the <code>pixels</code> array
-     */
-    public void setPixels(int x, int y, int w, int h, 
-	   ColorModel model, byte[] pixels, int offset, int scansize)
-    {
-      if (consumer != null)
-	consumer.setPixels(x, y, w, h, model, pixels, offset, scansize);
-    }
-
-    /**
-     * This function delivers a rectangle of pixels where any
-     * pixel(m,n) is stored in the array as an <code>int</code> at
-     * index (n * scansize + m + offset).  
-     *
-     * @param x the x coordinate of the rectangle
-     * @param y the y coordinate of the rectangle
-     * @param w the width of the rectangle
-     * @param h the height of the rectangle
-     * @param model the <code>ColorModel</code> used to translate the pixels
-     * @param pixels the array of pixel values
-     * @param offset the index of the first pixels in the <code>pixels</code> array
-     * @param scansize the width to use in extracting pixels from the <code>pixels</code> array
-     */
-    public void setPixels(int x, int y, int w, int h, 
-           ColorModel model, int[] pixels, int offset, int scansize)
-    {
-      if (consumer != null)
-	consumer.setPixels(x, y, w, h, model, pixels, offset, scansize);
-    }
+  /**
+   * Construct an instance of <code>AreaAveragingScaleFilter</code> which
+   * should be used in conjunction with a <code>FilteredImageSource</code>
+   * object.
+   * 
+   * @param width the width of the destination image
+   * @param height the height of the destination image
+   */
+  public AreaAveragingScaleFilter(int width, int height) {
+    super(width, height);
+  }
 
+  /**
+   * The <code>ImageProducer</code> should call this method with a
+   * bit mask of hints from any of <code>RANDOMPIXELORDER</code>,
+   * <code>TOPDOWNLEFTRIGHT</code>, <code>COMPLETESCANLINES</code>,
+   * <code>SINGLEPASS</code>, <code>SINGLEFRAME</code> from the 
+   * <code>ImageConsumer</code> interface.
+   * <br>
+   * FIXME - more than likely Sun's implementation desires 
+   * <code>TOPDOWNLEFTRIGHT</code> order and this method is overloaded here
+   * in order to assure that mask is part of the hints added to
+   * the consumer.
+   * 
+   * @param flags a bit mask of hints
+   * @see ImageConsumer
+   */
+  public void setHints(int flags)
+  {
+    if (consumer != null)
+      consumer.setHints(flags);
+  }
+
+  /**
+   * This function delivers a rectangle of pixels where any
+   * pixel(m,n) is stored in the array as a <code>byte</code> at
+   * index (n * scansize + m + offset).  
+   *
+   * @param x the x coordinate of the rectangle
+   * @param y the y coordinate of the rectangle
+   * @param w the width of the rectangle
+   * @param h the height of the rectangle
+   * @param model the <code>ColorModel</code> used to translate the pixels
+   * @param pixels the array of pixel values
+   * @param offset the index of the first pixels in the <code>pixels</code> array
+   * @param scansize the width to use in extracting pixels from the <code>pixels</code> array
+   */
+  public void setPixels(int x, int y, int w, int h, 
+			ColorModel model, byte[] pixels, int offset, int scansize)
+  {
+    double rx = ((double) srcWidth) / destWidth;
+    double ry = ((double) srcHeight) / destHeight;
+
+    int destScansize = (int) Math.round(scansize / rx);
+
+    byte[] destPixels = averagePixels(x, y, w, h,
+				      model, pixels, offset, scansize,
+				      rx, ry, destScansize);
+
+    if (consumer != null)
+      consumer.setPixels((int) Math.floor(x/rx), (int) Math.floor(y/ry),
+			 (int) Math.ceil(w/rx), (int) Math.ceil(h/ry),
+			 model, destPixels, 0, destScansize);
+  }
+
+  /**
+   * This function delivers a rectangle of pixels where any
+   * pixel(m,n) is stored in the array as an <code>int</code> at
+   * index (n * scansize + m + offset).  
+   *
+   * @param x the x coordinate of the rectangle
+   * @param y the y coordinate of the rectangle
+   * @param w the width of the rectangle
+   * @param h the height of the rectangle
+   * @param model the <code>ColorModel</code> used to translate the pixels
+   * @param pixels the array of pixel values
+   * @param offset the index of the first pixels in the <code>pixels</code> array
+   * @param scansize the width to use in extracting pixels from the <code>pixels</code> array
+   */
+  public void setPixels(int x, int y, int w, int h, 
+			ColorModel model, int[] pixels, int offset, int scansize)
+  {
+    double rx = ((double) srcWidth) / destWidth;
+    double ry = ((double) srcHeight) / destHeight;
+
+    int destScansize = (int) Math.round(scansize / rx);
+
+    int[] destPixels = averagePixels(x, y, w, h,
+				     model, pixels, offset, scansize,
+				     rx, ry, destScansize);
+
+    if (consumer != null)
+      consumer.setPixels((int) Math.floor(x/rx), (int) Math.floor(y/ry),
+			 (int) Math.ceil(w/rx), (int) Math.ceil(h/ry),
+			 model, destPixels, 0, destScansize);
+  }
+
+  /**
+   * This is a really terrible implementation, 
+   * since it uses the nearest-neighbor method. This filter is rarely used though.
+   *
+   * @param srcx, srcy - Source rectangle upper-left corner
+   * @param srcw, srch - Source rectangle width and height
+   * @param model - Pixel color model
+   * @param srcPixels - Source pixel data.
+   * @param srcOffset - Starting offset into the source pixel data array.
+   * @param srcScansize - Source array scanline size.
+   * @param rx,ry - Scaling factor.
+   * @param dstScansize - Destination array scanline size.
+   */
+  private byte[] averagePixels(int srcx, int srcy, int srcw, int srch,
+			       ColorModel model, byte[] srcPixels,
+			       int srcOffset, int srcScansize,
+			       double rx, double ry, int destScansize)
+  {
+    int destW = (int) Math.ceil(srcw/rx);
+    int destH = (int) Math.ceil(srch/ry);
+    byte[] destPixels = new byte[ destW * destH ];
+    int sx, sy;
+
+    int w = (int)Math.ceil(rx);
+    int h = (int)Math.ceil(ry);
+
+    for(int x = 0; x < destW; x++)
+      for(int y = 0; y < destH; y++)
+	{
+	  sx = (int) (x * rx);
+	  sy = (int) (y * ry);
+
+	  int r,g,b,a;
+	  r = g = b = a = 0;
+
+	  for(int i = 0; i < w; i++)
+	    {
+	      for(int j = 0; j < h; j++)
+		{
+		  int idx = srcx + sx + i + (srcy + sy + j)*srcScansize;
+		  r += model.getRed(srcPixels[ idx ]);
+		  g += model.getGreen(srcPixels[ idx ]);
+		  b += model.getBlue(srcPixels[ idx ]);
+		  a += model.getAlpha(srcPixels[ idx ]);
+		}
+	    }
+	    
+	  r = r / (w * h);
+	  g = g / (w * h);
+	  b = b / (w * h);
+	  a = a / (w * h);
+
+	  // Does this really work?
+	  destPixels[x + destScansize*y] = (byte)model.getDataElement
+	    (new int[]{r, g, b, a}, 0);
+	}
+
+    return destPixels;
+  }
+
+  /**
+   * This is a really terrible implementation, 
+   * since it uses the nearest-neighbor method. This filter is rarely used though.
+   *
+   * @param srcx, srcy - Source rectangle upper-left corner
+   * @param srcw, srch - Source rectangle width and height
+   * @param model - Pixel color model
+   * @param srcPixels - Source pixel data.
+   * @param srcOffset - Starting offset into the source pixel data array.
+   * @param srcScansize - Source array scanline size.
+   * @param rx,ry - Scaling factor.
+   * @param dstScansize - Destination array scanline size.
+   */
+  private int[] averagePixels(int srcx, int srcy, int srcw, int srch,
+			      ColorModel model, int[] srcPixels,
+			      int srcOffset, int srcScansize,
+			      double rx, double ry, int destScansize)
+  {
+    int destW = (int) Math.ceil(srcw/rx);
+    int destH = (int) Math.ceil(srch/ry);
+    int[] destPixels = new int[ destW * destH ];
+    int sx, sy;
+    
+    int w = (int)Math.ceil(rx);
+    int h = (int)Math.ceil(ry);
+    
+    for(int x = 0; x < destW; x++)
+      for(int y = 0; y < destH; y++)
+	{
+	  sx = (int) (x * rx);
+	  sy = (int) (y * ry);
+	  
+	  int r,g,b,a;
+	  r = g = b = a = 0;
+	  
+	  for(int i = 0; i < w; i++)
+	    {
+	      for(int j = 0; j < h; j++)
+		{
+		  int idx = srcx + sx + i + (srcy + sy + j)*srcScansize;
+		  r += model.getRed(srcPixels[ idx ]);
+		  g += model.getGreen(srcPixels[ idx ]);
+		  b += model.getBlue(srcPixels[ idx ]);
+		  a += model.getAlpha(srcPixels[ idx ]);
+		}
+	    }
+	  
+	  r = r / (w * h);
+	  g = g / (w * h);
+	  b = b / (w * h);
+	  a = a / (w * h);
+
+	  destPixels[x + destScansize*y] = model.getDataElement
+	    (new int[]{r, g, b, a}, 0);
+	}
+    
+    return destPixels;
+  }
 }
 
diff --git a/libjava/classpath/java/awt/image/BandCombineOp.java b/libjava/classpath/java/awt/image/BandCombineOp.java
index 79efb02..634125e 100644
--- a/libjava/classpath/java/awt/image/BandCombineOp.java
+++ b/libjava/classpath/java/awt/image/BandCombineOp.java
@@ -118,7 +118,7 @@ public class BandCombineOp implements RasterOp
   /* (non-Javadoc)
    * @see java.awt.image.RasterOp#getBounds2D(java.awt.image.Raster)
    */
-  public Rectangle2D getBounds2D(Raster src)
+  public final Rectangle2D getBounds2D(Raster src)
   {
     return src.getBounds();
   }
@@ -144,7 +144,7 @@ public class BandCombineOp implements RasterOp
    * @see java.awt.image.RasterOp#getPoint2D(java.awt.geom.Point2D,
    *java.awt.geom.Point2D) 
    */
-  public Point2D getPoint2D(Point2D src, Point2D dst)
+  public final Point2D getPoint2D(Point2D src, Point2D dst)
   {
     if (dst == null) return (Point2D)src.clone();
     dst.setLocation(src);
@@ -154,13 +154,13 @@ public class BandCombineOp implements RasterOp
   /* (non-Javadoc)
    * @see java.awt.image.RasterOp#getRenderingHints()
    */
-  public RenderingHints getRenderingHints()
+  public final RenderingHints getRenderingHints()
   {
     return hints;
   }
   
   /** Return the matrix for this Op. */
-  public float[][] getMatrix()
+  public final float[][] getMatrix()
   {
     return matrix;
   }
diff --git a/libjava/classpath/java/awt/image/ColorModel.java b/libjava/classpath/java/awt/image/ColorModel.java
index 1ced2a0..40307f2 100644
--- a/libjava/classpath/java/awt/image/ColorModel.java
+++ b/libjava/classpath/java/awt/image/ColorModel.java
@@ -452,8 +452,14 @@ public abstract class ColorModel implements Transparency
    * This method is typically overriden in subclasses to provide a
    * more efficient implementation.
    *
-   * @param array of transferType containing a single pixel.  The
-   * pixel should be encoded in the natural way of the color model.
+   * @param pixel an array of transferType containing a single pixel.  The
+   * pixel should be encoded in the natural way of the color model.  If
+   * this argument is not an array, as expected, a {@link ClassCastException}
+   * will be thrown.
+   * @param components an array that will be filled with the color component
+   * of the pixel.  If this is null, a new array will be allocated
+   * @param offset index into the components array at which the result
+   * will be stored
    * 
    * @return arrays of unnormalized component samples of single
    * pixel.  The scale and multiplication state of the samples are
@@ -521,8 +527,8 @@ public abstract class ColorModel implements Transparency
                                           float[] normComponents,
                                           int normOffset)
   {
-    // subclasses has to implement this method.
-    throw new UnsupportedOperationException();
+    int[] components = getComponents(pixel, null, 0);
+    return getNormalizedComponents(components, 0, normComponents, normOffset);
   }
 
   /**
diff --git a/libjava/classpath/java/awt/image/ComponentSampleModel.java b/libjava/classpath/java/awt/image/ComponentSampleModel.java
index 5cf06e4..b4e9450 100644
--- a/libjava/classpath/java/awt/image/ComponentSampleModel.java
+++ b/libjava/classpath/java/awt/image/ComponentSampleModel.java
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000, 2002  Free Software Foundation
+/* Copyright (C) 2000, 2002, 2006,  Free Software Foundation
 
 This file is part of GNU Classpath.
 
@@ -38,6 +38,8 @@ package java.awt.image;
 
 import gnu.java.awt.Buffers;
 
+import java.util.Arrays;
+
 /* FIXME: This class does not yet support data type TYPE_SHORT */
 
 /**
@@ -60,11 +62,14 @@ import gnu.java.awt.Buffers;
  */
 public class ComponentSampleModel extends SampleModel
 {
+  /** The offsets to the first sample for each band. */
   protected int[] bandOffsets;
+  
+  /** The indices of the bank used to store each band in a data buffer. */
   protected int[] bankIndices;
   
   /** 
-   * Number of bands in the image described.
+   * The number of bands in the image.
    * @specnote This field shadows the protected numBands in SampleModel.
    */
   protected int numBands;
@@ -72,42 +77,128 @@ public class ComponentSampleModel extends SampleModel
   /** Used when creating data buffers. */
   protected int numBanks;
 
+  /** 
+   * The number of data elements between a sample in one row and the 
+   * corresponding sample in the next row.
+   */
   protected int scanlineStride;
   
+  /**
+   * The number of data elements between a sample for one pixel and the 
+   * corresponding sample for the next pixel in the same row.
+   */
   protected int pixelStride;
   
   private boolean tightPixelPacking = false;
   
+  /**
+   * Creates a new sample model that assumes that all bands are stored in a 
+   * single bank of the {@link DataBuffer}.
+   * <p>
+   * Note that the <code>bandOffsets</code> array is copied to internal storage
+   * to prevent subsequent changes to the array from affecting this object.
+   * 
+   * @param dataType  the data type (one of {@link DataBuffer#TYPE_BYTE},
+   *   {@link DataBuffer#TYPE_USHORT}, {@link DataBuffer#TYPE_SHORT},
+   *   {@link DataBuffer#TYPE_INT}, {@link DataBuffer#TYPE_FLOAT} or 
+   *   {@link DataBuffer#TYPE_DOUBLE}).
+   * @param w  the width in pixels.
+   * @param h  the height in pixels.
+   * @param pixelStride  the number of data elements in the step from a sample
+   *   in one pixel to the corresponding sample in the next pixel.
+   * @param scanlineStride  the number of data elements in the step from a 
+   *   sample in a pixel to the corresponding sample in the pixel in the next
+   *   row.
+   * @param bandOffsets  the offset to the first element for each band, with 
+   *   the size of the array defining the number of bands (<code>null</code>
+   *   not permitted).
+   *   
+   * @throws IllegalArgumentException if <code>dataType</code> is not one of
+   *   the specified values.
+   * @throws IllegalArgumentException if <code>w</code> is less than or equal
+   *   to zero.
+   * @throws IllegalArgumentException if <code>h</code> is less than or equal 
+   *   to zero.
+   * @throws IllegalArgumentException if <code>w * h</code> exceeds
+   *   {@link Integer#MAX_VALUE}.
+   * @throws IllegalArgumentException if <code>pixelStride</code> is negative.
+   * @throws IllegalArgumentException if <code>scanlineStride</code> is less 
+   *   than or equal to zero.
+   * @throws IllegalArgumentException if <code>bandOffsets</code> has zero 
+   *   length.
+   */
   public ComponentSampleModel(int dataType,
-			      int w, int h,
-			      int pixelStride,
-			      int scanlineStride,
-			      int[] bandOffsets)
+                              int w, int h,
+                              int pixelStride,
+                              int scanlineStride,
+                              int[] bandOffsets)
   {
     this(dataType, w, h, pixelStride, scanlineStride,
-	 new int[bandOffsets.length], bandOffsets);
+         new int[bandOffsets.length], bandOffsets);
   }
     
+  /**
+   * Creates a new sample model that assumes that all bands are stored in a 
+   * single bank of the {@link DataBuffer}.
+   * 
+   * @param dataType  the data type (one of {@link DataBuffer#TYPE_BYTE},
+   *   {@link DataBuffer#TYPE_USHORT}, {@link DataBuffer#TYPE_SHORT},
+   *   {@link DataBuffer#TYPE_INT}, {@link DataBuffer#TYPE_FLOAT} or 
+   *   {@link DataBuffer#TYPE_DOUBLE}).
+   * @param w  the width in pixels.
+   * @param h  the height in pixels.
+   * @param pixelStride  the number of data elements in the step from a sample
+   *   in one pixel to the corresponding sample in the next pixel.
+   * @param scanlineStride  the number of data elements in the step from a 
+   *   sample in a pixel to the corresponding sample in the pixel in the next
+   *   row.
+   * @param bankIndices  the index of the bank in which each band is stored 
+   *   (<code>null</code> not permitted).  This array is copied to internal
+   *   storage so that subsequent updates to the array do not affect the sample 
+   *   model.
+   * @param bandOffsets  the offset to the first element for each band, with 
+   *   the size of the array defining the number of bands (<code>null</code>
+   *   not permitted).  This array is copied to internal storage so that 
+   *   subsequent updates to the array do not affect the sample model.
+   *   
+   * @throws IllegalArgumentException if <code>dataType</code> is not one of
+   *   the specified values.
+   * @throws IllegalArgumentException if <code>w</code> is less than or equal
+   *   to zero.
+   * @throws IllegalArgumentException if <code>h</code> is less than or equal 
+   *   to zero.
+   * @throws IllegalArgumentException if <code>w * h</code> exceeds
+   *   {@link Integer#MAX_VALUE}.
+   * @throws IllegalArgumentException if <code>pixelStride</code> is negative.
+   * @throws IllegalArgumentException if <code>scanlineStride</code> is less 
+   *   than or equal to zero.
+   * @throws IllegalArgumentException if <code>bandOffsets</code> has zero 
+   *   length.
+   */
   public ComponentSampleModel(int dataType,
-			      int w, int h,
-			      int pixelStride,
-			      int scanlineStride,
-			      int[] bankIndices,
-			      int[] bandOffsets)
+                              int w, int h,
+                              int pixelStride,
+                              int scanlineStride,
+                              int[] bankIndices,
+                              int[] bandOffsets)
   {
     super(dataType, w, h, bandOffsets.length);
-    if ((pixelStride<0) || (scanlineStride<0) || 
-	(bandOffsets.length<1) ||
-	(bandOffsets.length != bankIndices.length))
+    
+    // super permits DataBuffer.TYPE_UNDEFINED but this class doesn't...
+    if (dataType == DataBuffer.TYPE_UNDEFINED)
+      throw new IllegalArgumentException("Unsupported dataType.");
+    
+    if ((pixelStride < 0) || (scanlineStride < 0) || (bandOffsets.length < 1) 
+        || (bandOffsets.length != bankIndices.length))
       throw new IllegalArgumentException();
     
-    this.bandOffsets = bandOffsets;
-    this.bankIndices = bankIndices;
+    this.bandOffsets = (int[]) bandOffsets.clone();
+    this.bankIndices = (int[]) bankIndices.clone();
     this.numBands = bandOffsets.length;
 
     this.numBanks = 0;
-    for (int b=0; b<bankIndices.length; b++)
-      this.numBanks = Math.max(this.numBanks, bankIndices[b]+1);
+    for (int b = 0; b < bankIndices.length; b++)
+      this.numBanks = Math.max(this.numBanks, bankIndices[b] + 1);
 
     this.scanlineStride = scanlineStride;
     this.pixelStride = pixelStride;
@@ -116,68 +207,122 @@ public class ComponentSampleModel extends SampleModel
 
     /* FIXME: May these checks should be reserved for the
        PixelInterleavedSampleModel? */
-	
+        
     if (pixelStride == numBands)
       {
-	tightPixelPacking = true;
-	for (int b=0; b<numBands; b++) {
-	  if ((bandOffsets[b] != b) || (bankIndices[b] !=0))
-	    {
-	      tightPixelPacking = false;
-	      break;
-	    }
-	}
+        tightPixelPacking = true;
+        for (int b = 0; b < numBands; b++) {
+          if ((bandOffsets[b] != b) || (bankIndices[b] != 0))
+            {
+              tightPixelPacking = false;
+              break;
+            }
+        }
       }
-  }		
-
+  }             
+
+  /**
+   * Creates a new sample model that is compatible with this one, but with the
+   * specified dimensions.
+   * 
+   * @param w  the width (must be greater than zero).
+   * @param h  the height (must be greater than zero).
+   * 
+   * @return A new sample model.
+   */
   public SampleModel createCompatibleSampleModel(int w, int h)
   {
     return new ComponentSampleModel(dataType, w, h, pixelStride,
-				    scanlineStride, bankIndices,
-				    bandOffsets);
+                                    scanlineStride, bankIndices,
+                                    bandOffsets);
   }
 
+  /**
+   * Creates a new sample model that provides access to a subset of the bands
+   * that this sample model supports.
+   * 
+   * @param bands  the bands (<code>null</code> not permitted).
+   * 
+   * @return The new sample model.
+   */
   public SampleModel createSubsetSampleModel(int[] bands)
   {
     int numBands = bands.length;
     
     int[] bankIndices = new int[numBands];
     int[] bandOffsets = new int[numBands];
-    for (int b=0; b<numBands; b++)
+    for (int b = 0; b < numBands; b++)
       {
-	bankIndices[b] = this.bankIndices[bands[b]];
-	bandOffsets[b] = this.bandOffsets[bands[b]];
+        bankIndices[b] = this.bankIndices[bands[b]];
+        bandOffsets[b] = this.bandOffsets[bands[b]];
       }
 
     return new ComponentSampleModel(dataType, width, height, pixelStride,
-				    scanlineStride, bankIndices,
-				    bandOffsets);
+                                    scanlineStride, bankIndices,
+                                    bandOffsets);
   }
 
+  /**
+   * Creates a new data buffer that is compatible with this sample model.
+   * 
+   * @return The new data buffer.
+   */
   public DataBuffer createDataBuffer()
   {
     // Maybe this value should be precalculated in the constructor?
     int highestOffset = 0;
-    for (int b=0; b<numBands; b++)
+    for (int b = 0; b < numBands; b++)
       {
-	highestOffset = Math.max(highestOffset, bandOffsets[b]);
+        highestOffset = Math.max(highestOffset, bandOffsets[b]);
       }
-    int size = pixelStride*(width-1) + scanlineStride*(height-1) +
-      highestOffset + 1;
+    int size = pixelStride * (width - 1) + scanlineStride * (height - 1) 
+        + highestOffset + 1;
     
     return Buffers.createBuffer(getDataType(), size, numBanks);
   }
 
+  /**
+   * Returns the offset of the sample in band 0 for the pixel at location
+   * <code>(x, y)</code>.  This offset can be used to read a sample value from
+   * a {@link DataBuffer}.
+   * 
+   * @param x  the x-coordinate.
+   * @param y  the y-coordinate.
+   * 
+   * @return The offset.
+   * 
+   * @see #getOffset(int, int, int)
+   */
   public int getOffset(int x, int y)
   {
     return getOffset(x, y, 0);
   }
 
+  /**
+   * Returns the offset of the sample in band <code>b</code> for the pixel at
+   * location <code>(x, y)</code>.  This offset can be used to read a sample
+   * value from a {@link DataBuffer}.
+   * 
+   * @param x  the x-coordinate.
+   * @param y  the y-coordinate.
+   * @param b  the band index.
+   * 
+   * @return The offset.
+   */
   public int getOffset(int x, int y, int b)
   {
-    return bandOffsets[b] + pixelStride*x + scanlineStride*y;
+    return bandOffsets[b] + pixelStride * x + scanlineStride * y;
   }
 
+  /**
+   * Returns the size in bits for each sample (one per band).  For this sample
+   * model, each band has the same sample size and this is determined by the
+   * data type for the sample model.
+   * 
+   * @return The sample sizes.
+   * 
+   * @see SampleModel#getDataType()
+   */
   public final int[] getSampleSize()
   {
     int size = DataBuffer.getDataTypeSize(getDataType());
@@ -187,39 +332,101 @@ public class ComponentSampleModel extends SampleModel
     return sizes;
   }
 
+  /**
+   * Returns the size in bits for the samples in the specified band.  In this
+   * class, the sample size is the same for every band and is determined from 
+   * the data type for the model.
+   * 
+   * @param band  the band index (ignored here).
+   * 
+   * @return The sample size in bits.
+   * 
+   * @see SampleModel#getDataType()
+   */
   public final int getSampleSize(int band)
   {
     return DataBuffer.getDataTypeSize(getDataType());
   }
 
+  /**
+   * Returns the indices of the bank(s) in the {@link DataBuffer} used to 
+   * store the samples for each band.  The returned array is a copy, so that
+   * altering it will not impact the sample model.
+   * 
+   * @return The bank indices.
+   */
   public final int[] getBankIndices()
   {
-    return bankIndices;
+    return (int[]) bankIndices.clone();
   }
 
+  /**
+   * Returns the offsets to the first sample in each band.  The returned array
+   * is a copy, so that altering it will not impact the sample model.
+   * 
+   * @return The offsets.
+   */
   public final int[] getBandOffsets()
   {
-    return bandOffsets;
+    return (int[]) bandOffsets.clone();
   }
 
+  /**
+   * Returns the distance (in terms of element indices) between the sample for
+   * one pixel and the corresponding sample for the equivalent pixel in the 
+   * next row.  This is used in the calculation of the element offset for
+   * retrieving samples from a {@link DataBuffer}.
+   * 
+   * @return The distance between pixel samples in consecutive rows.
+   */
   public final int getScanlineStride()
   {
     return scanlineStride;
   }
 
+  /**
+   * Returns the distance (in terms of element indices) between the sample for 
+   * one pixel and the corresponding sample for the next pixel in a row.  This 
+   * is used in the calculation of the element offset for retrieving samples 
+   * from a {@link DataBuffer}.
+   * 
+   * @return The distance between pixel samples in the same row.
+   */
   public final int getPixelStride()
   {
     return pixelStride;
   }
 
+  /**
+   * Returns the number of data elements used to store the samples for one 
+   * pixel.  In this model, this is the same as the number of bands.
+   * 
+   * @return The number of data elements used to store the samples for one 
+   *   pixel.
+   */
   public final int getNumDataElements()
   {
     return numBands;
   }
 
+  /**
+   * Returns the samples for the pixel at location <code>(x, y)</code> in
+   * a primitive array (the array type is determined by the data type for 
+   * this model).  The <code>obj</code> argument provides an option to supply
+   * an existing array to hold the result, if this is <code>null</code> a new
+   * array will be allocated.
+   * 
+   * @param x  the x-coordinate.
+   * @param y  the y-coordinate.
+   * @param obj  a primitive array that, if not <code>null</code>, will be 
+   *   used to store and return the sample values.
+   * @param data  the data buffer (<code>null</code> not permitted).
+   * 
+   * @return An array of sample values for the specified pixel.
+   */
   public Object getDataElements(int x, int y, Object obj, DataBuffer data)
   {
-    int xyOffset = pixelStride*x + scanlineStride*y;
+    int xyOffset = pixelStride * x + scanlineStride * y;
     
     int[] totalBandDataOffsets = new int[numBands];
     
@@ -235,124 +442,147 @@ public class ComponentSampleModel extends SampleModel
     
     int[] bankOffsets = data.getOffsets();
     
-    for (int b=0; b<numBands; b++)
+    for (int b = 0; b < numBands; b++)
       {
-	totalBandDataOffsets[b] = 
-	  bandOffsets[b]+bankOffsets[bankIndices[b]] + xyOffset;
+        totalBandDataOffsets[b] = bandOffsets[b] + bankOffsets[bankIndices[b]] 
+                                  + xyOffset;
       }
-	
+        
     try
       {
-	switch (getTransferType())
-	  {
-	  case DataBuffer.TYPE_BYTE:
-	    DataBufferByte inByte = (DataBufferByte) data;
-	    byte[] outByte = (byte[]) obj;
-	    if (outByte == null) outByte = new byte[numBands];
-		
-	    for (int b=0; b<numBands; b++)
-	      {
-		int dOffset = totalBandDataOffsets[b];
-		outByte[b] = inByte.getData(bankIndices[b])[dOffset];
-	      }
-	    return outByte;
-		
-	  case DataBuffer.TYPE_USHORT:
-	    DataBufferUShort inUShort = (DataBufferUShort) data;
-	    short[] outUShort = (short[]) obj;
-	    if (outUShort == null) outUShort = new short[numBands];
-		
-	    for (int b=0; b<numBands; b++)
-	      {
-		int dOffset = totalBandDataOffsets[b];
-		outUShort[b] = inUShort.getData(bankIndices[b])[dOffset];
-	      }
-	    return outUShort;
-
-	  case DataBuffer.TYPE_SHORT:
-	    DataBufferShort inShort = (DataBufferShort) data;
-	    short[] outShort = (short[]) obj;
-	    if (outShort == null) outShort = new short[numBands];
-		
-	    for (int b=0; b<numBands; b++)
-	      {
-		int dOffset = totalBandDataOffsets[b];
-		outShort[b] = inShort.getData(bankIndices[b])[dOffset];
-	      }
-	    return outShort;
-
-	  case DataBuffer.TYPE_INT:
-	    DataBufferInt inInt = (DataBufferInt) data;
-	    int[] outInt = (int[]) obj;
-	    if (outInt == null) outInt = new int[numBands];
-		
-	    for (int b=0; b<numBands; b++)
-	      {
-		int dOffset = totalBandDataOffsets[b];
-		outInt[b] = inInt.getData(bankIndices[b])[dOffset];
-	      }
-	    return outInt;
-
-	  case DataBuffer.TYPE_FLOAT:
-	    DataBufferFloat inFloat = (DataBufferFloat) data;
-	    float[] outFloat = (float[]) obj;
-	    if (outFloat == null) outFloat = new float[numBands];
-
-	    for (int b=0; b<numBands; b++)
-	      {
-		int dOffset = totalBandDataOffsets[b];
-		outFloat[b] = inFloat.getData(bankIndices[b])[dOffset];
-	      }
-	    return outFloat;
-	    
-	  case DataBuffer.TYPE_DOUBLE:
-	    DataBufferDouble inDouble = (DataBufferDouble) data;
-	    double[] outDouble = (double[]) obj;
-	    if (outDouble == null) outDouble = new double[numBands];
-
-	    for (int b=0; b<numBands; b++)
-	      {
-		int dOffset = totalBandDataOffsets[b];
-		outDouble[b] = inDouble.getData(bankIndices[b])[dOffset];
-	      }
-	    return outDouble;
-	    
-	  default:
-	      throw new IllegalStateException("unknown transfer type " +
-					      getTransferType());
-	  }
+        switch (getTransferType())
+          {
+          case DataBuffer.TYPE_BYTE:
+            DataBufferByte inByte = (DataBufferByte) data;
+            byte[] outByte = (byte[]) obj;
+            if (outByte == null) 
+              outByte = new byte[numBands];
+                
+            for (int b = 0; b < numBands; b++)
+              {
+                int dOffset = totalBandDataOffsets[b];
+                outByte[b] = inByte.getData(bankIndices[b])[dOffset];
+              }
+            return outByte;
+                
+          case DataBuffer.TYPE_USHORT:
+            DataBufferUShort inUShort = (DataBufferUShort) data;
+            short[] outUShort = (short[]) obj;
+            if (outUShort == null) 
+              outUShort = new short[numBands];
+                
+            for (int b = 0; b < numBands; b++)
+              {
+                int dOffset = totalBandDataOffsets[b];
+                outUShort[b] = inUShort.getData(bankIndices[b])[dOffset];
+              }
+            return outUShort;
+
+          case DataBuffer.TYPE_SHORT:
+            DataBufferShort inShort = (DataBufferShort) data;
+            short[] outShort = (short[]) obj;
+            if (outShort == null) 
+              outShort = new short[numBands];
+                
+            for (int b = 0; b < numBands; b++)
+              {
+                int dOffset = totalBandDataOffsets[b];
+                outShort[b] = inShort.getData(bankIndices[b])[dOffset];
+              }
+            return outShort;
+
+          case DataBuffer.TYPE_INT:
+            DataBufferInt inInt = (DataBufferInt) data;
+            int[] outInt = (int[]) obj;
+            if (outInt == null) 
+              outInt = new int[numBands];
+                
+            for (int b = 0; b < numBands; b++)
+              {
+                int dOffset = totalBandDataOffsets[b];
+                outInt[b] = inInt.getData(bankIndices[b])[dOffset];
+              }
+            return outInt;
+
+          case DataBuffer.TYPE_FLOAT:
+            DataBufferFloat inFloat = (DataBufferFloat) data;
+            float[] outFloat = (float[]) obj;
+            if (outFloat == null) 
+              outFloat = new float[numBands];
+
+            for (int b = 0; b < numBands; b++)
+              {
+                int dOffset = totalBandDataOffsets[b];
+                outFloat[b] = inFloat.getData(bankIndices[b])[dOffset];
+              }
+            return outFloat;
+            
+          case DataBuffer.TYPE_DOUBLE:
+            DataBufferDouble inDouble = (DataBufferDouble) data;
+            double[] outDouble = (double[]) obj;
+            if (outDouble == null) 
+              outDouble = new double[numBands];
+
+            for (int b = 0; b < numBands; b++)
+              {
+                int dOffset = totalBandDataOffsets[b];
+                outDouble[b] = inDouble.getData(bankIndices[b])[dOffset];
+              }
+            return outDouble;
+            
+          default:
+              throw new IllegalStateException("unknown transfer type " 
+                                              + getTransferType());
+          }
       }
     catch (ArrayIndexOutOfBoundsException aioobe)
       {
-	String msg = "While reading data elements, " +
-	  "x=" + x + ", y=" + y +", " + ", xyOffset=" + xyOffset +
-	  ", data.getSize()=" + data.getSize() + ": " + aioobe;
-	throw new ArrayIndexOutOfBoundsException(msg);
+        String msg = "While reading data elements, " +
+          "x=" + x + ", y=" + y +", " + ", xyOffset=" + xyOffset +
+          ", data.getSize()=" + data.getSize() + ": " + aioobe;
+        throw new ArrayIndexOutOfBoundsException(msg);
       }
   }
 
+  /**
+   * Returns the samples for the pixels in the region defined by 
+   * <code>(x, y, w, h)</code> in a primitive array (the array type is 
+   * determined by the data type for this model).  The <code>obj</code> 
+   * argument provides an option to supply an existing array to hold the 
+   * result, if this is <code>null</code> a new array will be allocated.
+   * 
+   * @param x  the x-coordinate.
+   * @param y  the y-coordinate.
+   * @param w  the width.
+   * @param h  the height.
+   * @param obj  a primitive array that, if not <code>null</code>, will be 
+   *   used to store and return the sample values.
+   * @param data  the data buffer (<code>null</code> not permitted).
+   * 
+   * @return An array of sample values for the specified pixels.
+   * 
+   * @see #setDataElements(int, int, int, int, Object, DataBuffer)
+   */
   public Object getDataElements(int x, int y, int w, int h, Object obj,
-				DataBuffer data)
+                                DataBuffer data)
   {
     if (!tightPixelPacking)
       {
-	return super.getDataElements(x, y, w, h, obj, data);
+        return super.getDataElements(x, y, w, h, obj, data);
       }
 
     // using get speedup
     
     // We can copy whole rows
-    int rowSize = w*numBands;
-    int dataSize = rowSize*h;
+    int rowSize = w * numBands;
+    int dataSize = rowSize * h;
     
-    DataBuffer transferBuffer =
-      Buffers.createBuffer(getTransferType(), obj, dataSize);
+    DataBuffer transferBuffer = Buffers.createBuffer(getTransferType(), obj, 
+                                                     dataSize);
     obj = Buffers.getData(transferBuffer);
 
-    int inOffset =
-      pixelStride*x +
-      scanlineStride*y +
-      data.getOffset(); // Assumes only one band is used
+    int inOffset = pixelStride * x + scanlineStride * y + data.getOffset(); 
+                                           // Assumes only one band is used
 
     /* We don't add band offsets since we assume that bands have
        offsets 0, 1, 2, ... */
@@ -360,189 +590,345 @@ public class ComponentSampleModel extends SampleModel
     // See if we can copy everything in one go
     if (scanlineStride == rowSize)
       {
-	// Collapse scan lines:
-	rowSize *= h;
-	// We ignore scanlineStride since it won't be of any use
-	h = 1;
+        // Collapse scan lines:
+        rowSize *= h;
+        // We ignore scanlineStride since it won't be of any use
+        h = 1;
       }
 
     int outOffset = 0;
     Object inArray = Buffers.getData(data);
-    for (int yd = 0; yd<h; yd++)
+    for (int yd = 0; yd < h; yd++)
       {
-	System.arraycopy(inArray, inOffset, obj, outOffset, rowSize);
-	inOffset  += scanlineStride;
-	outOffset += rowSize;
+        System.arraycopy(inArray, inOffset, obj, outOffset, rowSize);
+        inOffset  += scanlineStride;
+        outOffset += rowSize;
       }
     return obj;
   }
 
+  /**
+   * Sets the samples for the pixels in the region defined by 
+   * <code>(x, y, w, h)</code> from a supplied primitive array (the array type 
+   * must be consistent with the data type for this model).  
+   * 
+   * @param x  the x-coordinate.
+   * @param y  the y-coordinate.
+   * @param w  the width.
+   * @param h  the height.
+   * @param obj  a primitive array containing the sample values.
+   * @param data  the data buffer (<code>null</code> not permitted).
+   * 
+   * @see #getDataElements(int, int, int, int, Object, DataBuffer)
+   */
   public void setDataElements(int x, int y, int w, int h,
-			      Object obj, DataBuffer data)
+                              Object obj, DataBuffer data)
   {
     if (!tightPixelPacking)
       {
-	super.setDataElements(x, y, w, h, obj, data);
-	return;
+        super.setDataElements(x, y, w, h, obj, data);
+        return;
       }
 
     // using set speedup, we can copy whole rows
-    int rowSize = w*numBands;
-    int dataSize = rowSize*h;
+    int rowSize = w * numBands;
+    int dataSize = rowSize * h;
     
-    DataBuffer transferBuffer =
-      Buffers.createBufferFromData(getTransferType(), obj, dataSize);
+    DataBuffer transferBuffer 
+        = Buffers.createBufferFromData(getTransferType(), obj, dataSize);
 
     int[] bankOffsets = data.getOffsets();
 
-    int outOffset =
-      pixelStride*x +
-      scanlineStride*y +
-      bankOffsets[0]; // same assuptions as in get...
+    int outOffset = pixelStride * x + scanlineStride * y + bankOffsets[0]; 
+                                                // same assumptions as in get...
 
     // See if we can copy everything in one go
     if (scanlineStride == rowSize)
       {
-	// Collapse scan lines:
-	rowSize *= h;
-	h = 1;
+        // Collapse scan lines:
+        rowSize *= h;
+        h = 1;
       }
 
     int inOffset = 0;
     Object outArray = Buffers.getData(data);
-    for (int yd = 0; yd<h; yd++)
+    for (int yd = 0; yd < h; yd++)
       {
-	System.arraycopy(obj, inOffset, outArray, outOffset, rowSize);
-	outOffset += scanlineStride;
-	inOffset  += rowSize;
+        System.arraycopy(obj, inOffset, outArray, outOffset, rowSize);
+        outOffset += scanlineStride;
+        inOffset += rowSize;
       }
   }
 
+  /**
+   * Returns all the samples for the pixel at location <code>(x, y)</code>
+   * stored in the specified data buffer.
+   * 
+   * @param x  the x-coordinate.
+   * @param y  the y-coordinate.
+   * @param iArray  an array that will be populated with the sample values and
+   *   returned as the result.  The size of this array should be equal to the 
+   *   number of bands in the model.  If the array is <code>null</code>, a new
+   *   array is created.
+   * @param data  the data buffer (<code>null</code> not permitted).
+   * 
+   * @return The samples for the specified pixel.
+   * 
+   * @see #setPixel(int, int, int[], DataBuffer)
+   */
   public int[] getPixel(int x, int y, int[] iArray, DataBuffer data)
   {
-    int offset = pixelStride*x + scanlineStride*y;
-    if (iArray == null) iArray = new int[numBands];
-    for (int b=0; b<numBands; b++)
+    int offset = pixelStride * x + scanlineStride * y;
+    if (iArray == null)
+      iArray = new int[numBands];
+    for (int b = 0; b < numBands; b++)
       {
-	iArray[b] = data.getElem(bankIndices[b], offset+bandOffsets[b]);
+        iArray[b] = data.getElem(bankIndices[b], offset + bandOffsets[b]);
       }
     return iArray;
   }
 
+  /**
+   * Returns the samples for all the pixels in a rectangular region.
+   * 
+   * @param x  the x-coordinate.
+   * @param y  the y-coordinate.
+   * @param w  the width.
+   * @param h  the height.
+   * @param iArray  an array that if non-<code>null</code> will be populated 
+   *   with the sample values and returned as the result.
+   * @param data  the data buffer (<code>null</code> not permitted).
+   * 
+   * @return The samples for all the pixels in the rectangle.
+   */
   public int[] getPixels(int x, int y, int w, int h, int[] iArray,
-			 DataBuffer data)
+                         DataBuffer data)
   {
-    int offset = pixelStride*x + scanlineStride*y;
-    if (iArray == null) iArray = new int[numBands*w*h];
+    int offset = pixelStride * x + scanlineStride * y;
+    if (iArray == null) 
+      iArray = new int[numBands * w * h];
     int outOffset = 0;
-    for (y=0; y<h; y++)
+    for (y = 0; y < h; y++)
       {
-	int lineOffset = offset;
-	for (x=0; x<w; x++)
-	  {
-	    for (int b=0; b<numBands; b++)
-	      {
-		iArray[outOffset++] = 
-		  data.getElem(bankIndices[b], lineOffset+bandOffsets[b]);
-	      }
-	    lineOffset += pixelStride;
-	  }
-	offset += scanlineStride;
+        int lineOffset = offset;
+        for (x = 0; x < w; x++)
+          {
+            for (int b = 0; b < numBands; b++)
+              {
+                iArray[outOffset++] 
+                    = data.getElem(bankIndices[b], lineOffset+bandOffsets[b]);
+              }
+            lineOffset += pixelStride;
+          }
+        offset += scanlineStride;
       }
     return iArray;
   }
-    
+ 
+  /**
+   * Returns the sample for band <code>b</code> of the pixel at 
+   * <code>(x, y)</code> that is stored in the specified data buffer.
+   * 
+   * @param x  the x-coordinate.
+   * @param y  the y-coordinate.
+   * @param b  the band index.
+   * @param data  the data buffer (<code>null</code> not permitted).
+   * 
+   * @return The sample value.
+   * 
+   * @see #setSample(int, int, int, int, DataBuffer)
+   */
   public int getSample(int x, int y, int b, DataBuffer data)
   {
     return data.getElem(bankIndices[b], getOffset(x, y, b));
   }
 
+  /**
+   * Sets the samples for the pixel at location <code>(x, y)</code> from the 
+   * supplied primitive array (the array type must be consistent with the data 
+   * type for this model).
+   * 
+   * @param x  the x-coordinate.
+   * @param y  the y-coordinate.
+   * @param obj  a primitive array containing the pixel's sample values.
+   * @param data  the data buffer (<code>null</code> not permitted).
+   * 
+   * @see #setDataElements(int, int, Object, DataBuffer)
+   */
   public void setDataElements(int x, int y, Object obj, DataBuffer data)
   {
-    int offset = pixelStride*x + scanlineStride*y;
+    int offset = pixelStride * x + scanlineStride * y;
     int[] totalBandDataOffsets = new int[numBands];
     int[] bankOffsets = data.getOffsets();
-    for (int b=0; b<numBands; b++)
-      totalBandDataOffsets[b] =
-	bandOffsets[b]+bankOffsets[bankIndices[b]] + offset;
+    for (int b = 0; b < numBands; b++)
+      totalBandDataOffsets[b] = bandOffsets[b] + bankOffsets[bankIndices[b]] 
+                                + offset;
 
     switch (getTransferType())
       {
       case DataBuffer.TYPE_BYTE:
-	{
-	  DataBufferByte out = (DataBufferByte) data;
-	  byte[] in = (byte[]) obj;
-	  
-	  for (int b=0; b<numBands; b++)
-	    out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
-	  
-	  return;
-	}
+        {
+          DataBufferByte out = (DataBufferByte) data;
+          byte[] in = (byte[]) obj;
+          
+          for (int b = 0; b < numBands; b++)
+            out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
+          
+          return;
+        }
       case DataBuffer.TYPE_USHORT:
-	{
-	  DataBufferUShort out = (DataBufferUShort) data;
-	  short[] in = (short[]) obj;
-	  
-	  for (int b=0; b<numBands; b++)
-	    out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
-	  
-	  return;
-	}
+        {
+          DataBufferUShort out = (DataBufferUShort) data;
+          short[] in = (short[]) obj;
+          
+          for (int b = 0; b < numBands; b++)
+            out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
+          
+          return;
+        }
       case DataBuffer.TYPE_SHORT:
-	{
-	  DataBufferShort out = (DataBufferShort) data;
-	  short[] in = (short[]) obj;
-	  
-	  for (int b=0; b<numBands; b++)
-	    out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
-	  
-	  return;
-	}
+        {
+          DataBufferShort out = (DataBufferShort) data;
+          short[] in = (short[]) obj;
+          
+          for (int b = 0; b < numBands; b++)
+            out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
+          
+          return;
+        }
       case DataBuffer.TYPE_INT:
-	{
-	  DataBufferInt out = (DataBufferInt) data;
-	  int[] in = (int[]) obj;
-	  
-	  for (int b=0; b<numBands; b++)
-	    out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
-	  
-	  return;
-	}
+        {
+          DataBufferInt out = (DataBufferInt) data;
+          int[] in = (int[]) obj;
+          
+          for (int b = 0; b < numBands; b++)
+            out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
+          
+          return;
+        }
       case DataBuffer.TYPE_FLOAT:
-	{
-	  DataBufferFloat out = (DataBufferFloat) data;
-	  float[] in = (float[]) obj;
-	  
-	  for (int b=0; b<numBands; b++)
-	    out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
-	  
-	  return;
-	}
+        {
+          DataBufferFloat out = (DataBufferFloat) data;
+          float[] in = (float[]) obj;
+          
+          for (int b = 0; b < numBands; b++)
+            out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
+          
+          return;
+        }
       case DataBuffer.TYPE_DOUBLE:
-	{
-	  DataBufferDouble out = (DataBufferDouble) data;
-	  double[] in = (double[]) obj;
-	  
-	  for (int b=0; b<numBands; b++)
-	    out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
-	  
-	  return;
-	}
+        {
+          DataBufferDouble out = (DataBufferDouble) data;
+          double[] in = (double[]) obj;
+          
+          for (int b = 0; b < numBands; b++)
+            out.getData(bankIndices[b])[totalBandDataOffsets[b]] = in[b];
+          
+          return;
+        }
       default:
-	throw new UnsupportedOperationException("transfer type not " +
-						"implemented");
+        throw new UnsupportedOperationException("transfer type not " +
+                                                "implemented");
       }
   }
   
+  /**
+   * Sets the sample values for the pixel at location <code>(x, y)</code>
+   * stored in the specified data buffer.
+   * 
+   * @param x  the x-coordinate.
+   * @param y  the y-coordinate.
+   * @param iArray  the pixel sample values (<code>null</code> not permitted).
+   * @param data  the data buffer (<code>null</code> not permitted).
+   * 
+   * @see #getPixel(int, int, int[], DataBuffer)
+   */
   public void setPixel(int x, int y, int[] iArray, DataBuffer data)
   {
-    int offset = pixelStride*x + scanlineStride*y;
-    for (int b=0; b<numBands; b++)
-      data.setElem(bankIndices[b], offset+bandOffsets[b], iArray[b]);
+    int offset = pixelStride * x + scanlineStride * y;
+    for (int b = 0; b < numBands; b++)
+      data.setElem(bankIndices[b], offset + bandOffsets[b], iArray[b]);
   }
     
+  /**
+   * Sets the sample value for band <code>b</code> of the pixel at location
+   * <code>(x, y)</code> in the specified data buffer.
+   * 
+   * @param x  the x-coordinate.
+   * @param y  the y-coordinate.
+   * @param b  the band index.
+   * @param s  the sample value.
+   * @param data  the data buffer (<code>null</code> not permitted).
+   * 
+   * @see #getSample(int, int, int, DataBuffer)
+   */
   public void setSample(int x, int y, int b, int s, DataBuffer data)
   {
     data.setElem(bankIndices[b], getOffset(x, y, b), s);
   }
+  
+  /**
+   * Tests this sample model for equality with an arbitrary object.  Returns
+   * <code>true</code> if and only if:
+   * <ul>
+   * <li><code>obj</code> is not <code>null</code>;</li>
+   * <li><code>obj</code> is an instance of <code>ComponentSampleModel</code>;
+   *   </li>
+   * <li>both models have the same values for the <code>dataType</code>,
+   *   <code>width</code>, <code>height</code>, <code>pixelStride</code>,
+   *   <code>scanlineStride</code>, <code>bandOffsets</code> and
+   *   <code>bankIndices</code> fields.</li>
+   * </ul>
+   * 
+   * @param obj  the object to test (<code>null</code> permitted).
+   * 
+   * @return <code>true</code> if this sample model is equal to 
+   *   <code>obj</code>, and <code>false</code> otherwise.
+   */
+  public boolean equals(Object obj)
+  {
+    if (obj == null)
+      return false;
+    if (! (obj instanceof ComponentSampleModel))
+      return false;
+    ComponentSampleModel that = (ComponentSampleModel) obj;
+    if (this.dataType != that.dataType)
+      return false;
+    if (this.width != that.width)
+      return false;
+    if (this.height != that.height)
+      return false;
+    if (this.pixelStride != that.pixelStride)
+      return false;
+    if (this.scanlineStride != that.scanlineStride)
+      return false;
+    if (! Arrays.equals(this.bandOffsets, that.bandOffsets))
+      return false;
+    if (! Arrays.equals(this.bankIndices, that.bankIndices))
+      return false;
+    // couldn't find any difference, so...
+    return true;
+  }
+  
+  /**
+   * Returns a hash code for this sample model.
+   * 
+   * @return The hash code.
+   */
+  public int hashCode()
+  {
+    // this computation is based on the method described in Chapter 3
+    // of Joshua Bloch's Effective Java...
+    int result = 17;
+    result = 37 * result + dataType;
+    result = 37 * result + width;
+    result = 37 * result + height;
+    result = 37 * result + pixelStride;
+    result = 37 * result + scanlineStride;
+    for (int i = 0; i < bandOffsets.length; i++)
+      result = 37 * result + bandOffsets[i];
+    for (int i = 0; i < bankIndices.length; i++)
+      result = 37 * result + bankIndices[i];
+    return result;
+  }
 }
diff --git a/libjava/classpath/java/awt/image/ConvolveOp.java b/libjava/classpath/java/awt/image/ConvolveOp.java
index 49ca2a6..1f73f75 100644
--- a/libjava/classpath/java/awt/image/ConvolveOp.java
+++ b/libjava/classpath/java/awt/image/ConvolveOp.java
@@ -110,7 +110,7 @@ public class ConvolveOp implements BufferedImageOp, RasterOp
    * @see java.awt.image.BufferedImageOp#filter(java.awt.image.BufferedImage,
    * java.awt.image.BufferedImage)
    */
-  public BufferedImage filter(BufferedImage src, BufferedImage dst)
+  public final BufferedImage filter(BufferedImage src, BufferedImage dst)
   {
     if (src == dst)
       throw new IllegalArgumentException();
@@ -163,7 +163,7 @@ public class ConvolveOp implements BufferedImageOp, RasterOp
   /* (non-Javadoc)
    * @see java.awt.image.RasterOp#getRenderingHints()
    */
-  public RenderingHints getRenderingHints()
+  public final RenderingHints getRenderingHints()
   {
     return hints;
   }
@@ -181,7 +181,7 @@ public class ConvolveOp implements BufferedImageOp, RasterOp
    *
    * @return The convolution kernel.
    */
-  public Kernel getKernel()
+  public final Kernel getKernel()
   {
     return (Kernel) kernel.clone();
   }
@@ -190,7 +190,7 @@ public class ConvolveOp implements BufferedImageOp, RasterOp
    * @see java.awt.image.RasterOp#filter(java.awt.image.Raster,
    * java.awt.image.WritableRaster)
    */
-  public WritableRaster filter(Raster src, WritableRaster dest) {
+  public final WritableRaster filter(Raster src, WritableRaster dest) {
     if (src == dest)
       throw new IllegalArgumentException();
     if (src.getWidth() < kernel.getWidth() ||
@@ -309,7 +309,7 @@ public class ConvolveOp implements BufferedImageOp, RasterOp
   /* (non-Javadoc)
    * @see java.awt.image.BufferedImageOp#getBounds2D(java.awt.image.BufferedImage)
    */
-  public Rectangle2D getBounds2D(BufferedImage src)
+  public final Rectangle2D getBounds2D(BufferedImage src)
   {
     return src.getRaster().getBounds();
   }
@@ -317,7 +317,7 @@ public class ConvolveOp implements BufferedImageOp, RasterOp
   /* (non-Javadoc)
    * @see java.awt.image.RasterOp#getBounds2D(java.awt.image.Raster)
    */
-  public Rectangle2D getBounds2D(Raster src)
+  public final Rectangle2D getBounds2D(Raster src)
   {
     return src.getBounds();
   }
@@ -330,7 +330,7 @@ public class ConvolveOp implements BufferedImageOp, RasterOp
    * @see java.awt.image.RasterOp#getPoint2D(java.awt.geom.Point2D,
    * java.awt.geom.Point2D)
    */
-  public Point2D getPoint2D(Point2D src, Point2D dst)
+  public final Point2D getPoint2D(Point2D src, Point2D dst)
   {
     if (dst == null) return (Point2D)src.clone();
     dst.setLocation(src);
diff --git a/libjava/classpath/java/awt/image/DirectColorModel.java b/libjava/classpath/java/awt/image/DirectColorModel.java
index 4f37151..579dc97 100644
--- a/libjava/classpath/java/awt/image/DirectColorModel.java
+++ b/libjava/classpath/java/awt/image/DirectColorModel.java
@@ -167,7 +167,7 @@ public class DirectColorModel extends PackedColorModel
   private int extractAndNormalizeSample(int pixel, int component)
   {
     int value = extractAndScaleSample(pixel, component);
-    if (hasAlpha() && isAlphaPremultiplied())
+    if (hasAlpha() && isAlphaPremultiplied() && getAlpha(pixel) != 0)
       value = value*255/getAlpha(pixel);
     return value;
   }
diff --git a/libjava/classpath/java/awt/image/LookupOp.java b/libjava/classpath/java/awt/image/LookupOp.java
index f131daa..46e72fe 100644
--- a/libjava/classpath/java/awt/image/LookupOp.java
+++ b/libjava/classpath/java/awt/image/LookupOp.java
@@ -81,7 +81,7 @@ public class LookupOp implements BufferedImageOp, RasterOp
   /* (non-Javadoc)
    * @see java.awt.image.BufferedImageOp#filter(java.awt.image.BufferedImage, java.awt.image.BufferedImage)
    */
-  public BufferedImage filter(BufferedImage src, BufferedImage dst)
+  public final BufferedImage filter(BufferedImage src, BufferedImage dst)
   {
     if (src.getColorModel() instanceof IndexColorModel)
       throw new IllegalArgumentException("LookupOp.filter: IndexColorModel "
@@ -149,7 +149,7 @@ public class LookupOp implements BufferedImageOp, RasterOp
   /* (non-Javadoc)
    * @see java.awt.image.BufferedImageOp#getBounds2D(java.awt.image.BufferedImage)
    */
-  public Rectangle2D getBounds2D(BufferedImage src)
+  public final Rectangle2D getBounds2D(BufferedImage src)
   {
     return src.getRaster().getBounds();
   }
@@ -173,7 +173,7 @@ public class LookupOp implements BufferedImageOp, RasterOp
    * @param dst The destination point.
    * @see java.awt.image.RasterOp#getPoint2D(java.awt.geom.Point2D, java.awt.geom.Point2D)
    */
-  public Point2D getPoint2D(Point2D src, Point2D dst)
+  public final Point2D getPoint2D(Point2D src, Point2D dst)
   {
     if (dst == null)
       return (Point2D) src.clone();
@@ -183,7 +183,7 @@ public class LookupOp implements BufferedImageOp, RasterOp
   }
 
   /** Return the LookupTable for this op. */
-  public LookupTable getTable()
+  public final LookupTable getTable()
   {
     return lut;
   }
@@ -191,7 +191,7 @@ public class LookupOp implements BufferedImageOp, RasterOp
   /* (non-Javadoc)
    * @see java.awt.image.RasterOp#getRenderingHints()
    */
-  public RenderingHints getRenderingHints()
+  public final RenderingHints getRenderingHints()
   {
     return hints;
   }
@@ -209,7 +209,7 @@ public class LookupOp implements BufferedImageOp, RasterOp
    * component but not the same as src and dest.
    * @see java.awt.image.RasterOp#filter(java.awt.image.Raster, java.awt.image.WritableRaster)
    */
-  public WritableRaster filter(Raster src, WritableRaster dest)
+  public final WritableRaster filter(Raster src, WritableRaster dest)
   {
     if (dest == null) 
       // Allocate a raster if needed
@@ -236,7 +236,7 @@ public class LookupOp implements BufferedImageOp, RasterOp
   /* (non-Javadoc)
    * @see java.awt.image.RasterOp#getBounds2D(java.awt.image.Raster)
    */
-  public Rectangle2D getBounds2D(Raster src)
+  public final Rectangle2D getBounds2D(Raster src)
   {
     return src.getBounds();
   }
diff --git a/libjava/classpath/java/awt/image/ReplicateScaleFilter.java b/libjava/classpath/java/awt/image/ReplicateScaleFilter.java
index d76f9db..6d5099d 100644
--- a/libjava/classpath/java/awt/image/ReplicateScaleFilter.java
+++ b/libjava/classpath/java/awt/image/ReplicateScaleFilter.java
@@ -46,7 +46,6 @@ import java.util.Hashtable;
  * exact method is not defined by Sun but some sort of fast Box filter should
  * probably be correct.
  * <br>
- * Currently this filter does nothing and needs to be implemented.
  *
  * @author C. Brian Jones (cbj@gnu.org) 
  */
diff --git a/libjava/classpath/java/awt/image/RescaleOp.java b/libjava/classpath/java/awt/image/RescaleOp.java
index 35b42f7..d5b2969 100644
--- a/libjava/classpath/java/awt/image/RescaleOp.java
+++ b/libjava/classpath/java/awt/image/RescaleOp.java
@@ -93,7 +93,7 @@ public class RescaleOp implements BufferedImageOp, RasterOp
   /* (non-Javadoc)
    * @see java.awt.image.BufferedImageOp#getRenderingHints()
    */
-  public RenderingHints getRenderingHints()
+  public final RenderingHints getRenderingHints()
   {
     return hints;
   }
diff --git a/libjava/classpath/java/awt/image/SampleModel.java b/libjava/classpath/java/awt/image/SampleModel.java
index 1159662..6e3fd40 100644
--- a/libjava/classpath/java/awt/image/SampleModel.java
+++ b/libjava/classpath/java/awt/image/SampleModel.java
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000, 2001, 2002, 2005  Free Software Foundation
+/* Copyright (C) 2000, 2001, 2002, 2005, 2006,  Free Software Foundation
 
 This file is part of GNU Classpath.
 
@@ -57,15 +57,43 @@ public abstract class SampleModel
    */
   protected int dataType;
 
+  /**
+   * Creates a new sample model with the specified attributes.
+   * 
+   * @param dataType  the data type (one of {@link DataBuffer#TYPE_BYTE},
+   *   {@link DataBuffer#TYPE_USHORT}, {@link DataBuffer#TYPE_SHORT},
+   *   {@link DataBuffer#TYPE_INT}, {@link DataBuffer#TYPE_FLOAT}, 
+   *   {@link DataBuffer#TYPE_DOUBLE} or {@link DataBuffer#TYPE_UNDEFINED}).
+   * @param w  the width in pixels (must be greater than zero).
+   * @param h  the height in pixels (must be greater than zero).
+   * @param numBands  the number of bands (must be greater than zero).
+   * 
+   * @throws IllegalArgumentException if <code>dataType</code> is not one of 
+   *   the listed values.
+   * @throws IllegalArgumentException if <code>w</code> is less than or equal
+   *   to zero.
+   * @throws IllegalArgumentException if <code>h</code> is less than or equal 
+   *   to zero.
+   * @throws IllegalArgumentException if <code>w * h</code> is greater than
+   *   {@link Integer#MAX_VALUE}.
+   */
   public SampleModel(int dataType, int w, int h, int numBands)
   {
+    if (dataType != DataBuffer.TYPE_UNDEFINED)
+      if (dataType < DataBuffer.TYPE_BYTE || dataType > DataBuffer.TYPE_DOUBLE)
+        throw new IllegalArgumentException("Unrecognised 'dataType' argument.");
+    
     if ((w <= 0) || (h <= 0)) 
       throw new IllegalArgumentException((w <= 0 ? " width<=0" : " width is ok")
-                                         +(h <= 0 ? " height<=0" : " height is ok"));
-	
-    // FIXME: How can an int be greater than Integer.MAX_VALUE?
-    // FIXME: How do we identify an unsupported data type?
-
+          + (h <= 0 ? " height<=0" : " height is ok"));
+        
+    long area = (long) w * (long) h;
+    if (area > Integer.MAX_VALUE)
+      throw new IllegalArgumentException("w * h exceeds Integer.MAX_VALUE.");
+
+    if (numBands <= 0)
+      throw new IllegalArgumentException("Requires numBands > 0.");
+      
     this.dataType = dataType;
     this.width = w;
     this.height = h;
@@ -102,8 +130,10 @@ public abstract class SampleModel
 
   public int[] getPixel(int x, int y, int[] iArray, DataBuffer data)
   {
-    if (iArray == null) iArray = new int[numBands];
-    for (int b=0; b<numBands; b++) iArray[b] = getSample(x, y, b, data);
+    if (iArray == null) 
+      iArray = new int[numBands];
+    for (int b = 0; b < numBands; b++) 
+      iArray[b] = getSample(x, y, b, data);
     return iArray;
   }
   
@@ -121,94 +151,95 @@ public abstract class SampleModel
    * DataBuffer.TYPE_USHORT, then a short[] object is returned.
    */
   public abstract Object getDataElements(int x, int y, Object obj,
-					 DataBuffer data);
+                                         DataBuffer data);
 
     
   public Object getDataElements(int x, int y, int w, int h, Object obj,
-				DataBuffer data)
+                                DataBuffer data)
   {
-    int size = w*h;
+    int size = w * h;
     int numDataElements = getNumDataElements();
-    int dataSize = numDataElements*size;
+    int dataSize = numDataElements * size;
     
     if (obj == null)
       {
-	switch (getTransferType())
-	  {
-	  case DataBuffer.TYPE_BYTE:
-	    obj = new byte[dataSize];
-	    break;
-	  case DataBuffer.TYPE_USHORT:
-	    obj = new short[dataSize];
-	    break;
-	  case DataBuffer.TYPE_INT:
-	    obj = new int[dataSize];
-	    break;
-	  default:
-	    // Seems like the only sensible thing to do.
-	    throw new ClassCastException();
-	  }
+        switch (getTransferType())
+          {
+          case DataBuffer.TYPE_BYTE:
+            obj = new byte[dataSize];
+            break;
+          case DataBuffer.TYPE_USHORT:
+            obj = new short[dataSize];
+            break;
+          case DataBuffer.TYPE_INT:
+            obj = new int[dataSize];
+            break;
+          default:
+            // Seems like the only sensible thing to do.
+            throw new ClassCastException();
+          }
       }
     Object pixelData = null;
     int outOffset = 0;
-    for (int yy = y; yy<(y+h); yy++)
+    for (int yy = y; yy < (y + h); yy++)
       {
-	for (int xx = x; xx<(x+w); xx++)
-	  {
-	    pixelData = getDataElements(xx, yy, pixelData, data);
-	    System.arraycopy(pixelData, 0, obj, outOffset,
-			     numDataElements);
-	    outOffset += numDataElements;
-	  }
+        for (int xx = x; xx < (x + w); xx++)
+          {
+            pixelData = getDataElements(xx, yy, pixelData, data);
+            System.arraycopy(pixelData, 0, obj, outOffset,
+                             numDataElements);
+            outOffset += numDataElements;
+          }
       }
     return obj;
   }
 
   public abstract void setDataElements(int x, int y, Object obj,
-				       DataBuffer data);
+                                       DataBuffer data);
 
   public void setDataElements(int x, int y, int w, int h,
-			      Object obj, DataBuffer data)
+                              Object obj, DataBuffer data)
   {
-    int size = w*h;
+    int size = w * h;
     int numDataElements = getNumDataElements();
-    int dataSize = numDataElements*size;
+    int dataSize = numDataElements * size;
     
     Object pixelData;
     switch (getTransferType())
       {
       case DataBuffer.TYPE_BYTE:
-	pixelData = new byte[numDataElements];
-	break;
+        pixelData = new byte[numDataElements];
+        break;
       case DataBuffer.TYPE_USHORT:
-	pixelData = new short[numDataElements];
-	break;
+        pixelData = new short[numDataElements];
+        break;
       case DataBuffer.TYPE_INT:
-	pixelData = new int[numDataElements];
-	break;
+        pixelData = new int[numDataElements];
+        break;
       default:
-	// Seems like the only sensible thing to do.
-	throw new ClassCastException();
+        // Seems like the only sensible thing to do.
+        throw new ClassCastException();
       }
     int inOffset = 0;
 
-    for (int yy=y; yy<(y+h); yy++)
+    for (int yy = y; yy < (y + h); yy++)
       {
-	for (int xx=x; xx<(x+w); xx++)
-	  {
-	    System.arraycopy(obj, inOffset, pixelData, 0,
-			     numDataElements);
-	    setDataElements(xx, yy, pixelData, data);
-	    inOffset += numDataElements;
-	  }
+        for (int xx = x; xx < (x + w); xx++)
+          {
+            System.arraycopy(obj, inOffset, pixelData, 0,
+                             numDataElements);
+            setDataElements(xx, yy, pixelData, data);
+            inOffset += numDataElements;
+          }
       }
   }
 
   public float[] getPixel(int x, int y, float[] fArray, DataBuffer data)
   {
-    if (fArray == null) fArray = new float[numBands];
+    if (fArray == null) 
+      fArray = new float[numBands];
     
-    for (int b=0; b<numBands; b++)
+    for (int b = 0; b < numBands; b++)
       {
         fArray[b] = getSampleFloat(x, y, b, data);
       }
@@ -216,10 +247,11 @@ public abstract class SampleModel
   }
 
   public double[] getPixel(int x, int y, double[] dArray, DataBuffer data) {
-    if (dArray == null) dArray = new double[numBands];
-    for (int b=0; b<numBands; b++)
+    if (dArray == null) 
+      dArray = new double[numBands];
+    for (int b = 0; b < numBands; b++)
       {
-	dArray[b] = getSampleDouble(x, y, b, data);
+        dArray[b] = getSampleDouble(x, y, b, data);
       }
     return dArray;
   }
@@ -227,20 +259,21 @@ public abstract class SampleModel
   /* FIXME: Should it return a banded or pixel interleaved array of
      samples? (Assume interleaved.) */
   public int[] getPixels(int x, int y, int w, int h, int[] iArray,
-			 DataBuffer data)
+                         DataBuffer data)
   {
-    int size = w*h;
+    int size = w * h;
     int outOffset = 0;
     int[] pixel = null;
-    if (iArray == null) iArray = new int[w*h*numBands];
-    for (int yy=y; yy<(y+h); yy++)
+    if (iArray == null) 
+      iArray = new int[w * h * numBands];
+    for (int yy = y; yy < (y + h); yy++)
       {
-	for (int xx=x; xx<(x+w); xx++)
-	  {
-	    pixel = getPixel(xx, yy, pixel, data);
-	    System.arraycopy(pixel, 0, iArray, outOffset, numBands);
-	    outOffset += numBands;
-	  }
+        for (int xx = x; xx < (x + w); xx++)
+          {
+            pixel = getPixel(xx, yy, pixel, data);
+            System.arraycopy(pixel, 0, iArray, outOffset, numBands);
+            outOffset += numBands;
+          }
       }
     return iArray;
   }
@@ -248,20 +281,20 @@ public abstract class SampleModel
   /* FIXME: Should it return a banded or pixel interleaved array of
      samples? (Assume interleaved.) */
   public float[] getPixels(int x, int y, int w, int h, float[] fArray,
-			   DataBuffer data)
+                           DataBuffer data)
   {
-    int size = w*h;
+    int size = w * h;
     int outOffset = 0;
     float[] pixel = null;
-    if (fArray == null) fArray = new float[w*h*numBands];
-    for (int yy=y; yy<(y+h); yy++)
+    if (fArray == null) fArray = new float[w * h * numBands];
+    for (int yy = y; yy < (y + h); yy++)
       {
-	for (int xx=x; xx<(x+w); xx++)
-	  {
-	    pixel = getPixel(xx, yy, pixel, data);
-	    System.arraycopy(pixel, 0, fArray, outOffset, numBands);
-	    outOffset += numBands;
-	  }
+        for (int xx = x; xx < (x + w); xx++)
+          {
+            pixel = getPixel(xx, yy, pixel, data);
+            System.arraycopy(pixel, 0, fArray, outOffset, numBands);
+            outOffset += numBands;
+          }
       }
     return fArray;
   }
@@ -269,20 +302,21 @@ public abstract class SampleModel
   /* FIXME: Should it return a banded or pixel interleaved array of
      samples? (Assume interleaved.) */
   public double[] getPixels(int x, int y, int w, int h, double[] dArray,
-			    DataBuffer data)
+                            DataBuffer data)
   {
-    int size = w*h;
+    int size = w * h;
     int outOffset = 0;
     double[] pixel = null;
-    if (dArray == null) dArray = new double[w*h*numBands];
-    for (int yy=y; yy<(y+h); yy++)
+    if (dArray == null) 
+      dArray = new double[w * h * numBands];
+    for (int yy = y; yy < (y + h); yy++)
       {
-	for (int xx=x; xx<(x+w); xx++)
-	  {
-	    pixel = getPixel(xx, yy, pixel, data);
-	    System.arraycopy(pixel, 0, dArray, outOffset, numBands);
-	    outOffset += numBands;
-	  }
+        for (int xx = x; xx < (x + w); xx++)
+          {
+            pixel = getPixel(xx, yy, pixel, data);
+            System.arraycopy(pixel, 0, dArray, outOffset, numBands);
+            outOffset += numBands;
+          }
       }
     return dArray;
   }
@@ -300,179 +334,185 @@ public abstract class SampleModel
   }
 
   public int[] getSamples(int x, int y, int w, int h, int b,
-			  int[] iArray, DataBuffer data)
+                          int[] iArray, DataBuffer data)
   {
-    int size = w*h;
+    int size = w * h;
     int outOffset = 0;
-    if (iArray == null) iArray = new int[size];
-    for (int yy=y; yy<(y+h); yy++)
+    if (iArray == null) 
+      iArray = new int[size];
+    for (int yy = y; yy < (y + h); yy++)
       {
-	for (int xx=x; xx<(x+w); xx++)
-	  {
-	    iArray[outOffset++] = getSample(xx, yy, b, data);
-	  }
+        for (int xx = x; xx < (x + w); xx++)
+          {
+            iArray[outOffset++] = getSample(xx, yy, b, data);
+          }
       }
     return iArray;
   }
 
   public float[] getSamples(int x, int y, int w, int h, int b,
-			    float[] fArray, DataBuffer data)
+                            float[] fArray, DataBuffer data)
   {
-    int size = w*h;
+    int size = w * h;
     int outOffset = 0;
-    if (fArray == null) fArray = new float[size];
-    for (int yy=y; yy<(y+h); yy++)
+    if (fArray == null) 
+      fArray = new float[size];
+    for (int yy = y; yy < (y + h); yy++)
       {
-	for (int xx=x; xx<(x+w); xx++)
-	  {
-	    fArray[outOffset++] = getSampleFloat(xx, yy, b, data);
-	  }
+        for (int xx = x; xx < (x + w); xx++)
+          {
+            fArray[outOffset++] = getSampleFloat(xx, yy, b, data);
+          }
       }
     return fArray;
   }
 
   public double[] getSamples(int x, int y, int w, int h, int b,
-			     double[] dArray, DataBuffer data)
+                             double[] dArray, DataBuffer data)
   {
-    int size = w*h;
+    int size = w * h;
     int outOffset = 0;
-    if (dArray == null) dArray = new double[size];
-    for (int yy=y; yy<(y+h); yy++)
+    if (dArray == null) 
+      dArray = new double[size];
+    for (int yy = y; yy < (y + h); yy++)
       {
-	for (int xx=x; xx<(x+w); xx++)
-	  {
-	    dArray[outOffset++] = getSampleDouble(xx, yy, b, data);
-	  }
+        for (int xx = x; xx < (x + w); xx++)
+          {
+            dArray[outOffset++] = getSampleDouble(xx, yy, b, data);
+          }
       }
     return dArray;
   }
   
   public void setPixel(int x, int y, int[] iArray, DataBuffer data)
   {
-    for (int b=0; b<numBands; b++) setSample(x, y, b, iArray[b], data);
+    for (int b = 0; b < numBands; b++) 
+      setSample(x, y, b, iArray[b], data);
   }
 
   public void setPixel(int x, int y, float[] fArray, DataBuffer data)
   {
-    for (int b=0; b<numBands; b++) setSample(x, y, b, fArray[b], data);
+    for (int b = 0; b < numBands; b++) 
+      setSample(x, y, b, fArray[b], data);
   }
 
   public void setPixel(int x, int y, double[] dArray, DataBuffer data)
   {
-    for (int b=0; b<numBands; b++) setSample(x, y, b, dArray[b], data);
+    for (int b = 0; b < numBands; b++) 
+      setSample(x, y, b, dArray[b], data);
   }
 
   public void setPixels(int x, int y, int w, int h, int[] iArray,
-			DataBuffer data)
+                        DataBuffer data)
   {
     int inOffset = 0;
     int[] pixel = new int[numBands];
-    for (int yy=y; yy<(y+h); yy++)
+    for (int yy = y; yy < (y + h); yy++)
       {
-	for (int xx=x; xx<(x+w); xx++)
-	  {
-	    System.arraycopy(iArray, inOffset, pixel, 0, numBands);
-	    setPixel(xx, yy, pixel, data);
-	    inOffset += numBands;
-	  }
+        for (int xx = x; xx < (x + w); xx++)
+          {
+            System.arraycopy(iArray, inOffset, pixel, 0, numBands);
+            setPixel(xx, yy, pixel, data);
+            inOffset += numBands;
+          }
       }
   }
 
   public void setPixels(int x, int y, int w, int h, float[] fArray,
-			DataBuffer data)
+                        DataBuffer data)
   {
     int inOffset = 0;
     float[] pixel = new float[numBands];
-    for (int yy=y; yy<(y+h); yy++)
+    for (int yy = y; yy < (y + h); yy++)
       {
-	for (int xx=x; xx<(x+w); xx++)
-	  {
-	    System.arraycopy(fArray, inOffset, pixel, 0, numBands);
-	    setPixel(xx, yy, pixel, data);
-	    inOffset += numBands;
-	  }
+        for (int xx = x; xx < (x + w); xx++)
+          {
+            System.arraycopy(fArray, inOffset, pixel, 0, numBands);
+            setPixel(xx, yy, pixel, data);
+            inOffset += numBands;
+          }
       }
   }
 
   public void setPixels(int x, int y, int w, int h, double[] dArray,
-			DataBuffer data)
+                        DataBuffer data)
   {
     int inOffset = 0;
     double[] pixel = new double[numBands];
-    for (int yy=y; yy<(y+h); yy++)
+    for (int yy = y; yy < (y + h); yy++)
       {
-	for (int xx=x; xx<(x+w); xx++)
-	  {
-	    System.arraycopy(dArray, inOffset, pixel, 0, numBands);
-	    setPixel(xx, yy, pixel, data);
-	    inOffset += numBands;
-	  }
+        for (int xx = x; xx < (x + w); xx++)
+          {
+            System.arraycopy(dArray, inOffset, pixel, 0, numBands);
+            setPixel(xx, yy, pixel, data);
+            inOffset += numBands;
+          }
       }
   }
 
   public abstract void setSample(int x, int y, int b, int s,
-				 DataBuffer data);
+                                 DataBuffer data);
 
   public void setSample(int x, int y, int b, float s,
-			DataBuffer data)
+                        DataBuffer data)
   {
     setSample(x, y, b, (int) s, data);
   }
 
   public void setSample(int x, int y, int b, double s,
-			DataBuffer data)
+                        DataBuffer data)
   {
     setSample(x, y, b, (float) s, data);
   }
 
   public void setSamples(int x, int y, int w, int h, int b,
-			 int[] iArray, DataBuffer data)
+                         int[] iArray, DataBuffer data)
   {
-    int size = w*h;
+    int size = w * h;
     int inOffset = 0;
-    for (int yy=y; yy<(y+h); yy++)
-      for (int xx=x; xx<(x+w); xx++)
-	setSample(xx, yy, b, iArray[inOffset++], data);
+    for (int yy = y; yy < (y + h); yy++)
+      for (int xx = x; xx < (x + w); xx++)
+        setSample(xx, yy, b, iArray[inOffset++], data);
   }
 
   public void setSamples(int x, int y, int w, int h, int b,
-			 float[] fArray, DataBuffer data)
+                         float[] fArray, DataBuffer data)
   {
-    int size = w*h;
+    int size = w * h;
+    int inOffset = 0;
+    for (int yy = y; yy < (y + h); yy++)
+      for (int xx = x; xx < (x + w); xx++)
+        setSample(xx, yy, b, fArray[inOffset++], data);
+
+  }
+
+  public void setSamples(int x, int y, int w, int h, int b,
+                         double[] dArray, DataBuffer data) {
+    int size = w * h;
     int inOffset = 0;
-    for (int yy=y; yy<(y+h); yy++)
-      for (int xx=x; xx<(x+w); xx++)
-	setSample(xx, yy, b, fArray[inOffset++], data);
-
-    }
-
-    public void setSamples(int x, int y, int w, int h, int b,
-			   double[] dArray, DataBuffer data) {
-      int size = w*h;
-      int inOffset = 0;
-      for (int yy=y; yy<(y+h); yy++)
-	for (int xx=x; xx<(x+w); xx++)
-	  setSample(xx, yy, b, dArray[inOffset++], data);
-    }
-
-    public abstract SampleModel createCompatibleSampleModel(int w, int h);
-
-    /**
-     * Return a SampleModel with a subset of the bands in this model.
-     * 
-     * Selects bands.length bands from this sample model.  The bands chosen
-     * are specified in the indices of bands[].  This also permits permuting
-     * the bands as well as taking a subset.  Thus, giving an array with
-     * 1, 2, 3, ..., numbands, will give an identical sample model.
-     * 
-     * @param bands Array with band indices to include.
-     * @return A new sample model
-     */
-    public abstract SampleModel createSubsetSampleModel(int[] bands);
-
-    public abstract DataBuffer createDataBuffer();
-
-    public abstract int[] getSampleSize();
-
-    public abstract int getSampleSize(int band);
+    for (int yy = y; yy < (y + h); yy++)
+      for (int xx = x; xx < (x + w); xx++)
+        setSample(xx, yy, b, dArray[inOffset++], data);
+  }
+
+  public abstract SampleModel createCompatibleSampleModel(int w, int h);
+
+  /**
+   * Return a SampleModel with a subset of the bands in this model.
+   * 
+   * Selects bands.length bands from this sample model.  The bands chosen
+   * are specified in the indices of bands[].  This also permits permuting
+   * the bands as well as taking a subset.  Thus, giving an array with
+   * 1, 2, 3, ..., numbands, will give an identical sample model.
+   * 
+   * @param bands Array with band indices to include.
+   * @return A new sample model
+   */
+  public abstract SampleModel createSubsetSampleModel(int[] bands);
+
+  public abstract DataBuffer createDataBuffer();
+
+  public abstract int[] getSampleSize();
+
+  public abstract int getSampleSize(int band);
 }
diff --git a/libjava/classpath/java/awt/image/renderable/RenderableImageProducer.java b/libjava/classpath/java/awt/image/renderable/RenderableImageProducer.java
index 78f3051..d8cca65 100644
--- a/libjava/classpath/java/awt/image/renderable/RenderableImageProducer.java
+++ b/libjava/classpath/java/awt/image/renderable/RenderableImageProducer.java
@@ -1,5 +1,5 @@
 /* RenderableImageProducer.java -- 
-   Copyright (C) 2002 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2006 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -38,42 +38,129 @@ exception statement from your version. */
 
 package java.awt.image.renderable;
 
+import java.awt.image.ColorModel;
+import java.awt.image.DataBuffer;
 import java.awt.image.ImageConsumer;
 import java.awt.image.ImageProducer;
+import java.awt.image.Raster;
+import java.awt.image.RenderedImage;
+import java.awt.image.SampleModel;
+import java.util.ArrayList;
+import java.util.Iterator;
 
 public class RenderableImageProducer implements ImageProducer, Runnable
 {
+  private RenderableImage image;
+  private RenderContext context;
+  private ArrayList consumers = new ArrayList();
+
   public RenderableImageProducer(RenderableImage image, RenderContext context)
   {
-    throw new Error("not implemented");
+    this.image = image;
+    this.context = context;
   }
 
   public void setRenderContext(RenderContext context)
   {
+    this.context = context;
   }
 
   public void addConsumer(ImageConsumer consumer)
   {
+    synchronized (consumers)
+      {
+        if (! consumers.contains(consumer))
+          consumers.add(consumer);
+      }
   }
 
   public boolean isConsumer(ImageConsumer consumer)
   {
-    return false;
+    synchronized (consumers)
+      {
+        return consumers.contains(consumer);
+      }
   }
 
   public void removeConsumer(ImageConsumer consumer)
   {
+    synchronized (consumers)
+      {
+        consumers.remove(consumer);
+      }
   }
 
   public void startProduction(ImageConsumer consumer)
   {
+    addConsumer(consumer);
+    Thread t = new Thread(this, "RenderableImageProducerWorker");
+    t.start();
   }
 
   public void requestTopDownLeftRightResend(ImageConsumer consumer)
   {
+    // Do nothing.  The contract says we can ignore this call, so we do.
   }
 
   public void run()
   {
+    // This isn't ideal but it avoids fail-fast problems.
+    // Alternatively, we could clone 'consumers' here.
+    synchronized (consumers)
+      {
+        RenderedImage newImage;
+        if (context == null)
+          newImage = image.createDefaultRendering();
+        else
+          newImage = image.createRendering(context);
+        Raster newData = newImage.getData();
+        ColorModel colorModel = newImage.getColorModel();
+        if (colorModel == null)
+          colorModel = ColorModel.getRGBdefault();
+        SampleModel sampleModel = newData.getSampleModel();
+        DataBuffer dataBuffer = newData.getDataBuffer();
+        int width = newData.getWidth();
+        int height = newData.getHeight();
+
+        // Initialize the consumers.
+        Iterator it = consumers.iterator();
+        while (it.hasNext())
+          {
+            ImageConsumer target = (ImageConsumer) it.next();
+            target.setHints(ImageConsumer.COMPLETESCANLINES
+                            | ImageConsumer.SINGLEFRAME
+                            | ImageConsumer.SINGLEPASS
+                            | ImageConsumer.TOPDOWNLEFTRIGHT);
+            target.setDimensions(width, height);
+          }
+
+        // Work in scan-line order.
+        int[] newLine = new int[width];
+        int[] bands = new int[sampleModel.getNumBands()];
+        for (int y = 0; y < height; ++y)
+          {
+            for (int x = 0; x < width; ++x)
+              {
+                sampleModel.getPixel(x, y, bands, dataBuffer);
+                newLine[x] = colorModel.getDataElement(bands, 0);
+              }
+
+            // Tell the consumers about the new scan line.
+            it = consumers.iterator();
+            while (it.hasNext())
+              {
+                ImageConsumer target = (ImageConsumer) it.next();
+                target.setPixels(0, y, width, 1, colorModel, newLine, 0, width);
+              }
+          }
+
+        // Tell the consumers that we're done.
+        it = consumers.iterator();
+        while (it.hasNext())
+          {
+            ImageConsumer target = (ImageConsumer) it.next();
+            target.imageComplete(ImageConsumer.STATICIMAGEDONE);
+          }
+      }
   }
 } // class RenderableImageProducer