QTextCodec *Network::_defaultCodecForServer = 0;
QTextCodec *Network::_defaultCodecForEncoding = 0;
QTextCodec *Network::_defaultCodecForDecoding = 0;
+
+Network::Server Network::Server::fromVariant(const QVariant &variant) {
+ QVariantMap serverMap = variant.toMap();
+ return Server(serverMap["Host"].toString(), serverMap["Port"].toUInt(), serverMap["Password"].toString(), serverMap["UseSSL"].toBool());
+}
+
+QVariant Network::Server::toVariant() const {
+ QVariantMap serverMap;
+ serverMap["Host"] = host;
+ serverMap["Port"] = port;
+ serverMap["Password"] = password;
+ serverMap["UseSSL"] = useSsl;
+ return QVariant::fromValue<QVariantMap>(serverMap);
+}
+
// ====================
// Public:
// ====================
_networkId(networkid),
_identity(0),
_myNick(QString()),
+ _latency(0),
_networkName(QString("<not initialized>")),
_currentServer(QString()),
_connected(false),
_unlimitedReconnectRetries(false),
_codecForServer(0),
_codecForEncoding(0),
- _codecForDecoding(0)
+ _codecForDecoding(0),
+ _autoAwayActive(false)
{
setObjectName(QString::number(networkid.toInt()));
}
bool Network::isChannelName(const QString &channelname) const {
if(channelname.isEmpty())
return false;
-
+
if(supports("CHANTYPES"))
return support("CHANTYPES").contains(channelname[0]);
else
info.codecForServer = codecForServer();
info.codecForEncoding = codecForEncoding();
info.codecForDecoding = codecForDecoding();
- info.serverList = serverList();
+ info.serverList = variantServerList();
info.useRandomServer = useRandomServer();
info.perform = perform();
info.useAutoIdentify = useAutoIdentify();
return nicks;
}
+QVariantList Network::variantServerList() const {
+ QVariantList servers;
+ ServerList::const_iterator serverIter = _serverList.constBegin();
+ while(serverIter != _serverList.constEnd()) {
+ servers << serverIter->toVariant();
+ serverIter++;
+ }
+ return servers;
+}
+
QString Network::prefixes() {
if(_prefixes.isNull())
determinePrefixes();
-
+
return _prefixes;
}
return _prefixModes;
}
-// example Unreal IRCD: CHANMODES=beI,kfL,lj,psmntirRcOAQKVCuzNSMTG
+// example Unreal IRCD: CHANMODES=beI,kfL,lj,psmntirRcOAQKVCuzNSMTG
Network::ChannelModeType Network::channelModeType(const QString &mode) {
if(mode.isEmpty())
return NOT_A_CHANMODE;
return QString();
}
-IrcUser *Network::newIrcUser(const QString &hostmask) {
+IrcUser *Network::newIrcUser(const QString &hostmask, const QVariantMap &initData) {
QString nick(nickFromMask(hostmask).toLower());
if(!_ircUsers.contains(nick)) {
IrcUser *ircuser = new IrcUser(hostmask, this);
+ if(!initData.isEmpty()) {
+ ircuser->fromVariantMap(initData);
+ ircuser->setInitialized();
+ }
if(proxy())
proxy()->synchronize(ircuser);
else
qWarning() << "unable to synchronize new IrcUser" << hostmask << "forgot to call Network::setProxy(SignalProxy *)?";
-
+
connect(ircuser, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickChanged(QString)));
- connect(ircuser, SIGNAL(initDone()), this, SLOT(ircUserInitDone()));
- connect(ircuser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed()));
+
_ircUsers[nick] = ircuser;
+
emit ircUserAdded(hostmask);
emit ircUserAdded(ircuser);
}
+
return _ircUsers[nick];
}
-void Network::ircUserDestroyed() {
- IrcUser *ircUser = static_cast<IrcUser *>(sender());
- if(!ircUser)
- return;
-
- QHash<QString, IrcUser *>::iterator ircUserIter = _ircUsers.begin();
- while(ircUserIter != _ircUsers.end()) {
- if(ircUser == *ircUserIter) {
- ircUserIter = _ircUsers.erase(ircUserIter);
- break;
- }
- ircUserIter++;
- }
+IrcUser *Network::ircUser(QString nickname) const {
+ nickname = nickname.toLower();
+ if(_ircUsers.contains(nickname))
+ return _ircUsers[nickname];
+ else
+ return 0;
}
void Network::removeIrcUser(IrcUser *ircuser) {
_ircUsers.remove(nick);
disconnect(ircuser, 0, this, 0);
- emit ircUserRemoved(nick);
- emit ircUserRemoved(ircuser);
ircuser->deleteLater();
}
-void Network::removeIrcUser(const QString &nick) {
- IrcUser *ircuser;
- if((ircuser = ircUser(nick)) != 0)
- removeIrcUser(ircuser);
+void Network::removeIrcChannel(IrcChannel *channel) {
+ QString chanName = _ircChannels.key(channel);
+ if(chanName.isNull())
+ return;
+
+ _ircChannels.remove(chanName);
+ disconnect(channel, 0, this, 0);
+ channel->deleteLater();
}
void Network::removeChansAndUsers() {
QList<IrcUser *> users = ircUsers();
- foreach(IrcUser *user, users) {
- removeIrcUser(user);
- }
+ _ircUsers.clear();
QList<IrcChannel *> channels = ircChannels();
+ _ircChannels.clear();
+
foreach(IrcChannel *channel, channels) {
- removeIrcChannel(channel);
+ proxy()->detachObject(channel);
+ disconnect(channel, 0, this, 0);
+ }
+ foreach(IrcUser *user, users) {
+ proxy()->detachObject(user);
+ disconnect(user, 0, this, 0);
}
-}
-IrcUser *Network::ircUser(QString nickname) const {
- nickname = nickname.toLower();
- if(_ircUsers.contains(nickname))
- return _ircUsers[nickname];
- else
- return 0;
+ // the second loop is needed because quit can have sideffects
+ foreach(IrcUser *user, users) {
+ user->quit();
+ }
+
+ qDeleteAll(users);
+ qDeleteAll(channels);
}
-IrcChannel *Network::newIrcChannel(const QString &channelname) {
+IrcChannel *Network::newIrcChannel(const QString &channelname, const QVariantMap &initData) {
if(!_ircChannels.contains(channelname.toLower())) {
- IrcChannel *channel = new IrcChannel(channelname, this);
+ IrcChannel *channel = ircChannelFactory(channelname);
+ if(!initData.isEmpty()) {
+ channel->fromVariantMap(initData);
+ channel->setInitialized();
+ }
if(proxy())
proxy()->synchronize(channel);
else
qWarning() << "unable to synchronize new IrcChannel" << channelname << "forgot to call Network::setProxy(SignalProxy *)?";
- connect(channel, SIGNAL(initDone()), this, SLOT(ircChannelInitDone()));
- connect(channel, SIGNAL(destroyed()), this, SLOT(channelDestroyed()));
_ircChannels[channelname.toLower()] = channel;
+
emit ircChannelAdded(channelname);
emit ircChannelAdded(channel);
}
void Network::setConnected(bool connected) {
if(_connected == connected)
return;
-
+
_connected = connected;
if(!connected) {
- removeChansAndUsers();
+ setMyNick(QString());
setCurrentServer(QString());
+ removeChansAndUsers();
}
emit connectedSet(connected);
}
void Network::setMyNick(const QString &nickname) {
_myNick = nickname;
+ if(!_myNick.isEmpty() && !ircUser(myNick())) {
+ newIrcUser(myNick());
+ }
emit myNickSet(nickname);
}
+void Network::setLatency(int latency) {
+ if(_latency == latency)
+ return;
+ _latency = latency;
+ emit latencySet(latency);
+}
+
void Network::setIdentity(IdentityId id) {
_identity = id;
emit identitySet(id);
}
void Network::setServerList(const QVariantList &serverList) {
- _serverList = serverList;
+ _serverList.clear();
+ foreach(QVariant variant, serverList) {
+ _serverList << Server::fromVariant(variant);
+ }
emit serverListSet(serverList);
}
return supports;
}
-QStringList Network::initIrcUsers() const {
- QStringList hostmasks;
- foreach(IrcUser *ircuser, ircUsers()) {
- hostmasks << ircuser->hostmask();
+QVariantMap Network::initIrcUsersAndChannels() const {
+ QVariantMap usersAndChannels;
+ QVariantMap users;
+ QVariantMap channels;
+
+ QHash<QString, IrcUser *>::const_iterator userIter = _ircUsers.constBegin();
+ QHash<QString, IrcUser *>::const_iterator userIterEnd = _ircUsers.constEnd();
+ while(userIter != userIterEnd) {
+ users[userIter.value()->hostmask()] = userIter.value()->toVariantMap();
+ userIter++;
+ }
+ usersAndChannels["users"] = users;
+
+ QHash<QString, IrcChannel *>::const_iterator channelIter = _ircChannels.constBegin();
+ QHash<QString, IrcChannel *>::const_iterator channelIterEnd = _ircChannels.constEnd();
+ while(channelIter != channelIterEnd) {
+ channels[channelIter.value()->name()] = channelIter.value()->toVariantMap();
+ channelIter++;
}
- return hostmasks;
+ usersAndChannels["channels"] = channels;
+
+ return usersAndChannels;
}
-QStringList Network::initIrcChannels() const {
- QStringList channels;
- QHash<QString, IrcChannel *>::const_iterator iter = _ircChannels.constBegin();
- while(iter != _ircChannels.constEnd()) {
- channels << iter.value()->name();
- iter++;
+void Network::initSetIrcUsersAndChannels(const QVariantMap &usersAndChannels) {
+ Q_ASSERT(proxy());
+ if(isInitialized()) {
+ qWarning() << "Network" << networkId() << "received init data for users and channels allthough there allready are known users or channels!";
+ return;
+ }
+
+ QVariantMap users = usersAndChannels.value("users").toMap();
+ QVariantMap::const_iterator userIter = users.constBegin();
+ QVariantMap::const_iterator userIterEnd = users.constEnd();
+ while(userIter != userIterEnd) {
+ newIrcUser(userIter.key(), userIter.value().toMap());
+ userIter++;
+ }
+
+ QVariantMap channels = usersAndChannels.value("channels").toMap();
+ QVariantMap::const_iterator channelIter = channels.constBegin();
+ QVariantMap::const_iterator channelIterEnd = channels.constEnd();
+ while(channelIter != channelIterEnd) {
+ newIrcChannel(channelIter.key(), channelIter.value().toMap());
+ channelIter++;
}
- return channels;
}
void Network::initSetSupports(const QVariantMap &supports) {
}
}
-void Network::initSetIrcUsers(const QStringList &hostmasks) {
- if(!_ircUsers.empty())
- return;
- foreach(QString hostmask, hostmasks) {
- newIrcUser(hostmask);
+void Network::initSetServerList(const QVariantList &serverList) {
+ foreach(QVariant variant, serverList) {
+ _serverList << Server::fromVariant(variant);
}
}
-void Network::initSetIrcChannels(const QStringList &channels) {
- if(!_ircChannels.empty())
- return;
- foreach(QString channel, channels)
- newIrcChannel(channel);
-}
-
IrcUser *Network::updateNickFromMask(const QString &mask) {
QString nick(nickFromMask(mask).toLower());
IrcUser *ircuser;
-
+
if(_ircUsers.contains(nick)) {
ircuser = _ircUsers[nick];
ircuser->updateHostmask(mask);
setMyNick(newnick);
}
-void Network::ircUserInitDone() {
- IrcUser *ircuser = static_cast<IrcUser *>(sender());
- Q_ASSERT(ircuser);
- emit ircUserInitDone(ircuser);
-}
-
-void Network::ircChannelInitDone() {
- IrcChannel *ircchannel = static_cast<IrcChannel *>(sender());
- Q_ASSERT(ircchannel);
- emit ircChannelInitDone(ircchannel);
-}
-
-void Network::removeIrcChannel(IrcChannel *channel) {
- QString chanName = _ircChannels.key(channel);
- if(chanName.isNull())
- return;
-
- _ircChannels.remove(chanName);
- disconnect(channel, 0, this, 0);
- emit ircChannelRemoved(chanName);
- emit ircChannelRemoved(channel);
- channel->deleteLater();
-}
-
-void Network::removeIrcChannel(const QString &channel) {
- IrcChannel *chan;
- if((chan = ircChannel(channel)) != 0)
- removeIrcChannel(chan);
-}
-
-void Network::channelDestroyed() {
- IrcChannel *channel = static_cast<IrcChannel *>(sender());
- Q_ASSERT(channel);
- _ircChannels.remove(_ircChannels.key(channel));
- emit ircChannelRemoved(channel);
-}
-
void Network::emitConnectionError(const QString &errorMsg) {
emit connectionError(errorMsg);
}
// ====================
void Network::determinePrefixes() {
// seems like we have to construct them first
- QString PREFIX = support("PREFIX");
-
- if(PREFIX.startsWith("(") && PREFIX.contains(")")) {
- _prefixes = PREFIX.section(")", 1);
- _prefixModes = PREFIX.mid(1).section(")", 0, 0);
+ QString prefix = support("PREFIX");
+
+ if(prefix.startsWith("(") && prefix.contains(")")) {
+ _prefixes = prefix.section(")", 1);
+ _prefixModes = prefix.mid(1).section(")", 0, 0);
} else {
QString defaultPrefixes("~&@%+");
QString defaultPrefixModes("qaohv");
+ if(prefix.isEmpty()) {
+ _prefixes = defaultPrefixes;
+ _prefixModes = defaultPrefixModes;
+ return;
+ }
+
// we just assume that in PREFIX are only prefix chars stored
for(int i = 0; i < defaultPrefixes.size(); i++) {
- if(PREFIX.contains(defaultPrefixes[i])) {
+ if(prefix.contains(defaultPrefixes[i])) {
_prefixes += defaultPrefixes[i];
_prefixModes += defaultPrefixModes[i];
}
// check for success
if(!_prefixes.isNull())
return;
-
+
// well... our assumption was obviously wrong...
// check if it's only prefix modes
for(int i = 0; i < defaultPrefixes.size(); i++) {
- if(PREFIX.contains(defaultPrefixModes[i])) {
+ if(prefix.contains(defaultPrefixModes[i])) {
_prefixes += defaultPrefixes[i];
_prefixModes += defaultPrefixModes[i];
}
projects / quassel.git / blobdiff