OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

IndexColorModel.java: Reformated.

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

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

From-SVN: r71898
This commit is contained in:
Michael Koch 2003-09-29 11:28:58 +00:00 committed by Michael Koch
parent 7da1da8352
commit 3887819542
2 changed files with 172 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libjava/ChangeLog
View File

@ -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,

336
libjava/java/awt/image/IndexColorModel.java
View File

@ -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));
}
}