Computer Shopper 139/dpcs0999.iso/Web/CFserver/data1.cab/Java/netscape/application/EventLoop.class

Java Class File | 1999-04-12 | 3.9 KB | 210 lines

package netscape.application;

import netscape.util.InconsistencyException;
import netscape.util.Vector;

public class EventLoop implements Runnable {
   Vector events = new Vector();
   Thread mainThread;
   private boolean shouldRun = false;
   static boolean letAwtThreadRun = true;

   public void addEvent(Event var1) {
      Vector var2 = this.events;
      synchronized(var2){}

      try {
         this.events.addElement(var1);
         this.events.notify();
      } catch (Throwable var4) {
         throw var4;
      }

   }

   final void letAWTThreadRun() {
      if (letAwtThreadRun) {
         if (this.shouldProcessSynchronously()) {
            Thread var1 = Thread.currentThread();
            int var2 = var1.getPriority();
            int var3 = var2 - 1;
            if (var3 < 1) {
               var3 = 1;
            }

            try {
               var1.setPriority(var3);
               Thread.yield();
               var1.setPriority(var2);
            } catch (SecurityException var4) {
               letAwtThreadRun = false;
            }
         }
      }
   }

   public void removeEvent(Event var1) {
      Vector var2 = this.events;
      synchronized(var2){}

      try {
         this.events.removeElement(var1);
      } catch (Throwable var4) {
         throw var4;
      }

   }

   public Object filterEvents(EventFilter var1) {
      this.letAWTThreadRun();
      Vector var3 = this.events;
      synchronized(var3){}

      Object var2;
      try {
         var2 = var1.filterEvents(this.events);
         this.events.notify();
      } catch (Throwable var5) {
         throw var5;
      }

      return var2;
   }

   public Event getNextEvent() {
      Object var1 = null;
      Vector var2 = this.events;
      synchronized(var2){}

      try {
         while(this.events.count() == 0) {
            try {
               this.events.wait();
            } catch (InterruptedException var5) {
            }
         }

         var7 = (Event)this.events.removeFirstElement();
      } catch (Throwable var6) {
         throw var6;
      }

      return var7;
   }

   public Event peekNextEvent() {
      this.letAWTThreadRun();
      Vector var2 = this.events;
      synchronized(var2){}

      Event var1;
      try {
         var1 = (Event)this.events.firstElement();
      } catch (Throwable var4) {
         throw var4;
      }

      return var1;
   }

   public void processEvent(Event var1) {
      Object var2 = var1.synchronousLock();
      Application var3 = Application.application();
      var3.willProcessInternalEvent(var1);
      var3.willProcessEvent(var1);
      var1.processor().processEvent(var1);
      if (var2 != null) {
         synchronized(var2){}

         try {
            var1.clearSynchronousLock();
            var2.notify();
         } catch (Throwable var6) {
            throw var6;
         }
      }

      var3.didProcessEvent(var1);
      var3.didProcessInternalEvent(var1);
   }

   public void run() {
      synchronized(this){}

      try {
         if (this.mainThread != null) {
            throw new InconsistencyException("Only one thread may run an EventLoop");
         }

         this.mainThread = Thread.currentThread();
         this.shouldRun = true;
      } catch (Throwable var11) {
         throw var11;
      }

      while(this.shouldRun) {
         Event var1 = this.getNextEvent();
         if (this.shouldRun) {
            try {
               this.processEvent(var1);
            } catch (Exception var10) {
               System.err.println(Application.application().exceptionHeader());
               ((Throwable)var10).printStackTrace(System.err);
               System.err.println("Restarting EventLoop.");
            }
         }
      }

      synchronized(this){}

      try {
         this.mainThread = null;
      } catch (Throwable var9) {
         throw var9;
      }

   }

   public synchronized void stopRunning() {
      ApplicationEvent var1 = new ApplicationEvent();
      this.shouldRun = false;
      var1.type = -25;
      this.addEvent(var1);
   }

   public synchronized boolean isRunning() {
      return this.shouldRun;
   }

   synchronized boolean shouldProcessSynchronously() {
      return this.mainThread == null || Thread.currentThread() == this.mainThread;
   }

   public void addEventAndWait(Event var1) {
      if (Thread.currentThread() == this.mainThread) {
         throw new InconsistencyException("Can't call addEventAndWait from within the EventLoop's main thread");
      } else {
         Object var2 = var1.createSynchronousLock();
         synchronized(var2){}

         try {
            this.addEvent(var1);

            while(var1.synchronousLock() != null) {
               try {
                  var2.wait();
               } catch (InterruptedException var6) {
               }
            }
         } catch (Throwable var7) {
            throw var7;
         }

      }
   }

   public synchronized String toString() {
      return this.events.toString();
   }
}