Core style/pmd fixes

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

src/com/dmdirc/Channel.java

 
     /**
      * Creates a new instance of Channel.
+     *
      * @param newServer The server object that this channel belongs to
      * @param newChannelInfo The parser's channel object that corresponds to
      * this channel
         icon = IconManager.getIconManager().getIcon("channel");
 
         tabCompleter = new TabCompleter(server.getTabCompleter());
-        tabCompleter.addEntries(TabCompletionType.COMMAND, 
+        tabCompleter.addEntries(TabCompletionType.COMMAND,
                 CommandManager.getCommandNames(CommandType.TYPE_CHANNEL));
         tabCompleter.addEntries(TabCompletionType.COMMAND,
                 CommandManager.getCommandNames(CommandType.TYPE_CHAT));
 
     /**
      * Returns the server object that this channel belongs to.
+     *
      * @return The server object
      */
     @Override
     }
 
     /**
-     * Returns the parser's ChannelInfo object that this object is associated with.
+     * Returns the parser's ChannelInfo object that this object is associated
+     * with.
+     *
      * @return The ChannelInfo object associated with this object
      */
     public ChannelInfo getChannelInfo() {
     }
 
     /**
-     * Sets this object's ChannelInfo reference to the one supplied. This only needs
-     * to be done if the channel window (and hence this channel object) has stayed
-     * open while the user has been out of the channel.
+     * Sets this object's ChannelInfo reference to the one supplied. This only
+     * needs to be done if the channel window (and hence this channel object)
+     * has stayed open while the user has been out of the channel.
+     *
      * @param newChannelInfo The new ChannelInfo object
      */
     public void setChannelInfo(final ChannelInfo newChannelInfo) {
 
     /**
      * Returns the internal window belonging to this object.
+     *
      * @return This object's internal window
      */
     @Override
 
     /**
      * Returns the tab completer for this channel.
+     *
      * @return This channel's tab completer
      */
     public TabCompleter getTabCompleter() {
     }
 
     /**
-     * Updates the title of the channel window, and of the main window if appropriate.
+     * Updates the title of the channel window, and of the main window if
+     * appropriate.
      */
     private void updateTitle() {
         String temp = Styliser.stipControlCodes(channelInfo.getName());
     }
 
     /**
-     * Joins the specified channel. This only makes sense if used after a call to
-     * part().
+     * Joins the specified channel. This only makes sense if used after a call
+     * to part().
      */
     public void join() {
         server.getParser().joinChannel(channelInfo.getName());
     /**
      * Parts this channel with the specified message. Parting does NOT close the
      * channel window.
+     *
      * @param reason The reason for parting the channel
      */
     public void part(final String reason) {
     }
 
     /**
-     * Replaces the list of known clients on this channel with the specified one.
+     * Replaces the list of known clients on this channel with the specified
+     * one.
      *
      * @param clients The list of clients to use
      */
     }
 
     /**
-     * Returns a string containing the most important mode for the specified client.
+     * Returns a string containing the most important mode for the specified
+     * client.
      *
      * @param channelClient The channel client to check.
      * @return A string containing the most important mode, or an empty string
     }
 
     /**
-     * Returns a string[] containing the nickname/ident/host of a channel client.
+     * Returns a string[] containing the nickname/ident/host of a channel
+     * client.
      *
      * @param client The channel client to check
      * @param showColours Whether or not to show colours

src/com/dmdirc/ChannelClientProperty.java

 
 /**
  * Represents the properties that can be set on a channel client.
+ *
  * @author chris
  */
 public enum ChannelClientProperty {
-    
+
     /** Nicklist client foreground colour. */
     NICKLIST_FOREGROUND,
+    
     /** Nicklist client background colour. */
     NICKLIST_BACKGROUND,
+    
     /** Textpane client foreground colour. */
     TEXT_FOREGROUND,
+    
     /** Textpane client background colour. */
     TEXT_BACKGROUND;
-    
+
 }

src/com/dmdirc/ChannelEventHandler.java

      */
     public ChannelEventHandler(final Channel owner) {
         super();
-        
+
         this.owner = owner;
     }
 
 
     /** {@inheritDoc} */
     @Override
-    public void onChannelTopic(final IRCParser tParser, final ChannelInfo cChannel,
-            final boolean bIsJoinTopic) {
+    public void onChannelTopic(final IRCParser tParser,
+            final ChannelInfo cChannel, final boolean bIsJoinTopic) {
         checkParser(tParser);
 
         final Topic newTopic = new Topic(cChannel.getTopic(),
             final ChannelClientInfo cChannelClient, final String sHost,
             final String sModes) {
         checkParser(tParser);
-        
+
         if (sHost.isEmpty()) {
             owner.doNotification(sModes.length() <= 1 ? "channelNoModes"
                     : "channelModeDiscovered", CoreActionType.CHANNEL_MODESDISCOVERED,
                     : "channelModeChanged", CoreActionType.CHANNEL_MODECHANGE,
                     cChannelClient, sModes);
         }
-        
+
         owner.refreshClients();
     }
 
             final ChannelInfo cChannel, final ChannelClientInfo cChangedClient,
             final ChannelClientInfo cSetByClient, final String sHost, final String sMode) {
         checkParser(tParser);
-        
+
         if (owner.getConfigManager().getOptionBool("channel", "splitusermodes", false)) {
             String format = "channelSplitUserMode_" + sMode;
-            
+
             if (!owner.getConfigManager().hasOption("format", format)) {
                 format = "channelSplitUserMode_default";
             }
- 
+
             owner.doNotification(format, CoreActionType.CHANNEL_USERMODECHANGE,
                     cSetByClient, cChangedClient, sMode);
         }
 
     /** {@inheritDoc} */
     @Override
-    public void onAwayStateOther(final IRCParser tParser, final ClientInfo client,
-            final boolean state) {
+    public void onAwayStateOther(final IRCParser tParser,
+            final ClientInfo client, final boolean state) {
         checkParser(tParser);
 
         final ChannelClientInfo channelClient = owner.getChannelInfo().getUser(client);

src/com/dmdirc/CustomWindow.java

 
 /**
  * A generic custom window implementation.
- * 
+ *
  * @author chris
  */
 public class CustomWindow extends FrameContainer {
 
     /**
      * Creates a new custom window as a child of the specified window.
-     * 
+     *
      * @param name The name of this custom window
      * @param title The title of this custom window
      * @param parent The parent of this custom window
 
     /**
      * Creates a new custom window as a top-level window.
-     * 
+     *
      * @param name The name of this custom window
      * @param title The parent of this custom window
      */
     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
 
     /**
      * Retrieves this custom window's name.
-     * 
+     *
      * @return This custom window's name
      */
     public String getName() {
 
     /**
      * Retrieves this custom window's title.
-     * 
+     *
      * @return This custom window's title
      */
     public String getTitle() {

src/com/dmdirc/FrameContainerComparator.java

 
 package com.dmdirc;
 
-
 import java.io.Serializable;
 import java.util.Comparator;
 
  */
 public final class FrameContainerComparator implements Comparator<FrameContainer>,
         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;
-    
+
     /**
      * Creates a new instance of FrameContainerComparator.
      */
     public FrameContainerComparator() {
         super();
     }
-    
+
     /**
      * Compares two frame containers names.
      *
      * @param item1 The first container to compare
      * @param item2 The second container to compare
-     *
      * @return -1 if item1 is before item2, 0 if they're equal,
      * +1 if item1 is after item2.
      */
             }
         }
     }
-    
+
     /**
      * Compares frame container types and checks order preferences.
      *
      * @param item1 The new container to be tested
      * @param item2 The existing container to test against
-     *
      * @return True iff the new container should be before the old container
      */
     private boolean sortBefore(final FrameContainer item1,
             final FrameContainer item2) {
-        
+
         return getPosition(item1) < getPosition(item2);
     }
-    
+
     /**
      * Compares frame container types and checks order preferences.
      *
      * @param item1 The new container to be tested
      * @param item2 The existing container to test against
-     *
      * @return True iff the new container should be after the old container
      */
     private boolean sortAfter(final FrameContainer item1,
             final FrameContainer item2) {
-        
         return getPosition(item1) > getPosition(item2);
     }
-    
+
     /**
      * Returns an integer corresponding to the expected order of a frame
      * container.
      *
      * @param item The frame container to be tested
-     *
      * @return Position of the frame container
      */
     private int getPosition(final FrameContainer item) {
         if (item instanceof GlobalWindow) {
             return 0;
         } else if (item instanceof Server) {
-	    return 1;
-	} else if (item instanceof Raw) {
-	    return 2;
-	} else if (item instanceof Channel) {
-	    return 3;
-	} else if (item instanceof Query) {
-	    return 4;
-	} else {
-	    return 5;
-	}
+            return 1;
+        } else if (item instanceof Raw) {
+            return 2;
+        } else if (item instanceof Channel) {
+            return 3;
+        } else if (item instanceof Query) {
+            return 4;
+        } else {
+            return 5;
+        }
     }
-    
+
 }

src/com/dmdirc/GlobalWindow.java

  * @author chris
  */
 public class GlobalWindow extends WritableFrameContainer {
-    
+
     /** The window we're using. */
     private final InputWindow window;
-    
+
     /** Creates a new instance of GlobalWindow. */
     public GlobalWindow() {
         super();
-        
+
         final TabCompleter tabCompleter = new TabCompleter();
         tabCompleter.addEntries(TabCompletionType.COMMAND,
                 CommandManager.getCommandNames(CommandType.TYPE_GLOBAL));
-        
+
         window = Main.getUI().getInputWindow(this, GlobalCommandParser.getGlobalCommandParser());
-        
+
         icon = IconManager.getIconManager().getIcon("icon");
-        
+
         window.setTitle("(Global)");
         window.getInputHandler().setTabCompleter(tabCompleter);
-        window.setFrameIcon(icon);        
-        
+        window.setFrameIcon(icon);
+
         WindowManager.addWindow(window);
-        
+
         window.open();
     }
 
     /** {@inheritDoc} */
-    @Override    
+    @Override
     public InputWindow getFrame() {
         return window;
     }
     }
 
     /** {@inheritDoc} */
-    @Override    
+    @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        
+
+        // 7: Remove any references to the window and parents
     }
 
     /** {@inheritDoc} */
-    @Override    
+    @Override
     public Server getServer() {
         return null;
     }
 
     /** {@inheritDoc} */
-    @Override    
+    @Override
     public void sendLine(final String line) {
-        GlobalCommandParser.getGlobalCommandParser().parseCommand(window, 
+        GlobalCommandParser.getGlobalCommandParser().parseCommand(window,
                 CommandManager.getCommandChar() + line);
     }
 
     /** {@inheritDoc} */
-    @Override    
+    @Override
     public int getMaxLineLength() {
         return 0;
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public ConfigManager getConfigManager() {
         return IdentityManager.getGlobalConfig();
     }
-    
+
 }

src/com/dmdirc/IconManager.java

 
 package com.dmdirc;
 
-import com.dmdirc.interfaces.ConfigChangeListener;
 import com.dmdirc.config.IdentityManager;
-
+import com.dmdirc.interfaces.ConfigChangeListener;
 import com.dmdirc.util.URLBuilder;
+
 import java.awt.Image;
 import java.awt.Toolkit;
 import java.io.File;
 public final class IconManager implements ConfigChangeListener {
     
     /** Previously created IconManager instance. */
-    private static final IconManager me = new IconManager();
+    private static final IconManager ME = new IconManager();
         
     /** A map of existing icons. */
     private final Map<String, Icon> icons;
      * @return Instance of IconManager
      */
     public static IconManager getIconManager() {
-        return me;
+        return ME;
     }
     
     /**

src/com/dmdirc/IgnoreList.java

 /**
  * Wraps around a RegexStringList to allow "simple" expressions to be used
  * instead of more complex regular expressions.
- * 
+ *
  * @author chris
  */
 public class IgnoreList extends RegexStringList {
-    
+
     /**
      * Creates a new instance of IgnoreList.
      */
 
     /**
      * Creates a new instance of IgnoreList containing the specified items.
-     * 
+     *
      * @param items The items to be added
      */
     public IgnoreList(final List<String> items) {
         super(items);
     }
-    
+
     /**
      * Adds the specified simple pattern to this ignore list.
-     * 
+     *
      * @param pattern The simple pattern to be added
      */
     public void addSimple(final String pattern) {
         add(simpleToRegex(pattern));
     }
-    
+
     /**
      * Determines if this list can be converted to a simple list.
-     * 
+     *
      * @return True if this list can be converted, false otherwise.
      */
     public boolean canConvert() {
         try {
             getSimpleList();
             return true;
-        } catch(UnsupportedOperationException ex) {
+        } catch (UnsupportedOperationException ex) {
             return false;
         }
     }
-    
+
     /**
      * Retrieves a list of regular expressions in this ignore list.
-     * 
+     *
      * @return All expressions in this ignore list
      */
     public List<String> getRegexList() {
         return new ArrayList<String>(ignoreInfo);
     }
-    
+
     /**
      * Retrieves a list of simple expressions in this ignore list.
-     * 
+     *
      * @return All expressions in this ignore list, converted to simple expressions
      * @throws UnsupportedOperationException if an expression can't be converted
      */
     public List<String> getSimpleList() throws UnsupportedOperationException {
         final List<String> res = new ArrayList<String>();
-        
+
         for (String regex : ignoreInfo) {
             res.add(regexToSimple(regex));
         }
-        
+
         return res;
     }
-    
+
     /**
      * Converts a regular expression into a simple expression.
-     * 
+     *
      * @param regex The regular expression to be converted
      * @return A simple expression corresponding to the regex
      * @throws UnsupportedOperationException if the regex cannot be converted
         final StringBuilder res = new StringBuilder(regex.length());
         boolean escaped = false;
         boolean inchar = false;
-        
+
         for (char part : regex.toCharArray()) {
             if (inchar) {
                 inchar = false;
-                
+
                 if (part == '*') {
                     res.append(part);
                     continue;
                     res.append('?');
                 }
             }
-            
+
             if (escaped) {
                 if (part == '?' || part == '*') {
-                    throw new UnsupportedOperationException("Cannot convert to" +
-                            " simple expression: ? or * is escaped.");
+                    throw new UnsupportedOperationException("Cannot convert to"
+                            + " simple expression: ? or * is escaped.");
                 }
-                
+
                 res.append(part);
                 escaped = false;
             }  else if (part == '\\') {
                 res.append(part);
             }
         }
-        
+
         if (escaped) {
             throw new UnsupportedOperationException("Cannot convert to "
                     + "simple expression: trailing backslash");
         } else if (inchar) {
             res.append('?');
         }
-        
+
         return res.toString();
     }
-    
+
     /**
      * Converts a simple expression to a regular expression.
-     * 
+     *
      * @param regex The simple expression to be converted
      * @return A corresponding regular expression
      */
     @SuppressWarnings("fallthrough")
     protected static String simpleToRegex(final String regex) {
         final StringBuilder res = new StringBuilder(regex.length());
-        
+
         for (char part : regex.toCharArray()) {
             switch (part) {
             case '.': case '^': case '$': case '[': case ']': case '\\':
                 res.append('.');
                 break;
             case '*':
-                res.append('.');                
+                res.append('.');
             default:
                 res.append(part);
                 break;
             }
         }
-        
+
         return res.toString();
     }
 

src/com/dmdirc/Main.java

  * @author chris
  */
 public final class Main {
-    
+
     /** Stores the current textual program version. */
     public static final String VERSION = "SVN";
-    
+
     /** The SVN revision that this build was made from. */
     public static final int SVN_REVISION = 3628; // 3601;
-    
+
     /** Stores the update channel that this version came from, if any. */
     public static final UpdateChannel UPDATE_CHANNEL = UpdateChannel.NONE;
-    
+
     /** Feedback nag delay. */
     private static final int FEEDBACK_DELAY = 30 * 60 * 1000;
-    
+
     /** The UI to use for the client. */
     private static UIController controller;
-    
+
     /** The config dir to use for the client. */
     private static String configdir;
-    
+
     /**
      * Prevents creation of main.
      */
     private Main() {
     }
-    
+
     /**
      * Entry procedure.
      *
      */
     public static void main(final String[] args) {
         Thread.setDefaultUncaughtExceptionHandler(new DMDircExceptionHandler());
-        
+
         final CommandLineParser clp = new CommandLineParser(args);
-        
+
         IdentityManager.load();
-        
+
         clp.applySettings();
-        
+
         CommandManager.initCommands();
-        
+
         getUI().initUISettings();
-        
+
         if (IdentityManager.getGlobalConfig().getOptionBool("general", "firstRun", true)) {
             IdentityManager.getConfigIdentity().setOption("general", "firstRun", "false");
             getUI().showFirstRunWizard();
             // @Deprecated - can be removed after 0.6 is released
             IdentityManager.getConfigIdentity().unsetOption("general", "addonrevision");
             getUI().showMigrationWizard();
-        }        
-        
+        }
+
         ActionManager.init();
-        
+
         PluginManager.getPluginManager();
-        
+
         ActionManager.loadActions();
-        
+
         new ThemeManager().loadDefaultTheme();
-        
+
         getUI().getMainWindow();
-                
+
         ActionManager.processEvent(CoreActionType.CLIENT_OPENED, null);
-        
+
         UpdateChecker.init();
-        
+
         clp.processArguments();
-        
+
         if (IdentityManager.getGlobalConfig().getOptionBool("general", "showglobalwindow", false)) {
             new GlobalWindow();
         }
-        
+
         Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
             public void run() {
                 ActionManager.processEvent(CoreActionType.CLIENT_CLOSED, null);
             }
         }, "Shutdown thread"));
     }
-    
+
     /**
      * Quits the client nicely, with the default closing message.
      */
     public static void quit() {
         quit(IdentityManager.getGlobalConfig().getOption("general", "closemessage"));
     }
-    
+
     /**
      * Quits the client nicely.
      *
      */
     public static void quit(final String reason) {
         ServerManager.getServerManager().disconnectAll(reason);
-        
+
         System.exit(0);
     }
-    
+
     /**
      * Retrieves the UI controller that's being used by the client.
      *
                 controller = new SwingController();
             }
         }
-        
+
         return controller;
     }
-    
+
     /**
      * Sets the UI controller that should be used by this client.
      *
     public static void setUI(final UIController newController) {
         controller = newController;
     }
-    
+
     /**
      * Returns the application's config directory.
      *
                 configdir = System.getProperty("user.home") + fs + ".DMDirc" + fs;
             }
         }
-        
+
         return configdir;
     }
-    
+
     /**
      * Sets the config directory for this client.
      *
     public static void setConfigDir(final String newdir) {
         configdir = newdir;
     }
-    
+
 }

src/com/dmdirc/MessageTarget.java

 /**
  * Defines common methods for objects that you can send messages to (such as
  * channels and queries).
- * 
+ *
  * @author Chris
  */
 public abstract class MessageTarget extends WritableFrameContainer {
-    
+
     /**
      * Sends the specified string as an action (CTCP) to the target that this
      * object represents.
-     * 
+     *
      * @param action The action to send
-     */    
+     */
     public abstract void sendAction(final String action);
 
 }

src/com/dmdirc/Query.java

     public void onQuit(final IRCParser tParser, final ClientInfo cClient,
             final String sReason) {
         if (cClient.getNickname().equals(ClientInfo.parseHost(host))) {
-            final StringBuffer format = new StringBuffer(sReason.isEmpty() ?
-                "queryQuit" : "queryQuitReason");
+            final StringBuffer format = new StringBuffer(sReason.isEmpty()
+                ? "queryQuit" : "queryQuitReason");
 
             ActionManager.processEvent(CoreActionType.QUERY_QUIT, format, this, sReason);
 
     @Override
     public ConfigManager getConfigManager() {
         if (server == null) {
-            Logger.appError(ErrorLevel.LOW, "Tried to retrieve config manager" +
-                    " from a query with no server", new IllegalStateException("My host: " + host));
+            Logger.appError(ErrorLevel.LOW, "Tried to retrieve config manager"
+                    + " from a query with no server",
+                    new IllegalStateException("My host: " + host));
             return IdentityManager.getGlobalConfig();
         }
 

src/com/dmdirc/Raw.java

  */
 public final class Raw extends WritableFrameContainer implements IDataIn,
         IDataOut, 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 object that's being monitored. */
     private Server server;
-    
+
     /** An InputWindow used for displaying the raw data.*/
     private InputWindow window;
-    
+
     /**
      * Creates a new instance of Raw.
      *
      */
     public Raw(final Server newServer) {
         super();
-        
+
         this.server = newServer;
-        
+
         icon = IconManager.getIconManager().getIcon("raw");
-        
+
         window = Main.getUI().getInputWindow(this, newServer.getFrame().getCommandParser());
         WindowManager.addWindow(server.getFrame(), window);
         window.setTitle("(Raw log)");
         window.getInputHandler().setTabCompleter(server.getTabCompleter());
         window.setFrameIcon(icon);
-        
+
         window.open();
     }
-    
+
     /**
      * Registers the data callbacks for this raw window.
      */
             Logger.appError(ErrorLevel.HIGH, "Unable to register raw callbacks", ex);
         }
     }
-    
+
     /** {@inheritDoc} */
     @Override
     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);
         }
-        
+
         // 3: Trigger any actions neccessary
         // 4: Trigger action for the window closing
-        
+
         // 5: Inform any parents that the window is closing
         server.delRaw();
-        
+
         // 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() {
     public ConfigManager getConfigManager() {
         return server.getConfigManager();
     }
-    
+
 }

src/com/dmdirc/Server.java

     private ConfigManager configManager;
 
     /** Our reason for being away, if any. */
-    private String awayMessage = null;
+    private String awayMessage;
 
     /** Our event handler. */
     private final ServerEventHandler eventHandler = new ServerEventHandler(this);
 
     /** A list of outstanding invites. */
     private final List<Invite> invites = new ArrayList<Invite>();
-    
+
     /** Our ignore list. */
     private final IgnoreList ignoreList = new IgnoreList();
-    
+
     /** Our string convertor. */
     private IRCStringConverter converter = new IRCStringConverter();
 
     })
     public void connect(final String server, final int port, final String password,
             final boolean ssl, final Identity profile) {
-        assert(profile != null);
+        assert profile != null;
 
-        synchronized(myState) {
+        synchronized (myState) {
             switch (myState) {
             case RECONNECT_WAIT:
                 reconnectTimer.cancel();
 
         ActionManager.processEvent(CoreActionType.SERVER_CONNECTING, null, this);
 
-        assert(parser == null || parser.getSocketState() != IRCParser.STATE_OPEN);
+        assert parser == null || parser.getSocketState() != IRCParser.STATE_OPEN;
 
         serverInfo = new ServerInfo(server, port, password);
         serverInfo.setSSL(ssl);
      * @param reason The quit reason to send
      */
     public void reconnect(final String reason) {
-        synchronized(myState) {
+        synchronized (myState) {
             if (myState == ServerState.CLOSING) {
                 return;
             }
     public void reconnect() {
         reconnect(configManager.getOption(DOMAIN_GENERAL, "reconnectmessage"));
     }
-    
+
     /**
      * Disconnects from the server with the default quit message.
      */
      * @param reason disconnect reason
      */
     public void disconnect(final String reason) {
-        synchronized(myState) {
+        synchronized (myState) {
             switch (myState) {
             case CLOSING:
             case DISCONNECTED:
         reconnectTimer.schedule(new TimerTask() {
             @Override
             public void run() {
-                synchronized(myState) {
+                synchronized (myState) {
                     if (myState == ServerState.RECONNECT_WAIT) {
                         myState = ServerState.TRANSIENTLY_DISCONNECTED;
                         reconnect();
      */
     public boolean hasQuery(final String host) {
         final String nick = ClientInfo.parseHost(host);
-        
+
         for (Query query : queries) {
             if (parser.equalsIgnoreCase(ClientInfo.parseHost(query.getHost()), nick)) {
                 return true;
             }
         }
-        
+
         return false;
     }
 
      */
     public Query getQuery(final String host) {
         final String nick = ClientInfo.parseHost(host);
-        
+
         for (Query query : queries) {
             if (parser.equalsIgnoreCase(ClientInfo.parseHost(query.getHost()), nick)) {
                 return query;
             }
         }
-        
+
         throw new IllegalArgumentException("No such query: " + host);
     }
 
      */
     private void updateIcon() {
         icon = IconManager.getIconManager().getIcon(
-                myState == ServerState.CONNECTED ?
-                    serverInfo.getSSL() ? "secure-server" : "server" : "server-disconnected");
+                myState == ServerState.CONNECTED
+                    ? serverInfo.getSSL() ? "secure-server" : "server" : "server-disconnected");
         if (window != null) {
             window.setFrameIcon(icon);
 
      */
     @Precondition("The current profile is not null")
     private MyInfo getMyInfo() {
-        assert(profile != null);
+        assert profile != null;
 
         final MyInfo myInfo = new MyInfo();
         myInfo.setNickname(profile.getOption(DOMAIN_PROFILE, "nickname"));
     /** {@inheritDoc} */
     @Override
     public void sendLine(final String line) {
-        synchronized(myState) {
+        synchronized (myState) {
             if (parser != null && myState == ServerState.CONNECTED) {
                 parser.sendLine(window.getTranscoder().encode(line));
             }
     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
         if (parser != null && parser.isReady()) {
             disconnect();
         }
-        
+
         myState = ServerState.CLOSING;
         closeChannels();
         closeQueries();
         if (raw != null) {
             raw.close();
         }
-        
-        
+
+
         // 4: Trigger action for the window closing
         // 5: Inform any parents that the window is closing
         ServerManager.getServerManager().unregisterServer(this);
-        
+
         // 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
      * @return True if the channel name is valid, false otherwise
      */
     public boolean isValidChannelName(final String channelName) {
-        return hasChannel(channelName) ||
-                (parser != null && parser.isValidChannelName(channelName));
+        return hasChannel(channelName)
+                || (parser != null && parser.isValidChannelName(channelName));
     }
 
     /**
             return super.processNotificationArg(arg, args);
         }
     }
-    
+
     /**
      * Retusnt the list of invites for this server.
-     * 
+     *
      * @return Invite list
      */
     public List<Invite> getInvites() {
      */
     public void onSocketClosed() {
         handleNotification("socketClosed", getName());
-        
-        ActionManager.processEvent(CoreActionType.SERVER_DISCONNECTED, null, this);        
 
-        synchronized(myState) {
+        ActionManager.processEvent(CoreActionType.SERVER_DISCONNECTED, null, this);
+
+        synchronized (myState) {
             if (myState == ServerState.CLOSING || myState == ServerState.DISCONNECTED) {
                 // This has been triggered via .disconect()
                 return;
         if (configManager.getOptionBool(DOMAIN_GENERAL, "closequeriesondisconnect", false)) {
             closeQueries();
         }
-        
+
         removeInvites();
 
         if (configManager.getOptionBool(DOMAIN_GENERAL, "reconnectondisconnect", false)) {
      */
     @Precondition("The current server state is CONNECTING")
     public void onConnectError(final ParserError errorInfo) {
-        synchronized(myState) {
+        synchronized (myState) {
             if (myState == ServerState.CLOSING) {
                 // Do nothing
                 return;
             }
-            
-            assert(myState == ServerState.CONNECTING);
+
+            assert myState == ServerState.CONNECTING;
             myState = ServerState.TRANSIENTLY_DISCONNECTED;
         }
 
         ActionManager.processEvent(CoreActionType.SERVER_NOPING, null, this,
                 Long.valueOf(parser.getPingTime(false)));
 
-        if (parser.getPingTime(false) >=
-                configManager.getOptionInt(DOMAIN_SERVER, "pingtimeout", 60000)) {
+        if (parser.getPingTime(false)
+                 >= configManager.getOptionInt(DOMAIN_SERVER, "pingtimeout", 60000)) {
             handleNotification("stonedServer", getName());
             reconnect();
         }
      * Called after the parser receives the 005 headers from the server.
      */
     public void onPost005() {
-        synchronized(myState) {
+        synchronized (myState) {
             myState = ServerState.CONNECTED;
         }
         updateIcon();
 
         configManager = new ConfigManager(parser.getIRCD(true), getNetwork(), getName());
         updateIgnoreList();
-        
+
         converter = parser.getIRCStringConverter();
 
         ActionManager.processEvent(CoreActionType.SERVER_CONNECTED, null, this);
 
         checkModeAliases();
     }
-    
+
     /**
      * Checks that we have the neccessary mode aliases for this server.
      */
                 missingModes.append(mode);
             }
         }
-        
+
         for (char mode : umodes.toCharArray()) {
             if (!configManager.hasOption(DOMAIN_SERVER, "umode" + mode)) {
                 missingUmodes.append(mode);
             }
         }
-        
+
         if (missingModes.length() + missingUmodes.length() > 0) {
             final StringBuffer missing = new StringBuffer("Missing mode aliases: ");
-            
+
             if (missingModes.length() > 0) {
                 missing.append("channel: +");
                 missing.append(missingModes);
             }
-            
+
             if (missingUmodes.length() > 0) {
                 if (missingModes.length() > 0) {
                     missing.append(' ');
                 }
-                
+
                 missing.append("user: +");
                 missing.append(missingUmodes);
             }
-            
+
             Logger.appError(ErrorLevel.LOW, missing.toString() + " ["
                     + getNetwork() + "]",
                     new Exception(missing.toString() + "\n" // NOPMD
                     + "\n\n"));
         }
     }
-   
+
     // ---------------------------------------------- IGNORE LIST HANDLING -----
-    
+
     /**
      * Retrieves this server's ignore list.
-     * 
+     *
      * @return This server's ignore list
      */
     public IgnoreList getIgnoreList() {
         return ignoreList;
     }
-    
+
     /**
      * Updates this server's ignore list to use the entries stored in the
      * config manager.
         ignoreList.clear();
         ignoreList.addAll(configManager.getOptionList("network", "ignorelist"));
     }
-    
+
     /**
      * Saves the contents of our ignore list to the network identity.
      */
     public void saveIgnoreList() {
         getNetworkIdentity().setOption("network", "ignorelist", ignoreList.getRegexList());
-    }    
-    
+    }
+
     // ------------------------------------------------- IDENTITY WRAPPERS -----
-    
+
     /**
      * Retrieves the identity for this server.
-     * 
+     *
      * @return This server's identity
      */
     public Identity getServerIdentity() {
 
     /**
      * Retrieves the identity for this server's network.
-     * 
+     *
      * @return This server's network identity
-     */    
+     */
     public Identity getNetworkIdentity() {
         return IdentityManager.getNetworkConfig(getNetwork());
     }
      * @param invite The invite to be added
      */
     public void addInvite(final Invite invite) {
-        synchronized(invites) {
+        synchronized (invites) {
             for (Invite oldInvite : new ArrayList<Invite>(invites)) {
                 if (oldInvite.getChannel().equals(invite.getChannel())) {
                     removeInvite(oldInvite);
             }
         }
     }
-    
+
     /**
      * Removes all invites for the specified channel.
-     * 
+     *
      * @param channel The channel to remove invites for
      */
     public void removeInvites(final String channel) {
             }
         }
     }
-    
+
     /**
      * Removes all invites for all channels.
      */
         for (Invite invite : new ArrayList<Invite>(invites)) {
             removeInvite(invite);
         }
-    }    
+    }
 
     /**
      * Removes an invite from this server, and fires the appropriate listeners.
      * @param invite The invite to be removed
      */
     public void removeInvite(final Invite invite) {
-        synchronized(invites) {
+        synchronized (invites) {
             invites.remove(invite);
 
             for (InviteListener listener : listeners.get(InviteListener.class)) {
             }
         }
     }
-    
+
     // ----------------------------------------------- AWAY STATE HANDLING -----
-    
+
     /**
      * Adds an away state lisener to this server.
-     * 
+     *
      * @param listener The listener to be added
      */
     public void addAwayStateListener(final AwayStateListener listener) {
         listeners.add(AwayStateListener.class, listener);
     }
-    
+
     /**
      * Removes an away state lisener from this server.
-     * 
+     *
      * @param listener The listener to be removed
      */
     public void removeAwayStateListener(final AwayStateListener listener) {
         listeners.remove(AwayStateListener.class, listener);
     }
-    
+
     /**
      * Updates our away state and fires the relevant listeners.
-     * 
+     *
      * @param message The away message to use, or null if we're not away.
      */
     public void updateAwayState(final String message) {
         awayMessage = message;
-        
+
         if (message == null) {
             for (AwayStateListener listener : listeners.get(AwayStateListener.class)) {
                 listener.onBack();
         } else {
             for (AwayStateListener listener : listeners.get(AwayStateListener.class)) {
                 listener.onAway(message);
-            }            
+            }
         }
     }
 

src/com/dmdirc/ServerEventHandler.java

  * @author chris
  */
 public final class ServerEventHandler extends EventHandler
-        implements IChannelSelfJoin, IPrivateMessage, IPrivateAction, 
-        IErrorInfo, IPrivateCTCP, IPrivateCTCPReply, ISocketClosed, 
+        implements IChannelSelfJoin, IPrivateMessage, IPrivateAction,
+        IErrorInfo, IPrivateCTCP, IPrivateCTCPReply, ISocketClosed,
         IPrivateNotice, IMOTDStart, IMOTDLine, IMOTDEnd, INumeric, IPingFailed,
         IPingSuccess, IAwayState, IConnectError, INickInUse, IPost005,
         INoticeAuth, IUnknownNotice, IUserModeChanged, IInvite, IWallop,
         IWalluser, IWallDesync, INickChanged, IServerError, IPingSent,
         IUserModeDiscovered {
-    
+
     /** The server instance that owns this event handler. */
     private final Server owner;
-    
+
     /**
      * Creates a new instance of ServerEventHandler.
      *
      */
     public ServerEventHandler(final Server owner) {
         super();
-        
+
         this.owner = owner;
     }
-    
+
     /** {@inheritDoc} */
     @Override
     protected void addCallback(final CallbackManager cbm, final String name)
             throws CallbackNotFoundException {
         cbm.addCallback(name, this);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     protected IRCParser getParser() {
         return owner.getParser();
     }
-          
+
     /** {@inheritDoc} */
     @Override
     public void onChannelSelfJoin(final IRCParser tParser, final ChannelInfo cChannel) {
         checkParser(tParser);
         owner.addChannel(cChannel);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onPrivateMessage(final IRCParser tParser, final String sMessage,
         checkParser(tParser);
         owner.addQuery(sHost);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onPrivateAction(final IRCParser tParser, final String sMessage,
         checkParser(tParser);
         owner.addQuery(sHost);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onErrorInfo(final IRCParser tParser, final ParserError errorInfo) {
         checkParser(tParser);
-        
+
         final ErrorLevel errorLevel = ErrorLevel.UNKNOWN;
-        
+
         if (errorInfo.isException()) {
-            Logger.appError(errorLevel, errorInfo.getData(), 
+            Logger.appError(errorLevel, errorInfo.getData(),
                     new Exception("Parser exception with line:\t"
                     + errorInfo.getLastLine(), errorInfo.getException()));
         } else {
                     + errorInfo.getLastLine() + "\n\tServer:\t" + owner.getName() + "\n"));
         }
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onPrivateCTCP(final IRCParser tParser, final String sType,
         checkParser(tParser);
 
         owner.doNotification("privateCTCP", CoreActionType.SERVER_CTCP,
-                tParser.getClientInfoOrFake(sHost), sType, sMessage);        
-        
+                tParser.getClientInfoOrFake(sHost), sType, sMessage);
+
         owner.sendCTCPReply(ClientInfo.parseHost(sHost), sType, sMessage);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onPrivateCTCPReply(final IRCParser tParser, final String sType,
             final String sMessage, final String sHost) {
         checkParser(tParser);
-        
+
         owner.doNotification("privateCTCPreply", CoreActionType.SERVER_CTCPR,
                 tParser.getClientInfoOrFake(sHost), sType, sMessage);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onSocketClosed(final IRCParser tParser) {
         checkParser(tParser);
         owner.onSocketClosed();
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onPrivateNotice(final IRCParser tParser, final String sMessage,
             final String sHost) {
         checkParser(tParser);
-        
+
         owner.doNotification("privateNotice", CoreActionType.SERVER_NOTICE,
                 tParser.getClientInfoOrFake(sHost), sMessage);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onMOTDStart(final IRCParser tParser, final String sData) {
         checkParser(tParser);
-        
+
         owner.doNotification("motdStart", CoreActionType.SERVER_MOTDSTART, sData);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onMOTDLine(final IRCParser tParser, final String sData) {
         checkParser(tParser);
-        
+
         owner.doNotification("motdLine", CoreActionType.SERVER_MOTDLINE, sData);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onMOTDEnd(final IRCParser tParser, final boolean noMOTD, final String sData) {
         checkParser(tParser);
-        
+
         owner.doNotification("motdEnd", CoreActionType.SERVER_MOTDEND, sData);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onNumeric(final IRCParser tParser, final int numeric,
         checkParser(tParser);
         owner.onNumeric(numeric, token);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onPingFailed(final IRCParser tParser) {
         checkParser(tParser);
         owner.onPingFailed();
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onPingSent(final IRCParser tParser) {
         checkParser(tParser);
-        
+
         ActionManager.processEvent(CoreActionType.SERVER_PINGSENT, null, owner);
-    }    
-    
+    }
+
     /** {@inheritDoc} */
     @Override
     public void onPingSuccess(final IRCParser tParser) {
         checkParser(tParser);
-        
+
         ActionManager.processEvent(CoreActionType.SERVER_GOTPING, null, owner,
                 Long.valueOf(tParser.getServerLag()));
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onAwayState(final IRCParser tParser, final boolean currentState,
             final String reason) {
         checkParser(tParser);
-        
+
         owner.updateAwayState(currentState ? reason : null);
-        
+
         if (currentState) {
             owner.doNotification("away", CoreActionType.SERVER_AWAY, reason);
         } else {
             owner.doNotification("back", CoreActionType.SERVER_BACK);
         }
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onConnectError(final IRCParser tParser, final ParserError errorInfo) {
         checkParser(tParser);
         owner.onConnectError(errorInfo);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onNickInUse(final IRCParser tParser, final String nickname) {
         owner.onNickInUse(nickname);
         checkParser(tParser);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onPost005(final IRCParser tParser) {
         checkParser(tParser);
         owner.onPost005();
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onNoticeAuth(final IRCParser tParser, final String sData) {
         checkParser(tParser);
-        
+
         owner.doNotification("authNotice", CoreActionType.SERVER_AUTHNOTICE, sData);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onUnknownNotice(final IRCParser tParser, final String sMessage,
         owner.doNotification("unknownNotice", CoreActionType.SERVER_UNKNOWNNOTICE,
                 sHost, sTarget, sMessage);
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public void onUserModeChanged(final IRCParser tParser,
             final ClientInfo cClient, final String sSetBy, final String sModes) {
         checkParser(tParser);
-        
+
         owner.doNotification("userModeChanged", CoreActionType.SERVER_USERMODES,
                 tParser.getClientInfoOrFake(sSetBy), sModes);
     }
     public void onUserModeDiscovered(final IRCParser tParser, final ClientInfo cClient,
              final String sModes) {
         checkParser(tParser);
-        
+
         owner.doNotification("userModeDiscovered", CoreActionType.SERVER_USERMODES,
-                cClient, sModes);        
+                cClient, sModes);
     }
 
     /** {@inheritDoc} */
     public void onInvite(final IRCParser tParser, final String userHost,
             final String channel) {
         checkParser(tParser);
-        
+
         owner.addInvite(new Invite(owner, channel, userHost));
         owner.doNotification("inviteReceived",
-                CoreActionType.SERVER_INVITERECEIVED, 
+                CoreActionType.SERVER_INVITERECEIVED,
                 tParser.getClientInfoOrFake(userHost), channel);
     }
 
     /** {@inheritDoc} */
     @Override
-    public void onWallop(final IRCParser tParser, final String sMessage, 
+    public void onWallop(final IRCParser tParser, final String sMessage,
             final String sHost) {
         checkParser(tParser);
-        
-        owner.doNotification("wallop", CoreActionType.SERVER_WALLOPS, 
+
+        owner.doNotification("wallop", CoreActionType.SERVER_WALLOPS,
                 tParser.getClientInfoOrFake(sHost), sMessage);
-        
+
     }
 
     /** {@inheritDoc} */
-    @Override    
-    public void onWalluser(final IRCParser tParser, final String sMessage, 
+    @Override
+    public void onWalluser(final IRCParser tParser, final String sMessage,
             final String sHost) {
         checkParser(tParser);
 
-        owner.doNotification("walluser", CoreActionType.SERVER_WALLUSERS, 
+        owner.doNotification("walluser", CoreActionType.SERVER_WALLUSERS,
                 tParser.getClientInfoOrFake(sHost), sMessage);
     }
 
     /** {@inheritDoc} */
-    @Override    
-    public void onWallDesync(final IRCParser tParser, final String sMessage, 
+    @Override
+    public void onWallDesync(final IRCParser tParser, final String sMessage,
             final String sHost) {
         checkParser(tParser);
-        
-        owner.doNotification("walldesync", CoreActionType.SERVER_WALLDESYNC, 
+
+        owner.doNotification("walldesync", CoreActionType.SERVER_WALLDESYNC,
                 tParser.getClientInfoOrFake(sHost), sMessage);
     }
 
     public void onNickChanged(final IRCParser tParser, final ClientInfo cClient,
             final String sOldNick) {
         checkParser(tParser);
-        
+
         if (cClient.equals(tParser.getMyself())) {
             owner.doNotification("selfNickChange", CoreActionType.SERVER_NICKCHANGE,
                     sOldNick, cClient.getNickname());
     @Override
     public void onServerError(final IRCParser tParser, final String sMessage) {
         checkParser(tParser);
-        
+
         owner.doNotification("serverError", CoreActionType.SERVER_ERROR, sMessage);
     }
 

src/com/dmdirc/ServerManager.java

 /**
  * The ServerManager maintains a list of all servers, and provides methods to
  * search or iterate over them.
- * 
+ *
  * @author chris
  */
 public final class ServerManager {
-    
+
     /** Singleton instance of ServerManager. */
     private static ServerManager me;
-    
+
     /** All servers that currently exist. */
     private final List<Server> servers = new ArrayList<Server>();
-    
+
     /**
      * Creates a new instance of ServerManager.
      */
     private ServerManager() {
     }
-    
+
     /**
      * Returns the singleton instance of ServerManager.
-     * 
+     *
      * @return Instance of ServerManager
      */
     public static synchronized ServerManager getServerManager() {
         }
         return me;
     }
-    
+
     /**
      * Registers a new server with the manager.
-     * 
+     *
      * @param server The server to be registered
      */
     public void registerServer(final Server server) {
-        synchronized(servers) {
+        synchronized (servers) {
             servers.add(server);
         }
     }
-    
+
     /**
      * Unregisters a server from the manager. The request is ignored if the
      * ServerManager is in the process of closing all servers.
-     * 
+     *
      * @param server The server to be unregistered
      */
     public void unregisterServer(final Server server) {
-        synchronized(servers) {
+        synchronized (servers) {
             servers.remove(server);
         }
     }
-    
+
     /**
      * Returns a list of all servers.
-     * 
+     *
      * @return A list of all servers
      */
     public List<Server> getServers() {
         return new ArrayList<Server>(servers);
     }
-    
+
     /**
      * Makes all servers disconnected with the specified quit message.
-     * 
+     *
      * @param message The quit message to send to the IRC servers
      */
     public void disconnectAll(final String message) {
-        synchronized(servers) {
+        synchronized (servers) {
             for (Server server : servers) {
                 server.disconnect(message);
             }
         }
     }
-    
+
     /**
      * Closes all servers with a default quit message.
      */
     public void closeAll() {
-        synchronized(servers) {
+        synchronized (servers) {
             for (Server server : servers) {
                 server.disconnect();
                 server.close();
             }
         }
     }
-    
+
     /**
      * Closes all servers with the specified quit message.
-     * 
+     *
      * @param message The quit message to send to the IRC servers
      */
     public void closeAll(final String message) {
-        synchronized(servers) {
+        synchronized (servers) {
             for (Server server : servers) {
                 server.disconnect(message);
                 server.close();
             }
         }
     }
-    
+
     /**
      * Returns the number of servers that are registered with the manager.
-     * 
+     *
      * @return number of registered servers
      */
     public int numServers() {
         return servers.size();
     }
-    
+
     /**
      * Returns the server instance that owns the specified internal frame.
-     * 
+     *
      * @param active The internal frame to check
      * @return The server associated with the internal frame
      */
     public Server getServerFromFrame(final Window active) {
-        synchronized(servers) {
+        synchronized (servers) {
             for (Server server : servers) {
                 if (server.ownsFrame(active)) {
                     return server;
                 }
             }
         }
-        
+
         return null;
     }
-    
+
     /**
      * Retrieves a list of servers connected to the specified network.
-     * 
+     *
      * @param network The network to search for
      * @return A list of servers connected to the network
      */
     public List<Server> getServersByNetwork(final String network) {
         final List<Server> res = new ArrayList<Server>();
-        
-        synchronized(servers) {
+
+        synchronized (servers) {
             for (Server server : servers) {
                 if (server.getNetwork().equalsIgnoreCase(network)) {
                     res.add(server);
                 }
             }
         }
-        
+
         return res;
     }
-    
+
     /**
      * Retrieves a list of servers connected to the specified address.
-     * 
+     *
      * @param address The address to search for
      * @return A list of servers connected to the network
      */
     public List<Server> getServersByAddress(final String address) {
         final List<Server> res = new ArrayList<Server>();
-        
-        synchronized(servers) {
+
+        synchronized (servers) {
             for (Server server : servers) {
                 if (server.getName().equalsIgnoreCase(address)) {
                     res.add(server);
                 }
             }
         }
-        
+
         return res;
     }
-    
+
     /**
      * Connects the user to Quakenet if neccessary and joins #DMDirc.
      */
     public void joinDevChat() {
         final List<Server> qnetServers = getServersByNetwork("Quakenet");
-        
+
         Server connectedServer = null;
-        
+
         for (Server server : qnetServers) {
             if (server.getState() == ServerState.CONNECTED) {
                 connectedServer = server;
-                
+
                 if (server.hasChannel("#DMDirc")) {
                     server.join("#DMDirc");
                     return;
                 }
             }
         }
-        
+
         if (connectedServer == null) {
             final List<String> channels = new ArrayList<String>();
                 channels.add("#DMDirc");
-                
+
                 new Server("irc.quakenet.org", 6667, "", false,
                         IdentityManager.getProfiles().get(0), channels);
         } else {
             connectedServer.join("#DMDirc");
-        }        
+        }
     }
-    
+
 }

src/com/dmdirc/Topic.java

 
 /**
  * Stores information about a channel topic.
- * 
+ *
  * @author chris
  */
 public class Topic {
-    
-    /**  Topic. */
+
+    /** Topic. */
     private final String topic;
-    /**  Topic client. */
+    /** Topic client. */
     private final String client;
-    /**  Topic time. */
+    /** Topic time. */
     private final long time;
 
     /**
      * Creates a new topic.
+     *
      * @param topic Topic
      * @param client Topic client
      * @param time Topic time
      */
-    public Topic(String topic, String client, long time) {
+    public Topic(final String topic, final String client, final long time) {
         this.topic = topic;
         this.client = client;
         this.time = time;
     }
 
-    /** 
+    /**
      * Returns the client who set the topic.
+     *
      * @return client host
      */
     public String getClient() {
         return client;
     }
 
-    /** 
+    /**
      * Returns the time the topic was set.
+     *
      * @return topic time
      */
     public long getTime() {
         return time;
     }
 
-    /** 
+    /**
      * Returns the topic this object represents.
+     *
      * @return topic
      */
     public String getTopic() {
         return topic;
     }
-    
+
     /** {@inheritDoc} */
     @Override
     public String toString() {
         return topic;
     }
-    
+
 }

src/com/dmdirc/WritableFrameContainer.java

             containers.add(getServer());
             containers.addAll(getServer().getChildren());
 
-            for (WritableFrameContainer container: containers) {
+            for (WritableFrameContainer container : containers) {
                 final long time
                         = container.getFrame().getCommandParser().getCommandTime(command);
                 if (time > besttime) {