Use active window frame manager.

Change-Id: I9b37249813c03941cdd410a5b225f3d710a72244
Reviewed-on: http://gerrit.dmdirc.com/3323
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/addons/activewindow/ActiveCommand.java

 
 import com.dmdirc.FrameContainer;
 import com.dmdirc.WritableFrameContainer;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.commandparser.BaseCommandInfo;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
     public static final CommandInfo INFO = new BaseCommandInfo("active",
             "active <command> - executes the command as though it had been "
             + "executed in the active window", CommandType.TYPE_GLOBAL);
-    /** Parent MainFrame. */
-    private final MainFrame mainFrame;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
 
     /**
      * Creates a new active command.
      *
-     * @param controller The controller to use for command information.
-     * @param mainFrame  Parent MainFrame
+     * @param controller          The controller to use for command information.
+     * @param activeFrameManager The active window manager
      */
     @Inject
-    public ActiveCommand(final CommandController controller, final MainFrame mainFrame) {
+    public ActiveCommand(final CommandController controller,
+            final ActiveFrameManager activeFrameManager) {
         super(controller);
 
-        this.mainFrame = mainFrame;
+        this.activeFrameManager = activeFrameManager;
     }
 
     @Override
     public void execute(final FrameContainer origin,
             final CommandArguments args, final CommandContext context) {
-        final TextFrame frame = mainFrame.getActiveFrame();
+        final TextFrame frame = activeFrameManager.getActiveFrame();
         if (frame.getContainer() instanceof WritableFrameContainer) {
             ((WritableFrameContainer) frame.getContainer()).getCommandParser()
                     .parseCommand(frame.getContainer(),

src/com/dmdirc/addons/activewindow/ActiveWindowMessageSink.java

 package com.dmdirc.addons.activewindow;
 
 import com.dmdirc.WritableFrameContainer;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.messages.MessageSink;
 import com.dmdirc.messages.MessageSinkManager;
 
 
     /** The pattern to use to match this sink. */
     private static final Pattern PATTERN = Pattern.compile("active");
-    /** The main frame to use to get the currently active frame. */
-    private final MainFrame mainFrame;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
 
     /**
      * Creates a new ActiveWindowMessageSink for the specified mainframe.
      *
-     * @param mainFrame The mainframe to use to retrieve active windows
+     * @param activeFrameManager Active frame manager.
      */
     @Inject
-    public ActiveWindowMessageSink(final MainFrame mainFrame) {
-        this.mainFrame = mainFrame;
+    public ActiveWindowMessageSink(final ActiveFrameManager activeFrameManager) {
+        this.activeFrameManager = activeFrameManager;
     }
 
     @Override
     public void handleMessage(final MessageSinkManager despatcher,
             final WritableFrameContainer source, final String[] patternMatches,
             final Date date, final String messageType, final Object... args) {
-        final TextFrame frame = mainFrame.getActiveFrame();
+        final TextFrame frame = activeFrameManager.getActiveFrame();
         if (frame.getContainer() instanceof WritableFrameContainer) {
             frame.getContainer().addLine(messageType, date, args);
         }

src/com/dmdirc/addons/lagdisplay/LagDisplayManager.java

 import com.dmdirc.ServerState;
 import com.dmdirc.actions.ActionManager;
 import com.dmdirc.actions.CoreActionType;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.SelectionListener;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
 import com.dmdirc.addons.ui_swing.components.statusbar.SwingStatusBar;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.interfaces.ActionListener;
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.interfaces.actions.ActionType;
 @Singleton
 public class LagDisplayManager implements ActionListener, ConfigChangeListener, SelectionListener {
 
-    /** Frame to listen to selection events on. */
-    // TODO: Selection/focus management should be behind an interface
-    private final MainFrame mainFrame;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
     /** Status bar to add panels to. */
     private final SwingStatusBar statusBar;
     private final Provider<LagDisplayPanel> panelProvider;
 
     @Inject
     public LagDisplayManager(
-            final MainFrame mainFrame,
+            final ActiveFrameManager activeFrameManager,
             final SwingStatusBar statusBar,
             final Provider<LagDisplayPanel> panelProvider,
             @PluginDomain(LagDisplayPlugin.class) final String domain,
             @GlobalConfig final AggregateConfigProvider globalConfig) {
-        this.mainFrame = mainFrame;
+        this.activeFrameManager = activeFrameManager;
         this.statusBar = statusBar;
         this.panelProvider = panelProvider;
         this.domain = domain;
     public void load() {
         panel = panelProvider.get();
         statusBar.addComponent(panel);
-        mainFrame.addSelectionListener(this);
+        activeFrameManager.addSelectionListener(this);
         globalConfig.addChangeListener(domain, this);
         readConfig();
         ActionManager.getActionManager().registerListener(this,
 
     public void unload() {
         statusBar.removeComponent(panel);
-        mainFrame.removeSelectionListener(this);
+        activeFrameManager.removeSelectionListener(this);
         globalConfig.removeListener(this);
         ActionManager.getActionManager().unregisterListener(this);
         panel = null;
             }
         }
 
-        final TextFrame activeFrame = mainFrame.getActiveFrame();
+        final TextFrame activeFrame = activeFrameManager.getActiveFrame();
         final FrameContainer active = activeFrame == null ? null
                 : activeFrame.getContainer();
         final boolean isActive = active != null

src/com/dmdirc/addons/lagdisplay/PingHistoryPanel.java

 
 package com.dmdirc.addons.lagdisplay;
 
-import com.dmdirc.addons.ui_swing.MainFrame;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.util.collections.RollingList;
 
 import java.awt.Color;
  */
 public class PingHistoryPanel extends JPanel {
 
-    /**
-     * 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).
-     */
+    /** A version number for this class. */
     private static final long serialVersionUID = 1;
     /** The manager that this panel is for. */
     protected final LagDisplayManager manager;
     /**
      * Creates a new history panel for the specified plugin.
      *
-     * @param manager   The manager that owns this panel
-     * @param mainFrame Swing main frame
+     * @param manager            The manager that owns this panel
+     * @param activeFrameManager Active frame manager.
      */
     public PingHistoryPanel(final LagDisplayManager manager,
-            final MainFrame mainFrame) {
-        super();
-
+            final ActiveFrameManager activeFrameManager) {
         setMinimumSize(new Dimension(50, 100));
         setMaximumSize(new Dimension(Integer.MAX_VALUE, 100));
         setOpaque(false);
 
         this.manager = manager;
-        history = manager.getHistory(mainFrame.getActiveFrame().getContainer().getConnection());
+        history = manager.getHistory(activeFrameManager.getActiveFrame().getContainer().
+                getConnection());
 
         for (Long value : history.getList()) {
             maximum = Math.max(value, maximum);

src/com/dmdirc/addons/ui_swing/SwingLinkHandler.java

 package com.dmdirc.addons.ui_swing;
 
 import com.dmdirc.FrameContainer;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.events.LinkChannelClickedEvent;
 import com.dmdirc.events.LinkNicknameClickedEvent;
 import com.dmdirc.events.LinkUrlClickedEvent;
 import com.google.common.eventbus.Subscribe;
 
 import javax.inject.Inject;
-import javax.inject.Provider;
 import javax.inject.Singleton;
 
 /**
 public class SwingLinkHandler {
 
     private final URLHandler urlHandler;
-    private final Provider<MainFrame> mainFrame;
+    private final ActiveFrameManager activeFrameManager;
     private final SwingWindowFactory windowFactory;
 
     @Inject
     public SwingLinkHandler(
-            final Provider<MainFrame> mainFrame,
+            final ActiveFrameManager activeFrameManager,
             final URLHandler urlHandler,
             final SwingWindowFactory windowFactory) {
         this.urlHandler = urlHandler;
-        this.mainFrame = mainFrame;
+        this.activeFrameManager = activeFrameManager;
         this.windowFactory = windowFactory;
     }
 
         final FrameContainer container = event.getWindow().getContainer();
         final Connection connection = container.getConnection();
         if (connection != null) {
-            mainFrame.get().setActiveFrame(
+            activeFrameManager.setActiveFrame(
                     windowFactory.getSwingWindow(connection.getQuery(event.getTarget())));
         }
     }

src/com/dmdirc/addons/ui_swing/SwingWindowFactory.java

 import com.dmdirc.addons.ui_swing.components.frames.CustomInputFrameFactory;
 import com.dmdirc.addons.ui_swing.components.frames.ServerFrameFactory;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
 import com.dmdirc.interfaces.ui.FrameListener;
 import com.dmdirc.logger.ErrorLevel;
     private final Map<Collection<String>, WindowProvider> implementations = new HashMap<>();
     /** A map of frame containers to their Swing windows. */
     private final Map<FrameContainer, TextFrame> windows = new HashMap<>();
-    /** The provider to get the main frame to focus frames. */
-    private final Provider<MainFrame> mainFrameProvider;
+    /** Active window manager. */
+    private final Provider<ActiveFrameManager> activeFrameManager;
     /** Our list of listeners. */
     private final ListenerList listeners = new ListenerList();
 
     /**
      * Creates a new window factory for the specified controller.
      *
-     * @param mainFrameProvider       The provider to get the main frame to focus frames.
+     * @param activeFrameManager      The provider for the active frame manager.
      * @param customFrameFactory      The factory to use to produce custom frames.
      * @param customInputFrameFactory The factory to use to produce custom input frames.
      * @param serverFrameFactory      The factory to use to produce server frames.
      */
     @Inject
     public SwingWindowFactory(
-            final Provider<MainFrame> mainFrameProvider,
+            final Provider<ActiveFrameManager> activeFrameManager,
             final CustomFrameFactory customFrameFactory,
             final CustomInputFrameFactory customInputFrameFactory,
             final ServerFrameFactory serverFrameFactory,
             final ChannelFrameFactory channelFrameFactory,
             final GlobalCommandParser commandParser) {
-        this.mainFrameProvider = mainFrameProvider;
+        this.activeFrameManager = activeFrameManager;
 
         // TODO: Allow auto-factories to implement an interface and simplify this a bit.
         registerImplementation(
                 }
 
                 if (focus) {
-                    mainFrameProvider.get().setActiveFrame(childWindow);
+                    activeFrameManager.get().setActiveFrame(childWindow);
                 }
             }
         });

src/com/dmdirc/addons/ui_swing/components/MDIBar.java

 package com.dmdirc.addons.ui_swing.components;
 
 import com.dmdirc.ClientModule.GlobalConfig;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.SelectionListener;
 import com.dmdirc.addons.ui_swing.SwingController;
 import com.dmdirc.addons.ui_swing.SwingWindowFactory;
 import com.dmdirc.addons.ui_swing.SwingWindowListener;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigChangeListener;
 import com.dmdirc.plugins.PluginDomain;
     private static final int ICON_SIZE = 12;
     /** Button to close frames. */
     private final NoFocusButton closeButton;
-    /** Main frame component bieng shown in. */
-    private final MainFrame mainFrame;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
     /** Config manager to get settings from. */
     private final AggregateConfigProvider config;
     /** Option domain. */
     /**
      * Instantiates a new MDI bar.
      *
-     * @param globalConfig  The config to read settings from.
-     * @param iconManager   The manager to use to retrieve icons.
-     * @param domain        The domain to read settings from under.
-     * @param windowFactory The window factory to use to create and listen for windows.
-     * @param mainFrame     Main frame instance
+     * @param globalConfig       The config to read settings from.
+     * @param iconManager        The manager to use to retrieve icons.
+     * @param domain             The domain to read settings from under.
+     * @param windowFactory      The window factory to use to create and listen for windows.
+     * @param activeFrameManager Active frame manager.
      */
     @Inject
     public MDIBar(
             @GlobalConfig final IconManager iconManager,
             @PluginDomain(SwingController.class) final String domain,
             final SwingWindowFactory windowFactory,
-            final MainFrame mainFrame) {
+            final ActiveFrameManager activeFrameManager) {
         super();
 
-        this.mainFrame = mainFrame;
+        this.activeFrameManager = activeFrameManager;
         this.config = globalConfig;
         this.configDomain = domain;
         visibility = config.getOptionBool(configDomain, "mdiBarVisibility");
 
         windowFactory.addWindowListener(this);
 
-        mainFrame.addSelectionListener(this);
+        activeFrameManager.addSelectionListener(this);
         closeButton.addActionListener(this);
         config.addChangeListener(configDomain, "mdiBarVisibility", this);
 
             @Override
             public void run() {
                 setVisible(visibility);
-                setEnabled(mainFrame.getActiveFrame() != null);
+                setEnabled(activeFrameManager.getActiveFrame() != null);
             }
         });
     }
      */
     @Override
     public void actionPerformed(final ActionEvent e) {
-        if (mainFrame.getActiveFrame() == null) {
+        if (activeFrameManager.getActiveFrame() == null) {
             return;
         }
         if (closeButton.equals(e.getSource())) {
-            mainFrame.getActiveFrame().getContainer().close();
+            activeFrameManager.getActiveFrame().getContainer().close();
         }
     }
 

src/com/dmdirc/addons/ui_swing/components/frames/TextFrame.java

 import com.dmdirc.addons.ui_swing.actions.SearchAction;
 import com.dmdirc.addons.ui_swing.components.SwingSearchBar;
 import com.dmdirc.addons.ui_swing.dialogs.paste.PasteDialogFactory;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.addons.ui_swing.textpane.ClickTypeValue;
 import com.dmdirc.addons.ui_swing.textpane.MouseEventType;
 import com.dmdirc.addons.ui_swing.textpane.TextPane;
 public abstract class TextFrame extends JPanel implements Window,
         ConfigChangeListener, TextPaneListener, FrameCloseListener {
 
-    /**
-     * 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).
-     */
+    /** A version number for this class. */
     private static final long serialVersionUID = 5;
     /** The channel object that owns this frame. */
     protected final FrameContainer frameParent;
     private SwingSearchBar searchBar;
     /** Command parser for popup commands. */
     private final CommandParser commandParser;
-    /** Main frame to use to activate/deactivate windows. */
-    private final Provider<MainFrame> mainFrame;
+    /** Manager used to activate/deactivate windows. */
+    private final ActiveFrameManager activeFrameManager;
     /** Manager to use for building popups. */
     private final PopupManager popupManager;
     /** Bus to despatch events on. */
     private final EventBus eventBus;
     /** Boolean to determine if this frame should be popped out of main client. */
     private boolean popout;
-    /**
-     * DesktopWindowFrame to use for this TextFrame if it is to be popped out of the client.
-     */
+    /** DesktopWindowFrame to use for this TextFrame if it is to be popped out of the client. */
     private DesktopWindowFrame popoutFrame;
     /** Desktop place holder object used if this frame is popped out. */
     private DesktopPlaceHolderFrame popoutPlaceholder;
             final FrameContainer owner,
             final CommandParser commandParser,
             final TextFrameDependencies deps) {
-        this.mainFrame = deps.mainFrame;
+        this.activeFrameManager = deps.activeFrameManager;
         this.popupManager = deps.popupManager;
         this.frameParent = owner;
         this.iconManager = deps.iconManager;
             popoutFrame = null;
         }
         // Call setActiveFrame again so the contents of the frame manager are updated.
-        if (equals(mainFrame.get().getActiveFrame())) {
-            mainFrame.get().setActiveFrame(this);
+        if (equals(activeFrameManager.getActiveFrame())) {
+            activeFrameManager.setActiveFrame(this);
         }
     }
 
         final PasteDialogFactory pasteDialog;
         final PluginManager pluginManager;
         final IconManager iconManager;
+        final ActiveFrameManager activeFrameManager;
 
         @Inject
         public TextFrameDependencies(
                 final PasteDialogFactory pasteDialog,
                 final PluginManager pluginManager,
                 @GlobalConfig final IconManager iconManager,
-                @GlobalConfig final AggregateConfigProvider globalConfig) {
+                @GlobalConfig final AggregateConfigProvider globalConfig,
+                final ActiveFrameManager activeFrameManager) {
             this.textPaneFactory = textPaneFactory;
             this.controller = controller;
             this.mainFrame = mainFrame;
             this.pasteDialog = pasteDialog;
             this.pluginManager = pluginManager;
             this.iconManager = iconManager;
+            this.activeFrameManager = activeFrameManager;
         }
 
     }

src/com/dmdirc/addons/ui_swing/components/menubar/ChannelMenu.java

 import com.dmdirc.Channel;
 import com.dmdirc.FrameContainer;
 import com.dmdirc.ServerState;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
 import com.dmdirc.addons.ui_swing.dialogs.ChannelJoinDialogFactory;
 import com.dmdirc.addons.ui_swing.dialogs.channellist.ChannelListDialog;
 import com.dmdirc.addons.ui_swing.dialogs.channelsetting.ChannelSettingsDialog;
 import com.dmdirc.addons.ui_swing.injection.DialogProvider;
 import com.dmdirc.addons.ui_swing.injection.KeyedDialogProvider;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
     private final DialogProvider<ChannelListDialog> channelListDialogProvider;
     /** Channel join dialog factory. */
     private final ChannelJoinDialogFactory channelJoinDialogFactory;
-    /** Main frame. */
-    private final MainFrame mainFrame;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
     /** Menu items to be disabled/enabled. */
     private JMenuItem csd;
     private JMenuItem join;
     /**
      * Creates a new channel menu.
      *
-     * @param mainFrame                 Parent mainframe
+     * @param activeFrameManager        Active frame manager.
      * @param dialogProvider            Channel settings dialog provider
      * @param channelJoinDialogFactory  Channel join dialog factory
      * @param channelListDialogProvider Channel list dialog provider
      */
     @Inject
     public ChannelMenu(
-            final MainFrame mainFrame,
+            final ActiveFrameManager activeFrameManager,
             final KeyedDialogProvider<Channel, ChannelSettingsDialog> dialogProvider,
             final ChannelJoinDialogFactory channelJoinDialogFactory,
             final DialogProvider<ChannelListDialog> channelListDialogProvider) {
         super("Channel");
-        this.mainFrame = mainFrame;
+        this.activeFrameManager = activeFrameManager;
         this.dialogProvider = dialogProvider;
         this.channelJoinDialogFactory = channelJoinDialogFactory;
         this.channelListDialogProvider = channelListDialogProvider;
                         "Enter the name of the channel to join.").displayOrRequestFocus();
                 break;
             case "ChannelSettings":
-                final FrameContainer activeWindow = mainFrame.getActiveFrame().getContainer();
+                final FrameContainer activeWindow = activeFrameManager.getActiveFrame().
+                        getContainer();
                 if (activeWindow instanceof Channel) {
                     dialogProvider.displayOrRequestFocus(((Channel) activeWindow));
                 }
 
     @Override
     public final void menuSelected(final MenuEvent e) {
-        final TextFrame activeFrame = mainFrame.getActiveFrame();
+        final TextFrame activeFrame = activeFrameManager.getActiveFrame();
         final FrameContainer activeWindow = activeFrame == null ? null
                 : activeFrame.getContainer();
 

src/com/dmdirc/addons/ui_swing/components/menubar/ServerMenu.java

 import com.dmdirc.Server;
 import com.dmdirc.ServerState;
 import com.dmdirc.addons.ui_swing.Apple;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
 import com.dmdirc.addons.ui_swing.dialogs.NewServerDialog;
 import com.dmdirc.addons.ui_swing.dialogs.serversetting.ServerSettingsDialog;
 import com.dmdirc.addons.ui_swing.injection.DialogProvider;
 import com.dmdirc.addons.ui_swing.injection.KeyedDialogProvider;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
+import com.dmdirc.interfaces.LifecycleController;
 
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
     /** A version number for this class. */
     private static final long serialVersionUID = 1;
-    /** Main frame. */
-    private final MainFrame mainFrame;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
+    /** Lifecycle controller. */
+    private final LifecycleController lifecycleController;
     /** Menu items which can be enabled/disabled. */
     private JMenuItem ssd;
     private JMenuItem disconnect;
     /**
      * Creates a new Server menu.
      *
-     * @param mainFrame         Parent main frame
-     * @param newServerProvider Provider to use to retrieve NSD instances.
-     * @param ssdProvider       Provider to get SSD instances
+     * @param activeFrameManager  Active frame manager.
+     * @param lifecycleController Lifecycle controller
+     * @param newServerProvider   Provider to use to retrieve NSD instances.
+     * @param ssdProvider         Provider to get SSD instances
      */
     @Inject
     public ServerMenu(
-            final MainFrame mainFrame,
+            final ActiveFrameManager activeFrameManager,
+            final LifecycleController lifecycleController,
             final DialogProvider<NewServerDialog> newServerProvider,
             final KeyedDialogProvider<Server, ServerSettingsDialog> ssdProvider) {
         super("Server");
-        this.mainFrame = mainFrame;
+        this.activeFrameManager = activeFrameManager;
+        this.lifecycleController = lifecycleController;
         this.newServerProvider = newServerProvider;
         this.ssdProvider = ssdProvider;
 
                 newServerProvider.displayOrRequestFocus();
                 break;
             case "Exit":
-                mainFrame.quit();
+                lifecycleController.quit();
                 break;
             case "ServerSettings":
                 ssdProvider.displayOrRequestFocus(
-                        (Server) mainFrame.getActiveFrame().getContainer().getConnection());
+                        (Server) activeFrameManager.getActiveFrame().getContainer().getConnection());
                 break;
             case "Disconnect":
-                mainFrame.getActiveFrame().getContainer().getConnection().disconnect();
+                activeFrameManager.getActiveFrame().getContainer().getConnection().disconnect();
                 break;
         }
     }
 
     @Override
     public final void menuSelected(final MenuEvent e) {
-        final TextFrame activeFrame = mainFrame.getActiveFrame();
+        final TextFrame activeFrame = activeFrameManager.getActiveFrame();
         final FrameContainer activeWindow = activeFrame == null ? null
                 : activeFrame.getContainer();
 

src/com/dmdirc/addons/ui_swing/dialogs/ChannelJoinDialog.java

 
 import com.dmdirc.ClientModule.GlobalConfig;
 import com.dmdirc.addons.ui_swing.MainFrame;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.parser.common.ChannelJoinRequest;
 import com.dmdirc.ui.IconManager;
 import com.dmdirc.util.annotations.factory.Factory;
 
     /** Serial version UID. */
     private static final long serialVersionUID = 1;
-    /** The main frame that owns this dialog. */
-    private final MainFrame mainFrame;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
 
     /**
      * Creates a new dialog which prompts a user and then joins the channel they specify.
      *
      * @param mainFrame   Main frame
+     * @param activeFrameManager The active window manager
      * @param iconManager The icon manager to use for validating text fields.
      * @param title       Window title
      * @param message     Window message
      */
     public ChannelJoinDialog(
             final MainFrame mainFrame,
+            final ActiveFrameManager activeFrameManager,
             @SuppressWarnings("qualifiers") @GlobalConfig final IconManager iconManager,
             @Unbound final String title,
             @Unbound final String message) {
         super(mainFrame, ModalityType.APPLICATION_MODAL, iconManager, title, message);
 
-        this.mainFrame = mainFrame;
+        this.activeFrameManager = activeFrameManager;
     }
 
     @Override
     public boolean save() {
-        mainFrame.getActiveFrame().getContainer().getConnection()
+        activeFrameManager.getActiveFrame().getContainer().getConnection()
                 .join(new ChannelJoinRequest(getText()));
         return true;
     }

src/com/dmdirc/addons/ui_swing/dialogs/NewServerDialog.java

 import com.dmdirc.addons.ui_swing.components.vetoable.VetoableComboBoxSelectionListener;
 import com.dmdirc.addons.ui_swing.dialogs.profiles.ProfileManagerDialog;
 import com.dmdirc.addons.ui_swing.injection.DialogProvider;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigProvider;
     private final IconManager iconManager;
     /** Config. */
     private final AggregateConfigProvider config;
-    /** Main frame. */
-    private final MainFrame mainFrame;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
     /** checkbox. */
     private JCheckBox newServerWindowCheck;
     /** checkbox. */
      * Creates a new instance of the dialog.
      *
      * @param mainFrame             Main frame
+     * @param activeFrameManager    The active window manager
      * @param config                Config
      * @param iconManager           Icon manager
      * @param identityController    Identity controller
     @Inject
     public NewServerDialog(
             final MainFrame mainFrame,
+            final ActiveFrameManager activeFrameManager,
             @GlobalConfig final AggregateConfigProvider config,
             @GlobalConfig final IconManager iconManager,
             final IdentityController identityController,
         super(mainFrame, ModalityType.MODELESS);
         this.identityController = identityController;
         this.serverManager = serverManager;
-        this.mainFrame = mainFrame;
+        this.activeFrameManager = activeFrameManager;
         this.iconManager = iconManager;
         this.config = config;
         this.profileDialogProvider = profileDialogProvider;
 
         serverField.requestFocusInWindow();
 
-        if (serverManager.numServers() == 0 || mainFrame.getActiveFrame() == null) {
+        if (serverManager.numServers() == 0 || activeFrameManager.getActiveFrame() == null) {
             newServerWindowCheck.setSelected(true);
             newServerWindowCheck.setEnabled(false);
         } else {
             // Open in a new window?
             if (newServerWindowCheck.isSelected()
                     || serverManager.numServers() == 0
-                    || mainFrame.getActiveFrame() == null) {
+                    || activeFrameManager.getActiveFrame() == null) {
 
                 new LoggingSwingWorker<Void, Void>() {
                     @Override
                     }
                 }.executeInExecutor();
             } else {
-                final Connection connection = mainFrame.getActiveFrame().getContainer().
+                final Connection connection = activeFrameManager.getActiveFrame().getContainer().
                         getConnection();
 
                 new LoggingSwingWorker<Void, Void>() {

src/com/dmdirc/addons/ui_swing/dialogs/channellist/ChannelListDialog.java

 import com.dmdirc.Server;
 import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.dialogs.StandardDialog;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
     private final JLabel total;
 
     @Inject
-    public ChannelListDialog(final MainFrame mainFrame) {
+    public ChannelListDialog(final MainFrame mainFrame,
+            final ActiveFrameManager activeFrameManager) {
         super(mainFrame, ModalityType.MODELESS);
         setTitle("Channel List");
         total = new JLabel("No results.");
-        list = new ChannelListPanel((Server) mainFrame.getActiveFrame().getContainer()
+        list = new ChannelListPanel((Server) activeFrameManager.getActiveFrame().getContainer()
                 .getConnection(), total);
         layoutComponents();
         getCancelButton().setText("Close");

src/com/dmdirc/addons/ui_swing/framemanager/buttonbar/ButtonBar.java

 import com.dmdirc.ClientModule.GlobalConfig;
 import com.dmdirc.FrameContainer;
 import com.dmdirc.FrameContainerComparator;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.SwingWindowFactory;
 import com.dmdirc.addons.ui_swing.UIUtilities;
 import com.dmdirc.addons.ui_swing.actions.CloseFrameContainerAction;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
 import com.dmdirc.addons.ui_swing.framemanager.FrameManager;
 import com.dmdirc.addons.ui_swing.framemanager.FramemanagerPosition;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.interfaces.FrameInfoListener;
 import com.dmdirc.interfaces.NotificationListener;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import java.util.Map;
 
 import javax.inject.Inject;
-import javax.inject.Provider;
 import javax.swing.JComponent;
 import javax.swing.JMenuItem;
 import javax.swing.JPopupMenu;
     private final WindowManager windowManager;
     /** Global configuration to read settings from. */
     private final AggregateConfigProvider globalConfig;
-    /** Provider to use to retrieve the current main frame. */
-    private final Provider<MainFrame> mainFrameProvider;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
 
     /**
      * Creates a new instance of ButtonBar.
      * @param windowFactory     The factory to use to retrieve window information.
      * @param windowManager     The window manager to use to read window state.
      * @param globalConfig      Global configuration to read settings from.
-     * @param mainFrameProvider The provider to use to retrieve the current main frame.
+     * @param activeFrameManager The active window manager
      */
     @Inject
     public ButtonBar(
             final SwingWindowFactory windowFactory,
             @GlobalConfig final AggregateConfigProvider globalConfig,
             final WindowManager windowManager,
-            final Provider<MainFrame> mainFrameProvider) {
+            final ActiveFrameManager activeFrameManager) {
         this.windowFactory = windowFactory;
         this.globalConfig = globalConfig;
         this.windowManager = windowManager;
-        this.mainFrameProvider = mainFrameProvider;
+        this.activeFrameManager = activeFrameManager;
 
         scrollPane = new JScrollPane();
         scrollPane.setBorder(null);
                 globalConfig.getOption("ui", "framemanagerPosition"));
 
         if (position.isHorizontal()) {
-            buttonPanel = new ButtonPanel(mainFrameProvider,
+            buttonPanel = new ButtonPanel(activeFrameManager,
                     new MigLayout("ins rel, fill, flowx"), this);
         } else {
-            buttonPanel = new ButtonPanel(mainFrameProvider,
+            buttonPanel = new ButtonPanel(activeFrameManager,
                     new MigLayout("ins rel, fill, flowy"), this);
         }
         scrollPane.getViewport().addMouseWheelListener(buttonPanel);
                         ? 150 : (parent.getWidth() / NUM_CELLS);
                 initButtons(windowManager.getRootWindows());
 
-                final TextFrame activeFrame = mainFrameProvider.get().getActiveFrame();
+                final TextFrame activeFrame = activeFrameManager.getActiveFrame();
                 if (activeFrame != null) {
                     selectionChanged(activeFrame);
                 }
             button.setSelected(true);
         }
 
-        mainFrameProvider.get().setActiveFrame(frame);
+        activeFrameManager.setActiveFrame(frame);
     }
 
     /**

src/com/dmdirc/addons/ui_swing/framemanager/buttonbar/ButtonPanel.java

 
 package com.dmdirc.addons.ui_swing.framemanager.buttonbar;
 
-import com.dmdirc.addons.ui_swing.MainFrame;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 
 import java.awt.Component;
 import java.awt.Dimension;
 import java.awt.event.MouseWheelEvent;
 import java.awt.event.MouseWheelListener;
 
-import javax.inject.Provider;
 import javax.swing.JPanel;
 import javax.swing.Scrollable;
 
 
     /** A version number for this class. */
     private static final long serialVersionUID = 1;
-    /** The provider to get the main frame to set the active frame. */
-    private final Provider<MainFrame> mainFrameProvider;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
     /** The ButtonBar that created this Panel. */
     private final ButtonBar buttonBar;
 
     /**
      * Constructor for ButtonPanel.
      *
-     * @param mainFrameProvider The provider to get the main frame to set the active frame.
-     * @param layout            Layout settings for this ButtonPanel
-     * @param buttonBar         the buttonBar that created this Panel
+     * @param activeFrameManager The active window manager
+     * @param layout             Layout settings for this ButtonPanel
+     * @param buttonBar          the buttonBar that created this Panel
      */
-    public ButtonPanel(final Provider<MainFrame> mainFrameProvider, final MigLayout layout,
+    public ButtonPanel(final ActiveFrameManager activeFrameManager, final MigLayout layout,
             final ButtonBar buttonBar) {
         super(layout);
 
-        this.mainFrameProvider = mainFrameProvider;
+        this.activeFrameManager = activeFrameManager;
         this.buttonBar = buttonBar;
     }
 
             newIndex = (selectedIndex + 1) % getComponentCount();
         }
 
-        mainFrameProvider.get().setActiveFrame(
-                ((FrameToggleButton) getComponent(newIndex)).getTextFrame());
+        activeFrameManager.setActiveFrame(((FrameToggleButton) getComponent(newIndex)).
+                getTextFrame());
     }
 
     /**

src/com/dmdirc/addons/ui_swing/framemanager/ctrltab/CtrlTabWindowManager.java

 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
 import com.dmdirc.addons.ui_swing.framemanager.tree.TreeViewModel;
 import com.dmdirc.addons.ui_swing.framemanager.tree.TreeViewNode;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.ui.Window;
 import com.dmdirc.logger.ErrorLevel;
     /**
      * Creates a new ctrl tab window manager.
      *
-     * @param globalConfig  The configuration to read settings from.
-     * @param windowFactory The window factory to use to create and listen for windows.
+     * @param globalConfig       The configuration to read settings from.
+     * @param windowFactory      The window factory to use to create and listen for windows.
      * @param mainFrame     The main frame that owns this window manager
+     * @param activeFrameManager Active frame manager.
      */
     @Inject
     public CtrlTabWindowManager(
             @GlobalConfig final AggregateConfigProvider globalConfig,
             final SwingWindowFactory windowFactory,
+            final ActiveFrameManager activeFrameManager,
             final MainFrame mainFrame) {
         nodes = new HashMap<>();
         model = new TreeViewModel(globalConfig, new TreeViewNode(null, null));
             @Override
             protected void setPath(final TreePath path) {
                 super.setPath(path);
-                mainFrame.setActiveFrame(windowFactory.getSwingWindow(
+                activeFrameManager.setActiveFrame(windowFactory.getSwingWindow(
                         ((TreeViewNode) path.getLastPathComponent()).getWindow()));
             }
         };
 
         windowFactory.addWindowListener(this);
-        mainFrame.addSelectionListener(this);
+        activeFrameManager.addSelectionListener(this);
 
         mainFrame.getRootPane().getActionMap().put("prevFrameAction",
                 new PreviousFrameAction(treeScroller));

src/com/dmdirc/addons/ui_swing/framemanager/tree/Tree.java

 
 package com.dmdirc.addons.ui_swing.framemanager.tree;
 
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.SwingWindowFactory;
 import com.dmdirc.addons.ui_swing.UIUtilities;
 import com.dmdirc.addons.ui_swing.actions.CloseFrameContainerAction;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigChangeListener;
 
 import java.awt.event.MouseListener;
 import java.awt.event.MouseMotionListener;
 
-import javax.inject.Provider;
 import javax.swing.BorderFactory;
 import javax.swing.JComponent;
 import javax.swing.JMenuItem;
     private static final long serialVersionUID = 1;
     /** Tree frame manager. */
     private final TreeFrameManager manager;
-    /** The provider to use to retrieve the current main frame.. */
-    private final Provider<MainFrame> mainFrameProvider;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
     /** Config manager. */
     private final AggregateConfigProvider config;
     /** Drag selection enabled? */
      *
      * @param manager           Frame manager
      * @param model             tree model.
-     * @param mainFrameProvider The provider to use to retrieve the current main frame.
+     * @param activeFrameManager The active window manager
      * @param globalConfig      The config to read settings from.
      * @param domain            The domain to read settings from.
      * @param windowFactory     The factory to use to get swing windows.
     public Tree(
             final TreeFrameManager manager,
             final TreeModel model,
-            final Provider<MainFrame> mainFrameProvider,
+            final ActiveFrameManager activeFrameManager,
             final AggregateConfigProvider globalConfig,
             final SwingWindowFactory windowFactory,
             final String domain) {
         this.manager = manager;
         this.config = globalConfig;
         this.windowFactory = windowFactory;
-        this.mainFrameProvider = mainFrameProvider;
+        this.activeFrameManager = activeFrameManager;
 
         putClientProperty("JTree.lineStyle", "Angled");
         getInputMap().setParent(null);
         if (dragSelect && dragButton) {
             final TreeViewNode node = getNodeForLocation(e.getX(), e.getY());
             if (node != null) {
-                mainFrameProvider.get().setActiveFrame(windowFactory.getSwingWindow(
+                activeFrameManager.setActiveFrame(windowFactory.getSwingWindow(
                         ((TreeViewNode) new TreePath(node.getPath()).getLastPathComponent())
                         .getWindow()));
             }
             final TreePath selectedPath = getPathForLocation(e.getX(),
                     e.getY());
             if (selectedPath != null) {
-                mainFrameProvider.get().setActiveFrame(windowFactory.getSwingWindow(
+                activeFrameManager.setActiveFrame(windowFactory.getSwingWindow(
                         ((TreeViewNode) selectedPath.getLastPathComponent()).getWindow()));
             }
         }

src/com/dmdirc/addons/ui_swing/framemanager/tree/TreeFrameManager.java

 
 import com.dmdirc.ClientModule.GlobalConfig;
 import com.dmdirc.FrameContainer;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.SwingController;
 import com.dmdirc.addons.ui_swing.SwingWindowFactory;
 import com.dmdirc.addons.ui_swing.UIUtilities;
 import com.dmdirc.addons.ui_swing.components.TreeScroller;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
 import com.dmdirc.addons.ui_swing.framemanager.FrameManager;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.interfaces.FrameInfoListener;
 import com.dmdirc.interfaces.NotificationListener;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import java.util.Map;
 
 import javax.inject.Inject;
-import javax.inject.Provider;
 import javax.swing.JComponent;
 import javax.swing.JScrollPane;
 import javax.swing.JTree;
     private final SwingWindowFactory windowFactory;
     /** Window manage. */
     private final WindowManager windowManager;
-    /** Provider to use to retrieve the current main frame. */
-    private final Provider<MainFrame> mainFrameProvider;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
 
     /**
      * Creates a new instance of the TreeFrameManager.
      *
-     * @param windowManager     The window manager to use to read window state.
-     * @param globalConfig      The provider to read config settings from.
-     * @param colourManager     The colour manager to use to retrieve colours.
-     * @param mainFrameProvider The provider to use to retrieve the current main frame.
-     * @param windowFactory     The factory to use to retrieve swing windows.
-     * @param domain            The domain to read settings from.
+     * @param windowManager      The window manager to use to read window state.
+     * @param globalConfig       The provider to read config settings from.
+     * @param colourManager      The colour manager to use to retrieve colours.
+     * @param activeFrameManager The active window manager
+     * @param windowFactory      The factory to use to retrieve swing windows.
+     * @param domain             The domain to read settings from.
      */
     @Inject
     public TreeFrameManager(
             final WindowManager windowManager,
             @GlobalConfig final AggregateConfigProvider globalConfig,
             final ColourManager colourManager,
-            final Provider<MainFrame> mainFrameProvider,
+            final ActiveFrameManager activeFrameManager,
             final SwingWindowFactory windowFactory,
             @PluginDomain(SwingController.class) final String domain) {
         this.windowFactory = windowFactory;
         this.nodes = new HashMap<>();
         this.config = globalConfig;
         this.colourManager = colourManager;
+        this.activeFrameManager = activeFrameManager;
 
         UIUtilities.invokeLater(new Runnable() {
             @Override
             public void run() {
                 model = new TreeViewModel(config, new TreeViewNode(null, null));
-                tree = new Tree(TreeFrameManager.this, model, mainFrameProvider, globalConfig,
+                tree = new Tree(TreeFrameManager.this, model, activeFrameManager, globalConfig,
                         windowFactory, domain);
                 tree.setCellRenderer(new TreeViewTreeCellRenderer(config, colourManager,
                         TreeFrameManager.this));
                 config.addChangeListener("ui", "foregroundcolour", TreeFrameManager.this);
             }
         });
-        this.mainFrameProvider = mainFrameProvider;
     }
 
     @Override
                 if (scroller != null) {
                     scroller.unregister();
                 }
-                scroller = new TreeTreeScroller(mainFrameProvider, windowFactory, tree);
+                scroller = new TreeTreeScroller(activeFrameManager, windowFactory, tree);
 
                 for (FrameContainer window : windowManager.getRootWindows()) {
                     addWindow(null, window);
                     }
                 }
 
-                final MainFrame mainFrame = mainFrameProvider.get();
-                if (mainFrame != null && mainFrame.getActiveFrame() != null) {
-                    selectionChanged(mainFrame.getActiveFrame());
+                if (activeFrameManager.getActiveFrame() != null) {
+                    selectionChanged(activeFrameManager.getActiveFrame());
                 }
             }
         });

src/com/dmdirc/addons/ui_swing/framemanager/tree/TreeTreeScroller.java

 
 package com.dmdirc.addons.ui_swing.framemanager.tree;
 
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.SwingWindowFactory;
 import com.dmdirc.addons.ui_swing.components.TreeScroller;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
 
-import javax.inject.Provider;
 import javax.swing.tree.TreePath;
 
 /**
  */
 public class TreeTreeScroller extends TreeScroller {
 
-    /** Main frame provider. */
-    private final Provider<MainFrame> mainFrameProvider;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
     /** Factory to use to retrieve swing windows. */
     private final SwingWindowFactory windowFactory;
 
     /**
      * Creates a new Tree scroller for the tree view.
      *
-     * @param mainFrameProvider Main frame provider.
+     * @param activeFrameManager The active window manager
      * @param windowFactory     Factory to use to retrieve swing windows.
      * @param tree              Tree view tree
      */
     public TreeTreeScroller(
-            final Provider<MainFrame> mainFrameProvider,
+            final ActiveFrameManager activeFrameManager,
             final SwingWindowFactory windowFactory,
             final Tree tree) {
         super(tree);
 
-        this.mainFrameProvider = mainFrameProvider;
+        this.activeFrameManager = activeFrameManager;
         this.windowFactory = windowFactory;
     }
 
         }
         super.setPath(path);
 
-        mainFrameProvider.get().setActiveFrame(windowFactory.getSwingWindow(
+        activeFrameManager.setActiveFrame(windowFactory.getSwingWindow(
                 ((TreeViewNode) path.getLastPathComponent()).getWindow()));
     }
 

src/com/dmdirc/addons/ui_swing/framemanager/windowmenu/FrameContainerMenu.java

 package com.dmdirc.addons.ui_swing.framemanager.windowmenu;
 
 import com.dmdirc.FrameContainer;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.SelectionListener;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.interfaces.FrameInfoListener;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
-import javax.inject.Provider;
 import javax.swing.JMenu;
 import javax.swing.SwingUtilities;
 
 
     /** A version number for this class. */
     private static final long serialVersionUID = 1;
-    /** The provider to get the main frame to set the active frame. */
-    private final Provider<MainFrame> mainFrameProvider;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
     /** The swing frame. */
     private final TextFrame window;
     /** Wrapped frame. */
     /**
      * Instantiates a new FrameContainer menu item wrapping the specified frame.
      *
-     * @param mainFrameProvider   The provider to get the main frame to set the active frame.
-     * @param globalConfig The config to read settings from
-     * @param domain       The domain to read settings from
-     * @param window       The swing window being wrapped
-     * @param frame        Wrapped frame
+     * @param activeFrameManager The active window manager
+     * @param globalConfig       The config to read settings from
+     * @param domain             The domain to read settings from
+     * @param window             The swing window being wrapped
+     * @param frame              Wrapped frame
      */
     public FrameContainerMenu(
-            final Provider<MainFrame> mainFrameProvider,
+            final ActiveFrameManager activeFrameManager,
             final AggregateConfigProvider globalConfig,
             final String domain,
             final TextFrame window,
             final FrameContainer frame) {
         super(frame.getName());
 
-        this.mainFrameProvider = mainFrameProvider;
+        this.activeFrameManager = activeFrameManager;
         this.window = window;
         this.frame = frame;
 
      */
     @Override
     public void actionPerformed(final ActionEvent e) {
-        mainFrameProvider.get().setActiveFrame(window);
+        activeFrameManager.setActiveFrame(window);
     }
 
     @Override

src/com/dmdirc/addons/ui_swing/framemanager/windowmenu/FrameContainerMenuItem.java

 package com.dmdirc.addons.ui_swing.framemanager.windowmenu;
 
 import com.dmdirc.FrameContainer;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.SelectionListener;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.interfaces.FrameInfoListener;
 import com.dmdirc.ui.messages.Styliser;
 
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
-import javax.inject.Provider;
 import javax.swing.JMenuItem;
 import javax.swing.SwingUtilities;
 
 
     /** A version number for this class. */
     private static final long serialVersionUID = 1;
-    /** The provider to retrieve the mainframe to set active frames. */
-    private final Provider<MainFrame> mainFrameProvider;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
     /** Wrapped frame. */
     private final FrameContainer frame;
     /** Swing window. */
     /**
      * Instantiates a new FrameContainer menu item wrapping the specified frame.
      *
-     * @param mainFrameProvider The provider to retrieve the mainframe to set active frames.
-     * @param frame             Wrapped frame
-     * @param window            The window this menu item corresponds to.
-     * @param manager           Parent window menu frame manager.
+     * @param activeFrameManager The active window manager
+     * @param frame              Wrapped frame
+     * @param window             The window this menu item corresponds to.
+     * @param manager            Parent window menu frame manager.
      */
     public FrameContainerMenuItem(
-            final Provider<MainFrame> mainFrameProvider,
+            final ActiveFrameManager activeFrameManager,
             final FrameContainer frame,
             final TextFrame window,
             final WindowMenuFrameManager manager) {
         super(frame.getName(), frame.getIconManager().getIcon(frame.getIcon()));
 
-        this.mainFrameProvider = mainFrameProvider;
+        this.activeFrameManager = activeFrameManager;
         this.frame = frame;
         this.window = window;
         this.manager = manager;
 
     @Override
     public void actionPerformed(final ActionEvent e) {
-        mainFrameProvider.get().setActiveFrame(window);
+        activeFrameManager.setActiveFrame(window);
     }
 
     @Override

src/com/dmdirc/addons/ui_swing/framemanager/windowmenu/WindowMenuFrameManager.java

 import com.dmdirc.ClientModule.GlobalConfig;
 import com.dmdirc.FrameContainer;
 import com.dmdirc.FrameContainerComparator;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.SelectionListener;
 import com.dmdirc.addons.ui_swing.SwingController;
 import com.dmdirc.addons.ui_swing.SwingWindowFactory;
 import com.dmdirc.addons.ui_swing.SwingWindowListener;
 import com.dmdirc.addons.ui_swing.UIUtilities;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.plugins.PluginDomain;
 import com.dmdirc.ui.IconManager;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import javax.inject.Inject;
-import javax.inject.Provider;
 import javax.inject.Singleton;
 import javax.swing.AbstractButton;
 import javax.swing.JMenu;
     private final JSeparator separator;
     /** Enabled menu items? */
     private final AtomicBoolean enabledMenuItems = new AtomicBoolean(false);
-    /** Swing controller. */
-    private final SwingController controller;
     /** Window to menu map. */
     private final Map<FrameContainer, FrameContainerMenu> menus;
     private final Map<FrameContainer, FrameContainerMenuItem> items;
     private final Map<FrameContainer, FrameContainerMenuItem> menuItems;
-
-    private final Provider<MainFrame> mainFrame;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
     private final AggregateConfigProvider globalConfig;
     private final String domain;
 
     /**
      * Creates a new instance of WindowMenuFrameManager.
      *
-     * @param controller    Swing controller
-     * @param iconManager   Icon manager to use for window icons.
-     * @param globalConfig  Config to read settings from.
-     * @param domain        Domain to read settings from.
-     * @param windowFactory The window factory to use to create and listen for windows.
-     * @param mainFrame     The frame that owns this manager
+     * @param controller         Swing controller
+     * @param iconManager        Icon manager to use for window icons.
+     * @param globalConfig       Config to read settings from.
+     * @param domain             Domain to read settings from.
+     * @param windowFactory      The window factory to use to create and listen for windows.
+     * @param activeFrameManager The active window manager
      */
     @Inject
     public WindowMenuFrameManager(
             @GlobalConfig final AggregateConfigProvider globalConfig,
             @PluginDomain(SwingController.class) final String domain,
             final SwingWindowFactory windowFactory,
-            final Provider<MainFrame> mainFrame) {
-        this.controller = controller;
+            final ActiveFrameManager activeFrameManager) {
         this.globalConfig = globalConfig;
         this.domain = domain;
-        this.mainFrame = mainFrame;
+        this.activeFrameManager = activeFrameManager;
 
         menus = Collections.synchronizedMap(
                 new HashMap<FrameContainer, FrameContainerMenu>());
 
         itemCount = getMenuComponentCount();
 
-        mainFrame.get().addSelectionListener(this);
+        activeFrameManager.addSelectionListener(this);
 
         new WindowMenuScroller(this, globalConfig, domain, itemCount);
         checkMenuItems();
                         @Override
                         public FrameContainerMenuItem call() {
                             return new FrameContainerMenuItem(
-                                    mainFrame,
+                                    activeFrameManager,
                                     window.getContainer(),
                                     window,
                                     WindowMenuFrameManager.this);
                         @Override
                         public FrameContainerMenuItem call() {
                             return new FrameContainerMenuItem(
-                                    mainFrame,
+                                    activeFrameManager,
                                     window.getContainer(),
                                     window,
                                     WindowMenuFrameManager.this);
                             @Override
                             public FrameContainerMenu call() {
                                 return new FrameContainerMenu(
-                                        mainFrame,
+                                        activeFrameManager,
                                         globalConfig,
                                         domain,
                                         parent,
                                     getContainer()),
                                     menus.get(parent.getContainer()),
                                     new FrameContainerMenuItem(
-                                            mainFrame,
+                                            activeFrameManager,
                                             parent.getContainer(),
                                             parent,
                                             WindowMenuFrameManager.this));
     @Override
     public void actionPerformed(final ActionEvent e) {
         if (enabledMenuItems.get() && e.getActionCommand().equals("Close")) {
-            mainFrame.get().getActiveFrame().getContainer().close();
+            activeFrameManager.getActiveFrame().getContainer().close();
         }
     }
 

src/com/dmdirc/addons/ui_swing/injection/SwingModule.java

 import com.dmdirc.addons.ui_swing.framemanager.FrameManager;
 import com.dmdirc.addons.ui_swing.framemanager.FrameManagerProvider;
 import com.dmdirc.addons.ui_swing.framemanager.tree.TreeFrameManagerProvider;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.config.prefs.PreferencesDialogModel;
 import com.dmdirc.interfaces.LifecycleController;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
         });
     }
 
+    @Provides
+    @Singleton
+    public ActiveFrameManager getActiveFrameManager(final MainFrame mainFrame) {
+        return mainFrame;
+    }
+
     @Provides
     @Singleton
     public SwingStatusBar getSwingStatusBar(

src/com/dmdirc/addons/windowstatus/WindowStatusManager.java

 import com.dmdirc.Channel;
 import com.dmdirc.FrameContainer;
 import com.dmdirc.Query;
-import com.dmdirc.addons.ui_swing.MainFrame;
 import com.dmdirc.addons.ui_swing.SelectionListener;
 import com.dmdirc.addons.ui_swing.UIUtilities;
 import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
 import com.dmdirc.addons.ui_swing.components.statusbar.SwingStatusBar;
+import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.interfaces.config.ConfigChangeListener;
 import com.dmdirc.interfaces.config.IdentityController;
  */
 public class WindowStatusManager implements ConfigChangeListener, SelectionListener {
 
-    /** Main frame. */
-    private final MainFrame mainFrame;
+    /** Active frame manager. */
+    private final ActiveFrameManager activeFrameManager;
     /** Status bar we're adding to. */
     private final SwingStatusBar statusBar;
     /** Identity controller to read settings from. */
     private String nonePrefix;
 
     @Inject
-    public WindowStatusManager(final MainFrame mainFrame, final SwingStatusBar statusBar,
+    public WindowStatusManager(final ActiveFrameManager activeFrameManager,
+            final SwingStatusBar statusBar,
             final IdentityController identityController,
             @PluginDomain(WindowStatusPlugin.class) final String domain) {
         this.domain = domain;
-        this.mainFrame = mainFrame;
+        this.activeFrameManager = activeFrameManager;
         this.statusBar = statusBar;
         this.identityController = identityController;
     }
             }
         });
         statusBar.addComponent(panel);
-        mainFrame.addSelectionListener(this);
+        activeFrameManager.addSelectionListener(this);
         identityController.getGlobalConfiguration().addChangeListener(domain, this);
         updateCache();
     }
      * Unloads the plugin.
      */
     public void onUnload() {
-        mainFrame.removeSelectionListener(this);
+        activeFrameManager.removeSelectionListener(this);
         statusBar.removeComponent(panel);
         panel = null;
     }
 
     /** Update the window status using the current active window. */
     public void updateStatus() {
-        final TextFrame active = mainFrame.getActiveFrame();
+        final TextFrame active = activeFrameManager.getActiveFrame();
 
         if (active != null) {
             updateStatus(active.getContainer());