private long pData; // Placeholder for data for native functions

/**

protected int pixel_bits;

int nBits[];

int transparency = Transparency.TRANSLUCENT;

boolean supportsAlpha = true;

boolean isAlphaPremultiplied = false;

int numComponents = -1;

int numColorComponents = -1;

ColorSpace colorSpace = ColorSpace.getInstance(ColorSpace.CS_sRGB);

int colorSpaceType = ColorSpace.TYPE_RGB;

int maxBits;

boolean is_sRGB = true;

/**

protected int transferType;

/**

private static boolean loaded = false;

static void loadLibraries() {

if (!loaded) {

java.security.AccessController.doPrivileged(

new java.security.PrivilegedAction<Void>() {

public Void run() {

System.loadLibrary("awt");

return null;

}

});

loaded = true;

}

}

private static native void initIDs();

static {

/* ensure that the proper libraries are loaded */

loadLibraries();

initIDs();

}

private static ColorModel RGBdefault;

/**

public static ColorModel getRGBdefault() {

if (RGBdefault == null) {

RGBdefault = new DirectColorModel(32,

0x00ff0000, // Red

0x0000ff00, // Green

0x000000ff, // Blue

0xff000000 // Alpha

);

}

return RGBdefault;

}

/**

public ColorModel(int bits) {

pixel_bits = bits;

if (bits < 1) {

throw new IllegalArgumentException("Number of bits must be > 0");

}

numComponents = 4;

numColorComponents = 3;

maxBits = bits;

// REMIND: make sure transferType is set correctly

transferType = ColorModel.getDefaultTransferType(bits);

}

/**

protected ColorModel(int pixel_bits, int[] bits, ColorSpace cspace,

boolean hasAlpha,

boolean isAlphaPremultiplied,

int transparency,

int transferType) {

colorSpace = cspace;

colorSpaceType = cspace.getType();

numColorComponents = cspace.getNumComponents();

numComponents = numColorComponents + (hasAlpha ? 1 : 0);

supportsAlpha = hasAlpha;

if (bits.length < numComponents) {

throw new IllegalArgumentException("Number of color/alpha "+

"components should be "+

numComponents+

" but length of bits array is "+

bits.length);

}

// 4186669

if (transparency < Transparency.OPAQUE ||

transparency > Transparency.TRANSLUCENT)

{

throw new IllegalArgumentException("Unknown transparency: "+

transparency);

}

if (supportsAlpha == false) {

this.isAlphaPremultiplied = false;

this.transparency = Transparency.OPAQUE;

}

else {

this.isAlphaPremultiplied = isAlphaPremultiplied;

this.transparency = transparency;

}

nBits = bits.clone();

this.pixel_bits = pixel_bits;

if (pixel_bits <= 0) {

throw new IllegalArgumentException("Number of pixel bits must "+

"be > 0");

}

// Check for bits < 0

maxBits = 0;

for (int i=0; i < bits.length; i++) {

// bug 4304697

if (bits[i] < 0) {

throw new

IllegalArgumentException("Number of bits must be >= 0");

}

if (maxBits < bits[i]) {

maxBits = bits[i];

}

}

// Make sure that we don't have all 0-bit components

if (maxBits == 0) {

throw new IllegalArgumentException("There must be at least "+

"one component with > 0 "+

"pixel bits.");

}

// Save this since we always need to check if it is the default CS

if (cspace != ColorSpace.getInstance(ColorSpace.CS_sRGB)) {

is_sRGB = false;

}

// Save the transfer type

this.transferType = transferType;

}

/**

final public boolean hasAlpha() {

return supportsAlpha;

}

/**

final public boolean isAlphaPremultiplied() {

return isAlphaPremultiplied;

}

/**

final public int getTransferType() {

return transferType;

}

/**

public int getPixelSize() {

return pixel_bits;

}

/**

public int getComponentSize(int componentIdx) {

// REMIND:

if (nBits == null) {

throw new NullPointerException("Number of bits array is null.");

}

return nBits[componentIdx];

}

/**

public int[] getComponentSize() {

if (nBits != null) {

return nBits.clone();

}

return null;

}

/**

public int getTransparency() {

return transparency;

}

/**

public int getNumComponents() {

return numComponents;

}

/**

public int getNumColorComponents() {

return numColorComponents;

}

/**

public abstract int getRed(int pixel);

/**

public abstract int getGreen(int pixel);

/**

public abstract int getBlue(int pixel);

/**

public abstract int getAlpha(int pixel);

/**

public int getRGB(int pixel) {

return (getAlpha(pixel) << 24)

| (getRed(pixel) << 16)

| (getGreen(pixel) << 8)

| (getBlue(pixel) << 0);

}

/**

public int getRed(Object inData) {

int pixel=0,length=0;

switch (transferType) {

case DataBuffer.TYPE_BYTE:

byte bdata[] = (byte[])inData;

pixel = bdata[0] & 0xff;

length = bdata.length;

break;

case DataBuffer.TYPE_USHORT:

short sdata[] = (short[])inData;

pixel = sdata[0] & 0xffff;

length = sdata.length;

break;

case DataBuffer.TYPE_INT:

int idata[] = (int[])inData;

pixel = idata[0];

length = idata.length;

break;

default:

throw new UnsupportedOperationException("This method has not been "+

"implemented for transferType " + transferType);

}

if (length == 1) {

return getRed(pixel);

}

else {

throw new UnsupportedOperationException

("This method is not supported by this color model");

}

}

/**

public int getGreen(Object inData) {

int pixel=0,length=0;

switch (transferType) {

case DataBuffer.TYPE_BYTE:

byte bdata[] = (byte[])inData;

pixel = bdata[0] & 0xff;

length = bdata.length;

break;

case DataBuffer.TYPE_USHORT:

short sdata[] = (short[])inData;

pixel = sdata[0] & 0xffff;

length = sdata.length;

break;

case DataBuffer.TYPE_INT:

int idata[] = (int[])inData;

pixel = idata[0];

length = idata.length;

break;

default:

throw new UnsupportedOperationException("This method has not been "+

"implemented for transferType " + transferType);

}

if (length == 1) {

return getGreen(pixel);

}

else {

throw new UnsupportedOperationException

("This method is not supported by this color model");

}

}

/**

public int getBlue(Object inData) {

int pixel=0,length=0;

switch (transferType) {

case DataBuffer.TYPE_BYTE:

byte bdata[] = (byte[])inData;

pixel = bdata[0] & 0xff;

length = bdata.length;

break;

case DataBuffer.TYPE_USHORT:

short sdata[] = (short[])inData;

pixel = sdata[0] & 0xffff;

length = sdata.length;

break;

case DataBuffer.TYPE_INT:

int idata[] = (int[])inData;

pixel = idata[0];

length = idata.length;

break;

default:

throw new UnsupportedOperationException("This method has not been "+

"implemented for transferType " + transferType);

}

if (length == 1) {

return getBlue(pixel);

}

else {

throw new UnsupportedOperationException

("This method is not supported by this color model");

}

}

/**

public int getAlpha(Object inData) {

int pixel=0,length=0;

switch (transferType) {

case DataBuffer.TYPE_BYTE:

byte bdata[] = (byte[])inData;

pixel = bdata[0] & 0xff;

length = bdata.length;

break;

case DataBuffer.TYPE_USHORT:

short sdata[] = (short[])inData;

pixel = sdata[0] & 0xffff;

length = sdata.length;

break;

case DataBuffer.TYPE_INT:

int idata[] = (int[])inData;

pixel = idata[0];

length = idata.length;

break;

default:

throw new UnsupportedOperationException("This method has not been "+

"implemented for transferType " + transferType);

}

if (length == 1) {

return getAlpha(pixel);

}

else {

throw new UnsupportedOperationException

("This method is not supported by this color model");

}

}

/**

public int getRGB(Object inData) {

return (getAlpha(inData) << 24)

| (getRed(inData) << 16)

| (getGreen(inData) << 8)

| (getBlue(inData) << 0);

}

/**

public Object getDataElements(int rgb, Object pixel) {

throw new UnsupportedOperationException

("This method is not supported by this color model.");

}

/**

public int[] getComponents(int pixel, int[] components, int offset) {

throw new UnsupportedOperationException

("This method is not supported by this color model.");

}

/**