When coding with the basic AWT, you need to work harder to produce flicker-free images: you need to use buffering. With Swing, buffering is automatically done for you by default. (You can turn it off but there is rarely a reason to do so.) If you need to acquire an image for an AWT component, first assemble your drawing in a background image, then draw the background image.

Image buffered_image = createImage(width, height);
Graphics bg = buffered_image.getGraphics();
// all drawing commands that use bg fill the buffered_image
// . . .
// finally, draw the buffer g.drawImage(buffered_image, 0, 0, null);
bg.dispose();
buffered_image.flush();

Earlier in this chapter, we used the getImage method of the Toolkit class to read an image file. However, that method was written with the assumption that an image may arrive slowly over a network connection. Instead of loading the file and returning to the caller when the image is actually loaded, the method spawns a new thread of execution to load the image and then returns to the caller without actually having completed that task. (See the Multithreading chapter of Volume 2 for more information on threads.) This is—to say the least—surprising to anyone who expects that a method won't return until it has done its job. But here, the multithreaded aspect of Java works against your assumptions. The code in our program runs in parallel with the code to load the image. Eventually, the image will be loaded and available. Of course, in the meantime, our code has tiled the entire buffer with copies of a blank image. There is a mechanism for tracking the image acquisition process. Using this mechanism, you can be notified when the image size is known, each time that a chunk of the image is ready, and finally, when the entire image is complete. When you use an Internet browser and look at a web page that contains an image, you can see how these notifications are translated into actions. An Internet browser lays out a web page as soon as it knows the sizes of the images in the page. Then it gradually fills in the images, as more detailed information becomes available. The fourth parameter of the drawImage call, which we set to null, can optionally point to an ImageObserver object that receives these notifications. However, we are not interested in incremental rendering. We just want to find out when the GIF image is completely loaded and then tile the buffer. One option is to use the ImageIO class, but that class is only available with SDK 1.4. If you use an earlier version of the SDK, you should use the MediaTracker class instead. A media tracker can track the acquisition of one or more images. (The name "media" suggests that the class should also be able to track audio files or other media. While such an extension may be available in the future, the current implementation tracks images only.) You add an image to a tracker object with the following command:

MediaTracker tracker = new MediaTracker();
Image img = Toolkit.getDefaultToolkit().getImage(name);
int id = 1; // the ID used to track the image loading process tracker.addImage(img, id);

You can add as many images as you like to a single media tracker. Each of the images should have a different ID number, but you can choose any numbering that is convenient. To wait for an image to be loaded completely, you use code like this:

try { tracker.waitForID(id); }
catch (InterruptedException e) {}

If you want to acquire multiple images, then you can add them all to the media tracker object and wait until they are all loaded. You can achieve this with the following code:

try { tracker.waitForAll(); }
catch (InterruptedException e) {}

javax.swing.ImageIO 1.4

• static BufferedImage read(File f)
• static BufferedImage read(URL u)

  These methods read an image from the given file or URL.

java.awt.Image 1.0

• boolean drawImage(Image img, int x, int y, ImageObserver observer)

  draws a scaled image. Note: This call may return before the image is drawn.

  Parameters:	img	The image to be drawn
  	x	The x-coordinate of the upper-left corner
  	y	The y-coordinate of the upper-left corner
  	observer	The object to notify of the progress of the rendering process (may be null)

• boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer)

  draws a scaled image. The system scales the image to fit into a region with the given width and height. Note: This call may return before the image is drawn.

  Parameters:	img	The image to be drawn
  	x	The x-coordinate of the upper-left corner
  	y	The y-coordinate of the upper-left corner
  	width	The desired width of image
  	height	The desired height of image
  	observer	The object to notify of the progress of the rendering process (may be null)

• void copyArea(int x, int y, int width, int height, int dx, int dy)

  copies an area of the screen.

  Parameters:	x	The x-coordinate of the upper-left corner of the source area
  	y	The y-coordinate of the upper-left corner of the source area
  	width	The width of the source area
  	height	The height of the source area
  	dx	The horizontal distance from the source area to the target area
  	dy	The vertical distance from the source area to the target area

• Graphics getGraphics()

  gets a graphics context to draw into this image buffer.

• void flush()

  releases all resources held by this image object.

java.awt.Graphics 1.0

• void dispose()

  disposes of this graphics context and releases operating system resources. You should always dispose of the graphics contexts that you receive from calls to methods such as Image.getGraphics, but not the ones handed to you by paintComponent.

java.awt.Component 1.0

• Image createImage(int width, int height)

  creates an off-screen image buffer to be used for double buffering.

  Parameters:	width	The width of the image
  	height	The height of the image

java.awt.MediaTracker 1.0

adds an image to the list of images being tracked. When the image is added, the image loading process is started.

• void waitForID(int id)

  waits until all images with the specified ID are loaded.

• void waitForAll()

  waits until all images that are being tracked are loaded.