You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
993 lines
34 KiB
993 lines
34 KiB
/*
|
|
* Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package java.awt;
|
|
|
|
import java.awt.Component;
|
|
import java.awt.Image;
|
|
import java.awt.image.ImageObserver;
|
|
import sun.awt.image.MultiResolutionToolkitImage;
|
|
|
|
/**
|
|
* The <code>MediaTracker</code> class is a utility class to track
|
|
* the status of a number of media objects. Media objects could
|
|
* include audio clips as well as images, though currently only
|
|
* images are supported.
|
|
* <p>
|
|
* To use a media tracker, create an instance of
|
|
* <code>MediaTracker</code> and call its <code>addImage</code>
|
|
* method for each image to be tracked. In addition, each image can
|
|
* be assigned a unique identifier. This identifier controls the
|
|
* priority order in which the images are fetched. It can also be used
|
|
* to identify unique subsets of the images that can be waited on
|
|
* independently. Images with a lower ID are loaded in preference to
|
|
* those with a higher ID number.
|
|
*
|
|
* <p>
|
|
*
|
|
* Tracking an animated image
|
|
* might not always be useful
|
|
* due to the multi-part nature of animated image
|
|
* loading and painting,
|
|
* but it is supported.
|
|
* <code>MediaTracker</code> treats an animated image
|
|
* as completely loaded
|
|
* when the first frame is completely loaded.
|
|
* At that point, the <code>MediaTracker</code>
|
|
* signals any waiters
|
|
* that the image is completely loaded.
|
|
* If no <code>ImageObserver</code>s are observing the image
|
|
* when the first frame has finished loading,
|
|
* the image might flush itself
|
|
* to conserve resources
|
|
* (see {@link Image#flush()}).
|
|
*
|
|
* <p>
|
|
* Here is an example of using <code>MediaTracker</code>:
|
|
* <p>
|
|
* <hr><blockquote><pre>{@code
|
|
* import java.applet.Applet;
|
|
* import java.awt.Color;
|
|
* import java.awt.Image;
|
|
* import java.awt.Graphics;
|
|
* import java.awt.MediaTracker;
|
|
*
|
|
* public class ImageBlaster extends Applet implements Runnable {
|
|
* MediaTracker tracker;
|
|
* Image bg;
|
|
* Image anim[] = new Image[5];
|
|
* int index;
|
|
* Thread animator;
|
|
*
|
|
* // Get the images for the background (id == 0)
|
|
* // and the animation frames (id == 1)
|
|
* // and add them to the MediaTracker
|
|
* public void init() {
|
|
* tracker = new MediaTracker(this);
|
|
* bg = getImage(getDocumentBase(),
|
|
* "images/background.gif");
|
|
* tracker.addImage(bg, 0);
|
|
* for (int i = 0; i < 5; i++) {
|
|
* anim[i] = getImage(getDocumentBase(),
|
|
* "images/anim"+i+".gif");
|
|
* tracker.addImage(anim[i], 1);
|
|
* }
|
|
* }
|
|
*
|
|
* // Start the animation thread.
|
|
* public void start() {
|
|
* animator = new Thread(this);
|
|
* animator.start();
|
|
* }
|
|
*
|
|
* // Stop the animation thread.
|
|
* public void stop() {
|
|
* animator = null;
|
|
* }
|
|
*
|
|
* // Run the animation thread.
|
|
* // First wait for the background image to fully load
|
|
* // and paint. Then wait for all of the animation
|
|
* // frames to finish loading. Finally, loop and
|
|
* // increment the animation frame index.
|
|
* public void run() {
|
|
* try {
|
|
* tracker.waitForID(0);
|
|
* tracker.waitForID(1);
|
|
* } catch (InterruptedException e) {
|
|
* return;
|
|
* }
|
|
* Thread me = Thread.currentThread();
|
|
* while (animator == me) {
|
|
* try {
|
|
* Thread.sleep(100);
|
|
* } catch (InterruptedException e) {
|
|
* break;
|
|
* }
|
|
* synchronized (this) {
|
|
* index++;
|
|
* if (index >= anim.length) {
|
|
* index = 0;
|
|
* }
|
|
* }
|
|
* repaint();
|
|
* }
|
|
* }
|
|
*
|
|
* // The background image fills the frame so we
|
|
* // don't need to clear the applet on repaints.
|
|
* // Just call the paint method.
|
|
* public void update(Graphics g) {
|
|
* paint(g);
|
|
* }
|
|
*
|
|
* // Paint a large red rectangle if there are any errors
|
|
* // loading the images. Otherwise always paint the
|
|
* // background so that it appears incrementally as it
|
|
* // is loading. Finally, only paint the current animation
|
|
* // frame if all of the frames (id == 1) are done loading,
|
|
* // so that we don't get partial animations.
|
|
* public void paint(Graphics g) {
|
|
* if ((tracker.statusAll(false) & MediaTracker.ERRORED) != 0) {
|
|
* g.setColor(Color.red);
|
|
* g.fillRect(0, 0, size().width, size().height);
|
|
* return;
|
|
* }
|
|
* g.drawImage(bg, 0, 0, this);
|
|
* if (tracker.statusID(1, false) == MediaTracker.COMPLETE) {
|
|
* g.drawImage(anim[index], 10, 10, this);
|
|
* }
|
|
* }
|
|
* }
|
|
* } </pre></blockquote><hr>
|
|
*
|
|
* @author Jim Graham
|
|
* @since JDK1.0
|
|
*/
|
|
public class MediaTracker implements java.io.Serializable {
|
|
|
|
/**
|
|
* A given <code>Component</code> that will be
|
|
* tracked by a media tracker where the image will
|
|
* eventually be drawn.
|
|
*
|
|
* @serial
|
|
* @see #MediaTracker(Component)
|
|
*/
|
|
Component target;
|
|
/**
|
|
* The head of the list of <code>Images</code> that is being
|
|
* tracked by the <code>MediaTracker</code>.
|
|
*
|
|
* @serial
|
|
* @see #addImage(Image, int)
|
|
* @see #removeImage(Image)
|
|
*/
|
|
MediaEntry head;
|
|
|
|
/*
|
|
* JDK 1.1 serialVersionUID
|
|
*/
|
|
private static final long serialVersionUID = -483174189758638095L;
|
|
|
|
/**
|
|
* Creates a media tracker to track images for a given component.
|
|
* @param comp the component on which the images
|
|
* will eventually be drawn
|
|
*/
|
|
public MediaTracker(Component comp) {
|
|
target = comp;
|
|
}
|
|
|
|
/**
|
|
* Adds an image to the list of images being tracked by this media
|
|
* tracker. The image will eventually be rendered at its default
|
|
* (unscaled) size.
|
|
* @param image the image to be tracked
|
|
* @param id an identifier used to track this image
|
|
*/
|
|
public void addImage(Image image, int id) {
|
|
addImage(image, id, -1, -1);
|
|
}
|
|
|
|
/**
|
|
* Adds a scaled image to the list of images being tracked
|
|
* by this media tracker. The image will eventually be
|
|
* rendered at the indicated width and height.
|
|
*
|
|
* @param image the image to be tracked
|
|
* @param id an identifier that can be used to track this image
|
|
* @param w the width at which the image is rendered
|
|
* @param h the height at which the image is rendered
|
|
*/
|
|
public synchronized void addImage(Image image, int id, int w, int h) {
|
|
addImageImpl(image, id, w, h);
|
|
Image rvImage = getResolutionVariant(image);
|
|
if (rvImage != null) {
|
|
addImageImpl(rvImage, id,
|
|
w == -1 ? -1 : 2 * w,
|
|
h == -1 ? -1 : 2 * h);
|
|
}
|
|
}
|
|
|
|
private void addImageImpl(Image image, int id, int w, int h) {
|
|
head = MediaEntry.insert(head,
|
|
new ImageMediaEntry(this, image, id, w, h));
|
|
}
|
|
/**
|
|
* Flag indicating that media is currently being loaded.
|
|
* @see java.awt.MediaTracker#statusAll
|
|
* @see java.awt.MediaTracker#statusID
|
|
*/
|
|
public static final int LOADING = 1;
|
|
|
|
/**
|
|
* Flag indicating that the downloading of media was aborted.
|
|
* @see java.awt.MediaTracker#statusAll
|
|
* @see java.awt.MediaTracker#statusID
|
|
*/
|
|
public static final int ABORTED = 2;
|
|
|
|
/**
|
|
* Flag indicating that the downloading of media encountered
|
|
* an error.
|
|
* @see java.awt.MediaTracker#statusAll
|
|
* @see java.awt.MediaTracker#statusID
|
|
*/
|
|
public static final int ERRORED = 4;
|
|
|
|
/**
|
|
* Flag indicating that the downloading of media was completed
|
|
* successfully.
|
|
* @see java.awt.MediaTracker#statusAll
|
|
* @see java.awt.MediaTracker#statusID
|
|
*/
|
|
public static final int COMPLETE = 8;
|
|
|
|
static final int DONE = (ABORTED | ERRORED | COMPLETE);
|
|
|
|
/**
|
|
* Checks to see if all images being tracked by this media tracker
|
|
* have finished loading.
|
|
* <p>
|
|
* This method does not start loading the images if they are not
|
|
* already loading.
|
|
* <p>
|
|
* If there is an error while loading or scaling an image, then that
|
|
* image is considered to have finished loading. Use the
|
|
* <code>isErrorAny</code> or <code>isErrorID</code> methods to
|
|
* check for errors.
|
|
* @return <code>true</code> if all images have finished loading,
|
|
* have been aborted, or have encountered
|
|
* an error; <code>false</code> otherwise
|
|
* @see java.awt.MediaTracker#checkAll(boolean)
|
|
* @see java.awt.MediaTracker#checkID
|
|
* @see java.awt.MediaTracker#isErrorAny
|
|
* @see java.awt.MediaTracker#isErrorID
|
|
*/
|
|
public boolean checkAll() {
|
|
return checkAll(false, true);
|
|
}
|
|
|
|
/**
|
|
* Checks to see if all images being tracked by this media tracker
|
|
* have finished loading.
|
|
* <p>
|
|
* If the value of the <code>load</code> flag is <code>true</code>,
|
|
* then this method starts loading any images that are not yet
|
|
* being loaded.
|
|
* <p>
|
|
* If there is an error while loading or scaling an image, that
|
|
* image is considered to have finished loading. Use the
|
|
* <code>isErrorAny</code> and <code>isErrorID</code> methods to
|
|
* check for errors.
|
|
* @param load if <code>true</code>, start loading any
|
|
* images that are not yet being loaded
|
|
* @return <code>true</code> if all images have finished loading,
|
|
* have been aborted, or have encountered
|
|
* an error; <code>false</code> otherwise
|
|
* @see java.awt.MediaTracker#checkID
|
|
* @see java.awt.MediaTracker#checkAll()
|
|
* @see java.awt.MediaTracker#isErrorAny()
|
|
* @see java.awt.MediaTracker#isErrorID(int)
|
|
*/
|
|
public boolean checkAll(boolean load) {
|
|
return checkAll(load, true);
|
|
}
|
|
|
|
private synchronized boolean checkAll(boolean load, boolean verify) {
|
|
MediaEntry cur = head;
|
|
boolean done = true;
|
|
while (cur != null) {
|
|
if ((cur.getStatus(load, verify) & DONE) == 0) {
|
|
done = false;
|
|
}
|
|
cur = cur.next;
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/**
|
|
* Checks the error status of all of the images.
|
|
* @return <code>true</code> if any of the images tracked
|
|
* by this media tracker had an error during
|
|
* loading; <code>false</code> otherwise
|
|
* @see java.awt.MediaTracker#isErrorID
|
|
* @see java.awt.MediaTracker#getErrorsAny
|
|
*/
|
|
public synchronized boolean isErrorAny() {
|
|
MediaEntry cur = head;
|
|
while (cur != null) {
|
|
if ((cur.getStatus(false, true) & ERRORED) != 0) {
|
|
return true;
|
|
}
|
|
cur = cur.next;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns a list of all media that have encountered an error.
|
|
* @return an array of media objects tracked by this
|
|
* media tracker that have encountered
|
|
* an error, or <code>null</code> if
|
|
* there are none with errors
|
|
* @see java.awt.MediaTracker#isErrorAny
|
|
* @see java.awt.MediaTracker#getErrorsID
|
|
*/
|
|
public synchronized Object[] getErrorsAny() {
|
|
MediaEntry cur = head;
|
|
int numerrors = 0;
|
|
while (cur != null) {
|
|
if ((cur.getStatus(false, true) & ERRORED) != 0) {
|
|
numerrors++;
|
|
}
|
|
cur = cur.next;
|
|
}
|
|
if (numerrors == 0) {
|
|
return null;
|
|
}
|
|
Object errors[] = new Object[numerrors];
|
|
cur = head;
|
|
numerrors = 0;
|
|
while (cur != null) {
|
|
if ((cur.getStatus(false, false) & ERRORED) != 0) {
|
|
errors[numerrors++] = cur.getMedia();
|
|
}
|
|
cur = cur.next;
|
|
}
|
|
return errors;
|
|
}
|
|
|
|
/**
|
|
* Starts loading all images tracked by this media tracker. This
|
|
* method waits until all the images being tracked have finished
|
|
* loading.
|
|
* <p>
|
|
* If there is an error while loading or scaling an image, then that
|
|
* image is considered to have finished loading. Use the
|
|
* <code>isErrorAny</code> or <code>isErrorID</code> methods to
|
|
* check for errors.
|
|
* @see java.awt.MediaTracker#waitForID(int)
|
|
* @see java.awt.MediaTracker#waitForAll(long)
|
|
* @see java.awt.MediaTracker#isErrorAny
|
|
* @see java.awt.MediaTracker#isErrorID
|
|
* @exception InterruptedException if any thread has
|
|
* interrupted this thread
|
|
*/
|
|
public void waitForAll() throws InterruptedException {
|
|
waitForAll(0);
|
|
}
|
|
|
|
/**
|
|
* Starts loading all images tracked by this media tracker. This
|
|
* method waits until all the images being tracked have finished
|
|
* loading, or until the length of time specified in milliseconds
|
|
* by the <code>ms</code> argument has passed.
|
|
* <p>
|
|
* If there is an error while loading or scaling an image, then
|
|
* that image is considered to have finished loading. Use the
|
|
* <code>isErrorAny</code> or <code>isErrorID</code> methods to
|
|
* check for errors.
|
|
* @param ms the number of milliseconds to wait
|
|
* for the loading to complete
|
|
* @return <code>true</code> if all images were successfully
|
|
* loaded; <code>false</code> otherwise
|
|
* @see java.awt.MediaTracker#waitForID(int)
|
|
* @see java.awt.MediaTracker#waitForAll(long)
|
|
* @see java.awt.MediaTracker#isErrorAny
|
|
* @see java.awt.MediaTracker#isErrorID
|
|
* @exception InterruptedException if any thread has
|
|
* interrupted this thread.
|
|
*/
|
|
public synchronized boolean waitForAll(long ms)
|
|
throws InterruptedException
|
|
{
|
|
long end = System.currentTimeMillis() + ms;
|
|
boolean first = true;
|
|
while (true) {
|
|
int status = statusAll(first, first);
|
|
if ((status & LOADING) == 0) {
|
|
return (status == COMPLETE);
|
|
}
|
|
first = false;
|
|
long timeout;
|
|
if (ms == 0) {
|
|
timeout = 0;
|
|
} else {
|
|
timeout = end - System.currentTimeMillis();
|
|
if (timeout <= 0) {
|
|
return false;
|
|
}
|
|
}
|
|
wait(timeout);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculates and returns the bitwise inclusive <b>OR</b> of the
|
|
* status of all media that are tracked by this media tracker.
|
|
* <p>
|
|
* Possible flags defined by the
|
|
* <code>MediaTracker</code> class are <code>LOADING</code>,
|
|
* <code>ABORTED</code>, <code>ERRORED</code>, and
|
|
* <code>COMPLETE</code>. An image that hasn't started
|
|
* loading has zero as its status.
|
|
* <p>
|
|
* If the value of <code>load</code> is <code>true</code>, then
|
|
* this method starts loading any images that are not yet being loaded.
|
|
*
|
|
* @param load if <code>true</code>, start loading
|
|
* any images that are not yet being loaded
|
|
* @return the bitwise inclusive <b>OR</b> of the status of
|
|
* all of the media being tracked
|
|
* @see java.awt.MediaTracker#statusID(int, boolean)
|
|
* @see java.awt.MediaTracker#LOADING
|
|
* @see java.awt.MediaTracker#ABORTED
|
|
* @see java.awt.MediaTracker#ERRORED
|
|
* @see java.awt.MediaTracker#COMPLETE
|
|
*/
|
|
public int statusAll(boolean load) {
|
|
return statusAll(load, true);
|
|
}
|
|
|
|
private synchronized int statusAll(boolean load, boolean verify) {
|
|
MediaEntry cur = head;
|
|
int status = 0;
|
|
while (cur != null) {
|
|
status = status | cur.getStatus(load, verify);
|
|
cur = cur.next;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* Checks to see if all images tracked by this media tracker that
|
|
* are tagged with the specified identifier have finished loading.
|
|
* <p>
|
|
* This method does not start loading the images if they are not
|
|
* already loading.
|
|
* <p>
|
|
* If there is an error while loading or scaling an image, then that
|
|
* image is considered to have finished loading. Use the
|
|
* <code>isErrorAny</code> or <code>isErrorID</code> methods to
|
|
* check for errors.
|
|
* @param id the identifier of the images to check
|
|
* @return <code>true</code> if all images have finished loading,
|
|
* have been aborted, or have encountered
|
|
* an error; <code>false</code> otherwise
|
|
* @see java.awt.MediaTracker#checkID(int, boolean)
|
|
* @see java.awt.MediaTracker#checkAll()
|
|
* @see java.awt.MediaTracker#isErrorAny()
|
|
* @see java.awt.MediaTracker#isErrorID(int)
|
|
*/
|
|
public boolean checkID(int id) {
|
|
return checkID(id, false, true);
|
|
}
|
|
|
|
/**
|
|
* Checks to see if all images tracked by this media tracker that
|
|
* are tagged with the specified identifier have finished loading.
|
|
* <p>
|
|
* If the value of the <code>load</code> flag is <code>true</code>,
|
|
* then this method starts loading any images that are not yet
|
|
* being loaded.
|
|
* <p>
|
|
* If there is an error while loading or scaling an image, then that
|
|
* image is considered to have finished loading. Use the
|
|
* <code>isErrorAny</code> or <code>isErrorID</code> methods to
|
|
* check for errors.
|
|
* @param id the identifier of the images to check
|
|
* @param load if <code>true</code>, start loading any
|
|
* images that are not yet being loaded
|
|
* @return <code>true</code> if all images have finished loading,
|
|
* have been aborted, or have encountered
|
|
* an error; <code>false</code> otherwise
|
|
* @see java.awt.MediaTracker#checkID(int, boolean)
|
|
* @see java.awt.MediaTracker#checkAll()
|
|
* @see java.awt.MediaTracker#isErrorAny()
|
|
* @see java.awt.MediaTracker#isErrorID(int)
|
|
*/
|
|
public boolean checkID(int id, boolean load) {
|
|
return checkID(id, load, true);
|
|
}
|
|
|
|
private synchronized boolean checkID(int id, boolean load, boolean verify)
|
|
{
|
|
MediaEntry cur = head;
|
|
boolean done = true;
|
|
while (cur != null) {
|
|
if (cur.getID() == id
|
|
&& (cur.getStatus(load, verify) & DONE) == 0)
|
|
{
|
|
done = false;
|
|
}
|
|
cur = cur.next;
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/**
|
|
* Checks the error status of all of the images tracked by this
|
|
* media tracker with the specified identifier.
|
|
* @param id the identifier of the images to check
|
|
* @return <code>true</code> if any of the images with the
|
|
* specified identifier had an error during
|
|
* loading; <code>false</code> otherwise
|
|
* @see java.awt.MediaTracker#isErrorAny
|
|
* @see java.awt.MediaTracker#getErrorsID
|
|
*/
|
|
public synchronized boolean isErrorID(int id) {
|
|
MediaEntry cur = head;
|
|
while (cur != null) {
|
|
if (cur.getID() == id
|
|
&& (cur.getStatus(false, true) & ERRORED) != 0)
|
|
{
|
|
return true;
|
|
}
|
|
cur = cur.next;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns a list of media with the specified ID that
|
|
* have encountered an error.
|
|
* @param id the identifier of the images to check
|
|
* @return an array of media objects tracked by this media
|
|
* tracker with the specified identifier
|
|
* that have encountered an error, or
|
|
* <code>null</code> if there are none with errors
|
|
* @see java.awt.MediaTracker#isErrorID
|
|
* @see java.awt.MediaTracker#isErrorAny
|
|
* @see java.awt.MediaTracker#getErrorsAny
|
|
*/
|
|
public synchronized Object[] getErrorsID(int id) {
|
|
MediaEntry cur = head;
|
|
int numerrors = 0;
|
|
while (cur != null) {
|
|
if (cur.getID() == id
|
|
&& (cur.getStatus(false, true) & ERRORED) != 0)
|
|
{
|
|
numerrors++;
|
|
}
|
|
cur = cur.next;
|
|
}
|
|
if (numerrors == 0) {
|
|
return null;
|
|
}
|
|
Object errors[] = new Object[numerrors];
|
|
cur = head;
|
|
numerrors = 0;
|
|
while (cur != null) {
|
|
if (cur.getID() == id
|
|
&& (cur.getStatus(false, false) & ERRORED) != 0)
|
|
{
|
|
errors[numerrors++] = cur.getMedia();
|
|
}
|
|
cur = cur.next;
|
|
}
|
|
return errors;
|
|
}
|
|
|
|
/**
|
|
* Starts loading all images tracked by this media tracker with the
|
|
* specified identifier. This method waits until all the images with
|
|
* the specified identifier have finished loading.
|
|
* <p>
|
|
* If there is an error while loading or scaling an image, then that
|
|
* image is considered to have finished loading. Use the
|
|
* <code>isErrorAny</code> and <code>isErrorID</code> methods to
|
|
* check for errors.
|
|
* @param id the identifier of the images to check
|
|
* @see java.awt.MediaTracker#waitForAll
|
|
* @see java.awt.MediaTracker#isErrorAny()
|
|
* @see java.awt.MediaTracker#isErrorID(int)
|
|
* @exception InterruptedException if any thread has
|
|
* interrupted this thread.
|
|
*/
|
|
public void waitForID(int id) throws InterruptedException {
|
|
waitForID(id, 0);
|
|
}
|
|
|
|
/**
|
|
* Starts loading all images tracked by this media tracker with the
|
|
* specified identifier. This method waits until all the images with
|
|
* the specified identifier have finished loading, or until the
|
|
* length of time specified in milliseconds by the <code>ms</code>
|
|
* argument has passed.
|
|
* <p>
|
|
* If there is an error while loading or scaling an image, then that
|
|
* image is considered to have finished loading. Use the
|
|
* <code>statusID</code>, <code>isErrorID</code>, and
|
|
* <code>isErrorAny</code> methods to check for errors.
|
|
* @param id the identifier of the images to check
|
|
* @param ms the length of time, in milliseconds, to wait
|
|
* for the loading to complete
|
|
* @see java.awt.MediaTracker#waitForAll
|
|
* @see java.awt.MediaTracker#waitForID(int)
|
|
* @see java.awt.MediaTracker#statusID
|
|
* @see java.awt.MediaTracker#isErrorAny()
|
|
* @see java.awt.MediaTracker#isErrorID(int)
|
|
* @exception InterruptedException if any thread has
|
|
* interrupted this thread.
|
|
*/
|
|
public synchronized boolean waitForID(int id, long ms)
|
|
throws InterruptedException
|
|
{
|
|
long end = System.currentTimeMillis() + ms;
|
|
boolean first = true;
|
|
while (true) {
|
|
int status = statusID(id, first, first);
|
|
if ((status & LOADING) == 0) {
|
|
return (status == COMPLETE);
|
|
}
|
|
first = false;
|
|
long timeout;
|
|
if (ms == 0) {
|
|
timeout = 0;
|
|
} else {
|
|
timeout = end - System.currentTimeMillis();
|
|
if (timeout <= 0) {
|
|
return false;
|
|
}
|
|
}
|
|
wait(timeout);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculates and returns the bitwise inclusive <b>OR</b> of the
|
|
* status of all media with the specified identifier that are
|
|
* tracked by this media tracker.
|
|
* <p>
|
|
* Possible flags defined by the
|
|
* <code>MediaTracker</code> class are <code>LOADING</code>,
|
|
* <code>ABORTED</code>, <code>ERRORED</code>, and
|
|
* <code>COMPLETE</code>. An image that hasn't started
|
|
* loading has zero as its status.
|
|
* <p>
|
|
* If the value of <code>load</code> is <code>true</code>, then
|
|
* this method starts loading any images that are not yet being loaded.
|
|
* @param id the identifier of the images to check
|
|
* @param load if <code>true</code>, start loading
|
|
* any images that are not yet being loaded
|
|
* @return the bitwise inclusive <b>OR</b> of the status of
|
|
* all of the media with the specified
|
|
* identifier that are being tracked
|
|
* @see java.awt.MediaTracker#statusAll(boolean)
|
|
* @see java.awt.MediaTracker#LOADING
|
|
* @see java.awt.MediaTracker#ABORTED
|
|
* @see java.awt.MediaTracker#ERRORED
|
|
* @see java.awt.MediaTracker#COMPLETE
|
|
*/
|
|
public int statusID(int id, boolean load) {
|
|
return statusID(id, load, true);
|
|
}
|
|
|
|
private synchronized int statusID(int id, boolean load, boolean verify) {
|
|
MediaEntry cur = head;
|
|
int status = 0;
|
|
while (cur != null) {
|
|
if (cur.getID() == id) {
|
|
status = status | cur.getStatus(load, verify);
|
|
}
|
|
cur = cur.next;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* Removes the specified image from this media tracker.
|
|
* All instances of the specified image are removed,
|
|
* regardless of scale or ID.
|
|
* @param image the image to be removed
|
|
* @see java.awt.MediaTracker#removeImage(java.awt.Image, int)
|
|
* @see java.awt.MediaTracker#removeImage(java.awt.Image, int, int, int)
|
|
* @since JDK1.1
|
|
*/
|
|
public synchronized void removeImage(Image image) {
|
|
removeImageImpl(image);
|
|
Image rvImage = getResolutionVariant(image);
|
|
if (rvImage != null) {
|
|
removeImageImpl(rvImage);
|
|
}
|
|
notifyAll(); // Notify in case remaining images are "done".
|
|
}
|
|
|
|
private void removeImageImpl(Image image) {
|
|
MediaEntry cur = head;
|
|
MediaEntry prev = null;
|
|
while (cur != null) {
|
|
MediaEntry next = cur.next;
|
|
if (cur.getMedia() == image) {
|
|
if (prev == null) {
|
|
head = next;
|
|
} else {
|
|
prev.next = next;
|
|
}
|
|
cur.cancel();
|
|
} else {
|
|
prev = cur;
|
|
}
|
|
cur = next;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the specified image from the specified tracking
|
|
* ID of this media tracker.
|
|
* All instances of <code>Image</code> being tracked
|
|
* under the specified ID are removed regardless of scale.
|
|
* @param image the image to be removed
|
|
* @param id the tracking ID from which to remove the image
|
|
* @see java.awt.MediaTracker#removeImage(java.awt.Image)
|
|
* @see java.awt.MediaTracker#removeImage(java.awt.Image, int, int, int)
|
|
* @since JDK1.1
|
|
*/
|
|
public synchronized void removeImage(Image image, int id) {
|
|
removeImageImpl(image, id);
|
|
Image rvImage = getResolutionVariant(image);
|
|
if (rvImage != null) {
|
|
removeImageImpl(rvImage, id);
|
|
}
|
|
notifyAll(); // Notify in case remaining images are "done".
|
|
}
|
|
|
|
private void removeImageImpl(Image image, int id) {
|
|
MediaEntry cur = head;
|
|
MediaEntry prev = null;
|
|
while (cur != null) {
|
|
MediaEntry next = cur.next;
|
|
if (cur.getID() == id && cur.getMedia() == image) {
|
|
if (prev == null) {
|
|
head = next;
|
|
} else {
|
|
prev.next = next;
|
|
}
|
|
cur.cancel();
|
|
} else {
|
|
prev = cur;
|
|
}
|
|
cur = next;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the specified image with the specified
|
|
* width, height, and ID from this media tracker.
|
|
* Only the specified instance (with any duplicates) is removed.
|
|
* @param image the image to be removed
|
|
* @param id the tracking ID from which to remove the image
|
|
* @param width the width to remove (-1 for unscaled)
|
|
* @param height the height to remove (-1 for unscaled)
|
|
* @see java.awt.MediaTracker#removeImage(java.awt.Image)
|
|
* @see java.awt.MediaTracker#removeImage(java.awt.Image, int)
|
|
* @since JDK1.1
|
|
*/
|
|
public synchronized void removeImage(Image image, int id,
|
|
int width, int height) {
|
|
removeImageImpl(image, id, width, height);
|
|
Image rvImage = getResolutionVariant(image);
|
|
if (rvImage != null) {
|
|
removeImageImpl(rvImage, id,
|
|
width == -1 ? -1 : 2 * width,
|
|
height == -1 ? -1 : 2 * height);
|
|
}
|
|
notifyAll(); // Notify in case remaining images are "done".
|
|
}
|
|
|
|
private void removeImageImpl(Image image, int id, int width, int height) {
|
|
MediaEntry cur = head;
|
|
MediaEntry prev = null;
|
|
while (cur != null) {
|
|
MediaEntry next = cur.next;
|
|
if (cur.getID() == id && cur instanceof ImageMediaEntry
|
|
&& ((ImageMediaEntry) cur).matches(image, width, height))
|
|
{
|
|
if (prev == null) {
|
|
head = next;
|
|
} else {
|
|
prev.next = next;
|
|
}
|
|
cur.cancel();
|
|
} else {
|
|
prev = cur;
|
|
}
|
|
cur = next;
|
|
}
|
|
}
|
|
|
|
synchronized void setDone() {
|
|
notifyAll();
|
|
}
|
|
|
|
private static Image getResolutionVariant(Image image) {
|
|
if (image instanceof MultiResolutionToolkitImage) {
|
|
return ((MultiResolutionToolkitImage) image).getResolutionVariant();
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
abstract class MediaEntry {
|
|
MediaTracker tracker;
|
|
int ID;
|
|
MediaEntry next;
|
|
|
|
int status;
|
|
boolean cancelled;
|
|
|
|
MediaEntry(MediaTracker mt, int id) {
|
|
tracker = mt;
|
|
ID = id;
|
|
}
|
|
|
|
abstract Object getMedia();
|
|
|
|
static MediaEntry insert(MediaEntry head, MediaEntry me) {
|
|
MediaEntry cur = head;
|
|
MediaEntry prev = null;
|
|
while (cur != null) {
|
|
if (cur.ID > me.ID) {
|
|
break;
|
|
}
|
|
prev = cur;
|
|
cur = cur.next;
|
|
}
|
|
me.next = cur;
|
|
if (prev == null) {
|
|
head = me;
|
|
} else {
|
|
prev.next = me;
|
|
}
|
|
return head;
|
|
}
|
|
|
|
int getID() {
|
|
return ID;
|
|
}
|
|
|
|
abstract void startLoad();
|
|
|
|
void cancel() {
|
|
cancelled = true;
|
|
}
|
|
|
|
static final int LOADING = MediaTracker.LOADING;
|
|
static final int ABORTED = MediaTracker.ABORTED;
|
|
static final int ERRORED = MediaTracker.ERRORED;
|
|
static final int COMPLETE = MediaTracker.COMPLETE;
|
|
|
|
static final int LOADSTARTED = (LOADING | ERRORED | COMPLETE);
|
|
static final int DONE = (ABORTED | ERRORED | COMPLETE);
|
|
|
|
synchronized int getStatus(boolean doLoad, boolean doVerify) {
|
|
if (doLoad && ((status & LOADSTARTED) == 0)) {
|
|
status = (status & ~ABORTED) | LOADING;
|
|
startLoad();
|
|
}
|
|
return status;
|
|
}
|
|
|
|
void setStatus(int flag) {
|
|
synchronized (this) {
|
|
status = flag;
|
|
}
|
|
tracker.setDone();
|
|
}
|
|
}
|
|
|
|
class ImageMediaEntry extends MediaEntry implements ImageObserver,
|
|
java.io.Serializable {
|
|
Image image;
|
|
int width;
|
|
int height;
|
|
|
|
/*
|
|
* JDK 1.1 serialVersionUID
|
|
*/
|
|
private static final long serialVersionUID = 4739377000350280650L;
|
|
|
|
ImageMediaEntry(MediaTracker mt, Image img, int c, int w, int h) {
|
|
super(mt, c);
|
|
image = img;
|
|
width = w;
|
|
height = h;
|
|
}
|
|
|
|
boolean matches(Image img, int w, int h) {
|
|
return (image == img && width == w && height == h);
|
|
}
|
|
|
|
Object getMedia() {
|
|
return image;
|
|
}
|
|
|
|
synchronized int getStatus(boolean doLoad, boolean doVerify) {
|
|
if (doVerify) {
|
|
int flags = tracker.target.checkImage(image, width, height, null);
|
|
int s = parseflags(flags);
|
|
if (s == 0) {
|
|
if ((status & (ERRORED | COMPLETE)) != 0) {
|
|
setStatus(ABORTED);
|
|
}
|
|
} else if (s != status) {
|
|
setStatus(s);
|
|
}
|
|
}
|
|
return super.getStatus(doLoad, doVerify);
|
|
}
|
|
|
|
void startLoad() {
|
|
if (tracker.target.prepareImage(image, width, height, this)) {
|
|
setStatus(COMPLETE);
|
|
}
|
|
}
|
|
|
|
int parseflags(int infoflags) {
|
|
if ((infoflags & ERROR) != 0) {
|
|
return ERRORED;
|
|
} else if ((infoflags & ABORT) != 0) {
|
|
return ABORTED;
|
|
} else if ((infoflags & (ALLBITS | FRAMEBITS)) != 0) {
|
|
return COMPLETE;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public boolean imageUpdate(Image img, int infoflags,
|
|
int x, int y, int w, int h) {
|
|
if (cancelled) {
|
|
return false;
|
|
}
|
|
int s = parseflags(infoflags);
|
|
if (s != 0 && s != status) {
|
|
setStatus(s);
|
|
}
|
|
return ((status & LOADING) != 0);
|
|
}
|
|
}
|