Refactored parser.

Now has separate classes for different types of incomming message


git-svn-id: http://svn.dmdirc.com/trunk@480 00569f92-eb28-0410-84fd-f71c24880f

src/uk/org/ownage/dmdirc/parser/IRCProcessor.java

@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: IRCProcessor.java 273 2007-03-03 02:09:17Z greboid $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackManager;
+
+import java.util.Hashtable;
+import java.util.ArrayList;
+
+/**
+ * IRCProcessor.
+ * Superclass for all IRCProcessor types.
+ *
+ * @author            Shane Mc Cormack
+ * @version           $Id: IRCProcessor.java 273 2007-03-03 02:09:17Z greboid $
+ */
+public abstract class IRCProcessor {
+	/** Reference to the IRCParser that owns this IRCProcessor. */
+	protected IRCParser myParser = null;
+	
+	/** Reference to the Processing in charge of this IRCProcessor. */
+	protected ProcessingManager myManager = null;
+
+	// Some functions from the main parser are useful, and having to use myParser.functionName
+	// is annoying, so we also implement them here (calling them again using myParser)
+
+	/**
+	 * Callback to all objects implementing the IErrorInfo Interface.
+	 *
+	 * @see IErrorInfo
+	 * @param errorInfo ParserError object representing the error.
+	 */
+	protected final boolean callErrorInfo(ParserError errorInfo) {
+		return myParser.callErrorInfo(errorInfo);
+	}
+	
+	/**
+	 * Callback to all objects implementing the DebugInfo Callback.
+	 *
+	 * @see IDebugInfo
+	 * @param level Debugging Level (ndInfo, ndSocket etc)
+	 * @param data Debugging Information
+	 * @param args Formatting String Options
+	 */
+	protected boolean callDebugInfo(int level, String data, Object... args) {
+		return myParser.callDebugInfo(level, String.format(data, args));
+	}
+	
+	/**
+	 * Callback to all objects implementing the DebugInfo Callback.
+	 *
+	 * @see IDebugInfo
+	 * @param level Debugging Level (ndInfo, ndSocket etc)
+	 * @param data Debugging Information
+	 */
+	protected boolean callDebugInfo(int level, String data) {
+		return myParser.callDebugInfo(level, data);
+	}
+	
+	/**
+	 * Check if a channel name is valid .
+	 *
+	 * @param sChannelName Channel name to test
+	 */
+	protected boolean isValidChannelName(String sChannelName) {
+		return myParser.isValidChannelName(sChannelName);
+	}
+	
+	/**
+	 * Get the ClientInfo object for a person.
+	 *
+	 * @param sWho Who can be any valid identifier for a client as long as it contains a nickname (?:)nick(?!ident)(?@host)
+	 * @return ClientInfo Object for the client, or null
+	 */
+	protected ClientInfo getClientInfo(String sWho) {
+		return myParser.getClientInfo(sWho);
+	}
+	
+	/**
+	 * Get the ChannelInfo object for a channel.
+	 *
+	 * @param sWhat This is the name of the channel.
+	 * @return ChannelInfo Object for the channel, or null
+	 */
+	protected ChannelInfo getChannelInfo(String sWhat) {
+		return myParser.getChannelInfo(sWhat);
+	}
+	
+	/**
+	 * Get a reference to the CallbackManager
+	 *
+	 * @return Reference to the CallbackManager
+	 */
+	protected CallbackManager getCallbackManager() {
+		return myParser.getCallbackManager();
+	}
+	
+	/** 
+	 * Send a line to the server and add proper line ending.
+	 *
+	 * @param line Line to send (\r\n termination is added automatically)
+	 */
+	protected void sendString(String line) {
+		myParser.sendString(line);
+	}
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected IRCProcessor (IRCParser parser, ProcessingManager manager) {
+		this.myParser = parser;
+		this.myManager = manager;
+	}
+	
+	/**
+	 * Process a Line.
+	 *
+	 * @param sParam Type of line to process ("005", "PRIVMSG" etc)
+	 * @param token IRCTokenised line to process
+	 */
+	public abstract void process(String sParam, String[] token);
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public abstract String[] handles();
+	
+	/** Get the name for this Processor */
+	public String getName() {
+		Package thisPackage = this.getClass().getPackage();
+		int packageLength = 0;
+		if (thisPackage != null) {
+			packageLength = thisPackage.getName().length()+1;
+		}
+		return this.getClass().getName().substring(packageLength);
+	}
+	
+	/** Get the name for this Processor in lowercase */
+	public final String getLowerName() {
+		return this.getName().toLowerCase();
+	}
+	
+	/** Get the name for this Processor */
+	public final String toString() { return this.getName(); }
+	
+	/**
+	 * Get SVN Version information
+	 *
+	 * @return SVN Version String
+	 */
+	public static String getSvnInfo () { return "$Id: IRCParser.java 478 2007-03-08 05:52:14Z ShaneMcC $"; }	
+}

src/uk/org/ownage/dmdirc/parser/ParserError.java

@@ -39,7 +39,7 @@ public class ParserError {
 	public static final int errWarning = 4;
 	/** Error was an exception from elsewhere. */
 	public static final int errException = 8;
-
+	
 	/** Store the Error level */
 	protected int errorLevel = 0;
 	/** Store the Error Information */

src/uk/org/ownage/dmdirc/parser/Process001.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnServerReady;
+
+/**
+ * Process a 001 message.
+ */
+public class Process001 extends IRCProcessor {
+	/**
+	 * Process a 001 message.
+	 *
+	 * @param type Type of line to process ("001")
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		myParser.Got001 = true;
+		// << :demon1.uk.quakenet.org 001 Java-Test :Welcome to the QuakeNet IRC Network, Java-Test
+		String sNick;
+		myParser.sServerName = token[0].substring(1,token[0].length());
+		sNick = token[2];
+		
+		/* Code below is here incase relying on token[2] breaks somewhere
+		String[] temp = token[token.length-1].split(" ");
+		sConfirmedNickname = temp[temp.length-1];
+		// Some servers give a full host in 001
+		temp = sNick.split("!",2);
+		sNick = temp[0];  /* */
+		
+		myParser.cMyself = getClientInfo(sNick);
+		if (myParser.cMyself == null) {
+			myParser.cMyself = new ClientInfo(myParser, sNick);
+			myParser.hClientList.put(myParser.cMyself.getNickname().toLowerCase(),myParser.cMyself);
+		}
+		
+		callServerReady();
+	}
+	
+	/**
+	 * Callback to all objects implementing the ServerReady Callback.
+	 *
+	 * @see IServerReady
+	 */	
+	protected boolean callServerReady() {
+		CallbackOnServerReady cb = (CallbackOnServerReady)getCallbackManager().getCallbackType("OnServerReady");
+		if (cb != null) { return cb.call(); }
+		return false;
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[1];
+		iHandle[0] = "001";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected Process001 (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/Process004005.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+// import uk.org.ownage.dmdirc.parser.callbacks.;
+
+/**
+ * Process ISUPPORT lines.
+ */
+public class Process004005 extends IRCProcessor {
+	/**
+	 * Process ISUPPORT lines.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		if (sParam.equals("004")) {
+			// 004
+			myParser.h005Info.put("USERMODES",token[5]);
+		} else {
+			// 005
+			String[] Bits = null;
+			String sKey = null, sValue = null;
+			for (int i = 3; i < token.length ; i++) {
+				Bits = token[i].split("=",2);
+				sKey = Bits[0].toUpperCase();
+				if (Bits.length == 2) { sValue = Bits[1]; } else { sValue = ""; }
+				callDebugInfo(myParser.ndInfo, "%s => %s",sKey,sValue);
+				myParser.h005Info.put(sKey,sValue);
+			}
+		}
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[2];
+		iHandle[0] = "004";
+		iHandle[1] = "005";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected Process004005 (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/Process464.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+// import uk.org.ownage.dmdirc.parser.callbacks.;
+
+/**
+ * Process a 464 message.
+ */
+public class Process464 extends IRCProcessor {
+	/**
+	 * Process a 464 message.
+	 *
+	 * @param type Type of line to process ("464")
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		ParserError ei = new ParserError(ParserError.errError, "Password Required");
+		callErrorInfo(ei);
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[1];
+		iHandle[0] = "464";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected Process464 (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessAway.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+// import uk.org.ownage.dmdirc.parser.callbacks.;
+
+/**
+ * Process an Away/Back message.
+ */
+public class ProcessAway extends IRCProcessor {
+	/**
+	 * Process an Away/Back message.
+	 *
+	 * @param type Type of line to process ("306", "350")
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		myParser.cMyself.setAwayState(sParam.equals("306"));
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[2];
+		iHandle[0] = "305";
+		iHandle[1] = "306";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessAway (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessJoin.java

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelJoin;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelSelfJoin;
+import java.util.Enumeration;
+
+/**
+ * Process a channel join.
+ */
+public class ProcessJoin extends IRCProcessor {
+	/**
+	 * Process a channel join.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		// :nick!ident@host JOIN (:)#Channel
+		Character cTemp;
+		Byte nTemp;
+		if (token.length < 3) { return; }
+		ClientInfo iClient;
+		ChannelInfo iChannel;
+		ChannelClientInfo iChannelClient;
+		
+		iClient = myParser.getClientInfo(token[0]);
+		iChannel = myParser.getChannelInfo(token[token.length-1]);
+		
+		if (iClient == null) { 
+			iClient = new ClientInfo(myParser, token[0]);
+			myParser.hClientList.put(iClient.getNickname().toLowerCase(),iClient);
+		}
+		// Check to see if we know the host/ident for this client to facilitate dmdirc Formatter
+		if (iClient.getHost().equals("")) { iClient.setUserBits(token[0],false); }
+		if (iChannel == null) { 
+			if (iClient != myParser.cMyself) {
+				callErrorInfo(new ParserError(ParserError.errWarning, "Got join for channel ("+token[token.length-1]+") that I am not on. [User: "+token[0]+"]"));
+			}
+			iChannel = new ChannelInfo(myParser, token[token.length-1]);
+			myParser.hChannelList.put(iChannel.getName().toLowerCase(),iChannel);
+			sendString("MODE "+iChannel.getName());
+			
+			// Find out the lists currently in use
+			for (Enumeration e = myParser.hChanModesOther.keys(); e.hasMoreElements();) {
+				cTemp = (Character)e.nextElement();
+				nTemp = myParser.hChanModesOther.get(cTemp);
+				if (nTemp == myParser.cmList) { sendString("MODE "+iChannel.getName()+" "+cTemp); }
+			}
+			callChannelSelfJoin(iChannel);
+		} else {
+			// This is only done if we are on the channel. Else we wait for names.
+			iChannelClient = iChannel.addClient(iClient);
+			callChannelJoin(iChannel, iChannelClient);
+		}
+	}	
+	
+	/**
+	 * Callback to all objects implementing the ChannelJoin Callback.
+	 *
+	 * @see IChannelJoin
+	 * @param cChannel Channel Object
+	 * @param cChannelClient ChannelClient object for new person
+	 */
+	protected boolean callChannelJoin(ChannelInfo cChannel, ChannelClientInfo cChannelClient) {
+		CallbackOnChannelJoin cb = (CallbackOnChannelJoin)getCallbackManager().getCallbackType("OnChannelJoin");
+		if (cb != null) { return cb.call(cChannel, cChannelClient); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the ChannelSelfJoin Callback.
+	 *
+	 * @see IChannelSelfJoin
+	 * @param cChannel Channel Object
+	 */
+	protected boolean callChannelSelfJoin(ChannelInfo cChannel) {
+		CallbackOnChannelSelfJoin cb = (CallbackOnChannelSelfJoin)getCallbackManager().getCallbackType("OnChannelSelfJoin");
+		if (cb != null) { return cb.call(cChannel); }
+		return false;
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[1];
+		iHandle[0] = "JOIN";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessJoin (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessKick.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelKick;
+
+/**
+ * Process a channel kick.
+ */
+public class ProcessKick extends IRCProcessor {
+	/**
+	 * Process a channel kick.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		ChannelClientInfo iChannelClient;
+		ChannelClientInfo iChannelKicker;
+		ChannelInfo iChannel;
+		ClientInfo iClient;
+		ClientInfo iKicker;
+		String sReason = "";
+		
+		iClient = getClientInfo(token[3]);
+		iKicker = getClientInfo(token[0]);
+		iChannel = getChannelInfo(token[2]);
+		
+		if (iClient == null) { return; }
+		
+		if (myParser.alwaysUpdateClient && iKicker != null) {
+			// To facilitate dmdirc formatter, get user information
+			if (iKicker.getHost().equals("")) { iKicker.setUserBits(token[0],false); }
+		}
+
+		if (iChannel == null) { 
+			if (iClient != myParser.cMyself) {
+				callErrorInfo(new ParserError(ParserError.errWarning, "Got kick for channel ("+token[2]+") that I am not on. [User: "+token[3]+"]"));
+			}
+			return;
+		} else {
+			if (token.length > 4) { sReason = token[token.length-1]; }
+			iChannelClient = iChannel.getUser(iClient);
+			iChannelKicker = iChannel.getUser(token[0]);
+			callChannelKick(iChannel,iChannelClient,iChannelKicker,sReason,token[0]);
+			iChannel.delClient(iClient);
+			if (iClient == myParser.cMyself) {
+				iChannel.emptyChannel();
+				myParser.hChannelList.remove(iChannel.getName().toLowerCase());
+			} else { 
+				// Check if client is still on any channel we are on
+				if (!iClient.checkVisability()) {
+					// if not, remove them from memory incase they quit without us seeing
+					myParser.hClientList.remove(iClient.getNickname().toLowerCase());
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Callback to all objects implementing the ChannelKick Callback.
+	 *
+	 * @see IChannelKick
+	 * @param cChannel Channel where the kick took place
+	 * @param cKickedClient ChannelClient that got kicked
+	 * @param cKickedByClient ChannelClient that did the kicking (may be null if server)
+	 * @param sReason Reason for kick (may be "")
+	 * @param sKickedByHost Hostname of Kicker (or servername)
+	 */
+	protected boolean callChannelKick(ChannelInfo cChannel, ChannelClientInfo cKickedClient, ChannelClientInfo cKickedByClient, String sReason, String sKickedByHost) {
+		CallbackOnChannelKick cb = (CallbackOnChannelKick)getCallbackManager().getCallbackType("OnChannelKick");
+		if (cb != null) { return cb.call(cChannel, cKickedClient, cKickedByClient, sReason, sKickedByHost); }
+		return false;
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[1];
+		iHandle[0] = "KICK";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessKick (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessMOTD.java

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnMOTDEnd;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnMOTDLine;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnMOTDStart;
+
+/**
+ * Process a MOTD Related Line
+ */
+public class ProcessMOTD extends IRCProcessor {
+	/**
+	 * Process a MOTD Related Line.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		if (sParam.equals("375")) {
+			callMOTDStart(token[token.length-1]);
+		} else if (sParam.equals("372")) {
+			callMOTDLine(token[token.length-1]);
+		} else {
+			myParser.parseChanModes();
+			myParser.parseChanPrefix();
+			myParser.parsePrefixModes();
+			myParser.parseUserModes();
+			callMOTDEnd(sParam.equals(422));
+		}
+	}
+	
+	/**
+	 * Callback to all objects implementing the MOTDEnd Callback.
+	 *
+	 * @param noMOTD Was this an MOTDEnd or NoMOTD
+	 * @see IMOTDEnd
+	 */
+	protected boolean callMOTDEnd(boolean noMOTD) {
+		CallbackOnMOTDEnd cb = (CallbackOnMOTDEnd)getCallbackManager().getCallbackType("OnMOTDEnd");
+		if (cb != null) { return cb.call(noMOTD); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the MOTDLine Callback.
+	 *
+	 * @see IMOTDLine
+	 * @param data Incomming Line.
+	 */
+	protected boolean callMOTDLine(String data) {
+		CallbackOnMOTDLine cb = (CallbackOnMOTDLine)getCallbackManager().getCallbackType("OnMOTDLine");
+		if (cb != null) { return cb.call(data); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the MOTDStart
+	 *
+	 * @see IMOTDStart
+	 * @param data Incomming Line.
+	 */
+	protected boolean callMOTDStart(String data) {
+		CallbackOnMOTDStart cb = (CallbackOnMOTDStart)getCallbackManager().getCallbackType("OnMOTDStart");
+		if (cb != null) { return cb.call(data); }
+		return false;
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[4];
+		iHandle[0] = "372";
+		iHandle[1] = "375";
+		iHandle[2] = "376";
+		iHandle[3] = "422";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessMOTD (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessMessage.java

@@ -0,0 +1,419 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelAction;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelCTCP;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelCTCPReply;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelMessage;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelNotice;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnPrivateAction;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnPrivateCTCP;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnPrivateCTCPReply;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnPrivateMessage;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnPrivateNotice;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnUnknownAction;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnUnknownCTCP;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnUnknownCTCPReply;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnUnknownMessage;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnUnknownNotice;
+
+
+/**
+ * Process PRIVMSGs and NOTICEs.
+ * This horrible handles PRIVMSGs and NOTICES<br>
+ * This inclues CTCPs and CTCPReplies<br>
+ * It handles all 3 targets (Channel, Private, Unknown)<br>
+ * Actions are handled here aswell separately from CTCPs.<br>
+ * Each type has 5 Calls, making 15 callbacks handled here.
+ */
+public class ProcessMessage extends IRCProcessor {
+	/**
+	 * Process PRIVMSGs and NOTICEs.
+	 * This horrible thing handles PRIVMSGs and NOTICES<br>
+	 * This inclues CTCPs and CTCPReplies<br>
+	 * It handles all 3 targets (Channel, Private, Unknown)<br>
+	 * Actions are handled here aswell separately from CTCPs.<br>
+	 * Each type has 5 Calls, making 15 callbacks handled here.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		// Ignore people!
+		String bits[] = token[0].split(":",2);
+		String sMessage = "";
+		if (bits.length > 1) { sMessage = bits[1]; } else { sMessage = bits[0]; }
+		// We use sMessage to be the users host (first token in the line)
+		if (myParser.getIgnoreList().matches(sMessage) > -1) { return; }
+		
+		ChannelClientInfo iChannelClient = null;
+		ChannelInfo iChannel = null;
+		ClientInfo iClient = null;
+		sMessage = token[token.length-1];
+		bits = sMessage.split(" ", 2);
+		Character Char1 = Character.valueOf((char)1);
+		String sCTCP = "";
+		boolean isAction = false;
+		boolean isCTCP = false;
+		
+		if (sParam.equalsIgnoreCase("PRIVMSG")) {
+			// Actions are special CTCPs
+			// Bits is the message been split into 2 parts, the first word and the rest
+			if (bits[0].equalsIgnoreCase(Char1+"ACTION") && Character.valueOf(sMessage.charAt(sMessage.length()-1)).equals(Char1)) {
+				isAction = true;
+				if (bits.length > 1) {
+					sMessage = bits[1];
+					sMessage = sMessage.substring(0, sMessage.length()-1);
+				} else { sMessage = ""; }
+			}
+		}
+		// If the message is not an action, check if it is another type of CTCP
+		if (!isAction) {
+			// CTCPs have Character(1) at the start/end of the line
+			if (Character.valueOf(sMessage.charAt(0)).equals(Char1) && Character.valueOf(sMessage.charAt(sMessage.length()-1)).equals(Char1)) {
+				isCTCP = true;
+				// Bits is the message been split into 2 parts, the first word and the rest
+				// Some CTCPs have messages and some do not
+				if (bits.length > 1) { sMessage = bits[1]; } else { sMessage = ""; }
+				// Remove the leading char1
+				bits = bits[0].split(Char1.toString());
+				sCTCP = bits[1];
+				// remove the trailing char1
+				if (sMessage == "") { sMessage = sMessage.split(Char1.toString())[0]; }
+				else { sCTCP = sCTCP.split(Char1.toString())[0]; }
+				callDebugInfo(myParser.ndInfo, "CTCP: \"%s\" \"%s\"",sCTCP,sMessage);
+			}
+		}
+
+		iClient = getClientInfo(token[0]);
+		if (myParser.alwaysUpdateClient && iClient != null) {
+			// Facilitate DMDIRC Formatter
+			if (iClient.getHost().equals("")) {iClient.setUserBits(token[0],false); }
+		}
+		
+		// Fire the appropriate callbacks.
+		// OnChannel* Callbacks are fired if the target was a channel
+		// OnPrivate* Callbacks are fired if the target was us
+		// OnUnknown* Callbacks are fired if the target was neither of the above
+		// Actions and CTCPs are send as PRIVMSGS
+		// CTCPReplies are sent as Notices		
+		if (isValidChannelName(token[2])) {
+			iChannel = getChannelInfo(token[2]);
+			if (iClient != null && iChannel != null) { iChannelClient = iChannel.getUser(iClient); }
+			if (sParam.equalsIgnoreCase("PRIVMSG")) {
+				if (!isAction) {
+					if (isCTCP) {
+						callChannelCTCP(iChannel, iChannelClient, sCTCP, sMessage, token[0]);
+					} else {
+						callChannelMessage(iChannel, iChannelClient, sMessage, token[0]);
+					}
+				} else {
+					callChannelAction(iChannel, iChannelClient, sMessage, token[0]);
+				}
+			} else if (sParam.equalsIgnoreCase("NOTICE")) {
+				if (isCTCP) {
+					callChannelCTCPReply(iChannel, iChannelClient, sCTCP, sMessage, token[0]);
+				} else {
+					callChannelNotice(iChannel, iChannelClient, sMessage, token[0]);
+				}
+			}
+		} else if (token[2].equalsIgnoreCase(myParser.cMyself.getNickname())) {
+			if (sParam.equalsIgnoreCase("PRIVMSG")) {
+				if (!isAction) {
+					if (isCTCP) {
+						callPrivateCTCP(sCTCP, sMessage, token[0]);
+					} else {
+						callPrivateMessage(sMessage, token[0]);
+					}
+				} else {
+					callPrivateAction(sMessage, token[0]);
+				}
+			} else if (sParam.equalsIgnoreCase("NOTICE")) {
+				if (isCTCP) {
+					callPrivateCTCPReply(sCTCP, sMessage, token[0]);
+				} else {
+					callPrivateNotice(sMessage, token[0]);
+				}
+			}
+		} else {
+			callDebugInfo(myParser.ndInfo, "Message for Other ("+token[2]+")");
+			if (sParam.equalsIgnoreCase("PRIVMSG")) {
+				if (!isAction) {
+					if (isCTCP) {
+						callUnknownCTCP(sCTCP, sMessage, token[2], token[0]);
+					} else {
+						callUnknownMessage(sMessage, token[2], token[0]);
+					}
+				} else {
+					callUnknownAction(sMessage, token[2], token[0]);
+				}
+			} else if (sParam.equalsIgnoreCase("NOTICE")) {
+				if (isCTCP) {
+					callUnknownCTCPReply(sCTCP, sMessage, token[2], token[0]);
+				} else {
+					callUnknownNotice(sMessage, token[2], token[0]);
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Callback to all objects implementing the ChannelAction Callback.
+	 *
+	 * @see IChannelAction
+	 * @param cChannel Channel where the action was sent to
+	 * @param cChannelClient ChannelClient who sent the action (may be null if server)
+	 * @param sMessage action contents
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callChannelAction(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sMessage, String sHost) {
+		CallbackOnChannelAction cb = (CallbackOnChannelAction)getCallbackManager().getCallbackType("OnChannelAction");
+		if (cb != null) { return cb.call(cChannel, cChannelClient, sMessage, sHost); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the ChannelCTCP Callback.
+	 *
+	 * @see IChannelCTCP
+	 * @param cChannel Channel where CTCP was sent
+	 * @param cChannelClient ChannelClient who sent the message (may be null if server)
+	 * @param sType Type of CTCP (VERSION, TIME etc)
+	 * @param sMessage Additional contents
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callChannelCTCP(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sType, String sMessage, String sHost) {
+		CallbackOnChannelCTCP cb = (CallbackOnChannelCTCP)getCallbackManager().getCallbackType("OnChannelCTCP");
+		if (cb != null) { return cb.call(cChannel, cChannelClient, sType, sMessage, sHost); }
+		return false;
+	}
+
+	/**
+	 * Callback to all objects implementing the ChannelCTCPReply Callback.
+	 *
+	 * @see IChannelCTCPReply
+	 * @param cChannel Channel where CTCPReply was sent
+	 * @param cChannelClient ChannelClient who sent the message (may be null if server)
+	 * @param sType Type of CTCPRReply (VERSION, TIME etc)
+	 * @param sMessage Reply Contents
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callChannelCTCPReply(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sType, String sMessage, String sHost) {
+		CallbackOnChannelCTCPReply cb = (CallbackOnChannelCTCPReply)getCallbackManager().getCallbackType("OnChannelCTCPReply");
+		if (cb != null) { return cb.call(cChannel, cChannelClient, sType, sMessage, sHost); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the ChannelMessage Callback.
+	 *
+	 * @see IChannelMessage
+	 * @param cChannel Channel where the message was sent to
+	 * @param cChannelClient ChannelClient who sent the message (may be null if server)
+	 * @param sMessage Message contents
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callChannelMessage(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sMessage, String sHost) {
+		CallbackOnChannelMessage cb = (CallbackOnChannelMessage)getCallbackManager().getCallbackType("OnChannelMessage");
+		if (cb != null) { return cb.call(cChannel, cChannelClient, sMessage, sHost); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the ChannelNotice Callback.
+	 *
+	 * @see IChannelNotice
+	 * @param cChannel Channel where the notice was sent to
+	 * @param cChannelClient ChannelClient who sent the notice (may be null if server)
+	 * @param sMessage notice contents
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callChannelNotice(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sMessage, String sHost) {
+		CallbackOnChannelNotice cb = (CallbackOnChannelNotice)getCallbackManager().getCallbackType("OnChannelNotice");
+		if (cb != null) { return cb.call(cChannel, cChannelClient, sMessage, sHost); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the PrivateAction Callback.
+	 *
+	 * @see IPrivateAction
+	 * @param sMessage action contents
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callPrivateAction(String sMessage, String sHost) {
+		CallbackOnPrivateAction cb = (CallbackOnPrivateAction)getCallbackManager().getCallbackType("OnPrivateAction");
+		if (cb != null) { return cb.call(sMessage, sHost); }
+		return false;
+	}
+
+	/**
+	 * Callback to all objects implementing the PrivateCTCP Callback.
+	 *
+	 * @see IPrivateCTCP
+	 * @param sType Type of CTCP (VERSION, TIME etc)
+	 * @param sMessage Additional contents
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callPrivateCTCP(String sType, String sMessage, String sHost) {
+		CallbackOnPrivateCTCP cb = (CallbackOnPrivateCTCP)getCallbackManager().getCallbackType("OnPrivateCTCP");
+		if (cb != null) { return cb.call(sType, sMessage, sHost); }
+		return false;
+	}
+
+	/**
+	 * Callback to all objects implementing the PrivateCTCPReply Callback.
+	 *
+	 * @see IPrivateCTCPReply
+	 * @param sType Type of CTCPRReply (VERSION, TIME etc)
+	 * @param sMessage Reply Contents
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callPrivateCTCPReply(String sType, String sMessage, String sHost) {
+		CallbackOnPrivateCTCPReply cb = (CallbackOnPrivateCTCPReply)getCallbackManager().getCallbackType("OnPrivateCTCPReply");
+		if (cb != null) { return cb.call(sType, sMessage, sHost); }
+		return false;
+	}
+
+	/**
+	 * Callback to all objects implementing the PrivateMessage Callback.
+	 *
+	 * @see IPrivateMessage
+	 * @param sMessage Message contents
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callPrivateMessage(String sMessage, String sHost) {
+		CallbackOnPrivateMessage cb = (CallbackOnPrivateMessage)getCallbackManager().getCallbackType("OnPrivateMessage");
+		if (cb != null) { return cb.call(sMessage, sHost); }
+		return false;
+	}
+
+	/**
+	 * Callback to all objects implementing the PrivateNotice Callback.
+	 *
+	 * @see IPrivateNotice
+	 * @param sMessage Notice contents
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callPrivateNotice(String sMessage, String sHost) {
+		CallbackOnPrivateNotice cb = (CallbackOnPrivateNotice)getCallbackManager().getCallbackType("OnPrivateNotice");
+		if (cb != null) { return cb.call(sMessage, sHost); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the UnknownAction Callback.
+	 *
+	 * @see IUnknownAction
+	 * @param sMessage Action contents
+	 * @param sTarget Actual target of action
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callUnknownAction(String sMessage, String sTarget, String sHost) {
+		CallbackOnUnknownAction cb = (CallbackOnUnknownAction)getCallbackManager().getCallbackType("OnUnknownAction");
+		if (cb != null) { return cb.call(sMessage, sTarget, sHost); }
+		return false;
+	}
+
+	/**
+	 * Callback to all objects implementing the UnknownCTCP Callback.
+	 *
+	 * @see IUnknownCTCP
+	 * @param sType Type of CTCP (VERSION, TIME etc)
+	 * @param sMessage Additional contents
+	 * @param sTarget Actual Target of CTCP
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callUnknownCTCP(String sType, String sMessage, String sTarget, String sHost) {
+		CallbackOnUnknownCTCP cb = (CallbackOnUnknownCTCP)getCallbackManager().getCallbackType("OnUnknownCTCP");
+		if (cb != null) { return cb.call(sType, sMessage, sTarget, sHost); }
+		return false;
+	}
+
+	/**
+	 * Callback to all objects implementing the UnknownCTCPReply Callback.
+	 *
+	 * @see IUnknownCTCPReply
+	 * @param sType Type of CTCPRReply (VERSION, TIME etc)
+	 * @param sMessage Reply Contents
+	 * @param sTarget Actual Target of CTCPReply
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callUnknownCTCPReply(String sType, String sMessage, String sTarget, String sHost) {
+		CallbackOnUnknownCTCPReply cb = (CallbackOnUnknownCTCPReply)getCallbackManager().getCallbackType("OnUnknownCTCPReply");
+		if (cb != null) { return cb.call(sType, sMessage, sTarget, sHost); }
+		return false;
+	}
+
+	/**
+	 * Callback to all objects implementing the UnknownMessage Callback.
+	 *
+	 * @see IUnknownMessage
+	 * @param sMessage Message contents
+	 * @param sTarget Actual target of message
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callUnknownMessage(String sMessage, String sTarget, String sHost) {
+		CallbackOnUnknownMessage cb = (CallbackOnUnknownMessage)getCallbackManager().getCallbackType("OnUnknownMessage");
+		if (cb != null) { return cb.call(sMessage, sTarget, sHost); }
+		return false;
+	}
+
+	/**
+	 * Callback to all objects implementing the UnknownNotice Callback.
+	 *
+	 * @see IUnknownNotice
+	 * @param sMessage Notice contents
+	 * @param sTarget Actual target of notice
+	 * @param sHost Hostname of sender (or servername)
+	 */
+	protected boolean callUnknownNotice(String sMessage, String sTarget, String sHost) {
+		CallbackOnUnknownNotice cb = (CallbackOnUnknownNotice)getCallbackManager().getCallbackType("OnUnknownNotice");
+		if (cb != null) { return cb.call(sMessage, sTarget, sHost); }
+		return false;
+	}
+
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[2];
+		iHandle[0] = "PRIVMSG";
+		iHandle[1] = "NOTICE";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessMessage (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessMode.java

@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelSingleModeChanged;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelNonUserModeChanged;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelModeChanged;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelUserModeChanged;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnUserModeChanged;
+
+/**
+ * Process a Mode line.
+ */
+public class ProcessMode extends IRCProcessor {
+	/**
+	 * Process a Mode Line.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		String[] sModestr;
+		String sChannelName;
+		if (sParam.equals("324")) {
+			sChannelName = token[3];
+			sModestr = new String[token.length-4];
+			System.arraycopy(token, 4, sModestr, 0, token.length-4);
+		} else {
+			sChannelName = token[2];
+			sModestr = new String[token.length-3];
+			System.arraycopy(token, 3, sModestr, 0, token.length-3);
+		}
+
+		if (!isValidChannelName(sChannelName)) { processUserMode(sParam, token, sModestr); }
+		else { processChanMode(sParam, token, sModestr, sChannelName); }
+	}
+	
+	/**
+	 * Method to trim spaces from strings
+	 *
+	 * @param str String to trim
+	 * @return String without spaces on the ends
+	 */
+	private String trim(String str) { return str.trim(); }
+	
+	/**
+	 * Process Chan modes.
+	 *
+	 * @param sParam String representation of parameter to parse
+	 * @param token IRCTokenised Array of the incomming line
+	 */	
+	public void processChanMode(String sParam, String token[], String sModestr[], String sChannelName) {
+		String sFullModeStr;
+		String sNonUserModeStr = "";
+		String sNonUserModeStrParams = "";
+		String sModeParam;
+		String sTemp;
+		int nCurrent = 0, nParam = 1, nValue = 0;
+		boolean bPositive = true, bBooleanMode = true;
+		char cPositive = '+';
+		ChannelInfo iChannel;
+		ChannelClientInfo iChannelClientInfo;
+		ClientInfo iClient;
+		ChannelClientInfo setterCCI;
+		
+		CallbackOnChannelSingleModeChanged cbSingle = null;
+		CallbackOnChannelNonUserModeChanged cbNonUser = null;
+		if (!sParam.equals("324")) {
+			cbSingle = (CallbackOnChannelSingleModeChanged)getCallbackManager().getCallbackType("OnChannelSingleModeChanged");
+			cbNonUser = (CallbackOnChannelNonUserModeChanged)getCallbackManager().getCallbackType("OnChannelNonUserModeChanged");
+		}
+		
+		iChannel = getChannelInfo(sChannelName);
+		if (iChannel == null) { 
+			callErrorInfo(new ParserError(ParserError.errWarning, "Got modes for channel ("+sChannelName+") that I am not on."));
+			iChannel = new ChannelInfo(myParser, sChannelName);
+			myParser.hChannelList.put(iChannel.getName().toLowerCase(),iChannel);
+		}
+		// Get the current channel modes
+		if (!sParam.equals("324")) { nCurrent = iChannel.getMode(); }
+		
+		setterCCI = iChannel.getUser(token[0]);
+		if (myParser.alwaysUpdateClient && setterCCI != null) {
+			// Facilitate dmdirc formatter
+			if (setterCCI.getClient().getHost().equals("")) {setterCCI.getClient().setUserBits(token[0],false); }
+		}
+		
+		// Loop through the mode string, and add/remove modes/params where they are needed
+		for (int i = 0; i < sModestr[0].length(); ++i) {
+			Character cMode = sModestr[0].charAt(i);
+			if (cMode.equals(":".charAt(0))) { continue; }
+			
+			sNonUserModeStr = sNonUserModeStr+cMode;
+			if (cMode.equals("+".charAt(0))) { cPositive = '+'; bPositive = true; }
+			else if (cMode.equals("-".charAt(0))) { cPositive = '-'; bPositive = false; }
+			else {
+				if (myParser.hChanModesBool.containsKey(cMode)) { nValue = myParser.hChanModesBool.get(cMode); bBooleanMode = true; }
+				else if (myParser.hChanModesOther.containsKey(cMode)) { nValue = myParser.hChanModesOther.get(cMode); bBooleanMode = false; }
+				else if (myParser.hPrefixModes.containsKey(cMode)) { 
+					// (de) OP/Voice someone
+					sModeParam = sModestr[nParam++];
+					nValue = myParser.hPrefixModes.get(cMode);
+					callDebugInfo(myParser.ndInfo, "User Mode: %c / %d [%s] {Positive: %b}",cMode, nValue, sModeParam, bPositive);
+					iChannelClientInfo = iChannel.getUser(sModeParam);
+					if (iChannelClientInfo == null) {
+						// Client not known?
+						callErrorInfo(new ParserError(ParserError.errWarning, "Got mode for client not known on channel - Added"));
+						iClient = getClientInfo(sModeParam);
+						if (iClient == null) { 
+							callErrorInfo(new ParserError(ParserError.errWarning, "Got mode for client not known at all - Added"));
+							iClient = new ClientInfo(myParser, sModeParam);
+							myParser.hClientList.put(iClient.getNickname().toLowerCase(),iClient);
+						}
+						iChannelClientInfo = iChannel.addClient(iClient);
+					}
+					callDebugInfo(myParser.ndInfo, "\tOld Mode Value: %d",iChannelClientInfo.getChanMode());
+					if (bPositive) { iChannelClientInfo.setChanMode(iChannelClientInfo.getChanMode() + nValue); sTemp = "+"; }
+					else { iChannelClientInfo.setChanMode(iChannelClientInfo.getChanMode() - nValue); sTemp = "-"; }
+					sTemp = sTemp+cMode+" "+iChannelClientInfo.getNickname();
+					
+					callChannelUserModeChanged(iChannel, iChannelClientInfo, setterCCI, token[0], sTemp);
+					continue;
+				} else {
+					// unknown mode - add as boolean
+					callErrorInfo(new ParserError(ParserError.errWarning, "Got unknown mode "+cMode+" - Added as boolean mode"));
+					myParser.hChanModesBool.put(cMode,myParser.nNextKeyCMBool);
+					nValue = myParser.nNextKeyCMBool;
+					bBooleanMode = true;
+					myParser.nNextKeyCMBool = myParser.nNextKeyCMBool*2;
+				}
+				
+				if (bBooleanMode) {
+					callDebugInfo(myParser.ndInfo, "Boolean Mode: %c [%d] {Positive: %b}",cMode, nValue, bPositive);
+					if (bPositive) { nCurrent = nCurrent + nValue; }
+					else { nCurrent = nCurrent - nValue; }
+				} else {
+					if (nValue == myParser.cmList) {
+						// List Mode
+						sModeParam = sModestr[nParam++];
+						sNonUserModeStrParams = sNonUserModeStrParams+" "+sModeParam;
+						iChannel.setListModeParam(cMode, sModeParam, bPositive);
+						callDebugInfo(myParser.ndInfo, "List Mode: %c [%s] {Positive: %b}",cMode, sModeParam, bPositive);
+						if (cbSingle != null) { cbSingle.call(iChannel, setterCCI, token[0], cPositive+cMode+" "+sModeParam ); }
+					} else {
+						// Mode with a parameter
+						if (bPositive) { 
+							// +Mode - always needs a parameter to set
+							sModeParam = sModestr[nParam++];
+							sNonUserModeStrParams = sNonUserModeStrParams+" "+sModeParam;
+							callDebugInfo(myParser.ndInfo, "Set Mode: %c [%s] {Positive: %b}",cMode, sModeParam, bPositive);
+							iChannel.setModeParam(cMode,sModeParam);
+							if (cbSingle != null) { cbSingle.call(iChannel, setterCCI, token[0], cPositive+cMode+" "+sModeParam ); }
+						} else {
+							// -Mode - parameter isn't always needed, we need to check
+							if ((nValue & myParser.cmUnset) == myParser.cmUnset) {
+								sModeParam = sModestr[nParam++];
+								sNonUserModeStrParams = sNonUserModeStrParams+" "+sModeParam;
+							} else {
+								sModeParam = "";
+							}
+							callDebugInfo(myParser.ndInfo, "Unset Mode: %c [%s] {Positive: %b}",cMode, sModeParam, bPositive);
+							iChannel.setModeParam(cMode,"");
+							if (cbSingle != null) { cbSingle.call(iChannel, setterCCI, token[0], trim(cPositive+cMode+" "+sModeParam) ); }
+						}
+					}
+				}
+			}
+		}
+		
+		// Call Callbacks
+		sFullModeStr = "";
+		for (int i = 0; i < sModestr.length; ++i) { sFullModeStr = sFullModeStr+sModestr[i]+" "; }
+		
+		iChannel.setMode(nCurrent);
+		if (sParam.equals("324")) { callChannelModeChanged(iChannel, null, "", trim(sFullModeStr)); }
+		else { callChannelModeChanged(iChannel, setterCCI, token[0], trim(sFullModeStr)); }
+		if (cbNonUser != null) { cbNonUser.call(iChannel, setterCCI, token[0], trim(sNonUserModeStr+sNonUserModeStrParams)); }
+	}
+	
+	/**
+	 * Process user modes.
+	 *
+	 * @param sParam String representation of parameter to parse
+	 * @param token IRCTokenised Array of the incomming line
+	 */	
+	private void processUserMode(String sParam, String token[], String sModestr[]) {
+		int nCurrent = 0, nValue = 0;
+		boolean bPositive = true;
+		
+		ClientInfo iClient;
+		
+		iClient = getClientInfo(token[2]);
+		if (iClient == null) { return; }
+		
+		nCurrent = iClient.getUserMode();
+		
+		for (int i = 0; i < sModestr[0].length(); ++i) {
+			Character cMode = sModestr[0].charAt(i);
+			if (cMode.equals("+".charAt(0))) { bPositive = true; }
+			else if (cMode.equals("-".charAt(0))) { bPositive = false; }
+			else if (cMode.equals(":".charAt(0))) { continue; }
+			else {
+				if (myParser.hUserModes.containsKey(cMode)) { nValue = myParser.hUserModes.get(cMode); }
+				else {
+					// Unknown mode
+					callErrorInfo(new ParserError(ParserError.errWarning, "Got unknown user mode "+cMode+" - Added"));
+					myParser.hUserModes.put(cMode,myParser.nNextKeyUser);
+					nValue = myParser.nNextKeyUser;
+					myParser.nNextKeyUser = myParser.nNextKeyUser*2;
+				}
+				// Usermodes are always boolean
+				callDebugInfo(myParser.ndInfo, "User Mode: %c [%d] {Positive: %b}",cMode, nValue, bPositive);
+				if (bPositive) { nCurrent = nCurrent + nValue; }
+				else { nCurrent = nCurrent - nValue; }
+			}
+		}
+		
+		iClient.setUserMode(nCurrent);
+		callUserModeChanged(iClient, token[0]);
+	}	
+	
+	/**
+	 * Callback to all objects implementing the ChannelModeChanged Callback.
+	 *
+	 * @see IChannelModeChanged
+	 * @param cChannel Channel where modes were changed
+	 * @param cChannelClient Client chaning the modes (null if server)
+	 * @param sHost Host doing the mode changing (User host or server name)
+	 * @param sModes Exact String parsed
+	 */
+	protected boolean callChannelModeChanged(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sHost, String sModes) {
+		CallbackOnChannelModeChanged cb = (CallbackOnChannelModeChanged)getCallbackManager().getCallbackType("OnChannelModeChanged");
+		if (cb != null) { return cb.call(cChannel, cChannelClient, sHost, sModes); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the ChannelUserModeChanged Callback.
+	 *
+	 * @see IChannelUserModeChanged
+	 * @param cChannel Channel where modes were changed
+	 * @param cChangedClient Client being changed
+	 * @param cSetByClient Client chaning the modes (null if server)
+	 * @param sMode String representing mode change (ie +o)
+	 * @param sHost Host doing the mode changing (User host or server name)
+	 */
+	protected boolean callChannelUserModeChanged(ChannelInfo cChannel, ChannelClientInfo cChangedClient, ChannelClientInfo cSetByClient, String sHost, String sMode) {
+		CallbackOnChannelUserModeChanged cb = (CallbackOnChannelUserModeChanged)getCallbackManager().getCallbackType("OnChannelUserModeChanged");
+		if (cb != null) { return cb.call(cChannel, cChangedClient, cSetByClient, sHost, sMode); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the UserModeChanged Callback.
+	 *
+	 * @see IUserModeChanged
+	 * @param cClient Client that had the mode changed (almost always us)
+	 * @param sSetby Host that set the mode (us or servername)
+	 */
+	protected boolean callUserModeChanged(ClientInfo cClient, String sSetby) {
+		CallbackOnUserModeChanged cb = (CallbackOnUserModeChanged)getCallbackManager().getCallbackType("OnUserModeChanged");
+		if (cb != null) { return cb.call(cClient, sSetby); }
+		return false;
+	}	
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[2];
+		iHandle[0] = "MODE";
+		iHandle[1] = "324";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessMode (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessNames.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelGotNames;
+
+/**
+ * Process a Names reply.
+ */
+public class ProcessNames extends IRCProcessor {
+	/**
+	 * Process a Names reply.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		ChannelInfo iChannel;
+		if (sParam.equals("366")) {
+			// End of names
+			iChannel = getChannelInfo(token[3]);
+			if (iChannel != null) {
+				iChannel.bAddingNames = false;
+				callChannelGotNames(iChannel);
+			}
+		} else {
+			// Names
+			
+			ClientInfo iClient;
+			ChannelClientInfo iChannelClient;
+			
+			iChannel = getChannelInfo(token[4]);
+		
+			if (iChannel == null) { 
+				callErrorInfo(new ParserError(ParserError.errWarning, "Got names for channel ("+token[4]+") that I am not on."));
+				iChannel = new ChannelInfo(myParser, token[4]);
+				myParser.hChannelList.put(iChannel.getName().toLowerCase(),iChannel);
+			}
+			
+			// If we are not expecting names, clear the current known names - this is fresh stuff!
+			if (!iChannel.bAddingNames) { iChannel.emptyChannel(); }
+			iChannel.bAddingNames = true;
+			
+			String[] sNames = token[token.length-1].split(" ");
+			String sNameBit = "", sModes = "", sName = "";
+			int nPrefix = 0;
+			for (int j = 0; j < sNames.length; ++j) {
+				sNameBit = sNames[j];
+				for (int i = 0; i < sNameBit.length(); ++i) {
+					Character cMode = sNameBit.charAt(i);
+					if (myParser.hPrefixMap.containsKey(cMode)) {
+						// hPrefixMap contains @, o, +, v this caused issue 107
+						// hPrefixModes only contains o, v so if the mode is in hPrefixMap
+						// and not in hPrefixModes, its ok to use.
+						if (!myParser.hPrefixModes.containsKey(cMode)) {
+							sModes = sModes+cMode;
+							nPrefix = nPrefix + myParser.hPrefixModes.get(myParser.hPrefixMap.get(cMode));
+						}
+					} else {
+						sName = sNameBit.substring(i);
+						break;
+					}
+				}
+				callDebugInfo(myParser.ndInfo, "Name: %s Modes: \"%s\" [%d]",sName,sModes,nPrefix);
+				
+				iClient = getClientInfo(sName);
+				if (iClient == null) { iClient = new ClientInfo(myParser, sName); myParser.hClientList.put(iClient.getNickname().toLowerCase(),iClient); }
+				iChannelClient = iChannel.addClient(iClient);
+				iChannelClient.setChanMode(nPrefix);
+
+				sName = "";
+				sModes = "";
+				nPrefix = 0;
+			}
+		}
+	}
+	
+	/**
+	 * Callback to all objects implementing the ChannelGotNames Callback.
+	 *
+	 * @see IChannelGotNames
+	 * @param cChannel Channel which the names reply is for
+	 */
+	protected boolean callChannelGotNames(ChannelInfo cChannel) {
+		CallbackOnChannelGotNames cb = (CallbackOnChannelGotNames)getCallbackManager().getCallbackType("OnChannelGotNames");
+		if (cb != null) { return cb.call(cChannel); }
+		return false;
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[2];
+		iHandle[0] = "353";
+		iHandle[1] = "366";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessNames (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessNick.java

@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelNickChanged;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnNickChanged;
+import java.util.Enumeration;
+
+/**
+ * Process a Nick change.
+ */
+public class ProcessNick extends IRCProcessor {
+	/**
+	 * Process a Nick change.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		ClientInfo iClient;
+		ChannelClientInfo iChannelClient;
+		ChannelInfo iChannel;
+		
+		iClient = getClientInfo(token[0]);
+		if (iClient != null) {
+			// Remove the client from the known clients list
+			myParser.hClientList.remove(iClient.getNickname().toLowerCase());
+			// Change the nickame
+			iClient.setUserBits(token[2],true);
+			// Readd the client
+			myParser.hClientList.put(iClient.getNickname().toLowerCase(),iClient);
+			
+			for (Enumeration e = myParser.hChannelList.keys(); e.hasMoreElements();) {
+				iChannel = myParser.hChannelList.get(e.nextElement());
+				iChannelClient = iChannel.getUser(iClient);
+				if (iChannelClient != null) {
+					callChannelNickChanged(iChannel,iChannelClient,ClientInfo.parseHost(token[0]));
+				}
+			}
+			
+			callNickChanged(iClient, ClientInfo.parseHost(token[0]));
+		}
+		
+	}
+	
+	/**
+	 * Callback to all objects implementing the ChannelNickChanged Callback.
+	 *
+	 * @see IChannelNickChanged
+	 * @param cChannel One of the channels that the user is on
+	 * @param cChannelClient Client changing nickname
+	 * @param sOldNick Nickname before change
+	 */
+	protected boolean callChannelNickChanged(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sOldNick) {
+		CallbackOnChannelNickChanged cb = (CallbackOnChannelNickChanged)getCallbackManager().getCallbackType("OnChannelNickChanged");
+		if (cb != null) { return cb.call(cChannel, cChannelClient, sOldNick); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the NickChanged Callback.
+	 *
+	 * @see INickChanged
+	 * @param cClient Client changing nickname
+	 * @param sOldNick Nickname before change
+	 */
+	protected boolean callNickChanged(ClientInfo cClient, String sOldNick) {
+		CallbackOnNickChanged cb = (CallbackOnNickChanged)getCallbackManager().getCallbackType("OnNickChanged");
+		if (cb != null) { return cb.call(cClient, sOldNick); }
+		return false;
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[1];
+		iHandle[0] = "NICK";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessNick (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessNickInUse.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnNickInUse;
+
+/**
+ * Process a NickInUse message.
+ * Parser implements handling of this if Pre-001 and no other handler found,
+ * adding the NickInUse handler (addNickInUse) after 001 is prefered over before.<br><br>
+ * <br>
+ * If the first nickname is in use, and a NickInUse message is recieved before 001, we
+ * will attempt to use the altnickname instead.<br>
+ * If this also fails, we will start prepending _ (or the value of me.cPrepend) to the main nickname.
+ */
+public class ProcessNickInUse extends IRCProcessor {
+	/**
+	 * Process a NickInUse message.
+	 * Parser implements handling of this if Pre-001 and no other handler found,
+	 * adding the NickInUse handler (addNickInUse) after 001 is prefered over before.<br><br>
+	 * <br>
+	 * If the first nickname is in use, and a NickInUse message is recieved before 001, we
+	 * will attempt to use the altnickname instead.<br>
+	 * If this also fails, we will start prepending _ (or the value of me.cPrepend) to the main nickname.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		if (!callNickInUse()) {
+			// Manually handle nick in use.
+			callDebugInfo(myParser.ndInfo,"No Nick in use Handler.");
+			if (!myParser.Got001) {
+				callDebugInfo(myParser.ndInfo,"Using inbuilt handler");
+				// If this is before 001 we will try and get a nickname, else we will leave the nick as-is
+				if (!myParser.TriedAlt) { myParser.setNickname(myParser.me.sAltNickname); myParser.TriedAlt = true; }
+				else {
+					if (myParser.sThinkNickname.equalsIgnoreCase(myParser.me.sAltNickname)) { myParser.sThinkNickname = myParser.me.sNickname; }
+					myParser.setNickname(myParser.me.cPrepend+myParser.sThinkNickname);
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Callback to all objects implementing the NickInUse Callback.
+	 *
+	 * @see INickInUse
+	 */
+	protected boolean callNickInUse() {
+		CallbackOnNickInUse cb = (CallbackOnNickInUse)getCallbackManager().getCallbackType("OnNickInUse");
+		if (cb != null) { return cb.call(); }
+		return false;
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[1];
+		iHandle[0] = "433";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessNickInUse (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessNoticeAuth.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnNoticeAuth;
+
+/**
+ * Process a NoticeAuth message.
+ */
+public class ProcessNoticeAuth extends IRCProcessor {
+	/**
+	 * Process a NoticeAuth message.
+	 *
+	 * @param type Type of line to process ("Notice Auth")
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		callNoticeAuth(token[token.length-1]);
+	}
+	
+	/**
+	 * Callback to all objects implementing the NoticeAuth Callback.
+	 *
+	 * @see INoticeAuth
+	 * @param data Incomming Line.
+	 */
+	protected boolean callNoticeAuth(String data) {
+		CallbackOnNoticeAuth cb = (CallbackOnNoticeAuth)getCallbackManager().getCallbackType("OnNoticeAuth");
+		if (cb != null) { return cb.call(data); }
+		return false;
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[1];
+		iHandle[0] = "Notice Auth";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessNoticeAuth (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessPart.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelPart;
+
+/**
+ * Process a channel part.
+ */
+public class ProcessPart extends IRCProcessor {
+	/**
+	 * Process a channel part.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		// :nick!ident@host PART #Channel
+		// :nick!ident@host PART #Channel :reason
+		if (token.length < 3) { return; }
+		ClientInfo iClient;
+		ChannelInfo iChannel;
+		ChannelClientInfo iChannelClient;
+		
+		iClient = getClientInfo(token[0]);
+		iChannel = getChannelInfo(token[2]);
+		
+		if (iClient == null) { return; }
+		if (myParser.alwaysUpdateClient) {
+			// This may seem pointless - updating before they leave - but the formatter needs it!
+			if (iClient.getHost().equals("")) {iClient.setUserBits(token[0],false); }
+		}
+		if (iChannel == null) { 
+			if (iClient != myParser.cMyself) {
+				callErrorInfo(new ParserError(ParserError.errWarning, "Got part for channel ("+token[2]+") that I am not on. [User: "+token[0]+"]"));
+			}
+			return;
+		} else {
+			String sReason = "";
+			if (token.length > 3) { sReason = token[token.length-1]; }
+			iChannelClient = iChannel.getUser(iClient);
+			if (iChannelClient == null) {
+				callErrorInfo(new ParserError(ParserError.errWarning, "Got part for channel ("+token[2]+") for a non-existant user. [User: "+token[0]+"]"));
+				return;
+			}
+			callChannelPart(iChannel,iChannelClient,sReason);
+			callDebugInfo(myParser.ndInfo, "Removing %s from %s",iClient.getNickname(),iChannel.getName());
+			iChannel.delClient(iClient);
+			if (iClient == myParser.cMyself) {
+				iChannel.emptyChannel();
+				myParser.hChannelList.remove(iChannel.getName().toLowerCase());
+			} else { iClient.checkVisability(); }
+		}
+	}
+	
+	/**
+	 * Callback to all objects implementing the ChannelPart Callback.
+	 *
+	 * @see IChannelPart
+	 * @param cChannel Channel that the user parted
+	 * @param cChannelClient Client that parted
+	 * @param sReason Reason given for parting (May be "")
+	 */
+	protected boolean callChannelPart(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sReason) {
+		CallbackOnChannelPart cb = (CallbackOnChannelPart)getCallbackManager().getCallbackType("OnChannelPart");
+		if (cb != null) { return cb.call(cChannel, cChannelClient, sReason); }
+		return false;
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[1];
+		iHandle[0] = "PART";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessPart (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessQuit.java

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelQuit;
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnQuit;
+import java.util.Enumeration;
+
+/**
+ * Process a Quit message.
+ */
+public class ProcessQuit extends IRCProcessor {
+	/**
+	 * Process a Quit message.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		// :nick!ident@host QUIT
+		// :nick!ident@host QUIT :reason
+		if (token.length < 2) { return; }
+		ClientInfo iClient;
+		ChannelInfo iChannel;
+		ChannelClientInfo iChannelClient;
+		
+		iClient = getClientInfo(token[0]);
+		
+		if (iClient == null) { return; }
+		if (myParser.alwaysUpdateClient) {
+			// This may seem pointless - updating before they leave - but the formatter needs it!
+			if (iClient.getHost().equals("")) {iClient.setUserBits(token[0],false); }
+		}
+		String sReason = "";
+		if (token.length > 2) { sReason = token[token.length-1]; }
+		
+		for (Enumeration e = myParser.hChannelList.keys(); e.hasMoreElements();) {
+			iChannel = myParser.hChannelList.get(e.nextElement());
+			iChannelClient = iChannel.getUser(iClient);
+			if (iChannelClient != null) {
+				callChannelQuit(iChannel,iChannelClient,sReason);
+				if (iClient == myParser.cMyself) {
+					iChannel.emptyChannel();
+					myParser.hChannelList.remove(iChannel.getName().toLowerCase());
+				} else {
+					iChannel.delClient(iClient);
+				}
+			}
+		}
+
+		callQuit(iClient,sReason);
+		if (iClient == myParser.cMyself) {
+			myParser.hClientList.clear();
+		} else {
+			myParser.hClientList.remove(iClient.getNickname().toLowerCase());
+		}
+	}	
+	
+	/**
+	 * Callback to all objects implementing the ChannelQuit Callback.
+	 *
+	 * @see IChannelQuit
+	 * @param cChannel Channel that user was on
+	 * @param cChannelClient User thats quitting
+	 * @param sReason Quit reason
+	 */
+	protected boolean callChannelQuit(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sReason) {
+		CallbackOnChannelQuit cb = (CallbackOnChannelQuit)getCallbackManager().getCallbackType("OnChannelQuit");
+		if (cb != null) { return cb.call(cChannel, cChannelClient, sReason); }
+		return false;
+	}
+	
+	/**
+	 * Callback to all objects implementing the Quit Callback.
+	 *
+	 * @see IQuit
+	 * @param cClient Client Quitting
+	 * @param sReason Reason for quitting (may be "")
+	 */
+	protected boolean callQuit(ClientInfo cClient, String sReason) {
+		CallbackOnQuit cb = (CallbackOnQuit)getCallbackManager().getCallbackType("OnQuit");
+		if (cb != null) { return cb.call(cClient, sReason); }
+		return false;
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[1];
+		iHandle[0] = "QUIT";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessQuit (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessTopic.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackOnChannelNotice.java 257 2007-03-02 23:08:30Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+import uk.org.ownage.dmdirc.parser.callbacks.CallbackOnChannelTopic;
+
+import java.util.Calendar;
+
+/**
+ * Process a topic change.
+ */
+public class ProcessTopic extends IRCProcessor {
+	/**
+	 * Process a topic change.
+	 *
+	 * @param type Type of line to process ("005", "PRIVMSG" etc)
+	 * @param tokens IRCTokenised line to process
+	 */
+	public void process(String sParam, String[] token) {
+		ChannelInfo iChannel;
+		if (sParam.equals("332")) {
+			iChannel = getChannelInfo(token[3]);
+			if (iChannel == null) { return; };
+			iChannel.setTopic(token[token.length-1]);
+		} else if (sParam.equals("333")) {
+			iChannel = getChannelInfo(token[3]);
+			if (iChannel == null) { return; };
+			iChannel.setTopicTime(Long.parseLong(token[5]));
+			iChannel.setTopicUser(token[4]);
+			callChannelTopic(iChannel,true);
+		} else {
+			if (myParser.alwaysUpdateClient) {
+				ClientInfo iClient = getClientInfo(token[0]);
+				if (iClient != null) {
+					if (iClient.getHost().equals("")) {iClient.setUserBits(token[0],false); }
+				}
+			}
+			iChannel = getChannelInfo(token[2]);
+			if (iChannel == null) { return; };
+			iChannel.setTopicTime(Calendar.getInstance().getTimeInMillis() / 1000);
+			String sTemp[] = token[0].split(":",2);
+			if (sTemp.length > 1) { token[0] = sTemp[1]; }
+			iChannel.setTopicUser(token[0]);
+			iChannel.setTopic(token[token.length-1]);
+			callChannelTopic(iChannel,false);
+		}
+	}
+	
+	/**
+	 * Callback to all objects implementing the ChannelTopic Callback.
+	 *
+	 * @see IChannelTopic
+	 * @param cChannel Channel that topic was set on
+	 * @param bIsJoinTopic True when getting topic on join, false if set by user/server
+	 */
+	protected boolean callChannelTopic(ChannelInfo cChannel, boolean bIsJoinTopic) {
+		CallbackOnChannelTopic cb = (CallbackOnChannelTopic)getCallbackManager().getCallbackType("OnChannelTopic");
+		if (cb != null) { return cb.call(cChannel, bIsJoinTopic); }
+		return false;
+	}
+	
+	/**
+	 * What does this IRCProcessor handle.
+	 *
+	 * @return String[] with the names of the tokens we handle.
+	 */
+	public String[] handles() {
+		String[] iHandle = new String[3];
+		iHandle[0] = "TOPIC";
+		iHandle[1] = "332";
+		iHandle[2] = "333";
+		return iHandle;
+	} 
+	
+	/**
+	 * Create a new instance of the IRCProcessor Object
+	 *
+	 * @param parser IRCParser That owns this IRCProcessor
+	 * @param manager ProcessingManager that is in charge of this IRCProcessor
+	 */
+	protected ProcessTopic (IRCParser parser, ProcessingManager manager) { super(parser, manager); }
+}

src/uk/org/ownage/dmdirc/parser/ProcessingManager.java

@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: ProcessingManager.java 446 2007-03-06 16:46:38Z ShaneMcC $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+import java.util.Hashtable;
+import java.util.Enumeration;
+
+/**
+ * IRC Parser Processing Manager.
+ * Manages adding/removing/calling processing stuff.
+ *
+ * @author            Shane Mc Cormack
+ * @version           $Id: ProcessingManager.java 446 2007-03-06 16:46:38Z ShaneMcC $
+ */
+public class ProcessingManager {
+	/** Reference to the parser object that owns this ProcessingManager */
+	IRCParser myParser = null;
+	
+	/** Hashtable used to store the different types of IRCProcessor known. */
+	private Hashtable<String,IRCProcessor> processHash = new Hashtable<String,IRCProcessor>();
+
+	/**
+	 * Constructor to create a ProcessingManager
+	 *
+	 * @param parser IRCParser that owns this Processing Manager
+	 */
+	public ProcessingManager(IRCParser parser) {
+		myParser = parser;
+	}
+	
+	/**
+	 * Debugging Data to the console.
+	 */
+	private void DoDebug(String line, Object... args) {
+		myParser.callDebugInfo(myParser.ndProcessor, line, args);
+	}
+	
+	/**
+	 * Initialise the ProcessingManager with the default processors
+	 */
+	public void init() {
+		//------------------------------------------------
+		// Add processors
+		//------------------------------------------------
+		// NOTICE AUTH
+		addProcessor(new ProcessNoticeAuth(myParser, this));
+		// 001
+		addProcessor(new Process001(myParser, this));
+		// 004
+		// 005
+		addProcessor(new Process004005(myParser, this));
+		// 464
+		addProcessor(new Process464(myParser, this));
+		// 305
+		// 306
+		addProcessor(new ProcessAway(myParser, this));
+		// JOIN
+		addProcessor(new ProcessJoin(myParser, this));
+		// KICK
+		addProcessor(new ProcessKick(myParser, this));
+		// PRIVMSG
+		// NOTICE
+		addProcessor(new ProcessMessage(myParser, this));
+		// MODE
+		// 324
+		addProcessor(new ProcessMode(myParser, this));
+		// 372
+		// 375
+		// 376
+		// 422
+		addProcessor(new ProcessMOTD(myParser, this));
+		// 353
+		// 366
+		addProcessor(new ProcessNames(myParser, this));
+		// 433
+		addProcessor(new ProcessNickInUse(myParser, this));
+		// NICK
+		addProcessor(new ProcessNick(myParser, this));
+		// PART
+		addProcessor(new ProcessPart(myParser, this));
+		// QUIT
+		addProcessor(new ProcessQuit(myParser, this));
+		// TOPIC
+		// 332
+		// 333
+		addProcessor(new ProcessTopic(myParser, this));
+	}
+	
+	/**
+	 * Remove all processors
+	 */
+	public void empty() {
+		processHash.clear();
+	}
+	
+	/** Empty clone method to prevent cloning to get more copies of the ProcessingManager */
+	public Object clone() throws CloneNotSupportedException {
+		throw new CloneNotSupportedException();
+	}
+
+	/**
+	 * Add new Process type.
+	 *
+	 * @param processor IRCProcessor subclass for the processor.
+	 */
+	public void addProcessor(IRCProcessor processor) {	
+		// handles() returns a String array of all the tokens
+		// that this processor will parse.
+		DoDebug("Adding processor: "+processor.getName());
+		
+		try {
+			String[] handles = processor.handles();
+			for (int i = 0; i < handles.length; ++i) {
+				if (processHash.containsKey(handles[i].toLowerCase())) {
+					// New Processors take priority over old ones
+					processHash.remove(handles[i].toLowerCase());
+				}
+				DoDebug("\t Added handler for: "+handles[i]);
+				processHash.put(handles[i].toLowerCase(), processor);
+			}
+		} catch (Exception e) {
+			DoDebug("\t[ERROR] "+e.getMessage()+" - Removing processor");
+			delProcessor(processor);
+		}
+	}
+		
+	/**
+	 * Remove a Process type.
+	 *
+	 * @param processor IRCProcessor subclass for the processor.
+	 */
+	public void delProcessor(IRCProcessor processor) {	
+		IRCProcessor testProcessor;
+		String elementName;
+		DoDebug("Deleting processor: "+processor.getName());
+		for (Enumeration e = processHash.keys(); e.hasMoreElements();) {
+			elementName = (String)e.nextElement();
+			DoDebug("\t Checking handler for: "+elementName);
+			testProcessor = processHash.get(elementName);
+			if (testProcessor.getName().equalsIgnoreCase(processor.getName())) {
+				DoDebug("\t Removed handler for: "+elementName);
+				processHash.remove(elementName);
+			}
+		}
+	}
+	
+	/**
+	 * Process a Line.
+	 *
+	 * @param sParam Type of line to process ("005", "PRIVMSG" etc)
+	 * @param token IRCTokenised line to process
+	 * @throws ProcessorNotFound exception if no processors exists to handle the line
+	 */
+	public void process(String sParam, String[] token) throws ProcessorNotFound {
+		IRCProcessor messageProcessor = null;
+		try {
+			if (processHash.containsKey(sParam.toLowerCase())) {
+				messageProcessor = processHash.get(sParam.toLowerCase());
+				messageProcessor.process(sParam, token);
+			} else {
+				throw new ProcessorNotFound("No processors will handle "+sParam);
+			}
+		} catch (Exception e) {
+			String line = "";
+			for (int i = 0; i < token.length; ++i ) { line = line+" "+token[i]; }
+			line = line.trim();
+			ParserError ei = new ParserError(ParserError.errFatal,"Exception in Parser. [Param: "+sParam+"] [Processor: "+messageProcessor+"] [Line: "+line+"]");
+			ei.setException(e);
+			myParser.callErrorInfo(ei);
+		}
+	}
+		
+}

src/uk/org/ownage/dmdirc/parser/ProcessorNotFound.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack
+ *
+ * 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.
+ *
+ * SVN: $Id: CallbackNotFound.java 298 2007-03-03 14:52:33Z chris87 $
+ */
+
+package uk.org.ownage.dmdirc.parser;
+
+/**
+ * IRC Parser Processor Not Found Exception.
+ *
+ * @author            Shane Mc Cormack
+ * @version           $Id: CallbackNotFound.java 298 2007-03-03 14:52:33Z chris87 $
+ */
+public class ProcessorNotFound extends Exception {
+	/**
+	 * A version number for this class. It should be changed whenever the class
+	 * structure is changed (or anything else that would prevent serialized
+	 * objects being unserialized with the new class).
+	 */
+	private static final long serialVersionUID = 1;
+	
+	/**
+	 * Create a new ProcessorNotFound Exception.
+	 *
+	 * @param message Reason for exception
+	 */
+	public ProcessorNotFound(String message) { super(message); }
+}

src/uk/org/ownage/dmdirc/parser/callbacks/CallbackOnErrorInfo.java

@@ -36,7 +36,6 @@ public class CallbackOnErrorInfo extends CallbackObject {
 	 * @param errorInfo ParserError object representing the error.
 	 */
 	public boolean call(ParserError errorInfo) {
-		if (IRCParser.bDebug) { myParser.doDebug("[ERROR] {%d} %s\n", errorInfo.getLevel(), errorInfo.getData()); }
 		boolean bResult = false;
 		for (int i = 0; i < callbackInfo.size(); i++) {
 			try {