Fixes issue 617: window closing procedure

git-svn-id: http://svn.dmdirc.com/trunk@3115 00569f92-eb28-0410-84fd-f71c24880f

src/com/dmdirc/Channel.java

         window.updateNames(new ArrayList<ChannelClientInfo>());
     }
     
-    /**
-     * Parts the channel and then closes the window.
-     */
+    /** {@inheritDoc} */
     @Override
-    public void close() {
+    public void windowClosing() {
+        // 1: Make the window non-visible
+        window.setVisible(false);
+        
+        // 2: Remove any callbacks or listeners
+        eventHandler.unregisterCallbacks();
+        
+        // 3: Trigger any actions neccessary
         part(configManager.getOption("general", "partmessage"));
-        closeWindow();
-    }
-    
-    /**
-     * Closes the window without parting the channel.
-     */
-    public void closeWindow() {
-        closeWindow(true);
-    }
-    
-    /**
-     * Closes the window without parting the channel.
-     *
-     * @param shouldRemove Whether we should remove the window from the server
-     */
-    public void closeWindow(final boolean shouldRemove) {
-        if (server.getParser() != null) {
-            server.getParser().getCallbackManager().delAllCallback(eventHandler);
-        }
         
+        // 4: Trigger action for the window closing
         ActionManager.processEvent(CoreActionType.CHANNEL_CLOSED, null, this);
         
-        if (shouldRemove) {
-            server.delChannel(channelInfo.getName());
-        }
+        // 5: Inform any parents that the window is closing
+        server.delChannel(channelInfo.getName());
         
-        window.setVisible(false);
-        Main.getUI().getMainWindow().delChild(window);
+        // 6: Remove the window from the window manager
         WindowManager.removeWindow(window);
-        window.close();
-        window = null;
-        server = null;
+        if (server.getParser() != null) {
+            server.getParser().getCallbackManager().delAllCallback(eventHandler);
+        }
+        
+        // 7: Remove any references to the window and parents
+        window = null; // NOPMD
+        server = null; // NOPMD
     }
     
     /**

src/com/dmdirc/CustomWindow.java

 
     /** {@inheritDoc} */
     @Override
-    public void close() {
+    public void windowClosing() {
+        // 1: Make the window non-visible
         window.setVisible(false);
-
+        
+        // 2: Remove any callbacks or listeners
+        // 3: Trigger any actions neccessary
+        // 4: Trigger action for the window closing
+        // 5: Inform any parents that the window is closing
+        
+        // 6: Remove the window from the window manager
         WindowManager.removeWindow(window);
-        Main.getUI().getMainWindow().delChild(window);
         
-        window.close();
+        // 7: Remove any references to the window and parents
         window = null; // NOPMD
+        parent = null; // NOPMD
     }
 
     /** {@inheritDoc} */

src/com/dmdirc/EventHandler.java

             Logger.appError(ErrorLevel.FATAL, "Unable to register callbacks",
                     exception);
         }
-    }    
+    }
+    
+    /**
+     * Unregisters all callbacks that have been registered by this event handler.
+     */
+    public void unregisterCallbacks() {
+        getParser().getCallbackManager().delAllCallback(this);
+    }
     
     /**
      * Adds a callback to this event handler.

src/com/dmdirc/FrameContainer.java

     /**
      * Closes this container (and it's associated frame).
      */
-    public abstract void close();
+    public final void close() {
+        if (getFrame() == null) {
+            throw new IllegalStateException("No frame associated with this container!");
+        } else {
+            getFrame().close();
+        }
+    }
 
     /**
      * Returns the server instance associated with this container.
     /**
      * Invoked when our window is closing.
      */
-    public void windowClosing() {
-        close();
-    }
+    public abstract void windowClosing();
 
     /**
      * Invoked when our window has been closed.

src/com/dmdirc/GlobalWindow.java

         window.open();
     }
 
+    /** {@inheritDoc} */
+    @Override    
     public InputWindow getFrame() {
         return window;
     }
 
+    /** {@inheritDoc} */
+    @Override
     public String toString() {
         return "Global";
     }
 
-    public void close() {
+    /** {@inheritDoc} */
+    @Override    
+    public void windowClosing() {
+        // 1: Make the window non-visible
         window.setVisible(false);
-        window.close();
+        
+        // 2: Remove any callbacks or listeners
+        // 3: Trigger any actions neccessary
+        // 4: Trigger action for the window closing
+        // 5: Inform any parents that the window is closing
+        
+        // 6: Remove the window from the window manager
         WindowManager.removeWindow(window);
-        Main.getUI().getMainWindow().delChild(window);
+        
+        // 7: Remove any references to the window and parents        
     }
 
+    /** {@inheritDoc} */
+    @Override    
     public Server getServer() {
         return null;
     }
 
+    /** {@inheritDoc} */
+    @Override    
     public void sendLine(final String line) {
         GlobalCommandParser.getGlobalCommandParser().parseCommand(window, 
                 CommandManager.getCommandChar() + line);
     }
 
+    /** {@inheritDoc} */
+    @Override    
     public int getMaxLineLength() {
         return 0;
     }
     
+    /** {@inheritDoc} */
     @Override
     public ConfigManager getConfigManager() {
         return IdentityManager.getGlobalConfig();

src/com/dmdirc/Query.java

  */
 public final class Query extends MessageTarget implements
         IPrivateAction, IPrivateMessage, INickChanged, IQuit, Serializable {
-    
+
     /**
      * A version number for this class. It should be changed whenever the class
      * structure is changed (or anything else that would prevent serialized
      * objects being unserialized with the new class).
      */
     private static final long serialVersionUID = 1;
-    
+
     /** The Server this Query is on. */
     private Server server;
-    
+
     /** The QueryWindow used for this Query. */
     private QueryWindow window;
-    
+
     /** The full host of the client associated with this Query. */
     private String host;
-    
+
     /** The tab completer for the query window. */
     private final TabCompleter tabCompleter;
-    
+
     /**
      * Creates a new instance of Query.
      *
      */
     public Query(final Server newServer, final String newHost) {
         super();
-        
+
         this.server = newServer;
         this.host = newHost;
-        
+
         icon = IconManager.getIconManager().getIcon("query");
-        
+
         window = Main.getUI().getQuery(this);
         WindowManager.addWindow(server.getFrame(), window);
-        
+
         ActionManager.processEvent(CoreActionType.QUERY_OPENED, null, this);
-        
+
         window.setFrameIcon(icon);
-        
+
         if (!server.getConfigManager().getOptionBool("general", "hidequeries", false)) {
             window.open();
         }
-        
+
         tabCompleter = new TabCompleter(server.getTabCompleter());
         tabCompleter.addEntries(CommandManager.getCommandNames(CommandType.TYPE_QUERY));
         tabCompleter.addEntries(CommandManager.getCommandNames(CommandType.TYPE_CHAT));
         window.getInputHandler().setTabCompleter(tabCompleter);
-        
+
         reregister();
-        
+
         updateTitle();
     }
-    
+
     /**
      * Shows this query's window.
      */
     public void show() {
         window.open();
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public InputWindow getFrame() {
         return window;
     }
-    
+
     /**
      * Returns the tab completer for this query.
      *
     public TabCompleter getTabCompleter() {
         return tabCompleter;
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void sendLine(final String line) {
             Toolkit.getDefaultToolkit().beep();
             return;
         }
-        
+
         if (line.indexOf('\n') > -1) {
             for (String part : line.split("\n")) {
                 sendLine(part);
             }
-            
+
             return;
         }
 
         final ClientInfo client = server.getParser().getMyself();
-        
+
         if (line.length() <= getMaxLineLength()) {
             server.getParser().sendMessage(ClientInfo.parseHost(host), window.getTranscoder().encode(line));
-            
+
             final StringBuffer buff = new StringBuffer("querySelfMessage");
-            
+
             ActionManager.processEvent(CoreActionType.QUERY_SELF_MESSAGE, buff, this, line);
-            
+
             addLine(buff, client.getNickname(), client.getIdent(),
                     client.getHost(), window.getTranscoder().encode(line));
         } else {
             sendLine(line.substring(getMaxLineLength()));
         }
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public int getMaxLineLength() {
         return server.getParser().getMaxLength("PRIVMSG", host);
     }
-    
+
     /**
      * Sends a private action to the remote user.
      *
             Toolkit.getDefaultToolkit().beep();
             return;
         }
-        
+
         final ClientInfo client = server.getParser().getMyself();
         final int maxLineLength = server.getParser().getMaxLength("PRIVMSG", host);
-        
+
         if (maxLineLength >= action.length() + 2) {
             server.getParser().sendAction(ClientInfo.parseHost(host), window.getTranscoder().encode(action));
-            
+
             final StringBuffer buff = new StringBuffer("querySelfAction");
-            
+
             ActionManager.processEvent(CoreActionType.QUERY_SELF_ACTION, buff, this, action);
-            
+
             addLine(buff, client.getNickname(), client.getIdent(),
                     client.getHost(), window.getTranscoder().encode(action));
         } else {
             addLine("actionTooLong", action.length());
         }
     }
-    
+
     /**
      * Handles a private message event from the parser.
      *
     public void onPrivateMessage(final IRCParser parser, final String message,
             final String remoteHost) {
         final String[] parts = ClientInfo.parseHostFull(remoteHost);
-        
+
         final StringBuffer buff = new StringBuffer("queryMessage");
-        
+
         ActionManager.processEvent(CoreActionType.QUERY_MESSAGE, buff, this, message);
-        
+
         addLine(buff, parts[0], parts[1], parts[2], message);
     }
-    
+
     /**
      * Handles a private action event from the parser.
      *
     public void onPrivateAction(final IRCParser parser, final String message,
             final String remoteHost) {
         final String[] parts = ClientInfo.parseHostFull(host);
-        
+
         final StringBuffer buff = new StringBuffer("queryAction");
-        
+
         ActionManager.processEvent(CoreActionType.QUERY_ACTION, buff, this, message);
-        
+
         addLine(buff, parts[0], parts[1], parts[2], message);
     }
-    
+
     /**
      * Updates the QueryWindow's title.
      */
     private void updateTitle() {
         final String title = ClientInfo.parseHost(host);
-        
+
         window.setTitle(title);
-        
+
         if (window.isMaximum() && window.equals(Main.getUI().getMainWindow().getActiveFrame())) {
             Main.getUI().getMainWindow().setTitle(Main.getUI().getMainWindow().getTitlePrefix() + " - " + title);
         }
     }
-    
+
     /**
      * Reregisters query callbacks. Called when reconnecting to the server.
      */
     public void reregister() {
         final CallbackManager callbackManager = server.getParser().getCallbackManager();
-        
+
         try {
             callbackManager.addCallback("onPrivateAction", this, ClientInfo.parseHost(host));
             callbackManager.addCallback("onPrivateMessage", this, ClientInfo.parseHost(host));
             Logger.appError(ErrorLevel.HIGH, "Unable to get query events", ex);
         }
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onNickChanged(final IRCParser tParser, final ClientInfo cClient,
             final String sOldNick) {
         if (sOldNick.equals(ClientInfo.parseHost(host))) {
             final CallbackManager callbackManager = server.getParser().getCallbackManager();
-            
+
             callbackManager.delCallback("onPrivateAction", this);
             callbackManager.delCallback("onPrivateMessage", this);
-            
+
             try {
                 callbackManager.addCallback("onPrivateAction", this, cClient.getNickname());
                 callbackManager.addCallback("onPrivateMessage", this, cClient.getNickname());
             } catch (CallbackNotFoundException ex) {
                 Logger.appError(ErrorLevel.HIGH, "Unable to get query events", ex);
             }
-            
+
             final StringBuffer format = new StringBuffer("queryNickChanged");
-            
+
             ActionManager.processEvent(CoreActionType.QUERY_NICKCHANGE, format, this, sOldNick);
-            
+
             server.getTabCompleter().removeEntry(sOldNick);
             server.getTabCompleter().addEntry(cClient.getNickname());
-            
+
             addLine(format, sOldNick, cClient.getIdent(),
                     cClient.getHost(), cClient.getNickname());
             host = cClient.getNickname() + "!" + cClient.getIdent() + "@" + cClient.getHost();
             updateTitle();
         }
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onQuit(final IRCParser tParser, final ClientInfo cClient,
         if (cClient.getNickname().equals(ClientInfo.parseHost(host))) {
             final StringBuffer format = new StringBuffer(sReason.isEmpty() ?
                 "queryQuit" : "queryQuitReason");
-            
+
             ActionManager.processEvent(CoreActionType.QUERY_QUIT, format, this, sReason);
-            
+
             addLine(format, cClient.getNickname(),
                     cClient.getIdent(), cClient.getHost(), sReason);
         }
     }
-    
+
     /**
      * Returns the Server assocaited with this query.
      *
     public Server getServer() {
         return server;
     }
-    
-    /**
-     * Closes the query and associated window.
-     */
+
+    /** {@inheritDoc} */
     @Override
-    public void close() {
-        close(true);
-    }
-    
-    /**
-     * Closes the query and associated window.
-     *
-     * @param shouldRemove Whether or not we should remove the window from the server.
-     */
-    public void close(final boolean shouldRemove) {
+    public void windowClosing() {
+        // 1: Make the window non-visible
+        window.setVisible(false);
+
+        // 2: Remove any callbacks or listeners
         if (server != null && server.getParser() != null) {
-            server.getParser().getCallbackManager().delCallback("onPrivateAction", this);
-            server.getParser().getCallbackManager().delCallback("onPrivateMessage", this);
-            server.getParser().getCallbackManager().delCallback("onNickChanged", this);
-            server.getParser().getCallbackManager().delCallback("onQuit", this);
+            server.getParser().getCallbackManager().delAllCallback(this);
         }
-        
+
+        // 3: Trigger any actions neccessary
+
+        // 4: Trigger action for the window closing
         ActionManager.processEvent(CoreActionType.QUERY_CLOSED, null, this);
-        
-        if (server != null && shouldRemove) {
-            server.delQuery(this);
-        }
-        
-        if (window != null) {
-            Main.getUI().getMainWindow().delChild(window);
-            WindowManager.removeWindow(window);
-            window.close();
-            window.setVisible(false);
-        }
-        
+
+        // 5: Inform any parents that the window is closing
+        server.delQuery(this);
+
+        // 6: Remove the window from the window manager
+        WindowManager.removeWindow(window);
+
+        // 7: Remove any references to the window and parents
         window = null;
         server = null;
     }
-    
+
     /**
      * Returns this query's name.
      *
     public String toString() {
         return ClientInfo.parseHost(host);
     }
-    
+
     /**
      * Returns the host that this query is with.
      *
     public String getHost() {
         return host;
     }
-    
+
     /**
      * Returns the current nickname of the user that this query is with.
-     * 
+     *
      * @return The nickname of this query's user
      */
     public String getNickname() {
         return ClientInfo.parseHost(host);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void activateFrame() {
         if (window == null) {
             return;
         }
-        
+
         if (!window.isVisible()) {
             show();
         }
-        
+
         Main.getUI().getMainWindow().setActiveFrame(window);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public ConfigManager getConfigManager() {
                     " from a query with no server", new IllegalStateException("My host: " + host));
             return IdentityManager.getGlobalConfig();
         }
-        
+
         return server.getConfigManager();
-    }    
-    
+    }
+
 }

src/com/dmdirc/Raw.java

     
     /** {@inheritDoc} */
     @Override
-    public void close() {
-        if (server.getParser() != null) {
-            server.getParser().getCallbackManager().delCallback("OnDataIn", this);
-            server.getParser().getCallbackManager().delCallback("OnDataOut", this);
+    public void windowClosing() {
+        // 1: Make the window non-visible
+        window.setVisible(false);
+        
+        // 2: Remove any callbacks or listeners
+        if (server != null && server.getParser() != null) {
+            server.getParser().getCallbackManager().delAllCallback(this);
         }
         
-        window.setVisible(false);
-        WindowManager.removeWindow(window);
-        Main.getUI().getMainWindow().delChild(window);
+        // 3: Trigger any actions neccessary
+        // 4: Trigger action for the window closing
         
+        // 5: Inform any parents that the window is closing
         server.delRaw();
-        window.close();
+        
+        // 6: Remove the window from the window manager
+        WindowManager.removeWindow(window);
+        
+        // 7: Remove any references to the window and parents
         window = null;
         server = null;
     }
     
     /** {@inheritDoc} */
+    @Override
     public InputWindow getFrame() {
         return window;
     }
     
     /** {@inheritDoc} */
+    @Override
     public void onDataIn(final IRCParser tParser, final String sData) {
         addLine("rawIn", sData);
     }
     
     /** {@inheritDoc} */
+    @Override
     public void onDataOut(final IRCParser tParser, final String sData,
             final boolean bFromParser) {
         addLine("rawOut", sData);
     }
     
     /** {@inheritDoc} */
+    @Override
     public String toString() {
         return "Raw";
     }
     
     /** {@inheritDoc} */
+    @Override
     public Server getServer() {
         return server;
     }
     
     /** {@inheritDoc} */
+    @Override
     public void sendLine(final String line) {
         server.sendLine(window.getTranscoder().encode(line));
     }
     
     /** {@inheritDoc} */
+    @Override
     public int getMaxLineLength() {
         return server.getMaxLineLength();
     }

src/com/dmdirc/Server.java

     public void reconnect() {
         reconnect(configManager.getOption(DOMAIN_GENERAL, "reconnectmessage"));
     }
+    
+    /**
+     * Disconnects from the server with the default quit message.
+     */
+    public void disconnect() {
+        disconnect(configManager.getOption(DOMAIN_GENERAL, "quitmessage"));
+    }
 
     /**
      * Disconnects from the server.
         return myState;
     }
 
-    /**
-     * Closes this server connection and associated windows.
-     *
-     * @param reason reason for closing
-     */
-    public void close(final String reason) {
+    /** {@inheritDoc} */
+    @Override
+    public void windowClosing() {
+        // 1: Make the window non-visible
+        window.setVisible(false);
+        
+        // 2: Remove any callbacks or listeners
         if (parser != null) {
-            // Unregister parser callbacks
             parser.getCallbackManager().delAllCallback(eventHandler);
         }
-
-        // Disconnect from the server
-        disconnect(reason);
-
+        
+        // 3: Trigger any actions neccessary
+        if (parser != null && parser.isReady()) {
+            disconnect();
+        }
+        
         myState = ServerState.CLOSING;
-
-        // Close all channel windows
         closeChannels();
-        // Close all query windows
         closeQueries();
-        // Close the raw window
+
         if (raw != null) {
             raw.close();
         }
         
-        // Unregister ourselves with the server manager
+        
+        // 4: Trigger action for the window closing
+        // 5: Inform any parents that the window is closing
         ServerManager.getServerManager().unregisterServer(this);
-
-        if (window != null) {
-            window.setVisible(false);
-            WindowManager.removeWindow(window);
-            Main.getUI().getMainWindow().delChild(window);
-            window.close();
-            window = null; //NOPMD
-        }
-
-        // Ditch the parser
+        
+        // 6: Remove the window from the window manager
+        WindowManager.removeWindow(window);
+        
+        // 7: Remove any references to the window and parents
+        window = null; //NOPMD
         parser = null; //NOPMD
     }
 
-    /** {@inheritDoc} */
-    @Override
-    public void close() {
-        close(configManager.getOption(DOMAIN_GENERAL, "quitmessage"));
-    }
-
     /**
      * Closes all open channel windows associated with this server.
      */
     private void closeChannels() {
         for (Channel channel : new ArrayList<Channel>(channels.values())) {
-            channel.closeWindow(false);
+            channel.close();
         }
-
-        channels.clear();
     }
 
     /**
      */
     private void closeQueries() {
         for (Query query : new ArrayList<Query>(queries)) {
-            query.close(false);
+            query.close();
         }
-
-        queries.clear();
     }
 
     /**

src/com/dmdirc/ServerManager.java

 package com.dmdirc;
 
 import com.dmdirc.config.IdentityManager;
-import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.interfaces.Window;
 
 import java.util.ArrayList;
     /** Singleton instance of ServerManager. */
     private static ServerManager me;
     
-    /**
-     * Indicates that the server manager is in the process of closing all
-     * servers. Used to prevent concurrent access to the servers property.
-     */
-    private boolean closing;
-    
     /** All servers that currently exist. */
     private final List<Server> servers = new ArrayList<Server>();
     
      * @param server The server to be unregistered
      */
     public void unregisterServer(final Server server) {
-        if (!closing) {
-            servers.remove(server);
-        }
+        servers.remove(server);
     }
     
     /**
      * Closes all servers with a default quit message.
      */
     public void closeAll() {
-        closing = true;
-        for (Server server : servers) {
-            server.close(server.getConfigManager().getOption("general", "quitmessage"));
+        for (Server server : new ArrayList<Server>(servers)) {
+            server.disconnect();
+            server.close();
         }
-        closing = false;
-        servers.clear();
     }
     
     /**
      * @param message The quit message to send to the IRC servers
      */
     public void closeAll(final String message) {
-        closing = true;
-        for (Server server : servers) {
-            server.close(message);
+        for (Server server : new ArrayList<Server>(servers)) {
+            server.disconnect(message);
+            server.close();
         }
-        closing = false;
-        servers.clear();
     }
     
     /**
                 return server;
             }
         }
+        
         return null;
     }
     

src/com/dmdirc/addons/dcc/DCCChatWindow.java

 	/**
 	 * Closes this container (and it's associated frame).
 	 */
-	public void close() {
+        @Override
+	public void windowClosing() {
 		dcc.close();
-		super.close();
+		super.windowClosing();
 	}
 }

src/com/dmdirc/addons/dcc/DCCFrame.java

 
 package com.dmdirc.addons.dcc;
 
+import com.dmdirc.IconManager;
+import com.dmdirc.Server;
 import com.dmdirc.WritableFrameContainer;
-import com.dmdirc.config.ConfigManager;
-import com.dmdirc.config.IdentityManager;
-import com.dmdirc.ui.swing.components.InputTextFrame;
-import com.dmdirc.Main;
 import com.dmdirc.commandparser.CommandManager;
-import com.dmdirc.commandparser.parsers.GlobalCommandParser;
-import com.dmdirc.commandparser.parsers.CommandParser;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.GlobalCommand;
-
-import com.dmdirc.IconManager;
-import com.dmdirc.Server;
+import com.dmdirc.commandparser.parsers.CommandParser;
+import com.dmdirc.commandparser.parsers.GlobalCommandParser;
+import com.dmdirc.config.ConfigManager;
+import com.dmdirc.config.IdentityManager;
 import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.interfaces.InputWindow;
+import com.dmdirc.ui.swing.components.InputTextFrame;
 
 /**
  * This class links DCC objects to a window.
 		private static final long serialVersionUID = 200711271;
 		
 		/** Loads the relevant commands into the parser. */
+        @Override
 		protected void loadCommands() { CommandManager.loadGlobalCommands(this); }
 		
 		/**
 		 * @param command The command to be executed
 		 * @param args The arguments to the command
 		 */
+        @Override
 		protected void executeCommand(final InputWindow origin, final boolean isSilent, final Command command, final String... args) {
 			((GlobalCommand) command).execute(origin, isSilent, args);
 		}
 		 * @param origin The window in which the command was typed
 		 * @param line The line input by the user
 		 */
+        @Override
 		protected void handleNonCommand(final InputWindow origin, final String line) {
 			if (origin.getContainer() instanceof WritableFrameContainer) {
 				((WritableFrameContainer)origin.getContainer()).sendLine(line);
 		return null;
 	}
 	
-	/**
-	 * Closes this container (and it's associated frame).
-	 */
+	/** {@inheritDoc} */
 	@Override
-	public void close() {
-		plugin.delWindow(this);
-		myWindow.setVisible(false);
-		Main.getUI().getMainWindow().delChild(myWindow);
-		WindowManager.removeWindow(myWindow);
-                myWindow.close();
-                myWindow = null;
+	public void windowClosing() {
+                // 1: Make the window non-visible
+                myWindow.setVisible(false);
+
+                // 2: Remove any callbacks or listeners
+                // 3: Trigger any actions neccessary
+                // 4: Trigger action for the window closing
+                
+                // 5: Inform any parents that the window is closing
+                plugin.delWindow(this);
+
+                // 6: Remove the window from the window manager
+                WindowManager.removeWindow(myWindow);
+
+                // 7: Remove any references to the window and parents
+                myWindow = null; // NOPMD
 	}   
 }

src/com/dmdirc/addons/dcc/DCCSendWindow.java

 
 package com.dmdirc.addons.dcc;
 
-import com.dmdirc.WritableFrameContainer;
-import com.dmdirc.IconManager;
-import com.dmdirc.Main;
-import com.dmdirc.Server;
-import com.dmdirc.config.IdentityManager;
 import com.dmdirc.ui.swing.JWrappingLabel;
 import com.dmdirc.ui.swing.components.TextFrame;
+
 import javax.swing.SwingConstants;
+
 /**
  * This class links DCC Send objects to a window.
  *
 	/**
 	 * Closes this container (and it's associated frame).
 	 */
-	public void close() {
+	public void windowClosing() {
 		dcc.close();
-		super.close();
+		super.windowClosing();
 	}
 }

src/com/dmdirc/addons/logging/HistoryWindow.java

     private final String title;
        
     /** The window we're using. */
-    private Window myWindow;
+    private Window window;
     
     /** Our parent window. */
-    private final Window parent;
+    private Window parent;
     
     /**
      * Creates a new HistoryWindow.
         
         icon = IconManager.getIconManager().getIcon("raw");
         
-        myWindow = Main.getUI().getWindow(this);
+        window = Main.getUI().getWindow(this);
         
-        WindowManager.addWindow(parent, myWindow);
+        WindowManager.addWindow(parent, window);
         
-        myWindow.setTitle(title);
-        myWindow.setFrameIcon(icon);
-        myWindow.setVisible(true);
+        window.setTitle(title);
+        window.setFrameIcon(icon);
+        window.setVisible(true);
         
         final Stack<String> lines = reader.getLines(
-                IdentityManager.getGlobalConfig().getOptionInt("plugin-Logging", "history.lines", 50000));
+                IdentityManager.getGlobalConfig().getOptionInt("plugin-Logging",
+                "history.lines", 50000));
         while (lines.size() > 0) {
-            myWindow.addLine(lines.pop(), false);
+            window.addLine(lines.pop(), false);
         }
     }
     
     /** {@inheritDoc} */
+    @Override
     public Window getFrame() {
-        return myWindow;
+        return window;
     }
     
     /** {@inheritDoc} */
+    @Override
     public String toString() {
         return title;
     }
     
     /** {@inheritDoc} */
-    public void close() {
-        myWindow.setVisible(false);
-        Main.getUI().getMainWindow().delChild(myWindow);
-        WindowManager.removeWindow(myWindow);
-        myWindow.close();
-        myWindow = null;
+    @Override
+    public void windowClosing() {
+        // 1: Make the window non-visible
+        window.setVisible(false);
+        
+        // 2: Remove any callbacks or listeners
+        // 3: Trigger any actions neccessary
+        // 4: Trigger action for the window closing
+        // 5: Inform any parents that the window is closing
+        
+        // 6: Remove the window from the window manager
+        WindowManager.removeWindow(window);
+        
+        // 7: Remove any references to the window and parents
+        window = null; // NOPMD
+        parent = null; // NOPMD
     }
     
     /** {@inheritDoc} */
+    @Override
     public Server getServer() {
         return parent.getContainer().getServer();
     }

src/com/dmdirc/commandparser/commands/channel/Part.java

             final Channel channel, final boolean isSilent, final String... args) {
         channel.part(args.length > 0 ? implodeArgs(args)
                 : origin.getConfigManager().getOption("general", "partmessage"));
-        channel.closeWindow();
+        channel.close();
     }
     
     /** {@inheritDoc} */