Tear Server and FrameContainer apart.

src/com/dmdirc/FrameContainer.java

 import com.dmdirc.events.FrameIconChangedEvent;
 import com.dmdirc.events.FrameNameChangedEvent;
 import com.dmdirc.events.FrameTitleChangedEvent;
+import com.dmdirc.interfaces.Connection;
 import com.dmdirc.interfaces.InputModel;
 import com.dmdirc.interfaces.WindowModel;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
  * The frame container implements basic methods that should be present in all objects that handle a
  * frame.
  */
-public abstract class FrameContainer implements WindowModel {
+public class FrameContainer implements WindowModel {
 
     /** Listeners not yet using ListenerSupport. */
     protected final ListenerList listeners = new ListenerList();
     private BackBuffer backBuffer;
     /** The input model for this container. */
     private Optional<InputModel> inputModel = Optional.empty();
+    /** The connection associated with this model. */
+    private Optional<Connection> connection = Optional.empty();
 
     /**
      * Instantiate new frame container.
      */
-    protected FrameContainer(
+    public FrameContainer(
             final String icon,
             final String name,
             final String title,
         return unreadStatusManager;
     }
 
+    public void setConnection(@Nullable final Connection connection) {
+        this.connection = Optional.ofNullable(connection);
+    }
+
+    @Override
+    public Optional<Connection> getConnection() {
+        return connection;
+    }
+
 }

src/com/dmdirc/Server.java

 package com.dmdirc;
 
 import com.dmdirc.config.profiles.Profile;
+import com.dmdirc.events.FrameClosingEvent;
 import com.dmdirc.events.ServerConnectErrorEvent;
 import com.dmdirc.events.ServerConnectedEvent;
 import com.dmdirc.events.ServerConnectingEvent;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import net.engio.mbassy.listener.Handler;
+
 import static com.dmdirc.util.LogUtils.APP_ERROR;
 import static com.google.common.base.Preconditions.checkNotNull;
 
  * The Server class represents the client's view of a server. It maintains a list of all channels,
  * queries, etc, and handles parser callbacks pertaining to the server.
  */
-public class Server extends FrameContainer implements Connection {
+public class Server implements Connection {
 
     private static final Logger LOG = LoggerFactory.getLogger(Server.class);
     /** The name of the general domain. */
     private final HighlightManager highlightManager;
     /** Listener to use for config changes. */
     private final ConfigChangeListener configListener = (domain, key) -> updateTitle();
+    private final FrameContainer windowModel;
     /** The future used when a reconnect timer is scheduled. */
     private ScheduledFuture<?> reconnectTimerFuture;
 
             @Nonnull final Profile profile,
             final BackBufferFactory backBufferFactory,
             final UserManager userManager) {
-        super("server-disconnected",
-                getHost(uri),
-                getHost(uri),
-                configMigrator.getConfigProvider(),
-                backBufferFactory,
-                eventBus,
-                Arrays.asList(
-                        WindowComponent.TEXTAREA.getIdentifier(),
-                        WindowComponent.INPUTFIELD.getIdentifier(),
-                        WindowComponent.CERTIFICATE_VIEWER.getIdentifier()));
+        // TODO: Pass this in
+        windowModel =
+                new FrameContainer("server-disconnected", getHost(uri), getHost(uri),
+                        configMigrator.getConfigProvider(), backBufferFactory, eventBus,
+                        Arrays.asList(WindowComponent.TEXTAREA.getIdentifier(),
+                                WindowComponent.INPUTFIELD.getIdentifier(),
+                                WindowComponent.CERTIFICATE_VIEWER.getIdentifier()));
+        windowModel.setConnection(this);
 
         this.parserFactory = parserFactory;
         this.identityFactory = identityFactory;
         this.inviteManager = new InviteManagerImpl(this);
 
         awayMessage = Optional.empty();
-        eventHandler = new ServerEventHandler(this, groupChatManager, getEventBus());
+        eventHandler = new ServerEventHandler(this, groupChatManager, windowModel.getEventBus());
 
         this.address = uri;
         this.profile = profile;
 
         updateIcon();
 
-        getConfigManager().addChangeListener("formatter", "serverName", configListener);
-        getConfigManager().addChangeListener("formatter", "serverTitle", configListener);
+        windowModel.getConfigManager().addChangeListener("formatter", "serverName", configListener);
+        windowModel.getConfigManager().addChangeListener("formatter", "serverTitle", configListener);
 
-        initBackBuffer();
-        this.highlightManager = new HighlightManager(getConfigManager(),
-                new ColourManager(getConfigManager()));
+        windowModel.initBackBuffer();
+        this.highlightManager = new HighlightManager(windowModel.getConfigManager(),
+                new ColourManager(windowModel.getConfigManager()));
         highlightManager.init();
-        getEventBus().subscribe(highlightManager);
+        windowModel.getEventBus().subscribe(highlightManager);
+        windowModel.getEventBus().subscribe(this);
     }
 
     /**
                     return;
                 case CONNECTED:
                 case CONNECTING:
-                    disconnect(getConfigManager().getOption(DOMAIN_GENERAL, "quitmessage"));
+                    disconnect(windowModel.getConfigManager()
+                            .getOption(DOMAIN_GENERAL, "quitmessage"));
                 case DISCONNECTING:
                     while (!myState.getState().isDisconnected()) {
                         try {
                 parser = Optional.ofNullable(buildParser());
 
                 if (!parser.isPresent()) {
-                    getEventBus().publishAsync(
+                    windowModel.getEventBus().publishAsync(
                             new ServerUnknownProtocolEvent(this, address.getScheme()));
                     return;
                 }
             }
         }
 
-        getEventBus().publish(new ServerConnectingEvent(this, address));
+        windowModel.getEventBus().publish(new ServerConnectingEvent(this, address));
     }
 
     @Override
 
     @Override
     public void reconnect() {
-        reconnect(getConfigManager().getOption(DOMAIN_GENERAL, "reconnectmessage"));
+        reconnect(windowModel.getConfigManager().getOption(DOMAIN_GENERAL, "reconnectmessage"));
     }
 
     @Override
     public void disconnect() {
-        disconnect(getConfigManager().getOption(DOMAIN_GENERAL, "quitmessage"));
+        disconnect(windowModel.getConfigManager().getOption(DOMAIN_GENERAL, "quitmessage"));
     }
 
     @Override
                 parserLock.readLock().unlock();
             }
 
-            if (getConfigManager().getOptionBool(DOMAIN_GENERAL, "closequeriesonquit")) {
+            if (windowModel.getConfigManager()
+                    .getOptionBool(DOMAIN_GENERAL, "closequeriesonquit")) {
                 closeQueries();
             }
         }
             }
 
             final int delay = Math.max(1000,
-                    getConfigManager().getOptionInt(DOMAIN_GENERAL, "reconnectdelay"));
+                    windowModel.getConfigManager().getOptionInt(DOMAIN_GENERAL, "reconnectdelay"));
 
-            getEventBus().publishAsync(new ServerReconnectScheduledEvent(this, delay / 1000));
+            windowModel.getEventBus().publishAsync(
+                    new ServerReconnectScheduledEvent(this, delay / 1000));
 
             reconnectTimerFuture = executorService.schedule(() -> {
                 synchronized (myStateLock) {
             if (!getState().isDisconnected()) {
                 newQuery.reregister();
             }
-            getInputModel().get().getTabCompleter().addEntry(TabCompletionType.QUERY_NICK, nick);
+            windowModel.getInputModel().get().getTabCompleter()
+                    .addEntry(TabCompletionType.QUERY_NICK, nick);
             queries.put(lnick, newQuery);
         }
 
 
     @Override
     public void updateQuery(final Query query, final String oldNick, final String newNick) {
-        getInputModel().get().getTabCompleter().removeEntry(TabCompletionType.QUERY_NICK, oldNick);
-        getInputModel().get().getTabCompleter().addEntry(TabCompletionType.QUERY_NICK, newNick);
+        windowModel.getInputModel().get().getTabCompleter()
+                .removeEntry(TabCompletionType.QUERY_NICK, oldNick);
+        windowModel.getInputModel().get().getTabCompleter()
+                .addEntry(TabCompletionType.QUERY_NICK, newNick);
 
         queries.put(converter.toLowerCase(newNick), query);
         queries.remove(converter.toLowerCase(oldNick));
 
     @Override
     public void delQuery(final Query query) {
-        getInputModel().get().getTabCompleter().removeEntry(
+        windowModel.getInputModel().get().getTabCompleter().removeEntry(
                 TabCompletionType.QUERY_NICK, query.getNickname());
         queries.remove(converter.toLowerCase(query.getNickname()));
     }
      */
     @Nullable
     private Parser buildParser() {
-        final Parser myParser = parserFactory.getParser(profile, address, getConfigManager())
+        final Parser myParser = parserFactory
+                .getParser(profile, address, windowModel.getConfigManager())
                 .orElse(null);
 
         if (myParser != null) {
 
         if (myParser instanceof SecureParser) {
             final CertificateManager certificateManager =
-                    new CertificateManager(this, address.getHost(), getConfigManager(),
-                            userSettings, getEventBus());
+                    new CertificateManager(this, address.getHost(), windowModel.getConfigManager(),
+                            userSettings, windowModel.getEventBus());
             final SecureParser secureParser = (SecureParser) myParser;
             secureParser.setTrustManagers(certificateManager);
             secureParser.setKeyManagers(certificateManager.getKeyManager());
         final String icon = myState.getState() == ServerState.CONNECTED
                 ? protocolDescription.get().isSecure(address)
                 ? "secure-server" : "server" : "server-disconnected";
-        setIcon(icon);
+        windowModel.setIcon(icon);
     }
 
     /**
         return myState;
     }
 
-    @Override
-    public void close() {
-        synchronized (myStateLock) {
-            eventHandler.unregisterCallbacks();
-            getConfigManager().removeListener(configListener);
-            highlightManager.stop();
-            getEventBus().unsubscribe(highlightManager);
-            executorService.shutdown();
-
-            disconnect();
+    @Handler
+    private void handleClose(final FrameClosingEvent event) {
+        if (event.getContainer() == windowModel) {
+            synchronized (myStateLock) {
+                eventHandler.unregisterCallbacks();
+                windowModel.getConfigManager().removeListener(configListener);
+                highlightManager.stop();
+                windowModel.getEventBus().unsubscribe(highlightManager);
+                executorService.shutdown();
 
-            myState.transition(ServerState.CLOSING);
-        }
+                disconnect();
 
-        groupChatManager.closeAll();
-        closeQueries();
-        inviteManager.removeInvites();
+                myState.transition(ServerState.CLOSING);
+            }
 
-        super.close();
+            groupChatManager.closeAll();
+            closeQueries();
+            inviteManager.removeInvites();
+            windowModel.getEventBus().unsubscribe(this);
+        }
     }
 
     @Override
     public WindowModel getWindowModel() {
-        return this;
+        return windowModel;
     }
 
     @Override
     public void sendCTCPReply(final String source, final String type, final String args) {
         if ("VERSION".equalsIgnoreCase(type)) {
             parser.get().sendCTCPReply(source, "VERSION",
-                    "DMDirc " + getConfigManager().getOption("version", "version") +
+                    "DMDirc " + windowModel.getConfigManager().getOption("version", "version") +
                             " - https://www.dmdirc.com/");
         } else if ("PING".equalsIgnoreCase(type)) {
             parser.get().sendCTCPReply(source, "PING", args);
         }
     }
 
-    @Override
-    public Optional<Connection> getConnection() {
-        return Optional.of(this);
-    }
-
     @Override
     public void updateTitle() {
         synchronized (myStateLock) {
                     getLocalUser().map(User::getNickname).orElse("Unknown")
                 };
 
-                setName(Formatter.formatMessage(getConfigManager(),
+                windowModel.setName(Formatter.formatMessage(windowModel.getConfigManager(),
                         "serverName", arguments));
-                setTitle(Formatter.formatMessage(getConfigManager(),
+                windowModel.setTitle(Formatter.formatMessage(windowModel.getConfigManager(),
                         "serverTitle", arguments));
             } finally {
                 parserLock.readLock().unlock();
             return;
         }
 
-        getEventBus().publish(new ServerDisconnectedEvent(this));
+        windowModel.getEventBus().publish(new ServerDisconnectedEvent(this));
 
         eventHandler.unregisterCallbacks();
 
 
             updateIcon();
 
-            if (getConfigManager().getOptionBool(DOMAIN_GENERAL, "closequeriesondisconnect")) {
+            if (windowModel.getConfigManager()
+                    .getOptionBool(DOMAIN_GENERAL, "closequeriesondisconnect")) {
                 closeQueries();
             }
 
             inviteManager.removeInvites();
             updateAwayState(Optional.empty());
 
-            if (getConfigManager().getOptionBool(DOMAIN_GENERAL, "reconnectondisconnect")
+            if (windowModel.getConfigManager()
+                    .getOptionBool(DOMAIN_GENERAL, "reconnectondisconnect")
                     && myState.getState() == ServerState.TRANSIENTLY_DISCONNECTED) {
                 doDelayedReconnect();
             }
 
             updateIcon();
 
-            getEventBus().publish(new ServerConnectErrorEvent(this, getErrorDescription
-                    (errorInfo)));
+            windowModel.getEventBus().publish(new ServerConnectErrorEvent(this,
+                    getErrorDescription(errorInfo)));
 
-            if (getConfigManager().getOptionBool(DOMAIN_GENERAL, "reconnectonconnectfailure")) {
+            if (windowModel.getConfigManager()
+                    .getOptionBool(DOMAIN_GENERAL, "reconnectonconnectfailure")) {
                 doDelayedReconnect();
             }
         }
             groupChatManager.handleConnected();
         }
 
-        getEventBus().publish(new ServerConnectedEvent(this));
+        windowModel.getEventBus().publish(new ServerConnectedEvent(this));
     }
 
     @Override
     @Override
     public void updateIgnoreList() {
         ignoreList.clear();
-        ignoreList.addAll(getConfigManager().getOptionList("network", "ignorelist"));
+        ignoreList.addAll(windowModel.getConfigManager().getOptionList("network", "ignorelist"));
     }
 
     @Override

src/com/dmdirc/ServerEventHandler.java

     @Handler
     public void onPingFailed(final PingFailureEvent event) {
         eventBus.publishAsync(new StatusBarMessageEvent(new StatusMessage(
-                "No ping reply from " + owner.getName() + " for over " +
+                "No ping reply from " + owner.getWindowModel().getName() + " for over " +
                         (int) Math.floor(event.getParser().getPingTime() / 1000.0) + " seconds.",
-                owner.getConfigManager())));
+                owner.getWindowModel().getConfigManager())));
 
         eventBus.publishAsync(new ServerNoPingEvent(owner, event.getParser().getPingTime()));
 
         if (event.getParser().getPingTime()
-                >= owner.getConfigManager().getOptionInt("server", "pingtimeout")) {
+                >= owner.getWindowModel().getConfigManager().getOptionInt("server", "pingtimeout")) {
             LOG.warn("Server appears to be stoned, reconnecting");
             eventBus.publishAsync(new ServerStonedEvent(owner));
             owner.reconnect();

src/com/dmdirc/ServerFactoryImpl.java

                 identityFactory, queryFactory.get(), eventBus,
                 messageEncoderFactory, userSettings, groupChatManagerFactory, executorService,
                 uri, profile, backBufferFactory, userManager);
-        server.setInputModel(new DefaultInputModel(
+        // TODO: Yuck!
+        ((FrameContainer) server.getWindowModel()).setInputModel(new DefaultInputModel(
                 server::sendLine,
                 new ServerCommandParser(
-                        server.getConfigManager(),
+                        server.getWindowModel().getConfigManager(),
                         commandController.get(),
                         eventBus,
                         server),

src/com/dmdirc/ServerManager.java

                 uri,
                 profile);
         registerServer(server);
-        windowManager.addWindow(server);
+        windowManager.addWindow(server.getWindowModel());
         return server;
     }
 
     public void closeAll(final String message) {
         for (Server server : servers) {
             server.disconnect(message);
-            server.close();
+            server.getWindowModel().close();
         }
     }
 

test/com/dmdirc/ServerManagerTest.java

 import com.dmdirc.config.profiles.Profile;
 import com.dmdirc.config.profiles.ProfileManager;
 import com.dmdirc.interfaces.GroupChatManager;
+import com.dmdirc.interfaces.WindowModel;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigProviderMigrator;
 import com.dmdirc.interfaces.config.IdentityFactory;
     @Mock private WindowManager windowManager;
     @Mock private ServerFactoryImpl serverFactoryImpl;
     @Mock private Server server;
+    @Mock private WindowModel windowModel;
     @Mock private GroupChatManager groupChatManager;
     @Mock private DMDircMBassador eventBus;
     @Mock private Channel channel;
 
         when(server.getState()).thenReturn(ServerState.DISCONNECTED);
         when(server.getGroupChatManager()).thenReturn(groupChatManager);
+        when(server.getWindowModel()).thenReturn(windowModel);
 
         when(profileManager.getProfiles()).thenReturn(Collections.singletonList(profile));
         when(profileManager.getDefault()).thenReturn(profile);
     @Test
     public void testCloseAllWithMessage() {
         final Server serverA = mock(Server.class);
+        final WindowModel model = mock(WindowModel.class);
+        when(serverA.getWindowModel()).thenReturn(model);
         serverManager.registerServer(serverA);
         serverManager.closeAll("message here");
         verify(serverA).disconnect("message here");
-        verify(serverA).close();
+        verify(model).close();
     }
 
     @Test
     @Test
     public void testAddsNewServersToWindowManager() {
         serverManager.connectToAddress(URI.create("irc://fobar"));
-        verify(windowManager).addWindow(server);
+        verify(windowManager).addWindow(windowModel);
     }
 
 }