java.awt.image.ImageConsumer Java Examples

private void initConsumer(ImageConsumer ic) {
    if (isConsumer(ic)) {
        ic.setDimensions(width, height);
    }
    if (isConsumer(ic)) {
        ic.setProperties(properties);
    }
    if (isConsumer(ic)) {
        ic.setColorModel(model);
    }
    if (isConsumer(ic)) {
        ic.setHints(animating
                    ? (fullbuffers
                       ? (ImageConsumer.TOPDOWNLEFTRIGHT |
                          ImageConsumer.COMPLETESCANLINES)
                       : ImageConsumer.RANDOMPIXELORDER)
                    : (ImageConsumer.TOPDOWNLEFTRIGHT |
                       ImageConsumer.COMPLETESCANLINES |
                       ImageConsumer.SINGLEPASS |
                       ImageConsumer.SINGLEFRAME));
    }
}
 

public void setDimensions(int w, int h) {
    if (src != null) {
        src.checkSecurity(null, false);
    }

    image.setDimensions(w, h);

    newInfo(image, (ImageObserver.WIDTH | ImageObserver.HEIGHT),
            0, 0, w, h);

    if (w <= 0 || h <= 0) {
        imageComplete(ImageConsumer.IMAGEERROR);
        return;
    }

    if (width != w || height != h) {
        // dimension mismatch => trigger recreation of the buffer
        bimage = null;
    }

    width = w;
    height = h;

    availinfo |= ImageObserver.WIDTH | ImageObserver.HEIGHT;
}
 

/**
 * Adds an ImageConsumer to the list of consumers interested in
 * data for this image.
 * @param ic the specified <code>ImageConsumer</code>
 * @throws NullPointerException if the specified
 *           <code>ImageConsumer</code> is null
 * @see ImageConsumer
 */
public synchronized void addConsumer(ImageConsumer ic) {
    if (theConsumers.contains(ic)) {
        return;
    }
    theConsumers.addElement(ic);
    try {
        initConsumer(ic);
        sendPixels(ic, 0, 0, width, height);
        if (isConsumer(ic)) {
            ic.imageComplete(animating
                             ? ImageConsumer.SINGLEFRAMEDONE
                             : ImageConsumer.STATICIMAGEDONE);
            if (!animating && isConsumer(ic)) {
                ic.imageComplete(ImageConsumer.IMAGEERROR);
                removeConsumer(ic);
            }
        }
    } catch (Exception e) {
        if (isConsumer(ic)) {
            ic.imageComplete(ImageConsumer.IMAGEERROR);
        }
    }
}
 

static ImageConsumerQueue removeConsumer(ImageConsumerQueue cqbase,
                                         ImageConsumer ic,
                                         boolean stillinterested)
{
    ImageConsumerQueue cqprev = null;
    for (ImageConsumerQueue cq = cqbase; cq != null; cq = cq.next) {
        if (cq.consumer == ic) {
            if (cqprev == null) {
                cqbase = cq.next;
            } else {
                cqprev.next = cq.next;
            }
            cq.interested = stillinterested;
            break;
        }
        cqprev = cq;
    }
    return cqbase;
}
 

static ImageConsumerQueue removeConsumer(ImageConsumerQueue cqbase,
                                         ImageConsumer ic,
                                         boolean stillinterested)
{
    ImageConsumerQueue cqprev = null;
    for (ImageConsumerQueue cq = cqbase; cq != null; cq = cq.next) {
        if (cq.consumer == ic) {
            if (cqprev == null) {
                cqbase = cq.next;
            } else {
                cqprev.next = cq.next;
            }
            cq.interested = stillinterested;
            break;
        }
        cqprev = cq;
    }
    return cqbase;
}
 

ImageConsumerQueue(InputStreamImageSource src, ImageConsumer ic) {
    consumer = ic;
    interested = true;
    // ImageReps do their own security at access time.
    if (ic instanceof ImageRepresentation) {
        ImageRepresentation ir = (ImageRepresentation) ic;
        if (ir.image.source != src) {
            throw new SecurityException("ImageRep added to wrong image source");
        }
        secure = true;
    } else {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            securityContext = security.getSecurityContext();
        } else {
            securityContext = null;
        }
    }
}
 

/**
 * Specifies whether this animated memory image should always be
 * updated by sending the complete buffer of pixels whenever
 * there is a change.
 * This flag is ignored if the animation flag is not turned on
 * through the setAnimated() method.
 * <p>This method should be called immediately after the
 * MemoryImageSource is constructed and before an image is
 * created with it to ensure that all ImageConsumers will
 * receive the correct pixel delivery hints.
 * @param fullbuffers <code>true</code> if the complete pixel
 *             buffer should always
 * be sent
 * @see #setAnimated
 */
public synchronized void setFullBufferUpdates(boolean fullbuffers) {
    if (this.fullbuffers == fullbuffers) {
        return;
    }
    this.fullbuffers = fullbuffers;
    if (animating) {
        Enumeration enum_ = theConsumers.elements();
        while (enum_.hasMoreElements()) {
            ImageConsumer ic = (ImageConsumer) enum_.nextElement();
            ic.setHints(fullbuffers
                        ? (ImageConsumer.TOPDOWNLEFTRIGHT |
                           ImageConsumer.COMPLETESCANLINES)
                        : ImageConsumer.RANDOMPIXELORDER);
        }
    }
}
 

/**
 * Specifies whether this animated memory image should always be
 * updated by sending the complete buffer of pixels whenever
 * there is a change.
 * This flag is ignored if the animation flag is not turned on
 * through the setAnimated() method.
 * <p>This method should be called immediately after the
 * MemoryImageSource is constructed and before an image is
 * created with it to ensure that all ImageConsumers will
 * receive the correct pixel delivery hints.
 * @param fullbuffers <code>true</code> if the complete pixel
 *             buffer should always
 * be sent
 * @see #setAnimated
 */
public synchronized void setFullBufferUpdates(boolean fullbuffers) {
    if (this.fullbuffers == fullbuffers) {
        return;
    }
    this.fullbuffers = fullbuffers;
    if (animating) {
        Enumeration enum_ = theConsumers.elements();
        while (enum_.hasMoreElements()) {
            ImageConsumer ic = (ImageConsumer) enum_.nextElement();
            ic.setHints(fullbuffers
                        ? (ImageConsumer.TOPDOWNLEFTRIGHT |
                           ImageConsumer.COMPLETESCANLINES)
                        : ImageConsumer.RANDOMPIXELORDER);
        }
    }
}
 

ImageConsumerQueue(InputStreamImageSource src, ImageConsumer ic) {
    consumer = ic;
    interested = true;
    // ImageReps do their own security at access time.
    if (ic instanceof ImageRepresentation) {
        ImageRepresentation ir = (ImageRepresentation) ic;
        if (ir.image.source != src) {
            throw new SecurityException("ImageRep added to wrong image source");
        }
        secure = true;
    } else {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            securityContext = security.getSecurityContext();
        } else {
            securityContext = null;
        }
    }
}
 

public void setDimensions(int w, int h) {
    if (src != null) {
        src.checkSecurity(null, false);
    }

    image.setDimensions(w, h);

    newInfo(image, (ImageObserver.WIDTH | ImageObserver.HEIGHT),
            0, 0, w, h);

    if (w <= 0 || h <= 0) {
        imageComplete(ImageConsumer.IMAGEERROR);
        return;
    }

    if (width != w || height != h) {
        // dimension mismatch => trigger recreation of the buffer
        bimage = null;
    }

    width = w;
    height = h;

    availinfo |= ImageObserver.WIDTH | ImageObserver.HEIGHT;
}
 

/**
 * Specifies whether this animated memory image should always be
 * updated by sending the complete buffer of pixels whenever
 * there is a change.
 * This flag is ignored if the animation flag is not turned on
 * through the setAnimated() method.
 * <p>This method should be called immediately after the
 * MemoryImageSource is constructed and before an image is
 * created with it to ensure that all ImageConsumers will
 * receive the correct pixel delivery hints.
 * @param fullbuffers <code>true</code> if the complete pixel
 *             buffer should always
 * be sent
 * @see #setAnimated
 */
public synchronized void setFullBufferUpdates(boolean fullbuffers) {
    if (this.fullbuffers == fullbuffers) {
        return;
    }
    this.fullbuffers = fullbuffers;
    if (animating) {
        Enumeration enum_ = theConsumers.elements();
        while (enum_.hasMoreElements()) {
            ImageConsumer ic = (ImageConsumer) enum_.nextElement();
            ic.setHints(fullbuffers
                        ? (ImageConsumer.TOPDOWNLEFTRIGHT |
                           ImageConsumer.COMPLETESCANLINES)
                        : ImageConsumer.RANDOMPIXELORDER);
        }
    }
}
 

synchronized void infoDone(int status) {
    if (status == ImageConsumer.IMAGEERROR ||
        ((~availinfo) & (ImageObserver.WIDTH |
                         ImageObserver.HEIGHT)) != 0) {
        addInfo(ImageObserver.ERROR);
    } else if ((availinfo & ImageObserver.PROPERTIES) == 0) {
        setProperties(null);
    }
}
 

synchronized void infoDone(int status) {
    if (status == ImageConsumer.IMAGEERROR ||
        ((~availinfo) & (ImageObserver.WIDTH |
                         ImageObserver.HEIGHT)) != 0) {
        addInfo(ImageObserver.ERROR);
    } else if ((availinfo & ImageObserver.PROPERTIES) == 0) {
        setProperties(null);
    }
}
 

private void sendPixels(ImageConsumer ic, int x, int y, int w, int h) {
    int off = pixeloffset + pixelscan * y + x;
    if (isConsumer(ic)) {
        if (pixels instanceof byte[]) {
            ic.setPixels(x, y, w, h, model,
                         ((byte[]) pixels), off, pixelscan);
        } else {
            ic.setPixels(x, y, w, h, model,
                         ((int[]) pixels), off, pixelscan);
        }
    }
}
 

static boolean isConsumer(ImageConsumerQueue cqbase, ImageConsumer ic) {
    for (ImageConsumerQueue cq = cqbase; cq != null; cq = cq.next) {
        if (cq.consumer == ic) {
            return true;
        }
    }
    return false;
}
 

private void produce() {
    try {
        theConsumer.setDimensions(image.getWidth(), image.getHeight());
        theConsumer.setProperties(properties);
        sendPixels();
        theConsumer.imageComplete(ImageConsumer.SINGLEFRAMEDONE);
        theConsumer.imageComplete(ImageConsumer.STATICIMAGEDONE);
    } catch (NullPointerException e) {
        if (theConsumer != null) {
            theConsumer.imageComplete(ImageConsumer.IMAGEERROR);
        }
    }
}
 

static boolean isConsumer(ImageConsumerQueue cqbase, ImageConsumer ic) {
    for (ImageConsumerQueue cq = cqbase; cq != null; cq = cq.next) {
        if (cq.consumer == ic) {
            return true;
        }
    }
    return false;
}
 

synchronized void infoDone(int status) {
    if (status == ImageConsumer.IMAGEERROR ||
        ((~availinfo) & (ImageObserver.WIDTH |
                         ImageObserver.HEIGHT)) != 0) {
        addInfo(ImageObserver.ERROR);
    } else if ((availinfo & ImageObserver.PROPERTIES) == 0) {
        setProperties(null);
    }
}
 

private void produce() {
    try {
        theConsumer.setDimensions(image.getWidth(), image.getHeight());
        theConsumer.setProperties(properties);
        sendPixels();
        theConsumer.imageComplete(ImageConsumer.SINGLEFRAMEDONE);
        theConsumer.imageComplete(ImageConsumer.STATICIMAGEDONE);
    } catch (NullPointerException e) {
        if (theConsumer != null) {
            theConsumer.imageComplete(ImageConsumer.IMAGEERROR);
        }
    }
}
 

synchronized void infoDone(int status) {
    if (status == ImageConsumer.IMAGEERROR ||
        ((~availinfo) & (ImageObserver.WIDTH |
                         ImageObserver.HEIGHT)) != 0) {
        addInfo(ImageObserver.ERROR);
    } else if ((availinfo & ImageObserver.PROPERTIES) == 0) {
        setProperties(null);
    }
}
 

synchronized void infoDone(int status) {
    if (status == ImageConsumer.IMAGEERROR ||
        ((~availinfo) & (ImageObserver.WIDTH |
                         ImageObserver.HEIGHT)) != 0) {
        addInfo(ImageObserver.ERROR);
    } else if ((availinfo & ImageObserver.PROPERTIES) == 0) {
        setProperties(null);
    }
}
 

private void sendPixels(ImageConsumer ic, int x, int y, int w, int h) {
    int off = pixeloffset + pixelscan * y + x;
    if (isConsumer(ic)) {
        if (pixels instanceof byte[]) {
            ic.setPixels(x, y, w, h, model,
                         ((byte[]) pixels), off, pixelscan);
        } else {
            ic.setPixels(x, y, w, h, model,
                         ((int[]) pixels), off, pixelscan);
        }
    }
}
 

synchronized void infoDone(int status) {
    if (status == ImageConsumer.IMAGEERROR ||
        ((~availinfo) & (ImageObserver.WIDTH |
                         ImageObserver.HEIGHT)) != 0) {
        addInfo(ImageObserver.ERROR);
    } else if ((availinfo & ImageObserver.PROPERTIES) == 0) {
        setProperties(null);
    }
}
 

/**
 * Changes this memory image into a multi-frame animation or a
 * single-frame static image depending on the animated parameter.
 * <p>This method should be called immediately after the
 * MemoryImageSource is constructed and before an image is
 * created with it to ensure that all ImageConsumers will
 * receive the correct multi-frame data.  If an ImageConsumer
 * is added to this ImageProducer before this flag is set then
 * that ImageConsumer will see only a snapshot of the pixel
 * data that was available when it connected.
 * @param animated <code>true</code> if the image is a
 *       multi-frame animation
 */
public synchronized void setAnimated(boolean animated) {
    this.animating = animated;
    if (!animating) {
        Enumeration enum_ = theConsumers.elements();
        while (enum_.hasMoreElements()) {
            ImageConsumer ic = (ImageConsumer) enum_.nextElement();
            ic.imageComplete(ImageConsumer.STATICIMAGEDONE);
            if (isConsumer(ic)) {
                ic.imageComplete(ImageConsumer.IMAGEERROR);
            }
        }
        theConsumers.removeAllElements();
    }
}
 

synchronized void infoDone(int status) {
    if (status == ImageConsumer.IMAGEERROR ||
        ((~availinfo) & (ImageObserver.WIDTH |
                         ImageObserver.HEIGHT)) != 0) {
        addInfo(ImageObserver.ERROR);
    } else if ((availinfo & ImageObserver.PROPERTIES) == 0) {
        setProperties(null);
    }
}
 

/**
 * Sends a rectangular region of the buffer of pixels to any
 * ImageConsumers that are currently interested in the data for
 * this image.
 * If the framenotify parameter is true then the consumers are
 * also notified that an animation frame is complete.
 * This method only has effect if the animation flag has been
 * turned on through the setAnimated() method.
 * If the full buffer update flag was turned on with the
 * setFullBufferUpdates() method then the rectangle parameters
 * will be ignored and the entire buffer will always be sent.
 * @param x the x coordinate of the upper left corner of the rectangle
 * of pixels to be sent
 * @param y the y coordinate of the upper left corner of the rectangle
 * of pixels to be sent
 * @param w the width of the rectangle of pixels to be sent
 * @param h the height of the rectangle of pixels to be sent
 * @param framenotify <code>true</code> if the consumers should be sent a
 * {@link ImageConsumer#SINGLEFRAMEDONE SINGLEFRAMEDONE} notification
 * @see ImageConsumer
 * @see #setAnimated
 * @see #setFullBufferUpdates
 */
public synchronized void newPixels(int x, int y, int w, int h,
                                   boolean framenotify) {
    if (animating) {
        if (fullbuffers) {
            x = y = 0;
            w = width;
            h = height;
        } else {
            if (x < 0) {
                w += x;
                x = 0;
            }
            if (x + w > width) {
                w = width - x;
            }
            if (y < 0) {
                h += y;
                y = 0;
            }
            if (y + h > height) {
                h = height - y;
            }
        }
        if ((w <= 0 || h <= 0) && !framenotify) {
            return;
        }
        Enumeration enum_ = theConsumers.elements();
        while (enum_.hasMoreElements()) {
            ImageConsumer ic = (ImageConsumer) enum_.nextElement();
            if (w > 0 && h > 0) {
                sendPixels(ic, x, y, w, h);
            }
            if (framenotify && isConsumer(ic)) {
                ic.imageComplete(ImageConsumer.SINGLEFRAMEDONE);
            }
        }
    }
}
 

private void sendPixels(ImageConsumer ic, int x, int y, int w, int h) {
    int off = pixeloffset + pixelscan * y + x;
    if (isConsumer(ic)) {
        if (pixels instanceof byte[]) {
            ic.setPixels(x, y, w, h, model,
                         ((byte[]) pixels), off, pixelscan);
        } else {
            ic.setPixels(x, y, w, h, model,
                         ((int[]) pixels), off, pixelscan);
        }
    }
}
 

public void requestTopDownLeftRightResend(ImageConsumer ic) {
}
 

public synchronized void removeConsumer(ImageConsumer ic) {
    if (theConsumer == ic) {
        theConsumer = null;
    }
}
 

public synchronized void removeConsumer(ImageConsumer ic) {
    if (theConsumer == ic) {
        theConsumer = null;
    }
}