[kaffe] CVS kaffe (robilad): Resynced with GNU Classpath: awt fixes

Kaffe CVS cvs-commits at kaffe.org
Fri Jun 10 17:09:10 PDT 2005


PatchSet 6620 
Date: 2005/06/11 00:04:23
Author: robilad
Branch: HEAD
Tag: (none) 
Log:
Resynced with GNU Classpath: awt fixes

Members: 
	ChangeLog:1.4146->1.4147 
	libraries/javalib/Makefile.am:1.360->1.361 
	libraries/javalib/Makefile.in:1.450->1.451 
	libraries/javalib/all.files:1.133->1.134 
	libraries/javalib/gnu/java/awt/GradientPaintContext.java:INITIAL->1.1 
	libraries/javalib/java/awt/GradientPaint.java:1.1->1.2 
	libraries/javalib/java/awt/image/IndexColorModel.java:INITIAL->1.9 

Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.4146 kaffe/ChangeLog:1.4147
--- kaffe/ChangeLog:1.4146	Fri Jun 10 23:24:33 2005
+++ kaffe/ChangeLog	Sat Jun 11 00:04:23 2005
@@ -2,6 +2,16 @@
 
 	Resynced with GNU Classpath.
 	
+	2005-06-01  David Gilbert  <david.gilbert at object-refinery.com>
+
+	* gnu/java/awt/GradientPaintContext.java: New file.
+	* java/awt/GradientPaint.java: Implemented.
+	* java/awt/image/IndexColorModel.java: Reimplemented.
+
+2005-06-10  Dalibor Topic  <robilad at kaffe.org>
+
+	Resynced with GNU Classpath.
+	
 	2005-06-10  Audrius Meskauskas <AudriusA at Bioinformatics.org>
 
 	* org/omg/CORBA/SendingContext/package.html,
Index: kaffe/libraries/javalib/Makefile.am
diff -u kaffe/libraries/javalib/Makefile.am:1.360 kaffe/libraries/javalib/Makefile.am:1.361
--- kaffe/libraries/javalib/Makefile.am:1.360	Fri Jun 10 23:24:37 2005
+++ kaffe/libraries/javalib/Makefile.am	Sat Jun 11 00:04:25 2005
@@ -1103,7 +1103,8 @@
 	gnu/java/awt/ComponentDataBlitOp.java \
 	gnu/java/awt/EmbeddedWindow.java \
 	gnu/java/awt/EmbeddedWindowSupport.java \
-	gnu/java/awt/EventModifier.java
+	gnu/java/awt/EventModifier.java \
+	gnu/java/awt/GradientPaintContext.java
 gnu_java_awt_color_SRCS = \
 	gnu/java/awt/color/CieXyzConverter.java \
 	gnu/java/awt/color/ClutProfileConverter.java \
Index: kaffe/libraries/javalib/Makefile.in
diff -u kaffe/libraries/javalib/Makefile.in:1.450 kaffe/libraries/javalib/Makefile.in:1.451
--- kaffe/libraries/javalib/Makefile.in:1.450	Fri Jun 10 23:24:38 2005
+++ kaffe/libraries/javalib/Makefile.in	Sat Jun 11 00:04:28 2005
@@ -1529,7 +1529,8 @@
 	gnu/java/awt/ComponentDataBlitOp.java \
 	gnu/java/awt/EmbeddedWindow.java \
 	gnu/java/awt/EmbeddedWindowSupport.java \
-	gnu/java/awt/EventModifier.java
+	gnu/java/awt/EventModifier.java \
+	gnu/java/awt/GradientPaintContext.java
 
 gnu_java_awt_color_SRCS = \
 	gnu/java/awt/color/CieXyzConverter.java \
Index: kaffe/libraries/javalib/all.files
diff -u kaffe/libraries/javalib/all.files:1.133 kaffe/libraries/javalib/all.files:1.134
--- kaffe/libraries/javalib/all.files:1.133	Fri Jun 10 23:24:39 2005
+++ kaffe/libraries/javalib/all.files	Sat Jun 11 00:04:29 2005
@@ -689,6 +689,7 @@
 gnu/java/awt/EmbeddedWindow.java
 gnu/java/awt/EmbeddedWindowSupport.java
 gnu/java/awt/EventModifier.java
+gnu/java/awt/GradientPaintContext.java
 gnu/java/awt/image/ImageDecoder.java
 gnu/java/awt/image/XBMDecoder.java
 gnu/java/awt/peer/ClasspathFontPeer.java
===================================================================
Checking out kaffe/libraries/javalib/gnu/java/awt/GradientPaintContext.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/gnu/java/awt/GradientPaintContext.java,v
VERS: 1.1
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/libraries/javalib/gnu/java/awt/GradientPaintContext.java	Sat Jun 11 00:09:09 2005
@@ -0,0 +1,164 @@
+/* GradientPaintContext.java -- 
+   Copyright (C) 2005, 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 gnu.java.awt;
+
+import java.awt.geom.Point2D;
+import java.awt.image.ColorModel;
+import java.awt.image.Raster;
+import java.awt.image.WritableRaster;
+import java.awt.PaintContext;
+import java.awt.Color;
+
+/**
+ * A {@link PaintContext} used by the {@link GradientPaint} class.
+ */
+public class GradientPaintContext implements PaintContext 
+{
+
+  // This implementation follows the technique described in 
+  // "Java(tm) 2D Graphics" by Jonathan Knudsen (O'Reilly 1999).
+    
+  /** The x-coordinate of the anchor point for color 1. */
+  private final float x1;
+    
+  /** The y-coordinate of the anchor point for color 1. */
+  private final float y1;
+    
+  /** Color 1. */
+  private final Color c1;
+    
+  /** The x-coordinate of the anchor point for color 2. */
+  private final float x2;
+    
+  /** The y-coordinate of the anchor point for color 2. */
+  private final float y2;
+    
+  /** Color 2. */
+  private final Color c2;
+    
+  /** A flag indicating whether the gradient is cyclic or acyclic. */
+  private final boolean cyclic;
+    
+  /** The length of the gradient line - computed from the two anchor points. */
+  private final double length; 
+
+  /**
+   * Creates a new instance.
+   * 
+   * @param x1  the x-coordinate for the anchor point for color 1.
+   * @param y1  the y-coordinate for the anchor point for color 1.
+   * @param c1  color 1.
+   * @param x2  the x-coordinate for the anchor point for color 2.
+   * @param y2  the y-coordinate for the anchor point for color 2.
+   * @param c2  color 2.
+   * @param cyclic  a flag that determines whether the gradient is cyclic
+   *                or acyclic.
+   */
+  public GradientPaintContext(float x1, float y1, Color c1, 
+                              float x2, float y2, Color c2, boolean cyclic) 
+  {     
+    this.x1 = x1;
+    this.y1 = y1;
+    this.c1 = c1;
+    this.x2 = x2;
+    this.y2 = y2;
+    this.c2 = c2;
+    this.cyclic = cyclic;
+    length = Point2D.distance(x1, y1, x2, y2);
+  }
+    
+  /**
+   * Return the color model of this context. It may be different from the
+   * hint specified during createContext, as not all contexts can generate
+   * color patterns in an arbitrary model.
+   *
+   * @return the context color model
+   */
+  public ColorModel getColorModel() 
+  {
+    return ColorModel.getRGBdefault();   
+  }
+
+  /**
+   * Return a raster containing the colors for the graphics operation.
+   *
+   * @param x the x-coordinate, in device space
+   * @param y the y-coordinate, in device space
+   * @param w the width, in device space
+   * @param h the height, in device space
+   * @return a raster for the given area and color
+   */
+  public Raster getRaster(int x, int y, int w, int h) {
+    ColorModel cm = getColorModel();
+    WritableRaster raster = cm.createCompatibleWritableRaster(w, h);
+    int[] data = new int[w * h * 4];
+    double pd2 = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
+    for (int r = 0; r < h; r++) {
+      for (int c = 0; c < w; c++) {
+        double u = 0.0;
+        if (pd2 != 0) 
+          u = (((x + c) - x1) * (x2 - x1) + ((y + r) - y1) * (y2 - y1)) 
+                  / Math.sqrt(pd2);
+        double ratio = u / length;
+        if (cyclic)
+          ratio = Math.abs(ratio - Math.floor((ratio + 1.0) / 2.0) * 2.0);
+        else 
+          ratio = Math.max(0.0, Math.min(1.0, ratio));
+        int base = (r * w + c) * 4;
+        data[base] = (int) (c1.getRed() + ratio * (c2.getRed() - c1.getRed()));
+        data[base + 1] 
+          = (int) (c1.getGreen() + ratio * (c2.getGreen() - c1.getGreen()));
+        data[base + 2] 
+          = (int) (c1.getBlue() + ratio * (c2.getBlue() - c1.getBlue()));
+        data[base + 3] 
+          = (int) (c1.getAlpha() + ratio * (c2.getAlpha() - c1.getAlpha()));
+      }
+    }
+    raster.setPixels(0, 0, w, h, data);
+    return raster;
+  }
+
+  /**
+   * Release the resources allocated for the paint (none in this 
+   * implementation).
+   */
+  public void dispose() {
+    // nothing to do    
+  }
+    
+}
Index: kaffe/libraries/javalib/java/awt/GradientPaint.java
diff -u kaffe/libraries/javalib/java/awt/GradientPaint.java:1.1 kaffe/libraries/javalib/java/awt/GradientPaint.java:1.2
--- kaffe/libraries/javalib/java/awt/GradientPaint.java:1.1	Mon Nov 11 23:15:08 2002
+++ kaffe/libraries/javalib/java/awt/GradientPaint.java	Sat Jun 11 00:04:30 2005
@@ -1,5 +1,5 @@
 /* GradientPaint.java -- 
-   Copyright (C) 2002 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2005, Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -42,9 +42,11 @@
 import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import java.awt.image.ColorModel;
+import gnu.java.awt.GradientPaintContext;
 
 /**
- * STUB CLASS ONLY
+ * A paint object that can be used to color a region by blending two colors. 
+ * Instances of this class are immutable.
  */
 public class GradientPaint implements Paint
 {
@@ -56,18 +58,48 @@
   private final Color c2;
   private final boolean cyclic;
 
+  /**
+   * Creates a new acyclic <code>GradientPaint</code>.
+   * 
+   * @param x1  the x-coordinate of the anchor point for color 1.
+   * @param y1  the y-coordinate of the anchor point for color 1.
+   * @param c1  color 1 (<code>null</code> not permitted).
+   * @param x2  the x-coordinate of the anchor point for color 2.
+   * @param y2  the y-coordinate of the anchor point for color 2.
+   * @param c2  the second color (<code>null</code> not permitted).
+   */
   public GradientPaint(float x1, float y1, Color c1,
                        float x2, float y2, Color c2)
   {
     this(x1, y1, c1, x2, y2, c2, false);
   }
 
+  /**
+   * Creates a new acyclic <code>GradientPaint</code>.
+   * 
+   * @param p1  anchor point 1 (<code>null</code> not permitted).
+   * @param c1  color 1 (<code>null</code> not permitted).
+   * @param p2  anchor point 2 (<code>null</code> not permitted).
+   * @param c2  color 2 (<code>null</code> not permitted).
+   */
   public GradientPaint(Point2D p1, Color c1, Point2D p2, Color c2)
   {
     this((float) p1.getX(), (float) p1.getY(), c1,
          (float) p2.getX(), (float) p2.getY(), c2, false);
   }
 
+  /**
+   * Creates a new cyclic or acyclic <code>GradientPaint</code>.
+   * 
+   * @param x1  the x-coordinate of the anchor point for color 1.
+   * @param y1  the y-coordinate of the anchor point for color 1.
+   * @param c1  color 1 (<code>null</code> not permitted).
+   * @param x2  the x-coordinate of the anchor point for color 2.
+   * @param y2  the y-coordinate of the anchor point for color 2.
+   * @param c2  the second color (<code>null</code> not permitted).
+   * @param cyclic  a flag that controls whether the gradient is cyclic or
+   *                acyclic.
+   */
   public GradientPaint(float x1, float y1, Color c1,
                        float x2, float y2, Color c2, boolean cyclic)
   {
@@ -82,6 +114,16 @@
     this.cyclic = cyclic;
   }
 
+  /**
+   * Creates a new cyclic or acyclic <code>GradientPaint</code>.
+   * 
+   * @param p1  anchor point 1 (<code>null</code> not permitted).
+   * @param c1  color 1 (<code>null</code> not permitted).
+   * @param p2  anchor point 2 (<code>null</code> not permitted).
+   * @param c2  color 2 (<code>null</code> not permitted).
+   * @param cyclic  a flag that controls whether the gradient is cyclic or
+   *                acyclic.
+   */
   public GradientPaint(Point2D p1, Color c1, Point2D p2, Color c2,
                        boolean cyclic)
   {
@@ -89,41 +131,99 @@
          (float) p2.getX(), (float) p2.getY(), c2, cyclic);
   }
 
+  /**
+   * Returns a point with the same coordinates as the anchor point for color 1.
+   * Note that if you modify this point, the <code>GradientPaint</code> remains
+   * unchanged.
+   * 
+   * @return A point with the same coordinates as the anchor point for color 1.
+   */
   public Point2D getPoint1()
   {
     return new Point2D.Float(x1, y1);
   }
 
+  /**
+   * Returns the first color.
+   * 
+   * @return The color (never <code>null</code>).
+   */
   public Color getColor1()
   {
     return c1;
   }
 
+  /**
+   * Returns a point with the same coordinates as the anchor point for color 2.
+   * Note that if you modify this point, the <code>GradientPaint</code> remains
+   * unchanged.
+   * 
+   * @return A point with the same coordinates as the anchor point for color 2.
+   */
   public Point2D getPoint2()
   {
     return new Point2D.Float(x2, y2);
   }
 
+  /**
+   * Returns the second color.
+   * 
+   * @return The color (never <code>null</code>).
+   */
   public Color getColor2()
   {
     return c2;
   }
 
+  /**
+   * Returns <code>true</code> if this <code>GradientPaint</code> instance is
+   * cyclic, and <code>false</code> otherwise.
+   * 
+   * @return A boolean.
+   */
   public boolean isCyclic()
   {
     return cyclic;
   }
 
+  /**
+   * Returns the {@link PaintContext} used to generate the color pattern.
+   * 
+   * @param cm  the color model, used as a hint (ignored in this 
+   *            implementation).
+   * @param deviceBounds  the device space bounding box of the painted area.
+   * @param userBounds  the user space bounding box of the painted area.
+   * @param xform  the transformation from user space to device space.
+   * @param hints  any hints for choosing between rendering alternatives.
+   * 
+   * @return The context for performing the paint
+   */
   public PaintContext createContext(ColorModel cm, Rectangle deviceBounds,
                                     Rectangle2D userBounds,
                                     AffineTransform xform,
                                     RenderingHints hints)
   {
-    throw new Error("not implemented");
+    Point2D xp1 = xform.transform(getPoint1(), null);
+    Point2D xp2 = xform.transform(getPoint2(), null);
+    return new GradientPaintContext((float) xp1.getX(), (float) xp1.getY(), c1, 
+            (float) xp2.getX(), (float) xp2.getY(), c2, cyclic);
   }
 
+  /**
+   * Returns the transparency code for this <code>GradientPaint</code> instance.
+   * This is derived from the two {@link Color} objects used in creating this
+   * object:  if both colors are opaque, this method returns 
+   * {@link Transparency#OPAQUE}, otherwise it returns 
+   * {@link Transparency#TRANSLUCENT}.
+   * 
+   * @return {@link Transparency#OPAQUE} or {@link Transparency#TRANSLUCENT}.
+   */
   public int getTransparency()
   {
-    throw new Error("not implemented");
+    if (c1.getAlpha() == 255 && c2.getAlpha() == 255)
+      return Transparency.OPAQUE;
+    else
+      return Transparency.TRANSLUCENT;   
   }
+  
 } // class GradientPaint
===================================================================
Checking out kaffe/libraries/javalib/java/awt/image/IndexColorModel.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/java/awt/image/IndexColorModel.java,v
VERS: 1.9
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/libraries/javalib/java/awt/image/IndexColorModel.java	Sat Jun 11 00:09:09 2005
@@ -0,0 +1,697 @@
+/* IndexColorModel.java -- Java class for interpreting Pixel objects
+   Copyright (C) 1999, 2005 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 gnu.java.awt.Buffers;
+
+import java.awt.color.ColorSpace;
+import java.math.BigInteger;
+
+/**
+ * Color model similar to pseudo visual in X11.
+ * <br><br>
+ * This color model maps linear pixel values to actual RGB and alpha colors.
+ * Thus, pixel values are indexes into the color map.  Each color component is
+ * an 8-bit unsigned value.
+ * <br><br>
+ * The <code>IndexColorModel</code> supports a map of valid pixels, allowing 
+ * the representation of holes in the the color map.  The valid map is 
+ * represented as a {@link BigInteger} where each bit indicates the validity 
+ * of the map entry with the same index.
+ * <br><br>
+ * Colors can have alpha components for transparency support.  If alpha
+ * component values aren't given, color values are opaque.  The model also
+ * supports a reserved pixel value to represent completely transparent colors,
+ * no matter what the actual color component values are.
+ * <br><br>
+ * <code>IndexColorModel</code> supports anywhere from 1 to 16 bit index 
+ * values.  The allowed transfer types are {@link DataBuffer#TYPE_BYTE} and 
+ * {@link DataBuffer#TYPE_USHORT}.
+ *
+ * @author C. Brian Jones (cbj at gnu.org) 
+ */
+public class IndexColorModel extends ColorModel
+{
+  private int map_size;
+  private boolean opaque;  // no alpha, but doesn't account for trans
+  private int trans = -1;
+  private int[] rgb;
+  private BigInteger validBits = BigInteger.ZERO;
+
+  /**
+   * Creates a new indexed color model for <code>size</code> color elements 
+   * with no alpha component.  Each array must contain at least 
+   * <code>size</code> elements.  For each array, the i-th color is described 
+   * by reds[i], greens[i] and blues[i]. 
+   *
+   * @param bits the number of bits needed to represent <code>size</code> 
+   *             colors.
+   * @param size the number of colors in the color map.
+   * @param reds the red component of all colors.
+   * @param greens the green component of all colors.
+   * @param blues the blue component of all colors.
+   *
+   * @throws IllegalArgumentException if <code>bits</code> &lt; 1 or 
+   *         <code>bits</code> &gt; 16.
+   * @throws NullPointerException if any of the arrays is <code>null</code>.
+   * @throws ArrayIndexOutOfBoundsException if <code>size</code> is greater 
+   *         than the length of the component arrays.
+   */
+  public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
+                         byte[] blues)
+  {
+    this(bits, size, reds, greens, blues, (byte[]) null);
+  }
+
+  /**
+   * Creates a new indexed color model for <code>size</code> color elements.
+   * Each array must contain at least <code>size</code> elements.  For each 
+   * array, the i-th color is described by reds[i], greens[i] and blues[i]. 
+   * All the colors are opaque except for the transparent color. 
+   *
+   * @param bits the number of bits needed to represent <code>size</code> 
+   *             colors
+   * @param size the number of colors in the color map
+   * @param reds the red component of all colors
+   * @param greens the green component of all colors
+   * @param blues the blue component of all colors
+   * @param trans the index of the transparent color (use -1 for no 
+   *              transparent color).
+   * 
+   * @throws IllegalArgumentException if <code>bits</code> &lt; 1 or 
+   *         <code>bits</code> &gt; 16.
+   * @throws NullPointerException if any of the arrays is <code>null</code>.
+   * @throws ArrayIndexOutOfBoundsException if <code>size</code> is greater 
+   *         than the length of the component arrays.
+   */
+  public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
+                         byte[] blues, int trans)
+  {
+    super(bits, nArray(8, (0 <= trans && trans < size) ? 4 : 3), 
+        ColorSpace.getInstance(ColorSpace.CS_sRGB), 
+        (0 <= trans && trans < size),  // hasAlpha 
+        false, OPAQUE, 
+        Buffers.smallestAppropriateTransferType(bits)); 
+    if (bits < 1) 
+      throw new IllegalArgumentException("bits < 1");
+    if (bits > 16)
+      throw new IllegalArgumentException("bits > 16");
+    if (size < 1)
+      throw new IllegalArgumentException("size < 1");
+    map_size = size;
+    if (0 <= trans && trans < size) {
+      this.trans = trans;
+      transparency = BITMASK;
+    }
+    rgb = new int[size];
+    for (int i = 0; i < size; i++)
+      {
+        rgb[i] = (0xff000000
+                  | ((reds[i] & 0xff) << 16)
+                  | ((greens[i] & 0xff) << 8)
+                  | (blues[i] & 0xff));
+      }
+    // Generate a bigint with 1's for every pixel
+    validBits = validBits.setBit(size).subtract(BigInteger.ONE);
+  }
+
+  /**
+   * Creates a new indexed color model for <code>size</code> color elements 
+   * including alpha.  Each array must contain at least <code>size</code> 
+   * elements.  For each array, the i-th color is described 
+   * by reds[i], greens[i], blues[i] and alphas[i]. 
+   *
+   * @param bits the number of bits needed to represent <code>size</code> 
+   *             colors.
+   * @param size the number of colors in the color map.
+   * @param reds the red component of all colors.
+   * @param greens the green component of all colors.
+   * @param blues the blue component of all colors.
+   * @param alphas the alpha component of all colors (<code>null</code> 
+   *               permitted).
+   *
+   * @throws IllegalArgumentException if <code>bits</code> &lt; 1 or 
+   *           <code>bits</code> &gt; 16.
+   * @throws NullPointerException if <code>reds</code>, <code>greens</code> or
+   *         <code>blues</code> is <code>null</code>.
+   * @throws ArrayIndexOutOfBoundsException if <code>size</code> is greater 
+   *         than the length of the component arrays.
+   */
+  public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
+                         byte[] blues, byte[] alphas)
+  {
+    super(bits, nArray(8, (alphas == null ? 3 : 4)), 
+        ColorSpace.getInstance(ColorSpace.CS_sRGB), 
+        (alphas != null), false, TRANSLUCENT, 
+        Buffers.smallestAppropriateTransferType(bits)); 
+    if (bits < 1) 
+      throw new IllegalArgumentException("bits < 1");
+    if (bits > 16)
+      throw new IllegalArgumentException("bits > 16");
+    if (size < 1)
+      throw new IllegalArgumentException("size < 1");
+    map_size = size;
+    opaque = (alphas == null);
+
+    rgb = new int[size];
+    if (alphas == null)
+      {
+        for (int i = 0; i < size; i++)
+          {
+            rgb[i] = (0xff000000
+                      | ((reds[i] & 0xff) << 16)
+                      | ((greens[i] & 0xff) << 8)
+                      | (blues[i] & 0xff));
+          }
+        transparency = OPAQUE;
+      }
+    else
+      {
+	byte alphaZero = (byte) 0x00;
+        byte alphaOne = (byte) 0xFF;
+        for (int i = 0; i < size; i++)
+          {
+	    alphaZero = (byte) (alphaZero | alphas[i]);
+            alphaOne = (byte) (alphaOne & alphas[i]);
+            rgb[i] = ((alphas[i] & 0xff) << 24
+                      | ((reds[i] & 0xff) << 16)
+                      | ((greens[i] & 0xff) << 8)
+                      | (blues[i] & 0xff));
+          }
+        if ((alphaZero == (byte) 0x00) || (alphaOne == (byte) 0xFF))
+	  transparency = BITMASK;
+	else
+	  transparency = TRANSLUCENT;
+      }
+
+    // Generate a bigint with 1's for every pixel
+    validBits = validBits.setBit(size).subtract(BigInteger.ONE);
+  }
+
+  /**
+   * Creates a new indexed color model using the color components in 
+   * <code>cmap</code>. If <code>hasAlpha</code> is <code>true</code> then
+   * <code>cmap</code> contains an alpha component after each of the red, green
+   * and blue components.
+   *
+   * @param bits the number of bits needed to represent <code>size</code> 
+   *             colors
+   * @param size the number of colors in the color map
+   * @param cmap packed color components
+   * @param start the offset of the first color component in <code>cmap</code>
+   * @param hasAlpha <code>cmap</code> has alpha values
+   * @throws IllegalArgumentException if bits &lt; 1, bits &gt; 16, or size 
+   *         &lt; 1.
+   * @throws NullPointerException if <code>cmap</code> is <code>null</code>.
+   */
+  public IndexColorModel(int bits, int size, byte[] cmap, int start, 
+                         boolean hasAlpha)
+  {
+    this(bits, size, cmap, start, hasAlpha, -1);
+  }
+
+  /**
+   * Construct an IndexColorModel from an array of red, green, blue, and
+   * optional alpha components. The component values are interleaved as RGB(A).
+   * 
+   * @param bits the number of bits needed to represent <code>size</code> 
+   *             colors
+   * @param size the number of colors in the color map
+   * @param cmap interleaved color components
+   * @param start the offset of the first color component in <code>cmap</code>
+   * @param hasAlpha <code>cmap</code> has alpha values
+   * @param trans the index of the transparent color
+   * @throws IllegalArgumentException if bits &lt; 1, bits &gt; 16, or size
+   *         &lt; 1.
+   * @throws NullPointerException if <code>cmap</code> is <code>null</code>.
+   */
+  public IndexColorModel(int bits, int size, byte[] cmap, int start, 
+                         boolean hasAlpha, int trans)
+  {
+    super(bits, nArray(8, hasAlpha || (0 <= trans && trans < size) ? 4 : 3), 
+        ColorSpace.getInstance(ColorSpace.CS_sRGB),
+        hasAlpha || (0 <= trans && trans < size), false, OPAQUE, 
+        Buffers.smallestAppropriateTransferType(bits));
+    if (bits < 1)
+      throw new IllegalArgumentException("bits < 1");
+    if (bits > 16)
+      throw new IllegalArgumentException("bits > 16");
+    if (size < 1)
+      throw new IllegalArgumentException("size < 1");
+    map_size = size;
+    opaque = !hasAlpha;
+    if (0 <= trans && trans < size)
+      this.trans = trans;
+
+    rgb = new int[size];
+    if (hasAlpha)
+    {
+      int alpha;
+      int alphaZero = 0x00;  // use to detect all zeros
+      int alphaOne = 0xff;   // use to detect all ones
+      for (int i = 0; i < size; i++) {
+	alpha = cmap[4 * i + 3 + start] & 0xff;  
+        alphaZero = alphaZero | alpha;
+        alphaOne = alphaOne & alpha;
+        rgb[i] =
+	  ( alpha << 24
+	   // red
+	   | ((cmap[4 * i + start] & 0xff) << 16)
+	   // green
+	   | ((cmap[4 * i + 1 + start] & 0xff) << 8)
+	   // blue
+	   | (cmap[4 * i + 2 + start] & 0xff));
+      }
+      if (alphaZero == 0) 
+	transparency = BITMASK;
+      else if (alphaOne == 255) 
+        transparency = (trans != -1 ? BITMASK : OPAQUE);
+      else
+	transparency = TRANSLUCENT;
+    }
+    else
+    {
+      for (int i = 0; i < size; i++)
+	rgb[i] = (0xff000000
+		  // red
+		  | ((cmap[3 * i + start] & 0xff) << 16)
+		  // green
+		  | ((cmap[3 * i + 1 + start] & 0xff) << 8)
+		  // blue
+		  | (cmap[3 * i + 2 + start] & 0xff));
+      if (trans != -1)
+	transparency = BITMASK;
+    }
+
+    // Generate a bigint with 1's for every pixel
+    validBits = validBits.setBit(size).subtract(BigInteger.ONE);
+  }
+
+  /**
+   * Construct an IndexColorModel from an array of <code>size</code> packed
+   * colors.  Each int element contains 8-bit red, green, blue, and optional
+   * alpha values packed in order.  If hasAlpha is false, then all the colors
+   * are opaque except for the transparent color.
+   *
+   * @param bits the number of bits needed to represent <code>size</code> 
+   *             colors
+   * @param size the number of colors in the color map
+   * @param cmap packed color components
+   * @param start the offset of the first color component in <code>cmap</code>
+   * @param hasAlpha <code>cmap</code> has alpha values
+   * @param trans the index of the transparent color
+   * @param transferType {@link DataBuffer#TYPE_BYTE} or 
+            {@link DataBuffer#TYPE_USHORT}.
+   * @throws IllegalArgumentException if bits &lt; 1, bits &gt; 16, or size
+   *         &lt; 1.
+   * @throws IllegalArgumentException if <code>transferType</code> is something
+   *         other than {@link DataBuffer#TYPE_BYTE} or 
+   *         {@link DataBuffer#TYPE_USHORT}.
+   */
+  public IndexColorModel(int bits, int size, int[] cmap, int start, 
+                         boolean hasAlpha, int trans, int transferType)
+  {
+    super(bits, 
+	  nArray(8, 4), // bits for each channel
+	  ColorSpace.getInstance(ColorSpace.CS_sRGB), // sRGB
+	  true, // has alpha
+	  false, // not premultiplied
+	  TRANSLUCENT, transferType);
+    if (transferType != DataBuffer.TYPE_BYTE
+        && transferType != DataBuffer.TYPE_USHORT)
+      throw new IllegalArgumentException();
+    if (bits > 16)
+      throw new IllegalArgumentException("bits > 16");
+    if (size < 1)
+      throw new IllegalArgumentException("size < 1");
+    map_size = size;
+    opaque = !hasAlpha;
+    if (0 <= trans && trans < size)
+      this.trans = trans;
+
+    rgb = new int[size];
+    if (!hasAlpha)
+      for (int i = 0; i < size; i++)
+	rgb[i] = cmap[i + start] | 0xff000000;
+    else
+      System.arraycopy(cmap, start, rgb, 0, size);
+
+    // Generate a bigint with 1's for every pixel
+    validBits = validBits.setBit(size).subtract(BigInteger.ONE);
+  }
+
+  /**
+   * Construct an IndexColorModel using a colormap with holes.
+   * <br><br>
+   * The IndexColorModel is built from the array of ints defining the
+   * colormap.  Each element contains red, green, blue, and alpha
+   * components.    The ColorSpace is sRGB.  The transparency value is
+   * automatically determined.
+   * <br><br>
+   * This constructor permits indicating which colormap entries are valid,
+   * using the validBits argument.  Each entry in cmap is valid if the
+   * corresponding bit in validBits is set.  
+   * 
+   * @param bits the number of bits needed to represent <code>size</code> 
+   *             colors.
+   * @param size the number of colors in the color map.
+   * @param cmap packed color components.
+   * @param start the offset of the first color component in <code>cmap</code>.
+   * @param transferType {@link DataBuffer#TYPE_BYTE} or 
+   *                     {@link DataBuffer#TYPE_USHORT}.
+   * @param validBits a map of the valid entries in <code>cmap</code>.
+   * @throws IllegalArgumentException if bits &lt; 1, bits &gt; 16, or size
+   *         &lt; 1.
+   * @throws IllegalArgumentException if transferType is something other than
+   *         {@link DataBuffer#TYPE_BYTE} or {@link DataBuffer#TYPE_USHORT}.
+   */
+  public IndexColorModel(int bits, int size, int[] cmap, int start, 
+                         int transferType, BigInteger validBits)
+  {
+    super(bits, // total bits, sRGB, four channels
+	  nArray(8, 4), // bits for each channel
+	  ColorSpace.getInstance(ColorSpace.CS_sRGB), // sRGB
+	  true, // has alpha
+	  false, // not premultiplied
+	  TRANSLUCENT, transferType);
+    if (transferType != DataBuffer.TYPE_BYTE
+        && transferType != DataBuffer.TYPE_USHORT)
+      throw new IllegalArgumentException();
+    if (bits > 16)
+      throw new IllegalArgumentException("bits > 16");
+    if (size < 1)
+      throw new IllegalArgumentException("size < 1");
+    map_size = size;
+    opaque = false;
+    this.trans = -1;
+    this.validBits = validBits;
+
+    rgb = new int[size];
+    if (!hasAlpha)
+      for (int i = 0; i < size; i++)
+	rgb[i] = cmap[i + start] | 0xff000000;
+    else
+      System.arraycopy(cmap, start, rgb, 0, size);
+  }
+
+  /**
+   * Returns the size of the color lookup table.
+   *
+   * @return The size of the color lookup table.
+   */
+  public final int getMapSize()
+  {
+    return map_size;
+  }
+
+  /**
+   * Get the index of the transparent color in this color model.
+   *
+   * @return The index of the color that is considered transparent, or -1 if 
+   *         there is no transparent color.
+   */
+  public final int getTransparentPixel()
+  {
+    return trans;
+  }
+
+  /**
+   * Fills the supplied array with the red component of each color in the 
+   * lookup table.
+   *
+   * @param r an array that is at least as large as {@link #getMapSize()}.
+   * @throws NullPointerException if <code>r</code> is <code>null</code>.
+   * @throws ArrayIndexOutOfBoundsException if <code>r</code> has less 
+   *         than {@link #getMapSize()} elements. 
+   */
+  public final void getReds(byte[] r)
+  {
+    int i;
+    for (i = 0; i < map_size; i++)
+      r[i] = (byte) ((0x00FF0000  & rgb[i]) >> 16);
+  }
+
+  /**
+   * Fills the supplied array with the green component of each color in the 
+   * lookup table.
+   *
+   * @param g an array that is at least as large as {@link #getMapSize()}.
+   * @throws NullPointerException if <code>g</code> is <code>null</code>.
+   * @throws ArrayIndexOutOfBoundsException if <code>g</code> has less 
+   *         than {@link #getMapSize()} elements. 
+   */
+  public final void getGreens(byte[] g)
+  {
+    int i;
+    for (i = 0; i < map_size; i++)
+      g[i] = (byte) ((0x0000FF00  & rgb[i]) >> 8);
+  }
+
+  /**
+   * Fills the supplied array with the blue component of each color in the 
+   * lookup table.
+   *
+   * @param b an array that is at least as large as {@link #getMapSize()}.
+   * @throws NullPointerException if <code>b</code> is <code>null</code>.
+   * @throws ArrayIndexOutOfBoundsException if <code>b</code> has less 
+   *         than {@link #getMapSize()} elements. 
+   */
+  public final void getBlues(byte[] b)
+  {
+    int i;
+    for (i = 0; i < map_size; i++)
+      b[i] = (byte) (0x000000FF & rgb[i]);
+  }
+
+  /**
+   * Fills the supplied array with the alpha component of each color in the 
+   * lookup table.  If the model has a transparent pixel specified, the alpha
+   * for that pixel will be 0.
+   *
+   * @param a an array that is at least as large as {@link #getMapSize()}.
+   * @throws NullPointerException if <code>a</code> is <code>null</code>.
+   * @throws ArrayIndexOutOfBoundsException if <code>a</code> has less 
+   *         than {@link #getMapSize()} elements. 
+   */
+  public final void getAlphas(byte[] a)
+  {
+    int i;
+    for (i = 0; i < map_size; i++)
+      if (i == trans) 
+	a[i] = (byte) 0;
+      else 
+        a[i] = (byte) ((0xFF000000  & rgb[i]) >> 24);
+  }
+
+  /**
+   * Returns the red component of the color in the lookup table for the 
+   * given pixel value.
+   *
+   * @param pixel  the pixel lookup value.
+   *
+   * @return The red component of the color in the lookup table.
+   * @throws ArrayIndexOutOfBoundsException if <code>pixel</code> is negative.
+   */
+  public final int getRed(int pixel)
+  {
+    if (pixel < map_size)
+      return (0x00FF0000 & rgb[pixel]) >> 16;
+    
+    return 0;
+  }
+
+  /**
+   * Returns the green component of the color in the lookup table for the 
+   * given pixel value.
+   *
+   * @param pixel  the pixel lookup value.
+   *
+   * @return The green component of the color in the lookup table.
+   * @throws ArrayIndexOutOfBoundsException if <code>pixel</code> is negative.
+   */
+  public final int getGreen(int pixel)
+  {
+    if (pixel < map_size)
+      return (0x0000FF00 & rgb[pixel]) >> 8;

*** Patch too long, truncated ***




More information about the kaffe mailing list