/*
 *  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.math.BigInteger;

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

/**
 * The Class IndexColorModel represents a color model in which the color values
 * of the pixels are read from a palette.
 * 
 * @since Android 1.0
 */
public class IndexColorModel extends ColorModel {

    /**
     * The color map.
     */
    private int colorMap[]; // Color Map

    /**
     * The map size.
     */
    private int mapSize; // Color Map size

    /**
     * The transparent index.
     */
    private int transparentIndex; // Index of fully transparent pixel

    /**
     * The gray palette.
     */
    private boolean grayPalette; // Color Model has Color Map with Gray Pallete

    /**
     * The valid bits.
     */
    private BigInteger validBits; // Specify valid Color Map values

    /**
     * The Constant CACHESIZE.
     */
    private static final int CACHESIZE = 20; // Cache size. Cache used for

    // improving performace of selection
    // nearest color in Color Map

    /**
     * The cachetable.
     */
    private final int cachetable[] = new int[CACHESIZE * 2]; // Cache table -

    // used for

    // storing RGB values and that appropriate indices
    // in the Color Map

    /**
     * The next insert idx.
     */
    private int nextInsertIdx = 0; // Next index for insertion into Cache table

    /**
     * The total inserted.
     */
    private int totalInserted = 0; // Number of inserted values into Cache table

    /**
     * Instantiates a new index color model.
     * 
     * @param bits
     *            the array of component masks.
     * @param size
     *            the size of the color map.
     * @param cmap
     *            the array that gives the color mapping.
     * @param start
     *            the start index of the color mapping data within the cmap
     *            array.
     * @param transferType
     *            the transfer type (primitive java type to use for the
     *            components).
     * @param validBits
     *            a list of which bits represent valid colormap values, or null
     *            if all are valid.
     * @throws IllegalArgumentException
     *             if the size of the color map is less than one.
     */
    public IndexColorModel(int bits, int size, int cmap[], int start, int transferType,
            BigInteger validBits) {

        super(bits, IndexColorModel.createBits(true), ColorSpace.getInstance(ColorSpace.CS_sRGB),
                true, false, Transparency.OPAQUE, validateTransferType(transferType));

        if (size < 1) {
            // awt.264=Size of the color map is less than 1
            throw new IllegalArgumentException(Messages.getString("awt.264")); //$NON-NLS-1$
        }

        mapSize = size;
        colorMap = new int[mapSize];
        transparentIndex = -1;

        if (validBits != null) {
            for (int i = 0; i < mapSize; i++) {
                if (!validBits.testBit(i)) {
                    this.validBits = validBits;
                }
                break;
            }
        }

        transparency = Transparency.OPAQUE;
        int alphaMask = 0xff000000;
        int alpha = 0;

        for (int i = 0; i < mapSize; i++, start++) {
            colorMap[i] = cmap[start];
            alpha = cmap[start] & alphaMask;

            if (alpha == alphaMask) {
                continue;
            }
            if (alpha == 0) {
                if (transparentIndex < 0) {
                    transparentIndex = i;
                }
                if (transparency == Transparency.OPAQUE) {
                    transparency = Transparency.BITMASK;
                }
            } else if (alpha != alphaMask && transparency != Transparency.TRANSLUCENT) {
                transparency = Transparency.TRANSLUCENT;
            }

        }
        checkPalette();

    }

    /**
     * Instantiates a new index color model.
     * 
     * @param bits
     *            the array of component masks.
     * @param size
     *            the size of the color map.
     * @param cmap
     *            the array that gives the color mapping.
     * @param start
     *            the start index of the color mapping data within the cmap
     *            array.
     * @param hasalpha
     *            whether this color model uses alpha.
     * @param trans
     *            the transparency supported, @see java.awt.Transparency.
     * @param transferType
     *            the transfer type (primitive java type to use for the
     *            components).
     * @throws IllegalArgumentException
     *             if the size of the color map is less than one.
     */
    public IndexColorModel(int bits, int size, int cmap[], int start, boolean hasalpha, int trans,
            int transferType) {

        super(bits, IndexColorModel.createBits(hasalpha || (trans >= 0)), ColorSpace
                .getInstance(ColorSpace.CS_sRGB), (hasalpha || (trans >= 0)), false,
                Transparency.OPAQUE, validateTransferType(transferType));

        if (size < 1) {
            // awt.264=Size of the color map is less than 1
            throw new IllegalArgumentException(Messages.getString("awt.264")); //$NON-NLS-1$
        }

        mapSize = size;
        colorMap = new int[mapSize];
        if (trans >= 0 && trans < mapSize) {
            transparentIndex = trans;
            transparency = Transparency.BITMASK;
        } else {
            transparentIndex = -1;
            transparency = Transparency.OPAQUE;
        }

        int alphaMask = 0xff000000;
        int alpha = 0;

        for (int i = 0; i < mapSize; i++, start++) {
            if (transparentIndex == i) {
                colorMap[i] = cmap[start] & 0x00ffffff;
                continue;
            }
            if (hasalpha) {
                alpha = cmap[start] & alphaMask;
                colorMap[i] = cmap[start];

                if (alpha == alphaMask) {
                    continue;
                }
                if (alpha == 0) {
                    if (trans < 0) {
                        trans = i;
                    }
                    if (transparency == Transparency.OPAQUE) {
                        transparency = Transparency.BITMASK;
                    }
                } else if (alpha != 0 && transparency != Transparency.TRANSLUCENT) {
                    transparency = Transparency.TRANSLUCENT;
                }
            } else {
                colorMap[i] = alphaMask | cmap[start];
            }
        }
        checkPalette();

    }

    /**
     * Instantiates a new index color model by building the color map from
     * arrays of red, green, blue, and alpha values.
     * 
     * @param bits
     *            the array of component masks.
     * @param size
     *            the size of the color map.
     * @param r
     *            the array giving the red components of the entries in the
     *            color map.
     * @param g
     *            the array giving the green components of the entries in the
     *            color map.
     * @param b
     *            the array giving the blue components of the entries in the
     *            color map.
     * @param a
     *            the array giving the alpha components of the entries in the
     *            color map.
     * @throws IllegalArgumentException
     *             if the size of the color map is less than one.
     * @throws ArrayIndexOutOfBoundsException
     *             if the size of one of the component arrays is less than the
     *             size of the color map.
     */
    public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[], byte a[]) {

        super(bits, IndexColorModel.createBits(true), ColorSpace.getInstance(ColorSpace.CS_sRGB),
                true, false, Transparency.OPAQUE, validateTransferType(ColorModel
                        .getTransferType(bits)));

        createColorMap(size, r, g, b, a, -1);
        checkPalette();
    }

    /**
     * Instantiates a new index color model by building the color map from
     * arrays of red, green, and blue values.
     * 
     * @param bits
     *            the array of component masks.
     * @param size
     *            the size of the color map.
     * @param r
     *            the array giving the red components of the entries in the
     *            color map.
     * @param g
     *            the array giving the green components of the entries in the
     *            color map.
     * @param b
     *            the array giving the blue components of the entries in the
     *            color map.
     * @param trans
     *            the transparency supported, @see java.awt.Transparency.
     * @throws IllegalArgumentException
     *             if the size of the color map is less than one.
     * @throws ArrayIndexOutOfBoundsException
     *             if the size of one of the component arrays is less than the
     *             size of the color map.
     */
    public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[], int trans) {

        super(bits, IndexColorModel.createBits((trans >= 0)), ColorSpace
                .getInstance(ColorSpace.CS_sRGB), (trans >= 0), false, Transparency.OPAQUE,
                validateTransferType(ColorModel.getTransferType(bits)));

        createColorMap(size, r, g, b, null, trans);
        checkPalette();
    }

    /**
     * Instantiates a new index color model by building the color map from
     * arrays of red, green, and blue values.
     * 
     * @param bits
     *            the array of component masks.
     * @param size
     *            the size of the color map.
     * @param r
     *            the array giving the red components of the entries in the
     *            color map.
     * @param g
     *            the array giving the green components of the entries in the
     *            color map.
     * @param b
     *            the array giving the blue components of the entries in the
     *            color map.
     * @throws IllegalArgumentException
     *             if the size of the color map is less than one.
     * @throws ArrayIndexOutOfBoundsException
     *             if the size of one of the component arrays is less than the
     *             size of the color map.
     */
    public IndexColorModel(int bits, int size, byte r[], byte g[], byte b[]) {
        super(bits, IndexColorModel.createBits(false), ColorSpace.getInstance(ColorSpace.CS_sRGB),
                false, false, Transparency.OPAQUE, validateTransferType(ColorModel
                        .getTransferType(bits)));

        createColorMap(size, r, g, b, null, -1);
        checkPalette();
    }

    /**
     * Instantiates a new index color model.
     * 
     * @param bits
     *            the array of component masks.
     * @param size
     *            the size of the color map.
     * @param cmap
     *            the array that gives the color mapping.
     * @param start
     *            the start index of the color mapping data within the cmap
     *            array.
     * @param hasalpha
     *            whether this color model uses alpha.
     * @param trans
     *            the transparency supported, @see java.awt.Transparency.
     * @throws IllegalArgumentException
     *             if the size of the color map is less than one.
     */
    public IndexColorModel(int bits, int size, byte cmap[], int start, boolean hasalpha, int trans) {

        super(bits, IndexColorModel.createBits(hasalpha || (trans >= 0)), ColorSpace
                .getInstance(ColorSpace.CS_sRGB), (hasalpha || (trans >= 0)), false,
                Transparency.OPAQUE, validateTransferType(ColorModel.getTransferType(bits)));

        if (size < 1) {
            // awt.264=Size of the color map is less than 1
            throw new IllegalArgumentException(Messages.getString("awt.264")); //$NON-NLS-1$
        }

        mapSize = size;
        colorMap = new int[mapSize];
        transparentIndex = -1;

        transparency = Transparency.OPAQUE;
        int alpha = 0xff000000;

        for (int i = 0; i < mapSize; i++) {
            colorMap[i] = (cmap[start++] & 0xff) << 16 | (cmap[start++] & 0xff) << 8
                    | (cmap[start++] & 0xff);
            if (trans == i) {
                if (transparency == Transparency.OPAQUE) {
                    transparency = Transparency.BITMASK;
                }
                if (hasalpha) {
                    start++;
                }
                continue;
            }
            if (hasalpha) {
                alpha = cmap[start++] & 0xff;
                if (alpha == 0) {
                    if (transparency == Transparency.OPAQUE) {
                        transparency = Transparency.BITMASK;
                        if (trans < 0) {
                            trans = i;
                        }
                    }
                } else {
                    if (alpha != 0xff && transparency != Transparency.TRANSLUCENT) {
                        transparency = Transparency.TRANSLUCENT;
                    }
                }
                alpha <<= 24;
            }
            colorMap[i] |= alpha;
        }

        if (trans >= 0 && trans < mapSize) {
            transparentIndex = trans;
        }
        checkPalette();

    }

    /**
     * Instantiates a new index color model.
     * 
     * @param bits
     *            the array of component masks.
     * @param size
     *            the size of the color map.
     * @param cmap
     *            the array that gives the color mapping.
     * @param start
     *            the start index of the color mapping data within the cmap
     *            array.
     * @param hasalpha
     *            whether this color model uses alpha.
     * @throws IllegalArgumentException
     *             if the size of the color map is less than one.
     */
    public IndexColorModel(int bits, int size, byte cmap[], int start, boolean hasalpha) {

        this(bits, size, cmap, start, hasalpha, -1);
    }

    @Override
    public Object getDataElements(int[] components, int offset, Object pixel) {
        int rgb = (components[offset] << 16) | (components[offset + 1]) << 8
                | components[offset + 2];
        if (hasAlpha) {
            rgb |= components[offset + 3] << 24;
        } else {
            rgb |= 0xff000000;
        }
        return getDataElements(rgb, pixel);
    }

    @Override
    public synchronized Object getDataElements(int rgb, Object pixel) {
        int red = (rgb >> 16) & 0xff;
        int green = (rgb >> 8) & 0xff;
        int blue = rgb & 0xff;
        int alpha = rgb >>> 24;
        int pixIdx = 0;

        for (int i = 0; i < totalInserted; i++) {
            int idx = i * 2;
            if (rgb == cachetable[idx]) {
                return createDataObject(cachetable[idx + 1], pixel);
            }
        }

        if (!hasAlpha && grayPalette) {
            int grey = (red * 77 + green * 150 + blue * 29 + 128) >>> 8;
            int minError = 255;
            int error = 0;

            for (int i = 0; i < mapSize; i++) {
                error = Math.abs((colorMap[i] & 0xff) - grey);
                if (error < minError) {
                    pixIdx = i;
                    if (error == 0) {
                        break;
                    }
                    minError = error;
                }
            }
        } else if (alpha == 0 && transparentIndex > -1) {
            pixIdx = transparentIndex;
        } else {
            int minAlphaError = 255;
            int minError = 195075; // 255^2 + 255^2 + 255^2
            int alphaError;
            int error = 0;

            for (int i = 0; i < mapSize; i++) {
                int pix = colorMap[i];
                if (rgb == pix) {
                    pixIdx = i;
                    break;
                }
                alphaError = Math.abs(alpha - (pix >>> 24));
                if (alphaError <= minAlphaError) {
                    minAlphaError = alphaError;

                    int buf = ((pix >> 16) & 0xff) - red;
                    error = buf * buf;

                    if (error < minError) {
                        buf = ((pix >> 8) & 0xff) - green;
                        error += buf * buf;

                        if (error < minError) {
                            buf = (pix & 0xff) - blue;
                            error += buf * buf;

                            if (error < minError) {
                                pixIdx = i;
                                minError = error;
                            }
                        }
                    }
                }
            }
        }

        cachetable[nextInsertIdx] = rgb;
        cachetable[nextInsertIdx + 1] = pixIdx;

        nextInsertIdx = (nextInsertIdx + 2) % (CACHESIZE * 2);
        if (totalInserted < CACHESIZE) {
            totalInserted++;
        }

        return createDataObject(pixIdx, pixel);
    }

    /**
     * Converts an image from indexed to RGB format.
     * 
     * @param raster
     *            the raster containing the source image.
     * @param forceARGB
     *            whether to use the default RGB color model.
     * @return the buffered image.
     * @throws IllegalArgumentException
     *             if the raster is not compatible with this color model.
     */
    public BufferedImage convertToIntDiscrete(Raster raster, boolean forceARGB) {

        if (!isCompatibleRaster(raster)) {
            // awt.265=The raster argument is not compatible with this
            // IndexColorModel
            throw new IllegalArgumentException(Messages.getString("awt.265")); //$NON-NLS-1$
        }

        ColorModel model;
        if (forceARGB || transparency == Transparency.TRANSLUCENT) {
            model = ColorModel.getRGBdefault();
        } else if (transparency == Transparency.BITMASK) {
            model = new DirectColorModel(25, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x01000000);
        } else {
            model = new DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff);
        }

        int w = raster.getWidth();
        int h = raster.getHeight();

        WritableRaster distRaster = model.createCompatibleWritableRaster(w, h);

        int minX = raster.getMinX();
        int minY = raster.getMinY();

        Object obj = null;
        int pixels[] = null;

        for (int i = 0; i < h; i++, minY++) {
            obj = raster.getDataElements(minX, minY, w, 1, obj);
            if (obj instanceof byte[]) {
                byte ba[] = (byte[])obj;
                if (pixels == null) {
                    pixels = new int[ba.length];
                }
                for (int j = 0; j < ba.length; j++) {
                    pixels[j] = colorMap[ba[j] & 0xff];
                }
            } else if (obj instanceof short[]) {
                short sa[] = (short[])obj;
                if (pixels == null) {
                    pixels = new int[sa.length];
                }
                for (int j = 0; j < sa.length; j++) {
                    pixels[j] = colorMap[sa[j] & 0xffff];
                }
            }
            if (obj instanceof int[]) {
                int ia[] = (int[])obj;
                if (pixels == null) {
                    pixels = new int[ia.length];
                }
                for (int j = 0; j < ia.length; j++) {
                    pixels[j] = colorMap[ia[j]];
                }
            }

            distRaster.setDataElements(0, i, w, 1, pixels);
        }

        return new BufferedImage(model, distRaster, false, null);
    }

    /**
     * Gets the valid pixels.
     * 
     * @return the valid pixels.
     */
    public BigInteger getValidPixels() {
        return validBits;
    }

    @Override
    public String toString() {
        // The output format based on 1.5 release behaviour.
        // It could be reveled such way:
        // BufferedImage bi = new BufferedImage(1, 1,
        // BufferedImage.TYPE_BYTE_INDEXED);
        // ColorModel cm = bi.getColorModel();
        // System.out.println(cm.toString());
        String str = "IndexColorModel: #pixel_bits = " + pixel_bits + //$NON-NLS-1$
                " numComponents = " + numComponents + " color space = " + cs + //$NON-NLS-1$ //$NON-NLS-2$
                " transparency = "; //$NON-NLS-1$

        if (transparency == Transparency.OPAQUE) {
            str = str + "Transparency.OPAQUE"; //$NON-NLS-1$
        } else if (transparency == Transparency.BITMASK) {
            str = str + "Transparency.BITMASK"; //$NON-NLS-1$
        } else {
            str = str + "Transparency.TRANSLUCENT"; //$NON-NLS-1$
        }

        str = str + " transIndex = " + transparentIndex + " has alpha = " + //$NON-NLS-1$ //$NON-NLS-2$
                hasAlpha + " isAlphaPre = " + isAlphaPremultiplied; //$NON-NLS-1$

        return str;
    }

    @Override
    public int[] getComponents(Object pixel, int components[], int offset) {
        int pixIdx = -1;
        if (pixel instanceof byte[]) {
            byte ba[] = (byte[])pixel;
            pixIdx = ba[0] & 0xff;
        } else if (pixel instanceof short[]) {
            short sa[] = (short[])pixel;
            pixIdx = sa[0] & 0xffff;
        } else if (pixel instanceof int[]) {
            int ia[] = (int[])pixel;
            pixIdx = ia[0];
        } else {
            // awt.219=This transferType is not supported by this color model
            throw new UnsupportedOperationException(Messages.getString("awt.219")); //$NON-NLS-1$
        }

        return getComponents(pixIdx, components, offset);
    }

    @Override
    public WritableRaster createCompatibleWritableRaster(int w, int h) {
        WritableRaster raster;
        if (pixel_bits == 1 || pixel_bits == 2 || pixel_bits == 4) {
            raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE, w, h, 1, pixel_bits, null);
        } else if (pixel_bits <= 8) {
            raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, w, h, 1, null);
        } else if (pixel_bits <= 16) {
            raster = Raster.createInterleavedRaster(DataBuffer.TYPE_USHORT, w, h, 1, null);
        } else {
            // awt.266=The number of bits in a pixel is greater than 16
            throw new UnsupportedOperationException(Messages.getString("awt.266")); //$NON-NLS-1$
        }

        return raster;
    }

    @Override
    public boolean isCompatibleSampleModel(SampleModel sm) {
        if (sm == null) {
            return false;
        }

        if (!(sm instanceof MultiPixelPackedSampleModel) && !(sm instanceof ComponentSampleModel)) {
            return false;
        }

        if (sm.getTransferType() != transferType) {
            return false;
        }
        if (sm.getNumBands() != 1) {
            return false;
        }

        return true;
    }

    @Override
    public SampleModel createCompatibleSampleModel(int w, int h) {
        if (pixel_bits == 1 || pixel_bits == 2 || pixel_bits == 4) {
            return new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE, w, h, pixel_bits);
        }
        int bandOffsets[] = new int[1];
        bandOffsets[0] = 0;
        return new ComponentSampleModel(transferType, w, h, 1, w, bandOffsets);

    }

    @Override
    public boolean isCompatibleRaster(Raster raster) {
        int sampleSize = raster.getSampleModel().getSampleSize(0);
        return (raster.getTransferType() == transferType && raster.getNumBands() == 1 && (1 << sampleSize) >= mapSize);
    }

    @Override
    public int getDataElement(int components[], int offset) {
        int rgb = (components[offset] << 16) | (components[offset + 1]) << 8
                | components[offset + 2];

        if (hasAlpha) {
            rgb |= components[offset + 3] << 24;
        } else {
            rgb |= 0xff000000;
        }

        int pixel;

        switch (transferType) {
            case DataBuffer.TYPE_BYTE:
                byte ba[] = (byte[])getDataElements(rgb, null);
                pixel = ba[0] & 0xff;
                break;
            case DataBuffer.TYPE_USHORT:
                short sa[] = (short[])getDataElements(rgb, null);
                pixel = sa[0] & 0xffff;
                break;
            default:
                // awt.267=The transferType is invalid
                throw new UnsupportedOperationException(Messages.getString("awt.267")); //$NON-NLS-1$
        }

        return pixel;
    }

    /**
     * Gets the color map.
     * 
     * @param rgb
     *            the destination array where the color map is written.
     */
    public final void getRGBs(int rgb[]) {
        System.arraycopy(colorMap, 0, rgb, 0, mapSize);
    }

    /**
     * Gets the red component of the color map.
     * 
     * @param r
     *            the destination array.
     */
    public final void getReds(byte r[]) {
        for (int i = 0; i < mapSize; i++) {
            r[i] = (byte)(colorMap[i] >> 16);
        }
    }

    /**
     * Gets the green component of the color map.
     * 
     * @param g
     *            the destination array.
     */
    public final void getGreens(byte g[]) {
        for (int i = 0; i < mapSize; i++) {
            g[i] = (byte)(colorMap[i] >> 8);
        }
    }

    /**
     * Gets the blue component of the color map.
     * 
     * @param b
     *            the destination array.
     */
    public final void getBlues(byte b[]) {
        for (int i = 0; i < mapSize; i++) {
            b[i] = (byte)colorMap[i];
        }
    }

    /**
     * Gets the alpha component of the color map.
     * 
     * @param a
     *            the destination array.
     */
    public final void getAlphas(byte a[]) {
        for (int i = 0; i < mapSize; i++) {
            a[i] = (byte)(colorMap[i] >> 24);
        }
    }

    @Override
    public int[] getComponents(int pixel, int components[], int offset) {
        if (components == null) {
            components = new int[offset + numComponents];
        }

        components[offset + 0] = getRed(pixel);
        components[offset + 1] = getGreen(pixel);
        components[offset + 2] = getBlue(pixel);
        if (hasAlpha && (components.length - offset) > 3) {
            components[offset + 3] = getAlpha(pixel);
        }

        return components;
    }

    /**
     * Checks if the specified pixel is valid for this color model.
     * 
     * @param pixel
     *            the pixel.
     * @return true, if the pixel is valid.
     */
    public boolean isValid(int pixel) {
        if (validBits == null) {
            return (pixel >= 0 && pixel < mapSize);
        }
        return (pixel < mapSize && validBits.testBit(pixel));
    }

    @Override
    public final int getRed(int pixel) {
        return (colorMap[pixel] >> 16) & 0xff;
    }

    @Override
    public final int getRGB(int pixel) {
        return colorMap[pixel];
    }

    @Override
    public final int getGreen(int pixel) {
        return (colorMap[pixel] >> 8) & 0xff;
    }

    @Override
    public final int getBlue(int pixel) {
        return colorMap[pixel] & 0xff;
    }

    @Override
    public final int getAlpha(int pixel) {
        return (colorMap[pixel] >> 24) & 0xff;
    }

    @Override
    public int[] getComponentSize() {
        return bits.clone();
    }

    /**
     * Checks if this color model validates pixels.
     * 
     * @return true, if all pixels are valid, otherwise false.
     */
    public boolean isValid() {
        return (validBits == null);
    }

    @Override
    public void finalize() {
        // TODO: implement
        return;
    }

    /**
     * Gets the index that represents the transparent pixel.
     * 
     * @return the index that represents the transparent pixel.
     */
    public final int getTransparentPixel() {
        return transparentIndex;
    }

    @Override
    public int getTransparency() {
        return transparency;
    }

    /**
     * Gets the size of the color map.
     * 
     * @return the map size.
     */
    public final int getMapSize() {
        return mapSize;
    }

    /**
     * Creates the color map.
     * 
     * @param size
     *            the size.
     * @param r
     *            the r.
     * @param g
     *            the g.
     * @param b
     *            the b.
     * @param a
     *            the a.
     * @param trans
     *            the trans.
     */
    private void createColorMap(int size, byte r[], byte g[], byte b[], byte a[], int trans) {
        if (size < 1) {
            // awt.264=Size of the color map is less than 1
            throw new IllegalArgumentException(Messages.getString("awt.264")); //$NON-NLS-1$
        }

        mapSize = size;
        colorMap = new int[mapSize];
        if (trans >= 0 && trans < mapSize) {
            transparency = Transparency.BITMASK;
            transparentIndex = trans;
        } else {
            transparency = Transparency.OPAQUE;
            transparentIndex = -1;
        }
        int alpha = 0;

        for (int i = 0; i < mapSize; i++) {
            colorMap[i] = ((r[i] & 0xff) << 16) | ((g[i] & 0xff) << 8) | (b[i] & 0xff);

            if (trans == i) {
                continue;
            }

            if (a == null) {
                colorMap[i] |= 0xff000000;
            } else {
                alpha = a[i] & 0xff;
                if (alpha == 0xff) {
                    colorMap[i] |= 0xff000000;
                } else if (alpha == 0) {
                    if (transparency == Transparency.OPAQUE) {
                        transparency = Transparency.BITMASK;
                    }
                    if (transparentIndex < 0) {
                        transparentIndex = i;
                    }
                } else {
                    colorMap[i] |= (a[i] & 0xff) << 24;
                    if (transparency != Transparency.TRANSLUCENT) {
                        transparency = Transparency.TRANSLUCENT;
                    }
                }
            }

        }

    }

    /**
     * This method checking, if Color Map has Gray palette.
     */
    private void checkPalette() {
        grayPalette = false;
        if (transparency > Transparency.OPAQUE) {
            return;
        }
        int rgb = 0;

        for (int i = 0; i < mapSize; i++) {
            rgb = colorMap[i];
            if (((rgb >> 16) & 0xff) != ((rgb >> 8) & 0xff) || ((rgb >> 8) & 0xff) != (rgb & 0xff)) {
                return;
            }
        }
        grayPalette = true;
    }

    /**
     * Construction an array pixel representation.
     * 
     * @param colorMapIdx
     *            the index into Color Map.
     * @param pixel
     *            the pixel
     * @return the pixel representation array.
     */
    private Object createDataObject(int colorMapIdx, Object pixel) {
        if (pixel == null) {
            switch (transferType) {
                case DataBuffer.TYPE_BYTE:
                    byte[] ba = new byte[1];
                    ba[0] = (byte)colorMapIdx;
                    pixel = ba;
                    break;
                case DataBuffer.TYPE_USHORT:
                    short[] sa = new short[1];
                    sa[0] = (short)colorMapIdx;
                    pixel = sa;
                    break;
                default:
                    // awt.267=The transferType is invalid
                    throw new UnsupportedOperationException(Messages.getString("awt.267")); //$NON-NLS-1$
            }
        } else if (pixel instanceof byte[] && transferType == DataBuffer.TYPE_BYTE) {
            byte ba[] = (byte[])pixel;
            ba[0] = (byte)colorMapIdx;
            pixel = ba;
        } else if (pixel instanceof short[] && transferType == DataBuffer.TYPE_USHORT) {
            short[] sa = (short[])pixel;
            sa[0] = (short)colorMapIdx;
            pixel = sa;
        } else if (pixel instanceof int[]) {
            int ia[] = (int[])pixel;
            ia[0] = colorMapIdx;
            pixel = ia;
        } else {
            // awt.268=The pixel is not a primitive array of type transferType
            throw new ClassCastException(Messages.getString("awt.268")); //$NON-NLS-1$
        }
        return pixel;
    }

    /**
     * Creates the bits.
     * 
     * @param hasAlpha
     *            the has alpha.
     * @return the int[].
     */
    private static int[] createBits(boolean hasAlpha) {

        int numChannels;
        if (hasAlpha) {
            numChannels = 4;
        } else {
            numChannels = 3;
        }

        int bits[] = new int[numChannels];
        for (int i = 0; i < numChannels; i++) {
            bits[i] = 8;
        }

        return bits;

    }

    /**
     * Validate transfer type.
     * 
     * @param transferType
     *            the transfer type.
     * @return the int.
     */
    private static int validateTransferType(int transferType) {
        if (transferType != DataBuffer.TYPE_BYTE && transferType != DataBuffer.TYPE_USHORT) {
            // awt.269=The transferType is not one of DataBuffer.TYPE_BYTE or
            // DataBuffer.TYPE_USHORT
            throw new IllegalArgumentException(Messages.getString("awt.269")); //$NON-NLS-1$
        }
        return transferType;
    }

    /**
     * Checks if is gray palette.
     * 
     * @return true, if is gray palette.
     */
    boolean isGrayPallete() {
        return grayPalette;
    }

}