META-INF.modules.java.desktop.classes.java.awt.image.MemoryImageSource Maven / Gradle / Ivy
Show all versions of java.desktop Show documentation
/*
* Copyright (c) 1995, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.awt.image;
import java.awt.image.ImageConsumer;
import java.awt.image.ImageProducer;
import java.awt.image.ColorModel;
import java.util.Hashtable;
import java.util.Vector;
import java.util.Enumeration;
/**
* This class is an implementation of the ImageProducer interface which
* uses an array to produce pixel values for an Image. Here is an example
* which calculates a 100x100 image representing a fade from black to blue
* along the X axis and a fade from black to red along the Y axis:
* {@code
*
* int w = 100;
* int h = 100;
* int pix[] = new int[w * h];
* int index = 0;
* for (int y = 0; y < h; y++) {
* int red = (y * 255) / (h - 1);
* for (int x = 0; x < w; x++) {
* int blue = (x * 255) / (w - 1);
* pix[index++] = (255 << 24) | (red << 16) | blue;
* }
* }
* Image img = createImage(new MemoryImageSource(w, h, pix, 0, w));
*
* }
* The MemoryImageSource is also capable of managing a memory image which
* varies over time to allow animation or custom rendering. Here is an
* example showing how to set up the animation source and signal changes
* in the data (adapted from the MemoryAnimationSourceDemo by Garth Dickie):
* {@code
*
* int pixels[];
* MemoryImageSource source;
*
* public void init() {
* int width = 50;
* int height = 50;
* int size = width * height;
* pixels = new int[size];
*
* int value = getBackground().getRGB();
* for (int i = 0; i < size; i++) {
* pixels[i] = value;
* }
*
* source = new MemoryImageSource(width, height, pixels, 0, width);
* source.setAnimated(true);
* image = createImage(source);
* }
*
* public void run() {
* Thread me = Thread.currentThread( );
* me.setPriority(Thread.MIN_PRIORITY);
*
* while (true) {
* try {
* Thread.sleep(10);
* } catch( InterruptedException e ) {
* return;
* }
*
* // Modify the values in the pixels array at (x, y, w, h)
*
* // Send the new data to the interested ImageConsumers
* source.newPixels(x, y, w, h);
* }
* }
*
* }
*
* @see ImageProducer
*
* @author Jim Graham
* @author Animation capabilities inspired by the
* MemoryAnimationSource class written by Garth Dickie
*/
public class MemoryImageSource implements ImageProducer {
int width;
int height;
ColorModel model;
Object pixels;
int pixeloffset;
int pixelscan;
Hashtable properties;
Vector theConsumers = new Vector<>();
boolean animating;
boolean fullbuffers;
/**
* Constructs an ImageProducer object which uses an array of bytes
* to produce data for an Image object.
* @param w the width of the rectangle of pixels
* @param h the height of the rectangle of pixels
* @param cm the specified {@code ColorModel}
* @param pix an array of pixels
* @param off the offset into the array of where to store the
* first pixel
* @param scan the distance from one row of pixels to the next in
* the array
* @see java.awt.Component#createImage
*/
public MemoryImageSource(int w, int h, ColorModel cm,
byte[] pix, int off, int scan) {
initialize(w, h, cm, (Object) pix, off, scan, null);
}
/**
* Constructs an ImageProducer object which uses an array of bytes
* to produce data for an Image object.
* @param w the width of the rectangle of pixels
* @param h the height of the rectangle of pixels
* @param cm the specified {@code ColorModel}
* @param pix an array of pixels
* @param off the offset into the array of where to store the
* first pixel
* @param scan the distance from one row of pixels to the next in
* the array
* @param props a list of properties that the {@code ImageProducer}
* uses to process an image
* @see java.awt.Component#createImage
*/
public MemoryImageSource(int w, int h, ColorModel cm,
byte[] pix, int off, int scan,
Hashtable props)
{
initialize(w, h, cm, (Object) pix, off, scan, props);
}
/**
* Constructs an ImageProducer object which uses an array of integers
* to produce data for an Image object.
* @param w the width of the rectangle of pixels
* @param h the height of the rectangle of pixels
* @param cm the specified {@code ColorModel}
* @param pix an array of pixels
* @param off the offset into the array of where to store the
* first pixel
* @param scan the distance from one row of pixels to the next in
* the array
* @see java.awt.Component#createImage
*/
public MemoryImageSource(int w, int h, ColorModel cm,
int[] pix, int off, int scan) {
initialize(w, h, cm, (Object) pix, off, scan, null);
}
/**
* Constructs an ImageProducer object which uses an array of integers
* to produce data for an Image object.
* @param w the width of the rectangle of pixels
* @param h the height of the rectangle of pixels
* @param cm the specified {@code ColorModel}
* @param pix an array of pixels
* @param off the offset into the array of where to store the
* first pixel
* @param scan the distance from one row of pixels to the next in
* the array
* @param props a list of properties that the {@code ImageProducer}
* uses to process an image
* @see java.awt.Component#createImage
*/
public MemoryImageSource(int w, int h, ColorModel cm,
int[] pix, int off, int scan,
Hashtable props)
{
initialize(w, h, cm, (Object) pix, off, scan, props);
}
private void initialize(int w, int h, ColorModel cm,
Object pix, int off, int scan, Hashtable props) {
width = w;
height = h;
model = cm;
pixels = pix;
pixeloffset = off;
pixelscan = scan;
if (props == null) {
props = new Hashtable<>();
}
properties = props;
}
/**
* Constructs an ImageProducer object which uses an array of integers
* in the default RGB ColorModel to produce data for an Image object.
* @param w the width of the rectangle of pixels
* @param h the height of the rectangle of pixels
* @param pix an array of pixels
* @param off the offset into the array of where to store the
* first pixel
* @param scan the distance from one row of pixels to the next in
* the array
* @see java.awt.Component#createImage
* @see ColorModel#getRGBdefault
*/
public MemoryImageSource(int w, int h, int[] pix, int off, int scan) {
initialize(w, h, ColorModel.getRGBdefault(),
(Object) pix, off, scan, null);
}
/**
* Constructs an ImageProducer object which uses an array of integers
* in the default RGB ColorModel to produce data for an Image object.
* @param w the width of the rectangle of pixels
* @param h the height of the rectangle of pixels
* @param pix an array of pixels
* @param off the offset into the array of where to store the
* first pixel
* @param scan the distance from one row of pixels to the next in
* the array
* @param props a list of properties that the {@code ImageProducer}
* uses to process an image
* @see java.awt.Component#createImage
* @see ColorModel#getRGBdefault
*/
public MemoryImageSource(int w, int h, int[] pix, int off, int scan,
Hashtable props)
{
initialize(w, h, ColorModel.getRGBdefault(),
(Object) pix, off, scan, props);
}
/**
* 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);
}
}
}
/**
* Determines if an ImageConsumer is on the list of consumers currently
* interested in data for this image.
* @param ic the specified {@code ImageConsumer}
* @return {@code true} if the {@code ImageConsumer}
* is on the list; {@code false} otherwise.
* @see ImageConsumer
*/
public synchronized boolean isConsumer(ImageConsumer ic) {
return theConsumers.contains(ic);
}
/**
* Removes an ImageConsumer from the list of consumers interested in
* data for this image.
* @param ic the specified {@code ImageConsumer}
* @see ImageConsumer
*/
public synchronized void removeConsumer(ImageConsumer ic) {
theConsumers.removeElement(ic);
}
/**
* 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 specified {@code ImageConsumer}
* image data through the ImageConsumer interface.
* @see ImageConsumer
*/
public void startProduction(ImageConsumer ic) {
addConsumer(ic);
}
/**
* Requests that a given ImageConsumer have the image data delivered
* one more time in top-down, left-right order.
* @param ic the specified {@code ImageConsumer}
* @see ImageConsumer
*/
public void requestTopDownLeftRightResend(ImageConsumer ic) {
// Ignored. The data is either single frame and already in TDLR
// format or it is multi-frame and TDLR resends aren't critical.
}
/**
* Changes this memory image into a multi-frame animation or a
* single-frame static image depending on the animated parameter.
* 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 enum_ = theConsumers.elements();
while (enum_.hasMoreElements()) {
ImageConsumer ic = enum_.nextElement();
ic.imageComplete(ImageConsumer.STATICIMAGEDONE);
if (isConsumer(ic)) {
ic.imageComplete(ImageConsumer.IMAGEERROR);
}
}
theConsumers.removeAllElements();
}
}
/**
* 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.
* 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 enum_ = theConsumers.elements();
while (enum_.hasMoreElements()) {
ImageConsumer ic = enum_.nextElement();
ic.setHints(fullbuffers
? (ImageConsumer.TOPDOWNLEFTRIGHT |
ImageConsumer.COMPLETESCANLINES)
: ImageConsumer.RANDOMPIXELORDER);
}
}
}
/**
* Sends a whole new buffer of pixels to any ImageConsumers that
* are currently interested in the data for this image and notify
* them that an animation frame is complete.
* This method only has effect if the animation flag has been
* turned on through the setAnimated() method.
* @see #newPixels(int, int, int, int, boolean)
* @see ImageConsumer
* @see #setAnimated
*/
public void newPixels() {
newPixels(0, 0, width, height, true);
}
/**
* Sends a rectangular region of the buffer of pixels to any
* ImageConsumers that are currently interested in the data for
* this image and notify them 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
* @see #newPixels(int, int, int, int, boolean)
* @see ImageConsumer
* @see #setAnimated
* @see #setFullBufferUpdates
*/
public synchronized void newPixels(int x, int y, int w, int h) {
newPixels(x, y, w, h, true);
}
/**
* 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 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);
}
}
}
}
/**
* Changes to a new byte array to hold the pixels for this image.
* If the animation flag has been turned on through the setAnimated()
* method, then the new pixels will be immediately delivered to any
* ImageConsumers that are currently interested in the data for
* this image.
* @param newpix the new pixel array
* @param newmodel the specified {@code ColorModel}
* @param offset the offset into the array
* @param scansize the distance from one row of pixels to the next in
* the array
* @see #newPixels(int, int, int, int, boolean)
* @see #setAnimated
*/
public synchronized void newPixels(byte[] newpix, ColorModel newmodel,
int offset, int scansize) {
this.pixels = newpix;
this.model = newmodel;
this.pixeloffset = offset;
this.pixelscan = scansize;
newPixels();
}
/**
* Changes to a new int array to hold the pixels for this image.
* If the animation flag has been turned on through the setAnimated()
* method, then the new pixels will be immediately delivered to any
* ImageConsumers that are currently interested in the data for
* this image.
* @param newpix the new pixel array
* @param newmodel the specified {@code ColorModel}
* @param offset the offset into the array
* @param scansize the distance from one row of pixels to the next in
* the array
* @see #newPixels(int, int, int, int, boolean)
* @see #setAnimated
*/
public synchronized void newPixels(int[] newpix, ColorModel newmodel,
int offset, int scansize) {
this.pixels = newpix;
this.model = newmodel;
this.pixeloffset = offset;
this.pixelscan = scansize;
newPixels();
}
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));
}
}
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);
}
}
}
}