Merge remote-tracking branch 'refs/remotes/DMDirc/master'

activewindow/build.gradle

-dependencies {
-  compile plugin('ui_swing')
-}

activewindow/plugin.config

-# This is a DMDirc configuration file.
-
-# This section indicates which sections below take key/value
-# pairs, rather than a simple list. It should be placed above
-# any sections that take key/values.
-keysections:
-  metadata
-  updates
-  version
-  requires
-
-metadata:
-  author=Greboid <greg@dmdirc.com>
-  mainclass=com.dmdirc.addons.activewindow.ActiveWindowPlugin
-  description=Provides an active window command to the swing UI
-  name=activewindow
-  nicename=Active Window
-
-updates:
-  id=66
-
-requires:
-  parent=ui_swing
-
-version:
-  friendly=1.0
-
-provides:
-  active command
-
-required-services:
-  swing ui

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

-/*
- * Copyright (c) 2006-2015 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package com.dmdirc.addons.activewindow;
-
-import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
-import com.dmdirc.commandparser.BaseCommandInfo;
-import com.dmdirc.commandparser.CommandArguments;
-import com.dmdirc.commandparser.CommandInfo;
-import com.dmdirc.commandparser.CommandType;
-import com.dmdirc.commandparser.commands.Command;
-import com.dmdirc.commandparser.commands.IntelligentCommand;
-import com.dmdirc.commandparser.commands.context.CommandContext;
-import com.dmdirc.interfaces.CommandController;
-import com.dmdirc.interfaces.WindowModel;
-import com.dmdirc.ui.input.AdditionalTabTargets;
-import com.dmdirc.ui.input.TabCompleterUtils;
-
-import javax.annotation.Nonnull;
-import javax.inject.Inject;
-
-/**
- * Executes another command as if it were executed in the active window.
- */
-public class ActiveCommand extends Command implements IntelligentCommand {
-
-    /** A command info object for this command. */
-    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);
-    /** Active frame manager. */
-    private final ActiveFrameManager activeFrameManager;
-    /** Tab-completer utilities. */
-    private final TabCompleterUtils tabUtils;
-
-    /**
-     * Creates a new active command.
-     *
-     * @param controller          The controller to use for command information.
-     * @param activeFrameManager The active window manager
-     */
-    @Inject
-    public ActiveCommand(
-            final CommandController controller,
-            final ActiveFrameManager activeFrameManager,
-            final TabCompleterUtils tabUtils) {
-        super(controller);
-
-        this.activeFrameManager = activeFrameManager;
-        this.tabUtils = tabUtils;
-    }
-
-    @Override
-    public void execute(@Nonnull final WindowModel origin,
-            final CommandArguments args, final CommandContext context) {
-        activeFrameManager.getActiveFrame().ifPresent(f -> f.getContainer().getCommandParser()
-                .parseCommand(f.getContainer(), args.getArgumentsAsString()));
-    }
-
-    @Override
-    public AdditionalTabTargets getSuggestions(final int arg,
-            final IntelligentCommandContext context) {
-        return tabUtils.getIntelligentResults(arg, context, 0);
-    }
-
-}

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

-/*
- * Copyright (c) 2006-2015 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package com.dmdirc.addons.activewindow;
-
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
-
-import javax.inject.Inject;
-
-/**
- * Manages the active window sink.
- */
-public class ActiveWindowManager {
-
-    /** The message sink to register and unregister. */
-    private final ActiveWindowMessageSink sink;
-    /** The manager to add and remove the sink from. */
-    private final MessageSinkManager sinkManager;
-
-    /**
-     * Creates a new instance of {@link ActiveWindowManager}.
-     *
-     * @param sinkManager The manager to add and remove sinks from.
-     * @param sink        The sink to be added and removed.
-     */
-    @Inject
-    public ActiveWindowManager(
-            final MessageSinkManager sinkManager,
-            final ActiveWindowMessageSink sink) {
-        this.sink = sink;
-        this.sinkManager = sinkManager;
-    }
-
-    /**
-     * Registers the sink with the manager.
-     */
-    public void register() {
-        sinkManager.addSink(sink);
-    }
-
-    /**
-     * Unregisters the sink from the manager.
-     */
-    public void unregister() {
-        sinkManager.removeSink(sink);
-    }
-
-}

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

-/*
- * Copyright (c) 2006-2015 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package com.dmdirc.addons.activewindow;
-
-import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
-import com.dmdirc.interfaces.WindowModel;
-import com.dmdirc.ui.messages.sink.MessageSink;
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
-
-import java.util.Date;
-import java.util.regex.Pattern;
-
-import javax.inject.Inject;
-
-/**
- * A message sink which passes messages onto the active swing window.
- */
-public class ActiveWindowMessageSink implements MessageSink {
-
-    /** The pattern to use to match this sink. */
-    private static final Pattern PATTERN = Pattern.compile("active");
-    /** Active frame manager. */
-    private final ActiveFrameManager activeFrameManager;
-
-    /**
-     * Creates a new ActiveWindowMessageSink for the specified mainframe.
-     *
-     * @param activeFrameManager Active frame manager.
-     */
-    @Inject
-    public ActiveWindowMessageSink(final ActiveFrameManager activeFrameManager) {
-        this.activeFrameManager = activeFrameManager;
-    }
-
-    @Override
-    public Pattern getPattern() {
-        return PATTERN;
-    }
-
-    @Override
-    public void handleMessage(final MessageSinkManager dispatcher,
-            final WindowModel source, final String[] patternMatches,
-            final Date date, final String messageType, final Object... args) {
-        activeFrameManager.getActiveFrame()
-                .ifPresent(f -> f.getContainer().addLine(messageType, date, args));
-    }
-
-}

activewindow/test/com/dmdirc/addons/activewindow/ActiveCommandTest.java

-/*
- * Copyright (c) 2006-2015 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package com.dmdirc.addons.activewindow;
-
-import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
-import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
-import com.dmdirc.commandparser.CommandArguments;
-import com.dmdirc.commandparser.commands.IntelligentCommand.IntelligentCommandContext;
-import com.dmdirc.commandparser.commands.context.CommandContext;
-import com.dmdirc.commandparser.parsers.CommandParser;
-import com.dmdirc.interfaces.CommandController;
-import com.dmdirc.interfaces.WindowModel;
-import com.dmdirc.ui.input.TabCompleterUtils;
-
-import java.util.Optional;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class ActiveCommandTest {
-
-    @Mock private IntelligentCommandContext intelligentCommandContext;
-    @Mock private CommandParser commandParser;
-    @Mock private CommandController commandController;
-    @Mock private ActiveFrameManager activeFrameManager;
-    @Mock private TabCompleterUtils tabCompleterUtils;
-    @Mock private WindowModel frameContainer;
-    @Mock private TextFrame textFrame;
-    @Mock private CommandArguments commandArguments;
-    @Mock private CommandContext commandContext;
-    private ActiveCommand activeCommand;
-
-    @Before
-    public void setUp() throws Exception {
-        when(textFrame.getContainer()).thenReturn(frameContainer);
-        when(frameContainer.getCommandParser()).thenReturn(commandParser);
-        when(commandArguments.getArgumentsAsString()).thenReturn("some arguments");
-        activeCommand = new ActiveCommand(commandController, activeFrameManager, tabCompleterUtils);
-    }
-
-    @Test
-    public void testExecute_NoActive() throws Exception {
-        when(activeFrameManager.getActiveFrame()).thenReturn(Optional.empty());
-        activeCommand.execute(frameContainer, commandArguments, commandContext);
-        verify(commandParser, never())
-                .parseCommand(frameContainer, commandArguments.getArgumentsAsString());
-    }
-
-    @Test
-    public void testExecute_Active() throws Exception {
-        when(activeFrameManager.getActiveFrame()).thenReturn(Optional.of(textFrame));
-        activeCommand.execute(frameContainer, commandArguments, commandContext);
-        verify(commandParser).parseCommand(frameContainer, commandArguments.getArgumentsAsString());
-    }
-
-    @Test
-    public void testGetSuggestions() throws Exception {
-        activeCommand.getSuggestions(1, intelligentCommandContext);
-        verify(tabCompleterUtils).getIntelligentResults(1, intelligentCommandContext, 0);
-    }
-}

activewindow/test/com/dmdirc/addons/activewindow/ActiveWindowMessageSinkTest.java

-/*
- * Copyright (c) 2006-2015 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package com.dmdirc.addons.activewindow;
-
-import com.dmdirc.addons.ui_swing.components.frames.TextFrame;
-import com.dmdirc.addons.ui_swing.interfaces.ActiveFrameManager;
-import com.dmdirc.interfaces.WindowModel;
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
-
-import java.util.Date;
-import java.util.Optional;
-import java.util.regex.Pattern;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-
-import static junit.framework.TestCase.assertEquals;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class ActiveWindowMessageSinkTest {
-
-    private static final Pattern PATTERN = Pattern.compile("active");
-    @Mock private ActiveFrameManager activeFrameManager;
-    @Mock private MessageSinkManager messageSinkManager;
-    @Mock private WindowModel frameContainer;
-    @Mock private TextFrame textFrame;
-    @Mock private Date date;
-    private ActiveWindowMessageSink sink;
-
-    @Before
-    public void setUp() throws Exception {
-        sink = new ActiveWindowMessageSink(activeFrameManager);
-        when(textFrame.getContainer()).thenReturn(frameContainer);
-    }
-
-    @Test
-    public void testGetPattern() throws Exception {
-        assertEquals(PATTERN.toString(), sink.getPattern().toString());
-    }
-
-    @Test
-    public void testHandleMessage_NoActive() throws Exception {
-        when(activeFrameManager.getActiveFrame()).thenReturn(Optional.empty());
-        sink.handleMessage(messageSinkManager, frameContainer, null, date, "type", "message");
-        verify(frameContainer, never()).addLine("type", date, "message");
-    }
-
-    @Test
-    public void testHandleMessage_Active() throws Exception {
-        when(activeFrameManager.getActiveFrame()).thenReturn(Optional.of(textFrame));
-        sink.handleMessage(messageSinkManager, frameContainer, null, date, "type", "message");
-        verify(frameContainer).addLine("type", date, "message");
-    }
-}

audio/src/com/dmdirc/addons/audio/AudioCommand.java

             if (AudioPlayer.isValid(file)) {
                 new AudioPlayer(file).play();
             } else {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR, "Invalid file type");
+                showError(origin, args.isSilent(), "Invalid file type");
             }
         } else {
-            sendLine(origin, args.isSilent(), FORMAT_ERROR, "File does not exist");
+            showError(origin, args.isSilent(), "File does not exist");
         }
     }
 

build.gradle

 
     repositories {
         mavenCentral()
-        maven {
-            url 'http://artifactory.dmdirc.com/artifactory/repo'
-        }
+        maven { url 'http://artifactory.dmdirc.com/artifactory/repo' }
+        maven { url 'https://oss.sonatype.org/content/repositories/snapshots' }
     }
 
     dependencies {

calc/src/com/dmdirc/addons/calc/CalcCommand.java

             int offset = 0;
             boolean showexpr = false;
 
-            if (args.getArguments().length > 0 && args.getArguments()[0]
-                    .equals("--showexpr")) {
+            if (args.getArguments().length > 0 && "--showexpr".equals(args.getArguments()[0])) {
                 showexpr = true;
                 offset++;
             }
             final Parser parser = new Parser(lexer);
             final Evaluator evaluator = new Evaluator(parser.parse());
             final Number result = evaluator.evaluate();
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
-                    (showexpr ? input + " = " : "") + result);
+            showOutput(origin, args.isSilent(), (showexpr ? input + " = " : "") + result);
         } catch (ParseException ex) {
-            sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                    "Unable to parse expression: " + ex.getMessage());
+            showError(origin, args.isSilent(), "Unable to parse expression: " + ex.getMessage());
         } catch (ArithmeticException ex) {
-            sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                    "Unable to calculate expression: " + ex.getMessage());
+            showError(origin, args.isSilent(), "Unable to calculate expression: " + ex.getMessage());
         }
     }
 

channelwho/test/com/dmdirc/addons/channelwho/ChannelWhoManagerTest.java

 
 import com.google.common.collect.Lists;
 
+import java.net.URI;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
     @Test
     public void testServerConnectionEvent() throws Exception {
-        instance.handleServerConnectingEvent(new ServerConnectingEvent(connection2));
+        instance.handleServerConnectingEvent(
+                new ServerConnectingEvent(connection2, URI.create("irc://foo.bar")));
         verify(connectionHandlerFactory).get(connection);
     }
 

channelwho/test/com/dmdirc/addons/channelwho/ConnectionHandlerTest.java

 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyLong;
 import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
     @Mock private WindowModel windowModel;
     @Mock private DMDircMBassador eventBus;
     @Mock private ScheduledExecutorService scheduledExecutorService;
-    @Mock private ScheduledFuture scheduledFuture;
+    @Mock private ScheduledFuture<?> scheduledFuture;
     @Mock private ConnectionManager connectionManager;
     @Mock private Connection connection;
     @Mock private GroupChat groupChat;
 
     @Before
     public void setUp() throws Exception {
-        when(scheduledExecutorService.scheduleAtFixedRate(any(Runnable.class), anyLong(), anyLong(),
-                any())).thenReturn(scheduledFuture);
+        doReturn(scheduledFuture).when(scheduledExecutorService)
+                .scheduleAtFixedRate(any(Runnable.class), anyLong(), anyLong(), any());
         when(windowModel.getEventBus()).thenReturn(eventBus);
         when(connection.getWindowModel()).thenReturn(windowModel);
         when(config.getBinder()).thenReturn(configBinder);
         instance.load();
         verify(configBinder).bind(instance, ConnectionHandler.class);
         verify(eventBus).subscribe(instance);
-        verify(scheduledExecutorService).scheduleAtFixedRate(any(Runnable.class), eq(5l), eq(5l),
+        verify(scheduledExecutorService).scheduleAtFixedRate(any(Runnable.class), eq(5L), eq(5L),
                 eq(TimeUnit.MILLISECONDS));
     }
 
     public void testHandleWhoInterval() throws Exception {
         instance.handleWhoInterval(10);
         verify(scheduledFuture).cancel(false);
-        verify(scheduledExecutorService).scheduleAtFixedRate(any(Runnable.class), eq(5l), eq(5l),
+        verify(scheduledExecutorService).scheduleAtFixedRate(any(Runnable.class), eq(5L), eq(5L),
                 eq(TimeUnit.MILLISECONDS));
-        verify(scheduledExecutorService).scheduleAtFixedRate(any(Runnable.class), eq(10l), eq(10l),
+        verify(scheduledExecutorService).scheduleAtFixedRate(any(Runnable.class), eq(10L), eq(10L),
                 eq(TimeUnit.MILLISECONDS));
     }
 
 
     @Test
     public void testHandleAwayEvent_WithReason() throws Exception {
-        when(channelUserAwayEvent.getReason()).thenReturn(Optional.ofNullable("reason"));
+        when(channelUserAwayEvent.getReason()).thenReturn(Optional.of("reason"));
         instance.load();
         instance.handleAwayEvent(channelUserAwayEvent);
         verify(channelUserAwayEvent, never())

conditional_execute/src/com/dmdirc/addons/conditional_execute/ConditionalExecuteCommand.java

             final String arg = arguments[i].toLowerCase();
             final String nextArg = i + 1 < arguments.length ? arguments[i + 1] : "";
 
-            if (arg.equalsIgnoreCase("--help")) {
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Usage:");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, cmdname + " <args>");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, cmdname
+            if ("--help".equalsIgnoreCase(arg)) {
+                showOutput(origin, args.isSilent(), "Usage:");
+                showOutput(origin, args.isSilent(), "");
+                showOutput(origin, args.isSilent(), cmdname + " <args>");
+                showOutput(origin, args.isSilent(), cmdname
                         + " --namespace <name> <namespace commands>");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, cmdname
+                showOutput(origin, args.isSilent(), cmdname
                         + " --namespace <name> [--inverse] </commandToRun <command args>>");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(), "");
+                showOutput(origin, args.isSilent(),
                         "Commands can only be specified if no other non-namespace args are given.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(), "");
+                showOutput(origin, args.isSilent(),
                         "When trying to run a command, the namespace will be checked to see if the command can be run.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "The checks performed are as follows:");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "   1) Does the namespace exist? if not, run the command and create the namespace.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "   2) Is the namespace inhibited? - Do not run the command.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "   3) Is the namespace in forced mode? - Run the command.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "   4) If --inverse is specified, are we under the limit time? Run the command");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "   5) If --inverse is not specified, are we over the limit time? Run the command");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "   6) Do not run the command.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "General Arguments.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(), "   6) Do not run the command.");
+                showOutput(origin, args.isSilent(), "");
+                showOutput(origin, args.isSilent(), "General Arguments.");
+                showOutput(origin, args.isSilent(),
                         "  --list                   - List all current namespaces and their status");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "  --help                   - Print this help.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "  --reset                  - Remove all namespaces.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Useful things:");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(), "");
+                showOutput(origin, args.isSilent(), "Useful things:");
+                showOutput(origin, args.isSilent(),
                         "  --namespace <name>       - Namespace to modify. If the namespace does not exist, it will be created. Namespaces are not remembered across sessions.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Arguments related to a namespace:");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(), "");
+                showOutput(origin, args.isSilent(), "Arguments related to a namespace:");
+                showOutput(origin, args.isSilent(),
                         "  --settime <time>         - Set the limit time on this namespace. Time can be either a time in seconds, 'now' for now, or 'nowifless' to set to now only if it is currently less.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "  --delay <seconds>        - Increase the 'limit' time on this namespace by <seconds> seconds");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "  --inhibit                - Prevent any attempts at running commands in this namespace from executing");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "  --force                  - Any future attempts at running commands in this namespace will always execute");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "  --allow                  - Disable '--force' or '--inhibit' and resume normal operation.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "  --remove                 - Remove this namespace.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(),
                         "  --status                 - Show the status of this namespace.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Arguments when running a command:");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                showOutput(origin, args.isSilent(), "");
+                showOutput(origin, args.isSilent(), "Arguments when running a command:");
+                showOutput(origin, args.isSilent(),
                         "  --inverse              - Inverse the match against the 'limit' time.");
                 return;
-            } else if (arg.equalsIgnoreCase("--list")) {
+            } else if ("--list".equalsIgnoreCase(arg)) {
                 if (namespaces.isEmpty()) {
-                    sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+                    showOutput(origin, args.isSilent(),
                             "There are currently no known namespaces.");
                 } else {
-                    sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Current namespaces: ");
+                    showOutput(origin, args.isSilent(), "Current namespaces: ");
                     for (final Map.Entry<String, ConditionalExecuteNamespace> e : namespaces.
                             entrySet()) {
-                        sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "    " + e.getValue().
-                                toString());
+                        showOutput(origin, args.isSilent(),"    " + e.getValue());
                     }
                 }
                 return;
-            } else if (arg.equalsIgnoreCase("--reset")) {
+            } else if ("--reset".equalsIgnoreCase(arg)) {
                 namespaces.clear();
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "All namespaces removed.");
+                showOutput(origin, args.isSilent(), "All namespaces removed.");
                 return;
             } else if (namespace == null) {
-                if (arg.equalsIgnoreCase("--namespace")) {
+                if ("--namespace".equalsIgnoreCase(arg)) {
                     if (nextArg.isEmpty()) {
-                        sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                                "Error: You must specify a namespace.");
+                        showError(origin, args.isSilent(), "Error: You must specify a namespace.");
                         return;
                     } else {
                         if (!namespaces.containsKey(nextArg.toLowerCase())) {
                         i++;
                     }
                 } else {
-                    sendLine(origin, args.isSilent(), FORMAT_ERROR,
+                    showError(origin, args.isSilent(),
                             "Error: You must specify a namespace first.");
                     return;
                 }
-            } else if (arg.equalsIgnoreCase("--inhibit")) {
+            } else if ("--inhibit".equalsIgnoreCase(arg)) {
                 namespace.inhibit();
                 manipulated = true;
-            } else if (arg.equalsIgnoreCase("--force")) {
+            } else if ("--force".equalsIgnoreCase(arg)) {
                 namespace.force();
                 manipulated = true;
-            } else if (arg.equalsIgnoreCase("--allow")) {
+            } else if ("--allow".equalsIgnoreCase(arg)) {
                 namespace.reset();
                 manipulated = true;
-            } else if (arg.equalsIgnoreCase("--settime")) {
+            } else if ("--settime".equalsIgnoreCase(arg)) {
                 if (nextArg.isEmpty()) {
-                    sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                            "Error: You must provide a time to use.");
+                    showError(origin, args.isSilent(), "Error: You must provide a time to use.");
                     return;
-                } else if (nextArg.equalsIgnoreCase("now")) {
+                } else if ("now".equalsIgnoreCase(nextArg)) {
                     namespace.setLimit(System.currentTimeMillis());
                     i++;
                     manipulated = true;
-                } else if (nextArg.equalsIgnoreCase("nowifless")) {
+                } else if ("nowifless".equalsIgnoreCase(nextArg)) {
                     if (namespace.getLimitTime() < System.currentTimeMillis()) {
                         namespace.setLimit(System.currentTimeMillis());
                     }
                         i++;
                         manipulated = true;
                     } catch (final NumberFormatException nfe) {
-                        sendLine(origin, args.isSilent(), FORMAT_ERROR, "Error: Invalid time: "
-                                + nextArg);
+                        showError(origin, args.isSilent(), "Error: Invalid time: " + nextArg);
                         return;
                     }
                 }
-            } else if (arg.equalsIgnoreCase("--delay")) {
+            } else if ("--delay".equalsIgnoreCase(arg)) {
                 if (nextArg.isEmpty()) {
-                    sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                            "Error: You must provide a delay to use.");
+                    showError(origin, args.isSilent(),  "Error: You must provide a delay to use.");
                     return;
                 } else {
                     try {
                         i++;
                         manipulated = true;
                     } catch (final NumberFormatException nfe) {
-                        sendLine(origin, args.isSilent(), FORMAT_ERROR, "Error: Invalid delay: "
-                                + nextArg);
+                        showError(origin, args.isSilent(), "Error: Invalid delay: " + nextArg);
                         return;
                     }
                 }
-            } else if (arg.equalsIgnoreCase("--remove")) {
+            } else if ("--remove".equalsIgnoreCase(arg)) {
                 namespaces.remove(namespace.getName());
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Removed namespace '" + namespace.
-                        getName() + "'");
+                showOutput(origin, args.isSilent(),
+                        "Removed namespace '" + namespace.getName() + '\'');
                 return;
-            } else if (arg.equalsIgnoreCase("--status")) {
+            } else if ("--status".equalsIgnoreCase(arg)) {
                 // Show the current status, in case some manipulations occurred prior to this.
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, namespaces.get(namespace.getName()));
+                showOutput(origin, args.isSilent(), namespaces.get(namespace.getName()).toString());
                 return;
-            } else if (arg.equalsIgnoreCase("--inverse")) {
+            } else if ("--inverse".equalsIgnoreCase(arg)) {
                 inverse = true;
             } else if (manipulated) {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
+                showError(origin, args.isSilent(),
                         "You can't run commands and manipulate the namespace at the same time, ignored.");
             } else {
                 // Command to run!
 
         // If we get here, we either manipulated something, or should show the usage text.
         if (manipulated) {
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Namespace updated.");
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT, namespace.toString());
+            showOutput(origin, args.isSilent(), "Namespace updated.");
+            showOutput(origin, args.isSilent(), namespace.toString());
             namespaces.put(namespace.getName(), namespace);
         } else {
-            sendLine(origin, args.isSilent(), FORMAT_ERROR, "Usage:");
-            sendLine(origin, args.isSilent(), FORMAT_ERROR, "");
-            sendLine(origin, args.isSilent(), FORMAT_ERROR, cmdname + " <args>");
-            sendLine(origin, args.isSilent(), FORMAT_ERROR, cmdname
+            showError(origin, args.isSilent(), "Usage:");
+            showError(origin, args.isSilent(), "");
+            showError(origin, args.isSilent(), cmdname + " <args>");
+            showError(origin, args.isSilent(), cmdname
                     + " --namespace <name> <namespace commands>");
-            sendLine(origin, args.isSilent(), FORMAT_ERROR, cmdname
+            showError(origin, args.isSilent(), cmdname
                     + " --namespace <name> [--inverse] </commandToRun <command args>>");
-            sendLine(origin, args.isSilent(), FORMAT_ERROR, "");
-            sendLine(origin, args.isSilent(), FORMAT_ERROR, "For more information, see " + cmdname
+            showError(origin, args.isSilent(), "");
+            showError(origin, args.isSilent(), "For more information, see " + cmdname
                     + " --help");
         }
     }

conditional_execute/test/com/dmdirc/addons/conditional_execute/ConditionalExecuteCommandTest.java

 
 package com.dmdirc.addons.conditional_execute;
 
+import com.dmdirc.DMDircMBassador;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.commands.context.CommandContext;
 import com.dmdirc.commandparser.parsers.CommandParser;
+import com.dmdirc.events.CommandErrorEvent;
 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.WindowModel;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
+import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.contains;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Matchers.same;
 import static org.mockito.Mockito.never;
     @Mock private CommandParser commandParser;
     @Mock private WindowModel container;
     @Mock private CommandContext context;
+    @Mock private DMDircMBassador eventbus;
+    @Captor private ArgumentCaptor<CommandErrorEvent> errorEventCaptor;
     private ConditionalExecuteCommand command;
 
     @Before
         when(commandController.getSilenceChar()).thenReturn('/');
         when(container.getCommandParser()).thenReturn(commandParser);
         when(container.isWritable()).thenReturn(true);
+        when(container.getEventBus()).thenReturn(eventbus);
 
         command = new ConditionalExecuteCommand(commandController);
     }
         verify(commandParser, never()).parseCommand(same(container), anyString());
     }
 
-    private void verifyErrorOutput(final String substring) {
-        verify(container).addLine(eq("commandError"), contains(substring));
+    private void verifyErrorOutput(final CharSequence substring) {
+        verify(eventbus).publishAsync(errorEventCaptor.capture());
+        assertTrue(errorEventCaptor.getValue().getMessage().contains(substring));
     }
 
 }

dcc/src/com/dmdirc/addons/dcc/ChatContainer.java

 import com.dmdirc.ui.core.components.WindowComponent;
 import com.dmdirc.ui.input.TabCompleterFactory;
 import com.dmdirc.ui.messages.BackBufferFactory;
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
 import com.dmdirc.util.EventUtils;
 
 import java.util.Arrays;
      * @param nick                My Current Nickname
      * @param targetNick          Nickname of target
      * @param tabCompleterFactory The factory to use to create tab completers.
-     * @param messageSinkManager  The sink manager to use to dispatch messages.
      * @param eventBus            The bus to dispatch events on.
      */
     public ChatContainer(
             final String nick,
             final String targetNick,
             final TabCompleterFactory tabCompleterFactory,
-            final MessageSinkManager messageSinkManager,
             final DMDircMBassador eventBus) {
         super(parent, title, "dcc-chat-inactive", configManager, backBufferFactory,
                 new DCCCommandParser(configManager, commandController, eventBus),
-                messageSinkManager,
                 tabCompleterFactory,
                 eventBus,
                 Arrays.asList(

dcc/src/com/dmdirc/addons/dcc/DCCCommand.java

 import com.dmdirc.ui.input.TabCompleterFactory;
 import com.dmdirc.ui.input.TabCompletionType;
 import com.dmdirc.ui.messages.BackBufferFactory;
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
 
 import java.awt.Window;
 import java.io.File;
     private final Window mainWindow;
     /** Window management. */
     private final WindowManager windowManager;
-    /** The sink manager to use to dispatch messages. */
-    private final MessageSinkManager messageSinkManager;
     /** The factory to use for tab completers. */
     private final TabCompleterFactory tabCompleterFactory;
     /** The bus to dispatch events on. */
             final CommandController controller,
             @MainWindow final Window mainWindow,
             final DCCManager plugin,
-            final MessageSinkManager messageSinkManager,
             final WindowManager windowManager,
             final TabCompleterFactory tabCompleterFactory,
             final DMDircMBassador eventBus,
         super(controller);
         this.mainWindow = mainWindow;
         myPlugin = plugin;
-        this.messageSinkManager = messageSinkManager;
         this.windowManager = windowManager;
         this.tabCompleterFactory = tabCompleterFactory;
         this.eventBus = eventBus;
                 sendFile(target, origin, connection, true,
                         args.getArgumentsAsString(2));
             } else {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                        "Unknown DCC Type: '" + type + "'");
+                showError(origin, args.isSilent(), "Unknown DCC Type: '" + type + '\'');
             }
         } else {
             showUsage(origin, true, INFO.getName(), INFO.getHelp());
                     myNickname,
                     target,
                     tabCompleterFactory,
-                    messageSinkManager,
                     eventBus);
             windowManager.addWindow(myPlugin.getContainer(), window);
             parser.sendCTCP(target, "DCC", "CHAT chat " + DCC.ipToLong(
-                    myPlugin.getListenIP(parser)) + " " + chat.getPort());
+                    myPlugin.getListenIP(parser)) + ' ' + chat.getPort());
             eventBus.publish(new DccChatRequestSentEvent(connection, target));
             sendLine(origin, isSilent, "DCCChatStarting", target, chat.getHost(), chat.getPort());
             window.addLine("DCCChatStarting", target, chat.getHost(), chat.getPort());
             eventBus.publish(new DccSendRequestEvent(connection, target, selectedFile.
                     getAbsolutePath()));
 
-            sendLine(origin, isSilent, FORMAT_OUTPUT,
-                    "Starting DCC Send with: " + target);
+            showOutput(origin, isSilent, "Starting DCC Send with: " + target);
 
             send.setFileName(selectedFile.getAbsolutePath());
             send.setFileSize(selectedFile.length());

dcc/src/com/dmdirc/addons/dcc/DCCFrameContainer.java

 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.ui.input.TabCompleterFactory;
 import com.dmdirc.ui.messages.BackBufferFactory;
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
 
 import java.util.Collection;
 import java.util.Optional;
      * @param icon                The icon to use
      * @param configManager       Config manager
      * @param parser              Command parser to use for this window
-     * @param messageSinkManager  The sink manager to use to dispatch messages.
      * @param tabCompleterFactory The factory to use to create tab completers.
      * @param eventBus            The bus to dispatch events on.
      * @param components          The UI components that this frame requires
             final AggregateConfigProvider configManager,
             final BackBufferFactory backBufferFactory,
             final CommandParser parser,
-            final MessageSinkManager messageSinkManager,
             final TabCompleterFactory tabCompleterFactory,
             final DMDircMBassador eventBus,
             final Collection<String> components) {
         super(parent, icon, title, title, configManager, backBufferFactory,
                 tabCompleterFactory.getTabCompleter(configManager),
-                messageSinkManager,
                 eventBus,
                 components);
         initBackBuffer();

dcc/src/com/dmdirc/addons/dcc/DCCManager.java

 import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.input.TabCompleterFactory;
 import com.dmdirc.ui.messages.BackBufferFactory;
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
 
 import com.google.common.collect.Sets;
 
     private PlaceholderContainer container;
     /** Config manager to read settings from. */
     private final AggregateConfigProvider config;
-    /** The sink manager to use to dispatch messages. */
-    private final MessageSinkManager messageSinkManager;
     /** Window Management. */
     private final WindowManager windowManager;
     /** The command controller to use. */
             final IdentityController identityController,
             @GlobalConfig final AggregateConfigProvider globalConfig,
             final CommandController commandController,
-            final MessageSinkManager messageSinkManager,
             final WindowManager windowManager,
             final TabCompleterFactory tabCompleterFactory,
             final SwingWindowFactory windowFactory,
             @Directory(DirectoryType.BASE) final String baseDirectory,
             final BackBufferFactory backBufferFactory) {
         this.mainWindow = mainWindow;
-        this.messageSinkManager = messageSinkManager;
         this.windowManager = windowManager;
         this.commandController = commandController;
         this.tabCompleterFactory = tabCompleterFactory;
                 myNickname,
                 nickname,
                 tabCompleterFactory,
-                messageSinkManager,
                 eventBus);
         windowManager.addWindow(getContainer(), f);
         f.addLine("DCCChatStarting", nickname, chat.getHost(), chat.getPort());

dcop/src/com/dmdirc/addons/dcop/DcopCommand.java

 
         final List<String> res = executor.getDcopResult(arguments[0], arguments[1], arguments[2]);
         for (String line : res) {
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT, line);
+            showOutput(origin, args.isSilent(), line);
         }
     }
 

debug/src/com/dmdirc/addons/debug/Debug.java

         } else {
             final DebugCommand command = commands.get(args.getArguments()[0]);
             if (command == null) {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                        "Unknown debug action.");
+                showError(origin, args.isSilent(), "Unknown debug action.");
             } else {
                 final CommandArguments newArgs = new CommandArguments(
                         controller,
      * @param type     The type of message to send
      * @param args     The arguments of the message
      */
+    @Deprecated
     public void proxySendLine(final WindowModel target,
             final boolean isSilent, final String type, final Object... args) {
         sendLine(target, isSilent, type, args);

debug/src/com/dmdirc/addons/debug/RawWindow.java

 import com.dmdirc.ui.core.components.WindowComponent;
 import com.dmdirc.ui.input.TabCompleterFactory;
 import com.dmdirc.ui.messages.BackBufferFactory;
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
 
 import java.util.Arrays;
 import java.util.Optional;
 
     public RawWindow(
             final Connection connection,
-            final MessageSinkManager messageSinkManager,
             final TabCompleterFactory tabCompleterFactory,
             final BackBufferFactory backBufferFactory) {
         super(connection.getWindowModel(), "raw", "Raw", "(Raw log)",
                 tabCompleterFactory.getTabCompleter(connection.getWindowModel().getTabCompleter(),
                         connection.getWindowModel().getConfigManager(),
                         CommandType.TYPE_QUERY, CommandType.TYPE_CHAT),
-                messageSinkManager,
                 connection.getWindowModel().getEventBus(),
                 Arrays.asList(WindowComponent.TEXTAREA.getIdentifier(),
                         WindowComponent.INPUTFIELD.getIdentifier()));

debug/src/com/dmdirc/addons/debug/RawWindowFactory.java

 import com.dmdirc.ui.WindowManager;
 import com.dmdirc.ui.input.TabCompleterFactory;
 import com.dmdirc.ui.messages.BackBufferFactory;
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
 
 import javax.inject.Inject;
 import javax.inject.Singleton;
 
     private final TabCompleterFactory tabCompleterFactory;
     private final CommandController commandController;
-    private final MessageSinkManager messageSinkManager;
     private final BackBufferFactory backBufferFactory;
     private final WindowManager windowManager;
 
     @Inject
-    public RawWindowFactory(final TabCompleterFactory tabCompleterFactory,
-            final CommandController commandController, final MessageSinkManager messageSinkManager,
-            final BackBufferFactory backBufferFactory, final WindowManager windowManager) {
+    public RawWindowFactory(
+            final TabCompleterFactory tabCompleterFactory,
+            final CommandController commandController,
+            final BackBufferFactory backBufferFactory,
+            final WindowManager windowManager) {
         this.tabCompleterFactory = tabCompleterFactory;
         this.commandController = commandController;
-        this.messageSinkManager = messageSinkManager;
         this.backBufferFactory = backBufferFactory;
         this.windowManager = windowManager;
     }
 
     public RawWindow getRawWindow(final Connection connection) {
         final RawWindow rawWindow = new RawWindow(connection,
-                messageSinkManager, tabCompleterFactory,  backBufferFactory);
+                tabCompleterFactory,  backBufferFactory);
         rawWindow.setCommandParser(new ServerCommandParser(
                 connection.getWindowModel().getConfigManager(),
                 commandController,

debug/src/com/dmdirc/addons/debug/commands/Benchmark.java

 import com.dmdirc.addons.debug.DebugCommand;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.commands.context.CommandContext;
+import com.dmdirc.events.CommandOutputEvent;
 import com.dmdirc.interfaces.WindowModel;
 
 import javax.annotation.Nonnull;
             final long start = System.nanoTime();
 
             for (int j = 0; j < 5000; j++) {
-                origin.addLine(FORMAT_OUTPUT,
-                        "This is a benchmark. Lorem ipsum doler...");
+                origin.getEventBus().publishAsync(new CommandOutputEvent(origin,
+                        "This is a benchmark. Lorem ipsum doler..."));
             }
 
             final long end = System.nanoTime();
         }
 
         for (int i = 0; i < results.length; i++) {
-            origin.addLine(FORMAT_OUTPUT, "Iteration " + i + ": " + results[i]
-                    + " nanoseconds.");
+            origin.getEventBus().publishAsync(new CommandOutputEvent(origin,
+                    "Iteration " + i + ": " + results[i] + " nanoseconds."));
         }
     }
 

debug/src/com/dmdirc/addons/debug/commands/EventBusViewer.java

 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.commands.context.CommandContext;
 import com.dmdirc.events.ClientLineAddedEvent;
+import com.dmdirc.events.CommandOutputEvent;
 import com.dmdirc.events.DMDircEvent;
+import com.dmdirc.events.DisplayableEvent;
 import com.dmdirc.events.FrameClosingEvent;
 import com.dmdirc.interfaces.WindowModel;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
         @Handler
         public void handleEvent(final DMDircEvent event) {
             if (event instanceof ClientLineAddedEvent
-                    && ((ClientLineAddedEvent) event).getFrameContainer() == target) {
+                    && ((ClientLineAddedEvent) event).getFrameContainer() == target
+                    || event instanceof CommandOutputEvent
+                    && ((DisplayableEvent) event).getSource() == target) {
                 // Don't add a line every time we add a line to our output window.
                 // Things will explode otherwise.
                 return;
                 }
             }
 
-            target.addLine(FORMAT_OUTPUT, output.toString());
+            target.getEventBus().publishAsync(new CommandOutputEvent(target, output.toString()));
         }
 
     }

debug/test/com/dmdirc/addons/debug/DebugTest.java

 
 package com.dmdirc.addons.debug;
 
+import com.dmdirc.DMDircMBassador;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.commands.context.CommandContext;
+import com.dmdirc.events.CommandErrorEvent;
 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.WindowModel;
 
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.argThat;
-import static org.mockito.Matchers.eq;
+import static org.mockito.Matchers.isA;
 import static org.mockito.Matchers.same;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
     @Mock private CommandController controller;
     @Mock private DebugCommand debugCommand;
     @Mock private CommandContext commandContext;
+    @Mock private DMDircMBassador eventbus;
     private Debug debug;
 
     @Before
     public void setup() {
         when(controller.getCommandChar()).thenReturn('/');
         when(debugCommand.getName()).thenReturn("test");
+        when(container.getEventBus()).thenReturn(eventbus);
     }
 
     /** Checks the debug command with no arguments shows usage. */
         when(arguments.isCommand()).thenReturn(true);
         when(arguments.getArguments()).thenReturn(new String[0]);
         debug.execute(container, arguments, null);
-        verify(container).addLine(eq("commandUsage"), anyString(),
-                eq("debug"), anyObject());
+        verify(eventbus).publishAsync(isA(CommandErrorEvent.class));
     }
 
     /** Checks the debug command with an invalid subcommand shows an error. */
         when(arguments.getArguments()).thenReturn(new String[]{"test"});
 
         debug.execute(container, arguments, null);
-        verify(container).addLine(eq("commandError"), anyString());
+        verify(eventbus).publishAsync(isA(CommandErrorEvent.class));
     }
 
     /** Checks the debug command executes a subcommand with no args. */
 
         debug.execute(container, arguments, commandContext);
 
-        verify(container, never()).addLine(anyString(), anyString());
+        verify(eventbus, never()).publishAsync(any());
         verify(debugCommand).execute(same(container), eqLine("/test"),
                 same(commandContext));
     }
 
         debug.execute(container, arguments, commandContext);
 
-        verify(container, never()).addLine(anyString(), anyString());
+        verify(eventbus, never()).publishAsync(any());
         verify(debugCommand).execute(same(container), eqLine("/test 1 2 3"),
                 same(commandContext));
     }

dns/src/com/dmdirc/addons/dns/DNSCommand.java

             return;
         }
 
-        sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Resolving: " + args.getArguments()[0]);
+        showOutput(origin, args.isSilent(), "Resolving: " + args.getArguments()[0]);
         new Timer("DNS Command Timer").schedule(new TimerTask() {
 
             @Override
             final String arg) {
         try {
             final InetAddress address = InetAddresses.forString(arg);
-            sendLine(origin, isSilent, FORMAT_OUTPUT, "Resolved: "
+            showOutput(origin, isSilent, "Resolved: "
                     + arg + ": " + address.getCanonicalHostName());
         } catch (IllegalArgumentException ex) {
-            sendLine(origin, isSilent, FORMAT_OUTPUT, "Resolved: "
+            showOutput(origin, isSilent, "Resolved: "
                     + arg + ": " + getIPs(arg));
         }
     }

exec/src/com/dmdirc/addons/exec/ExecCommand.java

             // This checks the command to execute has correct quotes
             // (if necessary). Without this /exec "command arg1 arg2 would error.
             if (commandArray.length == 0) {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
+                showError(origin, args.isSilent(),
                         "Could not execute: Invalid file name provided");
             } else if (!new File(commandArray[0]).exists()) {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
+                showError(origin, args.isSilent(),
                         "Could not execute: " + commandArray[0] + " does not exist.");
             } else {
                 final Process p = Runtime.getRuntime().exec(commandArray);
                     final List<String> errorOutput = CharStreams.readLines(
                             new InputStreamReader(p.getErrorStream()));
                     for (String line : execOutput) {
-                        sendLine(origin, args.isSilent(), FORMAT_OUTPUT, line);
+                        showOutput(origin, args.isSilent(), line);
                     }
                     for (String line : errorOutput) {
-                        sendLine(origin, args.isSilent(), FORMAT_ERROR, line);
+                        showError(origin, args.isSilent(), line);
                     }
                 }
             }

logging/res/META-INF/format.yml

+---
+HistoricalLineRestoredEvent:
+  format: "{{line}}"
+  timestamp: no

activewindow/src/com/dmdirc/addons/activewindow/package-info.java → logging/src/com/dmdirc/addons/logging/HistoricalLineRestoredEvent.java

  * SOFTWARE.
  */
 
+package com.dmdirc.addons.logging;
+
+import com.dmdirc.events.BaseDisplayableEvent;
+import com.dmdirc.interfaces.WindowModel;
+
 /**
- * Provides an active window command to the swing UI.
+ * Event raised when a line from the log is restored into a window.
  */
-package com.dmdirc.addons.activewindow;
+public class HistoricalLineRestoredEvent extends BaseDisplayableEvent {
+
+    private final String line;
+
+    public HistoricalLineRestoredEvent(final long timestamp, final WindowModel source,
+            final String line) {
+        super(timestamp, source);
+        this.line = line;
+    }
+
+    public HistoricalLineRestoredEvent(final WindowModel source, final String line) {
+        super(source);
+        this.line = line;
+    }
+
+    public String getLine() {
+        return line;
+    }
+
+}

logging/src/com/dmdirc/addons/logging/LoggingCommand.java

         if (args.getArguments().length > 0) {
             if ("history".equalsIgnoreCase(args.getArguments()[0])) {
                 if (!manager.showHistory(origin)) {
-                    sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                            "Unable to open history for this window.");
+                    showError(origin, args.isSilent(), "Unable to open history for this window.");
                 }
             } else if ("help".equalsIgnoreCase(args.getArguments()[0])) {
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, LOGGING
+                showOutput(origin, args.isSilent(), LOGGING
                         + " history          - Open the history of this window, if available.");
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, LOGGING
+                showOutput(origin, args.isSilent(), LOGGING
                         + " help             - Show this help.");
             } else {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR, "Unknown command '" + args.
-                        getArguments()[0] + "'. Use " + LOGGING + " help for a list of commands.");
+                showError(origin, args.isSilent(), "Unknown command '"
+                        + args.getArguments()[0] + "'. Use " + LOGGING
+                        + " help for a list of commands.");
             }
         } else {
-            sendLine(origin, args.isSilent(), FORMAT_ERROR, "Use " + LOGGING
-                    + " help for a list of commands.");
+            showError(origin, args.isSilent(), "Use " + LOGGING + " help for a list of commands.");
         }
     }
 

logging/src/com/dmdirc/addons/logging/LoggingManager.java

 
         synchronized (openFiles) {
             final Collection<String> old = new ArrayList<>(openFiles.size());
-            for (Map.Entry<String, OpenFile> entry : openFiles.entrySet()) {
-                if (entry.getValue().lastUsedTime < oldestTime) {
-                    StreamUtils.close(entry.getValue().writer);
-                    old.add(entry.getKey());
-                }
-            }
+            openFiles.entrySet().stream()
+                    .filter(entry -> entry.getValue().lastUsedTime < oldestTime)
+                    .forEach(entry -> {
+                        StreamUtils.close(entry.getValue().writer);
+                        old.add(entry.getKey());
+                    });
 
             openFiles.keySet().removeAll(old);
         }
 
         appendLine(filename, "*** Topic is: %s", event.getTopic().getTopic());
         appendLine(filename, "*** Set at: %s on %s by %s",
-                timeFormat.format(1000 * event.getTopic().getTime()),
-                dateFormat.format(1000 * event.getTopic().getTime()),
+                timeFormat.format(event.getTopic().getDate()),
+                dateFormat.format(event.getTopic().getDate()),
                         event.getTopic().getClient()
                                 .map(GroupChatUser::getNickname).orElse("Unknown"));
     }
 
         final Path testFile = Paths.get(filename);
         if (Files.exists(testFile)) {
-            try {
-                final ReverseFileReader file = new ReverseFileReader(testFile);
+            try (final ReverseFileReader file = new ReverseFileReader(testFile)) {
                 // Because the file includes a newline char at the end, an empty line
                 // is returned by getLines. To counter this, we call getLines(1) and do
                 // nothing with the output.
                 file.getLines(1);
                 final Stack<String> lines = file.getLines(backbufferLines);
                 while (!lines.empty()) {
-                    frame.addLine(getColouredString(colour, lines.pop()));
+                    frame.getEventBus().publishAsync(new HistoricalLineRestoredEvent(frame,
+                            getColouredString(colour, lines.pop())));
                 }
                 file.close();
-                frame.addLine(getColouredString(colour, "--- End of backbuffer\n"));
+                frame.getEventBus().publishAsync(new HistoricalLineRestoredEvent(frame,
+                        getColouredString(colour, "--- End of backbuffer\n")));
             } catch (IOException | SecurityException e) {
                 LOG.info(USER_ERROR, "Unable to show backbuffer (Filename: {}): {}", filename,
                         e.getMessage(), e);

nma/src/com/dmdirc/addons/nma/NotifyMyAndroidCommand.java

         new Thread(() -> {
             try {
                 client.notify(parts[0], parts[1]);
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Notification sent");
+                showOutput(origin, args.isSilent(), "Notification sent");
             } catch (IOException ex) {
                 LOG.info("Exception when trying to notify NMA", ex);
-                sendLine(origin, args.isSilent(), FORMAT_ERROR, "Unable to send: " + ex.
-                        getMessage());
+                showError(origin, args.isSilent(), "Unable to send: " + ex.getMessage());
             }
         }, "NMA Thread").start();
     }

notifications/src/com/dmdirc/addons/notifications/NotificationCommand.java

                 final NotificationHandler handler = manager.getHandler(sourceName);
 
                 if (handler == null) {
-                    sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                            "Method not found.");
+                    showError(origin, args.isSilent(), "Method not found.");
                 } else {
                     handler.showNotification("DMDirc", args.getArgumentsAsString(2));
                 }
             } else {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
+                showError(origin, args.isSilent(),
                         "You must specify a method when using --method.");
             }
         } else if (manager.hasActiveHandler()) {
             manager.getPreferredHandler().showNotification("DMDirc", args.getArgumentsAsString(0));
         } else {
-            sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                    "No active notification methods available.");
+            showError(origin, args.isSilent(), "No active notification methods available.");
         }
     }
 
         final Collection<String> handlers = manager.getHandlerNames();
 
         if (handlers.isEmpty()) {
-            sendLine(origin, isSilent, FORMAT_ERROR, "No notification "
-                    + "methods available.");
+            showError(origin, isSilent, "No notification methods available.");
         } else {
             final String[] headers = {"Method"};
             final String[][] data = new String[handlers.size()][1];
                 i++;
             }
 
-            sendLine(origin, isSilent, FORMAT_OUTPUT, doTable(headers, data));
+            showOutput(origin, isSilent, doTable(headers, data));
         }
     }
 

nowplaying/src/com/dmdirc/addons/nowplaying/NowPlayingCommand.java

                 final MediaSource source = manager.getSource(sourceName);
 
                 if (source == null) {
-                    sendLine(origin, args.isSilent(), FORMAT_ERROR, "Source not found.");
+                    showError(origin, args.isSilent(), "Source not found.");
                 } else {
                     if (source.getState() == MediaSourceState.CLOSED) {
-                        sendLine(origin, args.isSilent(), FORMAT_ERROR, "Source is not running.");
+                        showError(origin, args.isSilent(), "Source is not running.");
                     } else {
                         target.getWindowModel().getCommandParser().parseCommand(origin,
                                 getInformation(source, args.getArgumentsAsString(2)));
                     }
                 }
             } else {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
+                showError(origin, args.isSilent(),
                         "You must specify a source when using --source.");
             }
         } else {
                         getInformation(manager.getBestSource(), args.
                                 getArgumentsAsString(0)));
             } else {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                        "No running media sources available.");
+                showError(origin, args.isSilent(), "No running media sources available.");
             }
         }
     }
         final List<MediaSource> sources = manager.getSources();
 
         if (sources.isEmpty()) {
-            sendLine(origin, isSilent, FORMAT_ERROR, "No media sources available.");
+            showError(origin, isSilent, "No media sources available.");
         } else {
             final String[] headers = {"Source", "Status", "Information"};
             final String[][] data = new String[sources.size()][3];
                 i++;
             }
 
-            sendLine(origin, isSilent, FORMAT_OUTPUT, doTable(headers, data));
+            showOutput(origin, isSilent, doTable(headers, data));
         }
     }
 

osd/src/com/dmdirc/addons/osd/OsdCommand.java

         } else if (args.getArguments().length > 0
                 && "--timeout".equalsIgnoreCase(args.getArguments()[0])) {
             if (args.getArguments().length < 2) {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR, "You "
-                        + "must specify a valid number for the OSD timeout.");
+                showError(origin, args.isSilent(),
+                        "You must specify a valid number for the OSD timeout.");
                 return;
             }
 
                 showOSD(Integer.parseInt(args.getArguments()[1]), null,
                         args.getArgumentsAsString(2));
             } catch (NumberFormatException ex) {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR, "You "
-                        + "must specify a valid number for the OSD timeout.");
+                showError(origin, args.isSilent(),
+                        "You must specify a valid number for the OSD timeout.");
             }
         } else {
             showOSD(-1, null, args.getArgumentsAsString());
         if (arg == 0) {
             res.add("--close");
             res.add("--timeout");
-        } else if (arg > 0 && context.getPreviousArgs().get(0)
-                .equals("--close")) {
+        } else if (arg > 0 && "--close".equals(context.getPreviousArgs().get(0))) {
             res.excludeAll();
         }
 

parserdebug/src/com/dmdirc/addons/parserdebug/ParserDebugCommand.java

         final Optional<Parser> parser = connection.getParser();
 
         if (!parser.isPresent()) {
-            sendLine(origin, isSilent, FORMAT_ERROR, "Unable to get a parser for this window.");
+            showError(origin, isSilent, "Unable to get a parser for this window.");
             return;
         }
         if (parserDebugManager.containsParser(parser.get())) {
             parserDebugManager.removeParser(parser.get(), false);
-            sendLine(origin, isSilent, FORMAT_OUTPUT, "Removed callback");
+            showOutput(origin, isSilent, "Removed callback");
         } else {
             parserDebugManager.addParser(parser.get(), connection);
-            sendLine(origin, isSilent, FORMAT_OUTPUT, "Added callback");
+            showOutput(origin, isSilent, "Added callback");
         }
     }
 

redirect/src/com/dmdirc/addons/redirect/FakeWriteableFrameContainer.java

 import com.dmdirc.interfaces.WindowModel;
 import com.dmdirc.ui.messages.BackBufferFactory;
 import com.dmdirc.ui.messages.Formatter;
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
 
 import java.util.Collections;
 import java.util.Date;
      */
     public FakeWriteableFrameContainer(
             final WindowModel target,
-            final MessageSinkManager messageSinkManager,
             final DMDircMBassador eventBus,
             final BackBufferFactory backBufferFactory) {
         super(target, target.getIcon(), target.getName(), target.getTitle(),
                 target.getConfigManager(), backBufferFactory,
-                target.getTabCompleter(), messageSinkManager, eventBus,
-                Collections.<String>emptyList());
+                target.getTabCompleter(), eventBus, Collections.<String>emptyList());
         this.target = target;
         initBackBuffer();
         setCommandParser(target.getCommandParser());
     }
 
-    @Override
-    @Deprecated
-    public void addLine(final String line, final boolean timestamp) {
-        addLine(line);
-    }
-
     @Override
     public void sendLine(final String line) {
         target.sendLine(line);
     }
 
     @Override
+    @Deprecated
     public void addLine(final String type, final Date timestamp, final Object... args) {
         addLine(type, args);
     }
 
     @Override
+    @Deprecated
     public void addLine(final String type, final Object... args) {
         sendLine(Formatter.formatMessage(getConfigManager(), type, args));
     }
 
     @Override
-    public void addLine(final StringBuffer type, final Date timestamp, final Object... args) {
-        addLine(type, args);
-    }
-
-    @Override
-    public void addLine(final StringBuffer type, final Object... args) {
-        addLine(type.toString(), args);
-    }
-
-    @Override
+    @Deprecated
     public void addLine(final String line, final Date timestamp) {
         addLine(line);
     }

redirect/src/com/dmdirc/addons/redirect/RedirectCommand.java

 import com.dmdirc.ui.input.AdditionalTabTargets;
 import com.dmdirc.ui.input.TabCompleterUtils;
 import com.dmdirc.ui.messages.BackBufferFactory;
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
 
 import javax.annotation.Nonnull;
 import javax.inject.Inject;
             "redirect <command> - sends the output of the command to a "
             + "channel or query window",
             CommandType.TYPE_CHAT);
-    /** The sink manager to use to dispatch messages. */
-    private final MessageSinkManager messageSinkManager;
     /** The bus to dispatch events on. */
     private final DMDircMBassador eventBus;
     private final BackBufferFactory backBufferFactory;
     @Inject
     public RedirectCommand(
             final CommandController controller,
-            final MessageSinkManager messageSinkManager,
             final DMDircMBassador eventBus,
             final BackBufferFactory backBufferFactory,
             final TabCompleterUtils tabCompleterUtils) {
         super(controller);
-        this.messageSinkManager = messageSinkManager;
         this.eventBus = eventBus;
         this.backBufferFactory = backBufferFactory;
         this.tabCompleterUtils = tabCompleterUtils;
         final Chat target = ((ChatCommandContext) context).getChat();
         target.getWindowModel().getCommandParser().parseCommand(
                 new FakeWriteableFrameContainer(target.getWindowModel(),
-                        messageSinkManager, eventBus, backBufferFactory),
+                        eventBus, backBufferFactory),
                 args.getArgumentsAsString());
     }
 

scriptplugin/src/com/dmdirc/addons/scriptplugin/ScriptCommand.java

 
         if (sargs.length > 0 && ("rehash".equalsIgnoreCase(sargs[0]) ||
                 "reload".equalsIgnoreCase(sargs[0]))) {
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Reloading scripts");
+            showOutput(origin, args.isSilent(), "Reloading scripts");
             scriptManager.rehash();
         } else if (sargs.length > 0 && "load".equalsIgnoreCase(sargs[0])) {
             if (sargs.length > 1) {
                 final String filename = args.getArgumentsAsString(1);
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Loading: " + filename + " ["
+                showOutput(origin, args.isSilent(), "Loading: " + filename + " ["
                         + scriptManager.loadScript(scriptDirectory + filename) + ']');
             } else {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR, "You must specify a script to load");
+                showError(origin, args.isSilent(), "You must specify a script to load");
             }
         } else if (sargs.length > 0 && "unload".equalsIgnoreCase(sargs[0])) {
             if (sargs.length > 1) {
                 final String filename = args.getArgumentsAsString(1);
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Unloading: " + filename + " ["
+                showOutput(origin, args.isSilent(), "Unloading: " + filename + " ["
                         + scriptManager.loadScript(scriptDirectory + filename) + ']');
             } else {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                        "You must specify a script to unload");
+                showError(origin, args.isSilent(), "You must specify a script to unload");
             }
         } else if (sargs.length > 0 && "eval".equalsIgnoreCase(sargs[0])) {
             if (sargs.length > 1) {
                 final String script = args.getArgumentsAsString(1);
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Evaluating: " + script);
+                showOutput(origin, args.isSilent(), "Evaluating: " + script);
                 try {
                     final ScriptEngineWrapper wrapper;
                     if (globalConfig.hasOptionString(domain, "eval.baseFile")) {
                     wrapper.getScriptEngine().put("cmd_origin", origin);
                     wrapper.getScriptEngine().put("cmd_isSilent", args.isSilent());
                     wrapper.getScriptEngine().put("cmd_args", sargs);
-                    sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Result: " + wrapper.
-                            getScriptEngine().eval(script));
+                    showOutput(origin, args.isSilent(), "Result: "
+                            + wrapper.getScriptEngine().eval(script));
                 } catch (ScriptException e) {
-                    sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Exception: " + e + " -> " + e.
-                            getMessage());
+                    showOutput(origin, args.isSilent(), "Exception: " + e + " -> "
+                            + e.getMessage());
 
                     if (globalConfig.getOptionBool(domain, "eval.showStackTrace")) {
                         final String[] stacktrace = getTrace(e);
                         for (String line : stacktrace) {
-                            sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Stack trace: " + line);
+                            showOutput(origin, args.isSilent(), "Stack trace: " + line);
                         }
                     }
 
                 }
             } else {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                        "You must specify some script to eval.");
+                showError(origin, args.isSilent(), "You must specify some script to eval.");
             }
         } else if (sargs.length > 0 && "savetobasefile".equalsIgnoreCase(sargs[0])) {
             if (sargs.length > 2) {
                 final String[] bits = sargs[1].split("/");
                 final String functionName = bits[0];
                 final String script = args.getArgumentsAsString(2);
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Saving as '" + functionName
+                showOutput(origin, args.isSilent(), "Saving as '" + functionName
                         + "': " + script);
                 if (globalConfig.hasOptionString(domain, "eval.baseFile")) {
                     try {
                             writer.flush();
                         }
                     } catch (IOException ioe) {
-                        sendLine(origin, args.isSilent(), FORMAT_ERROR, "IOException: " + ioe.
-                                getMessage());
+                        showError(origin, args.isSilent(), "IOException: " + ioe.getMessage());
                     }
                 } else {
-                    sendLine(origin, args.isSilent(), FORMAT_ERROR,
+                    showError(origin, args.isSilent(),
                             "No baseFile specified, please /set " + domain
                             + " eval.baseFile filename (stored in scripts dir of profile)");
                 }
             } else if (sargs.length > 1) {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
-                        "You must specify some script to save.");
+                showError(origin, args.isSilent(), "You must specify some script to save.");
             } else {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR,
+                showError(origin, args.isSilent(),
                         "You must specify a function name and some script to save.");
             }
         } else if (sargs.length > 0 && "help".equalsIgnoreCase(sargs[0])) {
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+            showOutput(origin, args.isSilent(),
                     "This command allows you to interact with the script plugin");
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "-------------------");
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+            showOutput(origin, args.isSilent(), "-------------------");
+            showOutput(origin, args.isSilent(),
                     "reload/rehash                  - Reload all loaded scripts");
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+            showOutput(origin, args.isSilent(),
                     "load <script>                  - load scripts/<script> (file name relative to scripts dir)");
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+            showOutput(origin, args.isSilent(),
                     "unload <script>                - unload <script> (full file name)");
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+            showOutput(origin, args.isSilent(),
                     "eval <script>                  - evaluate the code <script> and return the result");
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+            showOutput(origin, args.isSilent(),
                     "savetobasefile <name> <script> - save the code <script> to the eval basefile ("
                     + domain + ".eval.basefile)");
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+            showOutput(origin, args.isSilent(),
                     "                                 as the function <name> (name/foo/bar will save it as 'name' with foo and");
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT,
+            showOutput(origin, args.isSilent(),
                     "                                 bar as arguments.");
-            sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "-------------------");
+            showOutput(origin, args.isSilent(), "-------------------");
         } else {
-            sendLine(origin, args.isSilent(), FORMAT_ERROR, "Unknown subcommand.");
+            showError(origin, args.isSilent(), "Unknown subcommand.");
         }
     }
 

tabcompletion_bash/res/META-INF/format.yml

+---
+BashDisambiguationEvent:
+  format: "Multiple possibilities: {{matches}}."
+  colour: 14

activewindow/test/com/dmdirc/addons/activewindow/ActiveWindowManagerTest.java → tabcompletion_bash/src/com/dmdirc/addons/tabcompletion_bash/BashDisambiguationEvent.java

  * SOFTWARE.
  */
 
-package com.dmdirc.addons.activewindow;
+package com.dmdirc.addons.tabcompletion_bash;
 
-import com.dmdirc.ui.messages.sink.MessageSinkManager;
+import com.dmdirc.events.BaseDisplayableEvent;
+import com.dmdirc.interfaces.WindowModel;
 
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-
-import static org.mockito.Mockito.verify;
-
-@RunWith(MockitoJUnitRunner.class)
-public class ActiveWindowManagerTest {
+/**
+ * Event raised when multiple potential results match a bash-style completion attempt.
+ */
+public class BashDisambiguationEvent extends BaseDisplayableEvent {
 
-    @Mock private MessageSinkManager messageSinkManager;
-    @Mock private ActiveWindowMessageSink activeWindowMessageSink;
-    private ActiveWindowManager activeWindowManager;
+    private final String matches;
 
-    @Before
-    public void setUp() throws Exception {
-        activeWindowManager = new ActiveWindowManager(messageSinkManager, activeWindowMessageSink);
+    public BashDisambiguationEvent(final long timestamp, final WindowModel source,
+            final String matches) {
+        super(timestamp, source);
+        this.matches = matches;
     }
 
-    @Test
-    public void testRegister() throws Exception {
-        activeWindowManager.register();
-        verify(messageSinkManager).addSink(activeWindowMessageSink);
+    public BashDisambiguationEvent(final WindowModel source, final String matches) {
+        super(source);
+        this.matches = matches;
     }
 
-    @Test
-    public void testUnregister() throws Exception {
-        activeWindowManager.unregister();
-        verify(messageSinkManager).removeSink(activeWindowMessageSink);
+    public String getMatches() {
+        return matches;
     }
-}
+
+}

tabcompletion_bash/src/com/dmdirc/addons/tabcompletion_bash/BashStyle.java

 
             final String sub = getBestSubstring(res);
             if (sub.equalsIgnoreCase(word) && tabCount >= 2) {
-                window.addLine("tabCompletion", res.toString());
-
+                window.getEventBus().publishAsync(
+                        new BashDisambiguationEvent(window, res.toString()));
                 return null;
             } else {
                 return new TabCompletionResult(

time/src/com/dmdirc/addons/time/TimerCommand.java

         }
 
         if (interval < 1) {
-            sendLine(origin, args.isSilent(), FORMAT_ERROR, "Cannot use intervals below 1");
+            showError(origin, args.isSilent(), "Cannot use intervals below 1");
             return;
         }
 
         manager.addTimer(repetitions, interval, command, origin);
-
-        sendLine(origin, args.isSilent(), FORMAT_OUTPUT, "Command scheduled.");
+        showOutput(origin, args.isSilent(), "Command scheduled.");
     }
 
     private void doCancel(final WindowModel origin, final boolean isSilent, final String arg) {
         }
         if (manager.hasTimerWithID(timerKey)) {
             manager.getTimerByID(timerKey).cancelTimer();
-            sendLine(origin, isSilent, FORMAT_OUTPUT, "Timer cancelled");
+            showOutput(origin, isSilent, "Timer cancelled");
         } else {
-            sendLine(origin, isSilent, FORMAT_ERROR, "There is currently no timer with that ID");
+            showError(origin, isSilent, "There is currently no timer with that ID");
         }
     }
 
     private void doList(final WindowModel origin, final boolean isSilent) {
         final Set<Entry<Integer, TimedCommand>> timerList = manager.listTimers();
         if (timerList.isEmpty()) {
-            sendLine(origin, isSilent, FORMAT_ERROR, "There are currently no active timers");
+            showError(origin, isSilent, "There are currently no active timers");
         } else {
             for (Entry<Integer, TimedCommand> entry : timerList) {
-                sendLine(origin, isSilent, FORMAT_OUTPUT,
+                showOutput(origin, isSilent,
                         "Timer ID: " + entry.getKey() + " - " + entry.getValue().getCommand());
             }
         }

time/test/com/dmdirc/addons/time/TimerCommandTest.java

 
 package com.dmdirc.addons.time;
 
+import com.dmdirc.DMDircMBassador;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.commands.IntelligentCommand.IntelligentCommandContext;
 import com.dmdirc.commandparser.commands.context.CommandContext;
+import com.dmdirc.events.CommandErrorEvent;
+import com.dmdirc.events.CommandOutputEvent;
 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.WindowModel;
 import com.dmdirc.ui.input.AdditionalTabTargets;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
 import static junit.framework.TestCase.assertEquals;
 import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
     @Mock private TimerManager timerManager;
     @Mock private CommandController commandController;
     @Mock private WindowModel frameContainer;
+    @Mock private DMDircMBassador eventbus;
     @Mock private CommandContext commandContext;
     @Mock private IntelligentCommandContext intelligentCommandContext;
     @Mock private CommandArguments commandArguments;
     @Mock private TimedCommand timer;
+    @Captor private ArgumentCaptor<CommandOutputEvent> outputEventCaptor;
+    @Captor private ArgumentCaptor<CommandErrorEvent> errorEventCaptor;
 
     private TimerCommand instance;
 
         when(commandArguments.isSilent()).thenReturn(false);
         when(timerManager.getTimerByID(anyInt())).thenReturn(timer);
         when(commandController.getCommandChar()).thenReturn('/');
+        when(frameContainer.getEventBus()).thenReturn(eventbus);
     }
 
     private void mockCommandArguments(final String one, final String two) {
         mockCommandArguments("--list", "", "");
         instance.execute(frameContainer, commandArguments, commandContext);
         verify(timerManager, times(1)).listTimers();
-        verify(frameContainer).addLine("commandError", "There are currently no active timers");
+        verify(eventbus).publishAsync(errorEventCaptor.capture());
+        assertEquals("There are currently no active timers", errorEventCaptor.getValue().getMessage());
     }
 
     @Test
         mockCommandArguments("--list", "", "");
         instance.execute(frameContainer, commandArguments, commandContext);
         verify(timerManager, times(1)).listTimers();
-        verify(frameContainer).addLine("commandOutput", "Timer ID: 1 - null");
+        verify(eventbus).publishAsync(outputEventCaptor.capture());
+        assertEquals("Timer ID: 1 - null", outputEventCaptor.getValue().getMessage());
     }
 
     @Test
     public void testExecute_incorrect() throws Exception {
         mockCommandArguments("woop", "woop");
         instance.execute(frameContainer, commandArguments, commandContext);
-        verify(frameContainer, times(1)).addLine(eq("commandUsage"), eq('/'),
-                eq(TimerCommand.INFO.getName()), eq(TimerCommand.INFO.getHelp()));
+        verify(eventbus).publishAsync(errorEventCaptor.capture());
     }
 
     @Test
     public void testExecute_no_args() throws Exception {
         when(commandArguments.getArguments()).thenReturn(new String[0]);
         instance.execute(frameContainer, commandArguments, commandContext);
-        verify(frameContainer, times(1)).addLine(eq("commandUsage"), eq('/'),
-                eq(TimerCommand.INFO.getName()), eq(TimerCommand.INFO.getHelp()));
+        verify(eventbus).publishAsync(errorEventCaptor.capture());
     }
 
     @Test
     public void testExecute_too_few_args() throws Exception {
         mockCommandArguments("woop", "woop");
         instance.execute(frameContainer, commandArguments, commandContext);
-        verify(frameContainer, times(1)).addLine(eq("commandUsage"), eq('/'),
-                eq(TimerCommand.INFO.getName()), eq(TimerCommand.INFO.getHelp()));
+        verify(eventbus).publishAsync(errorEventCaptor.capture());
     }
 
     @Test
     public void testExecute_repetitions_not_number() throws Exception {
         mockCommandArguments("woop", "woop", "woop");
         instance.execute(frameContainer, commandArguments, commandContext);
-        verify(frameContainer, times(1)).addLine(eq("commandUsage"), eq('/'),
-                eq(TimerCommand.INFO.getName()), eq(TimerCommand.INFO.getHelp()));
+        verify(eventbus).publishAsync(errorEventCaptor.capture());
     }
 
     @Test
     public void testExecute_interval_not_number() throws Exception {
         mockCommandArguments("1", "woop", "woop");
         instance.execute(frameContainer, commandArguments, commandContext);
-        verify(frameContainer, times(1)).addLine(eq("commandUsage"), eq('/'),
-                eq(TimerCommand.INFO.getName()), eq(TimerCommand.INFO.getHelp()));
+        verify(eventbus).publishAsync(errorEventCaptor.capture());
     }
 
     @Test
     public void testExecute_interval_invalid() throws Exception {
         mockCommandArguments("1", "0", "woop");
         instance.execute(frameContainer, commandArguments, commandContext);
-        verify(frameContainer, times(1))
-                .addLine(eq("commandError"), eq("Cannot use intervals below 1"));
+        verify(eventbus).publishAsync(errorEventCaptor.capture());
+        assertEquals("Cannot use intervals below 1", errorEventCaptor.getValue().getMessage());
     }
 
     @Test
         mockCommandArguments("1", "1", "woop");
         instance.execute(frameContainer, commandArguments, commandContext);
         verify(timerManager).addTimer(1, 1, "woop", frameContainer);
-        verify(frameContainer, times(1)).addLine(eq("commandOutput"), eq("Command scheduled."));
+        verify(eventbus).publishAsync(outputEventCaptor.capture());
+        assertEquals("Command scheduled.", outputEventCaptor.getValue().getMessage());
     }
 
     @Test

ui_swing/plugin.config

     showfulltopic=false
     hideEmptyTopicBar=false
     textpanebackground=
-    textpanebackgroundoption=STRETCH
+    textpanebackgroundoption=SCALE
+    textpanebackgroundopacity=1
     desktopbackground=dmdirc://com/dmdirc/res/background.png
     desktopbackgroundoption=CENTER
     showjrewarning=true

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

 import com.dmdirc.addons.ui_swing.components.SupplierLoggingSwingWorker;
 import com.dmdirc.util.colours.Colour;
 
+import java.awt.AlphaComposite;
 import java.awt.Color;
+import java.awt.Composite;
 import java.awt.Font;
 import java.awt.FontMetrics;
 import java.awt.Graphics2D;
      * @param bounds           Bounds to paint within
      * @param backgroundImage  background image
      * @param backgroundOption How to draw the background
+     * @param opacity          Opacity of the image
      */
     public static void paintBackground(final Graphics2D g,
             final Rectangle bounds,
             final Image backgroundImage,
-            final BackgroundOption backgroundOption) {
+            final BackgroundOption backgroundOption,
+            final float opacity) {
         if (backgroundImage == null) {
             paintNoBackground(g, bounds);
         } else {
             switch (backgroundOption) {
                 case TILED:
-                    paintTiledBackground(g, bounds, backgroundImage);
+                    paintTiledBackground(g, bounds, backgroundImage, opacity);
                     break;
                 case SCALE:
-                    paintStretchedBackground(g, bounds, backgroundImage);
+                    paintStretchedBackground(g, bounds, backgroundImage, opacity);
                     break;
                 case SCALE_ASPECT_RATIO:
-                    paintStretchedAspectRatioBackground(g, bounds, backgroundImage);
+                    paintStretchedAspectRatioBackground(g, bounds, backgroundImage, opacity);
                     break;
                 case CENTER:
-                    paintCenterBackground(g, bounds, backgroundImage);
+                    paintCenterBackground(g, bounds, backgroundImage, opacity);
                     break;
                 default:
                     break;
     }
 
     private static void paintStretchedBackground(final Graphics2D g,
-            final Rectangle bounds, final Image backgroundImage) {
+            final Rectangle bounds, final Image backgroundImage, final float opacity) {
+        final Composite originalComposite = g.getComposite();
+        g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, opacity));
         g.drawImage(backgroundImage, 0, 0, bounds.width, bounds.height, null);
+        g.setComposite(originalComposite);
     }
 
     private static void paintCenterBackground(final Graphics2D g,
-            final Rectangle bounds, final Image backgroundImage) {
+            final Rectangle bounds, final Image backgroundImage, final float opacity) {
         final int x = bounds.width / 2 - backgroundImage.getWidth(null) / 2;
         final int y = bounds.height / 2 - backgroundImage.getHeight(null) / 2;
+        final Composite originalComposite = g.getComposite();
+        g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, opacity));
         g.drawImage(backgroundImage, x, y, backgroundImage.getWidth(null),
                 backgroundImage.getHeight(null), null);
+        g.setComposite(originalComposite);
     }
 
     private static void paintStretchedAspectRatioBackground(final Graphics2D g,
-            final Rectangle bounds, final Image backgroundImage) {
+            final Rectangle bounds, final Image backgroundImage, final float opacity) {
         final double widthratio = bounds.width
                 / (double) backgroundImage.getWidth(null);
         final double heightratio = bounds.height
 
         final int x = bounds.width / 2 - width / 2;
         final int y = bounds.height / 2 - height / 2;
+        final Composite originalComposite = g.getComposite();
+        g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, opacity));
         g.drawImage(backgroundImage, x, y, width, height, null);
+        g.setComposite(originalComposite);
     }
 
     private static void paintTiledBackground(final Graphics2D g,
-            final Rectangle bounds, final Image backgroundImage) {
+            final Rectangle bounds, final Image backgroundImage, final float opacity) {
         final int width = backgroundImage.getWidth(null);
         final int height = backgroundImage.getHeight(null);
 
             return;
         }
 
+        final Composite originalComposite = g.getComposite();
+        g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, opacity));
         for (int x = 0; x < bounds.width; x += width) {
             for (int y = 0; y < bounds.height; y += height) {
                 g.drawImage(backgroundImage, x, y, width, height, null);
             }
         }
+        g.setComposite(originalComposite);
     }
 
     /**

ui_swing/src/com/dmdirc/addons/ui_swing/commands/PopInCommand.java

         UIUtilities.invokeLater(() -> {
             final TextFrame swingWindow = windowFactory.getSwingWindow(origin);
             if (swingWindow == null) {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR, "There is"
-                        + " currently no window to pop in.");
+                showError(origin, args.isSilent(), "There is currently no window to pop in.");
             } else {
                 swingWindow.setPopout(false);
             }

ui_swing/src/com/dmdirc/addons/ui_swing/commands/PopOutCommand.java

         UIUtilities.invokeLater(() -> {
             final TextFrame swingWindow = windowFactory.getSwingWindow(origin);
             if (swingWindow == null) {
-                sendLine(origin, args.isSilent(), FORMAT_ERROR, "There is"
-                        + " currently no window to pop out.");
+                showError(origin, args.isSilent(), "There is currently no window to pop out.");
             } else {
                 swingWindow.setPopout(true);
             }

ui_swing/src/com/dmdirc/addons/ui_swing/dialogs/channelsetting/TopicDisplayPane.java

 import java.awt.Color;
 import java.awt.datatransfer.Clipboard;
 import java.awt.event.KeyEvent;
-import java.util.Date;
 import java.util.Optional;
 
 import javax.swing.JLabel;
         if (topic.isPresent()) {
             topicWho.setText("Topic set by " + topic.get().getClient()
                     .map(GroupChatUser::getNickname).orElse("Unknown")
-                    + "<br> on " + new Date(1000 * topic.get().getTime()));
+                    + "<br> on " + topic.get().getDate());
             topicText.setText(topic.get().getTopic());
         } else {
             topicWho.setText("No topic set.");

ui_swing/src/com/dmdirc/addons/ui_swing/dialogs/channelsetting/TopicLabel.java

 import com.dmdirc.interfaces.GroupChatUser;
 
 import java.awt.Color;
-import java.util.Date;
 
 import javax.swing.JEditorPane;
 import javax.swing.JPanel;
 
     /** A version number for this class. */
     private static final long serialVersionUID = 1;
-    /** How many milliseconds in a second. */
-    private static final int MILLIS_IN_SECOND = 1000;
     /** Topic this label represents. */
     private final Topic topic;
     /** The group chat to which this label belongs. */
         }
         add(label, "wmax 450, grow, push, wrap, gapleft 5, pad 0");
 
-        label = new TextLabel("on " + new Date(topic.getTime() * MILLIS_IN_SECOND));
+        label = new TextLabel("on " + topic.getDate());
         add(label, "wmax 450, grow, push, wrap, gapleft 5, pad 0");
 
         add(new JSeparator(), "newline, span, growx, pushx");

ui_swing/src/com/dmdirc/addons/ui_swing/dialogs/globalautocommand/GlobalAutoCommandDialog.java

     }
 
     private void layoutComponents() {
+        setTitle("Global Perform");
         setLayout(new MigLayout("fill"));
         add(new TextLabel("These commands will be executed when the client starts."),
                 "wrap, span 2");

ui_swing/src/com/dmdirc/addons/ui_swing/textpane/BackgroundPainter.java

      */
     @Nonnull
     private final String optionKey;
+    /**
+     * Key in the domain to get image opacity level.
+     */
+    @Nonnull
+    private final String opacityKey;
+
     /** The URL builder to use to find icons. */
     private final URLBuilder urlBuilder;
     /**
      * Background option type.
      */
     private BackgroundOption backgroundOption;
+    /**
+     * Background opacity.
+     */
+    private float opacity;
 
     /**
      * Creates a new background painter.
      * @param domain        Domain to retrieve settings from
      * @param imageKey      Key for background image
      * @param optionKey     Key for background type
+     * @param opacityKey    Key for the opacity
      */
     public BackgroundPainter(
             final AggregateConfigProvider configManager,
             final URLBuilder urlBuilder,
             @Nonnull final String domain, @Nonnull final String imageKey,
-            @Nonnull final String optionKey) {
+            @Nonnull final String optionKey, @Nonnull final String opacityKey) {
         this.configManager = configManager;
         this.urlBuilder = urlBuilder;
         this.domain = domain;
         this.imageKey = imageKey;
         this.optionKey = optionKey;
+        this.opacityKey = opacityKey;
         configManager.getBinder().bind(this, BackgroundPainter.class);
     }
 
         return optionKey;
     }
 
+    @Nonnull
+    protected String getOpacityKey() {
+        return opacityKey;
+    }
+
     protected void setBackgroundImage(final Image backgroundImage) {
         this.backgroundImage = backgroundImage;
     }
         }
     }
 
+    @ConfigBinding(domain = "plugin-ui_swing", key = "textpanebackgroundopacity")
+    public void updateOpacity(final String opacity) {
+        try {
+            this.opacity = Float.valueOf(opacity);
+            if (this.opacity < 0 || this.opacity > 1) {
+                this.opacity = 1;
+            }
+        } catch (IllegalArgumentException ex) {
+            this.opacity = 1;
+        }
+    }
+
     @Override
     public void paint(final Graphics graphics, final JComponent component) {
         final Graphics2D g2 = (Graphics2D) graphics;
         g2.setColor(component.getBackground());
         g2.fill(g2.getClipBounds());
         UIUtilities.paintBackground(g2, component.getBounds(),
-                backgroundImage, backgroundOption);
+                backgroundImage, backgroundOption, opacity);
         super.paint(graphics, component);
     }
 

ui_swing/src/com/dmdirc/addons/ui_swing/textpane/TextPane.java

         setLayout(new MigLayout("fill, hidemode 3"));
         backgroundPainter = new BackgroundPainter(frame.getContainer().getConfigManager(),
                 urlBuilder, configDomain, "textpanebackground",
-                "textpanebackgroundoption");
+                "textpanebackgroundoption", "textpanebackgroundopacity");
         canvas = new TextPaneCanvas(this,
                 new CachingDocument<>(document, new AttributedStringMessageMaker()));
         final JLayer<JComponent> layer = new JLayer<>(canvas);

ui_swing/test/com/dmdirc/addons/ui_swing/components/GenericTableModelTest.java

 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
-import static junit.framework.Assert.assertEquals;
-import static junit.framework.Assert.assertSame;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.verify;
 

ui_web2/build.gradle

+dependencies {
+  bundle group: 'com.sparkjava', name: 'spark-core', version: '2.3'
+  bundle group: 'com.google.code.gson', name: 'gson', 'version': '2.5'
+}

ui_web2/plugin.config

+# This is a DMDirc configuration file.
+
+# This section indicates which sections below take key/value
+# pairs, rather than a simple list. It should be placed above
+# any sections that take key/values.
+keysections:
+  metadata
+  updates
+  version
+  defaults
+
+metadata:
+  author=Chris <chris@dmdirc.com>
+  mainclass=com.dmdirc.addons.ui_web2.WebUiPlugin
+  description=Web-based DMDirc user interface
+  name=ui_web2
+  nicename=Web UI
+
+updates:
+  id=81
+
+version:
+  friendly=0.0
+
+provides:
+  #web ui
+
+defaults:
+  port=4567
+
+exports:
+

ui_web2/res/META-INF/services/org.eclipse.jetty.http.HttpFieldPreEncoder

+org.eclipse.jetty.http.Http1FieldPreEncoder

ui_web2/res/jetty-logging.properties

+#
+# Copyright (c) 2006-2016 DMDirc Developers
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+
+# Configure Jetty for StdErrLog Logging
+org.eclipse.jetty.util.log.class=org.eclipse.jetty.util.log.StrErrLog
+# Overall Logging Level is INFO
+org.eclipse.jetty.LEVEL=DEBUG

ui_web2/res/www/index.html

+<!DOCTYPE html>
+<html>
+  <head>
+    <title>DMDirc</title>
+      <script src="js/socket.js"></script>
+  </head>
+  <body>
+    HELLO WORLD
+  </body>
+</html>

ui_web2/res/www/js/socket.js

+socket = null;
+
+function getAddress() {
+    var loc = window.location;
+    var uri = loc.protocol === "https:" ? "wss:" : "ws:";
+    uri += "//" + loc.host + "/ws";
+    return uri;
+}
+
+function connect() {
+    socket = new WebSocket(getAddress());
+
+    socket.onmessage = function(event) {
+      console.log(event.data);
+    }
+}
+
+function send(data) {
+    socket.send(JSON.stringify(data));
+}

ui_web2/src/com/dmdirc/addons/ui_web2/InitialStateProducer.java

+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.ui_web2;
+
+import com.dmdirc.addons.ui_web2.serialisers.BackBufferSerializer;
+import com.dmdirc.addons.ui_web2.serialisers.WindowModelSerialiser;
+import com.dmdirc.interfaces.WindowModel;
+import com.dmdirc.ui.WindowManager;
+import com.dmdirc.ui.messages.BackBuffer;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import javax.inject.Inject;
+
+/**
+ * Handles compiling the initial burst of state that will be sent to new web clients.
+ */
+public class InitialStateProducer {
+
+    private final Gson serialiser;
+    private final WindowManager windowManager;
+
+    @Inject
+    public InitialStateProducer(final WindowManager windowManager) {
+        serialiser = new GsonBuilder()
+                .registerTypeHierarchyAdapter(WindowModel.class, new WindowModelSerialiser())
+                .registerTypeAdapter(BackBuffer.class, new BackBufferSerializer())
+                .create();
+        this.windowManager = windowManager;
+    }
+
+    public String getInitialState() {
+        final InitialState state = new InitialState(windowManager.getRootWindows());
+        return serialiser.toJson(state);
+    }
+
+    private static class InitialState {
+
+        private final Collection<WindowModel> windows;
+
+        private InitialState(final Collection<WindowModel> windows) {
+            this.windows = windows;
+        }
+
+        public Collection<WindowModel> getWindows() {
+            return Collections.unmodifiableCollection(windows);
+        }
+    }
+
+}

activewindow/src/com/dmdirc/addons/activewindow/ActiveWindowModule.java → ui_web2/src/com/dmdirc/addons/ui_web2/WebServer.java

  * SOFTWARE.
  */
 
-package com.dmdirc.addons.activewindow;
+package com.dmdirc.addons.ui_web2;
 
-import com.dmdirc.addons.ui_swing.injection.SwingModule;
-
-import dagger.Module;
+import spark.Spark;
 
 /**
- * DI module for the active window plugin.
+ * Web server used by the web UI.
  */
-@Module(injects = {ActiveWindowManager.class, ActiveCommand.class}, addsTo = SwingModule.class)
-public class ActiveWindowModule {
+public class WebServer {
+
+    private final int port;
+
+    public WebServer(final int port) {
+        this.port = port;
+    }
+
+    public void start() {
+        Spark.port(port);
+        Spark.webSocket("/ws", WebSocketHandler.class);
+        Spark.staticFileLocation("/www");
+        Spark.get("/test", (request, response) -> "HELLO");
+    }
+
+    public void stop() {
+        Spark.stop();
+    }
+
 }

ui_web2/src/com/dmdirc/addons/ui_web2/WebSocketController.java

+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.ui_web2;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.eclipse.jetty.websocket.api.Session;
+
+/**
+ * Manages events raised by the {@link WebSocketHandler}.
+ *
+ * <p>This serves as a bridge between the {@link WebSocketHandler}, which cannot have dependencies
+ * passed in sanely due to the framework, and the rest of the plugin/client.
+ */
+@Singleton
+public class WebSocketController {
+
+    private final Collection<Session> sessions = new CopyOnWriteArrayList<>();
+    private final InitialStateProducer initialStateProducer;
+
+    @Inject
+    public WebSocketController(final InitialStateProducer initialStateProducer) {
+        this.initialStateProducer = initialStateProducer;
+    }
+
+    void sessionConnected(final Session session) {
+        sessions.add(session);
+        sendMessage(session, initialStateProducer.getInitialState());
+    }
+
+    void sessionClosed(final Session session, final int statusCode, final String reason) {
+        sessions.remove(session);
+    }
+
+    void messageReceived(final Session session, final String message) {
+        // Echo the message back for testing
+        sendMessage(session, message);
+    }
+
+    /**
+     * Sends a message to a specific session.
+     *
+     * @param session The session to send a message to.
+     * @param message The message to be sent.
+     */
+    public void sendMessage(final Session session, final String message) {
+        try {
+            WebSocketHandler.sendMessage(session, message);
+        } catch (IOException ex) {
+            // TODO: Raise an error...
+        }
+    }
+
+    /**
+     * Sends a message to all connected sessions.
+     *
+     * @param message The message to be sent.
+     */
+    public void sendMessage(final String message) {
+        sessions.forEach(s -> sendMessage(s, message));
+    }
+
+}

ui_web2/src/com/dmdirc/addons/ui_web2/WebSocketHandler.java

+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.ui_web2;
+
+import java.io.IOException;
+
+import org.eclipse.jetty.websocket.api.Session;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
+import org.eclipse.jetty.websocket.api.annotations.WebSocket;
+
+/**
+ * Handles websocket connections.
+ */
+@WebSocket
+public class WebSocketHandler {
+
+    /** Controller to use. */
+    @SuppressWarnings("StaticNonFinalField")
+    private static WebSocketController controller;
+
+    /**
+     * Sets the controller that manages ALL instances of {@link WebSocketHandler}.
+     *
+     * @param controller Controller to use.
+     */
+    @SuppressWarnings("StaticMethodOnlyUsedInOneClass")
+    public static void setController(final WebSocketController controller) {
+        WebSocketHandler.controller = controller;
+    }
+
+    @OnWebSocketConnect
+    public void connected(final Session session) {
+        controller.sessionConnected(session);
+    }
+
+    @OnWebSocketClose
+    public void closed(final Session session, final int statusCode, final String reason) {
+        controller.sessionClosed(session, statusCode, reason);
+    }
+
+    @OnWebSocketMessage
+    public void message(final Session session, final String message) {
+        controller.messageReceived(session, message);
+    }
+
+    public static void sendMessage(final Session session, final String message) throws IOException {
+        session.getRemote().sendString(message);
+    }
+
+}

ui_web2/src/com/dmdirc/addons/ui_web2/WebUiModule.java

+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.ui_web2;
+
+import com.dmdirc.ClientModule;
+import com.dmdirc.ClientModule.GlobalConfig;
+import com.dmdirc.interfaces.config.AggregateConfigProvider;
+import com.dmdirc.plugins.PluginDomain;
+import com.dmdirc.plugins.PluginInfo;
+
+import javax.inject.Singleton;
+
+import dagger.Module;
+import dagger.Provides;
+
+/**
+ * Dagger module that provides Web UI-specific dependencies.
+ */
+@Module(
+        addsTo = ClientModule.class,
+        injects = WebServer.class,
+        library = true
+)
+@SuppressWarnings("TypeMayBeWeakened")
+public class WebUiModule {
+
+    private final PluginInfo pluginInfo;
+    private final String domain;
+
+    public WebUiModule(final PluginInfo pluginInfo, final String domain) {
+        this.pluginInfo = pluginInfo;
+        this.domain = domain;
+    }
+
+    @Provides
+    @PluginDomain(WebUiPlugin.class)
+    public String getSettingsDomain() {
+        return domain;
+    }
+
+    @Provides
+    @PluginDomain(WebUiPlugin.class)
+    public PluginInfo getPluginInfo() {
+        return pluginInfo;
+    }
+
+    @Provides
+    @Singleton
+    public WebServer getWebServer(
+            @PluginDomain(WebUiPlugin.class) final String domain,
+            @GlobalConfig final AggregateConfigProvider globalConfig,
+            final WebSocketController controller) {
+        WebSocketHandler.setController(controller);
+        final int port = globalConfig.getOptionInt(domain, "port");
+        return new WebServer(port);
+    }
+
+}

activewindow/src/com/dmdirc/addons/activewindow/ActiveWindowPlugin.java → ui_web2/src/com/dmdirc/addons/ui_web2/WebUiPlugin.java

  * SOFTWARE.
  */
 
-package com.dmdirc.addons.activewindow;
+package com.dmdirc.addons.ui_web2;
 
 import com.dmdirc.plugins.PluginInfo;
-import com.dmdirc.plugins.implementations.BaseCommandPlugin;
+import com.dmdirc.plugins.implementations.BasePlugin;
 
 import dagger.ObjectGraph;
 
-/** Plugin to provide an active window command to the Swing UI. */
-public class ActiveWindowPlugin extends BaseCommandPlugin {
+/**
+ * Web UI plugin.
+ */
+public class WebUiPlugin extends BasePlugin {
 
-    /** Manager to use for the active window sink. */
-    private ActiveWindowManager activeWindowManager;
+    private WebServer webServer;
 
     @Override
     public void load(final PluginInfo pluginInfo, final ObjectGraph graph) {
         super.load(pluginInfo, graph);
 
-        setObjectGraph(graph.plus(new ActiveWindowModule()));
-        registerCommand(ActiveCommand.class, ActiveCommand.INFO);
+        setObjectGraph(graph.plus(new WebUiModule(pluginInfo, pluginInfo.getDomain())));
+        getObjectGraph().validate();
 
-        activeWindowManager = getObjectGraph().get(ActiveWindowManager.class);
+        webServer = getObjectGraph().get(WebServer.class);
     }
 
     @Override
     public void onLoad() {
         super.onLoad();
-        activeWindowManager.register();
+        webServer.start();
     }
 
     @Override
     public void onUnload() {
         super.onUnload();
-        activeWindowManager.unregister();
+        webServer.stop();
     }
 
 }

ui_web2/src/com/dmdirc/addons/ui_web2/serialisers/BackBufferSerializer.java

+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.ui_web2.serialisers;
+
+import com.dmdirc.ui.messages.BackBuffer;
+import com.dmdirc.ui.messages.IRCDocument;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+
+import java.lang.reflect.Type;
+
+/**
+ * Serializes {@link BackBuffer}s.
+ */
+public class BackBufferSerializer implements JsonSerializer<BackBuffer> {
+
+    @Override
+    public JsonElement serialize(final BackBuffer src, final Type typeOfSrc,
+            final JsonSerializationContext context) {
+        final JsonArray res = new JsonArray();
+        final IRCDocument document = src.getDocument();
+        for (int i = 0; i < document.getNumLines(); i++) {
+            // TODO: Pass on foreground and background colours
+            res.add(document.getLine(i).getText());
+        }
+        return res;
+    }
+
+}

ui_web2/src/com/dmdirc/addons/ui_web2/serialisers/WindowModelSerialiser.java

+/*
+ * Copyright (c) 2006-2015 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.ui_web2.serialisers;
+
+import com.dmdirc.interfaces.WindowModel;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+
+import java.lang.reflect.Type;
+
+/**
+ * Serialises {@link WindowModel}s.
+ */
+public class WindowModelSerialiser implements JsonSerializer<WindowModel> {
+
+    @Override
+    public JsonElement serialize(final WindowModel src, final Type typeOfSrc,
+            final JsonSerializationContext context) {
+        final JsonObject res = new JsonObject();
+        res.addProperty("name", src.getName());
+        res.addProperty("icon", src.getIcon());
+        res.addProperty("title", src.getTitle());
+        res.addProperty("writable", src.isWritable());
+        res.add("children", context.serialize(src.getChildren()));
+        res.add("components", context.serialize(src.getComponents()));
+        res.add("backbuffer", context.serialize(src.getBackBuffer()));
+        return res;
+    }
+
+}