/** * 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); } } }
/** * 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); } } }
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)); } }
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; } } }
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; }
@Override public void setDimensions(int w, int h){ if (src != null) { src.checkSecurity(null, false); } image.setDimensions(w, h); // bitmap = new cli.System.Drawing.Bitmap(w, h); newInfo(image, (ImageObserver.WIDTH | ImageObserver.HEIGHT), 0, 0, w, h); if (w <= 0 || h <= 0) { imageComplete(ImageConsumer.IMAGEERROR); return; } 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} * @throws NullPointerException if the specified * {@code ImageConsumer} 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); } } }
/** * 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} 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<ImageConsumer> enum_ = theConsumers.elements(); while (enum_.hasMoreElements()) { ImageConsumer ic = enum_.nextElement(); ic.setHints(fullbuffers ? (ImageConsumer.TOPDOWNLEFTRIGHT | ImageConsumer.COMPLETESCANLINES) : ImageConsumer.RANDOMPIXELORDER); } } }
/** * 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(); } }
/** * 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); } } }
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); } } }
static boolean isConsumer(ImageConsumerQueue cqbase, ImageConsumer ic) { for (ImageConsumerQueue cq = cqbase; cq != null; cq = cq.next) { if (cq.consumer == ic) { return true; } } return false; }
/** * 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} if the image is a * multi-frame animation */ public synchronized void setAnimated(boolean animated) { this.animating = animated; if (!animating) { Enumeration<ImageConsumer> enum_ = theConsumers.elements(); while (enum_.hasMoreElements()) { ImageConsumer ic = enum_.nextElement(); ic.imageComplete(ImageConsumer.STATICIMAGEDONE); if (isConsumer(ic)) { ic.imageComplete(ImageConsumer.IMAGEERROR); } } theConsumers.removeAllElements(); } }
/** * 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} 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<ImageConsumer> enum_ = theConsumers.elements(); while (enum_.hasMoreElements()) { ImageConsumer ic = enum_.nextElement(); if (w > 0 && h > 0) { sendPixels(ic, x, y, w, h); } if (framenotify && isConsumer(ic)) { ic.imageComplete(ImageConsumer.SINGLEFRAMEDONE); } } } }
/** * Adds an ImageConsumer to the list of consumers interested in * data for this image, and immediately starts delivery of the * image data through the ImageConsumer interface. * * @param ic the ImageConsumer to be added to the list of consumers. */ public synchronized void startProduction(ImageConsumer ic) { addConsumer(ic); // Need to build a runnable object for the Thread. String name = "RenderableImageProducer Thread"; Thread thread = new Thread(null, this, name, 0, false); thread.start(); }
public synchronized void addConsumer(ImageConsumer ic) { theConsumer = ic; produce(); }
public synchronized boolean isConsumer(ImageConsumer ic) { return (ic == theConsumer); }
public synchronized void removeConsumer(ImageConsumer ic) { if (theConsumer == ic) { theConsumer = null; } }
