Merge pull request #71 from csmith/master

Publish events.

common/src/com/dmdirc/parser/common/CallbackObject.java

  */
 package com.dmdirc.parser.common;
 
+import com.dmdirc.parser.events.ErrorInfoEvent;
 import com.dmdirc.parser.interfaces.FakableArgument;
 import com.dmdirc.parser.interfaces.FakableSource;
 import com.dmdirc.parser.interfaces.Parser;
      * @param errorInfo ParserError object to pass as error.
      */
     protected final void callErrorInfo(final ParserError errorInfo) {
-        myManager.getCallback(ErrorInfoListener.class).onErrorInfo(myParser, new Date(), errorInfo);
+        myManager.publish(new ErrorInfoEvent(myParser, new Date(), errorInfo));
     }
 
     /**

common/src/com/dmdirc/parser/events/UnknownMessageEvent.java

     private final String target;
     private final String host;
 
-    public UnknownMessageEvent(final Parser parser, final Date date, final String type,
+    public UnknownMessageEvent(final Parser parser, final Date date,
             final String message, final String target, final String host) {
         super(parser, date);
         this.message = message;

common/src/com/dmdirc/parser/events/UnknownNoticeEvent.java

     private final String target;
     private final String host;
 
-    public UnknownNoticeEvent(final Parser parser, final Date date, final String type,
+    public UnknownNoticeEvent(final Parser parser, final Date date,
             final String message, final String target, final String host) {
         super(parser, date);
         this.message = message;

irc/src/com/dmdirc/parser/irc/IRCParser.java

 import com.dmdirc.parser.common.QueuePriority;
 import com.dmdirc.parser.common.SRVRecord;
 import com.dmdirc.parser.common.SystemEncoder;
+import com.dmdirc.parser.events.ConnectErrorEvent;
+import com.dmdirc.parser.events.DataInEvent;
+import com.dmdirc.parser.events.DataOutEvent;
+import com.dmdirc.parser.events.DebugInfoEvent;
+import com.dmdirc.parser.events.ErrorInfoEvent;
+import com.dmdirc.parser.events.PingFailureEvent;
+import com.dmdirc.parser.events.PingSentEvent;
+import com.dmdirc.parser.events.PingSuccessEvent;
+import com.dmdirc.parser.events.ServerErrorEvent;
+import com.dmdirc.parser.events.ServerReadyEvent;
+import com.dmdirc.parser.events.SocketCloseEvent;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.Encoder;
 import com.dmdirc.parser.interfaces.EncodingParser;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 import java.security.cert.X509Certificate;
-import java.text.SimpleDateFormat;
 import java.text.ParseException;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
      * @param message The error message
      */
     protected void callServerError(final String message) {
-        getCallback(ServerErrorListener.class).onServerError(this, new Date(), message);
+        getCallbackManager().publish(new ServerErrorEvent(this, new Date(), message));
     }
 
     /**
      * @param data Incoming Line.
      */
     protected void callDataIn(final String data) {
-        getCallback(DataInListener.class).onDataIn(this, new Date(), data);
+        getCallbackManager().publish(new DataInEvent(this, new Date(), data));
     }
 
     /**
      * @see DataOutListener
      */
     protected void callDataOut(final String data, final boolean fromParser) {
-        getCallback(DataOutListener.class).onDataOut(this, new Date(), data, fromParser);
+        getCallbackManager().publish(new DataOutEvent(this, new Date(), data));
     }
 
     /**
      * @param data Debugging Information
      */
     protected void callDebugInfo(final int level, final String data) {
-        getCallback(DebugInfoListener.class).onDebugInfo(this, new Date(), level, data);
+        getCallbackManager().publish(new DebugInfoEvent(this, new Date(), level, data));
     }
 
     /**
      * @param errorInfo ParserError object representing the error.
      */
     public void callErrorInfo(final ParserError errorInfo) {
-        getCallback(ErrorInfoListener.class).onErrorInfo(this, new Date(), errorInfo);
+        getCallbackManager().publish(new ErrorInfoEvent(this, new Date(), errorInfo));
     }
 
     /**
      * @param errorInfo ParserError object representing the error.
      */
     protected void callConnectError(final ParserError errorInfo) {
-        getCallback(ConnectErrorListener.class).onConnectError(this, new Date(), errorInfo);
+        getCallbackManager().publish(new ConnectErrorEvent(this, new Date(), errorInfo));
     }
 
     /**
      * @see SocketCloseListener
      */
     protected void callSocketClosed() {
-        getCallback(SocketCloseListener.class).onSocketClosed(this, new Date());
+        getCallbackManager().publish(new SocketCloseEvent(this, new Date()));
     }
 
     /**
      * @see PingFailureListener
      */
     protected void callPingFailed() {
-        getCallbackManager().getCallback(PingFailureListener.class).onPingFailed(this, new Date());
+        getCallbackManager().publish(new PingFailureEvent(this, new Date()));
     }
 
     /**
      * @see PingSentListener
      */
     protected void callPingSent() {
-        getCallback(PingSentListener.class).onPingSent(this, new Date());
+        getCallbackManager().publish(new PingSentEvent(this, new Date()));
     }
 
     /**
      * @see PingSuccessListener
      */
     protected void callPingSuccess() {
-        getCallback(PingSuccessListener.class).onPingSuccess(this, new Date());
+        getCallbackManager().publish(new PingSuccessEvent(this, new Date()));
     }
 
     /**
             parseChanModes();
         }
 
-        getCallback(ServerReadyListener.class).onServerReady(this, new Date());
+        getCallbackManager().publish(new ServerReadyEvent(this, new Date()));
     }
 
     //---------------------------------------------------------------------------

irc/src/com/dmdirc/parser/irc/ProcessingManager.java

 package com.dmdirc.parser.irc;
 
 import com.dmdirc.parser.common.ParserError;
+import com.dmdirc.parser.events.NumericEvent;
 import com.dmdirc.parser.interfaces.callbacks.NumericListener;
 import com.dmdirc.parser.irc.processors.IRCProcessor;
 import com.dmdirc.parser.irc.processors.Process001;
      * @param token IRC Tokenised line
      */
     protected void callNumeric(final int numeric, final String... token) {
-        parser.getCallbackManager().getCallback(NumericListener.class)
-                .onNumeric(parser, new Date(), numeric, token);
+        parser.getCallbackManager().publish(new NumericEvent(parser, new Date(), numeric, token));
     }
 }

irc/src/com/dmdirc/parser/irc/SimpleNickInUseHandler.java

 
 package com.dmdirc.parser.irc;
 
+import com.dmdirc.parser.events.DebugInfoEvent;
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.callbacks.DebugInfoListener;
 import com.dmdirc.parser.interfaces.callbacks.NickInUseListener;
 
 import java.util.Date;
     }
 
     private void callDebugInfo(final Parser parser, final int level, final String data) {
-        parser.getCallbackManager().getCallback(DebugInfoListener.class)
-                .onDebugInfo(parser, new Date(), level, data);
+        parser.getCallbackManager().publish(
+                new DebugInfoEvent(parser, new Date(), level, data));
     }
 }

irc/src/com/dmdirc/parser/irc/processors/IRCProcessor.java

 
 package com.dmdirc.parser.irc.processors;
 
+import com.dmdirc.parser.common.CallbackManager;
 import com.dmdirc.parser.common.ParserError;
 import com.dmdirc.parser.common.QueuePriority;
-import com.dmdirc.parser.interfaces.callbacks.CallbackInterface;
 import com.dmdirc.parser.interfaces.callbacks.DebugInfoListener;
 import com.dmdirc.parser.interfaces.callbacks.ErrorInfoListener;
 import com.dmdirc.parser.irc.IRCChannelInfo;
         return parser.getChannel(name);
     }
 
-    /**
-     * Gets a callback proxy used to raise events.
-     *
-     * @param callback The type of callback proxy to retrieve.
-     * @param <T> The type of callback proxy to retrieve.
-     * @return A proxy that can be used to call events.
-     */
-    protected <T extends CallbackInterface> T getCallback(final Class<T> callback) {
-        return parser.getCallbackManager().getCallback(callback);
+    protected CallbackManager getCallbackManager() {
+        return parser.getCallbackManager();
     }
 
     /**

irc/src/com/dmdirc/parser/irc/processors/Process004005.java

 
 import com.dmdirc.parser.common.ParserError;
 import com.dmdirc.parser.common.QueuePriority;
+import com.dmdirc.parser.events.NetworkDetectedEvent;
 import com.dmdirc.parser.interfaces.callbacks.NetworkDetectedListener;
 import com.dmdirc.parser.irc.CapabilityState;
 import com.dmdirc.parser.irc.IRCEncoding;
         final String ircdVersion = parser.getServerSoftware();
         final String ircdType = parser.getServerSoftwareType();
 
-        getCallback(NetworkDetectedListener.class)
-                .onGotNetwork(parser, new Date(), networkName, ircdVersion, ircdType);
+        getCallbackManager().publish(
+                new NetworkDetectedEvent(parser, new Date(), networkName, ircdVersion, ircdType));
     }
 
     /**

irc/src/com/dmdirc/parser/irc/processors/Process464.java

 
 package com.dmdirc.parser.irc.processors;
 
+import com.dmdirc.parser.events.PasswordRequiredEvent;
 import com.dmdirc.parser.interfaces.callbacks.PasswordRequiredListener;
 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.parser.irc.ProcessingManager;
      * @see PasswordRequiredListener
      */
     protected void callPasswordRequired() {
-        getCallback(PasswordRequiredListener.class).onPasswordRequired(parser, new Date());
+        getCallbackManager().publish(new PasswordRequiredEvent(parser, new Date()));
     }
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessAway.java

 package com.dmdirc.parser.irc.processors;
 
 import com.dmdirc.parser.common.AwayState;
+import com.dmdirc.parser.events.AwayStateEvent;
 import com.dmdirc.parser.interfaces.callbacks.AwayStateListener;
 import com.dmdirc.parser.irc.IRCClientInfo;
 import com.dmdirc.parser.irc.IRCParser;
      */
     protected void callAwayState(final AwayState oldState, final AwayState currentState,
             final String reason) {
-        getCallback(AwayStateListener.class)
-                .onAwayState(parser, new Date(), oldState, currentState, reason);
+        getCallbackManager().publish(
+                new AwayStateEvent(parser, new Date(), oldState, currentState, reason));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessInvite.java

 
 package com.dmdirc.parser.irc.processors;
 
+import com.dmdirc.parser.events.InviteEvent;
 import com.dmdirc.parser.interfaces.callbacks.InviteListener;
 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.parser.irc.ProcessingManager;
      * @param channel The name of the channel we were invited to
      */
     protected void callInvite(final String userHost, final String channel) {
-        getCallback(InviteListener.class).onInvite(parser, new Date(), userHost, channel);
+        getCallbackManager().publish(new InviteEvent(parser, new Date(), userHost, channel));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessJoin.java

 
 import com.dmdirc.parser.common.ParserError;
 import com.dmdirc.parser.common.QueuePriority;
+import com.dmdirc.parser.events.ChannelJoinEvent;
+import com.dmdirc.parser.events.ChannelSelfJoinEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelJoinListener;
      */
     protected void callChannelJoin(final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient) {
-        getCallback(ChannelJoinListener.class).onChannelJoin(parser, new Date(), cChannel,
-                cChannelClient);
+        getCallbackManager().publish(
+                new ChannelJoinEvent(parser, new Date(), cChannel, cChannelClient));
     }
 
     /**
      * @param cChannel Channel Object
      */
     protected void callChannelSelfJoin(final ChannelInfo cChannel) {
-        getCallback(ChannelSelfJoinListener.class).onChannelSelfJoin(parser, new Date(), cChannel);
+        getCallbackManager().publish(new ChannelSelfJoinEvent(parser, new Date(), cChannel));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessKick.java

 package com.dmdirc.parser.irc.processors;
 
 import com.dmdirc.parser.common.ParserError;
+import com.dmdirc.parser.events.ChannelKickEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelKickListener;
     protected void callChannelKick(final ChannelInfo cChannel,
             final ChannelClientInfo cKickedClient, final ChannelClientInfo cKickedByClient,
             final String sReason, final String sKickedByHost) {
-        getCallback(ChannelKickListener.class)
-                .onChannelKick(parser, new Date(), cChannel, cKickedClient, cKickedByClient,
-                        sReason, sKickedByHost);
+        getCallbackManager().publish(
+                new ChannelKickEvent(parser, new Date(), cChannel, cKickedClient, cKickedByClient,
+                        sReason, sKickedByHost));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessList.java

 
 package com.dmdirc.parser.irc.processors;
 
-import com.dmdirc.parser.interfaces.callbacks.GroupListEndListener;
-import com.dmdirc.parser.interfaces.callbacks.GroupListEntryListener;
-import com.dmdirc.parser.interfaces.callbacks.GroupListStartListener;
+import com.dmdirc.parser.events.GroupListEndEvent;
+import com.dmdirc.parser.events.GroupListEntryEvent;
+import com.dmdirc.parser.events.GroupListStartEvent;
 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.parser.irc.ProcessingManager;
 
         // :port80b.se.quakenet.org 323 MD87 :End of /LIST
         switch (sParam) {
             case "321":
-                getCallback(GroupListStartListener.class).onGroupListStart(parser, new Date());
+                getCallbackManager().publish(new GroupListStartEvent(parser, new Date()));
                 break;
             case "322":
-                getCallback(GroupListEntryListener.class)
-                        .onGroupListEntry(parser, new Date(), token[3], Integer.parseInt(token[4]),
-                                token[5]);
+                getCallbackManager().publish(new GroupListEntryEvent(parser, new Date(), token[3],
+                        Integer.parseInt(token[4]), token[5]));
                 break;
             case "323":
-                getCallback(GroupListEndListener.class).onGroupListEnd(parser, new Date());
+                getCallbackManager().publish(new GroupListEndEvent(parser, new Date()));
                 break;
         }
     }

irc/src/com/dmdirc/parser/irc/processors/ProcessListModes.java

 
 import com.dmdirc.parser.common.ChannelListModeItem;
 import com.dmdirc.parser.common.ParserError;
+import com.dmdirc.parser.events.ChannelListModeEvent;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelListModeListener;
 import com.dmdirc.parser.irc.IRCChannelInfo;
      * @param mode the mode that we got list modes for.
      */
     protected void callChannelGotListModes(final ChannelInfo cChannel, final char mode) {
-        getCallback(ChannelListModeListener.class)
-                .onChannelGotListModes(parser, new Date(), cChannel, mode);
+        getCallbackManager().publish(new ChannelListModeEvent(parser, new Date(), cChannel, mode));
     }
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessMOTD.java

 
 package com.dmdirc.parser.irc.processors;
 
+import com.dmdirc.parser.events.MOTDEndEvent;
+import com.dmdirc.parser.events.MOTDLineEvent;
+import com.dmdirc.parser.events.MOTDStartEvent;
 import com.dmdirc.parser.interfaces.callbacks.MotdEndListener;
 import com.dmdirc.parser.interfaces.callbacks.MotdLineListener;
 import com.dmdirc.parser.interfaces.callbacks.MotdStartListener;
      * @see MotdEndListener
      */
     protected void callMOTDEnd(final boolean noMOTD, final String data) {
-        getCallback(MotdEndListener.class).onMOTDEnd(parser, new Date(), noMOTD, data);
+        getCallbackManager().publish(new MOTDEndEvent(parser, new Date(), noMOTD, data));
     }
 
     /**
      * @param data Incomming Line.
      */
     protected void callMOTDLine(final String data) {
-        getCallback(MotdLineListener.class).onMOTDLine(parser, new Date(), data);
+        getCallbackManager().publish(new MOTDLineEvent(parser, new Date(), data));
     }
 
     /**
      * @param data Incomming Line.
      */
     protected void callMOTDStart(final String data) {
-        getCallback(MotdStartListener.class).onMOTDStart(parser, new Date(), data);
+        getCallbackManager().publish(new MOTDStartEvent(parser, new Date(), data));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessMessage.java

 package com.dmdirc.parser.irc.processors;
 
 import com.dmdirc.parser.common.ParserError;
+import com.dmdirc.parser.events.ChannelActionEvent;
+import com.dmdirc.parser.events.ChannelCTCPEvent;
+import com.dmdirc.parser.events.ChannelCTCPReplyEvent;
+import com.dmdirc.parser.events.ChannelMessageEvent;
+import com.dmdirc.parser.events.ChannelModeMessageEvent;
+import com.dmdirc.parser.events.ChannelModeNoticeEvent;
+import com.dmdirc.parser.events.ChannelNoticeEvent;
+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.ServerNoticeEvent;
+import com.dmdirc.parser.events.UnknownActionEvent;
+import com.dmdirc.parser.events.UnknownCTCPEvent;
+import com.dmdirc.parser.events.UnknownCTCPReplyEvent;
+import com.dmdirc.parser.events.UnknownMessageEvent;
+import com.dmdirc.parser.events.UnknownNoticeEvent;
+import com.dmdirc.parser.events.UnknownServerNoticeEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelActionListener;
      */
     protected void callChannelAction(final Date date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
-        getCallback(ChannelActionListener.class)
-                .onChannelAction(parser, date, cChannel, cChannelClient, sMessage, sHost);
+        getCallbackManager().publish(
+                new ChannelActionEvent(parser, date, cChannel, cChannelClient, sMessage, sHost));
     }
 
     /**
     protected void callChannelCTCP(final Date date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sType, final String sMessage,
             final String sHost) {
-        getCallback(ChannelCtcpListener.class)
-                .onChannelCTCP(parser, date, cChannel, cChannelClient, sType, sMessage, sHost);
+        getCallbackManager().publish(
+                new ChannelCTCPEvent(parser, date, cChannel, cChannelClient, sType, sMessage,
+                        sHost));
     }
 
     /**
     protected void callChannelCTCPReply(final Date date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sType, final String sMessage,
             final String sHost) {
-        getCallback(ChannelCtcpReplyListener.class)
-                .onChannelCTCPReply(parser, date, cChannel, cChannelClient, sType, sMessage, sHost);
+        getCallbackManager().publish(
+                new ChannelCTCPReplyEvent(parser, date, cChannel, cChannelClient, sType, sMessage,
+                        sHost));
     }
 
     /**
      */
     protected void callChannelMessage(final Date date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
-        getCallback(ChannelMessageListener.class)
-                .onChannelMessage(parser, date, cChannel, cChannelClient, sMessage, sHost);
+        getCallbackManager().publish(
+                new ChannelMessageEvent(parser, date, cChannel, cChannelClient, sMessage, sHost));
     }
 
     /**
      */
     protected void callChannelNotice(final Date date, final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
-        getCallback(ChannelNoticeListener.class)
-                .onChannelNotice(parser, date, cChannel, cChannelClient, sMessage, sHost);
+        getCallbackManager().publish(
+                new ChannelNoticeEvent(parser, date, cChannel, cChannelClient, sMessage, sHost));
     }
 
     /**
     protected void callChannelModeNotice(final Date date, final char prefix,
             final ChannelInfo cChannel, final ChannelClientInfo cChannelClient,
             final String sMessage, final String sHost) {
-        getCallback(ChannelModeNoticeListener.class)
-                .onChannelModeNotice(parser, date, cChannel, prefix, cChannelClient, sMessage,
-                        sHost);
+        getCallbackManager().publish(
+                new ChannelModeNoticeEvent(parser, date, cChannel, prefix, cChannelClient, sMessage,
+                        sHost));
     }
 
     /**
     protected void callChannelModeMessage(final Date date, final char prefix,
             final ChannelInfo cChannel, final ChannelClientInfo cChannelClient,
             final String sMessage, final String sHost) {
-        getCallback(ChannelModeMessageListener.class)
-                .onChannelModeMessage(parser, date, cChannel, prefix, cChannelClient, sMessage,
-                        sHost);
+        getCallbackManager().publish(
+                new ChannelModeMessageEvent(parser, date, cChannel, prefix, cChannelClient,
+                        sMessage, sHost));
     }
 
     /**
      * @param sHost Hostname of sender (or servername)
      */
     protected void callPrivateAction(final Date date, final String sMessage, final String sHost) {
-        getCallback(PrivateActionListener.class)
-                .onPrivateAction(parser, date, sMessage, sHost);
+        getCallbackManager().publish(new PrivateActionEvent(parser, date, sMessage, sHost));
     }
 
     /**
      */
     protected void callPrivateCTCP(final Date date, final String sType, final String sMessage,
             final String sHost) {
-        getCallback(PrivateCtcpListener.class)
-                .onPrivateCTCP(parser, date, sType, sMessage, sHost);
+        getCallbackManager().publish(new PrivateCTCPEvent(parser, date, sType, sMessage, sHost));
     }
 
     /**
      */
     protected void callPrivateCTCPReply(final Date date, final String sType, final String sMessage,
             final String sHost) {
-        getCallback(PrivateCtcpReplyListener.class)
-                .onPrivateCTCPReply(parser, date, sType, sMessage, sHost);
+        getCallbackManager().publish(
+                new PrivateCTCPReplyEvent(parser, date, sType, sMessage, sHost));
     }
 
     /**
      * @param sHost Hostname of sender (or servername)
      */
     protected void callPrivateMessage(final Date date, final String sMessage, final String sHost) {
-        getCallback(PrivateMessageListener.class)
-                .onPrivateMessage(parser, date, sMessage, sHost);
+        getCallbackManager().publish(new PrivateMessageEvent(parser, date, sMessage, sHost));
     }
 
     /**
      * @param sHost Hostname of sender (or servername)
      */
     protected void callPrivateNotice(final Date date, final String sMessage, final String sHost) {
-        getCallback(PrivateNoticeListener.class)
-                .onPrivateNotice(parser, date, sMessage, sHost);
+        getCallbackManager().publish(new PrivateNoticeEvent(parser, date, sMessage, sHost));
     }
 
     /**
      * @param sHost Hostname of sender (or servername)
      */
     protected void callServerNotice(final Date date, final String sMessage, final String sHost) {
-        getCallback(ServerNoticeListener.class)
-                .onServerNotice(parser, date, sMessage, sHost);
+        getCallbackManager().publish(new ServerNoticeEvent(parser, date, sMessage, sHost));
     }
 
     /**
      */
     protected void callUnknownAction(final Date date, final String sMessage, final String sTarget,
             final String sHost) {
-        getCallback(UnknownActionListener.class)
-                .onUnknownAction(parser, date, sMessage, sTarget, sHost);
+        getCallbackManager().publish(new UnknownActionEvent(parser, date, sMessage, sTarget, sHost));
     }
 
     /**
      */
     protected void callUnknownCTCP(final Date date, final String sType, final String sMessage,
             final String sTarget, final String sHost) {
-        getCallback(UnknownCtcpListener.class)
-                .onUnknownCTCP(parser, date, sType, sMessage, sTarget, sHost);
+        getCallbackManager().publish(
+                new UnknownCTCPEvent(parser, date, sType, sMessage, sTarget, sHost));
     }
 
     /**
      */
     protected void callUnknownCTCPReply(final Date date, final String sType, final String sMessage,
             final String sTarget, final String sHost) {
-        getCallback(UnknownCtcpReplyListener.class)
-                .onUnknownCTCPReply(parser, date, sType, sMessage, sTarget, sHost);
+        getCallbackManager().publish(
+                new UnknownCTCPReplyEvent(parser, date, sType, sMessage, sTarget, sHost));
     }
 
     /**
      */
     protected void callUnknownMessage(final Date date, final String sMessage, final String sTarget,
             final String sHost) {
-        getCallback(UnknownMessageListener.class)
-                .onUnknownMessage(parser, date, sMessage, sTarget, sHost);
+        getCallbackManager().publish(
+                new UnknownMessageEvent(parser, date, sMessage, sTarget, sHost));
     }
 
     /**
      */
     protected void callUnknownNotice(final Date date, final String sMessage, final String sTarget,
             final String sHost) {
-        getCallback(UnknownNoticeListener.class)
-                .onUnknownNotice(parser, date, sMessage, sTarget, sHost);
+        getCallbackManager().publish(new UnknownNoticeEvent(parser, date, sMessage, sTarget, sHost));
     }
 
     /**
      */
     protected void callUnknownServerNotice(final Date date, final String sMessage,
             final String sTarget, final String sHost) {
-        getCallback(UnknownServerNoticeListener.class)
-                .onUnknownServerNotice(parser, date, sMessage, sTarget, sHost);
+        getCallbackManager().publish(
+                new UnknownServerNoticeEvent(parser, date, sMessage, sTarget, sHost));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessMode.java

 
 import com.dmdirc.parser.common.ChannelListModeItem;
 import com.dmdirc.parser.common.ParserError;
+import com.dmdirc.parser.events.ChannelModeChangeEvent;
+import com.dmdirc.parser.events.ChannelNonUserModeChangeEvent;
+import com.dmdirc.parser.events.ChannelSingleModeChangeEvent;
+import com.dmdirc.parser.events.ChannelUserModeChangeEvent;
+import com.dmdirc.parser.events.UserModeChangeEvent;
+import com.dmdirc.parser.events.UserModeDiscoveryEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelModeChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelNonUserModeChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.ChannelSingleModeChangeListener;
 import com.dmdirc.parser.interfaces.callbacks.ChannelUserModeChangeListener;
 import com.dmdirc.parser.interfaces.callbacks.UserModeChangeListener;
 import com.dmdirc.parser.interfaces.callbacks.UserModeDiscoveryListener;
                         iChannel.setListModeParam(cMode, new ChannelListModeItem(sModeParam, token[0], nTemp), bPositive);
                         callDebugInfo(IRCParser.DEBUG_INFO, "List Mode: %c [%s] {Positive: %b}", cMode, sModeParam, bPositive);
                         if (!"324".equals(sParam)) {
-                            getCallback(ChannelSingleModeChangeListener.class)
-                                    .onChannelSingleModeChanged(parser, new Date(), iChannel,
+                            getCallbackManager().publish(
+                                    new ChannelSingleModeChangeEvent(parser, new Date(), iChannel,
                                             setterCCI, token[0], cPositive + cMode + " " +
-                                                    sModeParam);
+                                            sModeParam));
                         }
                     } else {
                         // Mode with a parameter
                             callDebugInfo(IRCParser.DEBUG_INFO, "Set Mode: %c [%s] {Positive: %b}", cMode, sModeParam, bPositive);
                             iChannel.setModeParam(cMode, sModeParam);
                             if (!"324".equals(sParam)) {
-                                getCallback(ChannelSingleModeChangeListener.class)
-                                        .onChannelSingleModeChanged(parser, new Date(), iChannel,
-                                                setterCCI, token[0], cPositive + cMode + " " +
-                                                        sModeParam);
+                                getCallbackManager().publish(
+                                        new ChannelSingleModeChangeEvent(parser, new Date(),
+                                                iChannel, setterCCI, token[0],
+                                                cPositive + cMode + " " +
+                                                        sModeParam));
                             }
                         } else {
                             // -Mode - parameter isn't always needed, we need to check
                             callDebugInfo(IRCParser.DEBUG_INFO, "Unset Mode: %c [%s] {Positive: %b}", cMode, sModeParam, bPositive);
                             iChannel.setModeParam(cMode, "");
                             if (!"324".equals(sParam)) {
-                                getCallback(ChannelSingleModeChangeListener.class)
-                                        .onChannelSingleModeChanged(parser, new Date(), iChannel,
-                                                setterCCI, token[0], trim(cPositive + cMode + " "
-                                                        + sModeParam));
+                                getCallbackManager().publish(
+                                        new ChannelSingleModeChangeEvent(parser, new Date(),
+                                                iChannel, setterCCI, token[0],
+                                                trim(cPositive + cMode + " " + sModeParam)));
                             }
                         }
                     }
             callChannelModeChanged(iChannel, null, "", sFullModeStr.toString().trim());
         } else {
             callChannelModeChanged(iChannel, setterCCI, token[0], sFullModeStr.toString().trim());
-            getCallback(ChannelNonUserModeChangeListener.class)
-                    .onChannelNonUserModeChanged(parser, new Date(), iChannel, setterCCI, token[0],
-                            trim(sNonUserModeStr.toString() + sNonUserModeStrParams));
+            getCallbackManager().publish(
+                    new ChannelNonUserModeChangeEvent(parser, new Date(), iChannel, setterCCI,
+                            token[0], trim(sNonUserModeStr.toString() + sNonUserModeStrParams)));
         }
     }
 
      */
     protected void callChannelModeChanged(final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sHost, final String sModes) {
-        getCallback(ChannelModeChangeListener.class)
-                .onChannelModeChanged(parser, new Date(), cChannel, cChannelClient, sHost, sModes);
+        getCallbackManager().publish(
+                new ChannelModeChangeEvent(parser, new Date(), cChannel, cChannelClient, sHost,
+                        sModes));
     }
 
     /**
     protected void callChannelUserModeChanged(final ChannelInfo cChannel,
             final ChannelClientInfo cChangedClient, final ChannelClientInfo cSetByClient,
             final String sHost, final String sMode) {
-        getCallback(ChannelUserModeChangeListener.class)
-                .onChannelUserModeChanged(parser, new Date(), cChannel, cChangedClient,
-                        cSetByClient, sHost, sMode);
+        getCallbackManager().publish(
+                new ChannelUserModeChangeEvent(parser, new Date(), cChannel, cChangedClient,
+                        cSetByClient, sHost, sMode));
     }
 
     /**
      */
     protected void callUserModeChanged(final ClientInfo cClient, final String sSetby,
             final String sModes) {
-        getCallback(UserModeChangeListener.class)
-                .onUserModeChanged(parser, new Date(), cClient, sSetby, sModes);
+        getCallbackManager().publish(
+                new UserModeChangeEvent(parser, new Date(), cClient, sSetby, sModes));
     }
 
     /**
      * @param sModes The modes set.
      */
     protected void callUserModeDiscovered(final ClientInfo cClient, final String sModes) {
-        getCallback(UserModeDiscoveryListener.class)
-                .onUserModeDiscovered(parser, new Date(), cClient, sModes);
+        getCallbackManager().publish(
+                new UserModeDiscoveryEvent(parser, new Date(), cClient, sModes));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessNames.java

 
 package com.dmdirc.parser.irc.processors;
 
+import com.dmdirc.parser.events.ChannelNamesEvent;
+import com.dmdirc.parser.events.ChannelTopicEvent;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelNamesListener;
 import com.dmdirc.parser.interfaces.callbacks.ChannelTopicListener;
      */
     protected void callChannelTopic(final ChannelInfo cChannel, final boolean bIsJoinTopic) {
         ((IRCChannelInfo) cChannel).setHadTopic();
-        getCallback(ChannelTopicListener.class)
-                .onChannelTopic(parser, new Date(), cChannel, bIsJoinTopic);
+        getCallbackManager().publish(
+                new ChannelTopicEvent(parser, new Date(), cChannel, bIsJoinTopic));
     }
 
     /**
      * @param cChannel Channel which the names reply is for
      */
     protected void callChannelGotNames(final ChannelInfo cChannel) {
-        getCallback(ChannelNamesListener.class)
-                .onChannelGotNames(parser, new Date(), cChannel);
+        getCallbackManager().publish(new ChannelNamesEvent(parser, new Date(), cChannel));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessNick.java

 package com.dmdirc.parser.irc.processors;
 
 import com.dmdirc.parser.common.ParserError;
+import com.dmdirc.parser.events.ChannelNickChangeEvent;
+import com.dmdirc.parser.events.NickChangeEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.ClientInfo;
      */
     protected void callChannelNickChanged(final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sOldNick) {
-        getCallback(ChannelNickChangeListener.class)
-                .onChannelNickChanged(parser, new Date(), cChannel, cChannelClient, sOldNick);
+        getCallbackManager().publish(
+                new ChannelNickChangeEvent(parser, new Date(), cChannel, cChannelClient, sOldNick));
     }
 
     /**
      * @param sOldNick Nickname before change
      */
     protected void callNickChanged(final ClientInfo cClient, final String sOldNick) {
-        getCallback(NickChangeListener.class)
-                .onNickChanged(parser, new Date(), cClient, sOldNick);
+        getCallbackManager().publish(new NickChangeEvent(parser, new Date(), cClient, sOldNick));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessNickInUse.java

 
 package com.dmdirc.parser.irc.processors;
 
+import com.dmdirc.parser.events.NickInUseEvent;
 import com.dmdirc.parser.interfaces.callbacks.NickInUseListener;
 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.parser.irc.ProcessingManager;
      * @see NickInUseListener
      */
     protected void callNickInUse(final String nickname) {
-        getCallback(NickInUseListener.class)
-                .onNickInUse(parser, new Date(), nickname);
+        getCallbackManager().publish(new NickInUseEvent(parser, new Date(), nickname));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessNoticeAuth.java

 
 package com.dmdirc.parser.irc.processors;
 
+import com.dmdirc.parser.events.AuthNoticeEvent;
 import com.dmdirc.parser.interfaces.callbacks.AuthNoticeListener;
 import com.dmdirc.parser.irc.IRCParser;
 import com.dmdirc.parser.irc.ProcessingManager;
      * @param data Incomming Line.
      */
     protected void callNoticeAuth(final String data) {
-        getCallback(AuthNoticeListener.class).onNoticeAuth(parser, new Date(), data);
+        getCallbackManager().publish(new AuthNoticeEvent(parser, new Date(), data));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessPart.java

 package com.dmdirc.parser.irc.processors;
 
 import com.dmdirc.parser.common.ParserError;
+import com.dmdirc.parser.events.ChannelPartEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelPartListener;
      */
     protected void callChannelPart(final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sReason) {
-        getCallback(ChannelPartListener.class)
-                .onChannelPart(parser, new Date(), cChannel, cChannelClient, sReason);
+        getCallbackManager().publish(
+                new ChannelPartEvent(parser, new Date(), cChannel, cChannelClient, sReason));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessQuit.java

 
 package com.dmdirc.parser.irc.processors;
 
+import com.dmdirc.parser.events.ChannelQuitEvent;
+import com.dmdirc.parser.events.QuitEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.ClientInfo;
      */
     protected void callChannelQuit(final ChannelInfo cChannel,
             final ChannelClientInfo cChannelClient, final String sReason) {
-        getCallback(ChannelQuitListener.class)
-                .onChannelQuit(parser, new Date(), cChannel, cChannelClient, sReason);
+        getCallbackManager().publish(
+                new ChannelQuitEvent(parser, new Date(), cChannel, cChannelClient, sReason));
     }
 
     /**
      * @param sReason Reason for quitting (may be "")
      */
     protected void callQuit(final ClientInfo cClient, final String sReason) {
-        getCallback(QuitListener.class)
-                .onQuit(parser, new Date(), cClient, sReason);
+        getCallbackManager().publish(new QuitEvent(parser, new Date(), cClient, sReason));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessTopic.java

 
 package com.dmdirc.parser.irc.processors;
 
+import com.dmdirc.parser.events.ChannelTopicEvent;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.callbacks.ChannelTopicListener;
 import com.dmdirc.parser.irc.IRCChannelInfo;
      */
     protected void callChannelTopic(final ChannelInfo cChannel, final boolean bIsJoinTopic) {
         ((IRCChannelInfo) cChannel).setHadTopic();
-        getCallback(ChannelTopicListener.class)
-                .onChannelTopic(parser, new Date(), cChannel, bIsJoinTopic);
+        getCallbackManager().publish(
+                new ChannelTopicEvent(parser, new Date(), cChannel, bIsJoinTopic));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessWallops.java

 
 package com.dmdirc.parser.irc.processors;
 
+import com.dmdirc.parser.events.WallDesyncEvent;
+import com.dmdirc.parser.events.WallopEvent;
+import com.dmdirc.parser.events.WalluserEvent;
 import com.dmdirc.parser.interfaces.callbacks.WallDesyncListener;
 import com.dmdirc.parser.interfaces.callbacks.WallopListener;
 import com.dmdirc.parser.interfaces.callbacks.WalluserListener;
      * @param host Host of the user who sent the wallop
      */
     protected void callWallop(final String message, final String host) {
-        getCallback(WallopListener.class).onWallop(parser, new Date(), message, host);
+        getCallbackManager().publish(new WallopEvent(parser, new Date(), message, host));
     }
 
     /**
      * @param host Host of the user who sent the walluser
      */
     protected void callWalluser(final String message, final String host) {
-        getCallback(WalluserListener.class)
-                .onWalluser(parser, new Date(), message, host);
+        getCallbackManager().publish(new WalluserEvent(parser, new Date(), message, host));
     }
 
     /**
      * @param host Host of the user who sent the WallDesync
      */
     protected void callWallDesync(final String message, final String host) {
-        getCallback(WallDesyncListener.class)
-                .onWallDesync(parser, new Date(), message, host);
+        getCallbackManager().publish(new WallDesyncEvent(parser, new Date(), message, host));
     }
 
 }

irc/src/com/dmdirc/parser/irc/processors/ProcessWho.java

 package com.dmdirc.parser.irc.processors;
 
 import com.dmdirc.parser.common.AwayState;
+import com.dmdirc.parser.events.AwayStateEvent;
+import com.dmdirc.parser.events.ChannelOtherAwayStateEvent;
+import com.dmdirc.parser.events.OtherAwayStateEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.ClientInfo;
      */
     protected void callAwayState(final AwayState oldState, final AwayState currentState,
             final String reason) {
-        getCallback(AwayStateListener.class)
-                .onAwayState(parser, new Date(), oldState, currentState, reason);
+        getCallbackManager().publish(
+                new AwayStateEvent(parser, new Date(), oldState, currentState, reason));
     }
 
     /**
      */
     protected void callAwayStateOther(final ClientInfo client, final AwayState oldState,
             final AwayState state) {
-        getCallback(OtherAwayStateListener.class)
-                .onAwayStateOther(parser, new Date(), client, oldState, state);
+        getCallbackManager().publish(
+                new OtherAwayStateEvent(parser, new Date(), client, oldState, state));
     }
 
     /**
      */
     protected void callChannelAwayStateOther(final ChannelInfo channel,
             final ChannelClientInfo channelClient, final AwayState oldState, final AwayState state) {
-        getCallback(ChannelOtherAwayStateListener.class)
-                .onChannelAwayStateOther(parser, new Date(), channel, channelClient, oldState,
-                        state);
+        getCallbackManager().publish(
+                new ChannelOtherAwayStateEvent(parser, new Date(), channel, channelClient, oldState,
+                        state));
     }
 
 }

xmpp/src/com/dmdirc/parser/xmpp/XmppFakeChannel.java

 
 import com.dmdirc.parser.common.BaseChannelInfo;
 import com.dmdirc.parser.common.ChannelListModeItem;
+import com.dmdirc.parser.events.ChannelNamesEvent;
 import com.dmdirc.parser.interfaces.ChannelClientInfo;
 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.Parser;
-import com.dmdirc.parser.interfaces.callbacks.ChannelNamesListener;
 
 import java.util.Collection;
 import java.util.Date;
         }
 
         // TODO: Delete old contacts, don't needlessly create new objects
-        getParser().getCallbackManager().getCallback(ChannelNamesListener.class)
-                .onChannelGotNames(getParser(), new Date(), this);
+        getParser().getCallbackManager().publish(
+                new ChannelNamesEvent(getParser(), new Date(), this));
     }
 
 }

xmpp/src/com/dmdirc/parser/xmpp/XmppParser.java

 import com.dmdirc.parser.common.DefaultStringConverter;
 import com.dmdirc.parser.common.ParserError;
 import com.dmdirc.parser.common.QueuePriority;
+import com.dmdirc.parser.events.AwayStateEvent;
+import com.dmdirc.parser.events.ChannelSelfJoinEvent;
+import com.dmdirc.parser.events.CompositionStateChangeEvent;
+import com.dmdirc.parser.events.ConnectErrorEvent;
+import com.dmdirc.parser.events.DataInEvent;
+import com.dmdirc.parser.events.DataOutEvent;
+import com.dmdirc.parser.events.NumericEvent;
+import com.dmdirc.parser.events.OtherAwayStateEvent;
+import com.dmdirc.parser.events.PrivateActionEvent;
+import com.dmdirc.parser.events.PrivateMessageEvent;
+import com.dmdirc.parser.events.ServerReadyEvent;
+import com.dmdirc.parser.events.SocketCloseEvent;
 import com.dmdirc.parser.interfaces.ChannelInfo;
 import com.dmdirc.parser.interfaces.ClientInfo;
 import com.dmdirc.parser.interfaces.LocalClientInfo;
 import com.dmdirc.parser.interfaces.StringConverter;
-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.CompositionStateChangeListener;
-import com.dmdirc.parser.interfaces.callbacks.ConnectErrorListener;
 import com.dmdirc.parser.interfaces.callbacks.DataInListener;
 import com.dmdirc.parser.interfaces.callbacks.DataOutListener;
-import com.dmdirc.parser.interfaces.callbacks.NumericListener;
-import com.dmdirc.parser.interfaces.callbacks.OtherAwayStateListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateActionListener;
-import com.dmdirc.parser.interfaces.callbacks.PrivateMessageListener;
-import com.dmdirc.parser.interfaces.callbacks.ServerReadyListener;
-import com.dmdirc.parser.interfaces.callbacks.SocketCloseListener;
 
 import java.net.URI;
 import java.util.Collection;
         newArgs[2] = getLocalClient().getNickname();
         System.arraycopy(args, 0, newArgs, 3, args.length);
 
-        getCallback(NumericListener.class).onNumeric(this, new Date(), numeric, newArgs);
+        getCallbackManager().publish(new NumericEvent(this, new Date(), numeric, newArgs));
     }
 
     @Override
     @Override
     public void run() {
         if (getURI().getUserInfo() == null || !getURI().getUserInfo().contains(":")) {
-            getCallback(ConnectErrorListener.class).onConnectError(this,
-                    new Date(), new ParserError(ParserError.ERROR_USER,
-                            "User name and password must be specified in URI", ""));
+            getCallbackManager().publish(new ConnectErrorEvent(this, new Date(),
+                    new ParserError(ParserError.ERROR_USER,
+                            "User name and password must be specified in URI", "")));
             return;
         }
         final String[] userInfoParts = getURI().getUserInfo().split(":", 2);
             try {
                 connection.login(userInfoParts[0], userInfoParts[1], "DMDirc.");
             } catch (XMPPException ex) {
-                getCallback(ConnectErrorListener.class).onConnectError(this,
-                        new Date(), new ParserError(ParserError.ERROR_USER,
-                                ex.getMessage(), ""));
+                getCallbackManager().publish(new ConnectErrorEvent(this, new Date(),
+                        new ParserError(ParserError.ERROR_USER, ex.getMessage(), "")));
                 return;
             }
 
 
             setServerName(connection.getServiceName());
 
-            getCallback(ServerReadyListener.class).onServerReady(this, new Date());
+            getCallbackManager().publish(new ServerReadyEvent(this, new Date()));
 
             for (RosterEntry contact : connection.getRoster().getEntries()) {
                 getClient(contact.getUser()).setRosterEntry(contact);
 
             if (useFakeChannel) {
                 fakeChannel = new XmppFakeChannel(this, "&contacts");
-                getCallback(ChannelSelfJoinListener.class).
-                        onChannelSelfJoin(null, null, fakeChannel);
+                getCallbackManager().publish(new ChannelSelfJoinEvent(null, null, fakeChannel));
                 fakeChannel.updateContacts(contacts.values());
 
                 contacts.values().stream().filter(XmppClientInfo::isAway).forEach(client ->
-                        getCallback(OtherAwayStateListener.class).onAwayStateOther(this, new Date(),
-                                client, AwayState.UNKNOWN, AwayState.AWAY));
+                        getCallbackManager().publish(
+                                new OtherAwayStateEvent(this, new Date(), client, AwayState.UNKNOWN,
+                                        AwayState.AWAY)));
             }
         } catch (XMPPException ex) {
             LOG.debug("Go an XMPP exception", ex);
                 error.setException(ex);
             }
 
-            getCallback(ConnectErrorListener.class).onConnectError(this, new Date(), error);
+            getCallbackManager().publish(new ConnectErrorEvent(this, new Date(), error));
         }
     }
 
         LOG.debug("Handling away state change for {} to {}", client.getNickname(), isBack);
 
         if (useFakeChannel) {
-            getCallback(OtherAwayStateListener.class)
-                    .onAwayStateOther(null, null, client,
-                            isBack ? AwayState.AWAY : AwayState.HERE,
-                            isBack ? AwayState.HERE : AwayState.AWAY);
+            getCallbackManager().publish(new OtherAwayStateEvent(
+                    this, new Date(), client, isBack ? AwayState.AWAY : AwayState.HERE,
+                    isBack ? AwayState.HERE : AwayState.AWAY));
         }
     }
 
         connection.sendPacket(new Presence(Presence.Type.available, reason,
                 priority, Presence.Mode.away));
 
-        getCallback(AwayStateListener.class).onAwayState(this, new Date(),
-                AwayState.HERE, AwayState.AWAY, reason);
+        getCallbackManager().publish(
+                new AwayStateEvent(this, new Date(), AwayState.HERE, AwayState.AWAY, reason));
     }
 
     /**
         connection.sendPacket(new Presence(Presence.Type.available, null,
                 priority, Presence.Mode.available));
 
-        getCallback(AwayStateListener.class).onAwayState(this, new Date(),
-                AwayState.AWAY, AwayState.HERE, null);
+        getCallbackManager().publish(
+                new AwayStateEvent(this, new Date(), AwayState.AWAY, AwayState.HERE, null));
     }
 
     @Override
 
         @Override
         public void connectionClosed() {
-            getCallback(SocketCloseListener.class).onSocketClosed(XmppParser.this, new Date());
+            getCallbackManager().publish(new SocketCloseEvent(XmppParser.this, new Date()));
         }
 
         @Override
         public void connectionClosedOnError(final Exception excptn) {
             // TODO: Handle exception
-            getCallback(SocketCloseListener.class).onSocketClosed(XmppParser.this, new Date());
+            getCallbackManager().publish(new SocketCloseEvent(XmppParser.this, new Date()));
         }
 
         @Override
         @Override
         public void processMessage(final Chat chat, final Message msg) {
             if (msg.getType() == Message.Type.error) {
-                getCallback(NumericListener.class).onNumeric(XmppParser.this, new Date(),
-                        404, new String[]{
-                            ":xmpp", "404", getLocalClient().getNickname(),
-                            msg.getFrom(),
-                            "Cannot send message: " + msg.getError().toString()
-                        });
+                getCallbackManager().publish(new NumericEvent(XmppParser.this, new Date(), 404,
+                        new String[]{":xmpp", "404", getLocalClient().getNickname(), msg.getFrom(),
+                                "Cannot send message: " + msg.getError().toString()}));
                 return;
             }
 
             if (msg.getBody() != null) {
                 if (msg.getBody().startsWith("/me ")) {
-                    getCallback(PrivateActionListener.class).onPrivateAction(XmppParser.this,
-                            new Date(), msg.getBody().substring(4), msg.getFrom());
+                    getCallbackManager().publish(new PrivateActionEvent(XmppParser.this, new Date(),
+                            msg.getBody().substring(4), msg.getFrom()));
                 } else {
-                    getCallback(PrivateMessageListener.class).onPrivateMessage(XmppParser.this,
-                            new Date(), msg.getBody(), msg.getFrom());
+                    getCallbackManager().publish(
+                            new PrivateMessageEvent(XmppParser.this, new Date(), msg.getBody(),
+                                    msg.getFrom()));
                 }
             }
         }
                     break;
             }
 
-            getCallback(CompositionStateChangeListener.class)
-                    .onCompositionStateChanged(XmppParser.this, new Date(), state,
-                            chat.getParticipant());
+            getCallbackManager().publish(
+                    new CompositionStateChangeEvent(XmppParser.this, new Date(), state,
+                            chat.getParticipant()));
         }
 
     }
         @Override
         public void processPacket(final Packet packet) {
             if (callback.equals(DataOutListener.class)) {
-                getCallback(DataOutListener.class).onDataOut(XmppParser.this, new Date(),
-                        packet.toXML(), true);
+                getCallbackManager().publish(
+                        new DataOutEvent(XmppParser.this, new Date(), packet.toXML()));
             } else {
-                getCallback(DataInListener.class).onDataIn(XmppParser.this, new Date(),
-                        packet.toXML());
+                getCallbackManager().publish(
+                        new DataInEvent(XmppParser.this, new Date(), packet.toXML()));
             }
         }