Couple more deprecation fixes.

res/com/dmdirc/ui/messages/format.yml

   colour: 7
 CommandOutputEvent:
   format: "{{message}}"
+UnknownCommandEvent:
+  format: "Unknown command {{command}}."
+  colour: 14
 
 ################## TODO ############################################################################
 #  selfCTCP=4->- [%1$s] %2$s
 #  serverDisconnectInProgress=A disconnection attempt is in progress, please wait...
 #  serverConnectInProgress=A connection attempt is in progress, please wait...
 #  rawCommand=10>>> %1$s
-#  unknownCommand=14Unknown command %1$s.
 #  commandOutput=%1$s
 #  actionTooLong=Warning: action too long to be sent
 #  tabCompletion=14Multiple possibilities: %1$s

src/com/dmdirc/GroupChatManagerImpl.java

         channels.closeAll();
     }
 
+    @Deprecated
     public void addLineToAll(final String messageType, final Date date, final Object... args) {
         channels.addLineToAll(messageType, date, args);
     }

src/com/dmdirc/commandparser/commands/channel/Mode.java

 import com.dmdirc.commandparser.commands.IntelligentCommand;
 import com.dmdirc.commandparser.commands.context.ChannelCommandContext;
 import com.dmdirc.commandparser.commands.context.CommandContext;
+import com.dmdirc.events.ChannelModesDiscoveredEvent;
 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.interfaces.GroupChat;
         final GroupChat channel = ((ChannelCommandContext) context).getGroupChat();
 
         if (args.getArguments().length == 0) {
-            sendLine(origin, args.isSilent(), "channelModeDiscovered", channel.getModes(), channel);
+            channel.getEventBus().publishAsync(new ChannelModesDiscoveredEvent(
+                    channel, channel.getModes()));
         } else {
             channel.getConnection().get().getParser().get().sendRawMessage("MODE "
                     + channel.getName() + ' ' + args.getArgumentsAsString());

src/com/dmdirc/commandparser/parsers/CommandParser.java

 import com.dmdirc.interfaces.GroupChat;
 import com.dmdirc.interfaces.WindowModel;
 import com.dmdirc.interfaces.config.ReadOnlyConfigProvider;
-import com.dmdirc.util.EventUtils;
 import com.dmdirc.util.collections.RollingList;
 
 import java.io.Serializable;
      */
     protected void handleInvalidCommand(final WindowModel origin,
             final CommandArguments args) {
-        if (origin == null) {
-            eventBus.publish(new UnknownCommandEvent(null, args.getCommandName(), args.getArguments()));
-        } else {
-            final UnknownCommandEvent event = new UnknownCommandEvent(origin,
-                    args.getCommandName(), args.getArguments());
-            final String format = EventUtils.postDisplayable(eventBus, event, "unknownCommand");
-
-            origin.addLine(format, args.getCommandName());
-        }
+        eventBus.publishAsync(new UnknownCommandEvent(origin, args.getCommandName(),
+                args.getArguments()));
     }
 
     /**

test/com/dmdirc/commandparser/commands/channel/ModeTest.java

 package com.dmdirc.commandparser.commands.channel;
 
 import com.dmdirc.Channel;
+import com.dmdirc.DMDircMBassador;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.commands.context.ChannelCommandContext;
 import com.dmdirc.config.InvalidIdentityFileException;
+import com.dmdirc.events.ChannelModesDiscoveredEvent;
 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.interfaces.Connection;
 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.assertEquals;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 public class ModeTest {
 
     @Mock private WindowModel origin;
+    @Mock private DMDircMBassador eventbus;
     @Mock private CommandController controller;
     @Mock private Channel channel;
     @Mock private Connection connection;
     @Mock private Parser parser;
+    @Captor private ArgumentCaptor<ChannelModesDiscoveredEvent> modeDiscoveredCaptor;
     private Mode command;
 
     @Before
         when(connection.getParser()).thenReturn(Optional.of(parser));
         when(channel.getModes()).thenReturn("my mode string!");
         when(channel.getName()).thenReturn("#chan");
+        when(channel.getEventBus()).thenReturn(eventbus);
 
         command = new Mode(controller);
     }
     public void testWithoutArgs() {
         command.execute(origin, new CommandArguments(controller, "/mode"),
                 new ChannelCommandContext(null, Mode.INFO, channel));
-
-        verify(origin).addLine("channelModeDiscovered", "my mode string!", channel);
+        verify(eventbus).publishAsync(modeDiscoveredCaptor.capture());
+        assertEquals("my mode string!", modeDiscoveredCaptor.getValue().getModes());
     }
 
     @Test