libjava/java/awt/image/IndexColorModel.java

   1 /* IndexColorModel.java -- Java class for interpreting Pixel objects
   2    Copyright (C) 1999 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.awt.image;
  40
  41 /**
  42  * @author C. Brian Jones (cbj@gnu.org)
  43  */
  44 public class IndexColorModel extends ColorModel
  45 {
  46   private int map_size;
  47   private boolean opaque;
  48   private int trans = -1;
  49   private int[] rgb;
  50
  51   /**
  52    * Each array much contain <code>size</code> elements.  For each
  53    * array, the i-th color is described by reds[i], greens[i],
  54    * blues[i], alphas[i], unless alphas is not specified, then all the
  55    * colors are opaque except for the transparent color.
  56    *
  57    * @param bits the number of bits needed to represent <code>size</code> colors
  58    * @param size the number of colors in the color map
  59    * @param reds the red component of all colors
  60    * @param greens the green component of all colors
  61    * @param blues the blue component of all colors
  62    */
  63   public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
  64                          byte[] blues)
  65   {
  66     this (bits, size, reds, greens, blues, (byte[]) null);
  67   }
  68
  69   /**
  70    * Each array much contain <code>size</code> elements.  For each
  71    * array, the i-th color is described by reds[i], greens[i],
  72    * blues[i], alphas[i], unless alphas is not specified, then all the
  73    * colors are opaque except for the transparent color.
  74    *
  75    * @param bits the number of bits needed to represent <code>size</code> colors
  76    * @param size the number of colors in the color map
  77    * @param reds the red component of all colors
  78    * @param greens the green component of all colors
  79    * @param blues the blue component of all colors
  80    * @param trans the index of the transparent color
  81    */
  82   public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
  83                          byte[] blues, int trans)
  84   {
  85     this (bits, size, reds, greens, blues, (byte[]) null);
  86     this.trans = trans;
  87   }
  88
  89   /**
  90    * Each array much contain <code>size</code> elements.  For each
  91    * array, the i-th color is described by reds[i], greens[i],
  92    * blues[i], alphas[i], unless alphas is not specified, then all the
  93    * colors are opaque except for the transparent color.
  94    *
  95    * @param bits the number of bits needed to represent <code>size</code> colors
  96    * @param size the number of colors in the color map
  97    * @param reds the red component of all colors
  98    * @param greens the green component of all colors
  99    * @param blues the blue component of all colors
 100    * @param alphas the alpha component of all colors
 101    */
 102   public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
 103                          byte[] blues, byte[] alphas)
 104   {
 105     super (bits);
 106     map_size = size;
 107     opaque = (alphas == null);
 108
 109     rgb = new int[size];
 110     if (alphas == null)
 111       {
 112         for (int i = 0; i < size; i++)
 113           {
 114             rgb[i] = (0xff000000
 115                       | ((reds[i] & 0xff) << 16)
 116                       | ((greens[i] & 0xff) << 8)
 117                       | (blues[i] & 0xff));
 118           }
 119       }
 120     else
 121       {
 122         for (int i = 0; i < size; i++)
 123           {
 124             rgb[i] = ((alphas[i] & 0xff) << 24
 125                       | ((reds[i] & 0xff) << 16)
 126                       | ((greens[i] & 0xff) << 8)
 127                       | (blues[i] & 0xff));
 128           }
 129       }
 130   }
 131
 132   /**
 133    * Each array much contain <code>size</code> elements.  For each
 134    * array, the i-th color is described by reds[i], greens[i],
 135    * blues[i], alphas[i], unless alphas is not specified, then all the
 136    * colors are opaque except for the transparent color.
 137    *
 138    * @param bits the number of bits needed to represent <code>size</code> colors
 139    * @param size the number of colors in the color map
 140    * @param cmap packed color components
 141    * @param start the offset of the first color component in <code>cmap</code>
 142    * @param hasAlpha <code>cmap</code> has alpha values
 143    */
 144   public IndexColorModel (int bits, int size, byte[] cmap, int start,
 145                           boolean hasAlpha)
 146   {
 147     this (bits, size, cmap, start, hasAlpha, -1);
 148   }
 149
 150   /**
 151    * Each array much contain <code>size</code> elements.  For each
 152    * array, the i-th color is described by reds[i], greens[i],
 153    * blues[i], alphas[i], unless alphas is not specified, then all the
 154    * colors are opaque except for the transparent color.
 155    *
 156    * @param bits the number of bits needed to represent <code>size</code> colors
 157    * @param size the number of colors in the color map
 158    * @param cmap packed color components
 159    * @param start the offset of the first color component in <code>cmap</code>
 160    * @param hasAlpha <code>cmap</code> has alpha values
 161    * @param trans the index of the transparent color
 162    */
 163   public IndexColorModel (int bits, int size, byte[] cmap, int start,
 164                           boolean hasAlpha, int trans)
 165   {
 166     super (bits);
 167     map_size = size;
 168     opaque = !hasAlpha;
 169     this.trans = trans;
 170   }
 171
 172   public final int getMapSize ()
 173   {
 174     return map_size;
 175   }
 176
 177   /**
 178    * Get the index of the transparent color in this color model
 179    */
 180   public final int getTransparentPixel ()
 181   {
 182     return trans;
 183   }
 184
 185   /**
 186    * <br>
 187    */
 188   public final void getReds (byte[] r)
 189   {
 190     getComponents (r, 2);
 191   }
 192
 193   /**
 194    * <br>
 195    */
 196   public final void getGreens (byte[] g)
 197   {
 198     getComponents (g, 1);
 199   }
 200
 201   /**
 202    * <br>
 203    */
 204   public final void getBlues (byte[] b)
 205   {
 206     getComponents (b, 0);
 207   }
 208
 209   /**
 210    * <br>
 211    */
 212   public final void getAlphas (byte[] a)
 213   {
 214     getComponents (a, 3);
 215   }
 216
 217   private void getComponents (byte[] c, int ci)
 218   {
 219     int i, max = (map_size < c.length) ? map_size : c.length;
 220     for (i = 0; i < max; i++)
 221             c[i] = (byte) ((generateMask (ci)  & rgb[i]) >> (ci * pixel_bits));
 222   }
 223
 224   /**
 225    * Get the red component of the given pixel.
 226    */
 227   public final int getRed (int pixel)
 228   {
 229     if (pixel < map_size)
 230             return (int) ((generateMask (2) & rgb[pixel]) >> (2 * pixel_bits));
 231
 232     return 0;
 233   }
 234
 235   /**
 236    * Get the green component of the given pixel.
 237    */
 238   public final int getGreen (int pixel)
 239   {
 240     if (pixel < map_size)
 241             return (int) ((generateMask (1) & rgb[pixel]) >> (1 * pixel_bits));
 242
 243     return 0;
 244   }
 245
 246   /**
 247    * Get the blue component of the given pixel.
 248    */
 249   public final int getBlue (int pixel)
 250   {
 251     if (pixel < map_size)
 252             return (int) (generateMask (0) & rgb[pixel]);
 253
 254     return 0;
 255   }
 256
 257   /**
 258    * Get the alpha component of the given pixel.
 259    */
 260   public final int getAlpha (int pixel)
 261   {
 262     if (pixel < map_size)
 263             return (int) ((generateMask (3) & rgb[pixel]) >> (3 * pixel_bits));
 264
 265     return 0;
 266   }
 267
 268   /**
 269    * Get the RGB color value of the given pixel using the default
 270    * RGB color model.
 271    *
 272    * @param pixel a pixel value
 273    */
 274   public final int getRGB (int pixel)
 275   {
 276     if (pixel < map_size)
 277             return rgb[pixel];
 278
 279     return 0;
 280   }
 281
 282   //pixel_bits is number of bits to be in generated mask
 283   private int generateMask (int offset)
 284   {
 285     return (((2 << pixel_bits ) - 1) << (pixel_bits * offset));
 286   }
 287
 288 }
 289