Class QtVolatileImage

public QtVolatileImage(int width,
                       int height)

Constructs an empty QtVolatileImage.

public void blit(QtImage i)

Blit a QImage

public void blit(QtImage i,
                 int x,
                 int y,
                 int w,
                 int h)

public int checkImage(ImageObserver observer)

Returns the image status, used by QtToolkit

public void clear()

Clears the image to RGBA 0

public boolean contentsLost()

Returns true if the contents of the image buffer have been damaged or if the image buffer's resources have been reclaimed by the graphics system. You should call this method after a series of rendering operations to or from the image, to see if the image buffer needs to be revalidated or the image re-rendered.

Overrides:

contentsLost in interface VolatileImage

Returns:

true if the validate should be called, false otherwise

public void copyArea(int x,
                     int y,
                     int width,
                     int height,
                     int dx,
                     int dy)

public Graphics2D createGraphics()

Returns a Graphics2D object that can be used to draw onto this image.

Overrides:

createGraphics in interface VolatileImage

Returns:

a Graphics2D object that can be used to draw onto this image

public void dispose()

public boolean drawImage(QtGraphics g,
                         QMatrix matrix,
                         ImageObserver observer)

Draws an image with eventual scaling/transforming.

public boolean drawImage(QtGraphics g,
                         int dx1,
                         int dy1,
                         int dx2,
                         int dy2,
                         int sx1,
                         int sy1,
                         int sx2,
                         int sy2,
                         Color bgcolor,
                         ImageObserver observer)

Draws an image with eventual scaling/transforming.

public boolean drawImage(QtGraphics g,
                         int x,
                         int y,
                         int width,
                         int height,
                         Color bgcolor,
                         ImageObserver observer)

Draws an image to the QtGraphics context, at (x,y) scaled to width and height, with optional compositing with a background color.

public boolean drawImage(QtGraphics g,
                         int x,
                         int y,
                         Color bgcolor,
                         ImageObserver observer)

Draws an image to the QtGraphics context, at (x,y) with optional compositing with a background color.

public void finalize()

Called on an object by the Virtual Machine at most once, at some point after the Object is determined unreachable but before it is destroyed. You would think that this means it eventually is called on every Object, but this is not necessarily the case. If execution terminates abnormally, garbage collection does not always happen. Thus you cannot rely on this method to always work. For finer control over garbage collection, use references from the java.lang.ref package.

Virtual Machines are free to not call this method if they can determine that it does nothing important; for example, if your class extends Object and overrides finalize to do simply super.finalize().

finalize() will be called by a Thread that has no locks on any Objects, and may be called concurrently. There are no guarantees on the order in which multiple objects are finalized. This means that finalize() is usually unsuited for performing actions that must be thread-safe, and that your implementation must be use defensive programming if it is to always work.

If an Exception is thrown from finalize() during garbage collection, it will be patently ignored and the Object will still be destroyed.

It is allowed, although not typical, for user code to call finalize() directly. User invocation does not affect whether automatic invocation will occur. It is also permitted, although not recommended, for a finalize() method to "revive" an object by making it reachable from normal code again.

Unlike constructors, finalize() does not get called for an object's superclass unless the implementation specifically calls super.finalize().

The default implementation does nothing.

Overrides:

finalize in interface Object

See Also:

System.gc(), System.runFinalizersOnExit(boolean), java.lang.ref

public void flush()

Overrides:

flush in interface VolatileImage

public ImageCapabilities getCapabilities()

Returns the capabilities of this image buffer.

Overrides:

getCapabilities in interface VolatileImage

Returns:

the capabilities of this image buffer

public Graphics getGraphics()

Creates a Graphics context for this image.

Overrides:

getGraphics in interface VolatileImage

public int getHeight()

Returns the height of this image buffer.

Overrides:

getHeight in interface VolatileImage

Returns:

the height of this VolatileImage

public int getHeight(ImageObserver observer)

Overrides:

getHeight in interface Image

public Object getProperty(String name,
                          ImageObserver observer)

Overrides:

getProperty in interface Image

public Image getScaledInstance(int width,
                               int height,
                               int hints)

Returns a scaled instance of this image.

Overrides:

getScaledInstance in interface Image

public BufferedImage getSnapshot()

Returns an image representing the current state of the volatile image buffer. The returned image is static meaning that it is not updated after being created. It is a snapshot of the volatile image buffer at the time getSnapshot is called. This method, which reads pixels from the volatile image buffer, may be less-performant than methods that write pixels since VolatileImages are typically optimized for writing.

Overrides:

getSnapshot in interface VolatileImage

Returns:

a BufferedImage representing this VolatileImage

public ImageProducer getSource()

Returns the source of this image.

Overrides:

getSource in interface VolatileImage

public int getWidth()

Returns the width of this image buffer.

Overrides:

getWidth in interface VolatileImage

Returns:

the width of this VolatileImage

public int getWidth(ImageObserver observer)

Overrides:

getWidth in interface Image

public int validate(GraphicsConfiguration gc)

Validates and restores this image. If the image buffer has become unavailable for further use since the last call to validate, validate will allocate a new image buffer. The image is also "validated" against the GraphicsConfiguration parameter. "Validating" the image means checking that the capabilities it requires of the output device are indeed supported by the given output device. If the image's characteristics, which can be highly output device-specific, are not supported by the graphics configuration, then IMAGE_INCOMPATIBLE will be returned. This can happen, for example, if this image was created on one output device, then validated against a different output device with different capabilities. Calling validate with a NULL gc argument causes validate to skip the validation test.

Overrides:

validate in interface VolatileImage

Parameters:

gc - graphics configuration against which to validate or NULL

Returns:

a code indicating the result of validation. One of:

• IMAGE_OK if the image did not need to be validated and didn't need to be restored
• IMAGE_RESTORED if the image may need to be re-rendered.
• IMAGE_INCOMPATIBLE if this image's requirements are not fulfilled by the graphics configuration parameter. This implies that you need to create a new VolatileImage for the different GraphicsConfiguration or Component. This return value implies nothing about whether the image is valid or needs to be re-rendered.