// we get into this loop if the Slideshow thread isn't
         // finished displaying the previous ImageObject
         while (available)
         {
            try
            {
               wait(250);
            }
            catch (InterruptedException ie)
            {
               continue;
            }
         }
         System.out.println("\n" + Thread.currentThread().getName() + " -
Notify image " + image_obj.url + " is ready.");

         // set the ImageObject for the Slideshow to display
         this.image_obj = image_obj;

         // notify the Slideshow thread that it's time to wake up
         // and display this new ImageObject.
         available = true;
         notifyAll();
      }
   }


   /****************************************************************************
    * This class extends a Canvas and is used to draw the image represented in
    * the ImageObject. An instance of this class resides in the ScrollPane of
    * the Slideshow.
    *
    * The sequence of events is this:
    * 1. getImage() is called in the fetchImage() method
    * 2. prepareImage() is called in the fetchImage() method which initiates
    * the loading of the image in a VM spawned thread. The CurrentPicture
    * is the ImageObserver.
    * 3. imageUpdate() is called asynchronously by the image loading thread.
    * 4. when the image is complete we release a monitor that may have been
    * blocking the Slideshow. The Slideshow then proceeds to the next
    * image.
    */
   class CurrentPicture extends Canvas
   {
      ImageObject img_obj = null;
      Image image = null;
      Object sync_up = new Object();
      int _width = 0,
                   _height = 0;
      boolean have_width = false,
                   have_height = false,
                   size_updated = false,
                   image_complete = false;

      void fetchImage(ImageObject img_obj)
      {
         System.out.println(Thread.currentThread().getName() + " - fetchImage
() - " + img_obj.url);

         this.img_obj = img_obj;

         // clear the drawing canvas
         Graphics g = getGraphics();
         if (g != null)
         {
            g.clearRect(0,0, getSize().width, getSize().height);
            g.dispose();
         }

         // reset flags
         have_width = false;
         have_height = false;
         size_updated = false;

         // save the old image so we can flush() it.
         Image old_image = image;

         // this avoids a race condition that seems to be occuring?
         image = null;

         // get the new image
         image = getToolkit().getImage(img_obj.url);
         if (image == null)
         {
            System.out.println("getImage failed for URL " + img_obj.url);
            System.exit(0);
         }

         if (image_complete)
            System.out.println(Thread.currentThread().getName() + " - fetchImage
() - image is complete too soon.");

         // prep the picture for loading, this should start the image thread
         // image_complete = CurrentPicture.this.prepareImage(image,-1,-
1,CurrentPicture.this);
         image_complete = CurrentPicture.this.prepareImage(image,
CurrentPicture.this);
         System.out.println(Thread.currentThread().getName() + " - fetchImage
() - " + (image_complete ? "Image already prepared!" : "Image being
prepared."));

         // flush the old image
         if (old_image != null)
         {
            System.out.println(Thread.currentThread().getName() + " - fetchImage
() - flushing old image.");
            old_image.flush();
         }
      }

      /**
       * This method is called by the Slideshow thread (i.e. the run()
method). It
       * blocks here until the image is finished loading, at which point this
monitor
       * is released and the slideshow continues.
       */
      void waitOnImage()
      {
         System.out.println(Thread.currentThread().getName() + " - waiting for
image complete...");

         // while the image isn't complete
         while (!image_complete)
         {
            synchronized (sync_up)
            {
               try
               {
                  // wait to be signalled by the imageUpdate() routine when
                  // the image is complete
                  sync_up.wait(250);
                  // System.out.println( (image_complete ? "Image
complete" : "Image not complete yet"));
               }
               catch (InterruptedException ie)
               {
                  continue;
               }
            }
         }
         System.out.println(Thread.currentThread().getName() + " - image says
it's complete.");
         image_complete = false;
      }

      /**
       * Override update() to keep the canvas from being cleared each time
       * which causes flicker.
       */
      public void update(Graphics g)
      {
         if (g != null)
            paint(g);
      }

      /**
       * Override paint() so we can draw the image as received this far.
       */
      public void paint(Graphics g)
      {
         if (image != null)
         {
            // Uncomment this to see that paint() really is getting called.
            // System.out.println(Thread.currentThread().getName() + " - paint
()");
            g.drawImage(image,0,0,null);
         }
      }

      /**
       * Prefer to be as large as the image, provided that we have been told
       * the width and height in one of the imageUpdate() method calls.
       */
      public Dimension getPreferredSize()
      {
         if (have_width && have_height)
            return new Dimension(_width, _height);
         else
            return new Dimension(600,600);
      }

      /**
       * Override the imageUpdate() method. The VM launched image thread will
       * call this method with progress infomation as the image loads. It will
       * tell us how big the image is, and when it is complete.
       */
      public boolean imageUpdate(Image img, int flags, int x, int y, int w, int
h)
      {
         // this early exit prevents sporadic updates I have encountered from
         // previous images. The sporadic updates occur when image.flush() is
         // called in fetchImage(). Sometimes the last image loaded will send
         // an ABORT flag when flushed, even though it has already indicated
         // successful completion previously.
         if (img != image || image_complete)
            return false;

         boolean ret = true;

         // System.out.println(Thread.currentThread().getName() + " -
imageUpdate(" + flags + ") - " + img);

         // we have the width now
         if ((flags & ImageObserver.WIDTH) == ImageObserver.WIDTH)
         {
            have_width = true;
            _width = w;
         }

         // we have the height now
         if ((flags & ImageObserver.HEIGHT) == ImageObserver.HEIGHT)
         {
            have_height = true;
            _height = h;
         }

         // if we have the width and height but have not yet resized the
         // Slideshow to fit the image, then update the size of the
         // ScrollPane in the Slideshow, then pack it. This causes the
         // Slideshow to conform to our new image.
         if (!size_updated && have_width && have_height)
         {
            size_updated = true;

            Insets inset = spane.getInsets();
            spane.setSize(_width + 50, _height + 50);
            spane.doLayout();
            Slideshow.this.pack();
         }

         // cause a repaint of the canvas with the image this far.
         if (img == image)
         {
            repaint();
         }

         // if the image terminated in any fashion
         if (((flags & ImageObserver.ABORT) != 0) ||
             ((flags & ImageObserver.ERROR) != 0) ||
             ((flags & (ImageObserver.ALLBITS | ImageObserver.FRAMEBITS)) != 0))
         {
            // notify the Slideshow thread this image is complete. The
Slideshow
            // thread is probably blocked in waitOnImage() awaiting this nod
from us.
            synchronized (sync_up)
            {
               image_complete = true;
               sync_up.notifyAll();
               System.out.println(Thread.currentThread().getName() + " in
imageUpdate() - Notifying slideshow that image is complete.");
            }
            ret = false;
         }

         /* uncomment this to slow the load down more
         try { Thread.sleep(20); } catch (InterruptedException ie) { }
         */
         return ret;
      }
   }
}

/****************************************************************************
 * An object which gets placed into the image load queue that contains the
 * "url" of the image to be loaded
 */
class ImageObject
{
   public URL url = null;

   public ImageObject(String url_string)
   {
      try
      {
         url = new URL(url_string);
      }
      catch (MalformedURLException mue)
      {
         mue.printStackTrace();
      }
   }
}
(Review ID: 101262)
======================================================================


Name: skT45625 Date: 05/09/2000


java version "1.3.0rc1"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.3.0rc1-T)
Java HotSpot(TM) Client VM (build 1.3.0rc1-S, mixed mode)

We have an application which loads images through a URL (via a custom URL
stream handler). The images are intended to progressively display as they are
downloaded from the net (via the stream handler). Under JDK1.1, they do indeed
progressively display. However, under JDK1.3 (and JDK1.2.2), the image is not
displayed as it loads -- but the paint() method can be observed as being called
many times during the load process. This defect is delaying the release of a
commercial package. The product has been ported to Swing (Java2), and we
initially thought it to be a Swing problem. But investigation resulted in
boiling it down to a problem in the underlying AWT layer. Most likely caused
by the replacement of native implementation of the Image class with a Java
implementation. The old Image class and the new one are obviously not
functionally equivalent. If there is a God in heaven, he will enable you to
fix this before 1.3 goes golden. ^_^

Included below is code to reproduce the problem. Cut, paste, compile. Run it
under JDK1.1 and then under JDK1.3 (in Windows NT if you want to duplicate my
environment). It is a simple slideshow in which images are loaded via a custom
URL handler. The custom URL handler is largely irrelavent, but we wanted to
closely approximate what our application does. The slow-load caused by the
custom handler allows you to observe progressive loading more readily (as might
be seen over a slow internet connection).

Run the code as follows:

> java TestURL3 <path to a directory with images>

All of the classes below where in one file (rather than one file per class) --
I cleaned it up as best I could for readability:

import java.io.*;
import java.net.*;
import java.awt.*;
import java.util.*;
import java.awt.image.*;
import java.awt.event.*;

public class TestURL3
{
   public Slideshow slideshow = new Slideshow();

   public static void main(String[] args)
   {
      if (args.length == 0)
      {
         System.err.println("\nSupply a path where images are located.\n");
         System.exit(0);
      }

      // Set the factory that implements our own URL protocol.
      URL.setURLStreamHandlerFactory(new TestURLStreamHandlerFactory());

      TestURL3 test = new TestURL3();

      test.slideshow.setVisible(true);
      Thread thread1 = new Thread(test.slideshow, "Slideshow");
      thread1.start();

      test.go(args[0]);
   }

   public void go(String path)
   {
      String[] file_list = new File(path).list();
      while (true)
      {
         for (int i = 0; i < file_list.length; i++)
         {
            // if the file is a .jpg or a .gif then send it to the slideshow
            if (file_list[i].toLowerCase().endsWith(".jpg") ||
                file_list[i].toLowerCase().endsWith(".gif"))
            {
               // create a url string that uses our custom "test:" protocol
               String url = "test:/" + path + File.separator + file_list[i];

               // create an ImageObject that uses that url
               ImageObject image_obj = new ImageObject(url);

               try
               {
                  // tell the Slideshow to display the image represented by our
                  // ImageObject (using the custom url).
                  slideshow.view(image_obj);

                  // Open the connection under the URL object
                  URLConnection connection = image_obj.url.openConnection();

                  connection.connect();

                  // get the stream for the URL so we can write data to it --
                  // the awt.image in the slide show will read the data
                  OutputStream out = connection.getOutputStream();

                  // open the file on the disk for reading
                  BufferedInputStream in;
                  in = new BufferedInputStream(new FileInputStream(path +
File.separator + file_list[i]));

                  int len;
                  byte[] b = new byte[45];
                  outer: while ( (len = in.read(b)) != -1)
                  {
                     int retry = 0;

                     while (true)
                     {
                        // write the file's data into the URL's stream
                        try
                        {
                           out.write(b,0,len);
                           break;
                        }
                        catch (NullPointerException npe)
                        {
                           npe.printStackTrace();
                           if (retry++ > 3)
                              break outer;
                           Thread.currentThread().yield();
                           try { Thread.sleep(250); } catch
(InterruptedException e) { }
                        }
                        catch (IOException ie)
                        {
                           ie.printStackTrace();
                           break outer;
                        }
                     }
                  }

                  in.close();

                  // Sleep for a 5 secs
                  try { Thread.sleep(5000); } catch (InterruptedException e) { }

                  TestURLStreamHandler.closeConnection(image_obj.url);
               }
               catch (IOException ie)
               {
                  ie.printStackTrace();
                  System.exit(0);
               }
            }
         }
      }
   }
}



/****************************************************************************
 * This class implements a URLStreamHandlerFactory. It creates a
 * URLStreamHandler to handle a protocol called "test". Such a protocol
 * will handle URLs of the form:
 * test://blah/blah.blah
 * ^^^^^
 */
class TestURLStreamHandlerFactory implements URLStreamHandlerFactory
{
   private TestURLStreamHandler test_url_stream_handler = new
TestURLStreamHandler();

   public URLStreamHandler createURLStreamHandler(String protocol)
   {
      System.out.println("createURLStreamHandler()");
      if (protocol.equals("test"))
         return test_url_stream_handler;
      else
         return null;
   }
}


/****************************************************************************
 * This class extends URLStreamHandler and will be called upon to create
 * URLConnections for URLs containing the "test:" protocol (rather than
 * "http:", for example). A URLConnection is the underlying communications
 * class beneath a URL. We have a custom URLConnection that facilitates our
 * custom "test:" protocol.
 */
class TestURLStreamHandler extends URLStreamHandler
{
   private static Hashtable urls = new Hashtable();

   /**
    * This method implements the abstract method from URLStreamHandler and
    * "opens" a connection for the URL provided. Returning a URLConnection
    * object, which in our case is a subclass of URLConnection.
    *
    * URLConnections that are created are put into a Hashtable, because we
    * might call this more than once and want to return the existing object
    * on the second call, rather than creating a new one.
    */
   public URLConnection openConnection(URL url)
   {
      synchronized (urls)
      {
         // Get the existing URLConnection if it exists
         URLConnection url_connection = (URLConnection)urls.get(url.toString());

         // if it doesn't exists, create one
         if (url_connection == null)
         {
            url_connection = new TestURLConnection(url);
            urls.put(url.toString(), url_connection);
            System.out.println(Thread.currentThread().getName() + " - Added to
hashtable: " + url);
         }
         else
            System.out.println(Thread.currentThread().getName() + " - Found in
hashtable: " + url);

         return url_connection;
      }
   }

   /**
    * This method is an internal method used to remove URLs from this
    * Handler's Hashtable -- where we keep URLs that have an open
    * connection.
    */
   public static void closeConnection(URL url)
   {
      synchronized (urls)
      {
         if (url != null)
         {
            TestURLConnection url_con = (TestURLConnection)urls.remove
(url.toString());
            if (url_con == null)
               System.out.println(Thread.currentThread().getName() + " - Del
URL (not in hashtable): " + url);
            else
            {
               System.out.println(Thread.currentThread().getName() + " - Del
from hashtable: " + url);
               url_con.disconnect();
            }
         }
      }
   }
}


/****************************************************************************
 * This class is this "plumbing" beneath URLs which contain the "test://"
 * protocol. It overrides three methods:
 * getInputStream()
 * getOutputStream()
 * connect()
 * Basically, it creates a "pipe stream" that we use to pipe data. Whoever
 * is reading from the URL gets data from one end of the pipe, the "pipe_out"
 * stream. Whoever is writing to the URL (it's us) puts data into the other
 * end of the pipe, the "pipe_in" stream.
 */
class TestURLConnection extends URLConnection
{
   private PipedInputStream pipe_out = null;
   private PipedOutputStream pipe_in = null;
   private Object sync_up = new Object();
   private boolean connected= false;

   /**
    * This is our constructor.
    */
   public TestURLConnection(URL url)
   {
      super(url);
   }

   /**
    * This returns a handle to an InputStream which is one end of our pipe.
    * We return "pipe_out" because the "out" of our pipe is the "in" to
    * whoever is making this call. I.e. whoever gets this will read data
    * >out of< our pipe.
    */
   public InputStream getInputStream()
   {
      System.out.println(Thread.currentThread().getName() + " - getInputStream
()");
      pipe_out = new PipedInputStream();

      do
      {
         if (pipe_in != null)
         {
            try
            {
               pipe_out.connect(pipe_in);
               connected = true;
               break;
            }
            catch (IOException ie)
            {
               ie.printStackTrace();
            }
         }

         synchronized (sync_up)
         {
            try
            {
               sync_up.wait(50);
            }
            catch (InterruptedException ie)
            {
            }
         }
      } while (!connected);

      return pipe_out;
   }

   /**
    * This returns a handle to an OutputStream which is one end of our pipe.
    * We return "pipe_in" because the "in" of our pipe is the "out" to
    * whoever is making this call. I.e. whoever gets this will write data
    * >into< our pipe.
    */
   public OutputStream getOutputStream()
   {
      System.out.println(Thread.currentThread().getName() + " - getOutputStream
()");
      pipe_in = new PipedOutputStream();

      do
      {
         if (pipe_out != null)
         {
            try
            {
               pipe_in.connect(pipe_out);
               connected = true;
               break;
            }
            catch (IOException ie)
            {
               System.err.println("Exception in getOutputStream()");
               ie.printStackTrace();
            }
         }

         synchronized (sync_up)
         {
            try
            {
               sync_up.wait(50);
            }
            catch (InterruptedException ie)
            {
            }
         }
      } while (!connected);

      return pipe_in;
   }


   /**
    * This implements the abstract method connect(). It creates the two
    * pipe ends and connects them together. Then it sets the "connected"
    * flag.
    */
   public void connect()
   {
      System.out.println(Thread.currentThread().getName() + " - connect()");
      connected = true;
   }

   /**
    * This internal method closes the two pipe ends, this disconnecting the
    * pipe.
    */
   public void disconnect()
   {
      System.out.println(Thread.currentThread().getName() + " - disconnect()");
      try
      {
         connected = false;
         if (pipe_in != null)
         {
            pipe_in.close();
         }

         pipe_out = null;
         pipe_in = null;
      }
      catch (IOException ie)
      {
         ie.printStackTrace();
      }
   }
}



/****************************************************************************
 *
 *
 *
 */
class Slideshow extends Frame implements Runnable
{
   private boolean available = false;
   private ImageObject image_obj = null;
   private CurrentPicture curr_pict = null;
   private ScrollPane spane = null;
   private Object slide_sync= new Object();

   /**
    * Construct a Slideshow (frame) with a ScrollPane and our
    * custom CurrentPicture component in it.
    */
   public Slideshow()
   {
      super("Slideshow");
      setBackground(Color.lightGray);
      setSize(400,600);

      spane = new ScrollPane(ScrollPane.SCROLLBARS_AS_NEEDED);
      add("Center", spane);

      curr_pict = new CurrentPicture();
      spane.add(curr_pict);

      addWindowListener(new WindowAdapter()
         {
            public void windowClosing(WindowEvent we) { System.exit(0); }
         });
   }

   /**
    * This is a thread that waits for an "ImageObject" to become available,
    * then calls a routine to display it.
    */
   public void run()
   {
      while (true)
      {
         synchronized (this)
         {
            System.out.println(Thread.currentThread().getName() + " - Waiting
for image...");
            // While an ImageObject isn't available
            while (!available)
            {
               try
               {
                  // wait for view() to "notify" us
                  wait(250);
               }
               catch (InterruptedException ie)
               {
                  continue;
               }
            }
            System.out.println(Thread.currentThread().getName() + " - Got an
image.");
            // call fetchImage() with the ImageObject that view() set
            curr_pict.fetchImage(image_obj);

            // this will wait to be informed by the CurrentPicture, that
            // the image load is complete. Don't ask why I didn't use a
            // MediaTracker, that's not the point.
            curr_pict.waitOnImage();

            // Now "notify" a thread that might be blocked in view(), with
            // a new ImageObject, that we are ready for another.
            available = false;
            notifyAll();
         }
      }
   }

   /**
    * This method is called from the "main" thread. It sets the
    * ImageObject and the availability flag, then "notifies" the
    * Slideshow thread (above) to display it.
    */
   public void view(ImageObject image_obj)
   {
      synchronized (this)
      {