/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/**
 * @author Igor V. Stolyarov
 * @version $Revision$
 */

package java.awt.image;

import java.awt.Transparency;
import java.awt.color.ColorSpace;
import java.util.Arrays;

import org.apache.harmony.awt.internal.nls.Messages;

/**
 * The class ColorModel.
 * 
 * @since Android 1.0
 */
public abstract class ColorModel implements Transparency {

    /**
     * The pixel_bits.
     */
    protected int pixel_bits; // Pixel length in bits

    /**
     * The transfer type.
     */
    protected int transferType;

    /**
     * The cs.
     */
    ColorSpace cs;

    /**
     * The has alpha.
     */
    boolean hasAlpha;

    /**
     * The is alpha premultiplied.
     */
    boolean isAlphaPremultiplied;

    /**
     * The transparency.
     */
    int transparency;

    /**
     * The num color components.
     */
    int numColorComponents;

    /**
     * The num components.
     */
    int numComponents;

    /**
     * The bits.
     */
    int[] bits; // Array of components masks

    /**
     * The max values.
     */
    int[] maxValues = null; // Max values that may be represent by color

    // components

    /**
     * The max bit length.
     */
    int maxBitLength; // Max length color components in bits

    /**
     * The RG bdefault.
     */
    private static ColorModel RGBdefault;

    /**
     * Instantiates a new color model with the specified values.
     * 
     * @param pixel_bits
     *            the pixel length in bits.
     * @param bits
     *            the array of component masks.
     * @param cspace
     *            the color space.
     * @param hasAlpha
     *            whether the color model has alpha.
     * @param isAlphaPremultiplied
     *            whether the alpha is pre-multiplied.
     * @param transparency
     *            the transparency strategy, @see java.awt.Transparency.
     * @param transferType
     *            the transfer type (primitive java type to use for the
     *            components).
     */
    protected ColorModel(int pixel_bits, int[] bits, ColorSpace cspace, boolean hasAlpha,
            boolean isAlphaPremultiplied, int transparency, int transferType) {

        if (pixel_bits < 1) {
            // awt.26B=The number of bits in the pixel values is less than 1
            throw new IllegalArgumentException(Messages.getString("awt.26B")); //$NON-NLS-1$
        }

        if (bits == null) {
            // awt.26C=bits is null
            throw new NullPointerException(Messages.getString("awt.26C")); //$NON-NLS-1$
        }

        int sum = 0;
        for (int element : bits) {
            if (element < 0) {
                // awt.26D=The elements in bits is less than 0
                throw new IllegalArgumentException(Messages.getString("awt.26D")); //$NON-NLS-1$
            }
            sum += element;
        }

        if (sum < 1) {
            // awt.26E=The sum of the number of bits in bits is less than 1
            throw new NullPointerException(Messages.getString("awt.26E")); //$NON-NLS-1$
        }

        if (cspace == null) {
            // awt.26F=The cspace is null
            throw new IllegalArgumentException(Messages.getString("awt.26F")); //$NON-NLS-1$
        }

        if (transparency < Transparency.OPAQUE || transparency > Transparency.TRANSLUCENT) {
            // awt.270=The transparency is not a valid value
            throw new IllegalArgumentException(Messages.getString("awt.270")); //$NON-NLS-1$
        }

        this.pixel_bits = pixel_bits;
        this.bits = bits.clone();

        maxValues = new int[bits.length];
        maxBitLength = 0;
        for (int i = 0; i < maxValues.length; i++) {
            maxValues[i] = (1 << bits[i]) - 1;
            if (bits[i] > maxBitLength) {
                maxBitLength = bits[i];
            }
        }

        cs = cspace;
        this.hasAlpha = hasAlpha;
        this.isAlphaPremultiplied = isAlphaPremultiplied;
        numColorComponents = cs.getNumComponents();

        if (hasAlpha) {
            numComponents = numColorComponents + 1;
        } else {
            numComponents = numColorComponents;
        }

        this.transparency = transparency;
        this.transferType = transferType;

    }

    /**
     * Instantiates a new color model with the specified pixel bit depth. The
     * transferType is chosen based on the pixel bits, and the other data fields
     * are given default values.
     * 
     * @param bits
     *            the array of component masks.
     */
    public ColorModel(int bits) {

        if (bits < 1) {
            // awt.271=The number of bits in bits is less than 1
            throw new IllegalArgumentException(Messages.getString("awt.271")); //$NON-NLS-1$
        }

        pixel_bits = bits;
        transferType = getTransferType(bits);
        cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
        hasAlpha = true;
        isAlphaPremultiplied = false;
        transparency = Transparency.TRANSLUCENT;

        numColorComponents = 3;
        numComponents = 4;

        this.bits = null;
    }

    /**
     * Gets the data elements from the specified component array, transforming
     * them according to rules of the color model.
     * 
     * @param components
     *            the components.
     * @param offset
     *            the offset in the normComponents array.
     * @param obj
     *            the array that the result is written to: an array of values
     *            whose length must be the number of components used by the
     *            color model and whose type depends on the transfer type (based
     *            on the pixel bit depth), or null to have the appropriate array
     *            created.
     * @return the array of data elements.
     */
    public Object getDataElements(int[] components, int offset, Object obj) {
        throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
                "supported by this ColorModel"); //$NON-NLS-1$
    }

    /**
     * Gets the data elements from the specified array of normalized components.
     * 
     * @param normComponents
     *            the array normalized components.
     * @param normOffset
     *            the offset in the normComponents array.
     * @param obj
     *            the array that the result is written to: an array of values
     *            whose length must be the number of components used by the
     *            color model and whose type depends on the transfer type (based
     *            on the pixel bit depth), or null to have the appropriate array
     *            created.
     * @return the array of data elements.
     */
    public Object getDataElements(float[] normComponents, int normOffset, Object obj) {
        int unnormComponents[] = getUnnormalizedComponents(normComponents, normOffset, null, 0);
        return getDataElements(unnormComponents, 0, obj);
    }

    /**
     * Gets the data elements corresponding to the pixel determined by the RGB
     * data.
     * 
     * @param rgb
     *            the RGB integer value that defines the pixel.
     * @param pixel
     *            the array that the result is written to: an array of values
     *            whose length must be the number of components used by the
     *            color model and whose type depends on the transfer type (based
     *            on the pixel bit depth), or null to have the appropriate array
     *            created.
     * @return the array of data elements.
     */
    public Object getDataElements(int rgb, Object pixel) {
        throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
                "supported by this ColorModel"); //$NON-NLS-1$
    }

    /**
     * Gets the child raster corresponding to the alpha channel of the specified
     * writable raster, or null if alpha is not supported.
     * 
     * @param raster
     *            the raster.
     * @return the alpha raster.
     */
    public WritableRaster getAlphaRaster(WritableRaster raster) {
        return null;
    }

    /**
     * Creates a new color model by coercing the data in the writable raster in
     * accordance with the alpha strategy of this color model.
     * 
     * @param raster
     *            the raster.
     * @param isAlphaPremultiplied
     *            whether the alpha is pre-multiplied in this color model
     * @return the new color model.
     */
    public ColorModel coerceData(WritableRaster raster, boolean isAlphaPremultiplied) {
        throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
                "supported by this ColorModel"); //$NON-NLS-1$
    }

    @Override
    public String toString() {
        // The output format based on 1.5 release behavior.
        // It could be reveled such way:
        // ColorModel cm = new
        // ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB,
        // false, false, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
        // System.out.println(cm.toString());
        return "ColorModel: Color Space = " + cs.toString() + "; has alpha = " //$NON-NLS-1$ //$NON-NLS-2$
                + hasAlpha + "; is alpha premultipied = " //$NON-NLS-1$
                + isAlphaPremultiplied + "; transparency = " + transparency //$NON-NLS-1$
                + "; number color components = " + numColorComponents //$NON-NLS-1$
                + "; pixel bits = " + pixel_bits + "; transfer type = " //$NON-NLS-1$ //$NON-NLS-2$
                + transferType;
    }

    /**
     * Gets the components of the pixel determined by the data array.
     * 
     * @param pixel
     *            the data array that defines the pixel (whose primitive type
     *            corresponds to the pixel length in bits.
     * @see ColorModel#getTransferType()
     * @param components
     *            the the array where the resulting components are written (or
     *            null to prompt the method to create the return array).
     * @param offset
     *            the offset that tells where the results should be written in
     *            the return array.
     * @return the array of components.
     */
    public int[] getComponents(Object pixel, int[] components, int offset) {
        throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
                "supported by this ColorModel"); //$NON-NLS-1$
    }

    /**
     * Gets the normalized components of the pixel determined by the data array.
     * 
     * @param pixel
     *            the data array that defines the pixel (whose primitive type
     *            corresponds to the pixel length in bits.
     * @see ColorModel#getTransferType()
     * @param normComponents
     *            the array where the resulting normalized components are
     *            written (or null to prompt the method to create the return
     *            array).
     * @param normOffset
     *            the offset that tells where the results should be written in
     *            the return array.
     * @return the array of normalized components.
     */
    public float[] getNormalizedComponents(Object pixel, float[] normComponents, int normOffset) {

        if (pixel == null) {
            // awt.294=pixel is null
            throw new NullPointerException(Messages.getString("awt.294")); //$NON-NLS-1$
        }

        int unnormComponents[] = getComponents(pixel, null, 0);
        return getNormalizedComponents(unnormComponents, 0, normComponents, normOffset);
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof ColorModel)) {
            return false;
        }
        ColorModel cm = (ColorModel)obj;

        return (pixel_bits == cm.getPixelSize() && transferType == cm.getTransferType()
                && cs.getType() == cm.getColorSpace().getType() && hasAlpha == cm.hasAlpha()
                && isAlphaPremultiplied == cm.isAlphaPremultiplied()
                && transparency == cm.getTransparency()
                && numColorComponents == cm.getNumColorComponents()
                && numComponents == cm.getNumComponents() && Arrays.equals(bits, cm
                .getComponentSize()));
    }

    /**
     * Gets the red component of the pixel determined by the data array.
     * 
     * @param inData
     *            the data array that defines the pixel (whose primitive type
     *            corresponds to the pixel length in bits.
     * @see ColorModel#getTransferType()
     * @return the red.
     */
    public int getRed(Object inData) {
        return getRed(constructPixel(inData));
    }

    /**
     * Gets the RGB integer value corresponding to the pixel defined by the data
     * array.
     * 
     * @param inData
     *            the data array that defines the pixel (whose primitive type
     *            corresponds to the pixel length in bits.
     * @see ColorModel#getTransferType()
     * @return the integer value that gives the pixel's colors in RGB format.
     */
    public int getRGB(Object inData) {
        return (getAlpha(inData) << 24 | getRed(inData) << 16 | getGreen(inData) << 8 | getBlue(inData));
    }

    /**
     * Gets the green component of the pixel defined by the data array.
     * 
     * @param inData
     *            the data array that defines the pixel (whose primitive type
     *            corresponds to the pixel length in bits.
     * @see ColorModel#getTransferType()
     * @return the green.
     */
    public int getGreen(Object inData) {
        return getGreen(constructPixel(inData));
    }

    /**
     * Gets the blue component of the pixel defined by the data array.
     * 
     * @param inData
     *            the data array that defines the pixel (whose primitive type
     *            corresponds to the pixel length in bits.
     * @see ColorModel#getTransferType()
     * @return the blue.
     */
    public int getBlue(Object inData) {
        return getBlue(constructPixel(inData));
    }

    /**
     * Gets the alpha component of the pixel defined by the data array.
     * 
     * @param inData
     *            the data array that defines the pixel (whose primitive type
     *            corresponds to the pixel length in bits.
     * @see ColorModel#getTransferType()
     * @return the alpha.
     */
    public int getAlpha(Object inData) {
        return getAlpha(constructPixel(inData));
    }

    /**
     * Creates a compatible writable raster.
     * 
     * @param w
     *            the width of the desired writable raster.
     * @param h
     *            the height of the desired writable raster.
     * @return the writable raster.
     */
    public WritableRaster createCompatibleWritableRaster(int w, int h) {
        throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
                "supported by this ColorModel"); //$NON-NLS-1$
    }

    /**
     * Checks if the sample model is compatible with this color model.
     * 
     * @param sm
     *            the sample model.
     * @return true, if the sample model is compatible with this color model.
     */
    public boolean isCompatibleSampleModel(SampleModel sm) {
        throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
                "supported by this ColorModel"); //$NON-NLS-1$
    }

    /**
     * Creates the compatible sample model.
     * 
     * @param w
     *            the width of the desired sample model.
     * @param h
     *            the height of the desired sample model.
     * @return the sample model.
     */
    public SampleModel createCompatibleSampleModel(int w, int h) {
        throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
                "supported by this ColorModel"); //$NON-NLS-1$
    }

    /**
     * Checks if the specified raster is compatible with this color model.
     * 
     * @param raster
     *            the raster to inspect.
     * @return true, if the raster is compatible with this color model.
     */
    public boolean isCompatibleRaster(Raster raster) {
        throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
                "supported by this ColorModel"); //$NON-NLS-1$
    }

    /**
     * Gets the color space of this color model.
     * 
     * @return the color space.
     */
    public final ColorSpace getColorSpace() {
        return cs;
    }

    /**
     * Gets the normalized components corresponding to the specified
     * unnormalized components.
     * 
     * @param components
     *            the array of unnormalized components.
     * @param offset
     *            the offset where the components should be read from the array
     *            of unnormalized components.
     * @param normComponents
     *            the array where the resulting normalized components are
     *            written (or null to prompt the method to create the return
     *            array).
     * @param normOffset
     *            the offset that tells where the results should be written in
     *            the return array.
     * @return the normalized components.
     */
    public float[] getNormalizedComponents(int[] components, int offset, float normComponents[],
            int normOffset) {
        if (bits == null) {
            // awt.26C=bits is null
            throw new UnsupportedOperationException(Messages.getString("awt.26C")); //$NON-NLS-1$
        }

        if (normComponents == null) {
            normComponents = new float[numComponents + normOffset];
        }

        if (hasAlpha && isAlphaPremultiplied) {
            float normAlpha = (float)components[offset + numColorComponents]
                    / maxValues[numColorComponents];
            if (normAlpha != 0.0f) {
                for (int i = 0; i < numColorComponents; i++) {
                    normComponents[normOffset + i] = components[offset + i]
                            / (normAlpha * maxValues[i]);
                }
                normComponents[normOffset + numColorComponents] = normAlpha;
            } else {
                for (int i = 0; i < numComponents; i++) {
                    normComponents[normOffset + i] = 0.0f;
                }
            }
        } else {
            for (int i = 0; i < numComponents; i++) {
                normComponents[normOffset + i] = (float)components[offset + i] / maxValues[i];
            }
        }

        return normComponents;
    }

    /**
     * Gets the data element corresponding to the unnormalized components.
     * 
     * @param components
     *            the components.
     * @param offset
     *            the offset to start reading the components from the array of
     *            components.
     * @return the data element.
     */
    public int getDataElement(int[] components, int offset) {
        throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
                "supported by this ColorModel"); //$NON-NLS-1$
    }

    /**
     * Gets the unnormalized components corresponding to the specified
     * normalized components.
     * 
     * @param normComponents
     *            the array of normalized components.
     * @param normOffset
     *            the offset where the components should be read from the array
     *            of normalized components.
     * @param components
     *            the array where the resulting unnormalized components are
     *            written (or null to prompt the method to create the return
     *            array).
     * @param offset
     *            the offset that tells where the results should be written in
     *            the return array.
     * @return the unnormalized components.
     */
    public int[] getUnnormalizedComponents(float normComponents[], int normOffset,
            int components[], int offset) {

        if (bits == null) {
            // awt.26C=bits is null
            throw new UnsupportedOperationException(Messages.getString("awt.26C")); //$NON-NLS-1$
        }

        if (normComponents.length - normOffset < numComponents) {
            // awt.273=The length of normComponents minus normOffset is less
            // than numComponents
            throw new IllegalArgumentException(Messages.getString("awt.273")); //$NON-NLS-1$
        }

        if (components == null) {
            components = new int[numComponents + offset];
        } else {
            if (components.length - offset < numComponents) {
                // awt.272=The length of components minus offset is less than
                // numComponents
                throw new IllegalArgumentException(Messages.getString("awt.272")); //$NON-NLS-1$
            }
        }

        if (hasAlpha && isAlphaPremultiplied) {
            float alpha = normComponents[normOffset + numColorComponents];
            for (int i = 0; i < numColorComponents; i++) {
                components[offset + i] = (int)(normComponents[normOffset + i] * maxValues[i]
                        * alpha + 0.5f);
            }
            components[offset + numColorComponents] = (int)(normComponents[normOffset
                    + numColorComponents]
                    * maxValues[numColorComponents] + 0.5f);
        } else {
            for (int i = 0; i < numComponents; i++) {
                components[offset + i] = (int)(normComponents[normOffset + i] * maxValues[i] + 0.5f);
            }
        }

        return components;
    }

    /**
     * Gets the data element corresponding to the normalized components.
     * 
     * @param normComponents
     *            the normalized components.
     * @param normOffset
     *            the offset where the normalized components should be read from
     *            the normalized component array.
     * @return the data element.
     */
    public int getDataElement(float normComponents[], int normOffset) {
        int unnormComponents[] = getUnnormalizedComponents(normComponents, normOffset, null, 0);
        return getDataElement(unnormComponents, 0);
    }

    /**
     * Takes a pixel whose data is defined by an integer, and writes the
     * corresponding components into the components array, starting from the
     * index offset.
     * 
     * @param pixel
     *            the pixel data.
     * @param components
     *            the data array to write the components to (or null to have the
     *            method create the return array).
     * @param offset
     *            the offset that determines where the results are written in
     *            the components array.
     * @return the array of components corresponding to the pixel.
     */
    public int[] getComponents(int pixel, int components[], int offset) {
        throw new UnsupportedOperationException("This method is not " + //$NON-NLS-1$
                "supported by this ColorModel"); //$NON-NLS-1$
    }

    /**
     * Gets the red component of the pixel determined by the pixel data.
     * 
     * @param pixel
     *            the pixel.
     * @return the red component of the given pixel.
     */
    public abstract int getRed(int pixel);

    /**
     * Takes the pixel data and returns the integer value corresponding to the
     * pixel's color in RGB format.
     * 
     * @param pixel
     *            the pixel data.
     * @return the corresponding RGB integer value.
     */
    public int getRGB(int pixel) {
        return (getAlpha(pixel) << 24 | getRed(pixel) << 16 | getGreen(pixel) << 8 | getBlue(pixel));
    }

    /**
     * Gets the green component of the pixel determined by the pixel data.
     * 
     * @param pixel
     *            the pixel.
     * @return the green component of the given pixel.
     */
    public abstract int getGreen(int pixel);

    /**
     * Gets the size of the desired component of this color model.
     * 
     * @param componentIdx
     *            the index that determines which component size to get.
     * @return the component size corresponding to the index.
     * @throws NullPointerException
     *             if this color model doesn't support an array of separate
     *             components.
     * @throws ArrayIndexOutOfBoundsException
     *             if the index is negative or greater than or equal to the
     *             number of components.
     */
    public int getComponentSize(int componentIdx) {
        if (bits == null) {
            // awt.26C=bits is null
            throw new NullPointerException(Messages.getString("awt.26C")); //$NON-NLS-1$
        }

        if (componentIdx < 0 || componentIdx >= bits.length) {
            // awt.274=componentIdx is greater than the number of components or
            // less than zero
            throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.274")); //$NON-NLS-1$
        }

        return bits[componentIdx];
    }

    /**
     * Gets the blue component of the pixel determined by the pixel data.
     * 
     * @param pixel
     *            the pixel.
     * @return the blue component of the given pixel.
     */
    public abstract int getBlue(int pixel);

    /**
     * Gets the alpha component of the pixel determined by the pixel data.
     * 
     * @param pixel
     *            the pixel.
     * @return the alpha component of the given pixel.
     */
    public abstract int getAlpha(int pixel);

    /**
     * Gets the array of sizes of the different components.
     * 
     * @return the array of sizes of the different components.
     */
    public int[] getComponentSize() {
        if (bits != null) {
            return bits.clone();
        }
        return null;
    }

    /**
     * Checks if the alpha component is pre-multiplied.
     * 
     * @return true, if the alpha component is pre-multiplied.
     */
    public final boolean isAlphaPremultiplied() {
        return isAlphaPremultiplied;
    }

    /**
     * Checks whether this color model supports alpha.
     * 
     * @return true, if this color model has alpha.
     */
    public final boolean hasAlpha() {
        return hasAlpha;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        int tmp;

        if (hasAlpha) {
            hash ^= 1;
            hash <<= 8;
        }
        if (isAlphaPremultiplied) {
            hash ^= 1;
            hash <<= 8;
        }

        tmp = hash >>> 24;
        hash ^= numColorComponents;
        hash <<= 8;
        hash |= tmp;

        tmp = hash >>> 24;
        hash ^= transparency;
        hash <<= 8;
        hash |= tmp;

        tmp = hash >>> 24;
        hash ^= cs.getType();
        hash <<= 8;
        hash |= tmp;

        tmp = hash >>> 24;
        hash ^= pixel_bits;
        hash <<= 8;
        hash |= tmp;

        tmp = hash >>> 24;
        hash ^= transferType;
        hash <<= 8;
        hash |= tmp;

        if (bits != null) {

            for (int element : bits) {
                tmp = hash >>> 24;
                hash ^= element;
                hash <<= 8;
                hash |= tmp;
            }

        }

        return hash;
    }

    public int getTransparency() {
        return transparency;
    }

    /**
     * Gets the transfer type, which is the type of Java primitive value that
     * corresponds to the bit length per pixel: either
     * {@link DataBuffer#TYPE_BYTE}, {@link DataBuffer#TYPE_USHORT},
     * {@link DataBuffer#TYPE_INT}, or {@link DataBuffer#TYPE_UNDEFINED}.
     * 
     * @return the transfer type.
     */
    public final int getTransferType() {
        return transferType;
    }

    /**
     * Gets the pixel size in bits.
     * 
     * @return the pixel size.
     */
    public int getPixelSize() {
        return pixel_bits;
    }

    /**
     * Gets the number of components of this color model.
     * 
     * @return the number of components.
     */
    public int getNumComponents() {
        return numComponents;
    }

    /**
     * Gets the number of color components of this color model.
     * 
     * @return the number color components.
     */
    public int getNumColorComponents() {
        return numColorComponents;
    }

    /**
     * Gets the default RGB color model.
     * 
     * @return the default RGB color model.
     */
    public static ColorModel getRGBdefault() {
        if (RGBdefault == null) {
            RGBdefault = new DirectColorModel(32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
        }
        return RGBdefault;
    }

    /*
     * Construct INT pixel representation from Object
     * @param obj
     * @return
     */
    /**
     * Construct pixel.
     * 
     * @param obj
     *            the obj.
     * @return the int.
     */
    private int constructPixel(Object obj) {
        int pixel = 0;

        switch (getTransferType()) {

            case DataBuffer.TYPE_BYTE:
                byte[] bPixel = (byte[])obj;
                if (bPixel.length > 1) {
                    // awt.275=This pixel representation is not suuported by tis
                    // Color Model
                    throw new UnsupportedOperationException(Messages.getString("awt.275")); //$NON-NLS-1$
                }
                pixel = bPixel[0] & 0xff;
                break;

            case DataBuffer.TYPE_USHORT:
                short[] sPixel = (short[])obj;
                if (sPixel.length > 1) {
                    // awt.275=This pixel representation is not suuported by tis
                    // Color Model
                    throw new UnsupportedOperationException(Messages.getString("awt.275")); //$NON-NLS-1$
                }
                pixel = sPixel[0] & 0xffff;
                break;

            case DataBuffer.TYPE_INT:
                int[] iPixel = (int[])obj;
                if (iPixel.length > 1) {
                    // awt.275=This pixel representation is not suuported by tis
                    // Color Model
                    throw new UnsupportedOperationException(Messages.getString("awt.275")); //$NON-NLS-1$
                }
                pixel = iPixel[0];
                break;

            default:
                // awt.22D=This transferType ( {0} ) is not supported by this
                // color model
                throw new UnsupportedOperationException(Messages.getString("awt.22D", //$NON-NLS-1$
                        transferType));

        }
        return pixel;
    }

    /**
     * Gets the transfer type, which is the type of Java primitive value that
     * corresponds to the bit length per pixel: either
     * {@link DataBuffer#TYPE_BYTE}, {@link DataBuffer#TYPE_USHORT},
     * {@link DataBuffer#TYPE_INT}, or {@link DataBuffer#TYPE_UNDEFINED}.
     * 
     * @param bits
     *            the array of component masks.
     * @return the transfer type.
     */
    static int getTransferType(int bits) {
        if (bits <= 8) {
            return DataBuffer.TYPE_BYTE;
        } else if (bits <= 16) {
            return DataBuffer.TYPE_USHORT;
        } else if (bits <= 32) {
            return DataBuffer.TYPE_INT;
        } else {
            return DataBuffer.TYPE_UNDEFINED;
        }
    }

    @Override
    public void finalize() {
        // This method is added for the API compatibility
        // Don't need to call super since Object's finalize is always empty
    }
}