Changes in this patch:

 *Added some irc numerical codes (253, 422)
 *Reordered codes
 *Unified some functions which did exactly the same in two functions
 *Changed nick ordering in channel list, now nicks get ordered first
  by flags and then by name.

4 files changed, 50 insertions, 46 deletions

diff --git a/noncore/net/opieirc/ircchannellist.cpp b/noncore/net/opieirc/ircchannellist.cpp
index 4e13dee..6bef318 100644
--- a/noncore/net/opieirc/ircchannellist.cpp
+++ b/noncore/net/opieirc/ircchannellist.cpp
@@ -1,47 +1,65 @@
 #include <qpe/resource.h>
 #include "ircchannellist.h"
 
 IRCChannelList::IRCChannelList(IRCChannel *channel, QWidget *parent, const char *name, WFlags f) : QListBox(parent, name, f) {
     m_channel = channel;
 }
 
 void IRCChannelList::update() {
     QPixmap op = Resource::loadPixmap("opieirc/op");
     QPixmap hop = Resource::loadPixmap("opieirc/hop");
     QPixmap voice = Resource::loadPixmap("opieirc/voice");
     QListIterator<IRCChannelPerson> it = m_channel->people();
     clear();
     for (; it.current(); ++it) {
         IRCChannelPerson *person = it.current();
         if (person->flags & PERSON_FLAG_OP) {
-            insertItem(op, person->person->nick());
+            insertItem(op, "1" + person->person->nick());
         } else if (person->flags & PERSON_FLAG_HALFOP) {
-            insertItem(op, person->person->nick());
+            insertItem(op, "2" + person->person->nick());
         } else if (person->flags & PERSON_FLAG_VOICE) {
-            insertItem(voice, person->person->nick());
+            insertItem(voice, "3" + person->person->nick());
         } else {
-            insertItem(person->person->nick());
+            insertItem("4" + person->person->nick());
         }
     }
     sort();
+    adjustNicks();
 }
 
 
 bool IRCChannelList::hasPerson(QString nick) {
     for (unsigned int i=0; i<count(); i++) {
         if (text(i) == nick)
             return TRUE;
     }
     return FALSE;
 }
 
 bool IRCChannelList::removePerson(QString nick) {
     for (unsigned int i=0; i<count(); i++) {
         if (text(i) == nick){
             removeItem(i);
             return TRUE;
             }
     }
     return FALSE;
 }
 
+void IRCChannelList::adjustNicks() {
+    QString txt;
+    QPixmap pm;
+
+    for(unsigned int i=0; i<count(); i++) {
+        txt = text(i).remove(0,1);
+        if(pixmap(i)) {
+            pm = *pixmap(i);
+            removeItem(i);
+            insertItem(pm, txt, i);
+        }
+        else {
+            removeItem(i);
+            insertItem(txt,i);
+        }
+    }
+}
diff --git a/noncore/net/opieirc/ircchannellist.h b/noncore/net/opieirc/ircchannellist.h
index deab649..b4e46eb 100644
--- a/noncore/net/opieirc/ircchannellist.h
+++ b/noncore/net/opieirc/ircchannellist.h
@@ -1,37 +1,38 @@
 /*
     OpieIRC - An embedded IRC client
     Copyright (C) 2002 Wenzel Jakob
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 */
 
 #ifndef __IRCCHANNELLIST_H
 #define __IRCCHANNELLIST_H
 
 #include <qlistbox.h>
 #include "ircchannel.h"
 
 class IRCChannelList : public QListBox {
 public:
     IRCChannelList(IRCChannel *channel, QWidget *parent = 0, const char *name = 0, WFlags f = 0);
     void update();
+    void adjustNicks();
     bool hasPerson(QString nick);
     bool removePerson(QString nick);
 protected:
     IRCChannel *m_channel;
 };
 
 #endif /* __IRCCHANNELLIST_H */
diff --git a/noncore/net/opieirc/ircmessageparser.cpp b/noncore/net/opieirc/ircmessageparser.cpp
index ecc7e9a..f8ccbb6 100644
--- a/noncore/net/opieirc/ircmessageparser.cpp
+++ b/noncore/net/opieirc/ircmessageparser.cpp
@@ -1,251 +1,254 @@
 #include <qtextstream.h>
 #include "ircmessageparser.h"
 #include "ircversion.h"
 
 /* Lookup table for literal commands */
 IRCLiteralMessageParserStruct IRCMessageParser::literalParserProcTable[] = {
     { "PING",    FUNC(parseLiteralPing) },
     { "NOTICE",  FUNC(parseLiteralNotice) },
     { "JOIN",    FUNC(parseLiteralJoin) },
     { "PRIVMSG", FUNC(parseLiteralPrivMsg) },
     { "NICK",    FUNC(parseLiteralNick) },
     { "PART",    FUNC(parseLiteralPart) },
     { "QUIT",    FUNC(parseLiteralQuit) },
     { "ERROR",   FUNC(parseLiteralError) },
     { "ERROR:",  FUNC(parseLiteralError) },
     { "MODE",    FUNC(parseLiteralMode) },
     { "KICK",    FUNC(parseLiteralKick) },
     { "TOPIC",   FUNC(parseLiteralTopic) },
     { 0 , 0 }
 };
 
 /* Lookup table for literal commands */
 IRCCTCPMessageParserStruct IRCMessageParser::ctcpParserProcTable[] = {
     { "PING",    FUNC(parseCTCPPing) },
     { "VERSION", FUNC(parseCTCPVersion) },
     { "ACTION",  FUNC(parseCTCPAction) },
     { 0 , 0 }
 };
 
 /* Lookup table for numerical commands */
 IRCNumericalMessageParserStruct IRCMessageParser::numericalParserProcTable[] = {
-    { 1,   FUNC(parseNumerical001) },           // RPL_WELCOME
-    { 2,   FUNC(parseNumerical002) },           // RPL_YOURHOST
-    { 3,   FUNC(parseNumerical003) },           // RPL_CREATED
-    { 4,   FUNC(parseNumerical004) },           // RPL_MYINFO
-    { 5,   FUNC(parseNumerical005) },           // RPL_BOUNCE, RPL_PROTOCTL
-    { 251, FUNC(parseNumericalStats) },         // RPL_LUSERCLIENT
-    { 252, FUNC(parseNumericalStats) },         // RPL_LUSEROP
-    { 265, FUNC(parseNumericalStats) },         // RPL_LOCALUSERS
-    { 266, FUNC(parseNumericalStats) },         // RPL_GLOBALUSERS
-    { 250, FUNC(parseNumericalStats) },         // RPL_STATSCONN
-    { 254, FUNC(nullFunc)},                     // RPL_LUSERCHANNELS
-    { 255, FUNC(parseNumericalStats) },         // RPL_LUSERNAME
+    { 1,   FUNC(parseNumericalSecondParam) },   // RPL_WELCOME
+    { 2,   FUNC(parseNumericalSecondParam) },   // RPL_YOURHOST
+    { 3,   FUNC(parseNumericalSecondParam) },   // RPL_CREATED
+    { 4,   FUNC(parseNumericalAllParams) },     // RPL_MYINFO
+    { 5,   FUNC(parseNumericalSecondParam) },   // RPL_BOUNCE, RPL_PROTOCTL
+    { 250, FUNC(parseNumericalAllParams) },     // RPL_STATSCONN
+    { 251, FUNC(parseNumericalSecondParam) },   // RPL_LUSERCLIENT
+    { 252, FUNC(parseNumericalAllParams) },     // RPL_LUSEROP
+    { 253, FUNC(parseNumericalAllParams) },     // RPL_LUSERUNKNOWN
+    { 254, FUNC(parseNumericalAllParams) },     // RPL_LUSERCHANNELS
+    { 255, FUNC(parseNumericalSecondParam) },   // RPL_LUSERME
+    { 265, FUNC(parseNumericalAllParams) },     // RPL_LOCALUSERS
+    { 266, FUNC(parseNumericalAllParams) },     // RPL_GLOBALUSERS
     { 332, FUNC(parseNumericalTopic) },         // RPL_TOPIC
     { 333, FUNC(parseNumericalTopicWhoTime) },  // RPL_TOPICWHOTIME
     { 353, FUNC(parseNumericalNames) },         // RPL_NAMREPLY
     { 366, FUNC(parseNumericalEndOfNames) },    // RPL_ENDOFNAMES
-    { 375, FUNC(parseNumericalStats) },         // RPL_MOTDSTART
-    { 372, FUNC(parseNumericalStats) },         // RPL_MOTD
-    { 376, FUNC(parseNumericalStats) },         // RPL_ENDOFMOTD
-    { 377, FUNC(parseNumericalStats) },         // RPL_MOTD2
-    { 378, FUNC(parseNumericalStats) },         // RPL_MOTD3
+    { 372, FUNC(parseNumericalSecondParam) },   // RPL_MOTD
+    { 375, FUNC(parseNumericalSecondParam) },   // RPL_MOTDSTART
+    { 376, FUNC(parseNumericalSecondParam) },   // RPL_ENDOFMOTD
+    { 377, FUNC(parseNumericalSecondParam) },   // RPL_MOTD2
+    { 378, FUNC(parseNumericalSecondParam) },   // RPL_MOTD3
     { 401, FUNC(parseNumericalNoSuchNick) },    // ERR_NOSUCHNICK
     { 406, FUNC(parseNumericalNoSuchNick) },    // ERR_WASNOSUCHNICK
-    { 412, FUNC(parseNumericalStats) },         // ERR_NOTEXTTOSEND
+    { 412, FUNC(parseNumericalSecondParam) },   // ERR_NOTEXTTOSEND
+    { 422, FUNC(parseNumericalSecondParam) },   // ERR_NOMOTD
     { 433, FUNC(parseNumericalNicknameInUse) }, // ERR_NICKNAMEINUSE
     { 0,   0 }
 };
 
+
 IRCMessageParser::IRCMessageParser(IRCSession *session) {
     m_session = session;
 }
 
 void IRCMessageParser::parse(IRCMessage *message) {
     /* Find out what kind of message we have here and call the appropriate handler using
        the parser tables. If no handler can be found, print out an error message */
     if (message->isNumerical()) {
         for (int i=0; i<numericalParserProcTable[i].commandNumber; i++) {
             if (message->commandNumber() == numericalParserProcTable[i].commandNumber) {
                 (this->*(numericalParserProcTable[i].proc))(message);
                 return;
             }
         }
         emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Received unhandled numeric command: %1").arg( QString::number(message->commandNumber()) )));
     } else if (message->isCTCP()) {
         for (int i=0; ctcpParserProcTable[i].commandName; i++) {
             if (message->ctcpCommand() == ctcpParserProcTable[i].commandName) {
                 (this->*(ctcpParserProcTable[i].proc))(message);
                 return;
             }
         }
         emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Received unhandled ctcp command: %1").arg( message->ctcpCommand())) );
     } else {
         for (int i=0; literalParserProcTable[i].commandName; i++) {
             if (message->command() == literalParserProcTable[i].commandName) {
                 (this->*(literalParserProcTable[i].proc))(message);
                 return;
             }
         }
         emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Received unhandled literal command: %1").arg( message->command()) ));
     }
 }
 
 void IRCMessageParser::nullFunc(IRCMessage *) {
     /* Do nothing */
 }
 
 void IRCMessageParser::parseLiteralPing(IRCMessage *message) {
     m_session->m_connection->sendLine("PONG " + message->allParameters());
 }
 
 void IRCMessageParser::parseLiteralNotice(IRCMessage *message) {
     emit outputReady(IRCOutput(OUTPUT_SERVERMESSAGE, message->allParameters()));
 }
 
 void IRCMessageParser::parseLiteralJoin(IRCMessage *message) {
     QString channelName = message->param(0).lower();
     IRCPerson mask(message->prefix());
     IRCChannel *channel = m_session->getChannel(channelName);
     if (!channel) {
         /* We joined */
         if (mask.nick() == m_session->m_server->nick()) {
             channel = new IRCChannel(channelName);
             m_session->addChannel(channel);
         } else {
             emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Nonexistant channel join - desynchronized?")));
         }
     } else {
         /* Someone else joined */
         if (mask.nick() != m_session->m_server->nick()) {
             if (!channel->getPerson(mask.nick())) {
                 IRCChannelPerson *chanperson = new IRCChannelPerson();
                 IRCPerson *person = m_session->getPerson(mask.nick());
                 if (!person) {
                     person = new IRCPerson(message->prefix());
                     m_session->addPerson(person);
                 }
                 chanperson->flags = 0;
                 chanperson->person = person;
                 channel->addPerson(chanperson);
                 IRCOutput output(OUTPUT_OTHERJOIN ,tr("%1 joined channel %2").arg( mask.nick() ).arg( channelName ));
                 output.addParam(channel);
                 output.addParam(chanperson);
                 emit outputReady(output);
             } else {
                emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Person has already joined the channel - desynchronized?")));
             }
         } else {
            emit outputReady(IRCOutput(OUTPUT_ERROR, tr("You already joined the channel - desynchronized?")));
         }
     }
 }
 
 void IRCMessageParser::parseLiteralPart(IRCMessage *message) {
     QString channelName = message->param(0).lower();
     IRCChannel *channel = m_session->getChannel(channelName);
     IRCPerson mask(message->prefix());
     if (channel) {
         if (mask.nick() == m_session->m_server->nick()) {
             m_session->removeChannel(channel);
             IRCOutput output(OUTPUT_SELFPART, tr("You left channel %1").arg( channelName ));
             output.addParam(channel);
             emit outputReady(output);
             delete channel;
         } else {
             IRCChannelPerson *person = channel->getPerson(mask.nick());
             if (person) {
                 channel->removePerson(person);
                 IRCOutput output(OUTPUT_OTHERPART, tr("%1 left channel %2").arg( mask.nick() ).arg( channelName) );
                 output.addParam(channel);
                 output.addParam(person);
                 emit outputReady(output);
                 delete person;
             } else {
                 emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Parting person not found - desynchronized?")));
             }
         }
     } else {
         emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Channel for part not found - desynchronized?")));
     }
 }
 
 void IRCMessageParser::parseLiteralPrivMsg(IRCMessage *message) {
     if (m_session->m_server->nick().lower() == message->param(0).lower() ) {
         /* IRC Query message detected, verify sender and display it */
         IRCPerson mask(message->prefix());
         IRCPerson *person = m_session->getPerson(mask.nick());
         if (!person) {
             /* Person not yet known, create and add to the current session */
             person = new IRCPerson(message->prefix());
             m_session->addPerson(person);
         }
         IRCOutput output(OUTPUT_QUERYPRIVMSG, message->param(1));
         output.addParam(person);
         emit outputReady(output);
     } else if (message->param(0).at(0) == '#' || message->param(0).at(0) == '+') {
         /* IRC Channel message detected, verify sender, channel and display it */
         IRCChannel *channel = m_session->getChannel(message->param(0).lower());
         if (channel) {
             IRCPerson mask(message->prefix());
             IRCChannelPerson *person = channel->getPerson(mask.nick());
             if (person) {
                 IRCOutput output(OUTPUT_CHANPRIVMSG, message->param(1));
                 output.addParam(channel);
                 output.addParam(person);
                 emit outputReady(output);
             } else {
                 emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Channel message with unknown sender")));
             }
         } else {
             emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Channel message with unknown channel %1").arg(message->param(0).lower()) ));
         }
     } else {
         emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Received PRIVMSG of unknown type")));
     }
 }
 
 void IRCMessageParser::parseLiteralNick(IRCMessage *message) {
 
     IRCPerson mask(message->prefix());
     /* this way of handling nick changes really sucks */
     if (mask.nick() == m_session->m_server->nick()) {
         /* We are changing our nickname */
         m_session->m_server->setNick(message->param(0));
         IRCOutput output(OUTPUT_NICKCHANGE, tr("You are now known as %1").arg( message->param(0)));
         output.addParam(0);
         emit outputReady(output);
     } else {
         /* Someone else is */
         IRCPerson *person = m_session->getPerson(mask.nick());
         if (person) {
             //IRCOutput output(OUTPUT_NICKCHANGE, tr("%1 is now known as %2").arg( mask.nick() ).arg( message->param(0)));
 
             /* new code starts here -- this removes the person from all channels */
             QList<IRCChannel> channels;
             m_session->getChannelsByPerson(person, channels);
             QListIterator<IRCChannel> it(channels);
             for (;it.current(); ++it) {
               IRCChannelPerson *chanperson = it.current()->getPerson(mask.nick());
               it.current()->removePerson(chanperson);
               chanperson->person->setNick(message->param(0));
               it.current()->addPerson(chanperson);
               IRCOutput output(OUTPUT_NICKCHANGE, tr("%1 is now known as %2").arg( mask.nick() ).arg( message->param(0)));
               output.addParam(person);
               emit outputReady(output);
             }
             /* new code ends here */
         } else {
             emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Nickname change of an unknown person")));
         }
     }
 }
 
 void IRCMessageParser::parseLiteralQuit(IRCMessage *message) {
     IRCPerson mask(message->prefix());
     IRCPerson *person = m_session->getPerson(mask.nick());
     if (person) {
         QList<IRCChannel> channels;
         m_session->getChannelsByPerson(person, channels);
         QListIterator<IRCChannel> it(channels);
         for (;it.current(); ++it) {
@@ -271,300 +274,286 @@ void IRCMessageParser::parseLiteralTopic(IRCMessage *message) {
         output.addParam(channel);
         emit outputReady(output);
     } else {
         emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Unknown channel topic - desynchronized?")));
     }
 }
 
 void IRCMessageParser::parseLiteralError(IRCMessage *message) {
     emit outputReady(IRCOutput(OUTPUT_ERROR, message->allParameters()));
 }
 
 void IRCMessageParser::parseCTCPPing(IRCMessage *message) {
     IRCPerson mask(message->prefix());
     m_session->m_connection->sendCTCP(mask.nick(), "PING " + message->allParameters());
     emit outputReady(IRCOutput(OUTPUT_CTCP, tr("Received a CTCP PING from ")+mask.nick()));
 
     //IRCPerson mask(message->prefix());
     QString dest = message->ctcpDestination();
     if (dest.startsWith("#")) {
         IRCChannel *channel = m_session->getChannel(dest.lower());
         if (channel) {
             IRCChannelPerson *person = channel->getPerson(mask.nick());
             if (person) {
                 IRCOutput output(OUTPUT_CHANACTION, tr("Received a CTCP PING from ")+ mask.nick()) ;
                 output.addParam(channel);
                 output.addParam(person);
                 emit outputReady(output);
             } else {
                 emit outputReady(IRCOutput(OUTPUT_ERROR, tr("CTCP PING with unknown person - Desynchronized?")));
             }
         } else {
             emit outputReady(IRCOutput(OUTPUT_ERROR, tr("CTCP PING with unknown channel - Desynchronized?")));
         }
     } else {
         if (message->ctcpDestination() == m_session->m_server->nick()) {
             IRCPerson *person = m_session->getPerson(mask.nick());
             if (!person) {
                 /* Person not yet known, create and add to the current session */
                 person = new IRCPerson(message->prefix());
                 m_session->addPerson(person);
             }
             IRCOutput output(OUTPUT_QUERYACTION, tr("Received a CTCP PING from ")+ mask.nick() );
             output.addParam(person);
             emit outputReady(output);
         } else {
             emit outputReady(IRCOutput(OUTPUT_ERROR, tr("CTCP PING with bad recipient")));
         }
     }
 
 }
 
 void IRCMessageParser::parseCTCPVersion(IRCMessage *message) {
     IRCPerson mask(message->prefix());
     m_session->m_connection->sendCTCP(mask.nick(), APP_VERSION " "  APP_COPYSTR);
     emit outputReady(IRCOutput(OUTPUT_CTCP, tr("Received a CTCP VERSION from ")+mask.nick()));
 }
 
 void IRCMessageParser::parseCTCPAction(IRCMessage *message) {
     IRCPerson mask(message->prefix());
     QString dest = message->ctcpDestination();
     if (dest.startsWith("#")) {
         IRCChannel *channel = m_session->getChannel(dest.lower());
         if (channel) {
             IRCChannelPerson *person = channel->getPerson(mask.nick());
             if (person) {
                 IRCOutput output(OUTPUT_CHANACTION, "*" + mask.nick() + message->param(0));
                 output.addParam(channel);
                 output.addParam(person);
                 emit outputReady(output);
             } else {
                 emit outputReady(IRCOutput(OUTPUT_ERROR, tr("CTCP ACTION with unknown person - Desynchronized?")));
             }
         } else {
             emit outputReady(IRCOutput(OUTPUT_ERROR, tr("CTCP ACTION with unknown channel - Desynchronized?")));
         }
     } else {
         if (message->ctcpDestination() == m_session->m_server->nick()) {
             IRCPerson *person = m_session->getPerson(mask.nick());
             if (!person) {
                 /* Person not yet known, create and add to the current session */
                 person = new IRCPerson(message->prefix());
                 m_session->addPerson(person);
             }
             IRCOutput output(OUTPUT_QUERYACTION, "*" + mask.nick() + message->param(0));
             output.addParam(person);
             emit outputReady(output);
         } else {
             emit outputReady(IRCOutput(OUTPUT_ERROR, tr("CTCP ACTION with bad recipient")));
         }
     }
 }
 
 void IRCMessageParser::parseLiteralMode(IRCMessage *message) {
     IRCPerson mask(message->prefix());
 
     if (message->param(0).startsWith("#")) {
         IRCChannel *channel = m_session->getChannel(message->param(0).lower());
         if (channel) {
             QString temp, parameters = message->allParameters().right(message->allParameters().length() - channel->channelname().length() - 1);
             QTextIStream stream(&parameters);
             bool set = FALSE;
             while (!stream.atEnd()) {
                 stream >> temp;
                 if (temp.startsWith("+")) {
                     set = TRUE;
                     temp = temp.right(1);
                 } else if (temp.startsWith("-")) {
                     set = FALSE;
                     temp = temp.right(1);
                 } else {
                     emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Mode change has unknown type")));
                     return;
                 }
                 if (temp == "o") {
                     stream >> temp;
                     IRCChannelPerson *person = channel->getPerson(temp);
                     if (person) {
                         if (set) {
                             person->flags |= PERSON_FLAG_OP;
                             IRCOutput output(OUTPUT_CHANPERSONMODE, mask.nick() + tr(" gives channel operator status to " + person->person->nick()));
                             output.addParam(channel);
                             output.addParam(person);
                             emit outputReady(output);
                         } else {
                             person->flags &= 0xFFFF - PERSON_FLAG_OP;
                             IRCOutput output(OUTPUT_CHANPERSONMODE, mask.nick() + tr(" removes channel operator status from " + person->person->nick()));
                             output.addParam(channel);
                             output.addParam(person);
                             emit outputReady(output);
                         }
                     } else {
                         emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Mode change with unknown person - Desynchronized?")));
                     }
                 } else if (temp == "v") {
                     stream >> temp;
                     IRCChannelPerson *person = channel->getPerson(temp);
                     if (person) {
                         if (set) {
                             person->flags |= PERSON_FLAG_VOICE;
                             IRCOutput output(OUTPUT_CHANPERSONMODE, mask.nick() + tr(" gives voice to " + person->person->nick()));
                             output.addParam(channel);
                             output.addParam(person);
                             emit outputReady(output);
                         } else {
                             person->flags &= 0xFFFF - PERSON_FLAG_VOICE;
                             IRCOutput output(OUTPUT_CHANPERSONMODE, mask.nick() + tr(" removes voice from " + person->person->nick()));
                             output.addParam(channel);
                             output.addParam(person);
                             emit outputReady(output);
                         }
                     } else {
                         emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Mode change with unknown person - Desynchronized?")));
                     }
                 } else {
                     emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Mode change with unknown flag")));
                 }
             }
         } else {
             emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Mode change with unknown kannel - Desynchronized?")));
         }
     } else {
         emit outputReady(IRCOutput(OUTPUT_ERROR, tr("User modes not supported yet")));
     }
 }
 
 void IRCMessageParser::parseLiteralKick(IRCMessage *message) {
     IRCPerson mask(message->prefix());
     IRCChannel *channel = m_session->getChannel(message->param(0).lower());
     if (channel) {
         IRCChannelPerson *person = channel->getPerson(message->param(1));
         if (person) {
             if (person->person->nick() == m_session->m_server->nick()) {
                 m_session->removeChannel(channel);
                 IRCOutput output(OUTPUT_SELFKICK, tr("You were kicked from ") + channel->channelname() + tr(" by ") + mask.nick() + " (" + message->param(2) + ")");
                 output.addParam(channel);
                 emit outputReady(output);
             } else {
               /* someone else got kicked */
                 channel->removePerson(person);
                 IRCOutput output(OUTPUT_OTHERKICK, person->person->nick() + tr(" was kicked from ") + channel->channelname() + tr(" by ") + mask.nick()+ " (" + message->param(2) + ")");
                 output.addParam(channel);
                 output.addParam(person);
                 emit outputReady(output);
             }
         } else {
             emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Unknown person kick - desynchronized?")));
         }
     } else {
          emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Unknown channel kick - desynchronized?")));
     }
 }
 
-void IRCMessageParser::parseNumerical001(IRCMessage *message) {
-    /* Welcome to IRC message, display */
-    emit outputReady(IRCOutput(OUTPUT_SERVERMESSAGE, message->param(1)));
-}
 
-void IRCMessageParser::parseNumerical002(IRCMessage *message) {
+void IRCMessageParser::parseNumericalSecondParam(IRCMessage *message) {
     emit outputReady(IRCOutput(OUTPUT_SERVERMESSAGE, message->param(1)));
 }
 
-void IRCMessageParser::parseNumerical003(IRCMessage *message) {
-    emit outputReady(IRCOutput(OUTPUT_SERVERMESSAGE, message->param(1)));
-}
-
-void IRCMessageParser::parseNumerical004(IRCMessage *message) {
+void IRCMessageParser::parseNumericalAllParams(IRCMessage *message) {
     emit outputReady(IRCOutput(OUTPUT_SERVERMESSAGE, message->allParameters()));
 }
 
-void IRCMessageParser::parseNumerical005(IRCMessage *message) {
-    emit outputReady(IRCOutput(OUTPUT_SERVERMESSAGE, message->allParameters()));
-}
-
-void IRCMessageParser::parseNumericalStats(IRCMessage *message) {
-    emit outputReady(IRCOutput(OUTPUT_SERVERMESSAGE, message->param(1)));
-}
-
 void IRCMessageParser::parseNumericalNames(IRCMessage *message) {
     /* Name list sent when joining a channel */
     IRCChannel *channel = m_session->getChannel(message->param(2).lower());
     if (channel != 0) {
         QString people = message->param(3);
         QTextIStream stream(&people);
         QString temp;
 
         while (!stream.atEnd()) {
             stream >> temp;
 
             char flagch = temp.at(0).latin1();
             int flag = 0;
             QString nick;
             /* Parse person flags */
             if (flagch == '@' || flagch == '+' || flagch=='%' || flagch == '*') {
 
                 nick = temp.right(temp.length()-1);
                 switch (flagch) {
                     case '@': flag = PERSON_FLAG_OP;     break;
                     case '+': flag = PERSON_FLAG_VOICE;  break;
                     case '%': flag = PERSON_FLAG_HALFOP; break;
                     default : flag = 0; break;
                 }
             } else {
                 nick = temp;
             }
 
             IRCChannelPerson *chan_person = new IRCChannelPerson();
             IRCPerson *person = m_session->getPerson(nick);
             if (person == 0) {
                 person = new IRCPerson();
                 person->setNick(nick);
                 m_session->addPerson(person);
             }
             chan_person->person = person;
             chan_person->flags = flag;
             channel->addPerson(chan_person);
         }
     } else {
         emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Server message with unknown channel")));
     }
 }
 
 void IRCMessageParser::parseNumericalEndOfNames(IRCMessage *message) {
     /* Done syncing to channel */
     IRCChannel *channel = m_session->getChannel(message->param(1).lower());
     if (channel) {
         channel->setHasPeople(TRUE);
         /* Yes, we want the names before anything happens inside the GUI */
         IRCOutput output(OUTPUT_SELFJOIN, tr("You joined channel ") + channel->channelname());
         output.addParam(channel);
         emit outputReady(output);
     } else {
         emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Server message with unknown channel")));
     }
 }
 
 
 void IRCMessageParser::parseNumericalNicknameInUse(IRCMessage *) {
     emit outputReady(IRCOutput(OUTPUT_ERROR, tr("Nickname is in use, please reconnect with a different nickname")));
     m_session->endSession();
 }
 
 void IRCMessageParser::parseNumericalNoSuchNick(IRCMessage *) {
     emit outputReady(IRCOutput(OUTPUT_ERROR, tr("No such nickname")));
 }
 
 void IRCMessageParser::parseNumericalTopic(IRCMessage *message) {
     IRCChannel *channel = m_session->getChannel(message->param(1).lower());
     if (channel) {
         IRCOutput output(OUTPUT_TOPIC, tr("Topic for channel " + channel->channelname() + " is \"" + message->param(2) + "\""));
         output.addParam(channel);
         emit outputReady(output);
     } else {
         IRCOutput output(OUTPUT_TOPIC, tr("Topic for channel " + message->param(1) + " is \"" + message->param(2) + "\""));
         output.addParam(0);
         emit outputReady(output);
     }
 }
 
 void IRCMessageParser::parseNumericalTopicWhoTime(IRCMessage *) {
 }
+
+    
diff --git a/noncore/net/opieirc/ircmessageparser.h b/noncore/net/opieirc/ircmessageparser.h
index c4dd96c..5412f5f 100644
--- a/noncore/net/opieirc/ircmessageparser.h
+++ b/noncore/net/opieirc/ircmessageparser.h
@@ -1,99 +1,95 @@
 /*
     OpieIRC - An embedded IRC client
     Copyright (C) 2002 Wenzel Jakob
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 */
 
 #ifndef __IRCMESSAGEPARSER_H
 #define __IRCMESSAGEPARSER_H
 
 #include "ircsession.h"
 
 /* Macro to facilitate the parser table's creation */
 #define FUNC(__proc) &IRCMessageParser::__proc
 
 class IRCMessageParser;
 
 /* Typedef representing a parser function */
 typedef void (IRCMessageParser::*IRCMessageParseProc)(IRCMessage *);
 
 /* Struct representing a literal command handler */
 typedef struct IRCLiteralMessageParserStruct {
     char *commandName;
     IRCMessageParseProc proc;
 };
 
 /* Struct representing a ctcp command handler */
 typedef struct IRCCTCPMessageParserStruct {
     char *commandName;
     IRCMessageParseProc proc;
 };
 
 /* Struct representing a numerical command handler */
 typedef struct IRCNumericalMessageParserStruct {
     unsigned short commandNumber; 
     IRCMessageParseProc proc;
 };
 
 class IRCMessageParser : public QObject {
     Q_OBJECT
 public:
     /* Create an IRCMessageParser object */
     IRCMessageParser(IRCSession *session);
     /* Parse a server message and take the appropriate actions */
     void parse(IRCMessage *message);
 signals:
     /* Used to send commands to the UI (such as displaying text etc) */
     void outputReady(IRCOutput output);
 private:
     /* Parser functions */
     void nullFunc(IRCMessage *message);
     void parseLiteralPing(IRCMessage *message);
     void parseLiteralNotice(IRCMessage *message);
     void parseLiteralJoin(IRCMessage *message);
     void parseLiteralPrivMsg(IRCMessage *message);
     void parseLiteralNick(IRCMessage *message);
     void parseLiteralPart(IRCMessage *message);
     void parseLiteralQuit(IRCMessage *message);
     void parseLiteralError(IRCMessage *message);
     void parseLiteralMode(IRCMessage *message);
     void parseLiteralKick(IRCMessage *message);
     void parseLiteralTopic(IRCMessage *message);
-    void parseNumerical001(IRCMessage *message);
-    void parseNumerical002(IRCMessage *message);
-    void parseNumerical003(IRCMessage *message);
-    void parseNumerical004(IRCMessage *message);
-    void parseNumerical005(IRCMessage *message);
-    void parseNumericalStats(IRCMessage *message);
+    void parseNumericalSecondParam(IRCMessage *message);
+    void parseNumericalAllParams(IRCMessage *message);
     void parseNumericalNames(IRCMessage *message);
     void parseNumericalEndOfNames(IRCMessage *message);
     void parseNumericalNicknameInUse(IRCMessage *message);
     void parseNumericalNoSuchNick(IRCMessage *message);
     void parseNumericalTopic(IRCMessage *message);
     void parseNumericalTopicWhoTime(IRCMessage *message);
     void parseCTCPPing(IRCMessage *message);
     void parseCTCPVersion(IRCMessage *message);
     void parseCTCPAction(IRCMessage *message);
 protected:
     IRCSession *m_session;
     /* Parser tables */
     static IRCLiteralMessageParserStruct literalParserProcTable[];
     static IRCNumericalMessageParserStruct numericalParserProcTable[];
     static IRCCTCPMessageParserStruct ctcpParserProcTable[];
 };
 
 #endif /* __IRCMESSAGEPARSER_H */