Change all command output/error to use events.

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");
         }
     }
 

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());
         }
     }
 

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/DCCCommand.java

                 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());
             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());

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

      * @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);

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/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.");
         }
     }
 

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");
         }
     }
 

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.");
         }
     }
 

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);
             }