/*
* 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);
}
}