Chip 2001 June/CHIPHEFT062001.ISO/browser/nc32lyc/comm.z/java40.jar/sun/awt/image/ImageFetcher.class

Java Class File | 2000-08-15 | 4.5 KB | 260 lines

package sun.awt.image;

import java.util.Vector;

class ImageFetcher extends Thread {
   static Thread[] fetchers = null;
   static int numfetchers;
   static int numwaiting;
   static final int HIGH_PRIORITY = 8;
   static final int LOW_PRIORITY = 3;
   static final int ANIM_PRIORITY = 2;
   static final int TIMEOUT = 5000;
   private static Vector waitList = new Vector();
   private static ThreadGroup imageFetcherThreadGroup;

   private static ThreadGroup getImageFetcherThreadGroup() {
      ThreadGroup var0;
      for(var0 = Thread.currentThread().getThreadGroup(); var0.getParent() != null && var0.getParent().getParent() != null; var0 = var0.getParent()) {
      }

      return var0;
   }

   private ImageFetcher(int var1) {
      super(imageFetcherThreadGroup, "Image Fetcher " + var1);
      SecurityManager.enablePrivilege("UniversalThreadAccess");
      ((Thread)this).setDaemon(true);
   }

   public static void add(ImageFetchable var0) {
      Vector var1 = waitList;
      synchronized(var1){}

      try {
         if (!waitList.contains(var0)) {
            waitList.addElement(var0);
            if (numwaiting == 0 && numfetchers < fetchers.length) {
               for(int var3 = 0; var3 < fetchers.length; ++var3) {
                  if (fetchers[var3] == null) {
                     SecurityManager.enablePrivilege("UniversalThreadGroupAccess");
                     fetchers[var3] = new ImageFetcher(var3);
                     SecurityManager.revertPrivilege();
                     fetchers[var3].start();
                     ++numfetchers;
                     break;
                  }
               }
            }

            waitList.notify();
         }
      } catch (Throwable var5) {
         throw var5;
      }

   }

   public static boolean remove(ImageFetchable var0) {
      Vector var2 = waitList;
      synchronized(var2){}

      boolean var1;
      try {
         if (!waitList.contains(var0)) {
            return false;
         }

         waitList.removeElement(var0);
         var1 = true;
      } catch (Throwable var5) {
         throw var5;
      }

      return var1;
   }

   public static boolean isFetcher(Thread var0) {
      Vector var2 = waitList;
      synchronized(var2){}

      try {
         for(int var4 = 0; var4 < fetchers.length; ++var4) {
            if (fetchers[var4] == var0) {
               boolean var1 = true;
               return var1;
            }
         }

         return false;
      } catch (Throwable var6) {
         throw var6;
      }
   }

   public static boolean amFetcher() {
      return isFetcher(Thread.currentThread());
   }

   private static ImageFetchable nextImage() {
      Vector var1 = waitList;
      synchronized(var1){}

      try {
         ImageFetchable var3 = null;
         long var4 = System.currentTimeMillis() + 5000L;

         while(var3 == null) {
            while(waitList.size() == 0) {
               long var6 = System.currentTimeMillis();
               if (var6 >= var4) {
                  Object var19 = null;
                  return (ImageFetchable)var19;
               }

               try {
                  ++numwaiting;
                  waitList.wait(var4 - var6);
               } catch (InterruptedException var16) {
                  System.err.println("Image Fetcher interrupted!");
                  Object var0 = null;
                  return (ImageFetchable)var0;
               } finally {
                  --numwaiting;
               }
            }

            var3 = (ImageFetchable)waitList.elementAt(0);
            waitList.removeElement(var3);
         }

         ImageFetchable var20 = var3;
         return var20;
      } catch (Throwable var18) {
         throw var18;
      }
   }

   public void run() {
      Thread var1 = Thread.currentThread();

      try {
         SecurityManager.enablePrivilege("UniversalConnect");
         this.fetchloop(var1);
      } catch (Exception var19) {
         ((Throwable)var19).printStackTrace();
      } finally {
         Vector var4 = waitList;
         synchronized(var4){}

         try {
            for(int var6 = 0; var6 < fetchers.length; ++var6) {
               if (fetchers[var6] == var1) {
                  fetchers[var6] = null;
                  --numfetchers;
               }
            }
         } catch (Throwable var20) {
            throw var20;
         }

      }

   }

   public void fetchloop(Thread var1) {
      for(; isFetcher(var1); stoppingAnimation(var1)) {
         Thread.interrupted();
         SecurityManager.enablePrivilege("UniversalThreadAccess");
         var1.setPriority(8);
         SecurityManager.revertPrivilege();
         ImageFetchable var2 = nextImage();
         if (var2 == null) {
            return;
         }

         try {
            var2.doFetch();
         } catch (Exception var4) {
            System.err.println("Uncaught error fetching image:");
            ((Throwable)var4).printStackTrace();
         }
      }

   }

   public static void startingAnimation() {
      Thread var0 = Thread.currentThread();
      SecurityManager.enablePrivilege("UniversalThreadAccess");
      Vector var1 = waitList;
      synchronized(var1){}

      try {
         for(int var3 = 0; var3 < fetchers.length; ++var3) {
            if (fetchers[var3] == var0) {
               fetchers[var3] = null;
               --numfetchers;
               var0.setName("Image Animator " + var3);
               return;
            }
         }
      } catch (Throwable var5) {
         throw var5;
      }

      var0.setPriority(2);
      var0.setName("Image Animator");
   }

   private static void stoppingAnimation(Thread var0) {
      Vector var1 = waitList;
      synchronized(var1){}

      try {
         int var3 = -1;

         for(int var4 = 0; var4 < fetchers.length; ++var4) {
            if (fetchers[var4] == var0) {
               return;
            }

            if (fetchers[var4] == null) {
               var3 = var4;
            }
         }

         if (var3 >= 0) {
            fetchers[var3] = var0;
            ++numfetchers;
            SecurityManager.enablePrivilege("UniversalThreadAccess");
            var0.setName("Image Fetcher " + var3);
         }
      } catch (Throwable var6) {
         throw var6;
      }
   }

   static {
      SecurityManager.enablePrivilege("UniversalPropertyRead");
      String var0 = System.getProperty("awt.imagefetchers", "4");
      SecurityManager.revertPrivilege();
      int var1 = Integer.parseInt(var0);
      fetchers = new Thread[var1];
      SecurityManager.enablePrivilege("UniversalThreadGroupAccess");

      ThreadGroup var2;
      for(var2 = Thread.currentThread().getThreadGroup(); var2.getParent() != null && var2.getParent().getParent() != null; var2 = var2.getParent()) {
      }

      imageFetcherThreadGroup = new ThreadGroup(var2, "ImageFetchers");
      imageFetcherThreadGroup.setDaemon(false);

      for(int var3 = 0; var3 < fetchers.length; ++var3) {
         Thread var4 = fetchers[var3] = new ImageFetcher(var3);
         var4.start();
      }

      SecurityManager.revertPrivilege();
   }
}