Remove deprecated parser methods for converting strings

	- Updated everything to use non-deprecated way
Replace stupid implementations of handles() in callbacks with decent code.
Spaces -> Tabs *runs*

Issue 1274


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

src/com/dmdirc/addons/nickcolours/NickColourPlugin.java

         final Map map = client.getMap();
         final ClientInfo myself = client.getClient().getParser().getMyself();
         final String nickOption1 = "color:"
-                + client.getClient().getParser().toLowerCase(network + ":" + client.getNickname());
+                + client.getClient().getParser().getIRCStringConverter().toLowerCase(network + ":" + client.getNickname());
         final String nickOption2 = "color:"
-                + client.getClient().getParser().toLowerCase("*:" + client.getNickname());
+                + client.getClient().getParser().getIRCStringConverter().toLowerCase("*:" + client.getNickname());
         
         if (IdentityManager.getGlobalConfig().getOptionBool(DOMAIN, "useowncolour", false)
                 && client.getClient().equals(myself)) {

src/com/dmdirc/commandparser/commands/server/Ignore.java

             
         } else if (args[0].toLowerCase().equals("remove") && args.length > 1) {
             
-            final String host = server.getParser().toLowerCase(implodeArgs(1, args));
+            final String host = server.getParser().getIRCStringConverter().toLowerCase(implodeArgs(1, args));
             
             final StringBuffer newlist = new StringBuffer();
             boolean found = false;
                 
                 
                 for (String entry : list.split("\n")) {
-                    if (server.getParser().toLowerCase(entry).equals(host)) {
+                    if (server.getParser().getIRCStringConverter().toLowerCase(entry).equals(host)) {
                         found = true;
                     } else {
                         if (newlist.length() > 0) {

src/com/dmdirc/parser/ChannelClientInfo.java

 	 *
 	 * @return String Value of user (inc prefix) (ie @Nickname)
 	 */
-    @Override
+	@Override
 	public String toString() { 
 		return this.getImportantModePrefix() + this.getNickname();
 	}	
 	 * @param sReason Why are they being kicked? "" for no reason
 	 */
 	public void kick(final String sReason) {
-		myParser.sendString("KICK " + myChannel + " " + this.getNickname()
-                + (sReason.isEmpty() ? sReason : " :" + sReason));
+		myParser.sendString("KICK " + myChannel + " " + this.getNickname() + (sReason.isEmpty() ? sReason : " :" + sReason));
 	}
 	
 	/**

src/com/dmdirc/parser/ChannelInfo.java

 	
 	/** Channel Name. */
 	private final String sName;
-    
+	
 	/** Hashtable containing references to ChannelClients. */
 	private final Map<String, ChannelClientInfo> hChannelUserList = new Hashtable<String, ChannelClientInfo>();
 	/** Hashtable storing values for modes set in the channel that use parameters. */
 	 */
 	public ChannelClientInfo getUser(String sWho) {
 		sWho = ClientInfo.parseHost(sWho);
-		sWho = myParser.toLowerCase(sWho);
+		sWho = myParser.getIRCStringConverter().toLowerCase(sWho);
 		if (hChannelUserList.containsKey(sWho)) {
 			return hChannelUserList.get(sWho);
 		}
 		ChannelClientInfo cTemp = getUser(cClient);
 		if (cTemp == null) { 
 			cTemp = new ChannelClientInfo(myParser, cClient, this);
-			hChannelUserList.put(myParser.toLowerCase(cTemp.getNickname()), cTemp);
+			hChannelUserList.put(myParser.getIRCStringConverter().toLowerCase(cTemp.getNickname()), cTemp);
 		}
 		return cTemp;
 	}
 			if (clTemp != myParser.getMyself() && !clTemp.checkVisibility()) {
 				myParser.removeClient(clTemp);
 			}
-			hChannelUserList.remove(myParser.toLowerCase(cTemp.getNickname()));
+			hChannelUserList.remove(myParser.getIRCStringConverter().toLowerCase(cTemp.getNickname()));
 		}
 	}	
 	
 				hChannelUserList.remove(oldNickname);
 				// Add with the new key. (getNickname will return the new name not the
 				// old one)
-				hChannelUserList.put(myParser.toLowerCase(cTemp.getNickname()), cTemp);
+				hChannelUserList.put(myParser.getIRCStringConverter().toLowerCase(cTemp.getNickname()), cTemp);
 			}
 		}
 	}
 		}
 		final ArrayList<ChannelListModeItem> lModes = hListModes.get(cMode);
 		for (int i = 0; i < lModes.size(); i++) {
-			if (myParser.equalsIgnoreCase(lModes.get(i).getItem(), newItem.getItem())) { 
+			if (myParser.getIRCStringConverter().equalsIgnoreCase(lModes.get(i).getItem(), newItem.getItem())) { 
 				if (bAdd) { return; }
 				else { 
 					lModes.remove(i);
 	 *
 	 * @return String representation of the Channel.
 	 */
-    @Override
+	@Override
 	public String toString() { return sName; }
 	
 	/**

src/com/dmdirc/parser/ChannelListModeItem.java

  */
 public final class ChannelListModeItem {
 
-    /** The Item itself. */
+	/** The Item itself. */
 	private final String myItem;
 	
 	/** The Time the item was created. */
 		myTime = time;
 
 		if (!owner.isEmpty() && owner.charAt(0) == ':') {
-            myOwner = owner.substring(1);
-        } else {
-            myOwner = owner;
-        }
+			myOwner = owner.substring(1);
+		} else {
+			myOwner = owner;
+		}
 	}
 	
 	/**
 	*
 	* @return String representation of this object
 	*/
-    @Override
+	@Override
 	public String toString() {
-			return getItem();
+		return getItem();
 	}
 
 }

src/com/dmdirc/parser/ClientInfo.java

 	 *
 	 * @return String representation of the user.
 	 */
-    @Override
+	@Override
 	public String toString() { return sNickname + "!" + sIdent + "@" + sHost; }
 	
 	/**
 	 * @return Known nickname for user.
 	 */
 	public String getNickname() { return sNickname; }
-    
+	
 	/**
 	 * Get the ident for this user.
 	 *
 	 * @return Known ident for user. (May be "")
 	 */		
 	public String getIdent() { return sIdent; }
-    
+	
 	/**
 	 * Get the hostname for this user.
 	 *
 		bIsAway = bNewState;
 		if (!bIsAway) { myAwayReason = ""; }
 	}
-    
+	
 	/**
 	 * Get the away state of a user.
 	 *
 	 * @return Known away reason for user.
 	 */
 	public String getAwayReason() { return myAwayReason; }
-    
+	
 	/**
 	 * Set the Away Reason for this user.
 	 * Automatically set to "" if awaystate is set to false
 	 * @return Known RealName for user.
 	 */
 	public String getRealName() { return sRealName; }
-    
+	
 	/**
 	 * Set the RealName for this user.
 	 *
 	 * @param nNewMode new long representing channel modes. (Boolean only)
 	 */	
 	protected void setUserMode(final long nNewMode) { nModes = nNewMode; }
-    
+	
 	/**
 	 * Get the user modes (as an integer).
 	 *
 	 * @param cci ChannelClientInfo to add as a known reference
 	 */	
 	public void addChannelClientInfo(final ChannelClientInfo cci) {
-		final String key = myParser.toLowerCase(cci.getChannel().getName());
+		final String key = myParser.getIRCStringConverter().toLowerCase(cci.getChannel().getName());
 		if (!myChannelClientInfos.containsKey(key)) {
 			myChannelClientInfos.put(key, cci);
 		}
 	 * @param cci ChannelClientInfo to remove as a known reference
 	 */	
 	public void delChannelClientInfo(final ChannelClientInfo cci) {
-		final String key = myParser.toLowerCase(cci.getChannel().getName());
+		final String key = myParser.getIRCStringConverter().toLowerCase(cci.getChannel().getName());
 		if (myChannelClientInfos.containsKey(key)) {
 			myChannelClientInfos.remove(key);
 		}

src/com/dmdirc/parser/IRCParser.java

 	/** This is the default TrustManager for SSL Sockets, it trusts all ssl certs. */
 	private final TrustManager[] trustAllCerts = {
 		new X509TrustManager() {
-            @Override
-            public X509Certificate[] getAcceptedIssuers() { return null;	}
-            @Override
+			@Override
+			public X509Certificate[] getAcceptedIssuers() { return null; }
+			@Override
 			public void checkClientTrusted(final X509Certificate[] certs, final String authType) { }
-            @Override
+			@Override
 			public void checkServerTrusted(final X509Certificate[] certs, final String authType) { }
 		},
 	};
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callServerError(final String message) {
-		return ((CallbackOnServerError) myCallbackManager
-                .getCallbackType("OnServerError")).call(message);
+		return ((CallbackOnServerError) myCallbackManager.getCallbackType("OnServerError")).call(message);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callDataIn(final String data) {
-		return ((CallbackOnDataIn) myCallbackManager
-                .getCallbackType("OnDataIn")).call(data);
+		return ((CallbackOnDataIn) myCallbackManager.getCallbackType("OnDataIn")).call(data);
 	}
 
 	/**
 	 * @see com.dmdirc.parser.callbacks.interfaces.IDataOut
 	 */
 	protected boolean callDataOut(final String data, final boolean fromParser) {
-		return ((CallbackOnDataOut) myCallbackManager
-                .getCallbackType("OnDataOut")).call(data, fromParser);
+		return ((CallbackOnDataOut) myCallbackManager.getCallbackType("OnDataOut")).call(data, fromParser);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callDebugInfo(final int level, final String data) {
-		return ((CallbackOnDebugInfo) myCallbackManager
-                .getCallbackType("OnDebugInfo")).call(level, data);
+		return ((CallbackOnDebugInfo) myCallbackManager.getCallbackType("OnDebugInfo")).call(level, data);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callErrorInfo(final ParserError errorInfo) {
-		return ((CallbackOnErrorInfo) myCallbackManager
-                .getCallbackType("OnErrorInfo")).call(errorInfo);
+		return ((CallbackOnErrorInfo) myCallbackManager.getCallbackType("OnErrorInfo")).call(errorInfo);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callConnectError(final ParserError errorInfo) {
-		return ((CallbackOnConnectError) myCallbackManager
-                .getCallbackType("OnConnectError")).call(errorInfo);
+		return ((CallbackOnConnectError) myCallbackManager.getCallbackType("OnConnectError")).call(errorInfo);
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callSocketClosed() {
-		return ((CallbackOnSocketClosed) myCallbackManager
-                .getCallbackType("OnSocketClosed")).call();
+		return ((CallbackOnSocketClosed) myCallbackManager.getCallbackType("OnSocketClosed")).call();
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPingFailed() {
-		return ((CallbackOnPingFailed) myCallbackManager
-                .getCallbackType("OnPingFailed")).call();
+		return ((CallbackOnPingFailed) myCallbackManager.getCallbackType("OnPingFailed")).call();
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPingSent() {
-		return ((CallbackOnPingSent) myCallbackManager
-                .getCallbackType("OnPingSent")).call();
+		return ((CallbackOnPingSent) myCallbackManager.getCallbackType("OnPingSent")).call();
 	}
 
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPingSuccess() {
-		return ((CallbackOnPingSuccess) myCallbackManager
-                .getCallbackType("OnPingSuccess")).call();
+		return ((CallbackOnPingSuccess) myCallbackManager.getCallbackType("OnPingSuccess")).call();
 	}
 
 	/**
 	protected synchronized boolean callPost005() {
 		if (post005) { return false; }
 		post005 = true;
-        
-		return ((CallbackOnPost005) getCallbackManager()
-                .getCallbackType("OnPost005")).call();
+		
+		return ((CallbackOnPost005) getCallbackManager().getCallbackType("OnPost005")).call();
 	}
 
 	//---------------------------------------------------------------------------
 		} catch (UnknownHostException uhe) {
 			localhost = "*";
 		}
-		sendString("USER " + toLowerCase(me.getUsername()) + " "+localhost+" "+server.getHost()+" :" + me.getRealname());
+		sendString("USER " + getIRCStringConverter().toLowerCase(me.getUsername()) + " "+localhost+" "+server.getHost()+" :" + me.getRealname());
 	}
 
 	/**
 	}
 
 	/** Close socket on destroy. */
-    @Override
+	@Override
 	protected void finalize() throws Throwable {
 		try { socket.close(); }
 		catch (IOException e) {
 	 * @return ClientInfo Object for the client, or null
 	 */
 	public ClientInfo getClientInfo(final String sHost) {
-		final String sWho = toLowerCase(ClientInfo.parseHost(sHost));
+		final String sWho = getIRCStringConverter().toLowerCase(ClientInfo.parseHost(sHost));
 		if (hClientList.containsKey(sWho)) { return hClientList.get(sWho); }
 		else { return null; }
 	}
 	 * @return ClientInfo Object for the client.
 	 */
 	public ClientInfo getClientInfoOrFake(final String sHost) {
-		final String sWho = toLowerCase(ClientInfo.parseHost(sHost));
+		final String sWho = getIRCStringConverter().toLowerCase(ClientInfo.parseHost(sHost));
 		if (hClientList.containsKey(sWho)) { return hClientList.get(sWho); }
 		else { return new ClientInfo(this, sHost).setFake(true); }
 	}
 	 */
 	public ChannelInfo getChannelInfo(String sWhat) {
 		synchronized (hChannelList) {
-			sWhat = toLowerCase(sWhat);
+			sWhat = getIRCStringConverter().toLowerCase(sWhat);
 			if (hChannelList.containsKey(sWhat)) { return hChannelList.get(sWhat); } else { return null; }
 		}
 	}
 		stringConverter = new IRCStringConverter(limit);
 	}
 
-	/**
-	 * Get the lowercase version of a String for this Server.
-	 *
-	 * @param input String to convert lowercase
-	 * @return input String converterd to lowercase
-     * @deprecated Use IRCStringConverter instead
-	 */
-    @Deprecated
-	public String toLowerCase(final String input) {
-		return getIRCStringConverter().toLowerCase(input);
-	}
-
-	/**
-	 * Get the uppercase version of a String for this Server.
-	 *
-	 * @param input String to convert uppercase
-	 * @return input String converterd to uppercase
-     * @deprecated Use IRCStringConverter instead
-	 */
-    @Deprecated
-	public String toUpperCase(final String input) {
-		return getIRCStringConverter().toUpperCase(input);
-	}
-
-	/**
-	 * Check if 2 strings are equal to each other ignoring case.
-	 *
-	 * @param first First string to check
-	 * @param second Second string to check
-	 * @return True if both strings are equal after being lowercased
-     * @deprecated Use IRCStringConverter instead
-	 */
-    @Deprecated
-	public boolean equalsIgnoreCase(final String first, final String second) {
-		return getIRCStringConverter().equalsIgnoreCase(first, second);
-	}
-
 	/**
 	 * Get the known boolean chanmodes in 005 order.
 	 * Modes are returned in the order that the ircd specifies the modes in 005
 		final String channelName;
 		if (isValidChannelName(sChannelName)) {
 			channelName = sChannelName;
-        } else {
+		} else {
 			if (autoPrefix) {
 				if (h005Info.containsKey("CHANTYPES")) {
 					final String chantypes = h005Info.get("CHANTYPES");
 		// Check sChannelName is not empty or null
 		if (sChannelName == null || sChannelName.isEmpty()) { return false; }
 		// Check its not ourself (PM recieved before 005)
-		if (equalsIgnoreCase(getMyNickname(), sChannelName)) { return false; }
+		if (getIRCStringConverter().equalsIgnoreCase(getMyNickname(), sChannelName)) { return false; }
 		// Check if we are already on this channel
 		if (getChannelInfo(sChannelName) != null) { return true; }
 		// Check if we know of any valid chan prefixes
 	 * @param client Client to add
 	 */
 	public void addClient(final ClientInfo client) {
-		hClientList.put(toLowerCase(client.getNickname()),client);
+		hClientList.put(getIRCStringConverter().toLowerCase(client.getNickname()),client);
 	}
 
 	/**
 	 * @param client Client to remove
 	 */
 	protected void forceRemoveClient(final ClientInfo client) {
-		hClientList.remove(toLowerCase(client.getNickname()));
+		hClientList.remove(getIRCStringConverter().toLowerCase(client.getNickname()));
 	}
 
 	/**
 	 */
 	public void addChannel(final ChannelInfo channel) {
 		synchronized (hChannelList) {
-			hChannelList.put(toLowerCase(channel.getName()), channel);
+			hChannelList.put(getIRCStringConverter().toLowerCase(channel.getName()), channel);
 		}
 	}
 
 	 */
 	public void removeChannel(final ChannelInfo channel) {
 		synchronized (hChannelList) {
-			hChannelList.remove(toLowerCase(channel.getName()));
+			hChannelList.remove(getIRCStringConverter().toLowerCase(channel.getName()));
 		}
 	}
 

src/com/dmdirc/parser/Process001.java

 	 * @param sParam Type of line to process ("001")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		myParser.got001 = true;
 		// << :demon1.uk.quakenet.org 001 Java-Test :Welcome to the QuakeNet IRC Network, Java-Test
 	 * Callback to all objects implementing the ServerReady Callback.
 	 *
 	 * @see IServerReady
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */	
 	protected boolean callServerReady() {
-		return ((CallbackOnServerReady) getCallbackManager()
-                .getCallbackType("OnServerReady")).call();
+		return ((CallbackOnServerReady) getCallbackManager().getCallbackType("OnServerReady")).call();
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[1];
-		iHandle[0] = "001";
-		return iHandle;
+		return new String[]{"001"};
 	} 
 	
 	/**

src/com/dmdirc/parser/Process004005.java

 	 * @param sParam Type of line to process ("005", "004")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		if (sParam.equals("003")) {
 			myParser.h005Info.put("003IRCD",token[token.length-1]);
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
 		return new String[]{"003", "004", "005"};
 	} 
 	 * This takes no params of its own, but works them out itself.
 	 *
 	 * @see IGotNetwork
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callGotNetwork() {
 		final String networkName = myParser.sNetworkName;
 		final String ircdVersion = myParser.getIRCD(false);
 		final String ircdType = myParser.getIRCD(true);
 		
-		return ((CallbackOnGotNetwork) getCallbackManager()
-                .getCallbackType("OnGotNetwork")).call(networkName, ircdVersion, ircdType);
+		return ((CallbackOnGotNetwork) getCallbackManager().getCallbackType("OnGotNetwork")).call(networkName, ircdVersion, ircdType);
 	}
 	
 	/**

src/com/dmdirc/parser/Process464.java

 	 * @param sParam Type of line to process ("464")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(String sParam, String[] token) {
 		callPasswordRequired();
 //		ParserError ei = new ParserError(ParserError.ERROR_ERROR, "Password Required");
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[1];
-		iHandle[0] = "464";
-		return iHandle;
+		return new String[]{"464"};
 	} 
 	
 	/**
 	 * Callback to all objects implementing the PasswordRequired Callback.
 	 *
 	 * @see IPasswordRequired
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPasswordRequired() {
-		return ((CallbackOnPasswordRequired) getCallbackManager()
-                .getCallbackType("OnPasswordRequired")).call();
+		return ((CallbackOnPasswordRequired) getCallbackManager().getCallbackType("OnPasswordRequired")).call();
 	}
 	
 	/**

src/com/dmdirc/parser/ProcessAway.java

 	 * @param sParam Type of line to process ("305", "306")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(String sParam, String[] token) {
 		if (sParam.equals("301")) {
 			ClientInfo iClient = myParser.getClientInfo(token[3]);
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callAwayState(boolean currentState, String reason) {
-		return ((CallbackOnAwayState) myParser.getCallbackManager()
-                .getCallbackType("OnAwayState")).call(currentState, reason);
+		return ((CallbackOnAwayState) myParser.getCallbackManager().getCallbackType("OnAwayState")).call(currentState, reason);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[3];
-		iHandle[0] = "301"; // Whois Away
-		iHandle[1] = "305";
-		iHandle[2] = "306";
-		return iHandle;
+		return new String[]{"301", "305", "306"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessInvite.java

 	 * @param sParam Type of line to process ("INVITE")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		// :Tobavaj!shane@Tobavaj.users.quakenet.org INVITE Dataforce #dataforceisgod 1188846462
 		if (token.length > 2) {
 	 * @see IInvite
 	 * @param userHost The hostname of the person who invited us
 	 * @param channel The name of the channel we were invited to
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callInvite(final String userHost, final String channel) {
-		return ((CallbackOnInvite) getCallbackManager()
-                .getCallbackType("OnInvite")).call(userHost, channel);
+		return ((CallbackOnInvite) getCallbackManager().getCallbackType("OnInvite")).call(userHost, channel);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
 		return new String[]{"INVITE"};
 	} 

src/com/dmdirc/parser/ProcessJoin.java

  */
 public class ProcessJoin extends IRCProcessor {
 
-    /**
+	/**
 	 * Process a channel join.
 	 *
 	 * @param sParam Type of line to process ("JOIN")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		if (sParam.equals("329")) {
 			if (token.length < 5) { return; }
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelJoin(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient) {
-		return ((CallbackOnChannelJoin)getCallbackManager()
-                .getCallbackType("OnChannelJoin")).call(cChannel, cChannelClient);
+		return ((CallbackOnChannelJoin)getCallbackManager().getCallbackType("OnChannelJoin")).call(cChannel, cChannelClient);
 	}
 	
 	/**
 	 *
 	 * @see IChannelSelfJoin
 	 * @param cChannel Channel Object
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelSelfJoin(final ChannelInfo cChannel) {
-		return ((CallbackOnChannelSelfJoin) getCallbackManager()
-                .getCallbackType("OnChannelSelfJoin")).call(cChannel);
+		return ((CallbackOnChannelSelfJoin) getCallbackManager().getCallbackType("OnChannelSelfJoin")).call(cChannel);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[2];
-		iHandle[0] = "JOIN";
-		iHandle[1] = "329";
-		return iHandle;
+		return new String[]{"JOIN", "329"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessKick.java

  */
 public class ProcessKick extends IRCProcessor {
 
-    /**
+	/**
 	 * Process a channel kick.
 	 *
 	 * @param sParam Type of line to process ("KICK")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		ChannelClientInfo iChannelClient;
 		ChannelClientInfo iChannelKicker;
 	 * @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)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelKick(ChannelInfo cChannel, ChannelClientInfo cKickedClient, ChannelClientInfo cKickedByClient, String sReason, String sKickedByHost) {
-		return ((CallbackOnChannelKick) getCallbackManager()
-                .getCallbackType("OnChannelKick")).call(cChannel, cKickedClient, cKickedByClient, sReason, sKickedByHost);
+		return ((CallbackOnChannelKick) getCallbackManager().getCallbackType("OnChannelKick")).call(cChannel, cKickedClient, cKickedByClient, sReason, sKickedByHost);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[1];
-		iHandle[0] = "KICK";
-		return iHandle;
+		return new String[]{"KICK"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessListModes.java

 	 * @param token IRCTokenised line to process
 	 */
 	@SuppressWarnings("unchecked")
-    @Override
+	@Override
 	public void process(String sParam, String[] token) {
 		ChannelInfo channel = getChannelInfo(token[3]);
 		String thisIRCD = myParser.getIRCD(true).toLowerCase();
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[10];
-		int i = 0;
+		/*
 		// Ban List - All IRCds
 		iHandle[i++] = "367"; // Item
 		iHandle[i++] = "368"; // End
 		iHandle[i++] = "482"; // End
 		
 		// This is here to allow finding the processor for adding LISTMODE support
-		iHandle[i++] = "__LISTMODE__";
-		return iHandle;
+		iHandle[i++] = "__LISTMODE__"; */
+		return new String[]{"367", "368", "344", "345", "346", "347", "348", "349", "482", "__LISTMODE__"};
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelGotListModes(ChannelInfo cChannel) {
-		return ((CallbackOnChannelGotListModes) getCallbackManager()
-                .getCallbackType("OnChannelGotListModes")).call(cChannel);
+		return ((CallbackOnChannelGotListModes) getCallbackManager().getCallbackType("OnChannelGotListModes")).call(cChannel);
 	}
 	
 	/**

src/com/dmdirc/parser/ProcessMOTD.java

  */
 public class ProcessMOTD extends IRCProcessor {
 
-    /**
+	/**
 	 * Process a MOTD Related Line.
 	 *
 	 * @param sParam Type of line to process ("375", "372", "376", "422")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(String sParam, String[] token) {
 		if (sParam.equals("375")) {
 			callMOTDStart(token[token.length-1]);
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callMOTDEnd(final boolean noMOTD, final String data) {
-		return ((CallbackOnMOTDEnd) getCallbackManager()
-                .getCallbackType("OnMOTDEnd")).call(noMOTD, data);
+		return ((CallbackOnMOTDEnd) getCallbackManager().getCallbackType("OnMOTDEnd")).call(noMOTD, data);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callMOTDLine(final String data) {
-		return ((CallbackOnMOTDLine) getCallbackManager()
-                .getCallbackType("OnMOTDLine")).call(data);
+		return ((CallbackOnMOTDLine) getCallbackManager().getCallbackType("OnMOTDLine")).call(data);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callMOTDStart(String data) {
-		return ((CallbackOnMOTDStart) getCallbackManager()
-                .getCallbackType("OnMOTDStart")).call(data);
+		return ((CallbackOnMOTDStart) getCallbackManager().getCallbackType("OnMOTDStart")).call(data);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[4];
-		iHandle[0] = "372";
-		iHandle[1] = "375";
-		iHandle[2] = "376";
-		iHandle[3] = "422";
-		return iHandle;
+		return new String[]{"372", "375", "376", "422"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessMessage.java

 	 * @param sParam Type of line to process ("NOTICE", "PRIVMSG")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, String[] token) {
 		// Ignore people!
 		String sMessage = "";
 					callChannelNotice(iChannel, iChannelClient, sMessage, token[0]);
 				}
 			}
-		} else if (myParser.equalsIgnoreCase(token[2], myParser.getMyNickname())) {
+		} else if (myParser.getIRCStringConverter().equalsIgnoreCase(token[2], myParser.getMyNickname())) {
 			if (sParam.equalsIgnoreCase("PRIVMSG")) {
 				if (!isAction) {
 					if (isCTCP) {
 	 * @param cChannelClient ChannelClient who sent the action (may be null if server)
 	 * @param sMessage action contents
 	 * @param sHost Hostname of sender (or servername)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelAction(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
-		return ((CallbackOnChannelAction) getCallbackManager()
-                .getCallbackType("OnChannelAction")).call(cChannel, cChannelClient, sMessage, sHost);
+		return ((CallbackOnChannelAction) getCallbackManager().getCallbackType("OnChannelAction")).call(cChannel, cChannelClient, sMessage, sHost);
 	}
 	
 	/**
 	 * @param sType Type of CTCP (VERSION, TIME etc)
 	 * @param sMessage Additional contents
 	 * @param sHost Hostname of sender (or servername)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelCTCP(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sType, final String sMessage, final String sHost) {
-		return ((CallbackOnChannelCTCP) getCallbackManager()
-                .getCallbackType("OnChannelCTCP")).call(cChannel, cChannelClient, sType, sMessage, sHost);
+		return ((CallbackOnChannelCTCP) getCallbackManager().getCallbackType("OnChannelCTCP")).call(cChannel, cChannelClient, sType, sMessage, sHost);
 	}
 
 	/**
 	 * @param sType Type of CTCPRReply (VERSION, TIME etc)
 	 * @param sMessage Reply Contents
 	 * @param sHost Hostname of sender (or servername)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelCTCPReply(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sType, final String sMessage, final String sHost) {
-		return ((CallbackOnChannelCTCPReply) getCallbackManager()
-                .getCallbackType("OnChannelCTCPReply")).call(cChannel, cChannelClient, sType, sMessage, sHost);
+		return ((CallbackOnChannelCTCPReply) getCallbackManager().getCallbackType("OnChannelCTCPReply")).call(cChannel, cChannelClient, sType, sMessage, sHost);
 	}
 	
 	/**
 	 * @param cChannelClient ChannelClient who sent the message (may be null if server)
 	 * @param sMessage Message contents
 	 * @param sHost Hostname of sender (or servername)
-     * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelMessage(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
-		return ((CallbackOnChannelMessage) getCallbackManager()
-                .getCallbackType("OnChannelMessage")).call(cChannel, cChannelClient, sMessage, sHost);
+		return ((CallbackOnChannelMessage) getCallbackManager().getCallbackType("OnChannelMessage")).call(cChannel, cChannelClient, sMessage, sHost);
 	}
 	
 	/**
 	 * @param cChannelClient ChannelClient who sent the notice (may be null if server)
 	 * @param sMessage notice contents
 	 * @param sHost Hostname of sender (or servername)
-     * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelNotice(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sMessage, final String sHost) {
-		return ((CallbackOnChannelNotice) getCallbackManager()
-                .getCallbackType("OnChannelNotice")).call(cChannel, cChannelClient, sMessage, sHost);
+		return ((CallbackOnChannelNotice) getCallbackManager().getCallbackType("OnChannelNotice")).call(cChannel, cChannelClient, sMessage, sHost);
 	}
 	
 	/**
 	 * @see com.dmdirc.parser.callbacks.interfaces.IPrivateAction
 	 * @param sMessage action contents
 	 * @param sHost Hostname of sender (or servername)
-     * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPrivateAction(final String sMessage, final String sHost) {
-		return ((CallbackOnPrivateAction) getCallbackManager()
-                .getCallbackType("OnPrivateAction")).call(sMessage, sHost);
+		return ((CallbackOnPrivateAction) getCallbackManager().getCallbackType("OnPrivateAction")).call(sMessage, sHost);
 	}
 
 	/**
 	 * @param sType Type of CTCP (VERSION, TIME etc)
 	 * @param sMessage Additional contents
 	 * @param sHost Hostname of sender (or servername)
-     * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPrivateCTCP(final String sType, final String sMessage, final String sHost) {
-		return ((CallbackOnPrivateCTCP) getCallbackManager()
-                .getCallbackType("OnPrivateCTCP")).call(sType, sMessage, sHost);
+		return ((CallbackOnPrivateCTCP) getCallbackManager().getCallbackType("OnPrivateCTCP")).call(sType, sMessage, sHost);
 	}
 
 	/**
 	 * @param sType Type of CTCPRReply (VERSION, TIME etc)
 	 * @param sMessage Reply Contents
 	 * @param sHost Hostname of sender (or servername)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPrivateCTCPReply(final String sType, final String sMessage, final String sHost) {
-		return ((CallbackOnPrivateCTCPReply) getCallbackManager()
-                .getCallbackType("OnPrivateCTCPReply")).call(sType, sMessage, sHost);
+		return ((CallbackOnPrivateCTCPReply) getCallbackManager().getCallbackType("OnPrivateCTCPReply")).call(sType, sMessage, sHost);
 	}
 
 	/**
 	 * @see com.dmdirc.parser.callbacks.interfaces.IPrivateMessage
 	 * @param sMessage Message contents
 	 * @param sHost Hostname of sender (or servername)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPrivateMessage(final String sMessage, final String sHost) {
-		return ((CallbackOnPrivateMessage) getCallbackManager()
-                .getCallbackType("OnPrivateMessage")).call(sMessage, sHost);
+		return ((CallbackOnPrivateMessage) getCallbackManager().getCallbackType("OnPrivateMessage")).call(sMessage, sHost);
 	}
 
 	/**
 	 * @see com.dmdirc.parser.callbacks.interfaces.IPrivateNotice
 	 * @param sMessage Notice contents
 	 * @param sHost Hostname of sender (or servername)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callPrivateNotice(final String sMessage, final String sHost) {
-		return ((CallbackOnPrivateNotice)getCallbackManager()
-                .getCallbackType("OnPrivateNotice")).call(sMessage, sHost);
+		return ((CallbackOnPrivateNotice)getCallbackManager().getCallbackType("OnPrivateNotice")).call(sMessage, sHost);
 	}
 	
 	/**
 	 * @param sMessage Action contents
 	 * @param sTarget Actual target of action
 	 * @param sHost Hostname of sender (or servername)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUnknownAction(final String sMessage, final String sTarget, final String sHost) {
-		return ((CallbackOnUnknownAction) getCallbackManager()
-                .getCallbackType("OnUnknownAction")).call(sMessage, sTarget, sHost);
+		return ((CallbackOnUnknownAction) getCallbackManager().getCallbackType("OnUnknownAction")).call(sMessage, sTarget, sHost);
 	}
 
 	/**
 	 * @param sMessage Additional contents
 	 * @param sTarget Actual Target of CTCP
 	 * @param sHost Hostname of sender (or servername)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUnknownCTCP(final String sType, final String sMessage, final String sTarget, final String sHost) {
-		return ((CallbackOnUnknownCTCP)getCallbackManager()
-                .getCallbackType("OnUnknownCTCP")).call(sType, sMessage, sTarget, sHost);
+		return ((CallbackOnUnknownCTCP)getCallbackManager().getCallbackType("OnUnknownCTCP")).call(sType, sMessage, sTarget, sHost);
 	}
 
 	/**
 	 * @param sMessage Reply Contents
 	 * @param sTarget Actual Target of CTCPReply
 	 * @param sHost Hostname of sender (or servername)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUnknownCTCPReply(final String sType, final String sMessage, final String sTarget, final String sHost) {
-		return ((CallbackOnUnknownCTCPReply) getCallbackManager()
-                .getCallbackType("OnUnknownCTCPReply")).call(sType, sMessage, sTarget, sHost);
+		return ((CallbackOnUnknownCTCPReply) getCallbackManager().getCallbackType("OnUnknownCTCPReply")).call(sType, sMessage, sTarget, sHost);
 	}
 
 	/**
 	 * @param sMessage Message contents
 	 * @param sTarget Actual target of message
 	 * @param sHost Hostname of sender (or servername)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUnknownMessage(final String sMessage, final String sTarget, final String sHost) {
-		return ((CallbackOnUnknownMessage)getCallbackManager()
-                .getCallbackType("OnUnknownMessage")).call(sMessage, sTarget, sHost);
+		return ((CallbackOnUnknownMessage)getCallbackManager().getCallbackType("OnUnknownMessage")).call(sMessage, sTarget, sHost);
 	}
 
 	/**
 	 * @param sMessage Notice contents
 	 * @param sTarget Actual target of notice
 	 * @param sHost Hostname of sender (or servername)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUnknownNotice(final String sMessage, final String sTarget, final String sHost) {
-		return ((CallbackOnUnknownNotice) getCallbackManager()
-                .getCallbackType("OnUnknownNotice")).call(sMessage, sTarget, sHost);
+		return ((CallbackOnUnknownNotice) getCallbackManager().getCallbackType("OnUnknownNotice")).call(sMessage, sTarget, sHost);
 	}
 
 	
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[2];
-		iHandle[0] = "PRIVMSG";
-		iHandle[1] = "NOTICE";
-		return iHandle;
-	} 
+		return new String[]{"PRIVMSG", "NOTICE"};
+	}
 	
 	/**
 	 * Create a new instance of the IRCProcessor Object.

src/com/dmdirc/parser/ProcessMode.java

 	 * @param sParam Type of line to process ("MODE", "324")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(String sParam, String[] token) {
 		String[] sModestr;
 		String sChannelName;
 		CallbackOnChannelSingleModeChanged cbSingle = null;
 		CallbackOnChannelNonUserModeChanged cbNonUser = null;
 
-        if (!sParam.equals("324")) {
+		if (!sParam.equals("324")) {
 			cbSingle = (CallbackOnChannelSingleModeChanged) getCallbackManager().getCallbackType("OnChannelSingleModeChanged");
 			cbNonUser = (CallbackOnChannelNonUserModeChanged) getCallbackManager().getCallbackType("OnChannelNonUserModeChanged");
 		}
 	 * @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
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelModeChanged(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sHost, String sModes) {
-		return ((CallbackOnChannelModeChanged) getCallbackManager()
-                .getCallbackType("OnChannelModeChanged")).call(cChannel, cChannelClient, sHost, sModes);
+		return ((CallbackOnChannelModeChanged) getCallbackManager().getCallbackType("OnChannelModeChanged")).call(cChannel, cChannelClient, sHost, sModes);
 	}
 	
 	/**
 	 * @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)
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelUserModeChanged(ChannelInfo cChannel, ChannelClientInfo cChangedClient, ChannelClientInfo cSetByClient, String sHost, String sMode) {
-		return ((CallbackOnChannelUserModeChanged) getCallbackManager()
-                .getCallbackType("OnChannelUserModeChanged")).call(cChannel, cChangedClient, cSetByClient, sHost, sMode);
+		return ((CallbackOnChannelUserModeChanged) getCallbackManager().getCallbackType("OnChannelUserModeChanged")).call(cChannel, cChangedClient, cSetByClient, sHost, sMode);
 	}
 	
 	/**
 	 * @param cClient Client that had the mode changed (almost always us)
 	 * @param sSetby Host that set the mode (us or servername)
 	 * @param sModes The modes set.
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUserModeChanged(ClientInfo cClient, String sSetby, String sModes) {
-		return ((CallbackOnUserModeChanged) getCallbackManager()
-                .getCallbackType("OnUserModeChanged")).call(cClient, sSetby, sModes);
+		return ((CallbackOnUserModeChanged) getCallbackManager().getCallbackType("OnUserModeChanged")).call(cClient, sSetby, sModes);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callUserModeDiscovered(ClientInfo cClient, String sModes) {
-		return ((CallbackOnUserModeDiscovered)getCallbackManager()
-                .getCallbackType("OnUserModeDiscovered")).call(cClient, sModes);
+		return ((CallbackOnUserModeDiscovered)getCallbackManager().getCallbackType("OnUserModeDiscovered")).call(cClient, sModes);
 	}	
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[3];
-		iHandle[0] = "MODE";
-		iHandle[1] = "324";
-		iHandle[2] = "221";
-		return iHandle;
+		return new String[]{"MODE", "324", "221"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessNames.java

 	 * @param sParam Type of line to process ("366", "353")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(String sParam, String[] token) {
 		ChannelInfo iChannel;
 		if (sParam.equals("366")) {
 	 *
 	 * @see IChannelGotNames
 	 * @param cChannel Channel which the names reply is for
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelGotNames(ChannelInfo cChannel) {
-		return ((CallbackOnChannelGotNames) getCallbackManager()
-                .getCallbackType("OnChannelGotNames")).call(cChannel);
+		return ((CallbackOnChannelGotNames) getCallbackManager().getCallbackType("OnChannelGotNames")).call(cChannel);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[2];
-		iHandle[0] = "353";
-		iHandle[1] = "366";
-		return iHandle;
+		return new String[]{"353", "366"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessNick.java

 	 * @param sParam Type of line to process ("NICK")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(String sParam, String[] token) {
 		ClientInfo iClient;
 		ChannelClientInfo iChannelClient;
 		
 		iClient = getClientInfo(token[0]);
 		if (iClient != null) {
-			oldNickname = myParser.toLowerCase(iClient.getNickname());
+			oldNickname = myParser.getIRCStringConverter().toLowerCase(iClient.getNickname());
 			// Remove the client from the known clients list
-			final boolean isSameNick = myParser.equalsIgnoreCase(oldNickname, token[token.length-1]);
+			final boolean isSameNick = myParser.getIRCStringConverter().equalsIgnoreCase(oldNickname, token[token.length-1]);
 			
 			if (!isSameNick) {
 				myParser.forceRemoveClient(getClientInfo(oldNickname));
 	 * @param cChannel One of the channels that the user is on
 	 * @param cChannelClient Client changing nickname
 	 * @param sOldNick Nickname before change
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelNickChanged(ChannelInfo cChannel, ChannelClientInfo cChannelClient, String sOldNick) {
-		return ((CallbackOnChannelNickChanged) getCallbackManager()
-                .getCallbackType("OnChannelNickChanged")).call(cChannel, cChannelClient, sOldNick);
+		return ((CallbackOnChannelNickChanged) getCallbackManager().getCallbackType("OnChannelNickChanged")).call(cChannel, cChannelClient, sOldNick);
 	}
 	
 	/**
 	 * @see INickChanged
 	 * @param cClient Client changing nickname
 	 * @param sOldNick Nickname before change
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callNickChanged(ClientInfo cClient, String sOldNick) {
-		return ((CallbackOnNickChanged) getCallbackManager()
-                .getCallbackType("OnNickChanged")).call(cClient, sOldNick);
+		return ((CallbackOnNickChanged) getCallbackManager().getCallbackType("OnNickChanged")).call(cClient, sOldNick);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[1];
-		iHandle[0] = "NICK";
-		return iHandle;
+		return new String[]{"NICK"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessNickInUse.java

 	 * @param sParam Type of line to process ("433")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		if (!callNickInUse(token[3])) {
 			// Manually handle nick in use.
 				callDebugInfo(IRCParser.DEBUG_INFO,"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) {
-					if (myParser.equalsIgnoreCase(myParser.sThinkNickname, myParser.me.getAltNickname())) {
+					if (myParser.getIRCStringConverter().equalsIgnoreCase(myParser.sThinkNickname, myParser.me.getAltNickname())) {
 						myParser.sThinkNickname = myParser.me.getNickname();
 					}
-					myParser.setNickname(myParser.me.getPrependChar()+myParser.sThinkNickname);                                    
+					myParser.setNickname(myParser.me.getPrependChar()+myParser.sThinkNickname);
 				} else {
 					myParser.setNickname(myParser.me.getAltNickname());
 					myParser.triedAlt = true; 
 	 *
 	 * @param nickname Nickname that was wanted.
 	 * @see INickInUse
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callNickInUse(final String nickname) {
-		return ((CallbackOnNickInUse) getCallbackManager()
-                .getCallbackType("OnNickInUse")).call(nickname);
+		return ((CallbackOnNickInUse) getCallbackManager().getCallbackType("OnNickInUse")).call(nickname);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[1];
-		iHandle[0] = "433";
-		return iHandle;
-	} 
+		return new String[]{"433"};
+	}
 	
 	/**
 	 * Create a new instance of the ProcessNickInUse Object.

src/com/dmdirc/parser/ProcessNoticeAuth.java

 	 * @param sParam Type of line to process ("Notice Auth")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		callNoticeAuth(token[token.length-1]);
 	}
 	 *
 	 * @see INoticeAuth
 	 * @param data Incomming Line.
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callNoticeAuth(final String data) {
-		return ((CallbackOnNoticeAuth) getCallbackManager()
-                .getCallbackType("OnNoticeAuth")).call(data);
+		return ((CallbackOnNoticeAuth) getCallbackManager().getCallbackType("OnNoticeAuth")).call(data);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[1];
-		iHandle[0] = "Notice Auth";
-		return iHandle;
+		return new String[]{"Notice Auth"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessPart.java

  */
 public class ProcessPart extends IRCProcessor {
 
-    /**
+	/**
 	 * Process a channel part.
 	 *
 	 * @param sParam Type of line to process ("PART")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		// :nick!ident@host PART #Channel
 		// :nick!ident@host PART #Channel :reason
 	 * @param cChannel Channel that the user parted
 	 * @param cChannelClient Client that parted
 	 * @param sReason Reason given for parting (May be "")
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelPart(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sReason) {
-		return ((CallbackOnChannelPart) getCallbackManager()
-                .getCallbackType("OnChannelPart")).call(cChannel, cChannelClient, sReason);
+		return ((CallbackOnChannelPart) getCallbackManager().getCallbackType("OnChannelPart")).call(cChannel, cChannelClient, sReason);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[1];
-		iHandle[0] = "PART";
-		return iHandle;
+		return new String[]{"PART"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessQuit.java

  */
 public class ProcessQuit extends IRCProcessor {
 
-    /**
+	/**
 	 * Process a Quit message.
 	 *
 	 * @param sParam Type of line to process ("QUIT")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		// :nick!ident@host QUIT
 		// :nick!ident@host QUIT :reason
 	 * @param cChannel Channel that user was on
 	 * @param cChannelClient User thats quitting
 	 * @param sReason Quit reason
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelQuit(final ChannelInfo cChannel, final ChannelClientInfo cChannelClient, final String sReason) {
-		return ((CallbackOnChannelQuit) getCallbackManager()
-                .getCallbackType("OnChannelQuit")).call(cChannel, cChannelClient, sReason);
+		return ((CallbackOnChannelQuit) getCallbackManager().getCallbackType("OnChannelQuit")).call(cChannel, cChannelClient, sReason);
 	}
 	
 	/**
 	 * @see IQuit
 	 * @param cClient Client Quitting
 	 * @param sReason Reason for quitting (may be "")
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callQuit(final ClientInfo cClient, final String sReason) {
-		return ((CallbackOnQuit) getCallbackManager()
-                .getCallbackType("OnQuit")).call(cClient, sReason);
+		return ((CallbackOnQuit) getCallbackManager().getCallbackType("OnQuit")).call(cClient, sReason);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[1];
-		iHandle[0] = "QUIT";
-		return iHandle;
+		return new String[]{"QUIT"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessTopic.java

 	 * @param sParam Type of line to process ("TOPIC", "332", "333")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		ChannelInfo iChannel;
 		if (sParam.equals("332")) {
 	 * @see IChannelTopic
 	 * @param cChannel Channel that topic was set on
 	 * @param bIsJoinTopic True when getting topic on join, false if set by user/server
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelTopic(final ChannelInfo cChannel, final boolean bIsJoinTopic) {
-		return ((CallbackOnChannelTopic) getCallbackManager()
-                .getCallbackType("OnChannelTopic")).call(cChannel, bIsJoinTopic);
+		return ((CallbackOnChannelTopic) getCallbackManager().getCallbackType("OnChannelTopic")).call(cChannel, bIsJoinTopic);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[3];
-		iHandle[0] = "TOPIC";
-		iHandle[1] = "332";
-		iHandle[2] = "333";
-		return iHandle;
+		return new String[]{"TOPIC", "332", "333"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessWallops.java

 	 * @param sParam Type of line to process ("WALLOPS")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		if (token.length < 3) { return; }
 		
 	 * @see IWallop
 	 * @param host Host of the user who sent the wallop
 	 * @param message The message
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callWallop(final String message, final String host) {
-		return ((CallbackOnWallop) getCallbackManager()
-                .getCallbackType("OnWallop")).call(message, host);
+		return ((CallbackOnWallop) getCallbackManager().getCallbackType("OnWallop")).call(message, host);
 	}
 	
 	/**
 	 * @see IWalluser
 	 * @param host Host of the user who sent the walluser
 	 * @param message The message
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callWalluser(final String message, final String host) {
-		return ((CallbackOnWalluser) getCallbackManager()
-                .getCallbackType("OnWalluser")).call(message, host);
+		return ((CallbackOnWalluser) getCallbackManager().getCallbackType("OnWalluser")).call(message, host);
 	}
 	
 	/**
 	 * @see IWallDesync
 	 * @param host Host of the user who sent the WallDesync
 	 * @param message The message
-         * @return true if a method was called, false otherwise
+	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callWallDesync(final String message, final String host) {
-		return ((CallbackOnWallDesync) getCallbackManager()
-                .getCallbackType("OnWallDesync")).call(message, host);
+		return ((CallbackOnWallDesync) getCallbackManager().getCallbackType("OnWallDesync")).call(message, host);
 	}
 	
 	
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[]{"WALLOPS"};
-		return iHandle;
+		return new String[]{"WALLOPS"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessWho.java

 	 * @param sParam Type of line to process ("352")
 	 * @param token IRCTokenised line to process
 	 */
-    @Override
+	@Override
 	public void process(final String sParam, final String[] token) {
 		// :blueyonder2.uk.quakenet.org 352 Dataforce #mdbot shane Tobavaj.users.quakenet.org *.quakenet.org Tobavaj G+x :3 Tobavaj - http://shane.dmdirc.com/scriptbot.php
 		//              0               1      2        3     4              5                      6           7     8        9
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callAwayStateOther(final ClientInfo client, final boolean state) {
-		return ((CallbackOnAwayStateOther) myParser.getCallbackManager()
-                .getCallbackType("OnAwayStateOther")).call(client, state);
+		return ((CallbackOnAwayStateOther) myParser.getCallbackManager().getCallbackType("OnAwayStateOther")).call(client, state);
 	}
 	
 	/**
 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callChannelAwayStateOther(final ChannelInfo channel, final ChannelClientInfo channelClient, final boolean state) {
-		return ((CallbackOnChannelAwayStateOther) myParser.getCallbackManager()
-                .getCallbackType("OnChannelAwayStateOther")).call(channel, channelClient, state);
+		return ((CallbackOnChannelAwayStateOther) myParser.getCallbackManager().getCallbackType("OnChannelAwayStateOther")).call(channel, channelClient, state);
 	}
 	
 	/**
 	 *
 	 * @return String[] with the names of the tokens we handle.
 	 */
-    @Override
+	@Override
 	public String[] handles() {
-		String[] iHandle = new String[1];
-		iHandle[0] = "352";
-		return iHandle;
+		return new String[]{"352"};
 	} 
 	
 	/**

src/com/dmdirc/parser/ProcessingManager.java

 	 * @return true if a method was called, false otherwise
 	 */
 	protected boolean callNumeric(final int numeric, final String[] token) {
-		return ((CallbackOnNumeric) myParser.getCallbackManager()
-                .getCallbackType("OnNumeric")).call(numeric, token);
+		return ((CallbackOnNumeric) myParser.getCallbackManager().getCallbackType("OnNumeric")).call(numeric, token);
 	}
 
 }

src/com/dmdirc/parser/callbacks/CallbackManager.java

 		if (!callbackHash.containsKey(callbackName.toLowerCase())) {
 			throw new CallbackNotFoundException("Callback not found: " + callbackName);
 		}
-        
+		
 		return callbackHash.get(callbackName.toLowerCase());
 	}
 	
 	 */
 	public void addCallback(final String callbackName, final ICallbackInterface o) throws CallbackNotFoundException {
 		if (o == null) {
-            throw new NullPointerException("CallbackInterface is null");
-        }
-        
-        final CallbackObject cb = getCallbackType(callbackName);
+			throw new NullPointerException("CallbackInterface is null");
+		}
+		
+		final CallbackObject cb = getCallbackType(callbackName);
 		
-        if (cb != null) { cb.add(o); }
+		if (cb != null) { cb.add(o); }
 	}
 	
 	/**

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

 	 * @return true if error call succeeded, false otherwise
 	 */
 	protected final boolean callErrorInfo(final ParserError errorInfo) {
-		return ((CallbackOnErrorInfo) myManager
-                .getCallbackType("OnErrorInfo")).call(errorInfo);
+		return ((CallbackOnErrorInfo) myManager.getCallbackType("OnErrorInfo")).call(errorInfo);
 	}
 	
 	/**

src/com/dmdirc/parser/callbacks/CallbackObjectSpecific.java

 	 */
 	protected boolean isValidChan(final ICallbackInterface eMethod, final ChannelInfo cChannel) {
 		if (specificData.containsKey(eMethod)) { 
-			if (!myParser.equalsIgnoreCase(cChannel.getName(), specificData.get(eMethod))) { return false; }
+			if (!myParser.getIRCStringConverter().equalsIgnoreCase(cChannel.getName(), specificData.get(eMethod))) { return false; }
 		}
 		return true;
 	}
 	protected boolean isValidUser(final ICallbackInterface eMethod, final String sHost) {
 		final String nickname = ClientInfo.parseHost(sHost);
 		if (specificData.containsKey(eMethod)) {
-			if (!myParser.equalsIgnoreCase(nickname, specificData.get(eMethod))) { return false; }
+			if (!myParser.getIRCStringConverter().equalsIgnoreCase(nickname, specificData.get(eMethod))) { return false; }
 		}
 		return true;
 	}