/***************************************************************************
- * Copyright (C) 2005-08 by the Quassel Project *
+ * Copyright (C) 2005-09 by the Quassel Project *
* devel@quassel-irc.org *
* *
* This program is free software; you can redistribute it and/or modify *
#include <QDebug>
-
+INIT_SYNCABLE_OBJECT(IrcChannel)
IrcChannel::IrcChannel(const QString &channelname, Network *network)
: SyncableObject(network),
_initialized(false),
_name(channelname),
_topic(QString()),
- network(network),
+ _network(network),
_codecForEncoding(0),
_codecForDecoding(0)
{
setObjectName(QString::number(network->networkId().toInt()) + "/" + channelname);
}
+IrcChannel::~IrcChannel() {
+}
+
// ====================
// PUBLIC:
// ====================
qWarning() << "Channel" << name() << "received IrcUser Nullpointer!";
return false;
}
-
+
if(!_userModes.contains(ircuser)) {
qWarning() << "Channel" << name() << "received data for unknown User" << ircuser->nick();
return false;
}
QString IrcChannel::userModes(const QString &nick) const {
- return userModes(network->ircUser(nick));
+ return userModes(network()->ircUser(nick));
}
void IrcChannel::setCodecForEncoding(const QString &name) {
}
QString IrcChannel::decodeString(const QByteArray &text) const {
- if(!codecForDecoding()) return network->decodeString(text);
+ if(!codecForDecoding()) return network()->decodeString(text);
return ::decodeString(text, _codecForDecoding);
}
if(codecForEncoding()) {
return _codecForEncoding->fromUnicode(string);
}
- return network->encodeString(string);
+ return network()->encodeString(string);
}
// ====================
// ====================
void IrcChannel::setTopic(const QString &topic) {
_topic = topic;
+ SYNC(ARG(topic))
emit topicSet(topic);
}
void IrcChannel::setPassword(const QString &password) {
_password = password;
- emit passwordSet(password);
+ SYNC(ARG(password))
}
void IrcChannel::joinIrcUsers(const QList<IrcUser *> &users, const QStringList &modes) {
IrcUser *ircuser;
for(int i = 0; i < users.count(); i++) {
ircuser = users[i];
- if(!ircuser || _userModes.contains(ircuser))
+ if(!ircuser || _userModes.contains(ircuser)) {
+ addUserMode(ircuser, modes[i]);
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()));
+
+ // 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
if(newNicks.isEmpty())
return;
-
+
+ SYNC_OTHER(joinIrcUsers, ARG(newNicks), ARG(newModes));
emit ircUsersJoined(newUsers);
- emit ircUsersJoined(newNicks, newModes);
}
void IrcChannel::joinIrcUsers(const QStringList &nicks, const QStringList &modes) {
QList<IrcUser *> users;
foreach(QString nick, nicks)
- users << network->newIrcUser(nick);
+ users << network()->newIrcUser(nick);
joinIrcUsers(users, modes);
}
-
-void IrcChannel::joinIrcUsers(IrcUser *ircuser) {
+
+void IrcChannel::joinIrcUser(IrcUser *ircuser) {
QList <IrcUser *> users;
users << ircuser;
QStringList modes;
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(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();
+
+ if(network()->isMe(ircuser) || _userModes.isEmpty()) {
+ // in either case we're no longer in the channel
+ // -> clean up the channel and destroy it
+ QList<IrcUser *> users = _userModes.keys();
+ _userModes.clear();
+ foreach(IrcUser *user, users) {
+ disconnect(user, 0, this, 0);
+ user->partChannel(this);
+ }
+ emit parted();
+ network()->removeIrcChannel(this);
+ }
}
}
void IrcChannel::part(const QString &nick) {
- part(network->ircUser(nick));
+ part(network()->ircUser(nick));
}
// SET USER MODE
void IrcChannel::setUserModes(IrcUser *ircuser, const QString &modes) {
if(isKnownUser(ircuser)) {
_userModes[ircuser] = modes;
- emit userModesSet(ircuser->nick(), modes);
+ QString nick = ircuser->nick();
+ SYNC_OTHER(setUserModes, ARG(nick), ARG(modes))
emit ircUserModesSet(ircuser, modes);
}
}
void IrcChannel::setUserModes(const QString &nick, const QString &modes) {
- setUserModes(network->ircUser(nick), modes);
+ setUserModes(network()->ircUser(nick), modes);
}
// ADD USER MODE
if(!_userModes[ircuser].contains(mode)) {
_userModes[ircuser] += mode;
- emit userModeAdded(ircuser->nick(), mode);
+ QString nick = ircuser->nick();
+ SYNC_OTHER(addUserMode, ARG(nick), ARG(mode))
emit ircUserModeAdded(ircuser, mode);
}
}
void IrcChannel::addUserMode(const QString &nick, const QString &mode) {
- addUserMode(network->ircUser(nick), mode);
+ addUserMode(network()->ircUser(nick), mode);
}
// REMOVE USER MODE
if(_userModes[ircuser].contains(mode)) {
_userModes[ircuser].remove(mode);
- emit userModeRemoved(ircuser->nick(), mode);
+ QString nick = ircuser->nick();
+ SYNC_OTHER(removeUserMode, ARG(nick), ARG(mode));
emit ircUserModeRemoved(ircuser, mode);
}
}
void IrcChannel::removeUserMode(const QString &nick, const QString &mode) {
- removeUserMode(network->ircUser(nick), mode);
+ removeUserMode(network()->ircUser(nick), mode);
}
// INIT SET USER MODES
QStringList modes;
QVariantMap::const_iterator iter = usermodes.constBegin();
while(iter != usermodes.constEnd()) {
- users << network->newIrcUser(iter.key());
+ users << network()->newIrcUser(iter.key());
modes << iter.value().toString();
iter++;
}
A_iter++;
}
channelModes["A"] = A_modes;
-
+
QVariantMap B_modes;
QHash<QChar, QString>::const_iterator B_iter = _B_channelModes.constBegin();
while(B_iter != _B_channelModes.constEnd()) {
B_iter++;
}
channelModes["B"] = B_modes;
-
+
QVariantMap C_modes;
QHash<QChar, QString>::const_iterator C_iter = _C_channelModes.constBegin();
while(C_iter != _C_channelModes.constEnd()) {
C_iter++;
}
channelModes["C"] = C_modes;
-
+
QString D_modes;
QSet<QChar>::const_iterator D_iter = _D_channelModes.constBegin();
while(D_iter != _D_channelModes.constEnd()) {
_B_channelModes[iter.key()[0]] = iter.value().toString();
iter++;
}
-
+
iter = channelModes["C"].toMap().constBegin();
iterEnd = channelModes["C"].toMap().constEnd();
while(iter != iterEnd) {
/*******************************************************************************
*
* 3.3 CHANMODES
- *
+ *
* o CHANMODES=A,B,C,D
- *
+ *
* The CHANMODES token specifies the modes that may be set on a channel.
* These modes are split into four categories, as follows:
- *
+ *
* o Type A: Modes that add or remove an address to or from a list.
* These modes always take a parameter when sent by the server to a
* client; when sent by a client, they may be specified without a
* mode is removed both in the client's and server's MODE command.
* o Type D: Modes that change a setting on the channel. These modes
* never take a parameter.
- *
+ *
* If the server sends any additional types after these 4, the client
* MUST ignore them; this is intended to allow future extension of this
* token.
- *
+ *
* The IRC server MUST NOT list modes in CHANMODES which are also
* present in the PREFIX parameter; however, for completeness, modes
* described in PREFIX may be treated as type B modes.
// NOTE: the behavior of addChannelMode and removeChannelMode depends on the type of mode
// see list above for chanmode types
void IrcChannel::addChannelMode(const QChar &mode, const QString &value) {
- Network::ChannelModeType modeType = network->channelModeType(mode);
+ Network::ChannelModeType modeType = network()->channelModeType(mode);
switch(modeType) {
case Network::NOT_A_CHANMODE:
else if(!_A_channelModes[mode].contains(value))
_A_channelModes[mode] << value;
break;
-
+
case Network::B_CHANMODE:
_B_channelModes[mode] = value;
break;
_D_channelModes << mode;
break;
}
- emit channelModeAdded(mode, value);
+ SYNC(ARG(mode), ARG(value))
}
void IrcChannel::removeChannelMode(const QChar &mode, const QString &value) {
- Network::ChannelModeType modeType = network->channelModeType(mode);
+ Network::ChannelModeType modeType = network()->channelModeType(mode);
switch(modeType) {
case Network::NOT_A_CHANMODE:
if(_A_channelModes.contains(mode))
_A_channelModes[mode].removeAll(value);
break;
-
+
case Network::B_CHANMODE:
_B_channelModes.remove(mode);
break;
_D_channelModes.remove(mode);
break;
}
- emit channelModeRemoved(mode, value);
+ SYNC(ARG(mode), ARG(value))
}
bool IrcChannel::hasMode(const QChar &mode) const {
- Network::ChannelModeType modeType = network->channelModeType(mode);
+ Network::ChannelModeType modeType = network()->channelModeType(mode);
switch(modeType) {
case Network::NOT_A_CHANMODE:
}
QString IrcChannel::modeValue(const QChar &mode) const {
- Network::ChannelModeType modeType = network->channelModeType(mode);
+ Network::ChannelModeType modeType = network()->channelModeType(mode);
switch(modeType) {
case Network::B_CHANMODE:
default:
return QString();
}
-
+
}
QStringList IrcChannel::modeValueList(const QChar &mode) const {
- Network::ChannelModeType modeType = network->channelModeType(mode);
+ Network::ChannelModeType modeType = network()->channelModeType(mode);
switch(modeType) {
case Network::A_CHANMODE:
projects / quassel.git / blobdiff