| /* |
| * Copyright (c) 1995, 2013, 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.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); |
| } |
| } |
