Deprecation fixes

Sprinkle some annotations over the CommandManager
More fiddling with NB7.1 settings

Change-Id: I2a0b751798249d4cc3e527f6d2e5525d1936f0e1
Reviewed-on: http://gerrit.dmdirc.com/2278
Reviewed-by: Greg Holmes <greg@dmdirc.com>
Automatic-Compile: DMDirc Build Manager

nbproject/project.properties

 auxiliary.org-netbeans-modules-editor-indent.CodeStyle.project.text-limit-width=80
 auxiliary.org-netbeans-modules-editor-indent.CodeStyle.project.text-line-wrap=none
 auxiliary.org-netbeans-modules-editor-indent.CodeStyle.usedProfile=project
-auxiliary.org-netbeans-modules-editor-indent.text.x-java.CodeStyle.project.importGroupsOrder=com.dmdirc;java;javax;org;*
+auxiliary.org-netbeans-modules-editor-indent.text.x-java.CodeStyle.project.allowConvertToStarImport=false
+auxiliary.org-netbeans-modules-editor-indent.text.x-java.CodeStyle.project.importGroupsOrder=com.dmdirc;java;javax;org;*;static *
+auxiliary.org-netbeans-modules-editor-indent.text.x-java.CodeStyle.project.separateStaticImports=true
 endorsed.classpath=
 javac.processorpath=\
     ${javac.classpath}

src/com/dmdirc/CustomWindow.java

      * @param title The parent of this custom window
      */
     public CustomWindow(final String name, final String title) {
-        super("custom", name, title, IdentityManager.getGlobalConfig(),
+        super("custom", name, title,
+                IdentityManager.getIdentityManager().getGlobalConfiguration(),
                 Arrays.asList(WindowComponent.TEXTAREA.getIdentifier()));
 
         WindowManager.getWindowManager().addWindow(this);

src/com/dmdirc/GlobalWindow.java

 
     /** Creates a new instance of GlobalWindow. */
     public GlobalWindow() {
-        super("icon", "Global", "(Global)",IdentityManager.getGlobalConfig(),
+        super("icon", "Global", "(Global)",
+                IdentityManager.getIdentityManager().getGlobalConfiguration(),
                 GlobalCommandParser.getGlobalCommandParser(),
                 Arrays.asList(WindowComponent.TEXTAREA.getIdentifier(),
                 WindowComponent.INPUTFIELD.getIdentifier()));
      * Initialises the global window if it's enabled in the config.
      */
     public static void init() {
-        IdentityManager.getGlobalConfig().addChangeListener("general", "showglobalwindow",
+        IdentityManager.getIdentityManager().getGlobalConfiguration()
+                .addChangeListener("general", "showglobalwindow",
                 new ConfigChangeListener() {
 
             @Override
      */
     protected static void updateWindowState() {
         synchronized (GlobalWindow.class) {
-            if (IdentityManager.getGlobalConfig().getOptionBool("general", "showglobalwindow")) {
+            if (IdentityManager.getIdentityManager().getGlobalConfiguration()
+                    .getOptionBool("general", "showglobalwindow")) {
                 if (globalWindow == null) {
                     globalWindow = new GlobalWindow();
                 }

src/com/dmdirc/Main.java

         MessageSinkManager.getManager().loadDefaultSinks();
 
         final PluginManager pm = PluginManager.getPluginManager();
-        checkBundledPlugins(pm, IdentityManager.getGlobalConfig());
+        checkBundledPlugins(pm, IdentityManager.getIdentityManager().getGlobalConfiguration());
 
         ThemeManager.loadThemes();
 
      */
     private static void handleMissingUI() {
         // Check to see if we have already tried this
-        if (IdentityManager.getGlobalConfig().hasOptionBool("debug", "uiFixAttempted")) {
+        if (IdentityManager.getIdentityManager().getGlobalConfiguration().hasOptionBool("debug", "uiFixAttempted")) {
             System.out.println("DMDirc is unable to load any compatible UI plugins.");
             if (!GraphicsEnvironment.isHeadless()) {
                 new WarningDialog(WarningDialog.NO_COMPAT_UIS_TITLE,
                         WarningDialog.NO_RECOV_UIS).displayBlocking();
             }
-            IdentityManager.getConfigIdentity().unsetOption("debug", "uiFixAttempted");
+            IdentityManager.getIdentityManager().getGlobalConfigIdentity().unsetOption("debug", "uiFixAttempted");
             System.exit(1);
         } else {
             // Try to extract the UIs again incase they changed between versions
             handleMissingUI();
         } else {
             // The fix worked!
-            if (IdentityManager.getGlobalConfig().hasOptionBool("debug", "uiFixAttempted")) {
+            if (IdentityManager.getIdentityManager().getGlobalConfiguration().hasOptionBool("debug", "uiFixAttempted")) {
                 IdentityManager.getConfigIdentity().unsetOption("debug", "uiFixAttempted");
             }
         }
      * Executes the first run or migration wizards as required.
      */
     private static void doFirstRun() {
-        if (IdentityManager.getGlobalConfig().getOptionBool("general", "firstRun")) {
+        if (IdentityManager.getIdentityManager().getGlobalConfiguration().getOptionBool("general", "firstRun")) {
             IdentityManager.getConfigIdentity().setOption("general", "firstRun", "false");
             for (UIController controller : CONTROLLERS) {
                 controller.showFirstRunWizard();
      *                  operating system when the client exits
      */
     public static void quit(final int exitCode) {
-        quit(IdentityManager.getGlobalConfig().getOption("general",
+        quit(IdentityManager.getIdentityManager().getGlobalConfiguration().getOption("general",
                 "closemessage"), exitCode);
     }
 

src/com/dmdirc/actions/Action.java

             error(ActionErrorType.FILE, "I/O error when loading action: " + ex.getMessage());
         }
 
-        IdentityManager.getGlobalConfig().addChangeListener("disable_action",
+        IdentityManager.getIdentityManager().getGlobalConfiguration().addChangeListener("disable_action",
                 (group + "/" + name).replace(' ', '.'), this);
         checkDisabled();
     }
 
         save();
 
-        IdentityManager.getGlobalConfig().addChangeListener("disable_action",
+        IdentityManager.getIdentityManager().getGlobalConfiguration().addChangeListener("disable_action",
                 (group + "/" + name).replace(' ', '.'), this);
         checkDisabled();
 
                 myGroup.getSettings().put(data.get("setting"), new PreferencesSetting(
                         PreferencesType.valueOf(data.get("type")), "actions",
                         data.get("setting"), data.get("title"), data.get("tooltip"),
-                        IdentityManager.getGlobalConfig(), IdentityManager.getConfigIdentity()));
+                        IdentityManager.getIdentityManager().getGlobalConfiguration(),
+                        IdentityManager.getConfigIdentity()));
             }
         }
     }
      */
     protected void checkDisabled() {
         final String key = (group + "/" + name).replace(' ', '.');
-        final boolean disabled = IdentityManager.getGlobalConfig()
-                .hasOptionBool("disable_action", key)
-                && IdentityManager.getGlobalConfig()
+        final boolean disabled = IdentityManager.getIdentityManager()
+                .getGlobalConfiguration().hasOptionBool("disable_action", key)
+                && IdentityManager.getIdentityManager().getGlobalConfiguration()
                 .getOptionBool("disable_action", key);
 
         if (disabled && status == ActionStatus.ACTIVE) {

src/com/dmdirc/actions/ActionSubstitutor.java

      * @return A list of global variable names that will be substituted
      */
     public Set<String> getConfigSubstitutions() {
-        return IdentityManager.getGlobalConfig().getOptions("actions").keySet();
+        return IdentityManager.getIdentityManager().getGlobalConfiguration().getOptions("actions").keySet();
     }
 
     /**
             }
         }
 
-        return IdentityManager.getGlobalConfig();
+        return IdentityManager.getIdentityManager().getGlobalConfiguration();
     }
 
     /**

src/com/dmdirc/commandline/CommandLineParser.java

     private static void doVersion() {
         System.out.println("DMDirc - a cross-platform, open-source IRC client.");
         System.out.println();
-        System.out.println("        Version: "
-                + IdentityManager.getGlobalConfig().getOption("version", "version"));
-        System.out.println(" Update channel: "
-                + IdentityManager.getGlobalConfig().getOption("updater", "channel"));
+        System.out.println("        Version: " + IdentityManager.getIdentityManager()
+                .getGlobalConfiguration().getOption("version", "version"));
+        System.out.println(" Update channel: " + IdentityManager.getIdentityManager()
+                .getGlobalConfiguration().getOption("updater", "channel"));
         exit();
     }
 

src/com/dmdirc/commandparser/CommandManager.java

 
 package com.dmdirc.commandparser;
 
-import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.BasicServerFactory;
 import com.dmdirc.Query;
 import com.dmdirc.Server;
 import com.dmdirc.ServerManager;
 import com.dmdirc.commandparser.commands.Command;
-import com.dmdirc.commandparser.commands.channel.*; //NOPMD
-import com.dmdirc.commandparser.commands.chat.*; //NOPMD
-import com.dmdirc.commandparser.commands.global.*; //NOPMD
-import com.dmdirc.commandparser.commands.server.*; //NOPMD
+import com.dmdirc.commandparser.commands.channel.Ban;
+import com.dmdirc.commandparser.commands.channel.Cycle;
+import com.dmdirc.commandparser.commands.channel.Invite;
+import com.dmdirc.commandparser.commands.channel.KickReason;
+import com.dmdirc.commandparser.commands.channel.Mode;
+import com.dmdirc.commandparser.commands.channel.Names;
+import com.dmdirc.commandparser.commands.channel.Part;
+import com.dmdirc.commandparser.commands.channel.SetNickColour;
+import com.dmdirc.commandparser.commands.channel.ShowTopic;
+import com.dmdirc.commandparser.commands.chat.Me;
+import com.dmdirc.commandparser.commands.global.AliasCommand;
+import com.dmdirc.commandparser.commands.global.AllServers;
+import com.dmdirc.commandparser.commands.global.Clear;
+import com.dmdirc.commandparser.commands.global.Echo;
+import com.dmdirc.commandparser.commands.global.Exit;
+import com.dmdirc.commandparser.commands.global.Help;
+import com.dmdirc.commandparser.commands.global.Ifplugin;
+import com.dmdirc.commandparser.commands.global.LoadPlugin;
+import com.dmdirc.commandparser.commands.global.NewServer;
+import com.dmdirc.commandparser.commands.global.Notify;
+import com.dmdirc.commandparser.commands.global.OpenWindow;
+import com.dmdirc.commandparser.commands.global.ReloadActions;
+import com.dmdirc.commandparser.commands.global.ReloadIdentities;
+import com.dmdirc.commandparser.commands.global.ReloadPlugin;
+import com.dmdirc.commandparser.commands.global.SaveConfig;
+import com.dmdirc.commandparser.commands.global.Set;
+import com.dmdirc.commandparser.commands.global.UnloadPlugin;
+import com.dmdirc.commandparser.commands.server.AllChannels;
+import com.dmdirc.commandparser.commands.server.Away;
+import com.dmdirc.commandparser.commands.server.Back;
+import com.dmdirc.commandparser.commands.server.ChangeServer;
+import com.dmdirc.commandparser.commands.server.Ctcp;
+import com.dmdirc.commandparser.commands.server.Disconnect;
+import com.dmdirc.commandparser.commands.server.Ignore;
+import com.dmdirc.commandparser.commands.server.JoinChannelCommand;
+import com.dmdirc.commandparser.commands.server.Message;
+import com.dmdirc.commandparser.commands.server.Nick;
+import com.dmdirc.commandparser.commands.server.Notice;
+import com.dmdirc.commandparser.commands.server.OpenQuery;
+import com.dmdirc.commandparser.commands.server.Raw;
+import com.dmdirc.commandparser.commands.server.RawServerCommand;
+import com.dmdirc.commandparser.commands.server.Reconnect;
+import com.dmdirc.commandparser.commands.server.Umode;
 import com.dmdirc.commandparser.parsers.CommandParser;
+import com.dmdirc.config.ConfigBinding;
 import com.dmdirc.config.IdentityManager;
-import com.dmdirc.interfaces.ConfigChangeListener;
+import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.ui.input.TabCompleter;
 import com.dmdirc.ui.input.TabCompletionType;
 import com.dmdirc.util.collections.MapList;
 import java.util.List;
 import java.util.Map;
 
+import lombok.Getter;
+
 /**
  * The command manager creates and manages a single instance of all commands,
  * and provides methods to load each group of commands into a parser instance.
  */
+@SuppressWarnings("PMD.UnusedPrivateField")
 public class CommandManager implements CommandController {
 
     /** A singleton instance of the command manager. */
             = new MapList<CommandType, CommandParser>();
 
     /** The command char we're using. */
-    private char commandChar = IdentityManager.getGlobalConfig()
-            .getOptionChar("general", "commandchar");
+    @ConfigBinding(domain="general", key="commandchar")
+    @Getter
+    private char commandChar;
 
     /** The silence char we're using. */
-    private char silenceChar = IdentityManager.getGlobalConfig()
-            .getOptionChar("general", "silencechar");
-
-    /** {@inheritDoc} */
-    @Override
-    public char getCommandChar() {
-        return commandChar;
-    }
+    @ConfigBinding(domain="general", key="silencechar")
+    @Getter
+    private char silenceChar;
 
-    /** {@inheritDoc} */
-    @Override
-    public char getSilenceChar() {
-        return silenceChar;
+    /**
+     * Creates a new instance of the Command Manager.
+     */
+    public CommandManager() {
+        IdentityManager.getIdentityManager().getGlobalConfiguration()
+                .getBinder().bind(this, CommandManager.class);
     }
 
     /** {@inheritDoc} */
         registerCommand(new ReloadPlugin(), ReloadPlugin.INFO);
         registerCommand(new SaveConfig(), SaveConfig.INFO);
         registerCommand(new Set(), Set.INFO);
-
-        // Set up a listener for config changes
-        final ConfigChangeListener listener = new ConfigChangeListener() {
-            @Override
-            public void configChanged(final String domain, final String key) {
-                commandChar = IdentityManager.getGlobalConfig()
-                        .getOptionChar("general", "commandchar");
-                silenceChar = IdentityManager.getGlobalConfig()
-                        .getOptionChar("general", "silencechar");
-            }
-        };
-
-        IdentityManager.getGlobalConfig().addChangeListener("general", "commandchar", listener);
-        IdentityManager.getGlobalConfig().addChangeListener("general", "silencechar", listener);
     }
 
     /** {@inheritDoc} */

src/com/dmdirc/commandparser/commands/global/Set.java

             return;
         }
 
-        Identity identity = IdentityManager.getConfigIdentity();
-        ConfigManager manager = IdentityManager.getGlobalConfig();
+        Identity identity = IdentityManager.getIdentityManager().getGlobalConfigIdentity();
+        ConfigManager manager = IdentityManager.getIdentityManager().getGlobalConfiguration();
 
         if (res.hasFlag(serverFlag)) {
             if (origin.getServer() == null) {
             }
 
             final Channel channel = ((ChannelCommandContext) context).getChannel();
-            identity = IdentityManager.getChannelConfig(origin.getServer().getNetwork(),
-                    channel.getName());
+            identity = IdentityManager.getIdentityManager().createChannelConfig(
+                    origin.getServer().getNetwork(), channel.getName());
             manager = channel.getConfigManager();
         }
 

src/com/dmdirc/commandparser/parsers/CommandParser.java

     /** Creates a new instance of CommandParser. */
     protected CommandParser() {
         commands = new HashMap<String, CommandInfoPair>();
-        history = new RollingList<PreviousCommand>(
-                IdentityManager.getGlobalConfig().getOptionInt("general",
-                    "commandhistory"));
+        history = new RollingList<PreviousCommand>(IdentityManager
+                .getIdentityManager().getGlobalConfiguration()
+                .getOptionInt("general", "commandhistory"));
         loadCommands();
     }
 

src/com/dmdirc/config/CipherUtils.java

      * @return true if auth was successful, false otherwise.
      */
     public boolean auth() {
+        final ConfigManager configManager = IdentityManager.getIdentityManager()
+                .getGlobalConfiguration();
+
         String passwordHash = null;
         String prompt = "Please enter your password";
         int tries = 1;
-        if (IdentityManager.getGlobalConfig().hasOptionString("encryption", "password")) {
-            password = IdentityManager.getGlobalConfig().getOption("encryption", "password");
+        if (configManager.hasOptionString("encryption", "password")) {
+            password = configManager.getOption("encryption", "password");
         } else {
-            if (IdentityManager.getGlobalConfig().hasOptionString("encryption",
-                    "passwordHash")) {
-                passwordHash = IdentityManager.getGlobalConfig().getOption("encryption",
-                        "passwordHash");
+            if (configManager.hasOptionString("encryption", "passwordHash")) {
+                passwordHash = configManager.getOption("encryption", "passwordHash");
             }
 
             while ((password == null || password.isEmpty()) && tries < AUTH_TRIES) {
                 password = getPassword(prompt);
                 if (passwordHash == null) {
                     passwordHash = hash(password);
-                    IdentityManager.getConfigIdentity().setOption("encryption",
-                            "passwordHash", passwordHash);
+                    IdentityManager.getIdentityManager().getGlobalConfigIdentity()
+                            .setOption("encryption", "passwordHash", passwordHash);
                 }
                 if (!hash(password).equals(passwordHash)) {
                     prompt = "<html>Password mis-match<br>Please re-enter "

src/com/dmdirc/config/ConfigBinder.java

             return manager.getOptionBool(binding.domain(), binding.key());
         }
 
+        if (targetClass.equals(Character.class) || targetClass.equals(Character.TYPE)) {
+            return manager.getOptionChar(binding.domain(), binding.key());
+        }
+
         return null;
     }
 

src/com/dmdirc/config/IdentityManager.java

         // currently using, extract them.
         if (getGlobalConfiguration().hasOptionString("identity", "defaultsversion")
                 && getGlobalConfiguration().hasOptionString("updater", "bundleddefaultsversion")) {
-            final Version installedVersion = new Version(getGlobalConfig()
+            final Version installedVersion = new Version(getGlobalConfiguration()
                     .getOption("identity", "defaultsversion"));
-            final Version bundledVersion = new Version(getGlobalConfig()
+            final Version bundledVersion = new Version(getGlobalConfiguration()
                     .getOption("updater", "bundleddefaultsversion"));
 
             if (bundledVersion.compareTo(installedVersion) > 0) {

src/com/dmdirc/config/validators/URLProtocolValidator.java

     public ValidationResponse validate(final String object) {
         if (object == null || object.isEmpty()) {
             return new ValidationResponse("Cannot be empty");
-        } else if (IdentityManager.getGlobalConfig().hasOptionString("protocol", object)) {
+        } else if (IdentityManager.getIdentityManager().getGlobalConfiguration()
+                .hasOptionString("protocol", object)) {
             return new ValidationResponse("Cannot already exist");
         } else {
             return new ValidationResponse();

src/com/dmdirc/logger/ErrorManager.java

         errors = new LinkedList<ProgramError>();
         nextErrorID = new AtomicLong();
 
-        final ConfigManager config = IdentityManager.getGlobalConfig();
+        final ConfigManager config = IdentityManager.getIdentityManager().getGlobalConfiguration();
 
         config.addChangeListener("general", "logerrors", this);
         config.addChangeListener("general", "submitErrors", this);
 
     /** Updates the settings used by this error manager. */
     protected void updateSettings() {
-        final ConfigManager config = IdentityManager.getGlobalConfig();
+        final ConfigManager config = IdentityManager.getIdentityManager().getGlobalConfiguration();
 
         try {
             sendReports = config.getOptionBool("general", "submitErrors")

src/com/dmdirc/logger/ProgramError.java

         }
         postData.put("message", getMessage());
         postData.put("trace", traceString);
-        postData.put("version", IdentityManager.getGlobalConfig().getOption("version", "version"));
+        postData.put("version", IdentityManager.getIdentityManager()
+                .getGlobalConfiguration().getOption("version", "version"));
 
         setReportStatus(ErrorReportStatus.SENDING);
 

src/com/dmdirc/plugins/PluginManager.java

      * Autoloads plugins.
      */
     public void doAutoLoad() {
-        for (String plugin : IdentityManager.getGlobalConfig().getOptionList("plugins", "autoload")) {
+        for (String plugin : IdentityManager.getIdentityManager()
+                .getGlobalConfiguration().getOptionList("plugins", "autoload")) {
             plugin = plugin.trim();
             if (!plugin.isEmpty() && plugin.charAt(0) != '#' && getPluginInfo(plugin) != null) {
                 getPluginInfo(plugin).loadPlugin();
     public String getFilesDirectory() {
         final String fs = System.getProperty("file.separator");
         String filesDir = myDir + "files" + fs;
-        if (IdentityManager.getGlobalConfig().hasOptionString("plugins", "filesdir")) {
-            final String fdopt = IdentityManager.getGlobalConfig().getOptionString("plugins", "filesdir");
+        if (IdentityManager.getIdentityManager().getGlobalConfiguration()
+                .hasOptionString("plugins", "filesdir")) {
+            final String fdopt = IdentityManager.getIdentityManager()
+                    .getGlobalConfiguration().getOptionString("plugins", "filesdir");
+
             if (fdopt != null && !fdopt.isEmpty() && new File(fdopt).exists()) {
                 filesDir = fdopt;
             }
      * @param plugin to add/remove (Decided automatically based on isLoaded())
      */
     public void updateAutoLoad(final PluginInfo plugin) {
-        final List<String> list = IdentityManager.getGlobalConfig().getOptionList("plugins", "autoload");
+        final List<String> list = IdentityManager.getIdentityManager()
+                .getGlobalConfiguration().getOptionList("plugins", "autoload");
         final String path = plugin.getMetaData().getRelativeFilename();
 
         if (plugin.isLoaded() && !list.contains(path)) {
             list.remove(path);
         }
 
-        IdentityManager.getConfigIdentity().setOption("plugins", "autoload", list);
+        IdentityManager.getIdentityManager().getGlobalConfigIdentity()
+                .setOption("plugins", "autoload", list);
     }
 
     /**

src/com/dmdirc/ui/FatalErrorDialog.java

 
         setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
         setTitle("DMDirc: Fatal Error");
-        setIconImage(new IconManager(IdentityManager.getGlobalConfig())
-                .getImage("icon"));
+
+        final IconManager iconManager = new IconManager(IdentityManager
+                .getIdentityManager().getGlobalConfiguration());
+
+        setIconImage(iconManager.getImage("icon"));
 
         infoLabel.setText("DMDirc has encountered a fatal error, and is "
                 + "not able to recover. \nThe application will now terminate.");
         ((StyledDocument) messageLabel.getDocument()).setParagraphAttributes(0,
                 messageLabel.getText().length(), sas, false);
 
-        icon = new ImageIcon(new IconManager(IdentityManager.getGlobalConfig())
-                .getImage("error"));
+        icon = new ImageIcon(iconManager.getImage("error"));
 
         stacktraceField.setEditable(false);
 

src/com/dmdirc/ui/core/util/Info.java

      * @return DMDirc version string
      */
     public static String getDMDircVersion() {
-        return IdentityManager.getGlobalConfig().getOption("version", "version")
-                + " ("
-                + IdentityManager.getGlobalConfig().getOption("updater", "channel")
-                + ")";
+        return IdentityManager.getIdentityManager().getGlobalConfiguration()
+                .getOption("version", "version") + " ("
+                + IdentityManager.getIdentityManager().getGlobalConfiguration()
+                .getOption("updater", "channel") + ")";
     }
 
     /**

src/com/dmdirc/ui/core/util/URLHandler.java

 import com.dmdirc.ServerManager;
 import com.dmdirc.config.ConfigManager;
 import com.dmdirc.config.IdentityManager;
+import com.dmdirc.interfaces.ui.UIController;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
 import com.dmdirc.ui.StatusMessage;
 import com.dmdirc.ui.core.components.StatusBarManager;
-import com.dmdirc.interfaces.ui.UIController;
 import com.dmdirc.util.CommandUtils;
 
 import java.awt.Desktop;
      */
     public URLHandler(final UIController controller) {
         this.controller = controller;
-        this.config = IdentityManager.getGlobalConfig();
+        this.config = IdentityManager.getIdentityManager().getGlobalConfiguration();
         this.desktop = Desktop.isDesktopSupported() ? Desktop.getDesktop() : null;
     }
 
         final Date oldLaunch = lastLaunch;
         lastLaunch = new Date();
 
-        if (IdentityManager.getGlobalConfig().getOptionBool("browser",
-                "uselaunchdelay") && oldLaunch != null) {
+        if (config.getOptionBool("browser", "uselaunchdelay") && oldLaunch != null) {
             final Long diff = lastLaunch.getTime() - oldLaunch.getTime();
 
-            if (diff < IdentityManager.getGlobalConfig().getOptionInt("browser",
-                    "launchdelay")) {
+            if (diff < config.getOptionInt("browser", "launchdelay")) {
                 return;
             }
         }
         if ("DMDIRC".equals(command)) {
             StatusBarManager.getStatusBarManager().setMessage(
                     new StatusMessage("Connecting to: " + uri.toString(),
-                    IdentityManager.getGlobalConfig()));
+                    config));
             ServerManager.getServerManager().connectToAddress(uri);
         } else if ("BROWSER".equals(command)) {
             StatusBarManager.getStatusBarManager().setMessage(
                     new StatusMessage("Opening: " + uri.toString(),
-                    IdentityManager.getGlobalConfig()));
+                    config));
             execBrowser(uri);
         } else if ("MAIL".equals(command)) {
             execMail(uri);
         } else {
             StatusBarManager.getStatusBarManager().setMessage(
                     new StatusMessage("Opening: " + uri.toString(),
-                    IdentityManager.getGlobalConfig()));
+                    config));
             execApp(substituteParams(uri, command));
         }
     }

src/com/dmdirc/ui/input/TabCompleter.java

         final MapList<TabCompletionType, String> targets
                 = new MapList<TabCompletionType, String>(entries);
 
-        final boolean caseSensitive = IdentityManager.getGlobalConfig()
+        final boolean caseSensitive = IdentityManager.getIdentityManager().getGlobalConfiguration()
                 .getOptionBool("tabcompletion", "casesensitive");
-        final boolean allowEmpty = IdentityManager.getGlobalConfig()
+        final boolean allowEmpty = IdentityManager.getIdentityManager().getGlobalConfiguration()
                 .getOptionBool("tabcompletion", "allowempty");
 
         if (partial.isEmpty() && !allowEmpty) {

src/com/dmdirc/ui/input/TabCompleterResult.java

             return "";
         }
 
-        final boolean caseSensitive = IdentityManager.getGlobalConfig()
-                .getOptionBool("tabcompletion", "casesensitive");
+        final boolean caseSensitive = IdentityManager.getIdentityManager()
+                .getGlobalConfiguration().getOptionBool("tabcompletion", "casesensitive");
 
         String res = results.get(0);
         for (String entry : results) {

src/com/dmdirc/ui/messages/ColourManager.java

 
 package com.dmdirc.ui.messages;
 
+import com.dmdirc.config.ConfigManager;
 import com.dmdirc.config.IdentityManager;
 import com.dmdirc.interfaces.ConfigChangeListener;
 import com.dmdirc.logger.ErrorLevel;
      * Initialises the IRC_COLOURS array.
      */
     private static void initColours() {
+        final ConfigManager configManager = IdentityManager.getIdentityManager()
+                .getGlobalConfiguration();
+
         for (int i = 0; i < 16; i++) {
-            if (IdentityManager.getGlobalConfig().hasOptionColour("colour", String.valueOf(i))) {
-                ircColours[i] = IdentityManager.getGlobalConfig()
-                        .getOptionColour("colour", String.valueOf(i));
+            if (configManager.hasOptionColour("colour", String.valueOf(i))) {
+                ircColours[i] = configManager.getOptionColour("colour", String.valueOf(i));
                 COLOUR_CACHE.remove(String.valueOf(i));
             } else if (!ircColours[i].equals(DEFAULT_COLOURS[i])) {
                 ircColours[i] = DEFAULT_COLOURS[i];

src/com/dmdirc/ui/themes/ThemeManager.java

     private static final Map<String, Theme> THEMES = new HashMap<String, Theme>();
 
     static {
-        IdentityManager.getGlobalConfig().addChangeListener("themes", "enabled",
+        IdentityManager.getIdentityManager().getGlobalConfiguration()
+                .addChangeListener("themes", "enabled",
                 new ConfigChangeListener() {
             /** {@inheritDoc} */
             @Override
             return;
         }
 
-        final List<String> enabled = IdentityManager.getGlobalConfig()
+        final List<String> enabled = IdentityManager.getIdentityManager().getGlobalConfiguration()
                 .getOptionList("themes", "enabled");
 
         synchronized (THEMES) {

src/com/dmdirc/updater/UpdateChecker.java

             return;
         }
 
-        final ConfigManager config = IdentityManager.getGlobalConfig();
+        final ConfigManager config = IdentityManager.getIdentityManager().getGlobalConfiguration();
 
         if (!config.getOptionBool(DOMAIN, "enable")
                 || status == STATE.UPDATING) {
      * frequency specified in the config.
      */
     public static void init() {
-        for (String update : IdentityManager.getGlobalConfig().getOptionList(DOMAIN, "updates")) {
+        for (String update : IdentityManager.getIdentityManager()
+                .getGlobalConfiguration().getOptionList(DOMAIN, "updates")) {
             checkLine(update);
         }
 
      * @since 0.6.5
      */
     protected static void initTimer() {
-        final int last = IdentityManager.getGlobalConfig()
+        final int last = IdentityManager.getIdentityManager().getGlobalConfiguration()
                 .getOptionInt(DOMAIN, "lastcheck");
-        final int freq = IdentityManager.getGlobalConfig()
+        final int freq = IdentityManager.getIdentityManager().getGlobalConfiguration()
                 .getOptionInt(DOMAIN, "frequency");
         final int timestamp = (int) (new Date().getTime() / 1000);
         int time = 0;
      * @return true iif the update component is enabled
      */
     public static boolean isEnabled(final UpdateComponent component) {
-        return !IdentityManager.getGlobalConfig().hasOptionBool(DOMAIN,
-                "enable-" + component.getName()) || IdentityManager.getGlobalConfig()
+        return !IdentityManager.getIdentityManager().getGlobalConfiguration()
+                .hasOptionBool(DOMAIN, "enable-" + component.getName())
+                || IdentityManager.getIdentityManager().getGlobalConfiguration()
                 .getOptionBool(DOMAIN, "enable-" + component.getName());
     }
 

src/com/dmdirc/updater/components/ClientComponent.java

     /** {@inheritDoc} */
     @Override
     public String getFriendlyVersion() {
-        return IdentityManager.getGlobalConfig().getOption("version",
-                "version");
+        return IdentityManager.getIdentityManager().getGlobalConfiguration()
+                .getOption("version", "version");
     }
 
     /** {@inheritDoc} */

src/com/dmdirc/updater/components/DefaultsComponent.java

     /** {@inheritDoc} */
     @Override
     public Version getVersion() {
-        final ConfigManager globalConfig = IdentityManager.getGlobalConfig();
+        final ConfigManager globalConfig = IdentityManager.getIdentityManager()
+                .getGlobalConfiguration();
 
         if (globalConfig.hasOptionString("identity", "defaultsversion")) {
             return new Version(globalConfig.getOption("identity",

src/com/dmdirc/updater/components/ModeAliasesComponent.java

     /** {@inheritDoc} */
     @Override
     public Version getVersion() {
-        final ConfigManager globalConfig = IdentityManager.getGlobalConfig();
+        final ConfigManager globalConfig = IdentityManager.getIdentityManager()
+                .getGlobalConfiguration();
 
         if (globalConfig.hasOptionString("identity", "modealiasversion")) {
             return new Version(globalConfig.getOption("identity",

src/com/dmdirc/updater/components/PluginComponent.java

 public class PluginComponent implements UpdateComponent, FileComponent {
 
     /** The config to use. */
-    private static final ConfigManager CONFIG = IdentityManager.getGlobalConfig();
+    private static final ConfigManager CONFIG = IdentityManager.getIdentityManager().getGlobalConfiguration();
 
     /** The plugin this component is for. */
     private final PluginInfo plugin;

test/com/dmdirc/config/IdentityManagerTest.java

 
 package com.dmdirc.config;
 
+import static org.junit.Assert.assertTrue;
 import org.junit.Before;
 import org.junit.Test;
-import static org.junit.Assert.*;
 
 public class IdentityManagerTest {
 
     @Before
-    public void setUp() throws Exception {        
-        IdentityManager.load();
+    public void setUp() throws Exception {
+        IdentityManager.getIdentityManager().initialise();
     }
 
     @Test
     public void testGetGlobalConfig() {
-        final ConfigManager gcm = IdentityManager.getGlobalConfig();
-        
+        final ConfigManager gcm = IdentityManager.getIdentityManager().getGlobalConfiguration();
+
         for (Identity identity : gcm.getSources()) {
             assertTrue(identity.getTarget().getType() == ConfigTarget.TYPE.GLOBAL
                     || identity.getTarget().getType() == ConfigTarget.TYPE.GLOBALDEFAULT
                     || identity.getTarget().getType() == ConfigTarget.TYPE.THEME);
         }
     }
-    
+
 }

test/com/dmdirc/config/prefs/PreferencesSettingTest.java

 import com.dmdirc.util.validators.NotEmptyValidator;
 import com.dmdirc.util.validators.PermissiveValidator;
 import com.dmdirc.util.validators.StringLengthValidator;
+
 import java.util.HashMap;
 import java.util.Map;
+
 import org.junit.BeforeClass;
 import org.junit.Test;
+
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
 
         final PreferencesSetting ps = new PreferencesSetting(PreferencesType.TEXT,
                 "unit-test", "ps", "title", "helptext",
-                IdentityManager.getGlobalConfig(), IdentityManager.getConfigIdentity());
+                IdentityManager.getIdentityManager().getGlobalConfiguration(),
+                IdentityManager.getConfigIdentity());
 
         assertFalse(ps.save());
         ps.setValue(null);
 
         final PreferencesSetting ps = new PreferencesSetting(PreferencesType.TEXT,
                 "unit-test", "ps", "title", "helptext",
-                IdentityManager.getGlobalConfig(), IdentityManager.getConfigIdentity());
+                IdentityManager.getIdentityManager().getGlobalConfiguration(),
+                IdentityManager.getConfigIdentity());
 
         assertFalse(ps.save());
         ps.setValue("def");

test/com/dmdirc/harness/TestWritableFrameContainer.java

     }
 
     public TestWritableFrameContainer(final int lineLength) {
-        this(lineLength, IdentityManager.getGlobalConfig());
+        this(lineLength, IdentityManager.getIdentityManager().getGlobalConfiguration());
     }
 
     @Override