Add debug plugin.

Tidy up sevreal classes
Add checkboxmenu item
Change menu bar so plugins can add items.
Add update ID to notifications plugin

Fixes issue CLIENT-80

Change-Id: I289bbf7bcad6d9c528eb353dc8cf49ad48954a65
Reviewed-on: http://gerrit.dmdirc.com/1559
Reviewed-by: Chris Smith <chris@dmdirc.com>
Automatic-Compile: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/addons/notifications/plugin.config

   version
   requires
   defaults
+  updates
 
 metadata:
   author=Greg <greg@dmdirc.com>
   name=notifications
   nicename=Notification Manager
 
+updates:
+  id=61
+
 version:
   friendly=0.1
 

src/com/dmdirc/addons/swingdebug/CloseListener.java

+/*
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.dmdirc.addons.swingdebug;
+
+import java.awt.Window;
+import java.awt.event.ComponentEvent;
+import java.awt.event.ComponentListener;
+
+import javax.swing.ButtonModel;
+
+/**
+ * Updates checkbox state on window close.
+ */
+public class CloseListener implements ComponentListener {
+
+    /** Button model to update. */
+    private final ButtonModel model;
+
+    /**
+     * Creates a new Close Listener for the specified window and model.
+     *
+     * @param model Model to keep updated
+     * @param window Window to monitor
+     */
+    public CloseListener(final ButtonModel model, final Window window) {
+        super();
+
+        this.model = model;
+        window.addComponentListener(this);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void componentResized(final ComponentEvent e) {
+        //Ignore, don't care
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void componentMoved(final ComponentEvent e) {
+        //Ignore, don't care
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void componentShown(final ComponentEvent e) {
+        //Ignore, don't care
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void componentHidden(final ComponentEvent e) {
+        model.setSelected(false);
+    }
+
+    /**
+     * Adds a close listener to the specified window, updating the specified
+     * model.
+     *
+     * @param model Model to update
+     * @param window Window to listener to
+     */
+    public static void add(final ButtonModel model, final Window window) {
+        new CloseListener(model, window);
+    }
+}

src/com/dmdirc/addons/swingdebug/SwingDebugPlugin.java

+/*
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.swingdebug;
+
+import com.dmdirc.addons.ui_swing.DMDircEventQueue;
+import com.dmdirc.addons.ui_swing.SwingController;
+import com.dmdirc.addons.ui_swing.components.CheckBoxMenuItem;
+import com.dmdirc.addons.ui_swing.components.text.TextLabel;
+import com.dmdirc.plugins.Plugin;
+import com.dmdirc.plugins.PluginManager;
+import java.awt.Toolkit;
+import java.awt.event.ActionEvent;
+
+import java.awt.event.ActionListener;
+import java.io.IOException;
+import java.io.PrintStream;
+
+import javax.swing.JCheckBoxMenuItem;
+import javax.swing.JDialog;
+import javax.swing.JMenu;
+import javax.swing.JScrollPane;
+import net.miginfocom.swing.MigLayout;
+
+/**
+ * Swing debug plugin. Provides long running EDT task violation detection and
+ * a console for System.out and System.err.
+ */
+public class SwingDebugPlugin extends Plugin implements ActionListener {
+
+    /** Swing controller. */
+    private SwingController controller;
+    /** Debug menu. */
+    private JMenu debugMenu;
+    /** Debug EDT menu item. */
+    private JCheckBoxMenuItem debugEDT;
+    /** Debug EDT menu item. */
+    private JCheckBoxMenuItem showSysOut;
+    /** Debug EDT menu item. */
+    private JCheckBoxMenuItem showSysErr;
+    /** Old System.out. */
+    private PrintStream sysout;
+    /** Old System.err. */
+    private PrintStream syserr;
+    /** System.out redirect thread. */
+    private SystemStreamRedirectThread out;
+    /** System.err redirect thread. */
+    private SystemStreamRedirectThread err;
+    /** System out frame. */
+    private JDialog outFrame;
+    /** System error frame. */
+    private JDialog errorFrame;
+
+    /** {@inheritDoc} */
+    @Override
+    public void onLoad() {
+        controller = (SwingController) PluginManager.getPluginManager()
+                .getPluginInfoByName("ui_swing").getPlugin();
+        try {
+            sysout = System.out;
+            syserr = System.err;
+            final TextLabel outTextArea = new TextLabel();
+            final TextLabel errorTextArea = new TextLabel();
+            outFrame = new JDialog(controller.getMainFrame());
+            errorFrame = new JDialog(controller.getMainFrame());
+            outFrame.setTitle("DMDirc: System.out Console");
+            errorFrame.setTitle("DMDirc: System.err Console");
+            outFrame.setLayout(new MigLayout("ins 0, pack, wmin 20sp, hmin 20sp"));
+            errorFrame.setLayout(new MigLayout("ins 0, pack, wmin 20sp, hmin 20sp"));
+            outFrame.add(new JScrollPane(outTextArea), "grow, push");
+            errorFrame.add(new JScrollPane(errorTextArea), "grow, push");
+            outFrame.pack();
+            errorFrame.pack();
+            out = new SystemStreamRedirectThread(
+                    SystemStreamRedirectThread.Stream.OUT,
+                    outTextArea.getDocument());
+            err = new SystemStreamRedirectThread(
+                    SystemStreamRedirectThread.Stream.IN,
+                    errorTextArea.getDocument());
+            out.start();
+            err.start();
+            debugMenu = new JMenu("Debug");
+            debugEDT = new CheckBoxMenuItem("Check EDT task length");
+            showSysOut = new CheckBoxMenuItem("Show System.out Console");
+            showSysErr = new CheckBoxMenuItem("Show System.err Console");
+            debugEDT.addActionListener(this);
+            showSysErr.addActionListener(this);
+            showSysOut.addActionListener(this);
+            controller.getMainFrame().getJMenuBar().add(debugMenu);
+            debugMenu.add(debugEDT);
+            debugMenu.add(showSysOut);
+            debugMenu.add(showSysErr);
+            CloseListener.add(showSysOut.getModel(), outFrame);
+            CloseListener.add(showSysErr.getModel(), outFrame);
+        } catch (IOException ex) {
+            onUnload();
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void onUnload() {
+        out.cancel();
+        err.cancel();
+        System.setOut(sysout);
+        System.setErr(syserr);
+        outFrame = null;
+        errorFrame = null;
+        controller.getMainFrame().getJMenuBar().remove(debugMenu);
+        controller = null;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void actionPerformed(final ActionEvent e) {
+        if (e.getSource() == debugEDT) {
+            if (debugEDT.getState()) {
+                Toolkit.getDefaultToolkit().getSystemEventQueue().
+                        push(new TracingEventQueue(this, controller));
+            } else {
+                Toolkit.getDefaultToolkit().getSystemEventQueue().
+                        push(new DMDircEventQueue(controller));
+            }
+        }
+        if (e.getSource() == showSysOut) {
+            outFrame.setVisible(showSysOut.getState());
+        }
+        if (e.getSource() == showSysErr) {
+            errorFrame.setVisible(showSysErr.getState());
+        }
+    }
+
+}

src/com/dmdirc/addons/swingdebug/SystemStreamRedirectThread.java

+/*
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.swingdebug;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PipedInputStream;
+import java.io.PipedOutputStream;
+import java.io.PrintStream;
+
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Document;
+
+/**
+ * Simple utility class to redirect System streams to the specified Document.
+ */
+public class SystemStreamRedirectThread implements Runnable {
+
+    /**
+     * Enum to identify System streams.
+     */
+    public enum Stream {
+        /** System.out. */
+        OUT,
+        /** System.in. */
+        IN;
+    }
+
+    /** Is this thread running? */
+    private boolean running = false;
+    /** Reader to for the system stream. */
+    private final BufferedReader rar;
+    /** Stream identifier. */
+    private final Stream stream;
+    /** Document to output stream into. */
+    private final Document document;
+
+    /**
+     * Constructs a new redirection thread.
+     *
+     * @param stream System stream to redirect
+     * @param document Document to redirect stream into
+     *
+     * @throws IOException On error redirecting stream
+     */
+    public SystemStreamRedirectThread(final Stream stream,
+            final Document document) throws IOException {
+        super();
+        this.stream = stream;
+        this.document = document;
+
+        final PipedInputStream in = new PipedInputStream();
+        final PipedOutputStream out = new PipedOutputStream(in);
+        rar = new BufferedReader(new InputStreamReader(in));
+        switch (stream) {
+            case OUT:
+                System.setOut(new PrintStream(out));
+                break;
+            case IN:
+                System.setErr(new PrintStream(out));
+                break;
+            default:
+                throw new IllegalArgumentException("Unknown stream type: "
+                        + stream);
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void run() {
+        running = true;
+        while (running) {
+            try {
+                if (rar.ready()) {
+                    document.insertString(document.getLength(), rar.readLine(),
+                            null);
+                    document.insertString(document.getLength(), "\n", null);
+                }
+            } catch (BadLocationException ex) {
+                running = false;
+            } catch (IOException ex) {
+                running = false;
+            }
+        }
+    }
+
+    /**
+     * Starts the thread adding text to the document.
+     */
+    public void start() {
+        final Thread thread = new Thread(this,
+                "System stream redirector (" + stream + ")");
+        thread.setDaemon(true);
+        thread.start();
+    }
+
+    /**
+     * Cancels the thread adding text to the document.
+     */
+    public void cancel() {
+        running = false;
+    }
+
+    /**
+     * Is this thread running?
+     *
+     * @return true iif running
+     */
+    public boolean isRunning() {
+        return running;
+    }
+}

src/com/dmdirc/addons/ui_swing/TracingEventQueueThread.java → src/com/dmdirc/addons/swingdebug/TracingEventQueue.java

  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-package com.dmdirc.addons.ui_swing;
+package com.dmdirc.addons.swingdebug;
+
+import com.dmdirc.addons.ui_swing.DMDircEventQueue;
+import com.dmdirc.addons.ui_swing.SwingController;
+import com.dmdirc.config.IdentityManager;
+import com.dmdirc.interfaces.ConfigChangeListener;
+import com.dmdirc.plugins.Plugin;
 
 import java.awt.AWTEvent;
 import java.lang.management.ManagementFactory;
 import java.lang.management.ThreadInfo;
 import java.lang.management.ThreadMXBean;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import javax.management.ObjectName;
 
 /**
- * Event queue extention to monitor long running tasks on the EDT. Found at
- * http://today.java.net/lpt/a/433
+ * Event queue extention to monitor long running tasks on the EDT. Original
+ * code found at http://today.java.net/lpt/a/433 modified to work as a DMDirc
+ * plugin.
  */
-public class TracingEventQueueThread extends Thread {
+public class TracingEventQueue extends DMDircEventQueue implements
+        Runnable, ConfigChangeListener {
 
-    private final long thresholdDelay;
+    /** Threshold before event is considered long running. */
+    private long thresholdDelay;
+    /** Map of event to time started. */
     private final Map<AWTEvent, Long> eventTimeMap;
+    /** Thread bean, used to get thread info. */
     private ThreadMXBean threadBean;
+    /** boolean to end thread. */
     private boolean running = false;
+    /** Parent plugin. */
+    private final Plugin parentPlugin;
+    /** Tracing thread. */
+    private Thread tracingThread;
 
     /**
      * Instantiates a new tracing thread.
-     * 
-     * @param thresholdDelay
-     *            Length to consider a long running task
+     *
+     * @param parentPlugin Parent plugin
+     * @param controller Swing controller
      */
-    public TracingEventQueueThread(final long thresholdDelay) {
-        this.thresholdDelay = thresholdDelay;
-        eventTimeMap = new HashMap<AWTEvent, Long>();
+    public TracingEventQueue(final Plugin parentPlugin,
+            final SwingController controller) {
+        super(controller);
+        this.parentPlugin = parentPlugin;
+
+        eventTimeMap = Collections.synchronizedMap(
+                new HashMap<AWTEvent, Long>());
+        IdentityManager.getGlobalConfig().addChangeListener(
+                parentPlugin.getDomain(), "debugEDT", this);
+        IdentityManager.getGlobalConfig().addChangeListener(
+                parentPlugin.getDomain(), "slowedttaskthreshold", this);
+        checkTracing();
 
         try {
             final MBeanServer mbeanServer = ManagementFactory
                     .getPlatformMBeanServer();
             final ObjectName objName = new ObjectName(
                     ManagementFactory.THREAD_MXBEAN_NAME);
-            final Set<ObjectName> mbeans = mbeanServer
-                    .queryNames(objName, null);
+            final Set<ObjectName> mbeans = mbeanServer.queryNames(objName,
+                    null);
             for (final ObjectName name : mbeans) {
                 threadBean = ManagementFactory.newPlatformMXBeanProxy(
                         mbeanServer, name.toString(), ThreadMXBean.class);
         }
     }
 
+    /** {@inheritDoc} */
+    @Override
+    protected void preDispatchEvent(final AWTEvent event) {
+        eventDispatched(event);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected void postDispatchEvent(final AWTEvent event) {
+        eventProcessed(event);
+    }
+
+
+
     /**
      * Marks the start time for the specified event.
-     * 
-     * @param event
-     *            Event to monitor
+     *
+     * @param event Event to monitor
      */
-    public synchronized void eventDispatched(final AWTEvent event) {
+    public void eventDispatched(final AWTEvent event) {
         eventTimeMap.put(event, System.currentTimeMillis());
     }
 
     /**
      * Marks the end time for the specified event.
-     * 
-     * @param event
-     *            Event to finish monitoring.
+     *
+     * @param event Event to finish monitoring.
      */
-    public synchronized void eventProcessed(final AWTEvent event) {
-        checkEventTime(event, System.currentTimeMillis(), eventTimeMap
-                .get(event));
+    public void eventProcessed(final AWTEvent event) {
+        checkEventTime(event, System.currentTimeMillis(),
+                eventTimeMap.get(event));
         eventTimeMap.put(event, null);
     }
 
+    /**
+     * Check how long an event took, if over threshold notify user.
+     *
+     * @param event Event to check
+     * @param currTime Current time
+     * @param startTime Start time
+     */
     private void checkEventTime(final AWTEvent event, final long currTime,
             final long startTime) {
         final long currProcessingTime = currTime - startTime;
                             threadId, Integer.MAX_VALUE);
                     if (threadInfo != null
                             && threadInfo.getThreadName().startsWith(
-                                    "AWT-EventQueue")) {
+                            "AWT-EventQueue")) {
                         System.out.println(threadInfo.getThreadName() + " / "
                                 + threadInfo.getThreadState());
-                        final StackTraceElement[] stack = threadInfo
-                                .getStackTrace();
+                        final StackTraceElement[] stack = threadInfo.getStackTrace();
                         for (final StackTraceElement stackEntry : stack) {
                             System.out.println("\t" + stackEntry.getClassName()
                                     + "." + stackEntry.getMethodName() + " ["
                     }
                 }
 
-                final long[] deadlockedThreads = threadBean
-                        .findDeadlockedThreads();
+                final long[] deadlockedThreads = threadBean.findDeadlockedThreads();
                 if (deadlockedThreads != null && deadlockedThreads.length > 0) {
                     System.out.println("Deadlocked threads:");
                     for (final long threadId : deadlockedThreads) {
                                 threadId, Integer.MAX_VALUE);
                         System.out.println(threadInfo.getThreadName() + " / "
                                 + threadInfo.getThreadState());
-                        final StackTraceElement[] stack = threadInfo
-                                .getStackTrace();
+                        final StackTraceElement[] stack = threadInfo.getStackTrace();
                         for (final StackTraceElement stackEntry : stack) {
                             System.out.println("\t" + stackEntry.getClassName()
                                     + "." + stackEntry.getMethodName() + " ["
         running = true;
         while (running) {
             final long currTime = System.currentTimeMillis();
-            synchronized (this) {
+            synchronized (eventTimeMap) {
                 for (final Map.Entry<AWTEvent, Long> entry : eventTimeMap
                         .entrySet()) {
                     final AWTEvent event = entry.getKey();
                 }
             }
             try {
-                Thread.sleep(100);
+                Thread.sleep(thresholdDelay);
             } catch (final InterruptedException ie) {
                 // Ignore
             }
     public void cancel() {
         running = false;
     }
-}
+
+    private void checkTracing() {
+        final boolean tracing = IdentityManager.getGlobalConfig().
+                getOptionBool(parentPlugin.getDomain(), "debugEDT");
+        thresholdDelay = IdentityManager.getGlobalConfig().
+                getOptionInt(parentPlugin.getDomain(), "slowedttaskthreshold");
+        if (tracing) {
+            running = true;
+            tracingThread = new Thread(this);
+            tracingThread.start();
+        } else {
+            running = false;
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void configChanged(final String domain, final String key) {
+        checkTracing();
+    }
+}

src/com/dmdirc/addons/swingdebug/plugin.config

+# This is a DMDirc configuration file.
+
+# This section indicates which sections below take key/value
+# pairs, rather than a simple list. It should be placed above
+# any sections that take key/values.
+keysections:
+  metadata
+  updates
+  version
+  defaults
+  requires
+
+metadata:
+  author=Greg <greg@dmdirc.com>
+  mainclass=com.dmdirc.addons.swingdebug.SwingDebugPlugin
+  description=Debugging plugin for DMDirc.
+  name=swingdebug
+  nicename=Swing debug
+  unloadable=yes
+
+updates:
+  id=60
+
+version:
+  friendly=0.1
+
+requires:
+    parent=ui_swing
+
+required-services:
+    swing ui
+
+defaults:
+    debugEDT=false
+    slowedttaskthreshold=100

src/com/dmdirc/addons/ui_swing/DMDircEventQueue.java

 import com.dmdirc.addons.ui_swing.actions.CutAction;
 import com.dmdirc.addons.ui_swing.actions.PasteAction;
 
-import com.dmdirc.config.IdentityManager;
-import com.dmdirc.interfaces.ConfigChangeListener;
 import java.awt.AWTEvent;
 import java.awt.Component;
 import java.awt.EventQueue;
 import javax.swing.text.JTextComponent;
 
 /**
- * Custom event queue to add common functionality to certain components and 
- * monitor the EDT for long running tasks.  The monitoring code was taken from
- * TracingEventQueue by Kirill Grouchnikov (http://today.java.net/lpt/a/433).
+ * Custom event queue to add common functionality to certain components.
  */
-public final class DMDircEventQueue extends EventQueue implements
-        ConfigChangeListener {
+public class DMDircEventQueue extends EventQueue {
 
     /** Swing Controller. */
-    private SwingController controller;
-    /** Tracing thread. */
-    private TracingEventQueueThread tracingThread;
+    private final SwingController controller;
 
-    /** 
-     * Instantiates the DMDircEventQueue. 
-     * 
+    /**
+     * Instantiates the DMDircEventQueue.
+     *
      * @param controller Swing controller
      */
     public DMDircEventQueue(final SwingController controller) {
         super();
 
         this.controller = controller;
-        checkTracing();
-        IdentityManager.getGlobalConfig().addChangeListener(
-                controller.getDomain(), "debugEDT", this);
     }
 
     /** {@inheritDoc} */
     @Override
     protected void dispatchEvent(final AWTEvent event) {
-        if (tracingThread == null) {
-            super.dispatchEvent(event);
-        } else {
-            if (tracingThread != null) {
-                tracingThread.eventDispatched(event);
-            }
-            super.dispatchEvent(event);
-            if (tracingThread != null) {
-                tracingThread.eventProcessed(event);
-            }
-        }
-
         if (event instanceof MouseEvent) {
             handleMouseEvent((MouseEvent) event);
         } else if (event instanceof KeyEvent) {
         } else if (event instanceof WindowEvent) {
             handleWindowEvent((WindowEvent) event);
         }
+        preDispatchEvent(event);
+        super.dispatchEvent(event);
+        postDispatchEvent(event);
     }
 
-    private void checkTracing() {
-        final boolean tracing = IdentityManager.getGlobalConfig().
-                getOptionBool(controller.getDomain(), "debugEDT");
-        if (tracing) {
-            tracingThread = new TracingEventQueueThread(100);
-            tracingThread.start();
-        } else {
-            if (tracingThread != null) {
-                tracingThread.cancel();
-                tracingThread = null;
-            }
-        }
+    /**
+     * Triggered before the event is dispatched to AWT.
+     *
+     * @param event Event about to be dispatched
+     */
+    protected void preDispatchEvent(final AWTEvent event) {
+        //Do nothing
+    }
+
+    /**
+     * Called just after an event is dispatched to AWT.
+     *
+     * @param event Event that has been dispatched
+     */
+    protected void postDispatchEvent(final AWTEvent event) {
+        //Do nothing
     }
 
     /**
      * Handles key events.
-     * 
+     *
      * @param ke Key event
      */
     private void handleKeyEvent(final KeyEvent ke) {
-        switch (ke.getKeyChar()) {
-            case KeyEvent.VK_F1:
-            //Fallthrough
-            case KeyEvent.VK_F2:
-            //Fallthrough
-            case KeyEvent.VK_F3:
-            //Fallthrough
-            case KeyEvent.VK_F4:
-            //Fallthrough
-            case KeyEvent.VK_F5:
-            //Fallthrough
-            case KeyEvent.VK_F6:
-            //Fallthrough
-            case KeyEvent.VK_F7:
-            //Fallthrough
-            case KeyEvent.VK_F8:
-            //Fallthrough
-            case KeyEvent.VK_F9:
-            //Fallthrough
-            case KeyEvent.VK_F10:
-            //Fallthrough
-            case KeyEvent.VK_F11:
-            //Fallthrough
-            case KeyEvent.VK_F12:
-            //Fallthrough
-            case KeyEvent.VK_F13:
-            //Fallthrough
-            case KeyEvent.VK_F14:
-            //Fallthrough
-            case KeyEvent.VK_F15:
-            //Fallthrough
-            case KeyEvent.VK_F16:
-            //Fallthrough
-            case KeyEvent.VK_F17:
-            //Fallthrough
-            case KeyEvent.VK_F18:
-            //Fallthrough
-            case KeyEvent.VK_F19:
-            //Fallthrough
-            case KeyEvent.VK_F20:
-            //Fallthrough
-            case KeyEvent.VK_F21:
-            //Fallthrough
-            case KeyEvent.VK_F22:
-            //Fallthrough
-            case KeyEvent.VK_F23:
-            //Fallthrough
-            case KeyEvent.VK_F24:
-                ActionManager.processEvent(CoreActionType.CLIENT_KEY_PRESSED,
-                        null, KeyStroke.getKeyStroke(ke.getKeyChar(),
-                        ke.getModifiers()));
-                break;
-            default:
-                if (ke.getModifiers() != 0) {
-                    ActionManager.processEvent(CoreActionType.CLIENT_KEY_PRESSED,
-                            null, KeyStroke.getKeyStroke(ke.getKeyChar(),
-                            ke.getModifiers()));
-                }
-                break;
-        }
+        ActionManager.processEvent(CoreActionType.CLIENT_KEY_PRESSED, null,
+                KeyStroke.getKeyStroke(ke.getKeyChar(), ke.getModifiers()));
     }
 
     /**
      * Handles mouse events.
-     * 
+     *
      * @param me Mouse event
      */
     private void handleMouseEvent(final MouseEvent me) {
-        if (!me.isPopupTrigger()) {
-            return;
-        }
-
-        if (me.getComponent() == null) {
+        if (!me.isPopupTrigger() || me.getComponent() == null) {
             return;
         }
 
         final Component comp = SwingUtilities.getDeepestComponentAt(
                 me.getComponent(), me.getX(), me.getY());
 
-        if (!(comp instanceof JTextComponent)) {
-            return;
-        }
-
-        if (MenuSelectionManager.defaultManager().getSelectedPath().length > 0) {
+        if (!(comp instanceof JTextComponent) || MenuSelectionManager
+                .defaultManager().getSelectedPath().length > 0) {
             return;
         }
 
     }
 
     /**
-     * Handles window events
-     * 
-     * @param windowEvent Window event
+     * Handles window events.
+     *
+     * @param we Window event
      */
     private void handleWindowEvent(final WindowEvent we) {
-        if (we.getSource() instanceof Window) {
-            if (controller.hasMainFrame()) {
-                if (we.getID() == WindowEvent.WINDOW_OPENED) {
-                    controller.addTopLevelWindow((Window) we.getSource());
-                } else if (we.getID() == WindowEvent.WINDOW_CLOSED) {
-                    controller.delTopLevelWindow((Window) we.getSource());
-                }
+        if ((we.getSource() instanceof Window) && controller.hasMainFrame()) {
+            if (we.getID() == WindowEvent.WINDOW_OPENED) {
+                controller.addTopLevelWindow((Window) we.getSource());
+            } else if (we.getID() == WindowEvent.WINDOW_CLOSED) {
+                controller.delTopLevelWindow((Window) we.getSource());
             }
         }
     }
-
-    /** {@inheritDoc} */
-    @Override
-    public void configChanged(final String domain, final String key) {
-        checkTracing();
-    }
 }

src/com/dmdirc/addons/ui_swing/MainFrame.java

 import java.lang.reflect.InvocationTargetException;
 
 import javax.swing.ImageIcon;
-import javax.swing.JDesktopPane;
 import javax.swing.JFrame;
 import javax.swing.JPanel;
 import javax.swing.JSplitPane;

src/com/dmdirc/addons/ui_swing/components/CheckBoxMenuItem.java

+/*
+ * Copyright (c) 2006-2010 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.ui_swing.components;
+
+import javax.swing.Action;
+import javax.swing.Icon;
+import javax.swing.JCheckBoxMenuItem;
+import javax.swing.MenuElement;
+import javax.swing.MenuSelectionManager;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+/**
+ * Extention of a normal JCheckboxMenuItem that stays open when clicked.
+ */
+public class CheckBoxMenuItem extends JCheckBoxMenuItem {
+
+    /** Menu path to use when clicked. */
+    private static MenuElement[] path;
+
+    /**
+     * Constructs a new checkbox menu item.
+     *
+     * @see JCheckBoxMenuItem#JCheckBoxMenuItem()
+     */
+    public CheckBoxMenuItem() {
+        super();
+        getModel().addChangeListener(new StayOpenListener());
+    }
+
+    /**
+     * Constructs a new checkbox menu item with the specified action.
+     *
+     * @param a Action to use
+     *
+     * @see JCheckBoxMenuItem#JCheckBoxMenuItem(Action)
+     */
+    public CheckBoxMenuItem(final Action a) {
+        super(a);
+        getModel().addChangeListener(new StayOpenListener());
+    }
+
+    /**
+     * Constructs a new checkbox menu item with the specified action.
+     *
+     * @param icon Icon to use
+     *
+     * @see JCheckBoxMenuItem#JCheckBoxMenuItem(Icon)
+     */
+    public CheckBoxMenuItem(final Icon icon) {
+        super(icon);
+        getModel().addChangeListener(new StayOpenListener());
+    }
+
+    /**
+     * Constructs a new checkbox menu item with the specified text.
+     *
+     * @param text Text to use
+     *
+     * @see JCheckBoxMenuItem#JCheckBoxMenuItem(String)
+     */
+    public CheckBoxMenuItem(final String text) {
+        super(text);
+        getModel().addChangeListener(new StayOpenListener());
+    }
+
+    /**
+     * Constructs a new checkbox menu item with the specified text and selected
+     * state.
+     *
+     * @param text Text to use
+     * @param selected Initial selection state
+     *
+     * @see JCheckBoxMenuItem#JCheckBoxMenuItem(String, boolean)
+     */
+    public CheckBoxMenuItem(final String text, final boolean selected) {
+        super(text, selected);
+        getModel().addChangeListener(new StayOpenListener());
+    }
+
+    /**
+     * Constructs a new checkbox menu item with the specified text and icon.
+     *
+     * @param text Text to use
+     * @param icon Icon to use
+     *
+     * @see JCheckBoxMenuItem#JCheckBoxMenuItem(String, Icon)
+     */
+    public CheckBoxMenuItem(final String text, final Icon icon) {
+        super(text, icon);
+        getModel().addChangeListener(new StayOpenListener());
+    }
+
+    /**
+     * Constructs a new checkbox menu item with the specified text icon and
+     * initial selected state.
+     *
+     * @param text Text to use
+     * @param icon Icon to use
+     * @param selected Initial selection state
+     *
+     * @see JCheckBoxMenuItem#JCheckBoxMenuItem(String, Icon, boolean)
+     */
+    public CheckBoxMenuItem(final String text, final Icon icon,
+            final boolean selected) {
+        super(text, icon, selected);
+        getModel().addChangeListener(new StayOpenListener());
+    }
+
+    /**
+     * Overridden to reopen the menu.
+     *
+     * @param pressTime the time to "hold down" the button, in milliseconds
+     */
+    @Override
+    public void doClick(final int pressTime) {
+        super.doClick(pressTime);
+        MenuSelectionManager.defaultManager().setSelectedPath(path);
+    }
+
+    /**
+     * Listener to restore the saved path when clicked.
+     */
+    private class StayOpenListener implements ChangeListener {
+
+        /** {@inheritDoc} */
+        @Override
+        public void stateChanged(final ChangeEvent e) {
+            if (getModel().isArmed() && isShowing()) {
+                path = MenuSelectionManager.defaultManager().getSelectedPath();
+            }
+        }
+    }
+}

src/com/dmdirc/addons/ui_swing/components/MenuBar.java

     private final SwingController controller;
     /** Main frame. */
     private final MainFrame mainFrame;
+    /** Normal menu count. */
+    private int menuItemCount = 0;
 
     /**
      * Instantiates a new menu bar.
         initSettingsMenu();
         add(new WindowMenuFrameManager(controller));
         initHelpMenu();
-        add(Box.createHorizontalGlue(), "growx, pushx");
-        add(new MDIBar(controller, mainFrame));
-        add(Box.createHorizontalStrut(PlatformDefaults.getPanelInsets(1)
+        menuItemCount = getComponentCount();
+        super.add(Box.createHorizontalGlue(), "growx, pushx");
+        super.add(new MDIBar(controller, mainFrame));
+        super.add(Box.createHorizontalStrut(PlatformDefaults.getPanelInsets(1)
                 .getUnit()));
+        menuItemCount = getComponentCount() - menuItemCount;
 
         getActionMap().setParent(null);
         getActionMap().clear();
         menuSelected(null);
     }
 
+    /** {@inheritDoc} */
+    @Override
+    public JMenu add(final JMenu c) {
+        return (JMenu) super.add(c, getComponentCount() - menuItemCount);
+    }
+
     /**
      * Initialises the server menu.
      */

src/com/dmdirc/addons/ui_swing/plugin.config

   swing ui
 
 defaults:
-    debugEDT=false
     windowMenuItems=30
     windowMenuScrollInterval=250
     showtopicbar=true