1 /***************************************************************************
2 * Copyright (C) 2005-07 by The Quassel Team *
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) any later version. *
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"
23 #include "synchronizer.h"
25 #include "ircchannel.h"
31 // ====================
33 // ====================
34 NetworkInfo::NetworkInfo(const uint &networkid, SignalProxy *proxy, QObject *parent)
36 _networkId(networkid),
39 _networkName(QString()),
40 _currentServer(QString()),
42 _prefixModes(QString())
44 setObjectName(QString::number(networkid));
45 _synchronizer = new Synchronizer(this, proxy);
48 // I think this is unnecessary since IrcUsers have us as their daddy :)
49 // NetworkInfo::~NetworkInfo() {
50 // QHashIterator<QString, IrcUser *> ircuser(_ircUsers);
51 // while (ircuser.hasNext()) {
53 // delete ircuser.value();
57 uint NetworkInfo::networkId() const {
61 bool NetworkInfo::initialized() const {
65 Synchronizer *NetworkInfo::synchronizer() {
69 bool NetworkInfo::isMyNick(const QString &nick) const {
70 return (myNick().toLower() == nick.toLower());
73 bool NetworkInfo::isMyNick(IrcUser *ircuser) const {
74 return (ircuser->nick().toLower() == myNick());
77 bool NetworkInfo::isChannelName(const QString &channelname) const {
78 if(channelname.isEmpty())
81 if(supports("CHANTYPES"))
82 return support("CHANTYPES").contains(channelname[0]);
84 return QString("#&!+").contains(channelname[0]);
87 QString NetworkInfo::prefixToMode(const QString &prefix) {
88 if(prefixes().contains(prefix))
89 return QString(prefixModes()[prefixes().indexOf(prefix)]);
94 QString NetworkInfo::prefixToMode(const QCharRef &prefix) {
95 return prefixToMode(QString(prefix));
98 QString NetworkInfo::modeToPrefix(const QString &mode) {
99 if(prefixModes().contains(mode))
100 return QString(prefixes()[prefixModes().indexOf(mode)]);
105 QString NetworkInfo::modeToPrefix(const QCharRef &mode) {
106 return modeToPrefix(QString(mode));
109 QString NetworkInfo::networkName() const {
113 QString NetworkInfo::currentServer() const {
114 return _currentServer;
117 QString NetworkInfo::myNick() const {
121 QStringList NetworkInfo::nicks() const {
122 // we don't use _ircUsers.keys() since the keys may be
123 // not up to date after a nick change
125 foreach(IrcUser *ircuser, _ircUsers.values()) {
126 nicks << ircuser->nick();
131 QStringList NetworkInfo::channels() const {
132 return _ircChannels.keys();
135 QString NetworkInfo::prefixes() {
136 if(_prefixes.isNull())
142 QString NetworkInfo::prefixModes() {
143 if(_prefixModes.isNull())
149 bool NetworkInfo::supports(const QString ¶m) const {
150 return _supports.contains(param);
153 QString NetworkInfo::support(const QString ¶m) const {
154 QString support_ = param.toUpper();
155 if(_supports.contains(support_))
156 return _supports[support_];
161 IrcUser *NetworkInfo::newIrcUser(const QString &hostmask) {
162 QString nick(nickFromMask(hostmask));
163 if(!_ircUsers.contains(nick)) {
164 IrcUser *ircuser = new IrcUser(hostmask, this);
165 new Synchronizer(ircuser, synchronizer()->proxy());
166 connect(ircuser, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickChanged(QString)));
167 connect(ircuser, SIGNAL(initDone()), this, SIGNAL(ircUserInitDone()));
168 connect(ircuser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed()));
169 _ircUsers[nick] = ircuser;
170 emit ircUserAdded(hostmask);
172 return _ircUsers[nick];
175 IrcUser *NetworkInfo::ircUser(const QString &nickname) const {
176 if(_ircUsers.contains(nickname))
177 return _ircUsers[nickname];
182 QList<IrcUser *> NetworkInfo::ircUsers() const {
183 return _ircUsers.values();
186 IrcChannel *NetworkInfo::newIrcChannel(const QString &channelname) {
187 if(!_ircChannels.contains(channelname)) {
188 IrcChannel *channel = new IrcChannel(channelname, this);
189 new Synchronizer(channel, synchronizer()->proxy());
190 connect(channel, SIGNAL(initDone()), this, SIGNAL(ircChannelInitDone()));
191 connect(channel, SIGNAL(destroyed()), this, SLOT(channelDestroyed()));
192 _ircChannels[channelname] = channel;
193 emit ircChannelAdded(channelname);
195 return _ircChannels[channelname];
199 IrcChannel *NetworkInfo::ircChannel(const QString &channelname) {
200 if(_ircChannels.contains(channelname))
201 return _ircChannels[channelname];
206 QList<IrcChannel *> NetworkInfo::ircChannels() const {
207 return _ircChannels.values();
210 // ====================
212 // ====================
213 void NetworkInfo::setNetworkName(const QString &networkName) {
214 _networkName = networkName;
215 emit networkNameSet(networkName);
218 void NetworkInfo::setCurrentServer(const QString ¤tServer) {
219 _currentServer = currentServer;
220 emit currentServerSet(currentServer);
223 void NetworkInfo::setMyNick(const QString &nickname) {
225 emit myNickSet(nickname);
228 void NetworkInfo::addSupport(const QString ¶m, const QString &value) {
229 if(!_supports.contains(param)) {
230 _supports[param] = value;
231 emit supportAdded(param, value);
235 void NetworkInfo::removeSupport(const QString ¶m) {
236 if(_supports.contains(param)) {
237 _supports.remove(param);
238 emit supportRemoved(param);
242 QVariantMap NetworkInfo::initSupports() const {
243 QVariantMap supports;
244 QHashIterator<QString, QString> iter(_supports);
245 while(iter.hasNext()) {
247 supports[iter.key()] = iter.value();
252 QStringList NetworkInfo::initIrcUsers() const {
253 QStringList hostmasks;
254 foreach(IrcUser *ircuser, ircUsers()) {
255 hostmasks << ircuser->hostmask();
260 QStringList NetworkInfo::initIrcChannels() const {
261 return _ircChannels.keys();
264 void NetworkInfo::initSetSupports(const QVariantMap &supports) {
265 QMapIterator<QString, QVariant> iter(supports);
266 while(iter.hasNext()) {
268 addSupport(iter.key(), iter.value().toString());
272 void NetworkInfo::initSetIrcUsers(const QStringList &hostmasks) {
273 if(!_ircUsers.empty())
275 foreach(QString hostmask, hostmasks) {
276 newIrcUser(hostmask);
280 void NetworkInfo::initSetChannels(const QStringList &channels) {
281 if(!_ircChannels.empty())
283 foreach(QString channel, channels)
284 newIrcChannel(channel);
287 IrcUser *NetworkInfo::updateNickFromMask(const QString &mask) {
288 QString nick(nickFromMask(mask));
291 if(_ircUsers.contains(nick)) {
292 ircuser = _ircUsers[nick];
293 ircuser->updateHostmask(mask);
295 ircuser = newIrcUser(mask);
300 void NetworkInfo::ircUserNickChanged(QString newnick) {
301 QString oldnick = _ircUsers.key(qobject_cast<IrcUser*>(sender()));
305 _ircUsers[newnick] = _ircUsers.take(oldnick);
307 if(myNick() == oldnick)
311 void NetworkInfo::ircUserDestroyed() {
312 IrcUser *ircuser = qobject_cast<IrcUser *>(sender());
313 QHash<QString, IrcUser*>::iterator i = _ircUsers.begin();
314 while(i != _ircUsers.end()) {
315 if(i.value() == ircuser) {
316 i = _ircUsers.erase(i);
323 void NetworkInfo::channelDestroyed() {
324 IrcChannel *channel = qobject_cast<IrcChannel *>(sender());
325 QHash<QString, IrcChannel*>::iterator i = _ircChannels.begin();
326 while(i != _ircChannels.end()) {
327 if(i.value() == channel) {
328 i = _ircChannels.erase(i);
335 void NetworkInfo::setInitialized() {
340 // ====================
342 // ====================
343 void NetworkInfo::determinePrefixes() {
344 // seems like we have to construct them first
345 QString PREFIX = support("PREFIX");
347 if(PREFIX.startsWith("(") && PREFIX.contains(")")) {
348 _prefixes = PREFIX.section(")", 1);
349 _prefixModes = PREFIX.mid(1).section(")", 0, 0);
351 QString defaultPrefixes("@%+");
352 QString defaultPrefixModes("ohv");
354 // we just assume that in PREFIX are only prefix chars stored
355 for(int i = 0; i < defaultPrefixes.size(); i++) {
356 if(PREFIX.contains(defaultPrefixes[i])) {
357 _prefixes += defaultPrefixes[i];
358 _prefixModes += defaultPrefixModes[i];
362 if(!_prefixes.isNull())
365 // well... our assumption was obviously wrong...
366 // check if it's only prefix modes
367 for(int i = 0; i < defaultPrefixes.size(); i++) {
368 if(PREFIX.contains(defaultPrefixModes[i])) {
369 _prefixes += defaultPrefixes[i];
370 _prefixModes += defaultPrefixModes[i];
373 // now we've done all we've could...