示例#1
0
  // --------------------------------actionDisconnect---------------------------
  private void actionDisconnect() {

    try {
      oConn.disconnect();
      tConn.join(2000);
      tMain.join(2000);
    } catch (Exception e) {
    }
  }
    public void run() {
      try {
        if (myPreviousThread != null) myPreviousThread.join();
        Thread.sleep(delay);
        log("> run MouseMoveThread " + x + ", " + y);
        while (!hasFocus()) {
          Thread.sleep(1000);
        }
        int x1 = lastMouseX;
        int x2 = x;
        int y1 = lastMouseY;
        int y2 = y;
        // shrink range by 1 px on both ends
        // manually move this 1px to trip DND code
        if (x1 != x2) {
          int dx = x - lastMouseX;
          if (dx > 0) {
            x1 += 1;
            x2 -= 1;
          } else {
            x1 -= 1;
            x2 += 1;
          }
        }
        if (y1 != y2) {
          int dy = y - lastMouseY;
          if (dy > 0) {
            y1 += 1;
            y2 -= 1;
          } else {
            y1 -= 1;
            y2 += 1;
          }
        }
        robot.setAutoDelay(Math.max(duration / 100, 1));
        robot.mouseMove(x1, y1);
        int d = 100;
        for (int t = 0; t <= d; t++) {
          x1 =
              (int)
                  easeInOutQuad(
                      (double) t, (double) lastMouseX, (double) x2 - lastMouseX, (double) d);
          y1 =
              (int)
                  easeInOutQuad(
                      (double) t, (double) lastMouseY, (double) y2 - lastMouseY, (double) d);
          robot.mouseMove(x1, y1);
        }
        robot.mouseMove(x, y);
        lastMouseX = x;
        lastMouseY = y;
        robot.waitForIdle();
        robot.setAutoDelay(1);
      } catch (Exception e) {
        log("Bad parameters passed to mouseMove");
        e.printStackTrace();
      }

      log("< run MouseMoveThread");
    }
示例#3
0
 public void quit() {
   try {
     probeThread.join(5);
   } catch (InterruptedException e) {
   }
   probeThread = null;
 }
 public synchronized void stop() {
   running = false;
   try {
     thread.join();
   } catch (InterruptedException e) {
     thread.interrupt();
   }
 }
示例#5
0
 // Fecha o jogo; M�todo join() espera a thread morrer.
 public synchronized void stop() {
   running = false;
   try {
     thread.join();
   } catch (InterruptedException e) {
     e.printStackTrace();
   }
 }
示例#6
0
 public synchronized void stop() {
   if (!running) return;
   running = false;
   try {
     gameThread.join();
   } catch (InterruptedException e) {
     e.printStackTrace();
   }
 }
示例#7
0
 public void stop() {
   quit = true;
   boolean hasQuit = false;
   while (!hasQuit) {
     try {
       thread.join();
       hasQuit = true;
     } catch (InterruptedException e) {
     }
   }
 }
 public void run() {
   try {
     if (myPreviousThread != null) myPreviousThread.join();
     Thread.sleep(delay);
     log("> run MousePressThread");
     while (!hasFocus()) {
       Thread.sleep(1000);
     }
     robot.mousePress(mask);
     robot.waitForIdle();
   } catch (Exception e) {
     log("Bad parameters passed to mousePress");
     e.printStackTrace();
   }
   log("< run MousePressThread");
 }
示例#9
0
  /** Iterate the physics, call repaint(). */
  public void run() {
    while (true) {
      repaint();
      try {
        canvas.changeSize(getHeight(), getWidth());
        simthread.sleep(10);
        canvasthread.run();
        canvasthread.join();

        // this.iters++;
      } catch (Exception ie) {
        System.out.println(ie.getMessage() + "!!!");
      }
      // System.out.println(iters + "!!");
    }
  }
    public void run() {
      try {
        if (myPreviousThread != null) myPreviousThread.join();
        // in different order so async works
        while (!hasFocus()) {
          Thread.sleep(1000);
        }
        Thread.sleep(delay);
        log("> run KeyPressThread");

        _typeKey(charCode, keyCode, alt, ctrl, shift);
      } catch (Exception e) {
        log("Bad parameters passed to _typeKey");
        e.printStackTrace();
      }
      log("< run KeyPressThread");
    }
示例#11
0
  public void testRequiredLayoutTriggeredWhilePerformingLayoutStillGetsRegistered()
      throws Exception {
    for (int i = 0; i < 100; i++) panel.add(new PropPanel(new MockProp()));
    panel.markAsNeedingLayout();
    Thread thread =
        new Thread(
            new Runnable() {
              public void run() {
                panel.doLayout();
              }
            });
    thread.start();

    while (panel.getChildren().get(0).needsLayout()) Thread.yield();
    panel.markAsNeedingLayout();
    thread.join();

    assertEquals(true, panel.needsLayout());
  }
 public void run() {
   try {
     if (myPreviousThread != null) myPreviousThread.join();
     Thread.sleep(delay);
     log("> run KeyDownThread");
     while (!hasFocus()) {
       Thread.sleep(1000);
     }
     int vkCode = getVKCode(charCode, keyCode);
     if (charCode >= 32) {
       // if it is printable, then it lives in our hashmap
       KeyEvent event = (KeyEvent) charMap.get(new Integer(charCode));
       // see if we need to press shift to generate this
       // character
       if (event.isShiftDown()) {
         robot.keyPress(KeyEvent.VK_SHIFT);
         shift = true;
       }
       if (event.isAltGraphDown()) {
         robot.keyPress(KeyEvent.VK_ALT_GRAPH);
         altgraph = true;
       }
     } else {
       if (vkCode == KeyEvent.VK_ALT) {
         alt = true;
       } else if (vkCode == KeyEvent.VK_CONTROL) {
         ctrl = true;
       } else if (vkCode == KeyEvent.VK_SHIFT) {
         shift = true;
       } else if (vkCode == KeyEvent.VK_ALT_GRAPH) {
         altgraph = true;
       }
     }
     if (!isUnsafe(vkCode)) {
       robot.keyPress(vkCode);
     }
   } catch (Exception e) {
     log("Bad parameters passed to downKey");
     e.printStackTrace();
   }
   log("< run KeyDownThread");
 }
示例#13
0
  void killPlayThread() {
    tellThreadToStop();

    try {
      if (playThread != null) {
        while (playThread.isAlive()) {
          try {
            playThread.interrupt();
          }
          // Ignore security exceptions resulting from
          // attempting to interrupt a thread.
          // TODO Explain this better.
          catch (SecurityException ex) {
          }
          playThread.join(50);
        }

        playThread = null;
      }
    } catch (InterruptedException ex) {
      System.out.println("Interrupted while killing the play thread.  Shouldn't happen.");
    }
  }
 public void run() {
   try {
     if (myPreviousThread != null) myPreviousThread.join();
     Thread.sleep(delay);
     log("> run MouseWheelThread " + amount);
     while (!hasFocus()) {
       Thread.sleep(1000);
     }
     int dir = 1;
     if (System.getProperty("os.name").toUpperCase().indexOf("MAC") != -1) {
       // yay for Apple
       dir = -1;
     }
     robot.setAutoDelay(Math.max(duration / Math.abs(amount), 1));
     for (int i = 0; i < Math.abs(amount); i++) {
       robot.mouseWheel(amount > 0 ? dir : -dir);
     }
     robot.setAutoDelay(1);
   } catch (Exception e) {
     log("Bad parameters passed to mouseWheel");
     e.printStackTrace();
   }
   log("< run MouseWheelThread ");
 }
示例#15
0
 void joinAppletThread() throws InterruptedException {
   if (handler != null) {
     handler.join();
     handler = null;
   }
 }
示例#16
0
  public static void main(String[] args) throws Exception {
    SwingUtilities.invokeAndWait(
        new Runnable() {
          public void run() {
            label = new JLabel("A JLabel used as object for an HTML-formatted tooltip");
            label.setToolTipText(
                "<html><body bgcolor=FFFFE1>An HTML-formatted ToolTip</body></html>");

            frame = new JFrame();

            frame.add(label);
            frame.pack();
            frame.setVisible(true);
          }
        });

    ((SunToolkit) SunToolkit.getDefaultToolkit()).realSync();

    SwingUtilities.invokeAndWait(
        new Runnable() {
          public void run() {
            ToolTipManager toolTipManager = ToolTipManager.sharedInstance();

            toolTipManager.setInitialDelay(0);
            toolTipManager.mouseMoved(new MouseEvent(label, 0, 0, 0, 0, 0, 0, false));
          }
        });

    Thread.sleep(500);

    SwingUtilities.invokeAndWait(
        new Runnable() {
          public void run() {
            toolTipWidth = getTipWindow().getWidth();

            frame.dispose();
          }
        });

    Thread thread =
        new Thread(
            new ThreadGroup("Some ThreadGroup"),
            new Runnable() {
              public void run() {
                SunToolkit.createNewAppContext();

                try {
                  SwingUtilities.invokeAndWait(
                      new Runnable() {
                        public void run() {
                          frame = new JFrame();

                          frame.add(label);
                          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                          frame.pack();
                          frame.setVisible(true);
                        }
                      });

                  ((SunToolkit) SunToolkit.getDefaultToolkit()).realSync();

                  SwingUtilities.invokeAndWait(
                      new Runnable() {
                        public void run() {
                          ToolTipManager toolTipManager = ToolTipManager.sharedInstance();

                          toolTipManager.setInitialDelay(0);
                          toolTipManager.mouseMoved(new MouseEvent(label, 0, 0, 0, 0, 0, 0, false));
                        }
                      });

                  Thread.sleep(500);

                  SwingUtilities.invokeAndWait(
                      new Runnable() {
                        public void run() {
                          int newToolTipWidth = getTipWindow().getWidth();

                          frame.dispose();

                          if (toolTipWidth != newToolTipWidth) {
                            throw new RuntimeException(
                                "Tooltip width is different. Initial: "
                                    + toolTipWidth
                                    + ", new: "
                                    + newToolTipWidth);
                          }
                        }
                      });
                } catch (Exception e) {
                  throw new RuntimeException(e);
                }
              }
            });

    thread.start();
    thread.join();
  }
示例#17
0
  private void processResources(Session session, Element element, HashMap additionalInformation) {
    dataFiles = new ArrayList();
    missingDataFiles = new ArrayList();
    NodeList elements = element.getChildNodes();
    process(session, elements, additionalInformation);

    if (missingDataFiles.size() > 0) {
      StringBuffer message = new StringBuffer();
      message.append("<html>The following data file(s) could not be located.<ul>");
      for (ResourceLocator file : missingDataFiles) {
        if (file.isLocal()) {
          message.append("<li>");
          message.append(file.getPath());
          message.append("</li>");
        } else {
          message.append("<li>Server: ");
          message.append(file.getServerURL());
          message.append("  Path: ");
          message.append(file.getPath());
          message.append("</li>");
        }
      }
      message.append("</ul>");
      message.append("Common reasons for this include: ");
      message.append("<ul><li>The session or data files have been moved.</li> ");
      message.append(
          "<li>The data files are located on a drive that is not currently accessible.</li></ul>");
      message.append("</html>");

      MessageUtils.showMessage(message.toString());
    }
    if (dataFiles.size() > 0) {

      final List<String> errors = new ArrayList<String>();

      // Load files concurrently -- TODO, put a limit on # of threads?
      List<Thread> threads = new ArrayList(dataFiles.size());
      long t0 = System.currentTimeMillis();
      int i = 0;
      List<Runnable> synchronousLoads = new ArrayList<Runnable>();
      for (final ResourceLocator locator : dataFiles) {

        final String suppliedPath = locator.getPath();
        final String relPath = fullToRelPathMap.get(suppliedPath);

        Runnable runnable =
            new Runnable() {
              public void run() {
                List<Track> tracks = null;
                try {
                  tracks = igv.load(locator);
                  for (Track track : tracks) {
                    if (track == null) {
                      log.info("Null track for resource " + locator.getPath());
                      continue;
                    }

                    String id = track.getId();
                    if (id == null) {
                      log.info("Null track id for resource " + locator.getPath());
                      continue;
                    }

                    if (relPath != null) {
                      id = id.replace(suppliedPath, relPath);
                    }

                    List<Track> trackList = trackDictionary.get(id);
                    if (trackList == null) {
                      trackList = new ArrayList();
                      trackDictionary.put(id, trackList);
                    }
                    trackList.add(track);
                  }
                } catch (Exception e) {
                  log.error("Error loading resource " + locator.getPath(), e);
                  String ms =
                      "<b>" + locator.getPath() + "</b><br>&nbs;p&nbsp;" + e.toString() + "<br>";
                  errors.add(ms);
                }
              }
            };

        boolean isAlignment =
            locator.getPath().endsWith(".bam")
                || locator.getPath().endsWith(".entries")
                || locator.getPath().endsWith(".sam");

        // Run synchronously if in batch mode or if there are no "track" elments, or if this is an
        // alignment file
        if (isAlignment || Globals.isBatch() || !hasTrackElments) {
          synchronousLoads.add(runnable);
        } else {
          Thread t = new Thread(runnable);
          threads.add(t);
          t.start();
        }
        i++;
      }
      // Wait for all threads to complete
      for (Thread t : threads) {
        try {
          t.join();
        } catch (InterruptedException ignore) {
        }
      }

      // Now load data that must be loaded synchronously
      for (Runnable runnable : synchronousLoads) {
        runnable.run();
      }

      long dt = System.currentTimeMillis() - t0;
      log.debug("Total load time = " + dt);

      if (errors.size() > 0) {
        StringBuffer buf = new StringBuffer();
        buf.append("<html>Errors were encountered loading the session:<br>");
        for (String msg : errors) {
          buf.append(msg);
        }
        MessageUtils.showMessage(buf.toString());
      }
    }
    dataFiles = null;
  }
  public AeronLatencyUnderLoadPublisher(final String[] args) {
    try {
      parseArgs(args);
    } catch (final ParseException e) {
      throw new RuntimeException(e);
    }
    final Aeron.Context ctx = new Aeron.Context().newImageHandler(this::imageHandler);
    fragmentHandler = new FragmentAssembler(this::msgHandler);
    final Aeron aeron = Aeron.connect(ctx);
    System.out.println("Reflect: " + reflectChannel + " Pub: " + pubChannel);
    pub = aeron.addPublication(pubChannel, pubStreamId);
    sub = aeron.addSubscription(reflectChannel, subStreamId);
    imageLatch = new CountDownLatch(1);
    final IdleStrategy idle = new BusySpinIdleStrategy();
    bufferClaim = new BufferClaim();

    final List<RateControllerInterval> intervals = new ArrayList<>();
    intervals.add(new MessagesAtMessagesPerSecondInterval(100, 10));
    intervals.add(new MessagesAtMessagesPerSecondInterval(1000, 100));
    intervals.add(new MessagesAtMessagesPerSecondInterval(10000, 1000));
    intervals.add(new MessagesAtMessagesPerSecondInterval(100000, 10000));
    intervals.add(new MessagesAtMessagesPerSecondInterval(1000000, 100000));
    intervals.add(new MessagesAtMessagesPerSecondInterval(10000000, 1000000));
    intervals.add(new MessagesAtMessagesPerSecondInterval(30000000, 3000000));
    buffer = new UnsafeBuffer(ByteBuffer.allocateDirect(msgLen));
    msgCount = 0;

    RateController rateController = null;
    try {
      rateController = new RateController(this, intervals);
    } catch (final Exception ex) {
      throw new RuntimeException(ex);
    }

    final Runnable task =
        () -> {
          while (running) {
            while (sub.poll(fragmentHandler, 1) <= 0 && running) {}
          }
          System.out.println("Done");
        };
    final Thread subThread = new Thread(task);
    subThread.start();

    try {
      imageLatch.await();
    } catch (final InterruptedException e) {
      e.printStackTrace();
    }

    final int warmUpMsgs = 100000;
    for (int i = 0; i < warmUpMsgs; i++) {
      while (pub.tryClaim(buffer.capacity(), bufferClaim) < 0L) {
        idle.idle(1);
      }
      final MutableDirectBuffer buffer = bufferClaim.buffer();
      final int offset = bufferClaim.offset();
      buffer.putByte(offset, (byte) 'w');
      bufferClaim.commit();
    }
    try {
      Thread.sleep(1000);
    } catch (final InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("warmup msgs received: " + warmups);
    final int start = (int) System.currentTimeMillis();
    while (rateController.next()) {}

    final int total = (int) (System.currentTimeMillis() - start) / 1000;
    buffer.putByte(0, (byte) 'q');

    while (pub.offer(buffer, 0, buffer.capacity()) < 0L) {
      idle.idle(0);
    }

    System.out.println("Duration: " + total + " seconds");
    try {
      Thread.sleep(1000);
    } catch (final InterruptedException e) {
      e.printStackTrace();
    }

    running = false;

    try {
      subThread.join();
    } catch (final InterruptedException e) {
      e.printStackTrace();
    }

    aeron.close();

    try {
      computeStats();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
示例#19
0
  /**
   * Execute applet events. Here is the state transition diagram
   *
   * <pre>{@literal
   *   Note: (XXX) is the action
   *         APPLET_XXX is the state
   *  (applet code loaded) --> APPLET_LOAD -- (applet init called)--> APPLET_INIT --
   *  (applet start called) --> APPLET_START -- (applet stop called) --> APPLET_STOP --
   *  (applet destroyed called) --> APPLET_DESTROY --> (applet gets disposed) -->
   *   APPLET_DISPOSE --> ...
   * }</pre>
   *
   * In the legacy lifecycle model. The applet gets loaded, inited and started. So it stays in the
   * APPLET_START state unless the applet goes away(refresh page or leave the page). So the applet
   * stop method called and the applet enters APPLET_STOP state. Then if the applet is revisited, it
   * will call applet start method and enter the APPLET_START state and stay there.
   *
   * <p>In the modern lifecycle model. When the applet first time visited, it is same as legacy
   * lifecycle model. However, when the applet page goes away. It calls applet stop method and
   * enters APPLET_STOP state and then applet destroyed method gets called and enters APPLET_DESTROY
   * state.
   *
   * <p>This code is also called by AppletViewer. In AppletViewer "Restart" menu, the applet is jump
   * from APPLET_STOP to APPLET_DESTROY and to APPLET_INIT .
   *
   * <p>Also, the applet can jump from APPLET_INIT state to APPLET_DESTROY (in Netscape/Mozilla
   * case). Same as APPLET_LOAD to APPLET_DISPOSE since all of this are triggered by browser.
   */
  @Override
  public void run() {

    Thread curThread = Thread.currentThread();
    if (curThread == loaderThread) {
      // if we are in the loader thread, cause
      // loading to occur.  We may exit this with
      // status being APPLET_DISPOSE, APPLET_ERROR,
      // or APPLET_LOAD
      runLoader();
      return;
    }

    boolean disposed = false;
    while (!disposed && !curThread.isInterrupted()) {
      AppletEvent evt;
      try {
        evt = getNextEvent();
      } catch (InterruptedException e) {
        showAppletStatus("bail");
        return;
      }

      // showAppletStatus("EVENT = " + evt.getID());
      try {
        switch (evt.getID()) {
          case APPLET_LOAD:
            if (!okToLoad()) {
              break;
            }
            // This complexity allows loading of applets to be
            // interruptable.  The actual thread loading runs
            // in a separate thread, so it can be interrupted
            // without harming the applet thread.
            // So that we don't have to worry about
            // concurrency issues, the main applet thread waits
            // until the loader thread terminates.
            // (one way or another).
            if (loaderThread == null) {
              setLoaderThread(new Thread(null, this, "AppletLoader", 0, false));
              loaderThread.start();
              // we get to go to sleep while this runs
              loaderThread.join();
              setLoaderThread(null);
            } else {
              // REMIND: issue an error -- this case should never
              // occur.
            }
            break;

          case APPLET_INIT:
            // AppletViewer "Restart" will jump from destroy method to
            // init, that is why we need to check status w/ APPLET_DESTROY
            if (status != APPLET_LOAD && status != APPLET_DESTROY) {
              showAppletStatus("notloaded");
              break;
            }
            applet.resize(defaultAppletSize);

            if (PerformanceLogger.loggingEnabled()) {
              PerformanceLogger.setTime("Applet Init");
              PerformanceLogger.outputLog();
            }
            applet.init();

            // Need the default(fallback) font to be created in this AppContext
            Font f = getFont();
            if (f == null
                || "dialog".equals(f.getFamily().toLowerCase(Locale.ENGLISH))
                    && f.getSize() == 12
                    && f.getStyle() == Font.PLAIN) {
              setFont(new Font(Font.DIALOG, Font.PLAIN, 12));
            }

            // Validate the applet in event dispatch thread
            // to avoid deadlock.
            try {
              final AppletPanel p = this;
              Runnable r =
                  new Runnable() {
                    @Override
                    public void run() {
                      p.validate();
                    }
                  };
              AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r);
            } catch (InterruptedException ie) {
            } catch (InvocationTargetException ite) {
            }

            status = APPLET_INIT;
            showAppletStatus("inited");
            break;

          case APPLET_START:
            {
              if (status != APPLET_INIT && status != APPLET_STOP) {
                showAppletStatus("notinited");
                break;
              }
              applet.resize(currentAppletSize);
              applet.start();

              // Validate and show the applet in event dispatch thread
              // to avoid deadlock.
              try {
                final AppletPanel p = this;
                final Applet a = applet;
                Runnable r =
                    new Runnable() {
                      @Override
                      public void run() {
                        p.validate();
                        a.setVisible(true);

                        // Fix for BugTraq ID 4041703.
                        // Set the default focus for an applet.
                        if (hasInitialFocus()) {
                          setDefaultFocus();
                        }
                      }
                    };
                AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r);
              } catch (InterruptedException ie) {
              } catch (InvocationTargetException ite) {
              }

              status = APPLET_START;
              showAppletStatus("started");
              break;
            }

          case APPLET_STOP:
            if (status != APPLET_START) {
              showAppletStatus("notstarted");
              break;
            }
            status = APPLET_STOP;

            // Hide the applet in event dispatch thread
            // to avoid deadlock.
            try {
              final Applet a = applet;
              Runnable r =
                  new Runnable() {
                    @Override
                    public void run() {
                      a.setVisible(false);
                    }
                  };
              AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r);
            } catch (InterruptedException ie) {
            } catch (InvocationTargetException ite) {
            }

            // During Applet.stop(), any AccessControlException on an involved Class remains in
            // the "memory" of the AppletClassLoader.  If the same instance of the ClassLoader is
            // reused, the same exception will occur during class loading.  Set the
            // AppletClassLoader's
            // exceptionStatusSet flag to allow recognition of what had happened
            // when reusing AppletClassLoader object.
            try {
              applet.stop();
            } catch (java.security.AccessControlException e) {
              setExceptionStatus(e);
              // rethrow exception to be handled as it normally would be.
              throw e;
            }
            showAppletStatus("stopped");
            break;

          case APPLET_DESTROY:
            if (status != APPLET_STOP && status != APPLET_INIT) {
              showAppletStatus("notstopped");
              break;
            }
            status = APPLET_DESTROY;

            // During Applet.destroy(), any AccessControlException on an involved Class remains in
            // the "memory" of the AppletClassLoader.  If the same instance of the ClassLoader is
            // reused, the same exception will occur during class loading.  Set the
            // AppletClassLoader's
            // exceptionStatusSet flag to allow recognition of what had happened
            // when reusing AppletClassLoader object.
            try {
              applet.destroy();
            } catch (java.security.AccessControlException e) {
              setExceptionStatus(e);
              // rethrow exception to be handled as it normally would be.
              throw e;
            }
            showAppletStatus("destroyed");
            break;

          case APPLET_DISPOSE:
            if (status != APPLET_DESTROY && status != APPLET_LOAD) {
              showAppletStatus("notdestroyed");
              break;
            }
            status = APPLET_DISPOSE;

            try {
              final Applet a = applet;
              Runnable r =
                  new Runnable() {
                    @Override
                    public void run() {
                      remove(a);
                    }
                  };
              AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r);
            } catch (InterruptedException ie) {
            } catch (InvocationTargetException ite) {
            }
            applet = null;
            showAppletStatus("disposed");
            disposed = true;
            break;

          case APPLET_QUIT:
            return;
        }
      } catch (Exception e) {
        status = APPLET_ERROR;
        if (e.getMessage() != null) {
          showAppletStatus("exception2", e.getClass().getName(), e.getMessage());
        } else {
          showAppletStatus("exception", e.getClass().getName());
        }
        showAppletException(e);
      } catch (ThreadDeath e) {
        showAppletStatus("death");
        return;
      } catch (Error e) {
        status = APPLET_ERROR;
        if (e.getMessage() != null) {
          showAppletStatus("error2", e.getClass().getName(), e.getMessage());
        } else {
          showAppletStatus("error", e.getClass().getName());
        }
        showAppletException(e);
      }
      clearLoadAbortRequest();
    }
  }