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