1 /***************************************************************************
2 * Copyright (C) 2005-08 by the Quassel Project *
3 * devel@quassel-irc.org *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) version 3. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #include "networkinfo.h"
22 #include "signalproxy.h"
24 #include "ircchannel.h"
31 // ====================
33 // ====================
34 NetworkInfo::NetworkInfo(const uint &networkid, QObject *parent)
35 : SyncableObject(parent),
36 _networkId(networkid),
39 _networkName(QString()),
40 _currentServer(QString()),
42 _prefixModes(QString()),
47 setObjectName(QString::number(networkid));
50 // I think this is unnecessary since IrcUsers have us as their daddy :)
51 //NetworkInfo::~NetworkInfo() {
52 // QHashIterator<QString, IrcUser *> ircuser(_ircUsers);
53 // while (ircuser.hasNext()) {
55 // delete ircuser.value();
59 uint NetworkInfo::networkId() const {
63 bool NetworkInfo::initialized() const {
67 SignalProxy *NetworkInfo::proxy() const {
71 void NetworkInfo::setProxy(SignalProxy *proxy) {
73 proxy->synchronize(this);
76 bool NetworkInfo::isMyNick(const QString &nick) const {
77 return (myNick().toLower() == nick.toLower());
80 bool NetworkInfo::isMyNick(IrcUser *ircuser) const {
81 return (ircuser->nick().toLower() == myNick().toLower());
84 bool NetworkInfo::isChannelName(const QString &channelname) const {
85 if(channelname.isEmpty())
88 if(supports("CHANTYPES"))
89 return support("CHANTYPES").contains(channelname[0]);
91 return QString("#&!+").contains(channelname[0]);
94 QString NetworkInfo::prefixToMode(const QString &prefix) {
95 if(prefixes().contains(prefix))
96 return QString(prefixModes()[prefixes().indexOf(prefix)]);
101 QString NetworkInfo::prefixToMode(const QCharRef &prefix) {
102 return prefixToMode(QString(prefix));
105 QString NetworkInfo::modeToPrefix(const QString &mode) {
106 if(prefixModes().contains(mode))
107 return QString(prefixes()[prefixModes().indexOf(mode)]);
112 QString NetworkInfo::modeToPrefix(const QCharRef &mode) {
113 return modeToPrefix(QString(mode));
116 QString NetworkInfo::networkName() const {
120 QString NetworkInfo::currentServer() const {
121 return _currentServer;
124 QString NetworkInfo::myNick() const {
128 QStringList NetworkInfo::nicks() const {
129 // we don't use _ircUsers.keys() since the keys may be
130 // not up to date after a nick change
132 foreach(IrcUser *ircuser, _ircUsers.values()) {
133 nicks << ircuser->nick();
138 QStringList NetworkInfo::channels() const {
139 return _ircChannels.keys();
142 QString NetworkInfo::prefixes() {
143 if(_prefixes.isNull())
149 QString NetworkInfo::prefixModes() {
150 if(_prefixModes.isNull())
156 bool NetworkInfo::supports(const QString ¶m) const {
157 return _supports.contains(param);
160 QString NetworkInfo::support(const QString ¶m) const {
161 QString support_ = param.toUpper();
162 if(_supports.contains(support_))
163 return _supports[support_];
168 IrcUser *NetworkInfo::newIrcUser(const QString &hostmask) {
169 QString nick(nickFromMask(hostmask).toLower());
170 if(!_ircUsers.contains(nick)) {
171 IrcUser *ircuser = new IrcUser(hostmask, this);
172 // mark IrcUser as already initialized to keep the SignalProxy from requesting initData
174 ircuser->setInitialized();
176 proxy()->synchronize(ircuser);
178 qWarning() << "unable to synchronize new IrcUser" << hostmask << "forgot to call NetworkInfo::setProxy(SignalProxy *)?";
180 connect(ircuser, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickChanged(QString)));
181 connect(ircuser, SIGNAL(initDone()), this, SIGNAL(ircUserInitDone()));
182 connect(ircuser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed()));
183 _ircUsers[nick] = ircuser;
184 emit ircUserAdded(hostmask);
186 return _ircUsers[nick];
189 IrcUser *NetworkInfo::newIrcUser(const QByteArray &hostmask) {
190 return newIrcUser(decodeString(hostmask));
193 void NetworkInfo::removeIrcUser(IrcUser *ircuser) {
194 QString nick = _ircUsers.key(ircuser);
198 _ircUsers.remove(nick);
199 ircuser->deleteLater();
200 emit ircUserRemoved(nick);
203 void NetworkInfo::removeIrcUser(QString nick) {
205 if((ircuser = ircUser(nick)) != 0)
206 removeIrcUser(ircuser);
209 IrcUser *NetworkInfo::ircUser(QString nickname) const {
210 nickname = nickname.toLower();
211 if(_ircUsers.contains(nickname))
212 return _ircUsers[nickname];
217 IrcUser *NetworkInfo::ircUser(const QByteArray &nickname) const {
218 return ircUser(decodeString(nickname));
221 QList<IrcUser *> NetworkInfo::ircUsers() const {
222 return _ircUsers.values();
225 IrcChannel *NetworkInfo::newIrcChannel(const QString &channelname) {
226 if(!_ircChannels.contains(channelname.toLower())) {
227 IrcChannel *channel = new IrcChannel(channelname, this);
228 // mark IrcUser as already initialized to keep the SignalProxy from requesting initData
230 channel->setInitialized();
233 proxy()->synchronize(channel);
235 qWarning() << "unable to synchronize new IrcChannel" << channelname << "forgot to call NetworkInfo::setProxy(SignalProxy *)?";
237 connect(channel, SIGNAL(initDone()), this, SIGNAL(ircChannelInitDone()));
238 connect(channel, SIGNAL(destroyed()), this, SLOT(channelDestroyed()));
239 _ircChannels[channelname.toLower()] = channel;
240 emit ircChannelAdded(channelname);
242 return _ircChannels[channelname.toLower()];
245 IrcChannel *NetworkInfo::newIrcChannel(const QByteArray &channelname) {
246 return newIrcChannel(decodeString(channelname));
249 IrcChannel *NetworkInfo::ircChannel(QString channelname) {
250 channelname = channelname.toLower();
251 if(_ircChannels.contains(channelname))
252 return _ircChannels[channelname];
257 IrcChannel *NetworkInfo::ircChannel(const QByteArray &channelname) {
258 return ircChannel(decodeString(channelname));
262 QList<IrcChannel *> NetworkInfo::ircChannels() const {
263 return _ircChannels.values();
266 QTextCodec *NetworkInfo::codecForEncoding() const {
267 return _codecForEncoding;
270 void NetworkInfo::setCodecForEncoding(const QString &name) {
271 setCodecForEncoding(QTextCodec::codecForName(name.toAscii()));
274 void NetworkInfo::setCodecForEncoding(QTextCodec *codec) {
275 _codecForEncoding = codec;
278 QTextCodec *NetworkInfo::codecForDecoding() const {
279 return _codecForDecoding;
282 void NetworkInfo::setCodecForDecoding(const QString &name) {
283 setCodecForDecoding(QTextCodec::codecForName(name.toAscii()));
286 void NetworkInfo::setCodecForDecoding(QTextCodec *codec) {
287 _codecForDecoding = codec;
290 QString NetworkInfo::decodeString(const QByteArray &text) const {
291 return ::decodeString(text, _codecForDecoding);
294 QByteArray NetworkInfo::encodeString(const QString string) const {
295 if(_codecForEncoding) {
296 return _codecForEncoding->fromUnicode(string);
298 return string.toAscii();
301 // ====================
303 // ====================
304 void NetworkInfo::setNetworkName(const QString &networkName) {
305 _networkName = networkName;
306 emit networkNameSet(networkName);
309 void NetworkInfo::setCurrentServer(const QString ¤tServer) {
310 _currentServer = currentServer;
311 emit currentServerSet(currentServer);
314 void NetworkInfo::setMyNick(const QString &nickname) {
316 emit myNickSet(nickname);
319 void NetworkInfo::addSupport(const QString ¶m, const QString &value) {
320 if(!_supports.contains(param)) {
321 _supports[param] = value;
322 emit supportAdded(param, value);
326 void NetworkInfo::removeSupport(const QString ¶m) {
327 if(_supports.contains(param)) {
328 _supports.remove(param);
329 emit supportRemoved(param);
333 QVariantMap NetworkInfo::initSupports() const {
334 QVariantMap supports;
335 QHashIterator<QString, QString> iter(_supports);
336 while(iter.hasNext()) {
338 supports[iter.key()] = iter.value();
343 QStringList NetworkInfo::initIrcUsers() const {
344 QStringList hostmasks;
345 foreach(IrcUser *ircuser, ircUsers()) {
346 hostmasks << ircuser->hostmask();
351 QStringList NetworkInfo::initIrcChannels() const {
352 return _ircChannels.keys();
355 void NetworkInfo::initSetSupports(const QVariantMap &supports) {
356 QMapIterator<QString, QVariant> iter(supports);
357 while(iter.hasNext()) {
359 addSupport(iter.key(), iter.value().toString());
363 void NetworkInfo::initSetIrcUsers(const QStringList &hostmasks) {
364 if(!_ircUsers.empty())
366 foreach(QString hostmask, hostmasks) {
367 newIrcUser(hostmask);
371 void NetworkInfo::initSetChannels(const QStringList &channels) {
372 if(!_ircChannels.empty())
374 foreach(QString channel, channels)
375 newIrcChannel(channel);
378 IrcUser *NetworkInfo::updateNickFromMask(const QString &mask) {
379 QString nick(nickFromMask(mask).toLower());
382 if(_ircUsers.contains(nick)) {
383 ircuser = _ircUsers[nick];
384 ircuser->updateHostmask(mask);
386 ircuser = newIrcUser(mask);
391 void NetworkInfo::ircUserNickChanged(QString newnick) {
392 QString oldnick = _ircUsers.key(qobject_cast<IrcUser*>(sender()));
397 if(newnick.toLower() != oldnick) _ircUsers[newnick.toLower()] = _ircUsers.take(oldnick);
399 if(myNick().toLower() == oldnick)
403 void NetworkInfo::ircUserDestroyed() {
404 IrcUser *ircuser = static_cast<IrcUser *>(sender());
406 removeIrcUser(ircuser);
409 void NetworkInfo::channelDestroyed() {
410 IrcChannel *channel = static_cast<IrcChannel *>(sender());
412 _ircChannels.remove(_ircChannels.key(channel));
415 void NetworkInfo::setInitialized() {
420 // ====================
422 // ====================
423 void NetworkInfo::determinePrefixes() {
424 // seems like we have to construct them first
425 QString PREFIX = support("PREFIX");
427 if(PREFIX.startsWith("(") && PREFIX.contains(")")) {
428 _prefixes = PREFIX.section(")", 1);
429 _prefixModes = PREFIX.mid(1).section(")", 0, 0);
431 QString defaultPrefixes("~&@%+");
432 QString defaultPrefixModes("qaohv");
434 // we just assume that in PREFIX are only prefix chars stored
435 for(int i = 0; i < defaultPrefixes.size(); i++) {
436 if(PREFIX.contains(defaultPrefixes[i])) {
437 _prefixes += defaultPrefixes[i];
438 _prefixModes += defaultPrefixModes[i];
442 if(!_prefixes.isNull())
445 // well... our assumption was obviously wrong...
446 // check if it's only prefix modes
447 for(int i = 0; i < defaultPrefixes.size(); i++) {
448 if(PREFIX.contains(defaultPrefixModes[i])) {
449 _prefixes += defaultPrefixes[i];
450 _prefixModes += defaultPrefixModes[i];
453 // now we've done all we've could...