953 lines
29 KiB
Java
953 lines
29 KiB
Java
/*
|
|
* 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.
|
|
*
|
|
* @since Android 1.0
|
|
*/
|
|
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
|
|
* pre-multiplied 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 pre-multiplied 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 pre-multiplied 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 pre-multiplied 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
|
|
* color space of the specified area of this BufferedImage. The result array
|
|
* is composed by the following algorithm:
|
|
* <p>
|
|
* pixel = rgbArray[offset + (y-startY)*scansize + (x-startX)]
|
|
* </p>
|
|
*
|
|
* @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 color
|
|
* space 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 color space.
|
|
*/
|
|
public int getRGB(int x, int y) {
|
|
return cm.getRGB(raster.getDataElements(x, y, null));
|
|
}
|
|
|
|
/**
|
|
* Returns true if alpha is pre-multiplied, false if alpha is not
|
|
* pre-multiplied or there is no alpha.
|
|
*
|
|
* @return true if alpha is pre-multiplied, false if alpha is not
|
|
* pre-multiplied 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();
|
|
}
|
|
}
|