Java/Event/General Event

Event Listener List

    
/**
 * The utillib library.
 * More information is available at http://www.jinchess.ru/.
 * Copyright (C) 2002 Alexander Maryanovsky.
 * All rights reserved.
 *
 * The utillib library is free software; you can redistribute
 * it and/or modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * The utillib library is distributed in the hope that it will
 * be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
 * General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with utillib library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

import java.util.EventListener;
import java.lang.reflect.Array;

/**
 * A convenient storage place for Listeners. The listeners are stored in the
 * same manner as in javax.swing.event.EventListenerList.
 * <STRONG>Note:</STRONG> This class is not thread safe.
 */
public class EventListenerList{

  /**
   * The array where we keep the listeners and their types.
   */
  private Object [] listenerList = new Object[0];

  /**
   * Adds the given listener as a listener of the given type.
   */
  public void add(Class listenerType, EventListener listener){
    if (listener==null)
      return;
    if (!listenerType.isInstance(listener))
      throw new IllegalArgumentException("The listener is not an instance of the listener class.");
    Object [] tempArr = new Object[listenerList.length+2];
    System.arraycopy(listenerList,0,tempArr,0,listenerList.length);
    tempArr[tempArr.length-2] = listenerType;
    tempArr[tempArr.length-1] = listener;
    listenerList = tempArr;
  }

  
  /**
   * Removes the given listener as a listener of the specified type.
   */
  public void remove(Class listenerType, EventListener listener){
    if (listener == null)
      return;
    if (!listenerType.isInstance(listener))
      throw new IllegalArgumentException("The listener is not an instance of the listener class.");
    for (int i=0;i<listenerList.length;i+=2){
      if ((listenerList[i]==listenerType)&&(listenerList[i+1].equals(listener))){
        Object [] tempArr = new Object[listenerList.length-2];
        System.arraycopy(listenerList,0,tempArr,0,i);
        System.arraycopy(listenerList,i+2,tempArr,i,listenerList.length-i-2);
        listenerList = tempArr;
        return;
      }
    }
  }

  /**
   * Returns the total number of listeners for this listener list.
   */
  public int getListenerCount(){
    return listenerList.length;
  }

  /**
   * Returns the amount of listeners of the specified type in this listener
   * list.
   */
  public int getListenerCount(Class listenerType){
    int count = 0;
    for (int i=0;i<listenerList.length;i+=2){
      if (listenerList[i]==listenerType)
        count++;
    }
    return count;
  }

  /**
   * Returns an array containing all the listeners in this listener list. The
   * array contains listeners and their types in the following format: the
   * element at index 2*N is the type of the listener at index 2*N+1
   * <B>WARNING!!!</B> Absolutely NO modification of the data contained in this array
   * should be made -- if any such manipulation is necessary, it should be done on a
   * copy of the array returned rather than the array itself.
   */
  public Object [] getListenerList(){
    return listenerList;
  }

  /**
   * Returns an array of listeners registered as the listeners of the given
   * type. Note that the returned array is an array of the actual given type
   * so it can be safely casted to that type once instead of casting each of the
   * listener.
   */
  public EventListener [] getListeners(Class listenerType){
    EventListener [] listeners = (EventListener [])Array.newInstance(listenerType,getListenerCount(listenerType));
    int count = 0;
    for (int i=0;i<listenerList.length;i+=2){
      if (listenerType==listenerList[i])
        listeners[count++] = (EventListener)listenerList[i+1];
    }
    return listeners;
  }

}

EventTest Pane

   
/*
 * Copyright (c) 2000 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 2nd Edition.
 * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
 * You may study, use, and modify it for any non-commercial purpose.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book (recommended),
 * visit http://www.davidflanagan.ru/javaexamples2.
 */
import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ruponentEvent;
import java.awt.event.FocusEvent;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.JPanel;
/** A program that displays all the event that occur in its window */
public class EventTestPane extends JPanel {
  /** The constructor: register the event types we are interested in */
  public EventTestPane() {
    // We"re interested in all types of events
    this.enableEvents(AWTEvent.MOUSE_EVENT_MASK
        | AWTEvent.MOUSE_MOTION_EVENT_MASK | AWTEvent.KEY_EVENT_MASK
        | AWTEvent.FOCUS_EVENT_MASK | AWTEvent.ruPONENT_EVENT_MASK
        | AWTEvent.WINDOW_EVENT_MASK);
    this.setPreferredSize(new Dimension(500, 400));
  }
  /**
   * Display mouse events that don"t involve mouse motion. The mousemods()
   * method prints modifiers, and is defined below. The other methods return
   * additional information about the mouse event. showLine() displays a line
   * of text in the window. It is defined at the end of this class, along with
   * the paintComponent() method.
   */
  public void processMouseEvent(MouseEvent e) {
    String type = null;
    switch (e.getID()) {
    case MouseEvent.MOUSE_PRESSED:
      type = "MOUSE_PRESSED";
      break;
    case MouseEvent.MOUSE_RELEASED:
      type = "MOUSE_RELEASED";
      break;
    case MouseEvent.MOUSE_CLICKED:
      type = "MOUSE_CLICKED";
      break;
    case MouseEvent.MOUSE_ENTERED:
      type = "MOUSE_ENTERED";
      break;
    case MouseEvent.MOUSE_EXITED:
      type = "MOUSE_EXITED";
      break;
    }
    showLine(mousemods(e) + type + ": [" + e.getX() + "," + e.getY() + "] "
        + "num clicks = " + e.getClickCount()
        + (e.isPopupTrigger() ? "; is popup trigger" : ""));
    // When the mouse enters the component, request keyboard focus so
    // we can receive and respond to keyboard events
    if (e.getID() == MouseEvent.MOUSE_ENTERED)
      requestFocus();
  }
  /**
   * Display mouse moved and dragged mouse event. Note that MouseEvent is the
   * only event type that has two methods, two EventListener interfaces and
   * two adapter classes to handle two distinct categories of events. Also, as
   * seen in init(), mouse motion events must be requested separately from
   * other mouse event types.
   */
  public void processMouseMotionEvent(MouseEvent e) {
    String type = null;
    switch (e.getID()) {
    case MouseEvent.MOUSE_MOVED:
      type = "MOUSE_MOVED";
      break;
    case MouseEvent.MOUSE_DRAGGED:
      type = "MOUSE_DRAGGED";
      break;
    }
    showLine(mousemods(e) + type + ": [" + e.getX() + "," + e.getY() + "] "
        + "num clicks = " + e.getClickCount()
        + (e.isPopupTrigger() ? "; is popup trigger" : ""));
  }
  /**
   * Return a string representation of the modifiers for a MouseEvent. Note
   * that the methods called here are inherited from InputEvent.
   */
  protected String mousemods(MouseEvent e) {
    int mods = e.getModifiers();
    String s = "";
    if (e.isShiftDown())
      s += "Shift ";
    if (e.isControlDown())
      s += "Ctrl ";
    if ((mods & InputEvent.BUTTON1_MASK) != 0)
      s += "Button 1 ";
    if ((mods & InputEvent.BUTTON2_MASK) != 0)
      s += "Button 2 ";
    if ((mods & InputEvent.BUTTON3_MASK) != 0)
      s += "Button 3 ";
    return s;
  }
  /**
   * Display keyboard events.
   * 
   * Note that there are three distinct types of key events, and that key
   * events are reported by key code and/or Unicode character. KEY_PRESSED and
   * KEY_RELEASED events are generated for all key strokes. KEY_TYPED events
   * are only generated when a key stroke produces a Unicode character; these
   * events do not report a key code. If isActionKey() returns true, then the
   * key event reports only a key code, because the key that was pressed or
   * released (such as a function key) has no corresponding Unicode character.
   * Key codes can be interpreted by using the many VK_ constants defined by
   * the KeyEvent class, or they can be converted to strings using the static
   * getKeyText() method as we do here.
   */
  public void processKeyEvent(KeyEvent e) {
    String eventtype, modifiers, code, character;
    switch (e.getID()) {
    case KeyEvent.KEY_PRESSED:
      eventtype = "KEY_PRESSED";
      break;
    case KeyEvent.KEY_RELEASED:
      eventtype = "KEY_RELEASED";
      break;
    case KeyEvent.KEY_TYPED:
      eventtype = "KEY_TYPED";
      break;
    default:
      eventtype = "UNKNOWN";
    }
    // Convert the list of modifier keys to a string
    modifiers = KeyEvent.getKeyModifiersText(e.getModifiers());
    // Get string and numeric versions of the key code, if any.
    if (e.getID() == KeyEvent.KEY_TYPED)
      code = "";
    else
      code = "Code=" + KeyEvent.getKeyText(e.getKeyCode()) + " ("
          + e.getKeyCode() + ")";
    // Get string and numeric versions of the Unicode character, if any.
    if (e.isActionKey())
      character = "";
    else
      character = "Character=" + e.getKeyChar() + " (Unicode="
          + ((int) e.getKeyChar()) + ")";
    // Display it all.
    showLine(eventtype + ": " + modifiers + " " + code + " " + character);
  }
  /**
   * Display keyboard focus events. Focus can be permanently gained or lost,
   * or temporarily transferred to or from a component.
   */
  public void processFocusEvent(FocusEvent e) {
    if (e.getID() == FocusEvent.FOCUS_GAINED)
      showLine("FOCUS_GAINED" + (e.isTemporary() ? " (temporary)" : ""));
    else
      showLine("FOCUS_LOST" + (e.isTemporary() ? " (temporary)" : ""));
  }
  /** Display Component events. */
  public void processComponentEvent(ComponentEvent e) {
    switch (e.getID()) {
    case ComponentEvent.ruPONENT_MOVED:
      showLine("COMPONENT_MOVED");
      break;
    case ComponentEvent.ruPONENT_RESIZED:
      showLine("COMPONENT_RESIZED");
      break;
    case ComponentEvent.ruPONENT_HIDDEN:
      showLine("COMPONENT_HIDDEN");
      break;
    case ComponentEvent.ruPONENT_SHOWN:
      showLine("COMPONENT_SHOWN");
      break;
    }
  }
  /** Display Window events. Note the special handling of WINDOW_CLOSING */
  public void processWindowEvent(WindowEvent e) {
    switch (e.getID()) {
    case WindowEvent.WINDOW_OPENED:
      showLine("WINDOW_OPENED");
      break;
    case WindowEvent.WINDOW_CLOSED:
      showLine("WINDOW_CLOSED");
      break;
    case WindowEvent.WINDOW_CLOSING:
      showLine("WINDOW_CLOSING");
      break;
    case WindowEvent.WINDOW_ICONIFIED:
      showLine("WINDOW_ICONIFIED");
      break;
    case WindowEvent.WINDOW_DEICONIFIED:
      showLine("WINDOW_DEICONIFIED");
      break;
    case WindowEvent.WINDOW_ACTIVATED:
      showLine("WINDOW_ACTIVATED");
      break;
    case WindowEvent.WINDOW_DEACTIVATED:
      showLine("WINDOW_DEACTIVATED");
      break;
    }
    // If the user requested a window close, quit the program.
    // But first display a message, force it to be visible, and make
    // sure the user has time to read it.
    if (e.getID() == WindowEvent.WINDOW_CLOSING) {
      showLine("WINDOW_CLOSING event received.");
      showLine("Application will exit in 5 seconds");
      // Force the updates to appear now.
      update(this.getGraphics());
      // Wait five seconds
      try {
        Thread.sleep(5000);
      } catch (InterruptedException ie) {
        ;
      }
      // Exit now
      System.exit(0);
    }
  }
  /** The list of lines to display in the window */
  protected Vector lines = new Vector();
  /** Add a new line to the list of lines, and request redisplay */
  protected void showLine(String s) {
    if (lines.size() == 20)
      lines.removeElementAt(0);
    lines.addElement(s);
    repaint();
  }
  /** This method repaints the text in the window */
  public void paintComponent(Graphics g) {
    for (int i = 0; i < lines.size(); i++)
      g.drawString((String) lines.elementAt(i), 20, i * 16 + 50);
  }
  public boolean isOpaque() {
    return false;
  }
  public static void main(String[] args) {
    JFrame frame = new JFrame();
    frame.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        System.exit(0);
      }
    });
    frame.getContentPane().add(new EventTestPane(), BorderLayout.CENTER);
    // Finally, set the size of the main window, and pop it up.
    frame.setSize(600, 400);
    frame.setVisible(true);
  }
}

KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner()

   
import java.awt.KeyboardFocusManager;
public class Main {
  public static void main(String[] argv) throws Exception {
    KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner();
  }
}

Monitors the AWT event dispatch thread for events that take longer than a certain time to be dispatched

  
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

import java.awt.*;
import java.awt.event.*;
import java.lang.management.*;
import java.util.*;
import java.util.Timer;
import javax.swing.*;
/**
 * Monitors the AWT event dispatch thread for events that take longer than
 * a certain time to be dispatched.
 * <p/>
 * The principle is to record the time at which we start processing an event,
 * and have another thread check frequently to see if we"re still processing.
 * If the other thread notices that we"ve been processing a single event for
 * too long, it prints a stack trace showing what the event dispatch thread
 * is doing, and continues to time it until it finally finishes.
 * <p/>
 * This is useful in determining what code is causing your Java application"s
 * GUI to be unresponsive.
 * 
 * <p>The original blog can be found here<br>  
 * 
 * </p>
 *
 * @author Elliott Hughes <enh@jessies.org>
 * 
 * Advice, bug fixes, and test cases from
 * Alexander Potochkin and Oleg Sukhodolsky.
 * 
 * https://swinghelper.dev.java.net/
 */
public final class EventDispatchThreadHangMonitor extends EventQueue {
    private static final EventDispatchThreadHangMonitor INSTANCE = new EventDispatchThreadHangMonitor();
    // Time to wait between checks that the event dispatch thread isn"t hung.
    private static final long CHECK_INTERVAL_MS = 100;
    // Maximum time we won"t warn about. This used to be 500 ms, but 1.5 on
    // late-2004 hardware isn"t really up to it; there are too many parts of
    // the JDK that can go away for that long (often code that has to be
    // called on the event dispatch thread, like font loading).
    private static final long UNREASONABLE_DISPATCH_DURATION_MS = 1000;
    // Help distinguish multiple hangs in the log, and match start and end too.
    // Only access this via getNewHangNumber.
    private static int hangCount = 0;
    // Prevents us complaining about hangs during start-up, which are probably
    // the JVM vendor"s fault.
    private boolean haveShownSomeComponent = false;
    // The currently outstanding event dispatches. The implementation of
    // modal dialogs is a common cause for multiple outstanding dispatches.
    private final LinkedList<DispatchInfo> dispatches = new LinkedList<DispatchInfo>();
    private static class DispatchInfo {
        // The last-dumped hung stack trace for this dispatch.
        private StackTraceElement[] lastReportedStack;
        // If so; what was the identifying hang number?
        private int hangNumber;
        // The EDT for this dispatch (for the purpose of getting stack traces).
        // I don"t know of any API for getting the event dispatch thread,
        // but we can assume that it"s the current thread if we"re in the
        // middle of dispatching an AWT event...
        // We can"t cache this because the EDT can die and be replaced by a
        // new EDT if there"s an uncaught exception.
        private final Thread eventDispatchThread = Thread.currentThread();
        // The last time in milliseconds at which we saw a dispatch on the above thread.
        private long lastDispatchTimeMillis = System.currentTimeMillis();
        public DispatchInfo() {
            // All initialization is done by the field initializers.
        }
        public void checkForHang() {
            if (timeSoFar() > UNREASONABLE_DISPATCH_DURATION_MS) {
                examineHang();
            }
        }
        // We can"t use StackTraceElement.equals because that insists on checking the filename and line number.
        // That would be version-specific.
        private static boolean stackTraceElementIs(StackTraceElement e, String className, String methodName, boolean isNative) {
            return e.getClassName().equals(className) && e.getMethodName().equals(methodName) && e.isNativeMethod() == isNative;
        }
        // Checks whether the given stack looks like it"s waiting for another event.
        // This relies on JDK implementation details.
        private boolean isWaitingForNextEvent(StackTraceElement[] currentStack) {
            return stackTraceElementIs(currentStack[0], "java.lang.Object", "wait", true) && stackTraceElementIs(currentStack[1], "java.lang.Object", "wait", false) && stackTraceElementIs(currentStack[2], "java.awt.EventQueue", "getNextEvent", false);
        }
        private void examineHang() {
            StackTraceElement[] currentStack = eventDispatchThread.getStackTrace();
            if (isWaitingForNextEvent(currentStack)) {
                // Don"t be fooled by a modal dialog if it"s waiting for its next event.
                // As long as the modal dialog"s event pump doesn"t get stuck, it"s okay for the outer pump to be suspended.
                return;
            }
            if (stacksEqual(lastReportedStack, currentStack)) {
                // Don"t keep reporting the same hang every time the timer goes off.
                return;
            }
            hangNumber = getNewHangNumber();
            String stackTrace = stackTraceToString(currentStack);
            lastReportedStack = currentStack;
            Log.warn("(hang #" + hangNumber + ") event dispatch thread stuck processing event for " + timeSoFar() + " ms:" + stackTrace);
            checkForDeadlock();
        }
        private static boolean stacksEqual(StackTraceElement[] a, StackTraceElement[] b) {
            if (a == null) {
                return false;
            }
            if (a.length != b.length) {
                return false;
            }
            for (int i = 0; i < a.length; ++i) {
                if (a[i].equals(b[i]) == false) {
                    return false;
                }
            }
            return true;
        }
        /**
         * Returns how long this dispatch has been going on (in milliseconds).
         */
        private long timeSoFar() {
            return (System.currentTimeMillis() - lastDispatchTimeMillis);
        }
        public void dispose() {
            if (lastReportedStack != null) {
                Log.warn("(hang #" + hangNumber + ") event dispatch thread unstuck after " + timeSoFar() + " ms.");
            }
        }
    }
    private EventDispatchThreadHangMonitor() {
        initTimer();
    }
    /**
     * Sets up a timer to check for hangs frequently.
     */
    private void initTimer() {
        final long initialDelayMs = 0;
        final boolean isDaemon = true;
        Timer timer = new Timer("EventDispatchThreadHangMonitor", isDaemon);
        timer.schedule(new HangChecker(), initialDelayMs, CHECK_INTERVAL_MS);
    }
    private class HangChecker extends TimerTask {
        @Override
        public void run() {
            synchronized (dispatches) {
                if (dispatches.isEmpty() || !haveShownSomeComponent) {
                    // Nothing to do.
                    // We don"t destroy the timer when there"s nothing happening
                    // because it would mean a lot more work on every single AWT
                    // event that gets dispatched.
                    return;
                }
                // Only the most recent dispatch can be hung; nested dispatches
                // by their nature cause the outer dispatch pump to be suspended.
                dispatches.getLast().checkForHang();
            }
        }
    }
    /**
     * Sets up hang detection for the event dispatch thread.
     */
    public static void initMonitoring() {
        Toolkit.getDefaultToolkit().getSystemEventQueue().push(INSTANCE);
    }
    /**
     * Overrides EventQueue.dispatchEvent to call our pre and post hooks either
     * side of the system"s event dispatch code.
     */
    @Override
    protected void dispatchEvent(AWTEvent event) {
        try {
            preDispatchEvent();
            super.dispatchEvent(event);
        } finally {
            postDispatchEvent();
            if (!haveShownSomeComponent && 
                    event instanceof WindowEvent && event.getID() == WindowEvent.WINDOW_OPENED) {
                haveShownSomeComponent = true;
            }
        }
    }
    private void debug(String which) {
        if (false) {
            for (int i = dispatches.size(); i >= 0; --i) {
                System.out.print(" ");
            }
            System.out.println(which);
        }
    }
    /**
     * Starts tracking a dispatch.
     */
    private synchronized void preDispatchEvent() {
        debug("pre");
        synchronized (dispatches) {
            dispatches.addLast(new DispatchInfo());
        }
    }
    /**
     * Stops tracking a dispatch.
     */
    private synchronized void postDispatchEvent() {
        synchronized (dispatches) {
            // We"ve finished the most nested dispatch, and don"t need it any longer.
            DispatchInfo justFinishedDispatch = dispatches.removeLast();
            justFinishedDispatch.dispose();
            // The other dispatches, which have been waiting, need to be credited extra time.
            // We do this rather simplistically by pretending they"ve just been redispatched.
            Thread currentEventDispatchThread = Thread.currentThread();
            for (DispatchInfo dispatchInfo : dispatches) {
                if (dispatchInfo.eventDispatchThread == currentEventDispatchThread) {
                    dispatchInfo.lastDispatchTimeMillis = System.currentTimeMillis();
                }
            }
        }
        debug("post");
    }
    private static void checkForDeadlock() {
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        long[] threadIds = threadBean.findMonitorDeadlockedThreads();
        if (threadIds == null) {
            return;
        }
        Log.warn("deadlock detected involving the following threads:");
        ThreadInfo[] threadInfos = threadBean.getThreadInfo(threadIds, Integer.MAX_VALUE);
        for (ThreadInfo info : threadInfos) {
            Log.warn("Thread #" + info.getThreadId() + " " + info.getThreadName() + 
                    " (" + info.getThreadState() + ") waiting on " + info.getLockName() + 
                    " held by " + info.getLockOwnerName() + stackTraceToString(info.getStackTrace()));
        }
    }
    private static String stackTraceToString(StackTraceElement[] stackTrace) {
        StringBuilder result = new StringBuilder();
        // We used to avoid showing any code above where this class gets
        // involved in event dispatch, but that hides potentially useful
        // information when dealing with modal dialogs. Maybe we should
        // reinstate that, but search from the other end of the stack?
        for (StackTraceElement stackTraceElement : stackTrace) {
            String indentation = "    ";
            result.append("\n" + indentation + stackTraceElement);
        }
        return result.toString();
    }
    private synchronized static int getNewHangNumber() {
        return ++hangCount;
    }
    public static void main(String[] args) {
        initMonitoring();
        //special case for deadlock test
        if (args.length > 0 && "deadlock".equals(args[0])) {
            EventDispatchThreadHangMonitor.INSTANCE.haveShownSomeComponent = true;
            Tests.runDeadlockTest();
            return;
        }
        Tests.main(args);
    }
    private static class Tests {
        public static void main(final String[] args) {
            java.awt.EventQueue.invokeLater(new Runnable() {
                public void run() {
                    for (String arg : args) {
                        final JFrame frame = new JFrame();
                        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                        frame.setLocationRelativeTo(null);
                        if (arg.equals("exception")) {
                            runExceptionTest(frame);
                        } else if (arg.equals("focus")) {
                            runFocusTest(frame);
                        } else if (arg.equals("modal-hang")) {
                            runModalTest(frame, true);
                        } else if (arg.equals("modal-no-hang")) {
                            runModalTest(frame, false);
                        } else {
                            System.err.println("unknown regression test "" + arg + """);
                            System.exit(1);
                        }
                        frame.pack();
                        frame.setVisible(true);
                    }
                }
            });
        }
        private static void runDeadlockTest() {
            class Locker {
                private Locker locker;
                public void setLocker(Locker locker) {
                    this.locker = locker;
                }
                public synchronized void tryToDeadlock() {
                    locker.toString();
                }
                public synchronized String toString() {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return super.toString();
                }
            }
            final Locker one = new Locker();
            final Locker two = new Locker();
            one.setLocker(two);
            two.setLocker(one);
            //Deadlock expected here:
            for (int i = 0; i < 100; i++) {
                SwingUtilities.invokeLater(new Runnable() {
                    public void run() {
                        one.tryToDeadlock();
                    }
                });
                two.tryToDeadlock();
            }
        }
        // If we don"t do our post-dispatch activity in a finally block, we"ll
        // report bogus hangs.
        private static void runExceptionTest(final JFrame frame) {
            JButton button = new JButton("Throw Exception");
            button.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    // This shouldn"t cause us to report a hang.
                    throw new RuntimeException("Nobody expects the Spanish Inquisition!");
                }
            });
            frame.add(button);
        }
        // A demonstration of nested calls to dispatchEvent caused by SequencedEvent.
        private static void runFocusTest(final JFrame frame) {
            final JDialog dialog = new JDialog(frame, "Non-Modal Dialog");
            dialog.add(new JLabel("Close me!"));
            dialog.pack();
            dialog.setLocationRelativeTo(frame);
            dialog.addWindowFocusListener(new WindowAdapter() {
                public void windowGainedFocus(WindowEvent e) {
                    System.out.println("FocusTest.windowGainedFocus");
                    // If you don"t cope with nested calls to dispatchEvent, you won"t detect this.
                    // See java.awt.SequencedEvent for an example.
                    sleep(2500);
                }
            });
            JButton button = new JButton("Show Non-Modal Dialog");
            button.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    dialog.setVisible(true);
                }
            });
            frame.add(button);
        }
        // A demonstration of the problems of dealing with modal dialogs.
        private static void runModalTest(final JFrame frame, final boolean shouldSleep) {
            System.out.println(shouldSleep ? "Expect hangs!" : "There should be no hangs...");
            JButton button = new JButton("Show Modal Dialog");
            button.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if (shouldSleep) {
                        sleep(2500); // This is easy.
                    }
                    JDialog dialog = new JDialog(frame, "Modal dialog", true);
                    dialog.setLayout(new FlowLayout());
                    dialog.add(new JLabel("Close this dialog!"));
                    final JLabel label = new JLabel(" ");
                    dialog.add(label);
                    dialog.pack();
                    dialog.setLocation(frame.getX() - 100, frame.getY());
                    // Make sure the new event pump has some work to do, each unit of which is insufficient to cause a hang.
                    new Thread(new Runnable() {
                        public void run() {
                            for (int i = 0; i <= 100000; ++i) {
                                final int value = i;
                                EventQueue.invokeLater(new Runnable() {
                                    public void run() {
                                        label.setText(Integer.toString(value));
                                    }
                                });
                            }
                        }
                    }).start();
                    dialog.setVisible(true);
                    if (shouldSleep) {
                        sleep(2500); // If you don"t distinguish different stack traces, you won"t report this.
                    }
                }
            });
            frame.add(button);
        }
        private static void sleep(long ms) {
            try {
                System.out.println("Sleeping for " + ms + " ms on " + Thread.currentThread() + "...");
                Thread.sleep(ms);
                System.out.println("Finished sleeping...");
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }
    private static class Log {
        public static void warn(String str) {
            System.out.println(str);
        }
    }
}

Multicast event

   
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class MulticastEvent extends JPanel implements ActionListener {
  private int counter = 0;
  private JButton closeAllButton;
  public MulticastEvent() {
    JButton newButton = new JButton("New");
    add(newButton);
    newButton.addActionListener(this);
    closeAllButton = new JButton("Close all");
    add(closeAllButton);
  }
  public void actionPerformed(ActionEvent evt) {
    CloseFrame f = new CloseFrame();
    counter++;
    f.setTitle("Window " + counter);
    f.setSize(200, 150);
    f.setLocation(30 * counter, 30 * counter);
    f.show();
    closeAllButton.addActionListener(f);
  }
  public static void main(String[] args) {
    JFrame frame = new JFrame();
    frame.setTitle("MulticastTest");
    frame.setSize(300, 200);
    frame.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        System.exit(0);
      }
    });
    Container contentPane = frame.getContentPane();
    contentPane.add(new MulticastEvent());
    frame.show();
  }
  class CloseFrame extends JFrame implements ActionListener {
    public void actionPerformed(ActionEvent evt) { // handles Close all
                            // button
      setVisible(false);
    }
  }
}

Swing Event MultiListener

   
/* From http://java.sun.ru/docs/books/tutorial/index.html */
/*
 * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * -Redistribution of source code must retain the above copyright notice, this
 *  list of conditions and the following disclaimer.
 *
 * -Redistribution in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed, licensed or intended
 * for use in the design, construction, operation or maintenance of any
 * nuclear facility.
 */
/*
 * Swing version
 */
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
public class MultiListener extends JPanel implements ActionListener {
  JTextArea topTextArea;
  JTextArea bottomTextArea;
  JButton button1, button2;
  final static String newline = "\n";
  public MultiListener() {
    super(new GridBagLayout());
    GridBagLayout gridbag = (GridBagLayout) getLayout();
    GridBagConstraints c = new GridBagConstraints();
    JLabel l = null;
    c.fill = GridBagConstraints.BOTH;
    c.gridwidth = GridBagConstraints.REMAINDER;
    l = new JLabel("What MultiListener hears:");
    gridbag.setConstraints(l, c);
    add(l);
    c.weighty = 1.0;
    topTextArea = new JTextArea();
    topTextArea.setEditable(false);
    JScrollPane topScrollPane = new JScrollPane(topTextArea);
    Dimension preferredSize = new Dimension(200, 75);
    topScrollPane.setPreferredSize(preferredSize);
    gridbag.setConstraints(topScrollPane, c);
    add(topScrollPane);
    c.weightx = 0.0;
    c.weighty = 0.0;
    l = new JLabel("What Eavesdropper hears:");
    gridbag.setConstraints(l, c);
    add(l);
    c.weighty = 1.0;
    bottomTextArea = new JTextArea();
    bottomTextArea.setEditable(false);
    JScrollPane bottomScrollPane = new JScrollPane(bottomTextArea);
    bottomScrollPane.setPreferredSize(preferredSize);
    gridbag.setConstraints(bottomScrollPane, c);
    add(bottomScrollPane);
    c.weightx = 1.0;
    c.weighty = 0.0;
    c.gridwidth = 1;
    c.insets = new Insets(10, 10, 0, 10);
    button1 = new JButton("Blah blah blah");
    gridbag.setConstraints(button1, c);
    add(button1);
    c.gridwidth = GridBagConstraints.REMAINDER;
    button2 = new JButton("You don"t say!");
    gridbag.setConstraints(button2, c);
    add(button2);
    button1.addActionListener(this);
    button2.addActionListener(this);
    button2.addActionListener(new Eavesdropper(bottomTextArea));
    setPreferredSize(new Dimension(450, 450));
    setBorder(BorderFactory.createCompoundBorder(BorderFactory
        .createMatteBorder(1, 1, 2, 2, Color.black), BorderFactory
        .createEmptyBorder(5, 5, 5, 5)));
  }
  public void actionPerformed(ActionEvent e) {
    topTextArea.append(e.getActionCommand() + newline);
    topTextArea.setCaretPosition(topTextArea.getDocument().getLength());
  }
  /**
   * Create the GUI and show it. For thread safety, this method should be
   * invoked from the event-dispatching thread.
   */
  private static void createAndShowGUI() {
    //Make sure we have nice window decorations.
    JFrame.setDefaultLookAndFeelDecorated(true);
    //Create and set up the window.
    JFrame frame = new JFrame("MultiListener");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    //Create and set up the content pane.
    JComponent newContentPane = new MultiListener();
    newContentPane.setOpaque(true); //content panes must be opaque
    frame.setContentPane(newContentPane);
    //Display the window.
    frame.pack();
    frame.setVisible(true);
  }
  public static void main(String[] args) {
    //Schedule a job for the event-dispatching thread:
    //creating and showing this application"s GUI.
    javax.swing.SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        createAndShowGUI();
      }
    });
  }
}
class Eavesdropper implements ActionListener {
  JTextArea myTextArea;
  public Eavesdropper(JTextArea ta) {
    myTextArea = ta;
  }
  public void actionPerformed(ActionEvent e) {
    myTextArea.append(e.getActionCommand() + MultiListener.newline);
    myTextArea.setCaretPosition(myTextArea.getDocument().getLength());
  }
}