/***************************************************************************
- * Copyright (C) 2005-07 by The Quassel Team *
+ * Copyright (C) 2005-08 by the Quassel Project *
* devel@quassel-irc.org *
* *
* 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. *
+ * (at your option) version 3. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
#include "ircchannel.h"
-#include "networkinfo.h"
+#include "network.h"
//#include "nicktreemodel.h"
#include "signalproxy.h"
#include "ircuser.h"
+#include "util.h"
#include <QMapIterator>
#include <QHashIterator>
+#include <QTextCodec>
#include <QDebug>
-IrcChannel::IrcChannel(const QString &channelname, NetworkInfo *networkinfo)
- : QObject(networkinfo),
+IrcChannel::IrcChannel(const QString &channelname, Network *network) : SyncableObject(network),
_initialized(false),
_name(channelname),
_topic(QString()),
- networkInfo(networkinfo)
+ network(network),
+ _codecForEncoding(0),
+ _codecForDecoding(0)
{
- setObjectName(QString::number(networkInfo->networkId()) + "/" + channelname);
+ setObjectName(QString::number(network->networkId().toInt()) + "/" + channelname);
}
IrcChannel::~IrcChannel() {
-
}
// ====================
// PUBLIC:
// ====================
bool IrcChannel::isKnownUser(IrcUser *ircuser) const {
- bool isknown = true;
-
if(ircuser == 0) {
qWarning() << "Channel" << name() << "received IrcUser Nullpointer!";
- isknown = false;
+ return false;
}
if(!_userModes.contains(ircuser)) {
qWarning() << "Channel" << name() << "received data for unknown User" << ircuser->nick();
- isknown = false;
+ return false;
}
-
- return isknown;
+
+ return true;
}
bool IrcChannel::isValidChannelUserMode(const QString &mode) const {
return isvalid;
}
-bool IrcChannel::initialized() const {
- return _initialized;
+QString IrcChannel::userModes(IrcUser *ircuser) const {
+ if(_userModes.contains(ircuser))
+ return _userModes[ircuser];
+ else
+ return QString();
+}
+
+QString IrcChannel::userModes(const QString &nick) const {
+ return userModes(network->ircUser(nick));
}
-QString IrcChannel::name() const {
- return _name;
+void IrcChannel::setCodecForEncoding(const QString &name) {
+ setCodecForEncoding(QTextCodec::codecForName(name.toAscii()));
}
-QString IrcChannel::topic() const {
- return _topic;
+void IrcChannel::setCodecForEncoding(QTextCodec *codec) {
+ _codecForEncoding = codec;
}
-QList<IrcUser *> IrcChannel::ircUsers() const {
- return _userModes.keys();
+void IrcChannel::setCodecForDecoding(const QString &name) {
+ setCodecForDecoding(QTextCodec::codecForName(name.toAscii()));
}
-QString IrcChannel::userModes(IrcUser *ircuser) const {
- if(_userModes.contains(ircuser))
- return _userModes[ircuser];
- else
- return QString();
+void IrcChannel::setCodecForDecoding(QTextCodec *codec) {
+ _codecForDecoding = codec;
}
-QString IrcChannel::userModes(const QString &nick) const {
- return userModes(networkInfo->ircUser(nick));
+QString IrcChannel::decodeString(const QByteArray &text) const {
+ if(!codecForDecoding()) return network->decodeString(text);
+ return ::decodeString(text, _codecForDecoding);
+}
+
+QByteArray IrcChannel::encodeString(const QString &string) const {
+ if(codecForEncoding()) {
+ return _codecForEncoding->fromUnicode(string);
+ }
+ return network->encodeString(string);
}
// ====================
emit topicSet(topic);
}
-void IrcChannel::join(IrcUser *ircuser) {
- if(!_userModes.contains(ircuser) && ircuser) {
- _userModes[ircuser] = QString();
- ircuser->joinChannel(name());
+void IrcChannel::setPassword(const QString &password) {
+ _password = password;
+ emit passwordSet(password);
+}
+
+void IrcChannel::joinIrcUsers(const QList<IrcUser *> &users, const QStringList &modes) {
+ if(users.isEmpty())
+ return;
+
+ if(users.count() != modes.count()) {
+ qWarning() << "IrcChannel::addUsers(): number of nicks does not match number of modes!";
+ return;
+ }
+
+ QStringList newNicks;
+ QStringList newModes;
+ QList<IrcUser *> newUsers;
+
+ IrcUser *ircuser;
+ for(int i = 0; i < users.count(); i++) {
+ ircuser = users[i];
+ if(!ircuser || _userModes.contains(ircuser))
+ continue;
+
+ _userModes[ircuser] = modes[i];
+ ircuser->joinChannel(this);
+ //qDebug() << "JOIN" << name() << ircuser->nick() << ircUsers().count();
connect(ircuser, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickSet(QString)));
connect(ircuser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed()));
// if you wonder why there is no counterpart to ircUserJoined:
// the joines are propagted by the ircuser. the signal ircUserJoined is only for convenience
- emit ircUserJoined(ircuser);
+
+ newNicks << ircuser->nick();
+ newModes << modes[i];
+ newUsers << ircuser;
}
+
+ if(newNicks.isEmpty())
+ return;
+
+ emit ircUsersJoined(newUsers);
+ emit ircUsersJoined(newNicks, newModes);
}
-void IrcChannel::join(const QString &nick) {
- join(networkInfo->ircUser(nick));
+void IrcChannel::joinIrcUsers(const QStringList &nicks, const QStringList &modes) {
+ QList<IrcUser *> users;
+ foreach(QString nick, nicks)
+ users << network->newIrcUser(nick);
+ joinIrcUsers(users, modes);
+}
+
+void IrcChannel::joinIrcUsers(IrcUser *ircuser) {
+ QList <IrcUser *> users;
+ users << ircuser;
+ QStringList modes;
+ modes << QString();
+ joinIrcUsers(users, modes);
+}
+
+void IrcChannel::joinIrcUsers(const QString &nick) {
+ joinIrcUsers(network->newIrcUser(nick));
}
void IrcChannel::part(IrcUser *ircuser) {
if(isKnownUser(ircuser)) {
_userModes.remove(ircuser);
- ircuser->partChannel(name());
+ ircuser->partChannel(this);
+ //qDebug() << "PART" << name() << ircuser->nick() << ircUsers().count();
// if you wonder why there is no counterpart to ircUserParted:
// the joines are propagted by the ircuser. the signal ircUserParted is only for convenience
+ disconnect(ircuser, 0, this, 0);
emit ircUserParted(ircuser);
+ if(network->isMe(ircuser))
+ deleteLater();
}
}
void IrcChannel::part(const QString &nick) {
- part(networkInfo->ircUser(nick));
+ part(network->ircUser(nick));
}
// SET USER MODE
}
void IrcChannel::setUserModes(const QString &nick, const QString &modes) {
- setUserModes(networkInfo->ircUser(nick), modes);
+ setUserModes(network->ircUser(nick), modes);
}
// ADD USER MODE
}
void IrcChannel::addUserMode(const QString &nick, const QString &mode) {
- addUserMode(networkInfo->ircUser(nick), mode);
+ addUserMode(network->ircUser(nick), mode);
}
// REMOVE USER MODE
}
void IrcChannel::removeUserMode(const QString &nick, const QString &mode) {
- removeUserMode(networkInfo->ircUser(nick), mode);
+ removeUserMode(network->ircUser(nick), mode);
}
// INIT SET USER MODES
IrcUser *ircUser = static_cast<IrcUser *>(sender());
Q_ASSERT(ircUser);
_userModes.remove(ircUser);
- emit ircUserParted(ircUser);
+ // no further propagation.
+ // this leads only to fuck ups.
}
void IrcChannel::ircUserNickSet(QString nick) {
emit ircUserNickSet(ircUser, nick);
}
-void IrcChannel::setInitialized() {
- _initialized = true;
- emit initDone();
-}
-
projects / quassel.git / blobdiff