Merge pull request #554 from greboid/dev2

Fix client after parser changes. Eventbouseseses.

src/com/dmdirc/Channel.java

@@ -282,7 +282,7 @@ public class Channel extends FrameContainer implements GroupChat {
         getConfigManager().getBinder().unbind(this);
 
         connection.getParser().map(Parser::getCallbackManager)
-                .ifPresent(cm -> cm.delAllCallback(eventHandler));
+                .ifPresent(cm -> cm.unsubscribe(eventHandler));
 
         // Trigger any actions neccessary
         if (isOnChannel && connection.getState() != ServerState.CLOSING) {

src/com/dmdirc/ChannelEventHandler.java

@@ -47,27 +47,14 @@ import com.dmdirc.events.ChannelUserAwayEvent;
 import com.dmdirc.events.ChannelUserBackEvent;
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.parser.common.AwayState;
-import com.dmdirc.parser.common.CallbackManager;
+import com.dmdirc.parser.events.ChannelCTCPEvent;
+import com.dmdirc.parser.events.ChannelListModeEvent;
+import com.dmdirc.parser.events.ChannelNamesEvent;
+import com.dmdirc.parser.events.ChannelTopicEvent;
+import com.dmdirc.parser.events.OtherAwayStateEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
-import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
-import com.dmdirc.parser.interfaces.callbacks.ChannelActionListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelCtcpListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelJoinListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelKickListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelListModeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelMessageListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelModeChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelModeNoticeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelNamesListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelNickChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelNoticeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelPartListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelQuitListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelTopicListener;
-import com.dmdirc.parser.interfaces.callbacks.OtherAwayStateListener;
 import com.dmdirc.util.EventUtils;
 
 import com.google.common.base.Strings;
@@ -78,15 +65,12 @@ import java.util.stream.Collectors;
 
 import javax.annotation.Nonnull;
 
+import net.engio.mbassy.listener.Handler;
+
 /**
  * Handles events for channel objects.
  */
-public class ChannelEventHandler extends EventHandler implements
-        ChannelMessageListener, ChannelNamesListener, ChannelTopicListener,
-        ChannelJoinListener, ChannelPartListener, ChannelKickListener,
-        ChannelQuitListener, ChannelActionListener, ChannelNickChangeListener,
-        ChannelModeChangeListener, ChannelCtcpListener, OtherAwayStateListener,
-        ChannelNoticeListener, ChannelModeNoticeListener, ChannelListModeListener {
+public class ChannelEventHandler extends EventHandler {
 
     /** The channel that owns this event handler. */
     private final Channel owner;
@@ -96,23 +80,11 @@ public class ChannelEventHandler extends EventHandler implements
 
     public ChannelEventHandler(final Channel owner, final DMDircMBassador eventBus,
             final GroupChatUserManager groupChatUserManager) {
-        super(eventBus);
         this.owner = owner;
         this.eventBus = eventBus;
         this.groupChatUserManager = groupChatUserManager;
     }
 
-    @SuppressWarnings("unchecked")
-    @Override
-    protected <T extends CallbackInterface> void addCallback(final CallbackManager cbm,
-            final Class<T> type) {
-        if (OtherAwayStateListener.class.equals(type)) {
-            cbm.addCallback(type, (T) this);
-        } else {
-            cbm.addCallback(type, (T) this, owner.getChannelInfo().getName());
-        }
-    }
-
     @Nonnull
     @Override
     protected Connection getConnection() {
@@ -131,36 +103,45 @@ public class ChannelEventHandler extends EventHandler implements
                 .map(c -> client.getClient().equals(c)).orElse(false);
     }
 
-    @Override
-    public void onChannelMessage(final Parser parser, final Date date,
-            final ChannelInfo channel, final ChannelClientInfo client,
-            final String message, final String host) {
-        checkParser(parser);
+    @Handler
+    public void onChannelMessage(final com.dmdirc.parser.events.ChannelMessageEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
 
-        eventBus.publishAsync(new ChannelMessageEvent(date.getTime(), owner,
-                groupChatUserManager.getUserFromClient(client, owner), message));
+        eventBus.publishAsync(new ChannelMessageEvent(event.getDate().getTime(), owner,
+                groupChatUserManager.getUserFromClient(event.getClient(), owner), event.getMessage()));
     }
 
-    @Override
-    public void onChannelGotNames(final Parser parser, final Date date, final ChannelInfo channel) {
-        checkParser(parser);
+    @Handler
+    public void onChannelGotNames(final ChannelNamesEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
 
-        owner.setClients(channel.getChannelClients().stream()
+        owner.setClients(event.getChannel().getChannelClients().stream()
                 .map(client -> groupChatUserManager.getUserFromClient(client, owner))
                 .collect(Collectors.toList()));
-        eventBus.publishAsync(new ChannelGotNamesEvent(date.getTime(), owner));
+        eventBus.publishAsync(new ChannelGotNamesEvent(event.getDate().getTime(), owner));
     }
 
-    @Override
-    public void onChannelTopic(final Parser parser, final Date date,
-            final ChannelInfo channel, final boolean isJoinTopic) {
-        checkParser(parser);
+    @Handler
+    public void onChannelTopic(final ChannelTopicEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
+
+        final ChannelInfo channel = event.getChannel();
+        final Date date = event.getDate();
 
         final Topic topic = Topic.create(channel.getTopic(),
                 owner.getUser(getConnection().getUser(channel.getTopicSetter())).orElse(null),
                 channel.getTopicTime());
 
-        if (isJoinTopic) {
+        if (event.isJoinTopic()) {
             if (Strings.isNullOrEmpty(channel.getTopic())) {
                 eventBus.publishAsync(new ChannelNoTopicEvent(owner));
             } else {
@@ -181,7 +162,7 @@ public class ChannelEventHandler extends EventHandler implements
 
         final Optional<Topic> currentTopic = owner.getCurrentTopic();
         final boolean hasNewTopic = !Strings.isNullOrEmpty(channel.getTopic());
-        if (!isJoinTopic
+        if (!event.isJoinTopic()
                 || !currentTopic.isPresent() && hasNewTopic
                 || currentTopic.isPresent() && !channel.getTopic().equals(
                         owner.getCurrentTopic().get().getTopic())) {
@@ -193,20 +174,28 @@ public class ChannelEventHandler extends EventHandler implements
         }
     }
 
-    @Override
-    public void onChannelJoin(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client) {
-        checkParser(parser);
+    @Handler
+    public void onChannelJoin(final com.dmdirc.parser.events.ChannelJoinEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
 
-        eventBus.publish(new ChannelJoinEvent(date.getTime(), owner,
-                groupChatUserManager.getUserFromClient(client, owner)));
-        owner.addClient(groupChatUserManager.getUserFromClient(client, owner));
+        eventBus.publish(new ChannelJoinEvent(event.getDate().getTime(), owner,
+                groupChatUserManager.getUserFromClient(event.getClient(), owner)));
+        owner.addClient(groupChatUserManager.getUserFromClient(event.getClient(), owner));
     }
 
-    @Override
-    public void onChannelPart(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String reason) {
-        checkParser(parser);
+    @Handler
+    public void onChannelPart(final com.dmdirc.parser.events.ChannelPartEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
+
+        final ChannelClientInfo client = event.getClient();
+        final Date date = event.getDate();
+        final String reason = event.getReason();
 
         if (isMyself(client)) {
             eventBus.publishAsync(new ChannelSelfPartEvent(date.getTime(), owner,
@@ -218,66 +207,82 @@ public class ChannelEventHandler extends EventHandler implements
         owner.removeClient(groupChatUserManager.getUserFromClient(client, owner));
     }
 
-    @Override
-    public void onChannelKick(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo kickedClient, final ChannelClientInfo client,
-            final String reason, final String host) {
-        checkParser(parser);
-
-        eventBus.publishAsync(new ChannelKickEvent(date.getTime(), owner,
-                groupChatUserManager.getUserFromClient(client, owner),
-                groupChatUserManager.getUserFromClient(kickedClient, owner), reason));
+    @Handler
+    public void onChannelKick(final com.dmdirc.parser.events.ChannelKickEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
+        final ChannelClientInfo kickedClient = event.getKickedClient();
+
+        eventBus.publishAsync(new ChannelKickEvent(event.getDate().getTime(), owner,
+                groupChatUserManager.getUserFromClient(event.getClient(), owner),
+                groupChatUserManager.getUserFromClient(kickedClient, owner), event.getReason()));
         owner.removeClient(groupChatUserManager.getUserFromClient(kickedClient, owner));
     }
 
-    @Override
-    public void onChannelQuit(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String reason) {
-        checkParser(parser);
+    @Handler
+    public void onChannelQuit(final com.dmdirc.parser.events.ChannelQuitEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
 
-        eventBus.publishAsync(new ChannelQuitEvent(date.getTime(), owner,
-                groupChatUserManager.getUserFromClient(client, owner), reason));
-        owner.removeClient(groupChatUserManager.getUserFromClient(client, owner));
+        eventBus.publishAsync(new ChannelQuitEvent(event.getDate().getTime(), owner,
+                groupChatUserManager.getUserFromClient(event.getClient(), owner), event.getReason()));
+        owner.removeClient(groupChatUserManager.getUserFromClient(event.getClient(), owner));
     }
 
-    @Override
-    public void onChannelAction(final Parser parser, final Date date, final ChannelInfo channel,
-            final ChannelClientInfo client, final String message,
-            final String host) {
-        checkParser(parser);
+    @Handler
+    public void onChannelAction(final com.dmdirc.parser.events.ChannelActionEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
 
-        eventBus.publishAsync(new ChannelActionEvent(date.getTime(), owner,
-                groupChatUserManager.getUserFromClient(client, owner), message));
+        eventBus.publishAsync(new ChannelActionEvent(event.getDate().getTime(), owner,
+                groupChatUserManager.getUserFromClient(event.getClient(), owner), event.getMessage()));
     }
 
-    @Override
-    public void onChannelNickChanged(final Parser parser, final Date date,
-            final ChannelInfo channel, final ChannelClientInfo client, final String oldNick) {
-        checkParser(parser);
+    @Handler
+    public void onChannelNickChanged(final com.dmdirc.parser.events.ChannelNickChangeEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
+
+        final String oldNick = event.getOldNick();
+        final ChannelClientInfo client = event.getClient();
 
         owner.renameClient(oldNick, client.getClient().getNickname());
 
         if (isMyself(client)) {
             eventBus.publishAsync(
-                    new ChannelSelfNickChangeEvent(date.getTime(), owner,
+                    new ChannelSelfNickChangeEvent(event.getDate().getTime(), owner,
                             groupChatUserManager.getUserFromClient(client, owner), oldNick));
         } else {
             eventBus.publishAsync(
-                    new ChannelNickChangeEvent(date.getTime(), owner,
+                    new ChannelNickChangeEvent(event.getDate().getTime(), owner,
                             groupChatUserManager.getUserFromClient(client, owner), oldNick));
         }
     }
 
-    @Override
-    public void onChannelModeChanged(final Parser parser, final Date date,
-            final ChannelInfo channel, final ChannelClientInfo client, final String host,
-            final String modes) {
-        checkParser(parser);
+    @Handler
+    public void onChannelModeChanged(final com.dmdirc.parser.events.ChannelModeChangeEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
+
+        final String host = event.getHost();
+        final String modes = event.getModes();
+        final ChannelClientInfo client = event.getClient();
+        final Date date = event.getDate();
 
         if (host.isEmpty()) {
-            final ChannelModesDiscoveredEvent event = new ChannelModesDiscoveredEvent(
+            final ChannelModesDiscoveredEvent coreEvent = new ChannelModesDiscoveredEvent(
                     date.getTime(), owner, modes.length() <= 1 ? "" : modes);
-            final String format = EventUtils.postDisplayable(eventBus, event,
+            final String format = EventUtils.postDisplayable(eventBus, coreEvent,
                     modes.length() <= 1 ? "channelNoModes" : "channelModeDiscovered");
             owner.doNotification(date, format, modes.length() <= 1 ? "" : modes);
         } else if (isMyself(client)) {
@@ -291,66 +296,81 @@ public class ChannelEventHandler extends EventHandler implements
         owner.refreshClients();
     }
 
-    @Override
-    public void onChannelCTCP(final Parser parser, final Date date,
-            final ChannelInfo channel, final ChannelClientInfo client,
-            final String type, final String message, final String host) {
-        checkParser(parser);
+    @Handler
+    public void onChannelCTCP(final ChannelCTCPEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
+
+        final ChannelClientInfo client = event.getClient();
+        final String message = event.getMessage();
+        final Date date = event.getDate();
+        final String type = event.getType();
 
-        final ChannelCtcpEvent event = new ChannelCtcpEvent(date.getTime(), owner,
+        final ChannelCtcpEvent coreEvent = new ChannelCtcpEvent(date.getTime(), owner,
                 groupChatUserManager.getUserFromClient(client, owner),type, message);
-        eventBus.publish(event);
-        if (!event.isHandled()) {
+        eventBus.publish(coreEvent);
+        if (!coreEvent.isHandled()) {
             getConnection().sendCTCPReply(client.getClient().getNickname(), type, message);
         }
     }
 
-    @Override
-    public void onAwayStateOther(final Parser parser, final Date date,
-            final ClientInfo client, final AwayState oldState, final AwayState state) {
-        checkParser(parser);
-
-        owner.getUser(owner.getConnection().get().getUser(client.getNickname())).ifPresent(c -> {
-            if (state == AwayState.AWAY) {
-                eventBus.publishAsync(new ChannelUserAwayEvent(date.getTime(), owner, c));
-            } else {
-                eventBus.publishAsync(new ChannelUserBackEvent(date.getTime(), owner, c));
-            }
-        });
+    @Handler
+    public void onAwayStateOther(final OtherAwayStateEvent event) {
+        checkParser(event.getParser());
+
+        owner.getUser(owner.getConnection().get().getUser(event.getClient().getNickname()))
+                .ifPresent(c -> {
+                    if (event.getNewState() == AwayState.AWAY) {
+                        eventBus.publishAsync(
+                                new ChannelUserAwayEvent(event.getDate().getTime(), owner, c));
+                    } else {
+                        eventBus.publishAsync(
+                                new ChannelUserBackEvent(event.getDate().getTime(), owner, c));
+                    }
+                });
     }
 
-    @Override
-    public void onChannelNotice(final Parser parser, final Date date,
-            final ChannelInfo channel, final ChannelClientInfo client,
-            final String message, final String host) {
-        checkParser(parser);
+    @Handler
+    public void onChannelNotice(final com.dmdirc.parser.events.ChannelNoticeEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
 
-        eventBus.publishAsync(new ChannelNoticeEvent(date.getTime(), owner,
-                groupChatUserManager.getUserFromClient(client, owner), message));
+        eventBus.publishAsync(new ChannelNoticeEvent(event.getDate().getTime(), owner,
+                groupChatUserManager.getUserFromClient(event.getClient(), owner), event.getMessage()));
     }
 
-    @Override
-    public void onChannelModeNotice(final Parser parser, final Date date,
-            final ChannelInfo channel, final char prefix,
-            final ChannelClientInfo client, final String message,
-            final String host) {
-        checkParser(parser);
-
-        eventBus.publishAsync(new ChannelModeNoticeEvent(date.getTime(), owner,
-                groupChatUserManager.getUserFromClient(client, owner), String.valueOf(prefix),
-                message));
+    @Handler
+    public void onChannelModeNotice(final com.dmdirc.parser.events.ChannelModeNoticeEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
+
+        eventBus.publishAsync(new ChannelModeNoticeEvent(event.getDate().getTime(), owner,
+                groupChatUserManager.getUserFromClient(event.getClient(), owner), String.valueOf
+                (event.getPrefix()), event.getMessage()));
     }
 
-    @Override
-    public void onChannelGotListModes(final Parser parser, final Date date,
-            final ChannelInfo channel, final char mode) {
-        checkParser(parser);
+    @Handler
+    public void onChannelGotListModes(final ChannelListModeEvent event) {
+        checkParser(event.getParser());
+        if (!checkChannel(event.getChannel())) {
+            return;
+        }
 
-        final ChannelListModesRetrievedEvent event = new ChannelListModesRetrievedEvent(
-                date.getTime(), owner, mode);
-        final String format = EventUtils.postDisplayable(eventBus, event,
+        final ChannelListModesRetrievedEvent coreEvent = new ChannelListModesRetrievedEvent(
+                event.getDate().getTime(), owner, event.getMode());
+        final String format = EventUtils.postDisplayable(eventBus, coreEvent,
                 "channelListModeRetrieved");
-        owner.doNotification(date, format, mode);
+        owner.doNotification(event.getDate(), format, event.getMode());
+    }
+
+    private boolean checkChannel(final ChannelInfo channelInfo) {
+        return owner.getChannelInfo().equals(channelInfo);
     }
 
 }

src/com/dmdirc/EventHandler.java

@@ -22,70 +22,36 @@
 
 package com.dmdirc;
 
-import com.dmdirc.events.AppErrorEvent;
 import com.dmdirc.interfaces.Connection;
-import com.dmdirc.logger.ErrorLevel;
-import com.dmdirc.parser.common.CallbackManager;
-import com.dmdirc.parser.common.CallbackNotFoundException;
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
 
 import javax.annotation.Nonnull;
 
 /**
  * Abstracts some behaviour used by Event Handlers.
  */
-public abstract class EventHandler implements CallbackInterface {
-
-    private final DMDircMBassador eventBus;
+public abstract class EventHandler {
 
     /**
      * Creates a new instance.
-     *
-     * @param eventBus The event bus to post errors to.
      */
-    protected EventHandler(final DMDircMBassador eventBus) {
-        this.eventBus = eventBus;
+    protected EventHandler() {
     }
 
     /**
      * Registers all callbacks that this event handler implements with the owner's parser.
      */
     public void registerCallbacks() {
-        final CallbackManager cbm = getConnection().getParser().get().getCallbackManager();
-
-        try {
-            for (Class<?> iface : getClass().getInterfaces()) {
-                if (CallbackInterface.class.isAssignableFrom(iface)) {
-                    addCallback(cbm, iface.asSubclass(CallbackInterface.class));
-                }
-            }
-        } catch (CallbackNotFoundException exception) {
-            eventBus.publishAsync(new AppErrorEvent(ErrorLevel.FATAL, exception,
-                    "Unable to register callbacks", ""));
-        }
+        getConnection().getParser().get().getCallbackManager().subscribe(this);
     }
 
     /**
      * Unregisters all callbacks that have been registered by this event handler.
      */
     public void unregisterCallbacks() {
-        getConnection().getParser().map(Parser::getCallbackManager)
-                .ifPresent(cm -> cm.delAllCallback(this));
+        getConnection().getParser().map(Parser::getCallbackManager).ifPresent(cm -> cm.unsubscribe(this));
     }
 
-    /**
-     * Adds a callback to this event handler.
-     *
-     * @param <T>  The type of callback to be added
-     * @param cbm  The callback manager to use
-     * @param type The type of the callback to be added
-     *
-     * @throws CallbackNotFoundException if the specified callback isn't found
-     */
-    protected abstract <T extends CallbackInterface> void addCallback(
-            final CallbackManager cbm, final Class<T> type);
-
     /**
      * Retrieves the connection that this event handler is for.
      *

src/com/dmdirc/Query.java

@@ -40,13 +40,13 @@ import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.parser.common.CallbackManager;
 import com.dmdirc.parser.common.CallbackNotFoundException;
 import com.dmdirc.parser.common.CompositionState;
+import com.dmdirc.parser.events.CompositionStateChangeEvent;
+import com.dmdirc.parser.events.NickChangeEvent;
+import com.dmdirc.parser.events.PrivateActionEvent;
+import com.dmdirc.parser.events.PrivateMessageEvent;
+import com.dmdirc.parser.events.QuitEvent;
 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.callbacks.CompositionStateChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.NickChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateActionListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateMessageListener;
-import com.dmdirc.parser.interfaces.callbacks.QuitListener;
 import com.dmdirc.ui.core.components.WindowComponent;
 import com.dmdirc.ui.input.TabCompleterFactory;
 import com.dmdirc.ui.messages.BackBufferFactory;
@@ -54,18 +54,17 @@ import com.dmdirc.ui.messages.sink.MessageSinkManager;
 
 import java.awt.Toolkit;
 import java.util.Arrays;
-import java.util.Date;
 import java.util.List;
 import java.util.Optional;
 
+import net.engio.mbassy.listener.Handler;
+
 /**
  * The Query class represents the client's view of a query with another user. It handles callbacks
  * for query events from the parser, maintains the corresponding QueryWindow, and handles user input
  * for the query.
  */
-public class Query extends FrameContainer implements PrivateActionListener,
-        PrivateMessageListener, NickChangeListener, QuitListener,
-        CompositionStateChangeListener, PrivateChat {
+public class Query extends FrameContainer implements PrivateChat {
 
     /** The connection this Query is on. */
     private final Connection connection;
@@ -158,18 +157,25 @@ public class Query extends FrameContainer implements PrivateActionListener,
         }
     }
 
-    @Override
-    public void onPrivateMessage(final Parser parser, final Date date,
-            final String message, final String host) {
+    @Handler
+    public void onPrivateMessage(final PrivateMessageEvent event) {
+        if (!checkQuery(event.getHost())) {
+            return;
+        }
+        if (checkQuery(event.getHost())) {
+
+        }
         getEventBus().publishAsync(
-                new QueryMessageEvent(this, connection.getUser(host), message));
+                new QueryMessageEvent(this, connection.getUser(event.getHost()), event.getMessage()));
     }
 
-    @Override
-    public void onPrivateAction(final Parser parser, final Date date,
-            final String message, final String host) {
+    @Handler
+    public void onPrivateAction(final PrivateActionEvent event) {
+        if (!checkQuery(event.getHost())) {
+            return;
+        }
         getEventBus().publishAsync(
-                new QueryActionEvent(this, connection.getUser(host), message));
+                new QueryActionEvent(this, connection.getUser(event.getHost()), event.getMessage()));
     }
 
     /**
@@ -187,33 +193,26 @@ public class Query extends FrameContainer implements PrivateActionListener,
         final String nick = getNickname();
 
         try {
-            callbackManager.addCallback(PrivateActionListener.class, this, nick);
-            callbackManager.addCallback(PrivateMessageListener.class, this, nick);
-            callbackManager.addCallback(CompositionStateChangeListener.class, this, nick);
-            callbackManager.addCallback(QuitListener.class, this);
-            callbackManager.addCallback(NickChangeListener.class, this);
+            callbackManager.subscribe(this);
         } catch (CallbackNotFoundException ex) {
             getEventBus().publishAsync(new AppErrorEvent(ErrorLevel.HIGH, ex,
                     "Unable to get query events", ex.getMessage()));
         }
     }
 
-    @Override
-    public void onNickChanged(final Parser parser, final Date date,
-            final ClientInfo client, final String oldNick) {
+    @Handler
+    public void onNickChanged(final NickChangeEvent event) {
+        if (!checkQuery(event.getClient().getHostname())) {
+            return;
+        }
+        final ClientInfo client = event.getClient();
+        final String oldNick = event.getOldNick();
         if (client.getNickname().equals(getNickname())) {
             final CallbackManager callbackManager = connection.getParser().get().getCallbackManager();
 
-            callbackManager.delCallback(PrivateActionListener.class, this);
-            callbackManager.delCallback(PrivateMessageListener.class, this);
-            callbackManager.delCallback(CompositionStateChangeListener.class, this);
-
+            // TODO: Not specific now.
             try {
-                callbackManager.addCallback(PrivateActionListener.class, this, client.getNickname());
-                callbackManager.
-                        addCallback(PrivateMessageListener.class, this, client.getNickname());
-                callbackManager.addCallback(CompositionStateChangeListener.class, this, client.
-                        getNickname());
+                callbackManager.subscribe(this);
             } catch (CallbackNotFoundException ex) {
                 getEventBus().publishAsync(
                         new AppErrorEvent(ErrorLevel.HIGH, ex, "Unable to get query events",
@@ -229,18 +228,22 @@ public class Query extends FrameContainer implements PrivateActionListener,
         }
     }
 
-    @Override
-    public void onQuit(final Parser parser, final Date date,
-            final ClientInfo client, final String reason) {
-        if (client.getNickname().equals(getNickname())) {
-            getEventBus().publish(new QueryQuitEvent(this, reason));
+    @Handler
+    public void onQuit(final QuitEvent event) {
+        if (!checkQuery(event.getClient().getHostname())) {
+            return;
+        }
+        if (event.getClient().getNickname().equals(getNickname())) {
+            getEventBus().publish(new QueryQuitEvent(this, event.getReason()));
         }
     }
 
-    @Override
-    public void onCompositionStateChanged(final Parser parser, final Date date,
-            final CompositionState state, final String host) {
-        if (state == CompositionState.TYPING) {
+    @Handler
+    public void onCompositionStateChanged(final CompositionStateChangeEvent event) {
+        if (!checkQuery(event.getHost())) {
+            return;
+        }
+        if (event.getState() == CompositionState.TYPING) {
             addComponent(WindowComponent.TYPING_INDICATOR.getIdentifier());
         } else {
             removeComponent(WindowComponent.TYPING_INDICATOR.getIdentifier());
@@ -257,7 +260,8 @@ public class Query extends FrameContainer implements PrivateActionListener,
         super.close();
 
         // Remove any callbacks or listeners
-        connection.getParser().map(Parser::getCallbackManager).ifPresent(cm -> cm.delAllCallback(this));
+        connection.getParser().map(Parser::getCallbackManager).ifPresent(cm -> cm.unsubscribe(this));
+
 
         // Trigger action for the window closing
         getEventBus().publishAsync(new QueryClosedEvent(this));
@@ -286,4 +290,8 @@ public class Query extends FrameContainer implements PrivateActionListener,
         return user;
     }
 
+    private boolean checkQuery(final String host) {
+        return user.getHostname().orElse("").equals(host);
+    }
+
 }

src/com/dmdirc/ServerEventHandler.java

@@ -55,50 +55,42 @@ import com.dmdirc.events.UserErrorEvent;
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.parser.common.AwayState;
-import com.dmdirc.parser.common.CallbackManager;
-import com.dmdirc.parser.common.ParserError;
-import com.dmdirc.parser.interfaces.ChannelInfo;
-import com.dmdirc.parser.interfaces.ClientInfo;
+import com.dmdirc.parser.events.AuthNoticeEvent;
+import com.dmdirc.parser.events.AwayStateEvent;
+import com.dmdirc.parser.events.ChannelSelfJoinEvent;
+import com.dmdirc.parser.events.ConnectErrorEvent;
+import com.dmdirc.parser.events.ErrorInfoEvent;
+import com.dmdirc.parser.events.InviteEvent;
+import com.dmdirc.parser.events.MOTDEndEvent;
+import com.dmdirc.parser.events.MOTDLineEvent;
+import com.dmdirc.parser.events.MOTDStartEvent;
+import com.dmdirc.parser.events.NickChangeEvent;
+import com.dmdirc.parser.events.NickInUseEvent;
+import com.dmdirc.parser.events.NumericEvent;
+import com.dmdirc.parser.events.PingFailureEvent;
+import com.dmdirc.parser.events.PingSentEvent;
+import com.dmdirc.parser.events.PingSuccessEvent;
+import com.dmdirc.parser.events.PrivateActionEvent;
+import com.dmdirc.parser.events.PrivateCTCPEvent;
+import com.dmdirc.parser.events.PrivateCTCPReplyEvent;
+import com.dmdirc.parser.events.PrivateMessageEvent;
+import com.dmdirc.parser.events.PrivateNoticeEvent;
+import com.dmdirc.parser.events.ServerReadyEvent;
+import com.dmdirc.parser.events.SocketCloseEvent;
+import com.dmdirc.parser.events.UnknownActionEvent;
+import com.dmdirc.parser.events.UnknownMessageEvent;
+import com.dmdirc.parser.events.UnknownNoticeEvent;
+import com.dmdirc.parser.events.UserModeChangeEvent;
+import com.dmdirc.parser.events.UserModeDiscoveryEvent;
+import com.dmdirc.parser.events.WallDesyncEvent;
+import com.dmdirc.parser.events.WallopEvent;
+import com.dmdirc.parser.events.WalluserEvent;
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.callbacks.AuthNoticeListener;
-import com.dmdirc.parser.interfaces.callbacks.AwayStateListener;
-import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
-import com.dmdirc.parser.interfaces.callbacks.ChannelSelfJoinListener;
-import com.dmdirc.parser.interfaces.callbacks.ConnectErrorListener;
-import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
-import com.dmdirc.parser.interfaces.callbacks.InviteListener;
-import com.dmdirc.parser.interfaces.callbacks.MotdEndListener;
-import com.dmdirc.parser.interfaces.callbacks.MotdLineListener;
-import com.dmdirc.parser.interfaces.callbacks.MotdStartListener;
-import com.dmdirc.parser.interfaces.callbacks.NickChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.NickInUseListener;
-import com.dmdirc.parser.interfaces.callbacks.NumericListener;
-import com.dmdirc.parser.interfaces.callbacks.PingFailureListener;
-import com.dmdirc.parser.interfaces.callbacks.PingSentListener;
-import com.dmdirc.parser.interfaces.callbacks.PingSuccessListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateActionListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateCtcpListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateCtcpReplyListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateMessageListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateNoticeListener;
-import com.dmdirc.parser.interfaces.callbacks.ServerErrorListener;
-import com.dmdirc.parser.interfaces.callbacks.ServerNoticeListener;
-import com.dmdirc.parser.interfaces.callbacks.ServerReadyListener;
-import com.dmdirc.parser.interfaces.callbacks.SocketCloseListener;
-import com.dmdirc.parser.interfaces.callbacks.UnknownActionListener;
-import com.dmdirc.parser.interfaces.callbacks.UnknownMessageListener;
-import com.dmdirc.parser.interfaces.callbacks.UnknownNoticeListener;
-import com.dmdirc.parser.interfaces.callbacks.UserModeChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.UserModeDiscoveryListener;
-import com.dmdirc.parser.interfaces.callbacks.WallDesyncListener;
-import com.dmdirc.parser.interfaces.callbacks.WallopListener;
-import com.dmdirc.parser.interfaces.callbacks.WalluserListener;
 import com.dmdirc.ui.StatusMessage;
 import com.dmdirc.util.EventUtils;
 
 import com.google.common.base.Strings;
 
-import java.util.Date;
 import java.util.List;
 import java.util.Optional;
 import java.util.Random;
@@ -108,22 +100,13 @@ import javax.annotation.Nonnull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import net.engio.mbassy.listener.Handler;
+
 
 /**
  * Handles parser events for a Server object.
  */
-public class ServerEventHandler extends EventHandler implements
-        ChannelSelfJoinListener, PrivateMessageListener, PrivateActionListener,
-        ErrorInfoListener, PrivateCtcpListener, PrivateCtcpReplyListener,
-        SocketCloseListener, PrivateNoticeListener, MotdStartListener,
-        MotdLineListener, MotdEndListener, NumericListener, PingFailureListener,
-        PingSuccessListener, AwayStateListener, ConnectErrorListener,
-        NickInUseListener, AuthNoticeListener, UnknownNoticeListener,
-        UserModeChangeListener, InviteListener, WallopListener,
-        WalluserListener, WallDesyncListener, NickChangeListener,
-        ServerErrorListener, PingSentListener, UserModeDiscoveryListener,
-        ServerNoticeListener, UnknownMessageListener, UnknownActionListener,
-        ServerReadyListener {
+public class ServerEventHandler extends EventHandler {
 
     private static final Logger LOG = LoggerFactory.getLogger(ServerEventHandler.class);
 
@@ -142,147 +125,135 @@ public class ServerEventHandler extends EventHandler implements
      */
     public ServerEventHandler(final Server owner, final GroupChatManagerImpl groupChatManager,
             final DMDircMBassador eventBus) {
-        super(eventBus);
         this.owner = owner;
         this.groupChatManager = groupChatManager;
         this.eventBus = eventBus;
     }
 
-    @Override
-    @SuppressWarnings("unchecked")
-    protected <T extends CallbackInterface> void addCallback(
-            final CallbackManager cbm, final Class<T> type) {
-        cbm.addCallback(type, (T) this);
-    }
-
     @Nonnull
     @Override
     protected Connection getConnection() {
         return owner;
     }
 
-    @Override
-    public void onChannelSelfJoin(final Parser parser, final Date date, final ChannelInfo channel) {
-        checkParser(parser);
-        groupChatManager.addChannel(channel);
+    @Handler
+    public void onChannelSelfJoin(final ChannelSelfJoinEvent event) {
+        checkParser(event.getParser());
+        groupChatManager.addChannel(event.getChannel());
     }
 
-    @Override
-    public void onPrivateMessage(final Parser parser, final Date date, final String message,
-            final String host) {
-        checkParser(parser);
+    @Handler
+    public void onPrivateMessage(final PrivateMessageEvent event) {
+        checkParser(event.getParser());
 
-        if (!owner.hasQuery(host)) {
-            owner.getQuery(host).onPrivateMessage(parser, date, message, host);
+        if (!owner.hasQuery(event.getHost())) {
+            owner.getQuery(event.getHost()).onPrivateMessage(event);
         }
     }
 
-    @Override
-    public void onPrivateAction(final Parser parser, final Date date, final String message,
-            final String host) {
-        checkParser(parser);
+    @Handler
+    public void onPrivateAction(final PrivateActionEvent event) {
+        checkParser(event.getParser());
 
-        if (!owner.hasQuery(host)) {
-            owner.getQuery(host).onPrivateAction(parser, date, message, host);
+        if (!owner.hasQuery(event.getHost())) {
+            owner.getQuery(event.getHost()).onPrivateAction(event);
         }
     }
 
     @SuppressWarnings("ThrowableResultOfMethodCallIgnored")
-    @Override
-    public void onErrorInfo(final Parser parser, final Date date, final ParserError errorInfo) {
+    @Handler
+    public void onErrorInfo(final ErrorInfoEvent event) {
 
         final StringBuilder errorString = new StringBuilder();
         errorString.append("Parser exception.\n\n");
 
         errorString.append("\tLast line:\t");
-        errorString.append(errorInfo.getLastLine()).append('\n');
+        errorString.append(event.getErrorInfo().getLastLine()).append('\n');
 
         errorString.append("\tServer:\t");
         errorString.append(owner.getAddress()).append('\n');
 
         errorString.append("\tAdditional Information:\n");
-        for (final String line : parser.getServerInformationLines()) {
+        for (final String line : event.getParser().getServerInformationLines()) {
             errorString.append("\t\t").append(line).append('\n');
         }
 
-        final Exception ex = errorInfo.isException() ? errorInfo.getException()
+        final Exception ex = event.getErrorInfo().isException() ? event.getErrorInfo().getException()
                 : new Exception(errorString.toString()); // NOPMD
 
         final ErrorLevel errorLevel = ErrorLevel.UNKNOWN;
-        if (errorInfo.isUserError()) {
-            eventBus.publishAsync(new UserErrorEvent(errorLevel, ex, errorInfo.getData(), ""));
+        if (event.getErrorInfo().isUserError()) {
+            eventBus.publishAsync(new UserErrorEvent(errorLevel, ex, event.getErrorInfo().getData(), ""));
         } else {
-            eventBus.publishAsync(new AppErrorEvent(errorLevel, ex, errorInfo.getData(), ""));
+            eventBus.publishAsync(new AppErrorEvent(errorLevel, ex, event.getErrorInfo().getData(), ""));
         }
     }
 
-    @Override
-    public void onPrivateCTCP(final Parser parser, final Date date, final String type,
-            final String message, final String host) {
-        checkParser(parser);
-
-        final ServerCtcpEvent event = new ServerCtcpEvent(owner, owner.getUser(host),
-                type, message);
-        eventBus.publish(event);
-        if (!event.isHandled()) {
-            owner.sendCTCPReply(owner.getUser(host).getNickname(), type, message);
+    @Handler
+    public void onPrivateCTCP(final PrivateCTCPEvent event) {
+        checkParser(event.getParser());
+
+        final ServerCtcpEvent coreEvent = new ServerCtcpEvent(owner, owner.getUser(event.getHost()),
+                event.getType(), event.getMessage());
+        eventBus.publish(coreEvent);
+        if (!coreEvent.isHandled()) {
+            owner.sendCTCPReply(owner.getUser(event.getHost()).getNickname(), event.getType(),
+                    event.getMessage());
         }
     }
 
-    @Override
-    public void onPrivateCTCPReply(final Parser parser, final Date date, final String type,
-            final String message, final String host) {
-        checkParser(parser);
-        eventBus.publish(new ServerCtcpReplyEvent(owner, owner.getUser(host), type, message));
+    @Handler
+    public void onPrivateCTCPReply(final PrivateCTCPReplyEvent event) {
+        checkParser(event.getParser());
+        eventBus.publish(new ServerCtcpReplyEvent(owner, owner.getUser(event.getHost()),
+                event.getType(), event.getMessage()));
     }
 
-    @Override
-    public void onSocketClosed(final Parser parser, final Date date) {
-        if (owner.getParser().orElse(null) == parser) {
+    @Handler
+    public void onSocketClosed(final SocketCloseEvent event) {
+        if (owner.getParser().orElse(null) == event.getParser()) {
             owner.onSocketClosed();
         }
     }
 
-    @Override
-    public void onPrivateNotice(final Parser parser, final Date date,
-            final String message, final String host) {
-        checkParser(parser);
-        eventBus.publishAsync(new ServerNoticeEvent(owner, owner.getLocalUser().get(), message));
+    @Handler
+    public void onPrivateNotice(final PrivateNoticeEvent event) {
+        checkParser(event.getParser());
+        eventBus.publishAsync(new ServerNoticeEvent(owner, owner.getLocalUser().get(),
+                event.getMessage()));
     }
 
-    @Override
-    public void onServerNotice(final Parser parser, final Date date,
-            final String message, final String host) {
-        checkParser(parser);
-        eventBus.publishAsync(new ServerServerNoticeEvent(owner, owner.getLocalUser().get(),
-                message));
+    @Handler
+    public void onServerNotice(final com.dmdirc.parser.events.ServerNoticeEvent event) {
+        checkParser(event.getParser());
+        eventBus.publishAsync(
+                new ServerServerNoticeEvent(owner, owner.getLocalUser().get(), event.getMessage()));
     }
 
-    @Override
-    public void onMOTDStart(final Parser parser, final Date date, final String data) {
-        checkParser(parser);
-        eventBus.publishAsync(new ServerMotdStartEvent(owner, data));
+    @Handler
+    public void onMOTDStart(final MOTDStartEvent event) {
+        checkParser(event.getParser());
+        eventBus.publishAsync(new ServerMotdStartEvent(owner, event.getData()));
     }
 
-    @Override
-    public void onMOTDLine(final Parser parser, final Date date, final String data) {
-        checkParser(parser);
-        eventBus.publishAsync(new ServerMotdLineEvent(owner, data));
+    @Handler
+    public void onMOTDLine(final MOTDLineEvent event) {
+        checkParser(event.getParser());
+        eventBus.publishAsync(new ServerMotdLineEvent(owner, event.getData()));
     }
 
-    @Override
-    public void onMOTDEnd(final Parser parser, final Date date,
-            final boolean noMOTD, final String data) {
-        checkParser(parser);
-        eventBus.publishAsync(new ServerMotdEndEvent(owner, data));
+    @Handler
+    public void onMOTDEnd(final MOTDEndEvent event) {
+        checkParser(event.getParser());
+        eventBus.publishAsync(new ServerMotdEndEvent(owner, event.getData()));
     }
 
-    @Override
-    public void onNumeric(final Parser parser, final Date date, final int numeric,
-            final String[] token) {
-        checkParser(parser);
+    @Handler
+    public void onNumeric(final NumericEvent event) {
+        checkParser(event.getParser());
 
-        final String sansIrcd = "numeric_" + Strings.padStart(String.valueOf(numeric), 3, '0');
+        final String sansIrcd = "numeric_" + Strings
+                .padStart(String.valueOf(event.getNumeric()), 3, '0');
         String target = "";
 
         if (owner.getConfigManager().hasOptionString("formatter", sansIrcd)) {
@@ -291,23 +262,24 @@ public class ServerEventHandler extends EventHandler implements
             target = "numeric_unknown";
         }
 
-        final ServerNumericEvent event = new ServerNumericEvent(owner, numeric, token);
-        final String format = EventUtils.postDisplayable(eventBus, event, target);
-        owner.handleNotification(format, (Object[]) token);
+        final ServerNumericEvent coreEvent = new ServerNumericEvent(owner, event.getNumeric(),
+                event.getToken());
+        final String format = EventUtils.postDisplayable(eventBus, coreEvent, target);
+        owner.handleNotification(format, (Object[]) event.getToken());
     }
 
-    @Override
-    public void onPingFailed(final Parser parser, final Date date) {
-        checkParser(parser);
+    @Handler
+    public void onPingFailed(final PingFailureEvent event) {
+        checkParser(event.getParser());
 
         eventBus.publishAsync(new StatusBarMessageEvent(new StatusMessage(
                 "No ping reply from " + owner.getName() + " for over " +
-                        (int) Math.floor(parser.getPingTime() / 1000.0) + " seconds.",
+                        (int) Math.floor(event.getParser().getPingTime() / 1000.0) + " seconds.",
                 owner.getConfigManager())));
 
-        eventBus.publishAsync(new ServerNoPingEvent(owner, parser.getPingTime()));
+        eventBus.publishAsync(new ServerNoPingEvent(owner, event.getParser().getPingTime()));
 
-        if (parser.getPingTime()
+        if (event.getParser().getPingTime()
                 >= owner.getConfigManager().getOptionInt("server", "pingtimeout")) {
             LOG.warn("Server appears to be stoned, reconnecting");
             eventBus.publishAsync(new ServerStonedEvent(owner));
@@ -315,47 +287,47 @@ public class ServerEventHandler extends EventHandler implements
         }
     }
 
-    @Override
-    public void onPingSent(final Parser parser, final Date date) {
-        checkParser(parser);
+    @Handler
+    public void onPingSent(final PingSentEvent event) {
+        checkParser(event.getParser());
         eventBus.publishAsync(new ServerPingSentEvent(owner));
     }
 
-    @Override
-    public void onPingSuccess(final Parser parser, final Date date) {
-        checkParser(parser);
+    @Handler
+    public void onPingSuccess(final PingSuccessEvent event) {
+        checkParser(event.getParser());
         eventBus.publishAsync(new ServerGotPingEvent(owner,
                 owner.getParser().get().getServerLatency()));
     }
 
-    @Override
-    public void onAwayState(final Parser parser, final Date date, final AwayState oldState,
-            final AwayState currentState, final String reason) {
-        checkParser(parser);
+    @Handler
+    public void onAwayState(final AwayStateEvent event) {
+        checkParser(event.getParser());
 
-        owner.updateAwayState(currentState == AwayState.AWAY ? Optional.of(reason) : Optional.empty());
+        owner.updateAwayState(event.getNewState() == AwayState.AWAY ?
+                Optional.of(event.getReason()) : Optional.empty());
 
-        if (currentState == AwayState.AWAY) {
-            eventBus.publishAsync(new ServerAwayEvent(owner, reason));
-        } else if (oldState != AwayState.UNKNOWN) {
+        if (event.getNewState() == AwayState.AWAY) {
+            eventBus.publishAsync(new ServerAwayEvent(owner, event.getReason()));
+        } else if (event.getOldState() != AwayState.UNKNOWN) {
             eventBus.publishAsync(new ServerBackEvent(owner));
         }
     }
 
-    @Override
-    public void onConnectError(final Parser parser, final Date date, final ParserError errorInfo) {
-        checkParser(parser);
-        owner.onConnectError(errorInfo);
+    @Handler
+    public void onConnectError(final ConnectErrorEvent event) {
+        checkParser(event.getParser());
+        owner.onConnectError(event.getErrorInfo());
     }
 
-    @Override
-    public void onNickInUse(final Parser parser, final Date date, final String nickname) {
-        checkParser(parser);
+    @Handler
+    public void onNickInUse(final NickInUseEvent event) {
+        checkParser(event.getParser());
 
-        final String lastNick = parser.getLocalClient().getNickname();
+        final String lastNick = event.getParser().getLocalClient().getNickname();
 
         // If our last nick is still valid, ignore the in use message
-        if (!parser.getStringConverter().equalsIgnoreCase(lastNick, nickname)) {
+        if (!event.getParser().getStringConverter().equalsIgnoreCase(lastNick, event.getNickname())) {
             return;
         }
 
@@ -367,7 +339,7 @@ public class ServerEventHandler extends EventHandler implements
         // Loop so we can check case sensitivity
         for (String alt : alts) {
             offset++;
-            if (parser.getStringConverter().equalsIgnoreCase(alt, lastNick)) {
+            if (event.getParser().getStringConverter().equalsIgnoreCase(alt, lastNick)) {
                 break;
             }
         }
@@ -376,160 +348,154 @@ public class ServerEventHandler extends EventHandler implements
             newNick = alts.get(offset);
         }
 
-        parser.getLocalClient().setNickname(newNick);
+        event.getParser().getLocalClient().setNickname(newNick);
     }
 
-    @Override
-    public void onServerReady(final Parser parser, final Date date) {
-        checkParser(parser);
+    @Handler
+    public void onServerReady(final ServerReadyEvent event) {
+        checkParser(event.getParser());
         owner.onPost005();
     }
 
-    @Override
-    public void onNoticeAuth(final Parser parser, final Date date, final String data) {
-        checkParser(parser);
+    @Handler
+    public void onNoticeAuth(final AuthNoticeEvent event) {
+        checkParser(event.getParser());
 
-        final ServerAuthNoticeEvent event = new ServerAuthNoticeEvent(owner, data);
-        final String format = EventUtils.postDisplayable(eventBus, event, "authNotice");
-        owner.doNotification(format, data);
+        final ServerAuthNoticeEvent coreEvent = new ServerAuthNoticeEvent(owner, event.getMessage());
+        final String format = EventUtils.postDisplayable(eventBus, coreEvent, "authNotice");
+        owner.doNotification(format, event.getDate());
     }
 
-    @Override
-    public void onUnknownNotice(final Parser parser, final Date date, final String message,
-            final String target, final String host) {
-        checkParser(parser);
+    @Handler
+    public void onUnknownNotice(final UnknownNoticeEvent event) {
+        checkParser(event.getParser());
 
         final ServerUnknownNoticeEvent
-                event = new ServerUnknownNoticeEvent(owner, host, target, message);
-        final String format = EventUtils.postDisplayable(eventBus, event, "unknownNotice");
-        owner.doNotification(format, host, target, message);
+                coreEvent = new ServerUnknownNoticeEvent(owner, event.getHost(), event.getTarget(),
+                event.getMessage());
+        final String format = EventUtils.postDisplayable(eventBus, coreEvent, "unknownNotice");
+        owner.doNotification(format, event.getHost(), event.getTarget(), event.getMessage());
     }
 
-    @Override
-    public void onUnknownMessage(final Parser parser, final Date date, final String message,
-            final String target, final String host) {
-        checkParser(parser);
+    @Handler
+    public void onUnknownMessage(final UnknownMessageEvent event) {
+        checkParser(event.getParser());
 
-        if (parser.getLocalClient().equals(parser.getClient(host))) {
+        if (event.getParser().getLocalClient().equals(event.getParser().getClient(event.getHost()))) {
             // Local client
-            eventBus.publishAsync(new QuerySelfMessageEvent(owner.getQuery(target),
-                    owner.getLocalUser().get(), message));
+            eventBus.publishAsync(
+                    new QuerySelfMessageEvent(owner.getQuery(event.getTarget()), owner.getLocalUser().get(),
+                            event.getMessage()));
         } else {
-            final ServerUnknownMessageEvent event
-                    = new ServerUnknownMessageEvent(owner, host, target, message);
-            final String format = EventUtils.postDisplayable(eventBus, event, "unknownMessage");
-            owner.doNotification(format, host, target, message);
+            final ServerUnknownMessageEvent coreEvent
+                    = new ServerUnknownMessageEvent(owner, event.getHost(), event.getTarget(), event.getMessage());
+            final String format = EventUtils.postDisplayable(eventBus, coreEvent, "unknownMessage");
+            owner.doNotification(format, event.getHost(), event.getTarget(), event.getMessage());
         }
     }
 
-    @Override
-    public void onUnknownAction(final Parser parser, final Date date, final String message,
-            final String target, final String host) {
-        checkParser(parser);
+    @Handler
+    public void onUnknownAction(final UnknownActionEvent event) {
+        checkParser(event.getParser());
 
-        if (parser.getLocalClient().equals(parser.getClient(host))) {
+        if (event.getParser().getLocalClient().equals(event.getParser().getClient(event.getHost()))) {
             // Local client
-            eventBus.publishAsync(new QuerySelfActionEvent(owner.getQuery(target),
-                    owner.getLocalUser().get(), message));
+            eventBus.publishAsync(
+                    new QuerySelfActionEvent(owner.getQuery(event.getTarget()), owner.getLocalUser().get(),
+                            event.getMessage()));
         } else {
-            final ServerUnknownActionEvent event
-                    = new ServerUnknownActionEvent(owner, host, target, message);
-            final String format = EventUtils.postDisplayable(eventBus, event, "unknownAction");
-            owner.doNotification(format, host, target, message);
+            final ServerUnknownActionEvent coreEvent
+                    = new ServerUnknownActionEvent(owner, event.getHost(), event.getTarget(), event.getMessage());
+            final String format = EventUtils.postDisplayable(eventBus, coreEvent, "unknownAction");
+            owner.doNotification(format, event.getHost(), event.getTarget(), event.getMessage());
         }
     }
 
-    @Override
-    public void onUserModeChanged(final Parser parser, final Date date,
-            final ClientInfo client, final String host, final String modes) {
-        checkParser(parser);
+    @Handler
+    public void onUserModeChanged(final UserModeChangeEvent event) {
+        checkParser(event.getParser());
 
-        final ServerUserModesEvent event = new ServerUserModesEvent(owner,
-                owner.getUser(client.getHostname()), modes);
-        final String format = EventUtils.postDisplayable(eventBus, event, "userModeChanged");
-        owner.doNotification(format, owner.getUser(client.getHostname()), modes);
+        final ServerUserModesEvent coreEvent = new ServerUserModesEvent(owner,
+                owner.getUser(event.getClient().getHostname()), event.getModes());
+        final String format = EventUtils.postDisplayable(eventBus, coreEvent, "userModeChanged");
+        owner.doNotification(format, owner.getUser(event.getClient().getHostname()), event.getModes());
     }
 
-    @Override
-    public void onUserModeDiscovered(final Parser parser, final Date date,
-            final ClientInfo client, final String modes) {
-        checkParser(parser);
+    @Handler
+    public void onUserModeDiscovered(final UserModeDiscoveryEvent event) {
+        checkParser(event.getParser());
 
-        final ServerUserModesEvent event = new ServerUserModesEvent(owner,
-                owner.getUser(client.getHostname()), modes);
-        final String format = EventUtils.postDisplayable(eventBus, event,
-                modes.isEmpty() || "+".equals(modes) ? "userNoModes" : "userModeDiscovered");
-        owner.doNotification(format, owner.getUser(client.getHostname()), modes);
+        final ServerUserModesEvent coreEvent = new ServerUserModesEvent(owner,
+                owner.getUser(event.getClient().getHostname()), event.getModes());
+        final String format = EventUtils.postDisplayable(eventBus, coreEvent,
+                event.getModes().isEmpty() || "+".equals(event.getModes()) ? "userNoModes" : "userModeDiscovered");
+        owner.doNotification(format, owner.getUser(event.getClient().getHostname()), event.getModes());
     }
 
-    @Override
-    public void onInvite(final Parser parser, final Date date, final String userHost,
-            final String channel) {
-        checkParser(parser);
+    @Handler
+    public void onInvite(final InviteEvent event) {
+        checkParser(event.getParser());
 
-        final Invite invite = new Invite(owner.getInviteManager(), channel, owner.getUser(userHost));
+        final Invite invite = new Invite(owner.getInviteManager(), event.getChannel(),
+                owner.getUser(event.getUserHost()));
         owner.getInviteManager().addInvite(invite);
-        final ServerInviteReceivedEvent event = new ServerInviteReceivedEvent(owner,
-                owner.getUser(userHost), channel, invite);
-        final String format = EventUtils.postDisplayable(eventBus, event, "inviteReceived");
-        owner.doNotification(format, owner.getUser(userHost), channel);
+        final ServerInviteReceivedEvent coreEvent = new ServerInviteReceivedEvent(owner,
+                owner.getUser(event.getUserHost()), event.getChannel(), invite);
+        final String format = EventUtils.postDisplayable(eventBus, coreEvent, "inviteReceived");
+        owner.doNotification(format, owner.getUser(event.getUserHost()), event.getChannel());
     }
 
-    @Override
-    public void onWallop(final Parser parser, final Date date, final String message,
-            final String host) {
-        checkParser(parser);
+    @Handler
+    public void onWallop(final WallopEvent event) {
+        checkParser(event.getParser());
 
-        final ServerWallopsEvent event = new ServerWallopsEvent(owner,
-                owner.getUser(host), message);
-        final String format = EventUtils.postDisplayable(eventBus, event, "wallop");
-        owner.doNotification(format, owner.getUser(host), message);
+        final ServerWallopsEvent coreEvent = new ServerWallopsEvent(owner,
+                owner.getUser(event.getHost()), event.getMessage());
+        final String format = EventUtils.postDisplayable(eventBus, coreEvent, "wallop");
+        owner.doNotification(format, owner.getUser(event.getHost()), event.getMessage());
 
     }
 
-    @Override
-    public void onWalluser(final Parser parser, final Date date, final String message,
-            final String host) {
-        checkParser(parser);
+    @Handler
+    public void onWalluser(final WalluserEvent event) {
+        checkParser(event.getParser());
 
-        final ServerWallusersEvent event = new ServerWallusersEvent(owner,
-                owner.getLocalUser().get(), message);
-        final String format = EventUtils.postDisplayable(eventBus, event, "walluser");
-        owner.doNotification(format, owner.getUser(host), message);
+        final ServerWallusersEvent coreEvent = new ServerWallusersEvent(owner,
+                owner.getLocalUser().get(), event.getMessage());
+        final String format = EventUtils.postDisplayable(eventBus, coreEvent, "walluser");
+        owner.doNotification(format, owner.getUser(event.getHost()), event.getMessage());
     }
 
-    @Override
-    public void onWallDesync(final Parser parser, final Date date, final String message,
-            final String host) {
-        checkParser(parser);
+    @Handler
+    public void onWallDesync(final WallDesyncEvent event) {
+        checkParser(event.getParser());
 
-        final ServerWalldesyncEvent event = new ServerWalldesyncEvent(owner,
-                owner.getLocalUser().get(), message);
-        final String format = EventUtils.postDisplayable(eventBus, event, "walldesync");
-        owner.doNotification(format, owner.getUser(host), message);
+        final ServerWalldesyncEvent coreEvent = new ServerWalldesyncEvent(owner,
+                owner.getLocalUser().get(), event.getMessage());
+        final String format = EventUtils.postDisplayable(eventBus, coreEvent, "walldesync");
+        owner.doNotification(format, owner.getUser(event.getHost()), event.getMessage());
     }
 
-    @Override
-    public void onNickChanged(final Parser parser, final Date date, final ClientInfo client,
-            final String oldNick) {
-        checkParser(parser);
-
-        if (client.equals(owner.getParser().get().getLocalClient())) {
-            final ServerNickChangeEvent event = new ServerNickChangeEvent(owner, oldNick,
-                    client.getNickname());
-            final String format = EventUtils.postDisplayable(eventBus, event, "selfNickChange");
-            owner.doNotification(format, oldNick, client.getNickname());
+    @Handler
+    public void onNickChanged(final NickChangeEvent event) {
+        checkParser(event.getParser());
+
+        if (event.getClient().equals(owner.getParser().get().getLocalClient())) {
+            final ServerNickChangeEvent coreEvent = new ServerNickChangeEvent(owner,
+                    event.getOldNick(), event.getClient().getNickname());
+            final String format = EventUtils.postDisplayable(eventBus, coreEvent, "selfNickChange");
+            owner.doNotification(format, event.getOldNick(), event.getClient().getNickname());
             owner.updateTitle();
         }
     }
 
-    @Override
-    public void onServerError(final Parser parser, final Date date, final String message) {
-        checkParser(parser);
+    @Handler
+    public void onServerError(final com.dmdirc.parser.events.ServerErrorEvent event) {
+        checkParser(event.getParser());
 
-        final ServerErrorEvent event = new ServerErrorEvent(owner, message);
-        final String format = EventUtils.postDisplayable(eventBus, event, "serverError");
-        owner.doNotification(format, message);
+        final ServerErrorEvent coreEvent = new ServerErrorEvent(owner, event.getMessage());
+        final String format = EventUtils.postDisplayable(eventBus, coreEvent, "serverError");
+        owner.doNotification(format, event.getMessage());
     }
 
     @Override

src/com/dmdirc/lists/GroupListManager.java

@@ -24,22 +24,22 @@ package com.dmdirc.lists;
 
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.parser.common.ChannelJoinRequest;
+import com.dmdirc.parser.events.GroupListEndEvent;
+import com.dmdirc.parser.events.GroupListEntryEvent;
+import com.dmdirc.parser.events.GroupListStartEvent;
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.callbacks.GroupListEndListener;
-import com.dmdirc.parser.interfaces.callbacks.GroupListEntryListener;
-import com.dmdirc.parser.interfaces.callbacks.GroupListStartListener;
 import com.dmdirc.util.collections.ListenerList;
 import com.dmdirc.util.collections.ObservableList;
 import com.dmdirc.util.collections.ObservableListDecorator;
 
-import java.util.Date;
 import java.util.LinkedList;
 
+import net.engio.mbassy.listener.Handler;
+
 /**
  * Manages a group list request.
  */
-public class GroupListManager implements GroupListStartListener,
-        GroupListEntryListener, GroupListEndListener {
+public class GroupListManager {
 
     /** List of registered listeners. */
     private final ListenerList listenerList = new ListenerList();
@@ -68,27 +68,24 @@ public class GroupListManager implements GroupListStartListener,
         groups.clear();
 
         connection.getParser().ifPresent(p -> {
-            p.getCallbackManager().addCallback(GroupListStartListener.class, this);
-            p.getCallbackManager().addCallback(GroupListEntryListener.class, this);
-            p.getCallbackManager().addCallback(GroupListEndListener.class, this);
+            p.getCallbackManager().subscribe(this);
             p.requestGroupList(searchTerm);
         });
     }
 
-    @Override
-    public void onGroupListStart(final Parser parser, final Date date) {
+    @Handler
+    public void onGroupListStart(final GroupListStartEvent event) {
         listenerList.getCallable(GroupListObserver.class).onGroupListStarted();
     }
 
-    @Override
-    public void onGroupListEntry(final Parser parser, final Date date,
-            final String name, final int users, final String topic) {
-        groups.add(new GroupListEntry(name, users, topic));
+    @Handler
+    public void onGroupListEntry(final GroupListEntryEvent event) {
+        groups.add(new GroupListEntry(event.getName(), event.getUsers(), event.getTopic()));
     }
 
-    @Override
-    public void onGroupListEnd(final Parser parser, final Date date) {
-        parser.getCallbackManager().delAllCallback(this);
+    @Handler
+    public void onGroupListEnd(final GroupListEndEvent event) {
+        event.getParser().getCallbackManager().unsubscribe(this);
         listenerList.getCallable(GroupListObserver.class).onGroupListFinished();
     }
 

test/com/dmdirc/ServerEventHandlerTest.java

@@ -1,260 +0,0 @@
-/*
- * 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;
-
-import com.dmdirc.events.AppErrorEvent;
-import com.dmdirc.events.DMDircEvent;
-import com.dmdirc.events.ServerCtcpEvent;
-import com.dmdirc.events.UserErrorEvent;
-import com.dmdirc.interfaces.Connection;
-import com.dmdirc.interfaces.User;
-import com.dmdirc.parser.common.CallbackManager;
-import com.dmdirc.parser.common.ParserError;
-import com.dmdirc.parser.interfaces.ChannelInfo;
-import com.dmdirc.parser.interfaces.ClientInfo;
-import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
-import com.dmdirc.parser.interfaces.callbacks.ChannelSelfJoinListener;
-import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateActionListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateCtcpListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateMessageListener;
-
-import com.google.common.collect.Lists;
-
-import java.util.Date;
-import java.util.Optional;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class ServerEventHandlerTest {
-
-    @Mock private Server server;
-    @Mock private GroupChatManagerImpl groupChatManager;
-    @Mock private Parser parser;
-    @Mock private CallbackManager callbackManager;
-    @Mock private DMDircMBassador eventBus;
-    @Mock private ChannelInfo channelInfo;
-    @Mock private User user;
-    @Mock private UserFactory userFactory;
-    @Mock private Query query;
-    @Mock private Date date;
-    @Mock private ClientInfo clientInfo;
-
-    @Before
-    public void setUp() {
-        when(server.getParser()).thenReturn(Optional.of(parser));
-        when(server.getState()).thenReturn(ServerState.CONNECTED);
-        when(parser.getCallbackManager()).thenReturn(callbackManager);
-        when(server.getConnection()).thenReturn(Optional.ofNullable(server));
-        when(userFactory.getUser(any(Connection.class), eq(clientInfo))).thenReturn(user);
-        when(server.getUser(anyString())).thenReturn(user);
-        when(server.getLocalUser()).thenReturn(Optional.of(user));
-        final ServerEventHandler handler = new ServerEventHandler(server, groupChatManager,
-                eventBus);
-        handler.registerCallbacks();
-
-        when(user.getNickname()).thenReturn("ho");
-        when(user.getUsername()).thenReturn(Optional.of("st"));
-        when(user.getHostname()).thenReturn(Optional.of("name"));
-    }
-
-    @Test
-    public void testSelfJoinAddsChannel() {
-        final ChannelSelfJoinListener listener = getCallback(ChannelSelfJoinListener.class);
-        listener.onChannelSelfJoin(parser, date, channelInfo);
-        verify(groupChatManager).addChannel(channelInfo);
-    }
-
-    @Test
-    public void testOnPrivateMessageCreatesQuery() {
-        when(server.hasQuery("ho!st@name")).thenReturn(false);
-        when(server.getQuery("ho!st@name")).thenReturn(query);
-
-        final PrivateMessageListener listener = getCallback(PrivateMessageListener.class);
-        listener.onPrivateMessage(parser, date, "message", "ho!st@name");
-        verify(server).getQuery("ho!st@name");
-    }
-
-    @Test
-    public void testOnPrivateMessageRelaysMessage() {
-        when(server.hasQuery("ho!st@name")).thenReturn(false);
-        when(server.getQuery("ho!st@name")).thenReturn(query);
-
-        final PrivateMessageListener listener = getCallback(PrivateMessageListener.class);
-        listener.onPrivateMessage(parser, date, "message", "ho!st@name");
-        verify(query).onPrivateMessage(parser, date, "message", "ho!st@name");
-    }
-
-    @Test
-    public void testOnPrivateActionCreatesQuery() {
-        when(server.hasQuery("ho!st@name")).thenReturn(false);
-        when(server.getQuery("ho!st@name")).thenReturn(query);
-
-        final PrivateActionListener listener = getCallback(PrivateActionListener.class);
-        listener.onPrivateAction(parser, date, "message", "ho!st@name");
-        verify(server).getQuery("ho!st@name");
-    }
-
-    @Test
-    public void testOnPrivateActionRelaysMessage() {
-        when(server.hasQuery("ho!st@name")).thenReturn(false);
-        when(server.getQuery("ho!st@name")).thenReturn(query);
-
-        final PrivateActionListener listener = getCallback(PrivateActionListener.class);
-        listener.onPrivateAction(parser, date, "message", "ho!st@name");
-        verify(query).onPrivateAction(parser, date, "message", "ho!st@name");
-    }
-
-    @Test
-    public void testOnErrorInfoEmitsUserErrorEvent() {
-        final ParserError error = mock(ParserError.class);
-        when(parser.getServerInformationLines()).thenReturn(Lists.newArrayList("iline1", "iline2"));
-        when(error.getLastLine()).thenReturn("lastline");
-        when(server.getAddress()).thenReturn("serveraddress");
-        when(error.getData()).thenReturn("DATA");
-        when(error.isUserError()).thenReturn(true);
-
-        final ErrorInfoListener listener = getCallback(ErrorInfoListener.class);
-        listener.onErrorInfo(parser, date, error);
-
-        final UserErrorEvent event = getAsyncEvent(UserErrorEvent.class);
-        assertEquals("DATA", event.getMessage());
-    }
-
-    @Test
-    public void testOnErrorInfoEmitsAppErrorEvent() {
-        final ParserError error = mock(ParserError.class);
-        when(parser.getServerInformationLines()).thenReturn(Lists.newArrayList("iline1", "iline2"));
-        when(error.getLastLine()).thenReturn("lastline");
-        when(server.getAddress()).thenReturn("serveraddress");
-        when(error.getData()).thenReturn("DATA");
-        when(error.isUserError()).thenReturn(false);
-
-        final ErrorInfoListener listener = getCallback(ErrorInfoListener.class);
-        listener.onErrorInfo(parser, date, error);
-
-        final AppErrorEvent event = getAsyncEvent(AppErrorEvent.class);
-        assertEquals("DATA", event.getMessage());
-    }
-
-    @Test
-    public void testOnErrorInfoIncludesConnectionDetails() {
-        final ParserError error = mock(ParserError.class);
-        when(parser.getServerInformationLines()).thenReturn(Lists.newArrayList("iline1", "iline2"));
-        when(error.getLastLine()).thenReturn("lastline");
-        when(server.getAddress()).thenReturn("serveraddress");
-        when(error.getData()).thenReturn("DATA");
-        when(error.isUserError()).thenReturn(false);
-
-        final ErrorInfoListener listener = getCallback(ErrorInfoListener.class);
-        listener.onErrorInfo(parser, date, error);
-
-        final AppErrorEvent event = getAsyncEvent(AppErrorEvent.class);
-        assertNotNull(event.getThrowable());
-        assertTrue(event.getThrowable().getMessage().contains("lastline"));
-        assertTrue(event.getThrowable().getMessage().contains("iline1"));
-        assertTrue(event.getThrowable().getMessage().contains("iline2"));
-        assertTrue(event.getThrowable().getMessage().contains("serveraddress"));
-    }
-
-    @Test
-    public void testOnErrorInfoIncludesException() {
-        final ParserError error = mock(ParserError.class);
-        final Exception exception = mock(Exception.class);
-        when(parser.getServerInformationLines()).thenReturn(Lists.newArrayList("iline1", "iline2"));
-        when(error.getLastLine()).thenReturn("lastline");
-        when(server.getAddress()).thenReturn("serveraddress");
-        when(error.getData()).thenReturn("DATA");
-        when(error.isException()).thenReturn(true);
-        when(error.getException()).thenReturn(exception);
-
-        final ErrorInfoListener listener = getCallback(ErrorInfoListener.class);
-        listener.onErrorInfo(parser, date, error);
-
-        final AppErrorEvent event = getAsyncEvent(AppErrorEvent.class);
-        assertNotNull(event.getThrowable());
-        assertEquals(exception, event.getThrowable());
-    }
-
-    @Test
-    public void testOnPrivateCTCPRaisesEvent() {
-        when(server.getUser("ho!st@name")).thenReturn(user);
-
-        final PrivateCtcpListener listener = getCallback(PrivateCtcpListener.class);
-        listener.onPrivateCTCP(parser, date, "type", "message", "ho!st@name");
-
-        final ServerCtcpEvent event = getEvent(ServerCtcpEvent.class);
-        assertEquals("type", event.getType());
-        assertEquals("message", event.getContent());
-        assertEquals(user, event.getUser());
-    }
-
-    @Test
-    public void testOnPrivateCTCPSendsReplyIfEventUnhandled() {
-        when(server.getUser("ho!st@name")).thenReturn(user);
-
-        final PrivateCtcpListener listener = getCallback(PrivateCtcpListener.class);
-        listener.onPrivateCTCP(parser, date, "type", "message", "ho!st@name");
-
-        verify(server).sendCTCPReply("ho", "type", "message");
-    }
-
-    private <T extends CallbackInterface> T getCallback(final Class<T> type) {
-        final ArgumentCaptor<T> captor = ArgumentCaptor.forClass(type);
-        verify(callbackManager).addCallback(eq(type), captor.capture());
-        assertNotNull(captor.getValue());
-        return captor.getValue();
-    }
-
-    private <T extends DMDircEvent> T getAsyncEvent(final Class<T> type) {
-        final ArgumentCaptor<T> captor = ArgumentCaptor.forClass(type);
-        verify(eventBus).publishAsync(captor.capture());
-        assertNotNull(captor.getValue());
-        return captor.getValue();
-    }
-
-    private <T extends DMDircEvent> T getEvent(final Class<T> type) {
-        final ArgumentCaptor<T> captor = ArgumentCaptor.forClass(type);
-        verify(eventBus).publish(captor.capture());
-        assertNotNull(captor.getValue());
-        return captor.getValue();
-    }
-
-}