| /* |
| * 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 com.android.internal.awt.AndroidGraphics2D; |
| |
| import java.awt.Graphics; |
| import java.awt.Graphics2D; |
| import java.awt.GraphicsEnvironment; |
| import java.awt.Image; |
| import java.awt.Point; |
| import java.awt.Rectangle; |
| import java.awt.Transparency; |
| import java.awt.color.ColorSpace; |
| import java.util.Enumeration; |
| import java.util.Hashtable; |
| import java.util.Vector; |
| |
| import org.apache.harmony.awt.gl.ImageSurface; |
| import org.apache.harmony.awt.gl.Surface; |
| import org.apache.harmony.awt.gl.image.BufferedImageSource; |
| import org.apache.harmony.awt.internal.nls.Messages; |
| |
| |
| /** |
| * The BufferedImage class describes an Image which contains a buffer |
| * of image data and includes a ColorModel and a Raster for this data. |
| * This class provides methods for obtaining and setting the Raster |
| * and for manipulating the ColorModel parameters. |
| */ |
| public class BufferedImage extends |
| Image implements WritableRenderedImage, Transparency{ |
| |
| /** |
| * The Constant TYPE_CUSTOM indicates that Image type |
| * is unknown. |
| */ |
| public static final int TYPE_CUSTOM = 0; |
| |
| /** |
| * The Constant TYPE_INT_RGB indicates an image with |
| * 8 bit RGB color components, it has a DirectColorModel |
| * without alpha. |
| */ |
| public static final int TYPE_INT_RGB = 1; |
| |
| /** |
| * The Constant TYPE_INT_ARGB indicates an image with |
| * 8 bit RGBA color components, it has a DirectColorModel |
| * with alpha. |
| */ |
| public static final int TYPE_INT_ARGB = 2; |
| |
| /** |
| * The Constant TYPE_INT_ARGB_PRE indicates an image with |
| * 8 bit RGBA color components, it has a DirectColorModel |
| * with alpha, and image data is premultiplied by alpha. |
| */ |
| public static final int TYPE_INT_ARGB_PRE = 3; |
| |
| /** |
| * The Constant TYPE_INT_BGR indicates an image with |
| * 8 bit RGB color components, BGR color model |
| * (with the colors Blue, Green, and Red). There is no |
| * alpha. The image has a DirectColorModel. |
| */ |
| public static final int TYPE_INT_BGR = 4; |
| |
| /** |
| * The Constant TYPE_3BYTE_BGR indicates an image with |
| * 8 bit RGB color components, BGR color model |
| * (with the colors Blue, Green, and Red stored in 3 bytes). |
| * There is no alpha. The image has a ComponentColorModel. |
| */ |
| public static final int TYPE_3BYTE_BGR = 5; |
| |
| /** |
| * The Constant TYPE_4BYTE_ABGR indicates an image with |
| * 8 bit RGBA color components stored in 3 bytes and 1 byte of alpha. |
| * It has a ComponentColorModel with alpha. |
| */ |
| public static final int TYPE_4BYTE_ABGR = 6; |
| |
| /** |
| * The Constant TYPE_4BYTE_ABGR_PRE indicates an image with |
| * 8 bit RGBA color components stored in 3 bytes and 1 byte |
| * for alpha. The image has a ComponentColorModel with alpha. |
| * The color data is premultiplied with alpha. |
| */ |
| public static final int TYPE_4BYTE_ABGR_PRE = 7; |
| |
| /** |
| * The Constant TYPE_USHORT_565_RGB indicates an image with |
| * 565 RGB color components (5-bits red, 6-bits green, 5-bits blue) |
| * with no alpha. This image has a DirectColorModel. |
| */ |
| public static final int TYPE_USHORT_565_RGB = 8; |
| |
| /** |
| * The Constant TYPE_USHORT_555_RGB indicates an image with |
| * 555 RGB color components (5-bits red, 5-bits green, 5-bits blue) |
| * with no alpha. This image has a DirectColorModel. |
| */ |
| public static final int TYPE_USHORT_555_RGB = 9; |
| |
| /** |
| * The Constant TYPE_BYTE_GRAY indicates a unsigned byte |
| * image. This image has a ComponentColorModel with |
| * a CS_GRAY ColorSpace. |
| */ |
| public static final int TYPE_BYTE_GRAY = 10; |
| |
| /** |
| * The Constant TYPE_USHORT_GRAY indicates an unsigned short |
| * image. This image has a ComponentColorModel with a CS_GRAY |
| * ColorSpace. |
| */ |
| public static final int TYPE_USHORT_GRAY = 11; |
| |
| /** |
| * The Constant TYPE_BYTE_BINARY indicates an opaque byte-packed |
| * 1, 2 or 4 bit image. The image has an IndexColorModel without |
| * alpha. |
| */ |
| public static final int TYPE_BYTE_BINARY = 12; |
| |
| /** |
| * The Constant TYPE_BYTE_INDEXED indicates an indexed byte image. |
| */ |
| public static final int TYPE_BYTE_INDEXED = 13; |
| |
| /** The Constant ALPHA_MASK. */ |
| private static final int ALPHA_MASK = 0xff000000; |
| |
| /** The Constant RED_MASK. */ |
| private static final int RED_MASK = 0x00ff0000; |
| |
| /** The Constant GREEN_MASK. */ |
| private static final int GREEN_MASK = 0x0000ff00; |
| |
| /** The Constant BLUE_MASK. */ |
| private static final int BLUE_MASK = 0x000000ff; |
| |
| /** The Constant RED_BGR_MASK. */ |
| private static final int RED_BGR_MASK = 0x000000ff; |
| |
| /** The Constant GREEN_BGR_MASK. */ |
| private static final int GREEN_BGR_MASK = 0x0000ff00; |
| |
| /** The Constant BLUE_BGR_MASK. */ |
| private static final int BLUE_BGR_MASK = 0x00ff0000; |
| |
| /** The Constant RED_565_MASK. */ |
| private static final int RED_565_MASK = 0xf800; |
| |
| /** The Constant GREEN_565_MASK. */ |
| private static final int GREEN_565_MASK = 0x07e0; |
| |
| /** The Constant BLUE_565_MASK. */ |
| private static final int BLUE_565_MASK = 0x001f; |
| |
| /** The Constant RED_555_MASK. */ |
| private static final int RED_555_MASK = 0x7c00; |
| |
| /** The Constant GREEN_555_MASK. */ |
| private static final int GREEN_555_MASK = 0x03e0; |
| |
| /** The Constant BLUE_555_MASK. */ |
| private static final int BLUE_555_MASK = 0x001f; |
| |
| /** The cm. */ |
| private ColorModel cm; |
| |
| /** The raster. */ |
| private final WritableRaster raster; |
| |
| /** The image type. */ |
| private final int imageType; |
| |
| /** The properties. */ |
| private Hashtable<?, ?> properties; |
| |
| // Surface of the Buffered Image - used for blitting one Buffered Image |
| // on the other one or on the Component |
| /** The image surf. */ |
| private final ImageSurface imageSurf; |
| |
| /** |
| * Instantiates a new BufferedImage with the specified ColorModel, |
| * and WritableRaster objects. The Raster data can be |
| * be divided or multiplied by alpha. It depends on the |
| * alphaPremultiplied state in the ColorModel. |
| * |
| * @param cm the ColorModel of the new image. |
| * @param raster the WritableRaster of the new image. |
| * @param isRasterPremultiplied if true the data of the specified |
| * Raster is premultiplied by alpha. |
| * @param properties the properties of new Image. |
| */ |
| public BufferedImage(ColorModel cm, WritableRaster raster, |
| boolean isRasterPremultiplied, Hashtable<?, ?> properties) { |
| if (!cm.isCompatibleRaster(raster)) { |
| // awt.4D=The raster is incompatible with this ColorModel |
| throw new IllegalArgumentException(Messages.getString("awt.4D")); //$NON-NLS-1$ |
| } |
| |
| if (raster.getMinX() != 0 || raster.getMinY() != 0) { |
| // awt.228=minX or minY of this raster not equal to zero |
| throw new IllegalArgumentException(Messages.getString("awt.228")); //$NON-NLS-1$ |
| } |
| |
| this.cm = cm; |
| this.raster = raster; |
| this.properties = properties; |
| |
| coerceData(isRasterPremultiplied); |
| |
| imageType = Surface.getType(cm, raster); |
| |
| imageSurf = createImageSurface(imageType); |
| } |
| |
| /** |
| * Instantiates a new BufferedImage with the specified width, height |
| * predefined image type (TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED) |
| * and the specified IndexColorModel. |
| * |
| * @param width the width of new image. |
| * @param height the height of new image. |
| * @param imageType the predefined image type. |
| * @param cm the specified IndexColorModel. |
| */ |
| public BufferedImage(int width, int height, int imageType, |
| IndexColorModel cm) { |
| switch (imageType) { |
| case TYPE_BYTE_BINARY: |
| if (cm.hasAlpha()) { |
| // awt.227=This image type can't have alpha |
| throw new IllegalArgumentException(Messages.getString("awt.227")); //$NON-NLS-1$ |
| } |
| int pixel_bits = 0; |
| int mapSize = cm.getMapSize(); |
| if (mapSize <= 2) { |
| pixel_bits = 1; |
| } else if (mapSize <= 4) { |
| pixel_bits = 2; |
| } else if (mapSize <= 16) { |
| pixel_bits = 4; |
| } else { |
| // awt.221=The imageType is TYPE_BYTE_BINARY and the color map has more than 16 entries |
| throw new IllegalArgumentException(Messages.getString("awt.221")); //$NON-NLS-1$ |
| } |
| |
| raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE, width, |
| height, 1, pixel_bits, null); |
| break; |
| |
| case TYPE_BYTE_INDEXED: |
| raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, |
| width, height, 1, null); |
| break; |
| |
| default: |
| // awt.222=The imageType is not TYPE_BYTE_BINARY or TYPE_BYTE_INDEXED |
| throw new IllegalArgumentException(Messages.getString("awt.222")); //$NON-NLS-1$ |
| |
| } |
| |
| if (!cm.isCompatibleRaster(raster)) { |
| // awt.223=The imageType is not compatible with ColorModel |
| throw new IllegalArgumentException(Messages.getString("awt.223")); //$NON-NLS-1$ |
| } |
| |
| this.cm = cm; |
| this.imageType = imageType; |
| imageSurf = createImageSurface(imageType); |
| |
| } |
| |
| /** |
| * Instantiates a new BufferedImage with the specified width, height |
| * and predefined image type. |
| * |
| * @param width the width of new image. |
| * @param height the height of new image. |
| * @param imageType the predefined image type. |
| */ |
| public BufferedImage(int width, int height, int imageType) { |
| |
| switch (imageType) { |
| case TYPE_INT_RGB: |
| cm = new DirectColorModel(24, RED_MASK, GREEN_MASK, BLUE_MASK); |
| raster = cm.createCompatibleWritableRaster(width, height); |
| break; |
| |
| case TYPE_INT_ARGB: |
| cm = ColorModel.getRGBdefault(); |
| raster = cm.createCompatibleWritableRaster(width, height); |
| break; |
| |
| case TYPE_INT_ARGB_PRE: |
| cm = new DirectColorModel( |
| ColorSpace.getInstance(ColorSpace.CS_sRGB), |
| 32, |
| RED_MASK, |
| GREEN_MASK, |
| BLUE_MASK, |
| ALPHA_MASK, |
| true, |
| DataBuffer.TYPE_INT); |
| |
| raster = cm.createCompatibleWritableRaster(width, height); |
| break; |
| |
| case TYPE_INT_BGR: |
| cm = new DirectColorModel(24, |
| RED_BGR_MASK, |
| GREEN_BGR_MASK, |
| BLUE_BGR_MASK); |
| |
| raster = cm.createCompatibleWritableRaster(width, height); |
| break; |
| |
| case TYPE_3BYTE_BGR: { |
| int bits[] = { 8, 8, 8 }; |
| int bandOffsets[] = { 2, 1, 0 }; |
| cm = new ComponentColorModel( |
| ColorSpace.getInstance(ColorSpace.CS_sRGB), |
| bits, |
| false, |
| false, |
| Transparency.OPAQUE, |
| DataBuffer.TYPE_BYTE); |
| |
| raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, |
| width, height, width * 3, 3, bandOffsets, null); |
| } |
| break; |
| |
| case TYPE_4BYTE_ABGR: { |
| int bits[] = { 8, 8, 8, 8 }; |
| int bandOffsets[] = { 3, 2, 1, 0 }; |
| cm = new ComponentColorModel( |
| ColorSpace.getInstance(ColorSpace.CS_sRGB), |
| bits, |
| true, |
| false, |
| Transparency.TRANSLUCENT, |
| DataBuffer.TYPE_BYTE); |
| |
| raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, |
| width, height, width * 4, 4, bandOffsets, null); |
| } |
| break; |
| |
| case TYPE_4BYTE_ABGR_PRE: { |
| int bits[] = { 8, 8, 8, 8 }; |
| int bandOffsets[] = { 3, 2, 1, 0 }; |
| cm = new ComponentColorModel( |
| ColorSpace.getInstance(ColorSpace.CS_sRGB), |
| bits, |
| true, |
| true, |
| Transparency.TRANSLUCENT, DataBuffer.TYPE_BYTE); |
| |
| raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, |
| width, height, width * 4, 4, bandOffsets, null); |
| } |
| break; |
| |
| case TYPE_USHORT_565_RGB: |
| cm = new DirectColorModel( |
| ColorSpace.getInstance(ColorSpace.CS_sRGB), |
| 16, |
| RED_565_MASK, |
| GREEN_565_MASK, |
| BLUE_565_MASK, |
| 0, |
| false, |
| DataBuffer.TYPE_USHORT); |
| |
| raster = cm.createCompatibleWritableRaster(width, height); |
| break; |
| |
| case TYPE_USHORT_555_RGB: |
| cm = new DirectColorModel( |
| ColorSpace.getInstance(ColorSpace.CS_sRGB), |
| 15, |
| RED_555_MASK, |
| GREEN_555_MASK, |
| BLUE_555_MASK, |
| 0, |
| false, |
| DataBuffer.TYPE_USHORT); |
| |
| raster = cm.createCompatibleWritableRaster(width, height); |
| break; |
| |
| case TYPE_BYTE_GRAY: { |
| int bits[] = { 8 }; |
| cm = new ComponentColorModel( |
| ColorSpace.getInstance(ColorSpace.CS_GRAY), |
| bits, |
| false, |
| false, |
| Transparency.OPAQUE, |
| DataBuffer.TYPE_BYTE); |
| |
| raster = cm.createCompatibleWritableRaster(width, height); |
| } |
| break; |
| |
| case TYPE_USHORT_GRAY: { |
| int bits[] = { 16 }; |
| cm = new ComponentColorModel( |
| ColorSpace.getInstance(ColorSpace.CS_GRAY), |
| bits, |
| false, |
| false, |
| Transparency.OPAQUE, |
| DataBuffer.TYPE_USHORT); |
| raster = cm.createCompatibleWritableRaster(width, height); |
| } |
| break; |
| |
| case TYPE_BYTE_BINARY: { |
| int colorMap[] = { 0, 0xffffff }; |
| cm = new IndexColorModel(1, 2, colorMap, 0, false, -1, |
| DataBuffer.TYPE_BYTE); |
| |
| raster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE, width, |
| height, 1, 1, null); |
| } |
| break; |
| |
| case TYPE_BYTE_INDEXED: { |
| int colorMap[] = new int[256]; |
| int i = 0; |
| for (int r = 0; r < 256; r += 51) { |
| for (int g = 0; g < 256; g += 51) { |
| for (int b = 0; b < 256; b += 51) { |
| colorMap[i] = (r << 16) | (g << 8) | b; |
| i++; |
| } |
| } |
| } |
| |
| int gray = 0x12; |
| for (; i < 256; i++, gray += 6) { |
| colorMap[i] = (gray << 16) | (gray << 8) | gray; |
| } |
| cm = new IndexColorModel(8, 256, colorMap, 0, false, -1, |
| DataBuffer.TYPE_BYTE); |
| raster = Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, |
| width, height, 1, null); |
| |
| } |
| break; |
| default: |
| // awt.224=Unknown image type |
| throw new IllegalArgumentException(Messages.getString("awt.224")); //$NON-NLS-1$ |
| } |
| this.imageType = imageType; |
| imageSurf = createImageSurface(imageType); |
| } |
| |
| @Override |
| public Object getProperty(String name, ImageObserver observer) { |
| return getProperty(name); |
| } |
| |
| public Object getProperty(String name) { |
| if(name == null) { |
| // awt.225=Property name is null |
| throw new NullPointerException(Messages.getString("awt.225")); //$NON-NLS-1$ |
| } |
| if (properties == null) { |
| return Image.UndefinedProperty; |
| } |
| Object property = properties.get(name); |
| if (property == null) { |
| property = Image.UndefinedProperty; |
| } |
| return property; |
| } |
| |
| public WritableRaster copyData(WritableRaster outRaster) { |
| if (outRaster == null) { |
| outRaster = Raster.createWritableRaster(raster.getSampleModel(), |
| new Point(raster.getSampleModelTranslateX(), |
| raster.getSampleModelTranslateY())); |
| } |
| |
| int w = outRaster.getWidth(); |
| int h = outRaster.getHeight(); |
| int minX = outRaster.getMinX(); |
| int minY = outRaster.getMinY(); |
| |
| Object data = null; |
| |
| data = raster.getDataElements(minX, minY, w, h, data); |
| outRaster.setDataElements(minX, minY, w, h, data); |
| |
| return outRaster; |
| } |
| |
| public Raster getData(Rectangle rect) { |
| int minX = rect.x; |
| int minY = rect.y; |
| int w = rect.width; |
| int h = rect.height; |
| |
| SampleModel sm = raster.getSampleModel(); |
| SampleModel nsm = sm.createCompatibleSampleModel(w, h); |
| WritableRaster outr = Raster.createWritableRaster(nsm, |
| rect.getLocation()); |
| Object data = null; |
| |
| data = raster.getDataElements(minX, minY, w, h, data); |
| outr.setDataElements(minX, minY, w, h, data); |
| return outr; |
| } |
| |
| public Vector<RenderedImage> getSources() { |
| return null; |
| } |
| |
| public String[] getPropertyNames() { |
| if (properties == null) { |
| return null; |
| } |
| Vector<String> v = new Vector<String>(); |
| for (Enumeration<?> e = properties.keys(); e.hasMoreElements();) { |
| try { |
| v.add((String) e.nextElement()); |
| } catch (ClassCastException ex) { |
| } |
| } |
| int size = v.size(); |
| if (size > 0) { |
| String names[] = new String[size]; |
| for (int i = 0; i < size; i++) { |
| names[i] = v.elementAt(i); |
| } |
| return names; |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the string representation of this BufferedImage object. |
| * |
| * @return the string representation of this BufferedImage object. |
| */ |
| @Override |
| public String toString() { |
| return "BufferedImage@" + Integer.toHexString(hashCode()) + //$NON-NLS-1$ |
| ": type = " + imageType + " " + cm + " " + raster; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| } |
| |
| public WritableRaster getWritableTile(int tileX, int tileY) { |
| return raster; |
| } |
| |
| /** |
| * Gets the WritableRaster of this BufferedImage. |
| * |
| * @return the WritableRaster of this BufferedImage. |
| */ |
| public WritableRaster getRaster() { |
| return raster; |
| } |
| |
| /** |
| * Gets a WritableRaster object which contains the alpha channel of |
| * BufferedImage object with ColorModel objects that supports |
| * a separate alpha channel such as ComponentColorModel |
| * or DirectColorModel. |
| * |
| * @return the WritableRaster object which contains the alpha |
| * channel of this BufferedImage. |
| */ |
| public WritableRaster getAlphaRaster() { |
| return cm.getAlphaRaster(raster); |
| } |
| |
| public void removeTileObserver(TileObserver to) { |
| } |
| |
| public void addTileObserver(TileObserver to) { |
| } |
| |
| public SampleModel getSampleModel() { |
| return raster.getSampleModel(); |
| } |
| |
| public void setData(Raster r) { |
| |
| Rectangle from = r.getBounds(); |
| Rectangle to = raster.getBounds(); |
| Rectangle intersection = to.intersection(from); |
| |
| int minX = intersection.x; |
| int minY = intersection.y; |
| int w = intersection.width; |
| int h = intersection.height; |
| |
| Object data = null; |
| |
| data = r.getDataElements(minX, minY, w, h, data); |
| raster.setDataElements(minX, minY, w, h, data); |
| } |
| |
| public Raster getTile(int tileX, int tileY) { |
| if (tileX == 0 && tileY == 0) { |
| return raster; |
| } |
| // awt.226=Both tileX and tileY are not equal to 0 |
| throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.226")); //$NON-NLS-1$ |
| } |
| |
| public Raster getData() { |
| int w = raster.getWidth(); |
| int h = raster.getHeight(); |
| int minX = raster.getMinX(); |
| int minY = raster.getMinY(); |
| |
| WritableRaster outr = Raster.createWritableRaster( |
| raster.getSampleModel(), |
| new Point(raster.getSampleModelTranslateX(), |
| raster.getSampleModelTranslateY())); |
| |
| Object data = null; |
| |
| data = raster.getDataElements(minX, minY, w, h, data); |
| outr.setDataElements(minX, minY, w, h, data); |
| |
| return outr; |
| } |
| |
| @Override |
| public ImageProducer getSource() { |
| return new BufferedImageSource(this, properties); |
| } |
| |
| @Override |
| public int getWidth(ImageObserver observer) { |
| return raster.getWidth(); |
| } |
| |
| @Override |
| public int getHeight(ImageObserver observer) { |
| return raster.getHeight(); |
| } |
| |
| public ColorModel getColorModel() { |
| return cm; |
| } |
| |
| /** |
| * Gets the rectangular area of this BufferedImage as a subimage. |
| * |
| * @param x the x coordinate. |
| * @param y the y coordinate. |
| * @param w the width of the subimage. |
| * @param h the height of the subimage. |
| * |
| * @return the BufferedImage. |
| */ |
| public BufferedImage getSubimage(int x, int y, int w, int h) { |
| WritableRaster wr = raster.createWritableChild(x, y, w, h, 0, 0, null); |
| return new BufferedImage(cm, wr, cm.isAlphaPremultiplied(), properties); |
| } |
| |
| public Point[] getWritableTileIndices() { |
| Point points[] = new Point[1]; |
| points[0] = new Point(0, 0); |
| return points; |
| } |
| |
| /** |
| * Creates the Graphics2D object which allows to draw into |
| * this BufferedImage. |
| * |
| * @return the graphics2D object. |
| */ |
| public Graphics2D createGraphics() { |
| GraphicsEnvironment ge = |
| GraphicsEnvironment.getLocalGraphicsEnvironment(); |
| //return ge.createGraphics(this); |
| //???AWT hack, FIXME |
| //return AndroidGraphics2D.getInstance(); |
| //throw new RuntimeException("Not implemented!"); |
| return null; |
| } |
| |
| @Override |
| public Graphics getGraphics() { |
| return createGraphics(); |
| } |
| |
| /** |
| * Coerces the data to achieve the state which is specified by |
| * the isAlphaPremultiplied variable. |
| * |
| * @param isAlphaPremultiplied the is alpha premultiplied state. |
| */ |
| public void coerceData(boolean isAlphaPremultiplied) { |
| if (cm.hasAlpha() && |
| cm.isAlphaPremultiplied() != isAlphaPremultiplied) { |
| cm = cm.coerceData(raster, isAlphaPremultiplied); |
| } |
| } |
| |
| /** |
| * Gets an array of colors in the TYPE_INT_ARGB color model and |
| * default sRGB colorspace of the specified area of this |
| * BufferedImage. The result array is composed by the following |
| * algirithm: |
| * <p> |
| * pixel = rgbArray[offset + (y-startY)*scansize + (x-startX)] |
| * |
| * @param startX the start X area coordinate. |
| * @param startY the start Y area coordinate. |
| * @param w the width of the area. |
| * @param h the height of the area. |
| * @param rgbArray the result array will be stored to this array. |
| * @param offset the offset of the rgbArray array. |
| * @param scansize the scanline stride for the rgbArray. |
| * |
| * @return an array of colors for the specified area. |
| */ |
| public int[] getRGB(int startX, int startY, int w, int h, int[] rgbArray, |
| int offset, int scansize) { |
| if (rgbArray == null) { |
| rgbArray = new int[offset + h * scansize]; |
| } |
| |
| int off = offset; |
| for (int y = startY; y < startY + h; y++, off += scansize) { |
| int i = off; |
| for (int x = startX; x < startX + w; x++, i++) { |
| rgbArray[i] = cm.getRGB(raster.getDataElements(x, y, null)); |
| } |
| } |
| return rgbArray; |
| } |
| |
| /** |
| * Sets RGB values from the specified array to the specified |
| * BufferedImage area. The pixels are in the default RGB color model |
| * (TYPE_INT_ARGB) and default sRGB color space. |
| * |
| * @param startX the start X coordinate. |
| * @param startY the start Y coordinate. |
| * @param w the width of the BufferedImage area. |
| * @param h the height of the BufferedImage area. |
| * @param rgbArray the array of RGB values. |
| * @param offset the offset of the rgbArray array. |
| * @param scansize the scanline stride for the rgbArray. |
| */ |
| public void setRGB(int startX, int startY, int w, int h, int[] rgbArray, |
| int offset, int scansize) { |
| int off = offset; |
| for (int y = startY; y < startY + h; y++, off += scansize) { |
| int i = off; |
| for (int x = startX; x < startX + w; x++, i++) { |
| raster.setDataElements(x, y, |
| cm.getDataElements(rgbArray[i], null)); |
| } |
| } |
| } |
| |
| /** |
| * Sets a the specified RGB value to the specified pixel of |
| * this BufferedImage. The pixel should be in the default |
| * RGB color model (TYPE_INT_ARGB) and default sRGB color space. |
| * |
| * @param x the X coordinate of the pixel. |
| * @param y the Y coordinate of the pixel. |
| * @param rgb the RGB value to be set. |
| */ |
| public synchronized void setRGB(int x, int y, int rgb) { |
| raster.setDataElements(x, y, cm.getDataElements(rgb, null)); |
| } |
| |
| public boolean isTileWritable(int tileX, int tileY) { |
| if (tileX == 0 && tileY == 0) { |
| return true; |
| } |
| // awt.226=Both tileX and tileY are not equal to 0 |
| throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.226")); //$NON-NLS-1$ |
| } |
| |
| public void releaseWritableTile(int tileX, int tileY) { |
| } |
| |
| /** |
| * Gets a color in the TYPE_INT_ARGB color model and default |
| * sRGB colorspace of the specified pixel. |
| * |
| * @param x the X coordinate of the pixel. |
| * @param y the Y coordinate of the pixel. |
| * |
| * @return the color of the specified pixel in the TYPE_INT_ARGB |
| * color model and default sRGB colorspace. |
| */ |
| public int getRGB(int x, int y) { |
| return cm.getRGB(raster.getDataElements(x, y, null)); |
| } |
| |
| /** |
| * Returnes true if alpha is premultiplied, |
| * false if alpha is not premultiplied or there is no alpha. |
| * |
| * @return true if alpha is premultiplied, |
| * false if alpha is not premultiplied or there is no alpha. |
| */ |
| public boolean isAlphaPremultiplied() { |
| return cm.isAlphaPremultiplied(); |
| } |
| |
| public boolean hasTileWriters() { |
| return true; |
| } |
| |
| @Override |
| public void flush() { |
| imageSurf.dispose(); |
| } |
| |
| public int getWidth() { |
| return raster.getWidth(); |
| } |
| |
| /** |
| * Gets the image type. |
| * |
| * @return the image type. |
| */ |
| public int getType() { |
| return imageType; |
| } |
| |
| public int getTileWidth() { |
| return raster.getWidth(); |
| } |
| |
| public int getTileHeight() { |
| return raster.getHeight(); |
| } |
| |
| public int getTileGridYOffset() { |
| return raster.getSampleModelTranslateY(); |
| } |
| |
| public int getTileGridXOffset() { |
| return raster.getSampleModelTranslateX(); |
| } |
| |
| public int getNumYTiles() { |
| return 1; |
| } |
| |
| public int getNumXTiles() { |
| return 1; |
| } |
| |
| public int getMinY() { |
| return raster.getMinY(); |
| } |
| |
| public int getMinX() { |
| return raster.getMinX(); |
| } |
| |
| public int getMinTileY() { |
| return 0; |
| } |
| |
| public int getMinTileX() { |
| return 0; |
| } |
| |
| public int getHeight() { |
| return raster.getHeight(); |
| } |
| |
| /** |
| * Creates the image surface. |
| * |
| * @param type the type |
| * |
| * @return the image surface |
| */ |
| private ImageSurface createImageSurface(int type) { |
| return new ImageSurface(getColorModel(), getRaster(), type); |
| } |
| |
| /** |
| * Gets the image surface. |
| * |
| * @return the image surface |
| */ |
| ImageSurface getImageSurface() { |
| return imageSurf; |
| } |
| |
| public int getTransparency() { |
| return cm.getTransparency(); |
| } |
| } |
| |