You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
673 lines
24 KiB
673 lines
24 KiB
/*
|
|
* Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package java.awt.image;
|
|
|
|
import java.util.Hashtable;
|
|
import java.awt.image.ImageProducer;
|
|
import java.awt.image.ImageConsumer;
|
|
import java.awt.image.ColorModel;
|
|
import java.awt.Image;
|
|
|
|
/**
|
|
* The PixelGrabber class implements an ImageConsumer which can be attached
|
|
* to an Image or ImageProducer object to retrieve a subset of the pixels
|
|
* in that image. Here is an example:
|
|
* <pre>{@code
|
|
*
|
|
* public void handlesinglepixel(int x, int y, int pixel) {
|
|
* int alpha = (pixel >> 24) & 0xff;
|
|
* int red = (pixel >> 16) & 0xff;
|
|
* int green = (pixel >> 8) & 0xff;
|
|
* int blue = (pixel ) & 0xff;
|
|
* // Deal with the pixel as necessary...
|
|
* }
|
|
*
|
|
* public void handlepixels(Image img, int x, int y, int w, int h) {
|
|
* int[] pixels = new int[w * h];
|
|
* PixelGrabber pg = new PixelGrabber(img, x, y, w, h, pixels, 0, w);
|
|
* try {
|
|
* pg.grabPixels();
|
|
* } catch (InterruptedException e) {
|
|
* System.err.println("interrupted waiting for pixels!");
|
|
* return;
|
|
* }
|
|
* if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
|
|
* System.err.println("image fetch aborted or errored");
|
|
* return;
|
|
* }
|
|
* for (int j = 0; j < h; j++) {
|
|
* for (int i = 0; i < w; i++) {
|
|
* handlesinglepixel(x+i, y+j, pixels[j * w + i]);
|
|
* }
|
|
* }
|
|
* }
|
|
*
|
|
* }</pre>
|
|
*
|
|
* @see ColorModel#getRGBdefault
|
|
*
|
|
* @author Jim Graham
|
|
*/
|
|
public class PixelGrabber implements ImageConsumer {
|
|
ImageProducer producer;
|
|
|
|
int dstX;
|
|
int dstY;
|
|
int dstW;
|
|
int dstH;
|
|
|
|
ColorModel imageModel;
|
|
byte[] bytePixels;
|
|
int[] intPixels;
|
|
int dstOff;
|
|
int dstScan;
|
|
|
|
private boolean grabbing;
|
|
private int flags;
|
|
|
|
private static final int GRABBEDBITS = (ImageObserver.FRAMEBITS
|
|
| ImageObserver.ALLBITS);
|
|
private static final int DONEBITS = (GRABBEDBITS
|
|
| ImageObserver.ERROR);
|
|
|
|
/**
|
|
* Create a PixelGrabber object to grab the (x, y, w, h) rectangular
|
|
* section of pixels from the specified image into the given array.
|
|
* The pixels are stored into the array in the default RGB ColorModel.
|
|
* The RGB data for pixel (i, j) where (i, j) is inside the rectangle
|
|
* (x, y, w, h) is stored in the array at
|
|
* <tt>pix[(j - y) * scansize + (i - x) + off]</tt>.
|
|
* @see ColorModel#getRGBdefault
|
|
* @param img the image to retrieve pixels from
|
|
* @param x the x coordinate of the upper left corner of the rectangle
|
|
* of pixels to retrieve from the image, relative to the default
|
|
* (unscaled) size of the image
|
|
* @param y the y coordinate of the upper left corner of the rectangle
|
|
* of pixels to retrieve from the image
|
|
* @param w the width of the rectangle of pixels to retrieve
|
|
* @param h the height of the rectangle of pixels to retrieve
|
|
* @param pix the array of integers which are to be used to hold the
|
|
* RGB pixels retrieved from the image
|
|
* @param off the offset into the array of where to store the first pixel
|
|
* @param scansize the distance from one row of pixels to the next in
|
|
* the array
|
|
*/
|
|
public PixelGrabber(Image img, int x, int y, int w, int h,
|
|
int[] pix, int off, int scansize) {
|
|
this(img.getSource(), x, y, w, h, pix, off, scansize);
|
|
}
|
|
|
|
/**
|
|
* Create a PixelGrabber object to grab the (x, y, w, h) rectangular
|
|
* section of pixels from the image produced by the specified
|
|
* ImageProducer into the given array.
|
|
* The pixels are stored into the array in the default RGB ColorModel.
|
|
* The RGB data for pixel (i, j) where (i, j) is inside the rectangle
|
|
* (x, y, w, h) is stored in the array at
|
|
* <tt>pix[(j - y) * scansize + (i - x) + off]</tt>.
|
|
* @param ip the <code>ImageProducer</code> that produces the
|
|
* image from which to retrieve pixels
|
|
* @param x the x coordinate of the upper left corner of the rectangle
|
|
* of pixels to retrieve from the image, relative to the default
|
|
* (unscaled) size of the image
|
|
* @param y the y coordinate of the upper left corner of the rectangle
|
|
* of pixels to retrieve from the image
|
|
* @param w the width of the rectangle of pixels to retrieve
|
|
* @param h the height of the rectangle of pixels to retrieve
|
|
* @param pix the array of integers which are to be used to hold the
|
|
* RGB pixels retrieved from the image
|
|
* @param off the offset into the array of where to store the first pixel
|
|
* @param scansize the distance from one row of pixels to the next in
|
|
* the array
|
|
* @see ColorModel#getRGBdefault
|
|
*/
|
|
public PixelGrabber(ImageProducer ip, int x, int y, int w, int h,
|
|
int[] pix, int off, int scansize) {
|
|
producer = ip;
|
|
dstX = x;
|
|
dstY = y;
|
|
dstW = w;
|
|
dstH = h;
|
|
dstOff = off;
|
|
dstScan = scansize;
|
|
intPixels = pix;
|
|
imageModel = ColorModel.getRGBdefault();
|
|
}
|
|
|
|
/**
|
|
* Create a PixelGrabber object to grab the (x, y, w, h) rectangular
|
|
* section of pixels from the specified image. The pixels are
|
|
* accumulated in the original ColorModel if the same ColorModel
|
|
* is used for every call to setPixels, otherwise the pixels are
|
|
* accumulated in the default RGB ColorModel. If the forceRGB
|
|
* parameter is true, then the pixels will be accumulated in the
|
|
* default RGB ColorModel anyway. A buffer is allocated by the
|
|
* PixelGrabber to hold the pixels in either case. If {@code (w < 0)} or
|
|
* {@code (h < 0)}, then they will default to the remaining width and
|
|
* height of the source data when that information is delivered.
|
|
* @param img the image to retrieve the image data from
|
|
* @param x the x coordinate of the upper left corner of the rectangle
|
|
* of pixels to retrieve from the image, relative to the default
|
|
* (unscaled) size of the image
|
|
* @param y the y coordinate of the upper left corner of the rectangle
|
|
* of pixels to retrieve from the image
|
|
* @param w the width of the rectangle of pixels to retrieve
|
|
* @param h the height of the rectangle of pixels to retrieve
|
|
* @param forceRGB true if the pixels should always be converted to
|
|
* the default RGB ColorModel
|
|
*/
|
|
public PixelGrabber(Image img, int x, int y, int w, int h,
|
|
boolean forceRGB)
|
|
{
|
|
producer = img.getSource();
|
|
dstX = x;
|
|
dstY = y;
|
|
dstW = w;
|
|
dstH = h;
|
|
if (forceRGB) {
|
|
imageModel = ColorModel.getRGBdefault();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Request the PixelGrabber to start fetching the pixels.
|
|
*/
|
|
public synchronized void startGrabbing() {
|
|
if ((flags & DONEBITS) != 0) {
|
|
return;
|
|
}
|
|
if (!grabbing) {
|
|
grabbing = true;
|
|
flags &= ~(ImageObserver.ABORT);
|
|
producer.startProduction(this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Request the PixelGrabber to abort the image fetch.
|
|
*/
|
|
public synchronized void abortGrabbing() {
|
|
imageComplete(IMAGEABORTED);
|
|
}
|
|
|
|
/**
|
|
* Request the Image or ImageProducer to start delivering pixels and
|
|
* wait for all of the pixels in the rectangle of interest to be
|
|
* delivered.
|
|
* @return true if the pixels were successfully grabbed, false on
|
|
* abort, error or timeout
|
|
* @exception InterruptedException
|
|
* Another thread has interrupted this thread.
|
|
*/
|
|
public boolean grabPixels() throws InterruptedException {
|
|
return grabPixels(0);
|
|
}
|
|
|
|
/**
|
|
* Request the Image or ImageProducer to start delivering pixels and
|
|
* wait for all of the pixels in the rectangle of interest to be
|
|
* delivered or until the specified timeout has elapsed. This method
|
|
* behaves in the following ways, depending on the value of
|
|
* <code>ms</code>:
|
|
* <ul>
|
|
* <li> If {@code ms == 0}, waits until all pixels are delivered
|
|
* <li> If {@code ms > 0}, waits until all pixels are delivered
|
|
* as timeout expires.
|
|
* <li> If {@code ms < 0}, returns <code>true</code> if all pixels
|
|
* are grabbed, <code>false</code> otherwise and does not wait.
|
|
* </ul>
|
|
* @param ms the number of milliseconds to wait for the image pixels
|
|
* to arrive before timing out
|
|
* @return true if the pixels were successfully grabbed, false on
|
|
* abort, error or timeout
|
|
* @exception InterruptedException
|
|
* Another thread has interrupted this thread.
|
|
*/
|
|
public synchronized boolean grabPixels(long ms)
|
|
throws InterruptedException
|
|
{
|
|
if ((flags & DONEBITS) != 0) {
|
|
return (flags & GRABBEDBITS) != 0;
|
|
}
|
|
long end = ms + System.currentTimeMillis();
|
|
if (!grabbing) {
|
|
grabbing = true;
|
|
flags &= ~(ImageObserver.ABORT);
|
|
producer.startProduction(this);
|
|
}
|
|
while (grabbing) {
|
|
long timeout;
|
|
if (ms == 0) {
|
|
timeout = 0;
|
|
} else {
|
|
timeout = end - System.currentTimeMillis();
|
|
if (timeout <= 0) {
|
|
break;
|
|
}
|
|
}
|
|
wait(timeout);
|
|
}
|
|
return (flags & GRABBEDBITS) != 0;
|
|
}
|
|
|
|
/**
|
|
* Return the status of the pixels. The ImageObserver flags
|
|
* representing the available pixel information are returned.
|
|
* @return the bitwise OR of all relevant ImageObserver flags
|
|
* @see ImageObserver
|
|
*/
|
|
public synchronized int getStatus() {
|
|
return flags;
|
|
}
|
|
|
|
/**
|
|
* Get the width of the pixel buffer (after adjusting for image width).
|
|
* If no width was specified for the rectangle of pixels to grab then
|
|
* then this information will only be available after the image has
|
|
* delivered the dimensions.
|
|
* @return the final width used for the pixel buffer or -1 if the width
|
|
* is not yet known
|
|
* @see #getStatus
|
|
*/
|
|
public synchronized int getWidth() {
|
|
return (dstW < 0) ? -1 : dstW;
|
|
}
|
|
|
|
/**
|
|
* Get the height of the pixel buffer (after adjusting for image height).
|
|
* If no width was specified for the rectangle of pixels to grab then
|
|
* then this information will only be available after the image has
|
|
* delivered the dimensions.
|
|
* @return the final height used for the pixel buffer or -1 if the height
|
|
* is not yet known
|
|
* @see #getStatus
|
|
*/
|
|
public synchronized int getHeight() {
|
|
return (dstH < 0) ? -1 : dstH;
|
|
}
|
|
|
|
/**
|
|
* Get the pixel buffer. If the PixelGrabber was not constructed
|
|
* with an explicit pixel buffer to hold the pixels then this method
|
|
* will return null until the size and format of the image data is
|
|
* known.
|
|
* Since the PixelGrabber may fall back on accumulating the data
|
|
* in the default RGB ColorModel at any time if the source image
|
|
* uses more than one ColorModel to deliver the data, the array
|
|
* object returned by this method may change over time until the
|
|
* image grab is complete.
|
|
* @return either a byte array or an int array
|
|
* @see #getStatus
|
|
* @see #setPixels(int, int, int, int, ColorModel, byte[], int, int)
|
|
* @see #setPixels(int, int, int, int, ColorModel, int[], int, int)
|
|
*/
|
|
public synchronized Object getPixels() {
|
|
return (bytePixels == null)
|
|
? ((Object) intPixels)
|
|
: ((Object) bytePixels);
|
|
}
|
|
|
|
/**
|
|
* Get the ColorModel for the pixels stored in the array. If the
|
|
* PixelGrabber was constructed with an explicit pixel buffer then
|
|
* this method will always return the default RGB ColorModel,
|
|
* otherwise it may return null until the ColorModel used by the
|
|
* ImageProducer is known.
|
|
* Since the PixelGrabber may fall back on accumulating the data
|
|
* in the default RGB ColorModel at any time if the source image
|
|
* uses more than one ColorModel to deliver the data, the ColorModel
|
|
* object returned by this method may change over time until the
|
|
* image grab is complete and may not reflect any of the ColorModel
|
|
* objects that was used by the ImageProducer to deliver the pixels.
|
|
* @return the ColorModel object used for storing the pixels
|
|
* @see #getStatus
|
|
* @see ColorModel#getRGBdefault
|
|
* @see #setColorModel(ColorModel)
|
|
*/
|
|
public synchronized ColorModel getColorModel() {
|
|
return imageModel;
|
|
}
|
|
|
|
/**
|
|
* The setDimensions method is part of the ImageConsumer API which
|
|
* this class must implement to retrieve the pixels.
|
|
* <p>
|
|
* Note: This method is intended to be called by the ImageProducer
|
|
* of the Image whose pixels are being grabbed. Developers using
|
|
* this class to retrieve pixels from an image should avoid calling
|
|
* this method directly since that operation could result in problems
|
|
* with retrieving the requested pixels.
|
|
* @param width the width of the dimension
|
|
* @param height the height of the dimension
|
|
*/
|
|
public void setDimensions(int width, int height) {
|
|
if (dstW < 0) {
|
|
dstW = width - dstX;
|
|
}
|
|
if (dstH < 0) {
|
|
dstH = height - dstY;
|
|
}
|
|
if (dstW <= 0 || dstH <= 0) {
|
|
imageComplete(STATICIMAGEDONE);
|
|
} else if (intPixels == null &&
|
|
imageModel == ColorModel.getRGBdefault()) {
|
|
intPixels = new int[dstW * dstH];
|
|
dstScan = dstW;
|
|
dstOff = 0;
|
|
}
|
|
flags |= (ImageObserver.WIDTH | ImageObserver.HEIGHT);
|
|
}
|
|
|
|
/**
|
|
* The setHints method is part of the ImageConsumer API which
|
|
* this class must implement to retrieve the pixels.
|
|
* <p>
|
|
* Note: This method is intended to be called by the ImageProducer
|
|
* of the Image whose pixels are being grabbed. Developers using
|
|
* this class to retrieve pixels from an image should avoid calling
|
|
* this method directly since that operation could result in problems
|
|
* with retrieving the requested pixels.
|
|
* @param hints a set of hints used to process the pixels
|
|
*/
|
|
public void setHints(int hints) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* The setProperties method is part of the ImageConsumer API which
|
|
* this class must implement to retrieve the pixels.
|
|
* <p>
|
|
* Note: This method is intended to be called by the ImageProducer
|
|
* of the Image whose pixels are being grabbed. Developers using
|
|
* this class to retrieve pixels from an image should avoid calling
|
|
* this method directly since that operation could result in problems
|
|
* with retrieving the requested pixels.
|
|
* @param props the list of properties
|
|
*/
|
|
public void setProperties(Hashtable<?,?> props) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* The setColorModel method is part of the ImageConsumer API which
|
|
* this class must implement to retrieve the pixels.
|
|
* <p>
|
|
* Note: This method is intended to be called by the ImageProducer
|
|
* of the Image whose pixels are being grabbed. Developers using
|
|
* this class to retrieve pixels from an image should avoid calling
|
|
* this method directly since that operation could result in problems
|
|
* with retrieving the requested pixels.
|
|
* @param model the specified <code>ColorModel</code>
|
|
* @see #getColorModel
|
|
*/
|
|
public void setColorModel(ColorModel model) {
|
|
return;
|
|
}
|
|
|
|
private void convertToRGB() {
|
|
int size = dstW * dstH;
|
|
int newpixels[] = new int[size];
|
|
if (bytePixels != null) {
|
|
for (int i = 0; i < size; i++) {
|
|
newpixels[i] = imageModel.getRGB(bytePixels[i] & 0xff);
|
|
}
|
|
} else if (intPixels != null) {
|
|
for (int i = 0; i < size; i++) {
|
|
newpixels[i] = imageModel.getRGB(intPixels[i]);
|
|
}
|
|
}
|
|
bytePixels = null;
|
|
intPixels = newpixels;
|
|
dstScan = dstW;
|
|
dstOff = 0;
|
|
imageModel = ColorModel.getRGBdefault();
|
|
}
|
|
|
|
/**
|
|
* The setPixels method is part of the ImageConsumer API which
|
|
* this class must implement to retrieve the pixels.
|
|
* <p>
|
|
* Note: This method is intended to be called by the ImageProducer
|
|
* of the Image whose pixels are being grabbed. Developers using
|
|
* this class to retrieve pixels from an image should avoid calling
|
|
* this method directly since that operation could result in problems
|
|
* with retrieving the requested pixels.
|
|
* @param srcX the X coordinate of the upper-left corner
|
|
* of the area of pixels to be set
|
|
* @param srcY the Y coordinate of the upper-left corner
|
|
* of the area of pixels to be set
|
|
* @param srcW the width of the area of pixels
|
|
* @param srcH the height of the area of pixels
|
|
* @param model the specified <code>ColorModel</code>
|
|
* @param pixels the array of pixels
|
|
* @param srcOff the offset into the pixels array
|
|
* @param srcScan the distance from one row of pixels to the next
|
|
* in the pixels array
|
|
* @see #getPixels
|
|
*/
|
|
public void setPixels(int srcX, int srcY, int srcW, int srcH,
|
|
ColorModel model,
|
|
byte pixels[], int srcOff, int srcScan) {
|
|
if (srcY < dstY) {
|
|
int diff = dstY - srcY;
|
|
if (diff >= srcH) {
|
|
return;
|
|
}
|
|
srcOff += srcScan * diff;
|
|
srcY += diff;
|
|
srcH -= diff;
|
|
}
|
|
if (srcY + srcH > dstY + dstH) {
|
|
srcH = (dstY + dstH) - srcY;
|
|
if (srcH <= 0) {
|
|
return;
|
|
}
|
|
}
|
|
if (srcX < dstX) {
|
|
int diff = dstX - srcX;
|
|
if (diff >= srcW) {
|
|
return;
|
|
}
|
|
srcOff += diff;
|
|
srcX += diff;
|
|
srcW -= diff;
|
|
}
|
|
if (srcX + srcW > dstX + dstW) {
|
|
srcW = (dstX + dstW) - srcX;
|
|
if (srcW <= 0) {
|
|
return;
|
|
}
|
|
}
|
|
int dstPtr = dstOff + (srcY - dstY) * dstScan + (srcX - dstX);
|
|
if (intPixels == null) {
|
|
if (bytePixels == null) {
|
|
bytePixels = new byte[dstW * dstH];
|
|
dstScan = dstW;
|
|
dstOff = 0;
|
|
imageModel = model;
|
|
} else if (imageModel != model) {
|
|
convertToRGB();
|
|
}
|
|
if (bytePixels != null) {
|
|
for (int h = srcH; h > 0; h--) {
|
|
System.arraycopy(pixels, srcOff, bytePixels, dstPtr, srcW);
|
|
srcOff += srcScan;
|
|
dstPtr += dstScan;
|
|
}
|
|
}
|
|
}
|
|
if (intPixels != null) {
|
|
int dstRem = dstScan - srcW;
|
|
int srcRem = srcScan - srcW;
|
|
for (int h = srcH; h > 0; h--) {
|
|
for (int w = srcW; w > 0; w--) {
|
|
intPixels[dstPtr++] = model.getRGB(pixels[srcOff++]&0xff);
|
|
}
|
|
srcOff += srcRem;
|
|
dstPtr += dstRem;
|
|
}
|
|
}
|
|
flags |= ImageObserver.SOMEBITS;
|
|
}
|
|
|
|
/**
|
|
* The setPixels method is part of the ImageConsumer API which
|
|
* this class must implement to retrieve the pixels.
|
|
* <p>
|
|
* Note: This method is intended to be called by the ImageProducer
|
|
* of the Image whose pixels are being grabbed. Developers using
|
|
* this class to retrieve pixels from an image should avoid calling
|
|
* this method directly since that operation could result in problems
|
|
* with retrieving the requested pixels.
|
|
* @param srcX the X coordinate of the upper-left corner
|
|
* of the area of pixels to be set
|
|
* @param srcY the Y coordinate of the upper-left corner
|
|
* of the area of pixels to be set
|
|
* @param srcW the width of the area of pixels
|
|
* @param srcH the height of the area of pixels
|
|
* @param model the specified <code>ColorModel</code>
|
|
* @param pixels the array of pixels
|
|
* @param srcOff the offset into the pixels array
|
|
* @param srcScan the distance from one row of pixels to the next
|
|
* in the pixels array
|
|
* @see #getPixels
|
|
*/
|
|
public void setPixels(int srcX, int srcY, int srcW, int srcH,
|
|
ColorModel model,
|
|
int pixels[], int srcOff, int srcScan) {
|
|
if (srcY < dstY) {
|
|
int diff = dstY - srcY;
|
|
if (diff >= srcH) {
|
|
return;
|
|
}
|
|
srcOff += srcScan * diff;
|
|
srcY += diff;
|
|
srcH -= diff;
|
|
}
|
|
if (srcY + srcH > dstY + dstH) {
|
|
srcH = (dstY + dstH) - srcY;
|
|
if (srcH <= 0) {
|
|
return;
|
|
}
|
|
}
|
|
if (srcX < dstX) {
|
|
int diff = dstX - srcX;
|
|
if (diff >= srcW) {
|
|
return;
|
|
}
|
|
srcOff += diff;
|
|
srcX += diff;
|
|
srcW -= diff;
|
|
}
|
|
if (srcX + srcW > dstX + dstW) {
|
|
srcW = (dstX + dstW) - srcX;
|
|
if (srcW <= 0) {
|
|
return;
|
|
}
|
|
}
|
|
if (intPixels == null) {
|
|
if (bytePixels == null) {
|
|
intPixels = new int[dstW * dstH];
|
|
dstScan = dstW;
|
|
dstOff = 0;
|
|
imageModel = model;
|
|
} else {
|
|
convertToRGB();
|
|
}
|
|
}
|
|
int dstPtr = dstOff + (srcY - dstY) * dstScan + (srcX - dstX);
|
|
if (imageModel == model) {
|
|
for (int h = srcH; h > 0; h--) {
|
|
System.arraycopy(pixels, srcOff, intPixels, dstPtr, srcW);
|
|
srcOff += srcScan;
|
|
dstPtr += dstScan;
|
|
}
|
|
} else {
|
|
if (imageModel != ColorModel.getRGBdefault()) {
|
|
convertToRGB();
|
|
}
|
|
int dstRem = dstScan - srcW;
|
|
int srcRem = srcScan - srcW;
|
|
for (int h = srcH; h > 0; h--) {
|
|
for (int w = srcW; w > 0; w--) {
|
|
intPixels[dstPtr++] = model.getRGB(pixels[srcOff++]);
|
|
}
|
|
srcOff += srcRem;
|
|
dstPtr += dstRem;
|
|
}
|
|
}
|
|
flags |= ImageObserver.SOMEBITS;
|
|
}
|
|
|
|
/**
|
|
* The imageComplete method is part of the ImageConsumer API which
|
|
* this class must implement to retrieve the pixels.
|
|
* <p>
|
|
* Note: This method is intended to be called by the ImageProducer
|
|
* of the Image whose pixels are being grabbed. Developers using
|
|
* this class to retrieve pixels from an image should avoid calling
|
|
* this method directly since that operation could result in problems
|
|
* with retrieving the requested pixels.
|
|
* @param status the status of image loading
|
|
*/
|
|
public synchronized void imageComplete(int status) {
|
|
grabbing = false;
|
|
switch (status) {
|
|
default:
|
|
case IMAGEERROR:
|
|
flags |= ImageObserver.ERROR | ImageObserver.ABORT;
|
|
break;
|
|
case IMAGEABORTED:
|
|
flags |= ImageObserver.ABORT;
|
|
break;
|
|
case STATICIMAGEDONE:
|
|
flags |= ImageObserver.ALLBITS;
|
|
break;
|
|
case SINGLEFRAMEDONE:
|
|
flags |= ImageObserver.FRAMEBITS;
|
|
break;
|
|
}
|
|
producer.removeConsumer(this);
|
|
notifyAll();
|
|
}
|
|
|
|
/**
|
|
* Returns the status of the pixels. The ImageObserver flags
|
|
* representing the available pixel information are returned.
|
|
* This method and {@link #getStatus() getStatus} have the
|
|
* same implementation, but <code>getStatus</code> is the
|
|
* preferred method because it conforms to the convention of
|
|
* naming information-retrieval methods with the form
|
|
* "getXXX".
|
|
* @return the bitwise OR of all relevant ImageObserver flags
|
|
* @see ImageObserver
|
|
* @see #getStatus()
|
|
*/
|
|
public synchronized int status() {
|
|
return flags;
|
|
}
|
|
}
|