Remove the remaining WindowManager singleton refs.

Add a GlobalWindowManager to keep state and references, rather than
use static methods on GlobalWindow.

Minor tidying.

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

src/com/dmdirc/ClientModule.java

      * Gets the message sink manager for the client.
      *
      * @param statusBarManager The status bar manager to use for status bar sinks.
+     * @param windowManager The window manager to use for sinks that iterate windows.
      * @return The message sink manager the client should use.
      */
     @Provides
     @Singleton
-    public MessageSinkManager getMessageSinkManager(final StatusBarManager statusBarManager) {
+    public MessageSinkManager getMessageSinkManager(
+            final StatusBarManager statusBarManager,
+            final WindowManager windowManager) {
         final MessageSinkManager messageSinkManager = new MessageSinkManager();
         MessageSinkManager.setManager(messageSinkManager);
-        messageSinkManager.loadDefaultSinks(statusBarManager);
+        messageSinkManager.loadDefaultSinks(statusBarManager, windowManager);
         return messageSinkManager;
     }
 
         return manager;
     }
 
-    /**
-     * Gets a window manager.
-     *
-     * @return A singleton window manager.
-     */
-    @Provides
-    public WindowManager getWindowManager() {
-        return new WindowManager();
-    }
-
     /**
      * Gets a preferences manager.
      *

src/com/dmdirc/GlobalWindow.java

 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.parsers.CommandParser;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
-import com.dmdirc.config.IdentityManager;
+import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigChangeListener;
+import com.dmdirc.interfaces.config.IdentityController;
 import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.core.components.WindowComponent;
 import com.dmdirc.ui.input.TabCompleter;
 
 import java.util.Arrays;
 
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.inject.Singleton;
+
 import lombok.Getter;
 
 /**
         return -1;
     }
 
-    /**
-     * Initialises the global window if it's enabled in the config.
-     */
-    public static void init() {
-        IdentityManager.getIdentityManager().getGlobalConfiguration()
-                .addChangeListener("general", "showglobalwindow",
-                new ConfigChangeListener() {
-
-            @Override
-            public void configChanged(final String domain, final String key) {
-                updateWindowState();
-            }
-        });
+    /** Handles the state of the global window. */
+    @Singleton
+    public static class GlobalWindowManager implements ConfigChangeListener {
+
+        /** The global configuration to read settings from. */
+        private final AggregateConfigProvider globalConfig;
+        /** The provider to use to retrieve a command controller. */
+        private final Provider<CommandController> commandControllerProvider;
+        /** The provider to use to retrieve a window manager. */
+        private final Provider<WindowManager> windowManagerProvider;
+
+        /**
+         * Creates a new instance of {@link GlobalWindowManager}.
+         *
+         * @param identityController Controller to retrieve global configuration from.
+         * @param commandControllerProvider The provider to use to retrieve a command controller.
+         * @param windowManagerProvider The provider to use to retrieve a window manager.
+         */
+        @Inject
+        public GlobalWindowManager(
+                final IdentityController identityController,
+                final Provider<CommandController> commandControllerProvider,
+                final Provider<WindowManager> windowManagerProvider) {
+            this.globalConfig = identityController.getGlobalConfiguration();
+            this.commandControllerProvider = commandControllerProvider;
+            this.windowManagerProvider = windowManagerProvider;
+        }
 
-        updateWindowState();
-    }
+        /** {@inheritDoc} */
+        @Override
+        public void configChanged(final String domain, final String key) {
+            updateWindowState();
+        }
 
-    /**
-     * Updates the state of the global window in line with the
-     * general.showglobalwindow config setting.
-     */
-    protected static void updateWindowState() {
-        final AggregateConfigProvider configManager = IdentityManager.getIdentityManager()
-                .getGlobalConfiguration();
-
-        synchronized (GlobalWindow.class) {
-            if (configManager.getOptionBool("general", "showglobalwindow")) {
-                if (globalWindow == null) {
-                    globalWindow = new GlobalWindow(configManager,
-                            new GlobalCommandParser(configManager,
-                                    CommandManager.getCommandManager()), WindowManager.getWindowManager());
-                }
-            } else {
-                if (globalWindow != null) {
-                    globalWindow.close();
+        /**
+         * Initialises the global window if it's enabled in the config.
+         */
+        public void init() {
+            globalConfig.addChangeListener("general", "showglobalwindow", this);
+            updateWindowState();
+        }
+
+        /**
+         * Updates the state of the global window in line with the
+         * general.showglobalwindow config setting.
+         */
+        protected void updateWindowState() {
+            synchronized (GlobalWindow.class) {
+                if (globalConfig.getOptionBool("general", "showglobalwindow")) {
+                    if (globalWindow == null) {
+                        globalWindow = new GlobalWindow(globalConfig,
+                                new GlobalCommandParser(globalConfig, commandControllerProvider.get()),
+                                windowManagerProvider.get());
+                    }
+                } else {
+                    if (globalWindow != null) {
+                        globalWindow.close();
+                    }
                 }
             }
         }
+
     }
+
 }

src/com/dmdirc/Main.java

 
 package com.dmdirc;
 
+import com.dmdirc.GlobalWindow.GlobalWindowManager;
 import com.dmdirc.actions.ActionManager;
 import com.dmdirc.actions.CoreActionType;
 import com.dmdirc.commandline.CommandLineParser;
     /** The command manager to use. */
     private final CommandManager commandManager;
 
+    /** The global window manager to use. */
+    private final GlobalWindowManager globalWindowManager;
+
     /** The commands to load into the command manager. */
     private final Set<CommandDetails> commands;
 
      * @param commandManager The command manager the client will use.
      * @param messageSinkManager Unused for now - TODO: remove me when it's injected somewhere sensible.
      * @param themeManager Unused for now - TODO: remove me when it's injected somewhere sensible.
-     * @param aliasWrapper Alias wrapper to provide to the actions manager.
      * @param corePluginExtractor Extractor to use for core plugins.
      * @param urlBuilder URL builder to use as a singleton.
+     * @param globalWindowManager Global window manager to use.
      * @param commands The commands to be loaded into the command manager.
      */
     @Inject
             final ThemeManager themeManager,
             final CorePluginExtractor corePluginExtractor,
             final URLBuilder urlBuilder,
+            final GlobalWindowManager globalWindowManager,
             final Set<CommandDetails> commands) {
         this.identityManager = identityManager;
         this.serverManager = serverManager;
         this.pluginManager = pluginManager;
         this.corePluginExtractor = corePluginExtractor;
         this.commandManager = commandManager;
+        this.globalWindowManager = globalWindowManager;
         this.commands = commands;
         URLBuilder.setInstance(urlBuilder);
     }
 
     /**
      * Initialises the client.
-     *
-     * @param args The command line arguments
      */
     public void init() {
         for (CommandDetails command : commands) {
 
         commandLineParser.processArguments(serverManager);
 
-        GlobalWindow.init();
+        globalWindowManager.init();
 
         Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
             /** {@inheritDoc} */

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

 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandInfoPair;
-import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.CommandOptions;
 import com.dmdirc.commandparser.commands.ExternalCommand;
 import com.dmdirc.commandparser.commands.PreviousCommand;
+import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.util.collections.RollingList;
 
 
     /** Command manager to use. */
     @Getter
-    protected final CommandManager commandManager;
+    protected final CommandController commandManager;
 
     /** Creates a new instance of CommandParser. */
     protected CommandParser(final AggregateConfigProvider configManager,
-            final CommandManager commandManager) {
+            final CommandController commandManager) {
         commands = new HashMap<>();
         history = new RollingList<>(configManager.getOptionInt("general", "commandhistory"));
         this.commandManager = commandManager;

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

 import com.dmdirc.FrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
-import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.context.CommandContext;
+import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
      * @param commandManager Command manager to load commands from
      */
     public GlobalCommandParser(final AggregateConfigProvider configManager,
-            final CommandManager commandManager) {
+            final CommandController commandManager) {
         super(configManager, commandManager);
     }
 

src/com/dmdirc/messages/MessageSinkManager.java

      * Loads the default message sinks into this manager.
      *
      * @param statusBarManager The status bar manager to give to status-bar related sinks.
+     * @param windowManager The window manager to give to sinks that iterate windows.
      */
-    public void loadDefaultSinks(final StatusBarManager statusBarManager) {
+    public void loadDefaultSinks(
+            final StatusBarManager statusBarManager,
+            final WindowManager windowManager) {
         addSink(new AllMessageSink());
         addSink(new ChannelMessageSink());
         addSink(new CommonChanelsMessageSink());
-        addSink(new CustomWindowMessageSink(WindowManager.getWindowManager()));
+        addSink(new CustomWindowMessageSink(windowManager));
         addSink(new ForkMessageSink());
         addSink(new FormatMessageSink());
         addSink(new GroupMessageSink());

src/com/dmdirc/ui/WindowManager.java

 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
 /**
  * The WindowManager maintains a list of all open windows, and their
  * parent/child relations.
  */
+@Singleton
 public class WindowManager {
 
-    /** Singleton instance of the WindowManager. */
-    private static final WindowManager INSTANCE = new WindowManager();
-
     /** A list of root windows. */
     private final List<FrameContainer> rootWindows = new CopyOnWriteArrayList<>();
 
     /** A list of frame listeners. */
     private final ListenerList listeners = new ListenerList();
 
+    /**
+     * Creates a new instance of {@link WindowManager}.
+     */
+    @Inject
+    public WindowManager() {
+    }
+
     /**
      * Registers a FrameListener with the WindowManager.
      *
         }
     }
 
-    /**
-     * Returns a singleton instance of the WindowManager.
-     *
-     * @return A singleton WindowManager instance
-     */
-    public static WindowManager getWindowManager() {
-        return INSTANCE;
-    }
 }

test/com/dmdirc/harness/TestCommandParser.java

 import com.dmdirc.FrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
-import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.parsers.CommandParser;
+import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 
-
 public class TestCommandParser extends CommandParser {
     private static final long serialVersionUID = 7073002401375438532L;
 
     public String invalidCommand;
 
     public TestCommandParser(final AggregateConfigProvider configManager,
-            final CommandManager commandManager) {
+            final CommandController commandManager) {
         super(configManager, commandManager);
         this.configManager = configManager;
     }