| /* |
| * 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 |
| } |
| } |
