Remove most singleton uses of WindowManager.

Change-Id: Idd97b752328310b4f829a45a43de5fdf6f5712a5
Depends-On: I1f054c7423106afe3fc49db8dc44613ec11c35bb
Reviewed-on: http://gerrit.dmdirc.com/2816
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/Channel.java

      * @param newChannelInfo The parser's channel object that corresponds to
      * this channel
      * @param focus Whether or not to focus this channel
+     * @param windowManager Window management
      */
     public Channel(final Server newServer, final ChannelInfo newChannelInfo,
-            final boolean focus) {
+            final boolean focus, final WindowManager windowManager) {
         super("channel-inactive", newChannelInfo.getName(),
                 Styliser.stipControlCodes(newChannelInfo.getName()),
                 new ConfigManager(newServer.getProtocol(), newServer.getIrcd(),
                 Arrays.asList(WindowComponent.TEXTAREA.getIdentifier(),
                 WindowComponent.INPUTFIELD.getIdentifier(),
                 WindowComponent.TOPICBAR.getIdentifier(),
-                WindowComponent.USERLIST.getIdentifier()));
+                        WindowComponent.USERLIST.getIdentifier()), windowManager);
 
         channelInfo = newChannelInfo;
         server = newServer;
         tabCompleter.addEntries(TabCompletionType.COMMAND,
                 CommandManager.getCommandManager().getCommandNames(CommandType.TYPE_CHAT));
 
-        WindowManager.getWindowManager().addWindow(server, this, focus);
+        windowManager.addWindow(server, this, focus);
 
         eventHandler = new ChannelEventHandler(this);
 

src/com/dmdirc/ClientModule.java

      */
     @Provides
     public WindowManager getWindowManager() {
-        return WindowManager.getWindowManager();
+        return new WindowManager();
     }
 
     /**

src/com/dmdirc/CustomWindow.java

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

src/com/dmdirc/FrameContainer.java

     @Getter
     private final IconManager iconManager;
 
+    /** Window management. */
+    @Getter
+    private final WindowManager windowManager;
+
     /**
      * Instantiate new frame container.
      *
      * @param title The title of this container
      * @param config The config manager for this container
      * @param components The UI components that this frame requires
+     * @param windowManager Window manager to register from
      * @since 0.6.4
      */
     protected FrameContainer(
             final String icon, final String name,
             final String title, final AggregateConfigProvider config,
-            final Collection<String> components) {
+            final Collection<String> components,
+            final WindowManager windowManager) {
+        this.windowManager = windowManager;
         this.configManager = config;
         this.name = name;
         this.title = title;
 
         windowClosing();
 
-        WindowManager.getWindowManager().removeWindow(this);
+        windowManager.removeWindow(this);
     }
 
     /**

src/com/dmdirc/GlobalWindow.java

      *
      * @param config The ConfigManager to retrieve settings from.
      * @param parser The command parser to use to parse input.
+     * @param windowManager Window management
      */
-    public GlobalWindow(final AggregateConfigProvider config, final CommandParser parser) {
+    public GlobalWindow(final AggregateConfigProvider config, final CommandParser parser,
+            final WindowManager windowManager) {
         super("icon", "Global", "(Global)",
                 config, parser,
                 Arrays.asList(WindowComponent.TEXTAREA.getIdentifier(),
-                WindowComponent.INPUTFIELD.getIdentifier()));
+                        WindowComponent.INPUTFIELD.getIdentifier()), windowManager);
 
         tabCompleter = new TabCompleter(config);
         tabCompleter.addEntries(TabCompletionType.COMMAND,
         tabCompleter.addEntries(TabCompletionType.COMMAND,
                 AliasWrapper.getAliasWrapper().getAliases());
 
-        WindowManager.getWindowManager().addWindow(this);
+        windowManager.addWindow(this);
     }
 
     /** {@inheritDoc} */
                 if (globalWindow == null) {
                     globalWindow = new GlobalWindow(configManager,
                             new GlobalCommandParser(configManager,
-                            CommandManager.getCommandManager()));
+                                    CommandManager.getCommandManager()), WindowManager.getWindowManager());
                 }
             } else {
                 if (globalWindow != null) {

src/com/dmdirc/MessageTarget.java

 
 import com.dmdirc.commandparser.parsers.CommandParser;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
+import com.dmdirc.ui.WindowManager;
 
 import java.util.Collection;
 
      * @param config The config manager to use for this target
      * @param parser The command parser for this container
      * @param components The UI components that this frame requires
+     * @param windowManager Window manager
      * @since 0.6.4
      */
     public MessageTarget(final String icon, final String name,
             final String title, final AggregateConfigProvider config,
-            final CommandParser parser, final Collection<String> components) {
-        super(icon, name, title, config, parser, components);
+            final CommandParser parser, final Collection<String> components,
+            final WindowManager windowManager) {
+        super(icon, name, title, config, parser, components, windowManager);
     }
 
     /**

src/com/dmdirc/Query.java

      *
      * @param newHost host of the remove client
      * @param newServer The server object that this Query belongs to
+     * @param windowManager Window management
      */
-    public Query(final Server newServer, final String newHost) {
-        this(newServer, newHost, false);
+    public Query(final Server newServer, final String newHost, final WindowManager windowManager) {
+        this(newServer, newHost, false, windowManager);
     }
 
     /**
      * @param newHost host of the remove client
      * @param newServer The server object that this Query belongs to
      * @param focus Should we focus the query on open?
+     * @param windowManager Window management
      */
     public Query(final Server newServer, final String newHost,
-            final boolean focus) {
+            final boolean focus, final WindowManager windowManager) {
         super("query", newServer.parseHostmask(newHost)[0],
                 newServer.parseHostmask(newHost)[0],
                 newServer.getConfigManager(), new QueryCommandParser(newServer),
                 Arrays.asList(WindowComponent.TEXTAREA.getIdentifier(),
-                WindowComponent.INPUTFIELD.getIdentifier()));
+                        WindowComponent.INPUTFIELD.getIdentifier()), windowManager);
 
         this.server = newServer;
         this.host = newHost;
         this.nickname = server.parseHostmask(host)[0];
 
-        WindowManager.getWindowManager().addWindow(server, this, focus);
+        windowManager.addWindow(server, this, focus);
 
         ActionManager.getActionManager().triggerEvent(
                 CoreActionType.QUERY_OPENED, null, this);

src/com/dmdirc/Raw.java

  * Handles the raw window (which shows the user raw data being sent and
  * received to/from the server).
  */
-public final class Raw extends WritableFrameContainer
+public class Raw extends WritableFrameContainer
         implements DataInListener, DataOutListener {
 
     /** The server object that's being monitored. */
      * Creates a new instance of Raw.
      *
      * @param newServer the server to monitor
+     * @param windowManager Window management
      */
-    public Raw(final Server newServer) {
+    public Raw(final Server newServer, final WindowManager windowManager) {
         super("raw", "Raw", "(Raw log)", newServer.getConfigManager(),
                 new ServerCommandParser(newServer.getConfigManager()),
                 Arrays.asList(WindowComponent.TEXTAREA.getIdentifier(),
-                WindowComponent.INPUTFIELD.getIdentifier()));
+                        WindowComponent.INPUTFIELD.getIdentifier()), windowManager);
 
         this.server = newServer;
 
         getCommandParser().setOwner(server);
 
-        WindowManager.getWindowManager().addWindow(server, this);
+        windowManager.addWindow(server, this);
     }
 
     /**

src/com/dmdirc/Server.java

 import com.dmdirc.tls.CertificateManager;
 import com.dmdirc.tls.CertificateProblemListener;
 import com.dmdirc.ui.StatusMessage;
+import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.core.components.StatusBarManager;
 import com.dmdirc.ui.core.components.WindowComponent;
 import com.dmdirc.ui.input.TabCompleter;
     /** Factory to use to create new identities. */
     private final IdentityFactory identityFactory;
 
+    /** Window manager to pas to children. */
+    private final WindowManager windowManager;
+
     // </editor-fold>
 
     // </editor-fold>
      * @param tabCompleterFactory The factory to use for tab completers.
      * @param commandController The controller to use to retrieve commands.
      * @param identityFactory The factory to use to create identities.
+     * @param windowManager Window Manager
      * @param uri The address of the server to connect to
      * @param profile The profile to use
      */
             final TabCompleterFactory tabCompleterFactory,
             final CommandController commandController,
             final IdentityFactory identityFactory,
+            final WindowManager windowManager,
             final URI uri,
             final ConfigProvider profile) {
         super("server-disconnected",
                 commandParser,
                 Arrays.asList(WindowComponent.TEXTAREA.getIdentifier(),
                 WindowComponent.INPUTFIELD.getIdentifier(),
-                WindowComponent.CERTIFICATE_VIEWER.getIdentifier()));
+                        WindowComponent.CERTIFICATE_VIEWER.getIdentifier()), windowManager);
 
         this.manager = manager;
         this.parserFactory = parserFactory;
         this.identityFactory = identityFactory;
+        this.windowManager = windowManager;
         setConnectionDetails(uri, profile);
 
         tabCompleter = tabCompleterFactory.getTabCompleter(configManager,
         final String lnick = converter.toLowerCase(nick);
 
         if (!queries.containsKey(lnick)) {
-            final Query newQuery = new Query(this, host, focus);
+            final Query newQuery = new Query(this, host, focus, windowManager);
 
             tabCompleter.addEntry(TabCompletionType.QUERY_NICK, nick);
             queries.put(lnick, newQuery);
     @Override
     public void addRaw() {
         if (raw == null) {
-            raw = new Raw(this);
+            raw = new Raw(this, windowManager);
 
             try {
                 parserLock.readLock().lock();
             getChannel(chan.getName()).setChannelInfo(chan);
             getChannel(chan.getName()).selfJoin();
         } else {
-            final Channel newChan = new Channel(this, chan, focus);
+            final Channel newChan = new Channel(this, chan, focus, windowManager);
 
             tabCompleter.addEntry(TabCompletionType.CHANNEL, chan.getName());
             channels.put(converter.toLowerCase(chan.getName()), newChan);

src/com/dmdirc/ServerManager.java

                 tabCompleterFactory,
                 commandController.get(),
                 identityFactory,
+                windowManager,
                 uri,
                 profile);
         registerServer(server);

src/com/dmdirc/WritableFrameContainer.java

 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.messages.MessageSinkManager;
 import com.dmdirc.parser.common.CompositionState;
+import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.input.TabCompleter;
 
 import java.util.ArrayList;
      * @param config The config manager for this container
      * @param parser The command parser for this container
      * @param components The UI components that this frame requires
+     * @param windowManager For window management
      * @since 0.6.4
      */
     public WritableFrameContainer(final String icon, final String name,
             final String title, final AggregateConfigProvider config,
-            final CommandParser parser, final Collection<String> components) {
-        super(icon, name, title, config, components);
+            final CommandParser parser, final Collection<String> components,
+            final WindowManager windowManager) {
+        super(icon, name, title, config, components, windowManager);
 
         this.commandParser = parser;
         parser.setOwner(this);

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

     private final CommandFlag targetFlag = new CommandFlag("target", true, 1, 0);
     /** The command flag handler for this command. */
     private final CommandFlagHandler handler;
+    /** Window management. */
+    private final WindowManager windowManager;
 
     /**
      * Creates a new instance of Echo.
      *
      * @param controller Command controller
+     * @param windowManager Window management
      */
     @Inject
-    public Echo(final CommandController controller) {
+    public Echo(final CommandController controller, final WindowManager windowManager) {
         super(controller);
 
+        this.windowManager = windowManager;
         handler = new CommandFlagHandler(timeStampFlag, targetFlag);
     }
 
             FrameContainer target = origin;
 
             while (frame == null && target != null) {
-                frame = WindowManager.getWindowManager().findCustomWindow(target,
+                frame = windowManager.findCustomWindow(target,
                         results.getArgumentsAsString(targetFlag));
                 target = target.getParent();
             }
 
             if (frame == null) {
-                frame = WindowManager.getWindowManager().findCustomWindow(results.getArgumentsAsString(targetFlag));
+                frame = windowManager.findCustomWindow(results.getArgumentsAsString(targetFlag));
             }
 
             if (frame == null) {
             }
 
             //Global Windows
-            windowList.addAll(WindowManager.getWindowManager().getRootWindows());
+            windowList.addAll(windowManager.getRootWindows());
             for (FrameContainer customWindow : windowList) {
                 if (customWindow instanceof CustomWindow) {
                     targets.add(customWindow.getName());

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

             "openwindow [--server|--child] <name> [title] "
             + "- opens a window with the specified name and title",
             CommandType.TYPE_GLOBAL);
+    /** Window management. */
+    private final WindowManager windowManager;
 
     /**
      * Creates a new instance of this command.
      *
      * @param controller The controller to use for command information.
+     * @param windowManager Window management
      */
     @Inject
-    public OpenWindow(final CommandController controller) {
+    public OpenWindow(final CommandController controller, final WindowManager windowManager) {
         super(controller);
+
+        this.windowManager = windowManager;
     }
 
     /** {@inheritDoc} */
             final FrameContainer window;
 
             if (parent == null) {
-                window = WindowManager.getWindowManager().findCustomWindow(args.getArguments()[start]);
+                window = windowManager.findCustomWindow(args.getArguments()[start]);
             } else {
-                window = WindowManager.getWindowManager().findCustomWindow(parent, args.getArguments()[start]);
+                window = windowManager.findCustomWindow(parent, args.getArguments()[start]);
             }
 
             final String title = args.getArguments().length > start + 1
 
             if (window == null) {
                 if (parent == null) {
-                    new CustomWindow(args.getArguments()[start], title);
+                    new CustomWindow(args.getArguments()[start], title, windowManager);
                 } else {
                     new CustomWindow(args.getArguments()[start], title, parent);
                 }

src/com/dmdirc/messages/CustomWindowMessageSink.java

 
     /** The pattern to use to match this sink. */
     private static final Pattern PATTERN = Pattern.compile("window:(.*)");
+    /** Window management. */
+    private final WindowManager windowManager;
+
+    /**
+     * Creates a new custom window message sink.
+     *
+     * @param windowManager Window management
+     */
+    public CustomWindowMessageSink(final WindowManager windowManager) {
+        this.windowManager = windowManager;
+    }
 
     /** {@inheritDoc} */
     @Override
             final WritableFrameContainer source,
             final String[] patternMatches, final Date date,
             final String messageType, final Object... args) {
-        FrameContainer targetWindow = WindowManager.getWindowManager()
-                .findCustomWindow(source.getServer(), patternMatches[0]);
+        FrameContainer targetWindow = windowManager.findCustomWindow(source.getServer(), patternMatches[0]);
 
         if (targetWindow == null) {
             targetWindow = new CustomWindow(patternMatches[0],

src/com/dmdirc/messages/MessageSinkManager.java

 import com.dmdirc.WritableFrameContainer;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
+import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.core.components.StatusBarManager;
 
 import java.util.ArrayList;
         addSink(new AllMessageSink());
         addSink(new ChannelMessageSink());
         addSink(new CommonChanelsMessageSink());
-        addSink(new CustomWindowMessageSink());
+        addSink(new CustomWindowMessageSink(WindowManager.getWindowManager()));
         addSink(new ForkMessageSink());
         addSink(new FormatMessageSink());
         addSink(new GroupMessageSink());

test/com/dmdirc/ServerTest.java

 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigProvider;
 import com.dmdirc.interfaces.config.IdentityFactory;
+import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.input.TabCompleterFactory;
 
 import java.net.URI;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.when;
 
 public class ServerTest {
 
     @Mock private IdentityFactory identityFactory;
     @Mock private TabCompleterFactory tabCompleterFactory;
     @Mock private CommandController commandController;
+    @Mock private WindowManager windowManager;
 
     private Server server;
 
                 tabCompleterFactory,
                 commandController,
                 identityFactory,
+                windowManager,
                 new URI("irc-test://255.255.255.255"),
                 profile);
     }

test/com/dmdirc/WritableFrameContainerTest.java

 import com.dmdirc.config.ConfigBinder;
 import com.dmdirc.harness.TestWritableFrameContainer;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
+import com.dmdirc.ui.WindowManager;
 
 import java.util.Arrays;
 
 
     @Mock private AggregateConfigProvider acp;
     @Mock private ServerManager serverManager;
+    @Mock private WindowManager windowManager;
     private CommandManager commands;
 
     @Before
     @Test
     public void testGetNumLines() {
         final WritableFrameContainer container10
-                = new TestWritableFrameContainer(10, acp, commands);
+                = new TestWritableFrameContainer(10, acp, commands, windowManager);
 
         final int res0a = container10.getNumLines("");
         final int res0b = container10.getNumLines("\r");
     @Test
     public void testSplitLine() {
         final WritableFrameContainer container10
-                = new TestWritableFrameContainer(10, acp, commands);
+                = new TestWritableFrameContainer(10, acp, commands, windowManager);
         final String[][][] tests = new String[][][]{
             {{""}, {""}},
             {{"0123456789"}, {"0123456789"}},

test/com/dmdirc/commandparser/parsers/CommandParserTest.java

 import com.dmdirc.config.InvalidIdentityFileException;
 import com.dmdirc.harness.TestCommandParser;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
+import com.dmdirc.ui.WindowManager;
 
 import org.junit.Before;
 import org.junit.Test;
 
     @Mock private ServerManager serverManager;
     @Mock private AggregateConfigProvider cm;
+    @Mock private WindowManager windowManager;
     private CommandManager commands;
 
     @Before
         when(cm.getBinder()).thenReturn(binder);
         commands = new CommandManager(serverManager);
         commands.initialise(cm);
-        commands.registerCommand(new Echo(commands), Echo.INFO);
+        commands.registerCommand(new Echo(commands, windowManager), Echo.INFO);
     }
 
     @Test

test/com/dmdirc/harness/TestWritableFrameContainer.java

 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
+import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.input.TabCompleter;
 
 import java.util.Collections;
     private final int lineLength;
 
     public TestWritableFrameContainer(final int lineLength,
-            final AggregateConfigProvider cm, final CommandManager commandManager) {
+            final AggregateConfigProvider cm, final CommandManager commandManager,
+            final WindowManager windowManager) {
         super("raw", "Raw", "(Raw)", cm,
                 new GlobalCommandParser(cm, commandManager),
-                Collections.<String>emptySet());
+                Collections.<String>emptySet(), windowManager);
 
         this.lineLength = lineLength;
     }