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