diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index bc20e9637f3a1de543c3058d6cabfdbc568d28c9..3db9ddc0bf381685927a469fe8817330685f4bb7 100644
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,27 @@
+2002-01-23 Tom Tromey <tromey@redhat.com>
+
+ * Makefile.in: Rebuilt.
+ * Makefile.am (awt_java_source_files): Added new files.
+ * java/awt/image/AreaAveragingScaleFilter.java: New file from
+ Classpath.
+ * java/awt/image/CropImageFilter.java: New file from Classpath.
+ * java/awt/image/FilteredImageSource.java: New file from
+ Classpath.
+ * java/awt/image/ImageFilter.java: New file from Classpath.
+ * java/awt/image/MemoryImageSource.java: New file from Classpath.
+ * java/awt/image/PixelGrabber.java: New file from Classpath.
+ * java/awt/image/RGBImageFilter.java: New file from Classpath.
+ * java/awt/image/ReplicateScaleFilter.java: New file from
+ Classpath.
+ * java/awt/image/ImageProducer.java: Replaced with Classpath
+ version.
+ * java/awt/image/ImageObserver.java: Replaced with Classpath
+ version.
+ * java/awt/image/ImageConsumer.java: Replaced with Classpath
+ version.
+ * java/awt/GridBagConstraints.java (clone): Catch
+ CloneNotSupportedException.
+
2002-01-23 Per Bothner <per@bothner.com>
* java/lang/reflect/natField.cc (setAddr): New function.
diff --git a/libjava/Makefile.am b/libjava/Makefile.am
index 3ce308c6d67d16517a0991441759faccc7a60918..e93dd949b8f2a1004edb732a208bd30d519ea812 100644
--- a/libjava/Makefile.am
+++ b/libjava/Makefile.am
@@ -726,22 +726,30 @@ java/awt/geom/Point2D.java \
java/awt/geom/Rectangle2D.java \
java/awt/geom/RectangularShape.java \
java/awt/geom/RoundRectangle2D.java \
+java/awt/image/AreaAveragingScaleFilter.java \
java/awt/image/BufferedImage.java \
java/awt/image/ColorModel.java \
java/awt/image/ComponentColorModel.java \
java/awt/image/ComponentSampleModel.java \
+java/awt/image/CropImageFilter.java \
java/awt/image/DataBuffer.java \
java/awt/image/DataBufferByte.java \
java/awt/image/DataBufferInt.java \
java/awt/image/DataBufferUShort.java \
java/awt/image/DirectColorModel.java \
+java/awt/image/FilteredImageSource.java \
java/awt/image/ImageConsumer.java \
+java/awt/image/ImageFilter.java \
java/awt/image/ImageObserver.java \
java/awt/image/ImageProducer.java \
java/awt/image/IndexColorModel.java \
+java/awt/image/MemoryImageSource.java \
java/awt/image/PackedColorModel.java \
+java/awt/image/PixelGrabber.java \
+java/awt/image/RGBImageFilter.java \
java/awt/image/Raster.java \
java/awt/image/RasterOp.java \
+java/awt/image/ReplicateScaleFilter.java \
java/awt/image/SampleModel.java \
java/awt/image/SinglePixelPackedSampleModel.java \
java/awt/image/WritableRaster.java \
diff --git a/libjava/Makefile.in b/libjava/Makefile.in
index ac5848dab469d632316b5c24ba3c1f73b49c0d69..f5757531ee43f9f1176ebbcb194dd448e00639e6 100644
--- a/libjava/Makefile.in
+++ b/libjava/Makefile.in
@@ -477,22 +477,30 @@ java/awt/geom/Point2D.java \
java/awt/geom/Rectangle2D.java \
java/awt/geom/RectangularShape.java \
java/awt/geom/RoundRectangle2D.java \
+java/awt/image/AreaAveragingScaleFilter.java \
java/awt/image/BufferedImage.java \
java/awt/image/ColorModel.java \
java/awt/image/ComponentColorModel.java \
java/awt/image/ComponentSampleModel.java \
+java/awt/image/CropImageFilter.java \
java/awt/image/DataBuffer.java \
java/awt/image/DataBufferByte.java \
java/awt/image/DataBufferInt.java \
java/awt/image/DataBufferUShort.java \
java/awt/image/DirectColorModel.java \
+java/awt/image/FilteredImageSource.java \
java/awt/image/ImageConsumer.java \
+java/awt/image/ImageFilter.java \
java/awt/image/ImageObserver.java \
java/awt/image/ImageProducer.java \
java/awt/image/IndexColorModel.java \
+java/awt/image/MemoryImageSource.java \
java/awt/image/PackedColorModel.java \
+java/awt/image/PixelGrabber.java \
+java/awt/image/RGBImageFilter.java \
java/awt/image/Raster.java \
java/awt/image/RasterOp.java \
+java/awt/image/ReplicateScaleFilter.java \
java/awt/image/SampleModel.java \
java/awt/image/SinglePixelPackedSampleModel.java \
java/awt/image/WritableRaster.java \
@@ -2070,19 +2078,27 @@ DEP_FILES = .deps/$(srcdir)/$(CONVERT_DIR)/gen-from-JIS.P \
.deps/java/awt/geom/Rectangle2D.P \
.deps/java/awt/geom/RectangularShape.P \
.deps/java/awt/geom/RoundRectangle2D.P \
+.deps/java/awt/image/AreaAveragingScaleFilter.P \
.deps/java/awt/image/BufferedImage.P .deps/java/awt/image/ColorModel.P \
.deps/java/awt/image/ComponentColorModel.P \
.deps/java/awt/image/ComponentSampleModel.P \
+.deps/java/awt/image/CropImageFilter.P \
.deps/java/awt/image/DataBuffer.P .deps/java/awt/image/DataBufferByte.P \
.deps/java/awt/image/DataBufferInt.P \
.deps/java/awt/image/DataBufferUShort.P \
.deps/java/awt/image/DirectColorModel.P \
-.deps/java/awt/image/ImageConsumer.P \
+.deps/java/awt/image/FilteredImageSource.P \
+.deps/java/awt/image/ImageConsumer.P .deps/java/awt/image/ImageFilter.P \
.deps/java/awt/image/ImageObserver.P \
.deps/java/awt/image/ImageProducer.P \
.deps/java/awt/image/IndexColorModel.P \
-.deps/java/awt/image/PackedColorModel.P .deps/java/awt/image/Raster.P \
-.deps/java/awt/image/RasterOp.P .deps/java/awt/image/SampleModel.P \
+.deps/java/awt/image/MemoryImageSource.P \
+.deps/java/awt/image/PackedColorModel.P \
+.deps/java/awt/image/PixelGrabber.P \
+.deps/java/awt/image/RGBImageFilter.P .deps/java/awt/image/Raster.P \
+.deps/java/awt/image/RasterOp.P \
+.deps/java/awt/image/ReplicateScaleFilter.P \
+.deps/java/awt/image/SampleModel.P \
.deps/java/awt/image/SinglePixelPackedSampleModel.P \
.deps/java/awt/image/WritableRaster.P .deps/java/awt/peer/ButtonPeer.P \
.deps/java/awt/peer/CanvasPeer.P \
diff --git a/libjava/java/awt/GridBagConstraints.java b/libjava/java/awt/GridBagConstraints.java
index c91ed0969dd9e6331616546c4c642cadd0012792..dd72a519a8de56ac1960d23495f3743faf1f0efc 100644
--- a/libjava/java/awt/GridBagConstraints.java
+++ b/libjava/java/awt/GridBagConstraints.java
@@ -1,6 +1,6 @@
// GridBagConstraints.java - Constraints for GridBag layout manager
-/* Copyright (C) 2000, 2001 Free Software Foundation
+/* Copyright (C) 2000, 2001, 2002 Free Software Foundation
This file is part of GNU Classpath.
@@ -93,9 +93,17 @@ public class GridBagConstraints implements Cloneable, Serializable
/** Create a copy of this object. */
public Object clone ()
{
- GridBagConstraints g = (GridBagConstraints) super.clone ();
- g.insets = (Insets) insets.clone ();
- return g;
+ try
+ {
+ GridBagConstraints g = (GridBagConstraints) super.clone ();
+ g.insets = (Insets) insets.clone ();
+ return g;
+ }
+ catch (CloneNotSupportedException _)
+ {
+ // Can't happen.
+ return null;
+ }
}
/** Create a new GridBagConstraints object with the default
diff --git a/libjava/java/awt/image/AreaAveragingScaleFilter.java b/libjava/java/awt/image/AreaAveragingScaleFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2e6ea54cb601a56b973c1fa01c336a59979066c
--- /dev/null
+++ b/libjava/java/awt/image/AreaAveragingScaleFilter.java
@@ -0,0 +1,127 @@
+/* AreaAveragingScaleFilter.java -- Java class for filtering images
+ Copyright (C) 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package java.awt.image;
+
+/**
+ * This filter should produce images which do not have image artifacts
+ * like broken lines which were originally unbroken. The cost is of
+ * course speed. Using bi-linear interpolation here against 4 pixel
+ * points should give the desired results although Sun does not
+ * specify what the exact algorithm should be.
+ * <br>
+ * 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)
+ {
+ 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)
+ {
+ 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)
+ {
+ consumer.setPixels(x, y, w, h, model, pixels, offset, scansize);
+ }
+
+}
+
diff --git a/libjava/java/awt/image/CropImageFilter.java b/libjava/java/awt/image/CropImageFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ffc148b22b6e90238023e20f4609d788891e2d8
--- /dev/null
+++ b/libjava/java/awt/image/CropImageFilter.java
@@ -0,0 +1,140 @@
+/* CropImageFilter.java -- Java class for cropping image filter
+ Copyright (C) 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package java.awt.image;
+
+import java.util.Hashtable;
+
+/**
+ * <br>
+ * Currently this filter does almost nothing and needs to be implemented.
+ *
+ * @author C. Brian Jones (cbj@gnu.org)
+ */
+public class CropImageFilter extends ImageFilter
+{
+ int x;
+ int y;
+ int width;
+ int height;
+
+ /**
+ * Construct a new <code>CropImageFilter</code> instance.
+ *
+ * @param x the x-coordinate location of the top-left of the cropped rectangle
+ * @param y the y-coordinate location of the top-left of the cropped rectangle
+ * @param width the width of the cropped rectangle
+ * @param height the height of the cropped rectangle
+ */
+ public CropImageFilter(int x, int y, int width, int height) {
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ }
+
+ /**
+ * An <code>ImageProducer</code> indicates the size of the image
+ * being produced using this method. This filter overrides this
+ * method in order to set the dimentions to the size of the
+ * cropped rectangle instead of the size of the image.
+ *
+ * @param width the width of the image
+ * @param height the height of the image
+ */
+ public void setDimensions(int width, int height)
+ {
+ consumer.setDimensions(this.width, this.height);
+ }
+
+ /**
+ * An <code>ImageProducer</code> can set a list of properties
+ * associated with this image by using this method.
+ * <br>
+ * FIXME - What property is set for this class?
+ *
+ * @param props the list of properties associated with this image
+ */
+ public void setProperties(Hashtable props)
+ {
+// props.put("filters", "ReplicateScaleFilter");
+ consumer.setProperties(props);
+ }
+
+ /**
+ * 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)
+ {
+ 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)
+ {
+ consumer.setPixels(x, y, w, h, model, pixels, offset, scansize);
+ }
+
+}
+
diff --git a/libjava/java/awt/image/FilteredImageSource.java b/libjava/java/awt/image/FilteredImageSource.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f64f897f27671426ef7c0ab8aac205fadaf4956
--- /dev/null
+++ b/libjava/java/awt/image/FilteredImageSource.java
@@ -0,0 +1,125 @@
+/* FilteredImageSource.java -- Java class for providing image data
+ Copyright (C) 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package java.awt.image;
+
+import java.util.Hashtable;
+
+/**
+ *
+ * @see ImageConsumer
+ * @author C. Brian Jones (cbj@gnu.org)
+ */
+public class FilteredImageSource implements ImageProducer
+{
+ ImageProducer ip;
+ ImageFilter filter;
+ Hashtable consumers = new Hashtable();
+
+ /**
+ * The given filter is applied to the given image producer
+ * to create a new image producer.
+ */
+ public FilteredImageSource(ImageProducer ip, ImageFilter filter) {
+ this.ip = ip;
+ this.filter = filter;
+ }
+
+ /**
+ * Used to register an <code>ImageConsumer</code> with this
+ * <code>ImageProducer</code>.
+ */
+ public synchronized void addConsumer(ImageConsumer ic) {
+ if (consumers.containsKey(ic))
+ return;
+
+ ImageFilter f = filter.getFilterInstance(ic);
+ consumers.put(ic, f);
+ ip.addConsumer(f);
+ }
+
+ /**
+ * Used to determine if the given <code>ImageConsumer</code> is
+ * already registered with this <code>ImageProducer</code>.
+ */
+ public synchronized boolean isConsumer(ImageConsumer ic) {
+ ImageFilter f = (ImageFilter)consumers.get(ic);
+ if (f != null)
+ return ip.isConsumer(f);
+ return false;
+ }
+
+ /**
+ * Used to remove an <code>ImageConsumer</code> from the list of
+ * registered consumers for this <code>ImageProducer</code>.
+ */
+ public synchronized void removeConsumer(ImageConsumer ic) {
+ ImageFilter f = (ImageFilter)consumers.remove(ic);
+ if (f != null)
+ ip.removeConsumer(f);
+ }
+
+ /**
+ * Used to register an <code>ImageConsumer</code> with this
+ * <code>ImageProducer</code> and then immediately start
+ * reconstruction of the image data to be delivered to all
+ * registered consumers.
+ */
+ public void startProduction(ImageConsumer ic) {
+ ImageFilter f;
+ if (!(consumers.containsKey(ic))) {
+ f = filter.getFilterInstance(ic);
+ consumers.put(ic, f);
+ ip.addConsumer(f);
+ } else {
+ f = (ImageFilter)consumers.get( ic );
+ }
+ ip.startProduction(f);
+ }
+
+ /**
+ * Used to register an <code>ImageConsumer</code> with this
+ * <code>ImageProducer</code> and then request that this producer
+ * resend the image data in the order top-down, left-right.
+ */
+ public void requestTopDownLeftRightResend(ImageConsumer ic) {
+ ImageFilter f = (ImageFilter)consumers.get(ic);
+ ip.requestTopDownLeftRightResend(f);
+ }
+}
+
diff --git a/libjava/java/awt/image/ImageFilter.java b/libjava/java/awt/image/ImageFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..b34bb7d9cd38208bcbdeeb6d8fa24a9d5c6226be
--- /dev/null
+++ b/libjava/java/awt/image/ImageFilter.java
@@ -0,0 +1,218 @@
+/* ImageFilter.java -- Java class for filtering images
+ Copyright (C) 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package java.awt.image;
+
+import java.util.Hashtable;
+
+/**
+ * The <code>ImageFilter</code> class is a base class which can be
+ * extended to provide different types of filters for an image. By
+ * default this class does nothing to an image passing through it.
+ *
+ * @author C. Brian Jones (cbj@gnu.org)
+ */
+public class ImageFilter implements ImageConsumer, Cloneable
+{
+ /**
+ * The consumer this filter is filtering an image data stream for.
+ * It is initialized in the method <code>getFilterInstance</code>.
+ */
+ protected ImageConsumer consumer = null;
+
+ /**
+ * The <code>ImageConsumer</code> can use this method to request
+ * the pixels be delivered in top-down, left-right order.
+ * <br>
+ * The filter can respond in three different ways.
+ * <ul>
+ * <li>The default behavior is to forward the request to the
+ * <code>ImageProducer</code>
+ * using the method <code>requestTopDownLeftRightResend</code>
+ * and using the filter as the consumer.</li>
+ * <li>The filter has the pixels and can retransmit them in the
+ * top-down, left-right order.</li>
+ * <li>The filter can do nothing when this method is called.</li>
+ * </ul>
+ */
+ public void resendTopDownLeftRight(ImageProducer ip)
+ {
+ ip.requestTopDownLeftRightResend(this);
+ }
+
+ /**
+ * By default, returns a shallow copy of the object created by
+ * <code>Object.clone()</code>
+ *
+ * @see java.lang.Object#clone ()
+ */
+ public Object clone() throws CloneNotSupportedException
+ {
+ return (super.clone());
+ }
+
+ /**
+ * This is the only method which can set the
+ * <code>ImageConsumer</code> for this filter. By default a clone
+ * of this filter with the appropriate consumer set is returned.
+ *
+ * @see #clone ()
+ */
+ public ImageFilter getFilterInstance(ImageConsumer ic)
+ {
+ if ( ic == null )
+ throw new IllegalArgumentException("null argument for ImageFilter.getFilterInstance(ImageConsumer)");
+
+ consumer = ic;
+ try {
+ ImageFilter f = (ImageFilter)clone();
+ consumer = null;
+ return f;
+ } catch ( CloneNotSupportedException cnse ) {
+ cnse.printStackTrace();
+ consumer = null;
+ return null;
+ }
+ }
+
+ /**
+ * An <code>ImageProducer</code> indicates the size of the image
+ * being produced using this method. A filter can override this
+ * method to intercept these calls from the producer in order to
+ * change either the width or the height before in turn calling
+ * the consumer's <code>setDimensions</code> method.
+ *
+ * @param width the width of the image
+ * @param height the height of the image
+ */
+ public void setDimensions(int width, int height)
+ {
+ consumer.setDimensions(width, height);
+ }
+
+ /**
+ * An <code>ImageProducer</code> can set a list of properties
+ * associated with this image by using this method.
+ *
+ * @param props the list of properties associated with this image
+ */
+ public void setProperties(Hashtable props)
+ {
+ props.put("filters", "ImageFilter");
+ consumer.setProperties(props);
+ }
+
+ /**
+ * Override this method to process calls to this method from the
+ * <code>ImageProducer</code>. By default the <code>setColorModel</code>
+ * method of the consumer is called with the specified <code>model</code>.
+ *
+ * @param model the color model to be used most often by setPixels
+ * @see ColorModel */
+ public void setColorModel(ColorModel model)
+ {
+ consumer.setColorModel(model);
+ }
+
+ /**
+ * 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.
+ *
+ * @param flags a bit mask of hints
+ * @see ImageConsumer
+ */
+ public void setHints(int flags)
+ {
+ 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)
+ {
+ 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)
+ {
+ consumer.setPixels(x, y, w, h, model, pixels, offset, scansize);
+ }
+
+ /**
+ * The <code>ImageProducer</code> calls this method to indicate a
+ * single frame or the entire image is complete. The method is
+ * also used to indicate an error in loading or producing the
+ * image.
+ */
+ public void imageComplete(int status)
+ {
+ consumer.imageComplete(status);
+ }
+}
+
diff --git a/libjava/java/awt/image/MemoryImageSource.java b/libjava/java/awt/image/MemoryImageSource.java
new file mode 100644
index 0000000000000000000000000000000000000000..fce112a0656006a3299f4e0e24e3993e5ff44bd8
--- /dev/null
+++ b/libjava/java/awt/image/MemoryImageSource.java
@@ -0,0 +1,333 @@
+/* MemoryImageSource.java -- Java class for providing image data
+ Copyright (C) 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package java.awt.image;
+
+import java.awt.Image;
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+public class MemoryImageSource implements ImageProducer
+{
+ private boolean animated = false;
+ private boolean fullbuffers = false;
+ private int pixeli[], width, height, offset, scansize;
+ private byte pixelb[];
+ private ColorModel cm;
+ private Hashtable props, consumers = new Hashtable();
+
+ /**
+ Constructs an ImageProducer from memory
+ */
+ public MemoryImageSource(int w, int h, ColorModel cm,
+ byte pix[], int off, int scan)
+ {
+ this ( w, h, cm, pix, off, scan, null );
+ }
+ /**
+ Constructs an ImageProducer from memory
+ */
+ public MemoryImageSource( int w, int h, ColorModel cm,
+ byte pix[], int off, int scan,
+ Hashtable props)
+ {
+ width = w;
+ height = h;
+ this.cm = cm;
+ offset = off;
+ scansize = scan;
+ this.props = props;
+ int max = (( scansize > width ) ? scansize : width );
+ pixelb = new byte[ max * height ];
+ System.arraycopy( pix, 0, pixelb, 0, max );
+ }
+ /**
+ Constructs an ImageProducer from memory
+ */
+ public MemoryImageSource(int w, int h, ColorModel cm,
+ int pix[], int off, int scan)
+ {
+ this ( w, h, cm, pix, off, scan, null );
+ }
+
+ /**
+ Constructs an ImageProducer from memory
+ */
+ public MemoryImageSource(int w, int h, ColorModel cm,
+ int pix[], int off, int scan,
+ Hashtable props)
+ {
+ width = w;
+ height = h;
+ this.cm = cm;
+ offset = off;
+ scansize = scan;
+ this.props = props;
+ int max = (( scansize > width ) ? scansize : width );
+ pixeli = new int[ max * height ];
+ System.arraycopy( pix, 0, pixeli, 0, max );
+ }
+ /**
+ Constructs an ImageProducer from memory using the default RGB ColorModel
+ */
+ public MemoryImageSource(int w, int h,
+ int pix[], int off, int scan,
+ Hashtable props)
+ {
+ this ( w, h, ColorModel.getRGBdefault(), pix, off, scan, props);
+ }
+
+ /**
+ Constructs an ImageProducer from memory using the default RGB ColorModel
+ */
+ public MemoryImageSource(int w, int h,
+ byte pix[], int off, int scan)
+ {
+ this ( w, h, ColorModel.getRGBdefault(), pix, off, scan, null);
+ }
+
+ /**
+ * Used to register an <code>ImageConsumer</code> with this
+ * <code>ImageProducer</code>.
+ */
+ public synchronized void addConsumer(ImageConsumer ic) {
+ if (consumers.containsKey(ic))
+ return;
+
+ consumers.put(ic, ic);
+ }
+
+ /**
+ * Used to determine if the given <code>ImageConsumer</code> is
+ * already registered with this <code>ImageProducer</code>.
+ */
+ public synchronized boolean isConsumer(ImageConsumer ic) {
+ if (consumers.containsKey(ic))
+ return true;
+ return false;
+ }
+
+ /**
+ * Used to remove an <code>ImageConsumer</code> from the list of
+ * registered consumers for this <code>ImageProducer</code>.
+ */
+ public synchronized void removeConsumer(ImageConsumer ic) {
+ consumers.remove(ic);
+ }
+
+ /**
+ * Used to register an <code>ImageConsumer</code> with this
+ * <code>ImageProducer</code> and then immediately start
+ * reconstruction of the image data to be delivered to all
+ * registered consumers.
+ */
+ public void startProduction(ImageConsumer ic) {
+ if (!(consumers.containsKey(ic))) {
+ consumers.put(ic, ic);
+ }
+ Enumeration e = consumers.elements();
+ for( ; e.hasMoreElements(); ) {
+ ic = (ImageConsumer)e.nextElement();
+ sendPicture( ic );
+ ic.imageComplete( ImageConsumer.SINGLEFRAME );
+ }
+
+ }
+
+ /**
+ * Used to register an <code>ImageConsumer</code> with this
+ * <code>ImageProducer</code> and then request that this producer
+ * resend the image data in the order top-down, left-right.
+ */
+ public void requestTopDownLeftRightResend(ImageConsumer ic) {
+ startProduction ( ic );
+ }
+
+
+ /**
+ Changes a flag to indicate whether this MemoryImageSource supports
+ animations.
+
+ @param animated A flag indicating whether this class supports animations
+ */
+ public synchronized void setAnimated(boolean animated)
+ {
+ this.animated = animated;
+ }
+
+
+ /**
+ A flag to indicate whether or not to send full buffer updates when
+ sending animation. If this flag is set then full buffers are sent
+ in the newPixels methods instead of just regions.
+
+ @param fullbuffers - a flag indicating whether to send the full buffers
+ */
+ public synchronized void setFullBufferUpdates(boolean fullbuffers)
+ {
+ this.fullbuffers = fullbuffers;
+ }
+
+ /**
+ Send an animation frame to the image consumers.
+ */
+ public void newPixels()
+ {
+ if( animated == true ) {
+ ImageConsumer ic;
+ Enumeration e = consumers.elements();
+ for( ; e.hasMoreElements(); ) {
+ ic = (ImageConsumer)e.nextElement();
+ sendPicture( ic );
+ ic.imageComplete( ImageConsumer.SINGLEFRAME );
+ }
+ }
+ }
+
+
+ private void sendPicture ( ImageConsumer ic )
+ {
+ ic.setHints( ImageConsumer.TOPDOWNLEFTRIGHT );
+ if( props != null ) {
+ ic.setProperties( props );
+ }
+ if( pixeli != null ) {
+ ic.setPixels( 0, 0, width, height, cm, pixeli, offset, scansize );
+ } else {
+ ic.setPixels( 0, 0, width, height, cm, pixelb, offset, scansize );
+ }
+ }
+
+ /**
+ Send an animation frame to the image consumers containing the specified
+ pixels unless setFullBufferUpdates is set.
+ */
+ public synchronized void newPixels(int x,
+ int y,
+ int w,
+ int h)
+ {
+ if( animated == true )
+ {
+ if( fullbuffers ) {
+ newPixels();
+ } else {
+ ImageConsumer ic;
+ Enumeration e = consumers.elements();
+ for( ; e.hasMoreElements(); ) {
+ ic = (ImageConsumer)e.nextElement();
+ ic.setHints( ImageConsumer.TOPDOWNLEFTRIGHT );
+ if( props != null ) {
+ ic.setProperties( props );
+ }
+ if( pixeli != null ) {
+ ic.setPixels( 0, 0, width, height, cm, pixeli, offset, scansize );
+ } else {
+ ic.setPixels( 0, 0, width, height, cm, pixelb, offset, scansize );
+ }
+ ic.imageComplete( ImageConsumer.SINGLEFRAME );
+ }
+ }
+ }
+ }
+
+
+
+ /**
+ Send an animation frame to the image consumers containing the specified
+ pixels unless setFullBufferUpdates is set.
+
+ If framenotify is set then a notification is sent when the frame
+ is sent otherwise no status is sent.
+ */
+ public synchronized void newPixels(int x,
+ int y,
+ int w,
+ int h,
+ boolean framenotify)
+ {
+ if( animated == true )
+ {
+ if( fullbuffers ) {
+ newPixels();
+ } else {
+ ImageConsumer ic;
+ Enumeration e = consumers.elements();
+ for( ; e.hasMoreElements(); ) {
+ ic = (ImageConsumer)e.nextElement();
+ ic.setHints( ImageConsumer.TOPDOWNLEFTRIGHT );
+ if( props != null ) {
+ ic.setProperties( props );
+ }
+ if( pixeli != null ) {
+ ic.setPixels( 0, 0, width, height, cm, pixeli, offset, scansize );
+ } else {
+ ic.setPixels( 0, 0, width, height, cm, pixelb, offset, scansize );
+ }
+ if( framenotify == true )
+ ic.imageComplete( ImageConsumer.SINGLEFRAME );
+ }
+ }
+ }
+ }
+
+ public synchronized void newPixels(byte newpix[],
+ ColorModel newmodel,
+ int offset,
+ int scansize)
+
+ {
+ if( animated == true )
+ {
+ //FIXME
+ }
+ }
+
+ public synchronized void newPixels(int newpix[],
+ ColorModel newmodel,
+ int offset,
+ int scansize)
+
+ {
+ if( animated == true )
+ {
+ //FIXME
+ }
+ }
+
+}
diff --git a/libjava/java/awt/image/PixelGrabber.java b/libjava/java/awt/image/PixelGrabber.java
new file mode 100644
index 0000000000000000000000000000000000000000..efa98856ca32591ac181c8163ece575fa34b47c9
--- /dev/null
+++ b/libjava/java/awt/image/PixelGrabber.java
@@ -0,0 +1,361 @@
+/* PixelGrabber.java -- Java class for providing image data
+ Copyright (C) 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package java.awt.image;
+
+import java.awt.Image;
+import java.util.Hashtable;
+
+/**
+ PixelGrabber is an ImageConsumer designed to extract a rectangular region of pixels
+ from an Image
+ */
+public class PixelGrabber implements ImageConsumer
+{
+ int x, y, width, height, status, scansize, offset;
+ ColorModel model = ColorModel.getRGBdefault();
+ //int hints;
+ //Hashtable props;
+ int pixel_bufferi[];
+ byte pixel_bufferb[];
+ boolean grabbing;
+ ImageProducer ip;
+
+ /**
+ * Create a PixelGrabber used to grab pixels from the specified Image
+ * in the specified rectangle
+ *
+ * @param img the Image to grab pixels from
+ * @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 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 PixelGrabber(Image img, int x, int y, int w, int h,
+ int pix[], int off, int scansize)
+ {
+ this( img.getSource(), x, y, w, h, pix, off, scansize );
+ }
+
+ /**
+ * Create a PixelGrabber used to grab pixels from the specified ImageProducer
+ * in the specified rectangle
+ *
+ * @param ip the ImageProducer to grab pixels from
+ * @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 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 PixelGrabber(ImageProducer ip, int x, int y, int w, int h,
+ int pix[], int off, int scansize)
+ {
+ this.ip = ip;
+ this.x = x;
+ this.y = y;
+ this.width = w;
+ this.height = h;
+ this.pixel_bufferi = pix;
+ this.offset = off;
+ this.scansize = scansize;
+ pixel_bufferb = new byte[pix.length * 4];
+ }
+
+
+ /**
+ * Create a PixelGrabber used to grab pixels from the specified Image
+ * in the specified rectangle
+ *
+ * @param img the Image to grab pixels from
+ * @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 forceRGB true to force conversion to RGB
+ */
+ public PixelGrabber(Image img,
+ int x, int y,
+ int w, int h,
+ boolean forceRGB)
+ {
+ //FIXME
+ }
+
+ /**
+ Start Grabbing Pixels
+ */
+ public synchronized void startGrabbing()
+ {
+ if ( grabbing == false )
+ {
+ grabbing = true;
+ ip.startProduction( this );
+ }
+ }
+
+ /**
+ Abort the grabbing of pixels
+ */
+ public synchronized void abortGrabbing()
+ {
+ if ( grabbing == true )
+ {
+ grabbing = false;
+ ip.removeConsumer( this );
+ }
+ }
+
+ /**
+ Grab the Pixels.
+
+ @return true if successful
+
+ @throws InterruptedExcpetion if interrupted by another thread.
+ */
+ public boolean grabPixels() throws InterruptedException
+ {
+ startGrabbing();
+ while ( (status != ImageObserver.ALLBITS ) ||
+ (status != ImageObserver.ERROR ) ||
+ (status != ImageObserver.ABORT ) );
+
+ if( status == ImageObserver.ALLBITS )
+ return true;
+ else
+ return false;
+ }
+
+ /**
+ Grab the Pixels and abort if it takes too long
+
+ @return true if successful
+
+ @throws InterruptedExcpetion if interrupted by another thread.
+ or time runs out
+ */
+ public synchronized boolean grabPixels(long ms) throws InterruptedException
+ {
+ long start = System.currentTimeMillis();
+ startGrabbing();
+ while ( (status != ImageObserver.ALLBITS ) ||
+ (status != ImageObserver.ERROR ) ||
+ (status != ImageObserver.ABORT ) )
+ {
+ if( (System.currentTimeMillis() - start ) >= ms )
+ {
+ abortGrabbing();
+ throw new InterruptedException();
+ }
+ }
+
+ if( status == ImageObserver.ALLBITS )
+ return true;
+ else
+ return false;
+
+ }
+
+ /**
+ Get the status of the pixel grabbing representing by ImageObserver flags
+
+ @return the status
+ */
+ public synchronized int getStatus()
+ {
+ return status;
+ }
+
+ /**
+ Return width of pixel region
+
+ @return width of region
+ */
+ public synchronized int getWidth()
+ {
+ return width;
+ }
+
+ /**
+ Return height of pixel region
+
+ @return height of region
+ */
+ public synchronized int getHeight()
+ {
+ return height;
+ }
+
+ /**
+ Returns the grabbed pixel buffer
+
+ @return a byte or int array
+ */
+ public synchronized Object getPixels()
+ {
+ if( pixel_bufferi != null )
+ return pixel_bufferi;
+ return pixel_bufferb;
+ }
+
+ /**
+ Get the ColorModel of the image
+
+ @return the ColorModel
+ */
+ public synchronized ColorModel getColorModel()
+ {
+ return model;
+ }
+
+ /**
+ * An <code>ImageProducer</code> indicates the size of the image
+ * being produced using this method.
+ *
+ * @param width the width of the image
+ * @param height the height of the image
+ */
+ public void setDimensions(int width, int height)
+ {
+ }
+
+ /**
+ * An <code>ImageProducer</code> can set a list of properties
+ * associated with this image by using this method.
+ *
+ * @param props the list of properties associated with this image
+ */
+ public void setProperties(Hashtable props)
+ {
+ //this.props = props; //FIXME - DO WE NEED THIS
+ }
+
+ /**
+ * This <code>ColorModel</code> should indicate the model used by
+ * the majority of calls to <code>setPixels</code>. Each call to
+ * <code>setPixels</code> could however indicate a different
+ * <code>ColorModel</code>.
+ *
+ * @param model the color model to be used most often by setPixels
+ * @see ColorModel
+ */
+ public void setColorModel(ColorModel model)
+ {
+ this.model = model;
+ }
+
+ /**
+ * 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>.
+ *
+ * @param flags a bit mask of hints
+ */
+ public void setHints(int flags)
+ {
+ //hints = flags; // FIXME - DO NOT KNOW WHAT TO DO WITH THE HINTS
+ }
+
+ /**
+ * 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).
+ */
+ public void setPixels(int x, int y, int w, int h,
+ ColorModel model, byte[] pixels, int offset, int scansize)
+ {
+ //FIXME - I hate bytes
+ int xp, yp;
+ for( xp = x; xp < ( x + w); xp++ )
+ for( yp = y; yp < (y + h); yp++ )
+ if( xp >= this.x &&
+ yp >= this.y &&
+ xp <= ( this.x + this.width ) &&
+ yp <= ( this.y + this.height ) ) {
+ pixel_bufferb[(yp - this.y) * this.scansize + (xp - this.x) + this.offset] =
+ pixels[ offset + yp * scansize + xp ];
+ }
+
+ }
+
+ /**
+ * 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).
+ */
+ public void setPixels(int x, int y, int w, int h,
+ ColorModel model, int[] pixels, int offset, int scansize)
+ {
+ int xp, yp;
+ for( xp = x; xp < ( x + w); xp++ )
+ for( yp = y; yp < (y + h); yp++ )
+ if( xp >= this.x &&
+ yp >= this.y &&
+ xp <= ( this.x + this.width ) &&
+ yp <= ( this.y + this.height ) ) {
+ pixel_bufferi[(yp - this.y) * this.scansize + (xp - this.x) + this.offset] =
+ pixels[ offset + yp * scansize + xp ];
+ }
+ }
+
+ /**
+ * The <code>ImageProducer</code> calls this method to indicate a
+ * single frame or the entire image is complete. The method is
+ * also used to indicate an error in loading or producing the
+ * image.
+ */
+ public synchronized void imageComplete(int status)
+ {
+ this.status = status;
+ }
+
+ /**
+ @deprecated by getStatus
+ */
+ public synchronized int status()
+ {
+ return getStatus();
+ }
+
+}
diff --git a/libjava/java/awt/image/RGBImageFilter.java b/libjava/java/awt/image/RGBImageFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..f682cd8b959c30abca148ebcb014d672091bd4e0
--- /dev/null
+++ b/libjava/java/awt/image/RGBImageFilter.java
@@ -0,0 +1,244 @@
+/* RGBImageFilter.java -- Java class for filtering Pixels by RGB values
+ Copyright (C) 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package java.awt.image;
+
+/**
+ * A filter designed to filter images in the default RGBColorModel regardless of
+ * the ImageProducer's ColorModel.
+ *
+ * @author Mark Benvenuto <mcb54@columbia.edu>
+ */
+public abstract class RGBImageFilter extends ImageFilter
+{
+ protected ColorModel origmodel = ColorModel.getRGBdefault();
+
+ protected ColorModel newmodel;
+
+ /**
+ Specifies whether to apply the filter to the index entries of the
+ IndexColorModel. Subclasses should set this to true if the filter
+ does not depend on the pixel's coordinate.
+ */
+ protected boolean canFilterIndexColorModel = false;
+
+ /**
+ Construct new RGBImageFilter.
+ */
+ public RGBImageFilter()
+ {
+ }
+
+ /**
+ * Sets the ColorModel used to filter with. If the specified ColorModel is IndexColorModel
+ * and canFilterIndexColorModel is true, we subsitute the ColorModel for a filtered one
+ * here and in setPixels whenever the original one appears. Otherwise overrides the default
+ * ColorModel of ImageProducer and specifies the default RGBColorModel
+ *
+ * @param model the color model to be used most often by setPixels
+ * @see ColorModel */
+ public void setColorModel(ColorModel model)
+ {
+ origmodel = model;
+ newmodel = model;
+
+ if( ( model instanceof IndexColorModel) && canFilterIndexColorModel ) {
+ newmodel = filterIndexColorModel( (IndexColorModel) model );
+ }
+ }
+
+ /**
+ Registers a new ColorModel to subsitute for the old ColorModel when
+ setPixels encounters the a pixel with the old ColorModel. The pixel
+ remains unchanged except for a new ColorModel.
+
+ @param oldcm the old ColorModel
+ @param newcm the new ColorModel
+ */
+ public void substituteColorModel(ColorModel oldcm,
+ ColorModel newcm)
+ {
+ origmodel = oldcm;
+ newmodel = newcm;
+ }
+
+ /**
+ Filters an IndexColorModel through the filterRGB function. Uses
+ coordinates of -1 to indicate its filtering an index and not a pixel.
+
+ @param icm an IndexColorModel to filter
+ */
+ public IndexColorModel filterIndexColorModel(IndexColorModel icm)
+ {
+ int len = icm.getMapSize(), rgb;
+ byte reds[] = new byte[len], greens[] = new byte[len], blues[] = new byte[len], alphas[] = new byte[len];
+
+ icm.getAlphas( alphas );
+ icm.getReds( reds );
+ icm.getGreens( greens );
+ icm.getBlues( blues );
+
+ for( int i = 0; i < len; i++ )
+ {
+ rgb = filterRGB( -1, -1, makeColor ( alphas[i], reds[i], greens[i], blues[i] ) );
+ alphas[i] = (byte)(( 0xff000000 & rgb ) >> 24);
+ reds[i] = (byte)(( 0xff0000 & rgb ) >> 16);
+ greens[i] = (byte)(( 0xff00 & rgb ) >> 8);
+ blues[i] = (byte)(0xff & rgb);
+ }
+ return new IndexColorModel( icm.getPixelSize(), len, reds, greens, blues, alphas );
+ }
+
+ private int makeColor( byte a, byte r, byte g, byte b )
+ {
+ return ( 0xff000000 & (a << 24) | 0xff0000 & (r << 16) | 0xff00 & (b << 8) | 0xff & g );
+ }
+
+ /**
+ This functions filters a set of RGB pixels through filterRGB.
+
+ @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 filterRGBPixels(int x,
+ int y,
+ int w,
+ int h,
+ int[] pixels,
+ int off,
+ int scansize)
+ {
+ int xp, yp, i;
+
+ for( xp = x; xp < ( x + w); xp++ )
+ for( yp = y; yp < (y + h); yp++ )
+ pixels[ off + yp * scansize + xp ] = filterRGB( xp, yp, pixels[ off + yp * scansize + xp ] );
+ }
+
+
+ /**
+ * If the ColorModel is the same ColorModel which as already converted
+ * then it converts it the converted ColorModel. Otherwise it passes the
+ * array of pixels through filterRGBpixels.
+ *
+ * @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( model == origmodel ) {
+ consumer.setPixels(x, y, w, h, newmodel, pixels, offset, scansize);
+ } else {
+ //FIXME
+ //convert to proper CM
+ int pixelsi[] = new int[ pixels.length / 4 ];
+ filterRGBPixels( x, y, w, h, pixelsi, 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( model == origmodel ) {
+ consumer.setPixels(x, y, w, h, newmodel, pixels, offset, scansize);
+ } else {
+ convertColorModelToDefault( x, y, w, h, model, pixels, offset, scansize );
+ filterRGBPixels( x, y, w, h, pixels, offset, scansize );
+ }
+ }
+
+ private void convertColorModelToDefault( int x, int y, int w, int h,
+ ColorModel model, int pixels[], int offset, int scansize)
+ {
+ int xp, yp, i;
+
+ for( xp = x; xp < ( x + w); xp++ )
+ for( yp = y; yp < (y + h); yp++ )
+ pixels[ offset + yp * scansize + xp ] = makeColorbyDefaultCM( pixels[ offset + yp * scansize + xp ] );
+
+ }
+ private int makeColorbyDefaultCM( int rgb )
+ {
+ return makeColor( origmodel.getRed( rgb ), origmodel.getGreen( rgb ), origmodel.getGreen( rgb ), origmodel.getBlue( rgb ) );
+ }
+
+
+ private int makeColor( int a, int r, int g, int b )
+ {
+ return (int)( 0xff000000 & (a << 24) | 0xff0000 & (r << 16) | 0xff00 & (b << 8) | 0xff & g );
+ }
+
+
+ /**
+ Filters a single pixel from the default ColorModel.
+
+ @param x x-coordinate
+ @param y y-coordinate
+ @param rgb color
+ */
+ public abstract int filterRGB(int x,
+ int y,
+ int rgb);
+}
diff --git a/libjava/java/awt/image/ReplicateScaleFilter.java b/libjava/java/awt/image/ReplicateScaleFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..97992e8f2a21ae1c95b8a83e4221a0ce1ce79b5d
--- /dev/null
+++ b/libjava/java/awt/image/ReplicateScaleFilter.java
@@ -0,0 +1,163 @@
+/* ReplicateScaleFilter.java -- Java class for filtering images
+ Copyright (C) 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package java.awt.image;
+
+import java.util.Hashtable;
+
+/**
+ * This filter should be used for fast scaling of images where the result
+ * does not need to ensure straight lines are still straight, etc. The
+ * 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)
+ */
+public class ReplicateScaleFilter extends ImageFilter
+{
+ public ReplicateScaleFilter(int width, int height) {
+ destHeight = height;
+ destWidth = width;
+ }
+
+ /**
+ * The height of the destination image.
+ */
+ protected int destHeight;
+
+ /**
+ * The width of the destination image.
+ */
+ protected int destWidth;
+
+ /**
+ * The height of the source image.
+ */
+ protected int srcHeight;
+
+ /**
+ * The width of the source image.
+ */
+ protected int srcWidth;
+
+ /**
+ *
+ */
+ protected int srcrows[];
+
+ /**
+ *
+ */
+ protected int srccols[];
+
+ /**
+ *
+ */
+ protected Object outpixbuf;
+
+ /**
+ * An <code>ImageProducer</code> indicates the size of the image
+ * being produced using this method. A filter can override this
+ * method to intercept these calls from the producer in order to
+ * change either the width or the height before in turn calling
+ * the consumer's <code>setDimensions</code> method.
+ *
+ * @param width the width of the image
+ * @param height the height of the image
+ */
+ public void setDimensions(int width, int height)
+ {
+ consumer.setDimensions(width, height);
+ }
+
+ /**
+ * An <code>ImageProducer</code> can set a list of properties
+ * associated with this image by using this method.
+ *
+ * @param props the list of properties associated with this image
+ */
+ public void setProperties(Hashtable props)
+ {
+ props.put("filters", "ReplicateScaleFilter");
+ consumer.setProperties(props);
+ }
+
+ /**
+ * 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)
+ {
+ 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)
+ {
+ consumer.setPixels(x, y, w, h, model, pixels, offset, scansize);
+ }
+
+}
+