IndexColorModel.java: Reformated.

2003-09-29  Michael Koch  <konqueror@gmx.de>

	* java/awt/image/IndexColorModel.java: Reformated.

From-SVN: r71898

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index 15268d28a005532dc0285bdb83f3194bad03803f..100dc466509bd405192c201db9a5833067fde610 100644 (file)
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,7 @@
+2003-09-29  Michael Koch  <konqueror@gmx.de>
+
+       * java/awt/image/IndexColorModel.java: Reformated.
+
 2003-09-29  Michael Koch  <konqueror@gmx.de>
 
        * java/net/InetAddress.java,

diff --git a/libjava/java/awt/image/IndexColorModel.java b/libjava/java/awt/image/IndexColorModel.java
index 066c8682accabad28956b000e6a22d890682cbab..9ceb0bf0944e3422f455a577c25da665cae7adf6 100644 (file)
--- a/libjava/java/awt/image/IndexColorModel.java
+++ b/libjava/java/awt/image/IndexColorModel.java
@@ -43,70 +43,70 @@ package java.awt.image;
  */
 public class IndexColorModel extends ColorModel
 {
-    private int map_size;
-    private boolean opaque;
-    private int trans = -1;
-    private int[] rgb;
+  private int map_size;
+  private boolean opaque;
+  private int trans = -1;
+  private int[] rgb;
 
-    /**
-     * Each array much contain <code>size</code> elements.  For each 
-     * array, the i-th color is described by reds[i], greens[i], 
-     * blues[i], alphas[i], unless alphas is not specified, 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 reds the red component of all colors
-     * @param greens the green component of all colors
-     * @param blues the blue component of all colors
-     */
-    public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
+  /**
+   * Each array much contain <code>size</code> elements.  For each 
+   * array, the i-th color is described by reds[i], greens[i], 
+   * blues[i], alphas[i], unless alphas is not specified, 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 reds the red component of all colors
+   * @param greens the green component of all colors
+   * @param blues the blue component of all colors
+   */
+  public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
                          byte[] blues)
   {
-       this(bits, size, reds, greens, blues, (byte[])null);
-    }
+    this (bits, size, reds, greens, blues, (byte[]) null);
+  }
 
-    /**
-     * Each array much contain <code>size</code> elements.  For each 
-     * array, the i-th color is described by reds[i], greens[i], 
-     * blues[i], alphas[i], unless alphas is not specified, 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 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
-     */
-    public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
+  /**
+   * Each array much contain <code>size</code> elements.  For each 
+   * array, the i-th color is described by reds[i], greens[i], 
+   * blues[i], alphas[i], unless alphas is not specified, 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 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
+   */
+  public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
                          byte[] blues, int trans)
   {
-       this(bits, size, reds, greens, blues, (byte[])null);
-       this.trans = trans;
-    }
+    this (bits, size, reds, greens, blues, (byte[]) null);
+    this.trans = trans;
+  }
 
-    /**
-     * Each array much contain <code>size</code> elements.  For each 
-     * array, the i-th color is described by reds[i], greens[i], 
-     * blues[i], alphas[i], unless alphas is not specified, 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 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
-     */
-    public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
+  /**
+   * Each array much contain <code>size</code> elements.  For each 
+   * array, the i-th color is described by reds[i], greens[i], 
+   * blues[i], alphas[i], unless alphas is not specified, 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 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
+   */
+  public IndexColorModel(int bits, int size, byte[] reds, byte[] greens,
                          byte[] blues, byte[] alphas)
   {
-       super(bits);
-       map_size = size;
-       opaque = (alphas == null);
+    super (bits);
+    map_size = size;
+    opaque = (alphas == null);
 
-       rgb = new int[size];
+    rgb = new int[size];
     if (alphas == null)
       {
         for (int i = 0; i < size; i++)
@@ -115,8 +115,8 @@ public class IndexColorModel extends ColorModel
                       | ((reds[i] & 0xff) << 16)
                       | ((greens[i] & 0xff) << 8)
                       | (blues[i] & 0xff));
-           }
-       }
+          }
+      }
     else
       {
         for (int i = 0; i < size; i++)
@@ -125,165 +125,165 @@ public class IndexColorModel extends ColorModel
                       | ((reds[i] & 0xff) << 16)
                       | ((greens[i] & 0xff) << 8)
                       | (blues[i] & 0xff));
-           }
-       }
-    }
+          }
+      }
+  }
 
-    /**
-     * Each array much contain <code>size</code> elements.  For each 
-     * array, the i-th color is described by reds[i], greens[i], 
-     * blues[i], alphas[i], unless alphas is not specified, 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
-     */
-    public IndexColorModel(int bits, int size, byte[] cmap, int start, 
+  /**
+   * Each array much contain <code>size</code> elements.  For each 
+   * array, the i-th color is described by reds[i], greens[i], 
+   * blues[i], alphas[i], unless alphas is not specified, 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
+   */
+  public IndexColorModel (int bits, int size, byte[] cmap, int start, 
                           boolean hasAlpha)
   {
-       this(bits, size, cmap, start, hasAlpha, -1);
-    }
+    this (bits, size, cmap, start, hasAlpha, -1);
+  }
 
-    /**
-     * Each array much contain <code>size</code> elements.  For each 
-     * array, the i-th color is described by reds[i], greens[i], 
-     * blues[i], alphas[i], unless alphas is not specified, 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
-     */
-    public IndexColorModel(int bits, int size, byte[] cmap, int start, 
+  /**
+   * Each array much contain <code>size</code> elements.  For each 
+   * array, the i-th color is described by reds[i], greens[i], 
+   * blues[i], alphas[i], unless alphas is not specified, 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
+   */
+  public IndexColorModel (int bits, int size, byte[] cmap, int start, 
                           boolean hasAlpha, int trans)
   {
-       super(bits);
-       map_size = size;
-        opaque = !hasAlpha;
-       this.trans = trans;
-    }
+    super (bits);
+    map_size = size;
+    opaque = !hasAlpha;
+    this.trans = trans;
+  }
 
   public final int getMapSize ()
   {
-       return map_size;
-    }
+    return map_size;
+  }
 
-    /**
-     * Get the index of the transparent color in this color model
-     */
+  /**
+   * Get the index of the transparent color in this color model
+   */
   public final int getTransparentPixel ()
   {
-       return trans;
-    }
+    return trans;
+  }
 
-    /**
-     * <br>
-     */
+  /**
+   * <br>
+   */
   public final void getReds (byte[] r)
   {
-       getComponents( r, 2 );
-    }
+    getComponents (r, 2);
+  }
 
-    /**
-     * <br>
-     */
+  /**
+   * <br>
+   */
   public final void getGreens (byte[] g)
   {
-       getComponents( g, 1 );
-    }
+    getComponents (g, 1);
+  }
 
-    /**
-     * <br>
-     */
+  /**
+   * <br>
+   */
   public final void getBlues (byte[] b)
   {
-       getComponents( b, 0 );
-    }
+    getComponents (b, 0);
+  }
 
-    /**
-     * <br>
-     */
+  /**
+   * <br>
+   */
   public final void getAlphas (byte[] a)
   {
-       getComponents( a, 3 );
-    }
+    getComponents (a, 3);
+  }
 
-    private void getComponents( byte[] c, int ci )
-    {
-       int i, max = ( map_size < c.length ) ? map_size : c.length;
-       for( i = 0; i < max; i++ )
-           c[i] = (byte)(( generateMask( ci )  & rgb[i]) >> ( ci * pixel_bits) );
-    } 
+  private void getComponents (byte[] c, int ci)
+  {
+    int i, max = (map_size < c.length) ? map_size : c.length;
+    for (i = 0; i < max; i++)
+           c[i] = (byte) ((generateMask (ci)  & rgb[i]) >> (ci * pixel_bits));
+  } 
 
-    /**
-     * Get the red component of the given pixel.
-     */
+  /**
+   * Get the red component of the given pixel.
+   */
   public final int getRed (int pixel)
   {
-       if( pixel < map_size ) 
-           return  (int)(( generateMask( 2 )  & rgb[pixel]) >> (2 * pixel_bits ) );
+    if (pixel < map_size)
+           return (int) ((generateMask (2) & rgb[pixel]) >> (2 * pixel_bits));
     
-       return 0;
-    }
+    return 0;
+  }
 
-    /**
-     * Get the green component of the given pixel.
-     */
+  /**
+   * Get the green component of the given pixel.
+   */
   public final int getGreen (int pixel)
   {
-       if( pixel < map_size ) 
-           return (int)(( generateMask( 1 )  & rgb[pixel]) >> (1 * pixel_bits ) );
+    if (pixel < map_size)
+           return (int) ((generateMask (1) & rgb[pixel]) >> (1 * pixel_bits));
     
-       return 0;
-    }
+    return 0;
+  }
 
-    /**
-     * Get the blue component of the given pixel.
-     */
+  /**
+   * Get the blue component of the given pixel.
+   */
   public final int getBlue (int pixel)
   {
-       if( pixel < map_size ) 
-           return  (int)( generateMask( 0 )  & rgb[pixel]);
+    if (pixel < map_size) 
+           return (int) (generateMask (0) & rgb[pixel]);
     
-       return 0;
-    }
+    return 0;
+  }
 
-    /**
-     * Get the alpha component of the given pixel.
-     */
+  /**
+   * Get the alpha component of the given pixel.
+   */
   public final int getAlpha (int pixel)
   {
-       if( pixel < map_size ) 
-           return  (int)(( generateMask( 3 )  & rgb[pixel]) >> (3 * pixel_bits ) );
+    if (pixel < map_size)
+           return (int) ((generateMask (3) & rgb[pixel]) >> (3 * pixel_bits));
     
-       return 0;
-    }
+    return 0;
+  }
 
-    /**
-     * Get the RGB color value of the given pixel using the default
-     * RGB color model. 
-     *
-     * @param pixel a pixel value
-     */
+  /**
+   * Get the RGB color value of the given pixel using the default
+   * RGB color model. 
+   *
+   * @param pixel a pixel value
+   */
   public final int getRGB (int pixel)
   {
-       if( pixel < map_size ) 
+    if (pixel < map_size)
            return rgb[pixel];
     
-       return 0;
-    }
+    return 0;
+  }
     
-    //pixel_bits is number of bits to be in generated mask
-    private int generateMask( int offset )
-    {
-       return (  ( ( 2 << pixel_bits ) - 1 ) << ( pixel_bits * offset ) );
-    }
+  //pixel_bits is number of bits to be in generated mask
+  private int generateMask (int offset)
+  {
+    return (((2 << pixel_bits ) - 1) << (pixel_bits * offset));
+  }
 
 }