354 lines
15 KiB
Java
354 lines
15 KiB
Java
|
/*
|
||
|
|
* Copyright (c) 1995, 2007, 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;
|
||
|
|
|
||
|
|
import java.awt.image.ImageProducer;
|
||
|
|
import java.awt.image.ImageObserver;
|
||
|
|
import java.awt.image.ImageFilter;
|
||
|
|
import java.awt.image.FilteredImageSource;
|
||
|
|
import java.awt.image.AreaAveragingScaleFilter;
|
||
|
|
import java.awt.image.ReplicateScaleFilter;
|
||
|
|
|
||
|
|
//import sun.awt.image.SurfaceManager;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The abstract class <code>Image</code> is the superclass of all
|
||
|
|
* classes that represent graphical images. The image must be
|
||
|
|
* obtained in a platform-specific manner.
|
||
|
|
*
|
||
|
|
* @author Sami Shaio
|
||
|
|
* @author Arthur van Hoff
|
||
|
|
* @since JDK1.0
|
||
|
|
*/
|
||
|
|
public abstract class Image {
|
||
|
|
|
||
|
|
/**
|
||
|
|
* convenience object; we can use this single static object for
|
||
|
|
* all images that do not create their own image caps; it holds the
|
||
|
|
* default (unaccelerated) properties.
|
||
|
|
*/
|
||
|
|
private static ImageCapabilities defaultImageCaps =
|
||
|
|
new ImageCapabilities(false);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Priority for accelerating this image. Subclasses are free to
|
||
|
|
* set different default priorities and applications are free to
|
||
|
|
* set the priority for specific images via the
|
||
|
|
* <code>setAccelerationPriority(float)</code> method.
|
||
|
|
* @since 1.5
|
||
|
|
*/
|
||
|
|
protected float accelerationPriority = .5f;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Determines the width of the image. If the width is not yet known,
|
||
|
|
* this method returns <code>-1</code> and the specified
|
||
|
|
* <code>ImageObserver</code> object is notified later.
|
||
|
|
* @param observer an object waiting for the image to be loaded.
|
||
|
|
* @return the width of this image, or <code>-1</code>
|
||
|
|
* if the width is not yet known.
|
||
|
|
* @see java.awt.Image#getHeight
|
||
|
|
* @see java.awt.image.ImageObserver
|
||
|
|
*/
|
||
|
|
public abstract int getWidth(ImageObserver observer);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Determines the height of the image. If the height is not yet known,
|
||
|
|
* this method returns <code>-1</code> and the specified
|
||
|
|
* <code>ImageObserver</code> object is notified later.
|
||
|
|
* @param observer an object waiting for the image to be loaded.
|
||
|
|
* @return the height of this image, or <code>-1</code>
|
||
|
|
* if the height is not yet known.
|
||
|
|
* @see java.awt.Image#getWidth
|
||
|
|
* @see java.awt.image.ImageObserver
|
||
|
|
*/
|
||
|
|
public abstract int getHeight(ImageObserver observer);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gets the object that produces the pixels for the image.
|
||
|
|
* This method is called by the image filtering classes and by
|
||
|
|
* methods that perform image conversion and scaling.
|
||
|
|
* @return the image producer that produces the pixels
|
||
|
|
* for this image.
|
||
|
|
* @see java.awt.image.ImageProducer
|
||
|
|
*/
|
||
|
|
public abstract ImageProducer getSource();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a graphics context for drawing to an off-screen image.
|
||
|
|
* This method can only be called for off-screen images.
|
||
|
|
* @return a graphics context to draw to the off-screen image.
|
||
|
|
* @exception UnsupportedOperationException if called for a
|
||
|
|
* non-off-screen image.
|
||
|
|
* @see java.awt.Graphics
|
||
|
|
* @see java.awt.Component#createImage(int, int)
|
||
|
|
*/
|
||
|
|
public abstract Graphics getGraphics();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gets a property of this image by name.
|
||
|
|
* <p>
|
||
|
|
* Individual property names are defined by the various image
|
||
|
|
* formats. If a property is not defined for a particular image, this
|
||
|
|
* method returns the <code>UndefinedProperty</code> object.
|
||
|
|
* <p>
|
||
|
|
* If the properties for this image are not yet known, this method
|
||
|
|
* returns <code>null</code>, and the <code>ImageObserver</code>
|
||
|
|
* object is notified later.
|
||
|
|
* <p>
|
||
|
|
* The property name <code>"comment"</code> should be used to store
|
||
|
|
* an optional comment which can be presented to the application as a
|
||
|
|
* description of the image, its source, or its author.
|
||
|
|
* @param name a property name.
|
||
|
|
* @param observer an object waiting for this image to be loaded.
|
||
|
|
* @return the value of the named property.
|
||
|
|
* @throws <code>NullPointerException</code> if the property name is null.
|
||
|
|
* @see java.awt.image.ImageObserver
|
||
|
|
* @see java.awt.Image#UndefinedProperty
|
||
|
|
*/
|
||
|
|
public abstract Object getProperty(String name, ImageObserver observer);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The <code>UndefinedProperty</code> object should be returned whenever a
|
||
|
|
* property which was not defined for a particular image is fetched.
|
||
|
|
*/
|
||
|
|
public static final Object UndefinedProperty = new Object();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a scaled version of this image.
|
||
|
|
* A new <code>Image</code> object is returned which will render
|
||
|
|
* the image at the specified <code>width</code> and
|
||
|
|
* <code>height</code> by default. The new <code>Image</code> object
|
||
|
|
* may be loaded asynchronously even if the original source image
|
||
|
|
* has already been loaded completely.
|
||
|
|
*
|
||
|
|
* <p>
|
||
|
|
*
|
||
|
|
* If either <code>width</code>
|
||
|
|
* or <code>height</code> is a negative number then a value is
|
||
|
|
* substituted to maintain the aspect ratio of the original image
|
||
|
|
* dimensions. If both <code>width</code> and <code>height</code>
|
||
|
|
* are negative, then the original image dimensions are used.
|
||
|
|
*
|
||
|
|
* @param width the width to which to scale the image.
|
||
|
|
* @param height the height to which to scale the image.
|
||
|
|
* @param hints flags to indicate the type of algorithm to use
|
||
|
|
* for image resampling.
|
||
|
|
* @return a scaled version of the image.
|
||
|
|
* @exception IllegalArgumentException if <code>width</code>
|
||
|
|
* or <code>height</code> is zero.
|
||
|
|
* @see java.awt.Image#SCALE_DEFAULT
|
||
|
|
* @see java.awt.Image#SCALE_FAST
|
||
|
|
* @see java.awt.Image#SCALE_SMOOTH
|
||
|
|
* @see java.awt.Image#SCALE_REPLICATE
|
||
|
|
* @see java.awt.Image#SCALE_AREA_AVERAGING
|
||
|
|
* @since JDK1.1
|
||
|
|
*/
|
||
|
|
public Image getScaledInstance(int width, int height, int hints) {
|
||
|
|
ImageFilter filter;
|
||
|
|
if ((hints & (SCALE_SMOOTH | SCALE_AREA_AVERAGING)) != 0) {
|
||
|
|
filter = new AreaAveragingScaleFilter(width, height);
|
||
|
|
} else {
|
||
|
|
filter = new ReplicateScaleFilter(width, height);
|
||
|
|
}
|
||
|
|
ImageProducer prod;
|
||
|
|
prod = new FilteredImageSource(getSource(), filter);
|
||
|
|
return Toolkit.getDefaultToolkit().createImage(prod);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Use the default image-scaling algorithm.
|
||
|
|
* @since JDK1.1
|
||
|
|
*/
|
||
|
|
public static final int SCALE_DEFAULT = 1;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Choose an image-scaling algorithm that gives higher priority
|
||
|
|
* to scaling speed than smoothness of the scaled image.
|
||
|
|
* @since JDK1.1
|
||
|
|
*/
|
||
|
|
public static final int SCALE_FAST = 2;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Choose an image-scaling algorithm that gives higher priority
|
||
|
|
* to image smoothness than scaling speed.
|
||
|
|
* @since JDK1.1
|
||
|
|
*/
|
||
|
|
public static final int SCALE_SMOOTH = 4;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Use the image scaling algorithm embodied in the
|
||
|
|
* <code>ReplicateScaleFilter</code> class.
|
||
|
|
* The <code>Image</code> object is free to substitute a different filter
|
||
|
|
* that performs the same algorithm yet integrates more efficiently
|
||
|
|
* into the imaging infrastructure supplied by the toolkit.
|
||
|
|
* @see java.awt.image.ReplicateScaleFilter
|
||
|
|
* @since JDK1.1
|
||
|
|
*/
|
||
|
|
public static final int SCALE_REPLICATE = 8;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Use the Area Averaging image scaling algorithm. The
|
||
|
|
* image object is free to substitute a different filter that
|
||
|
|
* performs the same algorithm yet integrates more efficiently
|
||
|
|
* into the image infrastructure supplied by the toolkit.
|
||
|
|
* @see java.awt.image.AreaAveragingScaleFilter
|
||
|
|
* @since JDK1.1
|
||
|
|
*/
|
||
|
|
public static final int SCALE_AREA_AVERAGING = 16;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Flushes all reconstructable resources being used by this Image object.
|
||
|
|
* This includes any pixel data that is being cached for rendering to
|
||
|
|
* the screen as well as any system resources that are being used
|
||
|
|
* to store data or pixels for the image if they can be recreated.
|
||
|
|
* The image is reset to a state similar to when it was first created
|
||
|
|
* so that if it is again rendered, the image data will have to be
|
||
|
|
* recreated or fetched again from its source.
|
||
|
|
* <p>
|
||
|
|
* Examples of how this method affects specific types of Image object:
|
||
|
|
* <ul>
|
||
|
|
* <li>
|
||
|
|
* BufferedImage objects leave the primary Raster which stores their
|
||
|
|
* pixels untouched, but flush any information cached about those
|
||
|
|
* pixels such as copies uploaded to the display hardware for
|
||
|
|
* accelerated blits.
|
||
|
|
* <li>
|
||
|
|
* Image objects created by the Component methods which take a
|
||
|
|
* width and height leave their primary buffer of pixels untouched,
|
||
|
|
* but have all cached information released much like is done for
|
||
|
|
* BufferedImage objects.
|
||
|
|
* <li>
|
||
|
|
* VolatileImage objects release all of their pixel resources
|
||
|
|
* including their primary copy which is typically stored on
|
||
|
|
* the display hardware where resources are scarce.
|
||
|
|
* These objects can later be restored using their
|
||
|
|
* {@link java.awt.image.VolatileImage#validate validate}
|
||
|
|
* method.
|
||
|
|
* <li>
|
||
|
|
* Image objects created by the Toolkit and Component classes which are
|
||
|
|
* loaded from files, URLs or produced by an {@link ImageProducer}
|
||
|
|
* are unloaded and all local resources are released.
|
||
|
|
* These objects can later be reloaded from their original source
|
||
|
|
* as needed when they are rendered, just as when they were first
|
||
|
|
* created.
|
||
|
|
* </ul>
|
||
|
|
*/
|
||
|
|
public void flush() {
|
||
|
|
// if (surfaceManager != null) {
|
||
|
|
// surfaceManager.flush();
|
||
|
|
// }
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns an ImageCapabilities object which can be
|
||
|
|
* inquired as to the capabilities of this
|
||
|
|
* Image on the specified GraphicsConfiguration.
|
||
|
|
* This allows programmers to find
|
||
|
|
* out more runtime information on the specific Image
|
||
|
|
* object that they have created. For example, the user
|
||
|
|
* might create a BufferedImage but the system may have
|
||
|
|
* no video memory left for creating an image of that
|
||
|
|
* size on the given GraphicsConfiguration, so although the object
|
||
|
|
* may be acceleratable in general, it
|
||
|
|
* does not have that capability on this GraphicsConfiguration.
|
||
|
|
* @param gc a <code>GraphicsConfiguration</code> object. A value of null
|
||
|
|
* for this parameter will result in getting the image capabilities
|
||
|
|
* for the default <code>GraphicsConfiguration</code>.
|
||
|
|
* @return an <code>ImageCapabilities</code> object that contains
|
||
|
|
* the capabilities of this <code>Image</code> on the specified
|
||
|
|
* GraphicsConfiguration.
|
||
|
|
* @see java.awt.image.VolatileImage#getCapabilities()
|
||
|
|
* VolatileImage.getCapabilities()
|
||
|
|
* @since 1.5
|
||
|
|
*/
|
||
|
|
public ImageCapabilities getCapabilities(GraphicsConfiguration gc) {
|
||
|
|
// if (surfaceManager != null) {
|
||
|
|
// return surfaceManager.getCapabilities(gc);
|
||
|
|
// }
|
||
|
|
// Note: this is just a default object that gets returned in the
|
||
|
|
// absence of any more specific information from a surfaceManager.
|
||
|
|
// Subclasses of Image should either override this method or
|
||
|
|
// make sure that they always have a non-null SurfaceManager
|
||
|
|
// to return an ImageCapabilities object that is appropriate
|
||
|
|
// for their given subclass type.
|
||
|
|
return defaultImageCaps;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets a hint for this image about how important acceleration is.
|
||
|
|
* This priority hint is used to compare to the priorities of other
|
||
|
|
* Image objects when determining how to use scarce acceleration
|
||
|
|
* resources such as video memory. When and if it is possible to
|
||
|
|
* accelerate this Image, if there are not enough resources available
|
||
|
|
* to provide that acceleration but enough can be freed up by
|
||
|
|
* de-accelerating some other image of lower priority, then that other
|
||
|
|
* Image may be de-accelerated in deference to this one. Images
|
||
|
|
* that have the same priority take up resources on a first-come,
|
||
|
|
* first-served basis.
|
||
|
|
* @param priority a value between 0 and 1, inclusive, where higher
|
||
|
|
* values indicate more importance for acceleration. A value of 0
|
||
|
|
* means that this Image should never be accelerated. Other values
|
||
|
|
* are used simply to determine acceleration priority relative to other
|
||
|
|
* Images.
|
||
|
|
* @throws IllegalArgumentException if <code>priority</code> is less
|
||
|
|
* than zero or greater than 1.
|
||
|
|
* @since 1.5
|
||
|
|
*/
|
||
|
|
public void setAccelerationPriority(float priority) {
|
||
|
|
if (priority < 0 || priority > 1) {
|
||
|
|
throw new IllegalArgumentException("Priority must be a value " +
|
||
|
|
"between 0 and 1, inclusive");
|
||
|
|
}
|
||
|
|
accelerationPriority = priority;
|
||
|
|
// if (surfaceManager != null) {
|
||
|
|
// surfaceManager.setAccelerationPriority(accelerationPriority);
|
||
|
|
// }
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the current value of the acceleration priority hint.
|
||
|
|
* @see #setAccelerationPriority(float priority) setAccelerationPriority
|
||
|
|
* @return value between 0 and 1, inclusive, which represents the current
|
||
|
|
* priority value
|
||
|
|
* @since 1.5
|
||
|
|
*/
|
||
|
|
public float getAccelerationPriority() {
|
||
|
|
return accelerationPriority;
|
||
|
|
}
|
||
|
|
|
||
|
|
// SurfaceManager surfaceManager;
|
||
|
|
//
|
||
|
|
// static {
|
||
|
|
// SurfaceManager.setImageAccessor(new SurfaceManager.ImageAccessor() {
|
||
|
|
// public SurfaceManager getSurfaceManager(Image img) {
|
||
|
|
// return img.surfaceManager;
|
||
|
|
// }
|
||
|
|
// public void setSurfaceManager(Image img, SurfaceManager mgr) {
|
||
|
|
// img.surfaceManager = mgr;
|
||
|
|
// }
|
||
|
|
// });
|
||
|
|
// }
|
||
|
|
}
|