home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / rt.jar / sun / awt / image / ImageFetcher.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-04-23  |  3.8 KB  |  228 lines

  1. package sun.awt.image;
  2.  
  3. import java.util.Vector;
  4.  
  5. class ImageFetcher extends Thread {
  6.    static Thread[] fetchers = new Thread[4];
  7.    static int numfetchers;
  8.    static int numwaiting;
  9.    static final int HIGH_PRIORITY = 8;
  10.    static final int LOW_PRIORITY = 3;
  11.    static final int ANIM_PRIORITY = 2;
  12.    static final int TIMEOUT = 5000;
  13.    private static Vector waitList = new Vector();
  14.  
  15.    private static ThreadGroup getImageFetcherThreadGroup() {
  16.       ThreadGroup var0;
  17.       for(var0 = Thread.currentThread().getThreadGroup(); var0.getParent() != null && var0.getParent().getParent() != null; var0 = var0.getParent()) {
  18.       }
  19.  
  20.       return var0;
  21.    }
  22.  
  23.    private ImageFetcher(int var1) {
  24.       super(getImageFetcherThreadGroup(), "Image Fetcher " + var1);
  25.       ((Thread)this).setDaemon(true);
  26.    }
  27.  
  28.    public static void add(ImageFetchable var0) {
  29.       Vector var1 = waitList;
  30.       synchronized(var1){}
  31.  
  32.       try {
  33.          if (!waitList.contains(var0)) {
  34.             waitList.addElement(var0);
  35.             if (numwaiting == 0 && numfetchers < fetchers.length) {
  36.                for(int var3 = 0; var3 < fetchers.length; ++var3) {
  37.                   if (fetchers[var3] == null) {
  38.                      fetchers[var3] = new ImageFetcher(var3);
  39.                      fetchers[var3].start();
  40.                      ++numfetchers;
  41.                      break;
  42.                   }
  43.                }
  44.             }
  45.  
  46.             waitList.notify();
  47.          }
  48.       } catch (Throwable var5) {
  49.          throw var5;
  50.       }
  51.  
  52.    }
  53.  
  54.    public static boolean remove(ImageFetchable var0) {
  55.       Vector var2 = waitList;
  56.       synchronized(var2){}
  57.  
  58.       boolean var1;
  59.       try {
  60.          if (!waitList.contains(var0)) {
  61.             return false;
  62.          }
  63.  
  64.          waitList.removeElement(var0);
  65.          var1 = true;
  66.       } catch (Throwable var5) {
  67.          throw var5;
  68.       }
  69.  
  70.       return var1;
  71.    }
  72.  
  73.    public static boolean isFetcher(Thread var0) {
  74.       Vector var2 = waitList;
  75.       synchronized(var2){}
  76.  
  77.       try {
  78.          for(int var4 = 0; var4 < fetchers.length; ++var4) {
  79.             if (fetchers[var4] == var0) {
  80.                boolean var1 = true;
  81.                return var1;
  82.             }
  83.          }
  84.  
  85.          return false;
  86.       } catch (Throwable var6) {
  87.          throw var6;
  88.       }
  89.    }
  90.  
  91.    public static boolean amFetcher() {
  92.       return isFetcher(Thread.currentThread());
  93.    }
  94.  
  95.    private static ImageFetchable nextImage() {
  96.       Vector var1 = waitList;
  97.       synchronized(var1){}
  98.  
  99.       try {
  100.          ImageFetchable var3 = null;
  101.          long var4 = System.currentTimeMillis() + 5000L;
  102.  
  103.          while(var3 == null) {
  104.             while(waitList.size() == 0) {
  105.                long var6 = System.currentTimeMillis();
  106.                if (var6 >= var4) {
  107.                   Object var19 = null;
  108.                   return (ImageFetchable)var19;
  109.                }
  110.  
  111.                try {
  112.                   ++numwaiting;
  113.                   waitList.wait(var4 - var6);
  114.                } catch (InterruptedException var16) {
  115.                   System.err.println("Image Fetcher interrupted!");
  116.                   Object var0 = null;
  117.                   return (ImageFetchable)var0;
  118.                } finally {
  119.                   --numwaiting;
  120.                }
  121.             }
  122.  
  123.             var3 = (ImageFetchable)waitList.elementAt(0);
  124.             waitList.removeElement(var3);
  125.          }
  126.  
  127.          ImageFetchable var20 = var3;
  128.          return var20;
  129.       } catch (Throwable var18) {
  130.          throw var18;
  131.       }
  132.    }
  133.  
  134.    public void run() {
  135.       Thread var1 = Thread.currentThread();
  136.  
  137.       try {
  138.          this.fetchloop(var1);
  139.       } catch (Exception var19) {
  140.          ((Throwable)var19).printStackTrace();
  141.       } finally {
  142.          Vector var4 = waitList;
  143.          synchronized(var4){}
  144.  
  145.          try {
  146.             for(int var6 = 0; var6 < fetchers.length; ++var6) {
  147.                if (fetchers[var6] == var1) {
  148.                   fetchers[var6] = null;
  149.                   --numfetchers;
  150.                }
  151.             }
  152.          } catch (Throwable var20) {
  153.             throw var20;
  154.          }
  155.  
  156.       }
  157.  
  158.    }
  159.  
  160.    public void fetchloop(Thread var1) {
  161.       for(; isFetcher(var1); stoppingAnimation(var1)) {
  162.          Thread.interrupted();
  163.          var1.setPriority(8);
  164.          ImageFetchable var2 = nextImage();
  165.          if (var2 == null) {
  166.             return;
  167.          }
  168.  
  169.          try {
  170.             var2.doFetch();
  171.          } catch (Exception var4) {
  172.             System.err.println("Uncaught error fetching image:");
  173.             ((Throwable)var4).printStackTrace();
  174.          }
  175.       }
  176.  
  177.    }
  178.  
  179.    public static void startingAnimation() {
  180.       Thread var0 = Thread.currentThread();
  181.       Vector var1 = waitList;
  182.       synchronized(var1){}
  183.  
  184.       try {
  185.          for(int var3 = 0; var3 < fetchers.length; ++var3) {
  186.             if (fetchers[var3] == var0) {
  187.                fetchers[var3] = null;
  188.                --numfetchers;
  189.                var0.setName("Image Animator " + var3);
  190.                return;
  191.             }
  192.          }
  193.       } catch (Throwable var5) {
  194.          throw var5;
  195.       }
  196.  
  197.       var0.setPriority(2);
  198.       var0.setName("Image Animator");
  199.    }
  200.  
  201.    private static void stoppingAnimation(Thread var0) {
  202.       Vector var1 = waitList;
  203.       synchronized(var1){}
  204.  
  205.       try {
  206.          int var3 = -1;
  207.  
  208.          for(int var4 = 0; var4 < fetchers.length; ++var4) {
  209.             if (fetchers[var4] == var0) {
  210.                return;
  211.             }
  212.  
  213.             if (fetchers[var4] == null) {
  214.                var3 = var4;
  215.             }
  216.          }
  217.  
  218.          if (var3 >= 0) {
  219.             fetchers[var3] = var0;
  220.             ++numfetchers;
  221.             var0.setName("Image Fetcher " + var3);
  222.          }
  223.       } catch (Throwable var6) {
  224.          throw var6;
  225.       }
  226.    }
  227. }
  228.