stuff in the handlers and switched putCmd() et. al. to accepting (encoded) QByteArray only instead
of QString.
Also fixed notices being shown in a separate buffer upon reconnect, and the kick message problem (BR #99).
Oh, and the default kick reason defined in your identity is used if appropriate now.
void Network::setConnected(bool connected) {
_connected = connected;
- if(!connected)
+ if(!connected) {
removeChansAndUsers();
+ setCurrentServer(QString());
+ }
emit connectedSet(connected);
}
BasicHandler::BasicHandler(NetworkConnection *parent)
: QObject(parent),
- server(parent),
defaultHandler(-1),
+ _networkConnection(parent),
initDone(false)
{
connect(this, SIGNAL(displayMsg(Message::Type, BufferInfo::Type, QString, QString, QString, quint8)),
- server, SIGNAL(displayMsg(Message::Type, BufferInfo::Type, QString, QString, QString, quint8)));
+ networkConnection(), SIGNAL(displayMsg(Message::Type, BufferInfo::Type, QString, QString, QString, quint8)));
- connect(this, SIGNAL(putCmd(QString, QStringList, QString)),
- server, SLOT(putCmd(QString, QStringList, QString)));
+ connect(this, SIGNAL(putCmd(QString, const QVariantList &, const QByteArray &)),
+ networkConnection(), SLOT(putCmd(QString, const QVariantList &, const QByteArray &)));
- connect(this, SIGNAL(putRawLine(QString)),
- server, SLOT(putRawLine(QString)));
+ connect(this, SIGNAL(putRawLine(const QByteArray &)),
+ networkConnection(), SLOT(putRawLine(const QByteArray &)));
}
QStringList BasicHandler::providesHandlers() {
qt_metacall(QMetaObject::InvokeMetaMethod, handlerHash()[handler], param);
}
+QString BasicHandler::serverDecode(const QByteArray &string) {
+ return networkConnection()->serverDecode(string);
+}
+
+QStringList BasicHandler::serverDecode(const QList<QByteArray> &stringlist) {
+ QStringList list;
+ foreach(QByteArray s, stringlist) list << networkConnection()->serverDecode(s);
+ return list;
+}
+
+QString BasicHandler::bufferDecode(const QString &bufferName, const QByteArray &string) {
+ return networkConnection()->bufferDecode(bufferName, string);
+}
+
+QStringList BasicHandler::bufferDecode(const QString &bufferName, const QList<QByteArray> &stringlist) {
+ QStringList list;
+ foreach(QByteArray s, stringlist) list << networkConnection()->bufferDecode(bufferName, s);
+ return list;
+}
+
+QString BasicHandler::userDecode(const QString &userNick, const QByteArray &string) {
+ return networkConnection()->userDecode(userNick, string);
+}
+
+QStringList BasicHandler::userDecode(const QString &userNick, const QList<QByteArray> &stringlist) {
+ QStringList list;
+ foreach(QByteArray s, stringlist) list << networkConnection()->userDecode(userNick, s);
+ return list;
+}
+
+/*** ***/
+
+QByteArray BasicHandler::serverEncode(const QString &string) {
+ return networkConnection()->serverEncode(string);
+}
+
+QList<QByteArray> BasicHandler::serverEncode(const QStringList &stringlist) {
+ QList<QByteArray> list;
+ foreach(QString s, stringlist) list << networkConnection()->serverEncode(s);
+ return list;
+}
+
+QByteArray BasicHandler::bufferEncode(const QString &bufferName, const QString &string) {
+ return networkConnection()->bufferEncode(bufferName, string);
+}
+
+QList<QByteArray> BasicHandler::bufferEncode(const QString &bufferName, const QStringList &stringlist) {
+ QList<QByteArray> list;
+ foreach(QString s, stringlist) list << networkConnection()->bufferEncode(bufferName, s);
+ return list;
+}
+
+QByteArray BasicHandler::userEncode(const QString &userNick, const QString &string) {
+ return networkConnection()->userEncode(userNick, string);
+}
+
+QList<QByteArray> BasicHandler::userEncode(const QString &userNick, const QStringList &stringlist) {
+ QList<QByteArray> list;
+ foreach(QString s, stringlist) list << networkConnection()->userEncode(userNick, s);
+ return list;
+}
+
// ====================
// protected:
// ====================
+
Network *BasicHandler::network() const {
- return server->network();
+ return networkConnection()->network();
+}
+
+NetworkConnection *BasicHandler::networkConnection() const {
+ return _networkConnection;
}
BufferInfo::Type BasicHandler::typeByTarget(const QString &target) const {
return BufferInfo::QueryBuffer;
}
+
+void BasicHandler::putCmd(const QString &cmd, const QByteArray ¶m, const QByteArray &prefix) {
+ QVariantList list;
+ list << param;
+ emit putCmd(cmd, list, prefix);
+}
+
+void BasicHandler::putCmd(const QString &cmd, const QList<QByteArray> ¶ms, const QByteArray &prefix) {
+ QVariantList list;
+ foreach(QByteArray param, params) list << param;
+ emit putCmd(cmd, list, prefix);
+}
QStringList providesHandlers();
+ QString serverDecode(const QByteArray &string);
+ QStringList serverDecode(const QList<QByteArray> &stringlist);
+ QString bufferDecode(const QString &bufferName, const QByteArray &string);
+ QStringList bufferDecode(const QString &bufferName, const QList<QByteArray> &stringlist);
+ QString userDecode(const QString &userNick, const QByteArray &string);
+ QStringList userDecode(const QString &userNick, const QList<QByteArray> &stringlist);
+
+ QByteArray serverEncode(const QString &string);
+ QList<QByteArray> serverEncode(const QStringList &stringlist);
+ QByteArray bufferEncode(const QString &bufferName, const QString &string);
+ QList<QByteArray> bufferEncode(const QString &bufferName, const QStringList &stringlist);
+ QByteArray userEncode(const QString &userNick, const QString &string);
+ QList<QByteArray> userEncode(const QString &userNick, const QStringList &stringlist);
+
signals:
void displayMsg(Message::Type, BufferInfo::Type, QString target, QString text, QString sender = "", quint8 flags = Message::None);
- void putCmd(QString cmd, QStringList params, QString prefix = 0);
- void putRawLine(QString msg);
-
+ void putCmd(const QString &cmd, const QVariantList ¶ms, const QByteArray &prefix);
+ void putRawLine(const QByteArray &msg);
+
protected:
+ void putCmd(const QString &cmd, const QByteArray ¶m, const QByteArray &prefix = QByteArray());
+ void putCmd(const QString &cmd, const QList<QByteArray> ¶ms, const QByteArray &prefix = QByteArray());
+
virtual void handle(const QString &member, QGenericArgument val0 = QGenericArgument(0),
- QGenericArgument val1 = QGenericArgument(), QGenericArgument val2 = QGenericArgument(),
- QGenericArgument val3 = QGenericArgument(), QGenericArgument val4 = QGenericArgument(),
- QGenericArgument val5 = QGenericArgument(), QGenericArgument val6 = QGenericArgument(),
- QGenericArgument val7 = QGenericArgument(), QGenericArgument val8 = QGenericArgument());
-
- NetworkConnection *server;
+ QGenericArgument val1 = QGenericArgument(), QGenericArgument val2 = QGenericArgument(),
+ QGenericArgument val3 = QGenericArgument(), QGenericArgument val4 = QGenericArgument(),
+ QGenericArgument val5 = QGenericArgument(), QGenericArgument val6 = QGenericArgument(),
+ QGenericArgument val7 = QGenericArgument(), QGenericArgument val8 = QGenericArgument());
+
- Network *network() const;
+ Network * network() const;
+ NetworkConnection * networkConnection() const;
BufferInfo::Type typeByTarget(const QString &target) const;
private:
const QHash<QString, int> &handlerHash();
QHash<QString, int> _handlerHash;
int defaultHandler;
+ NetworkConnection *_networkConnection;
bool initDone;
};
#endif
return XDELIM + ctcpTag + ' ' + message + XDELIM;
}
+// TODO handle encodings correctly!
void CtcpHandler::query(QString bufname, QString ctcpTag, QString message) {
QStringList params;
params << bufname << pack(ctcpTag, message);
- emit putCmd("PRIVMSG", params);
+ emit putCmd("PRIVMSG", serverEncode(params));
}
void CtcpHandler::reply(QString bufname, QString ctcpTag, QString message) {
QStringList params;
params << bufname << pack(ctcpTag, message);
- emit putCmd("NOTICE", params);
+ emit putCmd("NOTICE", serverEncode(params));
}
//******************************/
#include <QDebug>
-IrcServerHandler::IrcServerHandler(NetworkConnection *parent)
- : BasicHandler(parent),
- networkConnection(parent) {
- _whois = false;
+IrcServerHandler::IrcServerHandler(NetworkConnection *parent) : BasicHandler(parent) {
+ _whois = false;
}
IrcServerHandler::~IrcServerHandler() {
}
-QString IrcServerHandler::serverDecode(const QByteArray &string) {
- return networkConnection->serverDecode(string);
-}
-
-QStringList IrcServerHandler::serverDecode(const QList<QByteArray> &stringlist) {
- QStringList list;
- foreach(QByteArray s, stringlist) list << networkConnection->serverDecode(s);
- return list;
-}
-
-QString IrcServerHandler::bufferDecode(const QString &bufferName, const QByteArray &string) {
- return networkConnection->bufferDecode(bufferName, string);
-}
-
-QStringList IrcServerHandler::bufferDecode(const QString &bufferName, const QList<QByteArray> &stringlist) {
- QStringList list;
- foreach(QByteArray s, stringlist) list << networkConnection->bufferDecode(bufferName, s);
- return list;
-}
-
-QString IrcServerHandler::userDecode(const QString &userNick, const QByteArray &string) {
- return networkConnection->userDecode(userNick, string);
-}
-
-QStringList IrcServerHandler::userDecode(const QString &userNick, const QList<QByteArray> &stringlist) {
- QStringList list;
- foreach(QByteArray s, stringlist) list << networkConnection->userDecode(userNick, s);
- return list;
-}
-
/*! Handle a raw message string sent by the server. We try to find a suitable handler, otherwise we call a default handler. */
void IrcServerHandler::handleServerMsg(QByteArray msg) {
try {
void IrcServerHandler::handleNotice(QString prefix, QList<QByteArray> params) {
if(params.count() < 2) {
- qWarning() << "IrcServerHandler::handleNotice(): not enoug Parameters:" << prefix << serverDecode(params);
+ qWarning() << "IrcServerHandler::handleNotice(): not enough Parameters:" << prefix << serverDecode(params);
return;
}
? nickFromMask(prefix)
: prefix;
- networkConnection->ctcpHandler()->parse(Message::Notice, sender, target, userDecode(prefix, params[1]));
+ networkConnection()->ctcpHandler()->parse(Message::Notice, sender, target, userDecode(prefix, params[1]));
}
void IrcServerHandler::handlePart(QString prefix, QList<QByteArray> params) {
void IrcServerHandler::handlePing(QString prefix, QList<QByteArray> params) {
Q_UNUSED(prefix);
- emit putCmd("PONG", serverDecode(params));
+ putCmd("PONG", params);
}
void IrcServerHandler::handlePrivmsg(QString prefix, QList<QByteArray> params) {
// it's possible to pack multiple privmsgs into one param using ctcp
// - > we let the ctcpHandler do the work
- networkConnection->ctcpHandler()->parse(Message::Plain, prefix, target, userDecode(ircuser->nick(), params[1]));
+ networkConnection()->ctcpHandler()->parse(Message::Plain, prefix, target, userDecode(ircuser->nick(), params[1]));
}
void IrcServerHandler::handleQuit(QString prefix, QList<QByteArray> params) {
// if there is a problem while connecting to the server -> we handle it
// but only if our connection has not been finished yet...
- if(!networkConnection->network()->currentServer().isEmpty())
+ if(!network()->currentServer().isEmpty())
return;
tryNextNick(errnick);
}
void IrcServerHandler::tryNextNick(const QString &errnick) {
- QStringList desiredNicks = networkConnection->coreSession()->identity(networkConnection->network()->identity())->nicks();
+ QStringList desiredNicks = networkConnection()->coreSession()->identity(network()->identity())->nicks();
int nextNick = desiredNicks.indexOf(errnick) + 1;
if(desiredNicks.size() > nextNick) {
- putCmd("NICK", QStringList(desiredNicks[nextNick]));
+ putCmd("NICK", serverEncode(desiredNicks[nextNick]));
} else {
emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", tr("No free and valid nicks in nicklist found. use: /nick <othernick> to continue"));
}
void handleServerMsg(QByteArray rawMsg);
- QString serverDecode(const QByteArray &string);
- QStringList serverDecode(const QList<QByteArray> &stringlist);
- QString bufferDecode(const QString &bufferName, const QByteArray &string);
- QStringList bufferDecode(const QString &bufferName, const QList<QByteArray> &stringlist);
- QString userDecode(const QString &userNick, const QByteArray &string);
- QStringList userDecode(const QString &userNick, const QList<QByteArray> &stringlist);
-
-
public slots:
void handleJoin(QString, QList<QByteArray>);
void handleKick(QString, QList<QByteArray>);
private:
void tryNextNick(const QString &errnick);
bool _whois;
- NetworkConnection *networkConnection;
};
_ctcpHandler(new CtcpHandler(this)),
_previousState(state)
{
- connect(network, SIGNAL(currentServerSet(const QString &)), this, SLOT(networkInitialized()));
+ connect(network, SIGNAL(currentServerSet(const QString &)), this, SLOT(networkInitialized(const QString &)));
connect(&socket, SIGNAL(connected()), this, SLOT(socketConnected()));
connect(&socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected()));
return network()->networkName();
}
+Identity *NetworkConnection::identity() const {
+ return coreSession()->identity(network()->identity());
+}
+
Network *NetworkConnection::network() const {
return _network;
}
socket.connectToHost(host, port);
}
-void NetworkConnection::networkInitialized() {
+void NetworkConnection::networkInitialized(const QString ¤tServer) {
+ if(currentServer.isEmpty()) return;
+
sendPerform();
// rejoin channels we've been in
QStringList chans = _previousState.toStringList();
if(chans.count() > 0) {
qDebug() << "autojoining" << chans;
- QString list = chans.join(",");
- putCmd("join", QStringList(list)); // FIXME check for 512 byte limit!
+ QVariantList list;
+ foreach(QString chan, chans) list << serverEncode(chan);
+ putCmd("JOIN", list); // FIXME check for 512 byte limit!
}
// delete _previousState, we won't need it again
_previousState = QVariant();
disconnectFromIrc();
return;
}
- putRawLine(QString("NICK :%1").arg(identity->nicks()[0])); // FIXME: try more nicks if error occurs
- putRawLine(QString("USER %1 8 * :%2").arg(identity->ident(), identity->realName()));
+ putRawLine(serverEncode(QString("NICK :%1").arg(identity->nicks()[0]))); // FIXME: try more nicks if error occurs
+ putRawLine(serverEncode(QString("USER %1 8 * :%2").arg(identity->ident(), identity->realName())));
}
void NetworkConnection::socketStateChanged(QAbstractSocket::SocketState socketState) {
userInputHandler()->handleUserInput(buf, msg);
}
-void NetworkConnection::putRawLine(QString s) {
+void NetworkConnection::putRawLine(QByteArray s) {
s += "\r\n";
- socket.write(s.toAscii());
+ socket.write(s);
}
-void NetworkConnection::putCmd(QString cmd, QStringList params, QString prefix) {
- QString msg;
+void NetworkConnection::putCmd(const QString &cmd, const QVariantList ¶ms, const QByteArray &prefix) {
+ QByteArray msg;
if(!prefix.isEmpty())
msg += ":" + prefix + " ";
- msg += cmd.toUpper();
-
+ msg += cmd.toUpper().toAscii();
+
for(int i = 0; i < params.size() - 1; i++) {
- msg += " " + params[i];
+ msg += " " + params[i].toByteArray();
}
if(!params.isEmpty())
- msg += " :" + params.last();
+ msg += " :" + params.last().toByteArray();
putRawLine(msg);
}
#include <QTcpSocket>
#include <QTimer>
+#include "identity.h"
#include "message.h"
#include "network.h"
#include "signalproxy.h"
NetworkId networkId() const;
QString networkName() const;
Network *network() const;
+ Identity *identity() const;
CoreSession *coreSession() const;
bool isConnected() const;
void disconnectFromIrc();
void userInput(BufferInfo bufferInfo, QString msg);
- void putRawLine(QString input);
- void putCmd(QString cmd, QStringList params, QString prefix = 0);
+ void putRawLine(QByteArray input);
+ void putCmd(const QString &cmd, const QVariantList ¶ms, const QByteArray &prefix = QByteArray());
private slots:
void socketDisconnected();
void socketStateChanged(QAbstractSocket::SocketState);
void setConnectionState(Network::ConnectionState);
- void networkInitialized();
+ void networkInitialized(const QString ¤tServer);
private:
QTcpSocket socket;
UserInputHandler *_userInputHandler;
CtcpHandler *_ctcpHandler;
- QVariantMap networkSettings;
- QVariantMap identity;
-
QVariant _previousState;
class ParseError : public Exception {
#include <QDebug>
-UserInputHandler::UserInputHandler(NetworkConnection *parent)
- : BasicHandler(parent) {
+UserInputHandler::UserInputHandler(NetworkConnection *parent) : BasicHandler(parent) {
}
void UserInputHandler::handleUserInput(const BufferInfo &bufferInfo, const QString &msg_) {
void UserInputHandler::handleAway(const BufferInfo &bufferInfo, const QString &msg) {
Q_UNUSED(bufferInfo)
- emit putCmd("AWAY", QStringList(msg));
+ putCmd("AWAY", serverEncode(msg));
}
void UserInputHandler::handleBan(const BufferInfo &bufferInfo, const QString &msg) {
//TODO: find suitable default hostmask if msg gives only nickname
// Example: MODE &oulu +b *!*@*
- QStringList banMsg(bufferInfo.bufferName()+" +b "+msg);
+ QByteArray banMsg = serverEncode(bufferInfo.bufferName()) + " +b " + bufferEncode(bufferInfo.bufferName(), msg);
emit putCmd("MODE", banMsg);
}
QString ctcpTag = msg.section(' ', 1, 1).toUpper();
if (ctcpTag.isEmpty()) return;
QString message = "";
- QString verboseMessage = tr("sending CTCP-%1-request").arg(ctcpTag);
+ QString verboseMessage = tr("sending CTCP-%1 request").arg(ctcpTag);
if(ctcpTag == "PING") {
uint now = QDateTime::currentDateTime().toTime_t();
message = QString::number(now);
}
- server->ctcpHandler()->query(nick, ctcpTag, message);
+ networkConnection()->ctcpHandler()->query(nick, ctcpTag, message);
emit displayMsg(Message::Action, BufferInfo::StatusBuffer, "", verboseMessage, network()->myNick());
}
QString m = "-"; for(int i = 0; i < nicks.count(); i++) m += 'o';
QStringList params;
params << bufferInfo.bufferName() << m << nicks;
- emit putCmd("MODE", params);
+ emit putCmd("MODE", serverEncode(params));
}
void UserInputHandler::handleDevoice(const BufferInfo &bufferInfo, const QString &msg) {
QString m = "-"; for(int i = 0; i < nicks.count(); i++) m += 'v';
QStringList params;
params << bufferInfo.bufferName() << m << nicks;
- emit putCmd("MODE", params);
+ emit putCmd("MODE", serverEncode(params));
}
void UserInputHandler::handleInvite(const BufferInfo &bufferInfo, const QString &msg) {
QStringList params;
params << msg << bufferInfo.bufferName();
- emit putCmd("INVITE", params);
+ emit putCmd("INVITE", serverEncode(params));
}
void UserInputHandler::handleJ(const BufferInfo &bufferInfo, const QString &msg) {
if(params.size() > 0 && !params[0].startsWith("#")) {
params[0] = QString("#%1").arg(params[0]);
}
- emit putCmd("JOIN", params);
+ emit putCmd("JOIN", serverEncode(params));
}
void UserInputHandler::handleJoin(const BufferInfo &bufferInfo, const QString &msg) {
Q_UNUSED(bufferInfo)
- emit putCmd("JOIN", msg.split(" "));
+ QStringList params = msg.split(" ");
+ emit putCmd("JOIN", serverEncode(params));
}
void UserInputHandler::handleKick(const BufferInfo &bufferInfo, const QString &msg) {
- QStringList params;
- params << bufferInfo.bufferName() << msg.split(' ', QString::SkipEmptyParts);
+ QString nick = msg.section(' ', 0, 0, QString::SectionSkipEmpty);
+ QString reason = msg.section(' ', 1, -1, QString::SectionSkipEmpty).trimmed();
+ if(reason.isEmpty()) reason = networkConnection()->identity()->kickReason();
+ QList<QByteArray> params;
+ params << serverEncode(bufferInfo.bufferName()) << serverEncode(nick) << bufferEncode(bufferInfo.bufferName(), reason);
emit putCmd("KICK", params);
}
void UserInputHandler::handleList(const BufferInfo &bufferInfo, const QString &msg) {
Q_UNUSED(bufferInfo)
- emit putCmd("LIST", msg.split(' ', QString::SkipEmptyParts));
+ emit putCmd("LIST", serverEncode(msg.split(' ', QString::SkipEmptyParts)));
}
void UserInputHandler::handleMe(const BufferInfo &bufferInfo, const QString &msg) {
if(bufferInfo.bufferName().isEmpty()) return; // server buffer
- server->ctcpHandler()->query(bufferInfo.bufferName(), "ACTION", msg);
+ networkConnection()->ctcpHandler()->query(bufferInfo.bufferName(), "ACTION", bufferEncode(bufferInfo.bufferName(), msg));
emit displayMsg(Message::Action, bufferInfo.type(), bufferInfo.bufferName(), msg, network()->myNick());
}
void UserInputHandler::handleMode(const BufferInfo &bufferInfo, const QString &msg) {
Q_UNUSED(bufferInfo)
- emit putCmd("MODE", msg.split(' ', QString::SkipEmptyParts));
+ // TODO handle correct encoding for buffer modes (bufferEncode())
+ emit putCmd("MODE", serverEncode(msg.split(' ', QString::SkipEmptyParts)));
}
// TODO: show privmsgs
void UserInputHandler::handleMsg(const BufferInfo &bufferInfo, const QString &msg) {
- Q_UNUSED(bufferInfo)
+ Q_UNUSED(bufferInfo);
if(!msg.contains(' '))
return;
-
- QStringList params;
- params << msg.section(' ', 0, 0);
- params << msg.section(' ', 1);
+
+ QList<QByteArray> params;
+ params << serverEncode(msg.section(' ', 0, 0));
+ params << userEncode(params[0], msg.section(' ', 1));
emit putCmd("PRIVMSG", params);
}
void UserInputHandler::handleNick(const BufferInfo &bufferInfo, const QString &msg) {
Q_UNUSED(bufferInfo)
QString nick = msg.section(' ', 0, 0);
- emit putCmd("NICK", QStringList(nick));
+ emit putCmd("NICK", serverEncode(nick));
}
void UserInputHandler::handleOp(const BufferInfo &bufferInfo, const QString &msg) {
QString m = "+"; for(int i = 0; i < nicks.count(); i++) m += 'o';
QStringList params;
params << bufferInfo.bufferName() << m << nicks;
- emit putCmd("MODE", params);
+ emit putCmd("MODE", serverEncode(params));
}
void UserInputHandler::handlePart(const BufferInfo &bufferInfo, const QString &msg) {
- QStringList params;
- params << bufferInfo.bufferName() << msg;
+ QList<QByteArray> params;
+ params << serverEncode(bufferInfo.bufferName()) << bufferEncode(bufferInfo.bufferName(), msg);
emit putCmd("PART", params);
}
void UserInputHandler::handleQuit(const BufferInfo &bufferInfo, const QString &msg) {
Q_UNUSED(bufferInfo)
- emit putCmd("QUIT", QStringList(msg));
+ emit putCmd("QUIT", serverEncode(msg));
}
void UserInputHandler::handleQuote(const BufferInfo &bufferInfo, const QString &msg) {
Q_UNUSED(bufferInfo)
- emit putRawLine(msg);
+ emit putRawLine(serverEncode(msg));
}
void UserInputHandler::handleSay(const BufferInfo &bufferInfo, const QString &msg) {
if(bufferInfo.bufferName().isEmpty()) return; // server buffer
- QStringList params;
- params << bufferInfo.bufferName() << msg;
+ QList<QByteArray> params;
+ params << serverEncode(bufferInfo.bufferName()) << bufferEncode(bufferInfo.bufferName(), msg);
emit putCmd("PRIVMSG", params);
- emit displayMsg(Message::Plain, bufferInfo.type(), params[0], msg, network()->myNick(), Message::Self);
+ emit displayMsg(Message::Plain, bufferInfo.type(), bufferInfo.bufferName(), msg, network()->myNick(), Message::Self);
}
void UserInputHandler::handleTopic(const BufferInfo &bufferInfo, const QString &msg) {
if(bufferInfo.bufferName().isEmpty()) return;
- QStringList params;
- params << bufferInfo.bufferName() << msg;
+ QList<QByteArray> params;
+ params << serverEncode(bufferInfo.bufferName()) << bufferEncode(bufferInfo.bufferName(), msg);
emit putCmd("TOPIC", params);
}
QString m = "+"; for(int i = 0; i < nicks.count(); i++) m += 'v';
QStringList params;
params << bufferInfo.bufferName() << m << nicks;
- emit putCmd("MODE", params);
+ emit putCmd("MODE", serverEncode(params));
}
void UserInputHandler::handleWho(const BufferInfo &bufferInfo, const QString &msg) {
Q_UNUSED(bufferInfo)
- emit putCmd("WHO", msg.split(' '));
+ emit putCmd("WHO", serverEncode(msg.split(' ')));
}
void UserInputHandler::handleWhois(const BufferInfo &bufferInfo, const QString &msg) {
Q_UNUSED(bufferInfo)
- emit putCmd("WHOIS", msg.split(' '));
+ emit putCmd("WHOIS", serverEncode(msg.split(' ')));
}
void UserInputHandler::handleWhowas(const BufferInfo &bufferInfo, const QString &msg) {
Q_UNUSED(bufferInfo)
- emit putCmd("WHOWAS", msg.split(' '));
+ emit putCmd("WHOWAS", serverEncode(msg.split(' ')));
}
void UserInputHandler::defaultHandler(QString cmd, const BufferInfo &bufferInfo, const QString &msg) {
<bool>true</bool>
</property>
<property name="echoMode" >
- <enum>QLineEdit::PasswordEchoOnEdit</enum>
+ <enum>QLineEdit::Password</enum>
</property>
</widget>
</item>