1 /***************************************************************************
2 * Copyright (C) 2005-07 by the Quassel IRC 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) 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"
30 // ====================
32 // ====================
33 NetworkInfo::NetworkInfo(const uint &networkid, QObject *parent)
35 _networkId(networkid),
38 _networkName(QString()),
39 _currentServer(QString()),
41 _prefixModes(QString()),
44 setObjectName(QString::number(networkid));
47 // I think this is unnecessary since IrcUsers have us as their daddy :)
48 //NetworkInfo::~NetworkInfo() {
49 // QHashIterator<QString, IrcUser *> ircuser(_ircUsers);
50 // while (ircuser.hasNext()) {
52 // delete ircuser.value();
56 uint NetworkInfo::networkId() const {
60 bool NetworkInfo::initialized() const {
64 SignalProxy *NetworkInfo::proxy() const {
68 void NetworkInfo::setProxy(SignalProxy *proxy) {
70 proxy->synchronize(this);
73 bool NetworkInfo::isMyNick(const QString &nick) const {
74 return (myNick().toLower() == nick.toLower());
77 bool NetworkInfo::isMyNick(IrcUser *ircuser) const {
78 return (ircuser->nick().toLower() == myNick());
81 bool NetworkInfo::isChannelName(const QString &channelname) const {
82 if(channelname.isEmpty())
85 if(supports("CHANTYPES"))
86 return support("CHANTYPES").contains(channelname[0]);
88 return QString("#&!+").contains(channelname[0]);
91 QString NetworkInfo::prefixToMode(const QString &prefix) {
92 if(prefixes().contains(prefix))
93 return QString(prefixModes()[prefixes().indexOf(prefix)]);
98 QString NetworkInfo::prefixToMode(const QCharRef &prefix) {
99 return prefixToMode(QString(prefix));
102 QString NetworkInfo::modeToPrefix(const QString &mode) {
103 if(prefixModes().contains(mode))
104 return QString(prefixes()[prefixModes().indexOf(mode)]);
109 QString NetworkInfo::modeToPrefix(const QCharRef &mode) {
110 return modeToPrefix(QString(mode));
113 QString NetworkInfo::networkName() const {
117 QString NetworkInfo::currentServer() const {
118 return _currentServer;
121 QString NetworkInfo::myNick() const {
125 QStringList NetworkInfo::nicks() const {
126 // we don't use _ircUsers.keys() since the keys may be
127 // not up to date after a nick change
129 foreach(IrcUser *ircuser, _ircUsers.values()) {
130 nicks << ircuser->nick();
135 QStringList NetworkInfo::channels() const {
136 return _ircChannels.keys();
139 QString NetworkInfo::prefixes() {
140 if(_prefixes.isNull())
146 QString NetworkInfo::prefixModes() {
147 if(_prefixModes.isNull())
153 bool NetworkInfo::supports(const QString ¶m) const {
154 return _supports.contains(param);
157 QString NetworkInfo::support(const QString ¶m) const {
158 QString support_ = param.toUpper();
159 if(_supports.contains(support_))
160 return _supports[support_];
165 IrcUser *NetworkInfo::newIrcUser(const QString &hostmask) {
166 QString nick(nickFromMask(hostmask).toLower());
167 if(!_ircUsers.contains(nick)) {
168 IrcUser *ircuser = new IrcUser(hostmask, this);
169 // mark IrcUser as already initialized to keep the SignalProxy from requesting initData
171 ircuser->setInitialized();
173 proxy()->synchronize(ircuser);
175 qWarning() << "unable to synchronize new IrcUser" << hostmask << "forgot to call NetworkInfo::setProxy(SignalProxy *)?";
177 connect(ircuser, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickChanged(QString)));
178 connect(ircuser, SIGNAL(initDone()), this, SIGNAL(ircUserInitDone()));
179 connect(ircuser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed()));
180 _ircUsers[nick] = ircuser;
181 emit ircUserAdded(hostmask);
183 return _ircUsers[nick];
186 void NetworkInfo::removeIrcUser(IrcUser *ircuser) {
187 QString nick = _ircUsers.key(ircuser);
191 _ircUsers.remove(nick);
192 ircuser->deleteLater();
193 emit ircUserRemoved(nick);
196 void NetworkInfo::removeIrcUser(QString nick) {
198 if((ircuser = ircUser(nick)) != 0)
199 removeIrcUser(ircuser);
202 IrcUser *NetworkInfo::ircUser(QString nickname) const {
203 nickname = nickname.toLower();
204 if(_ircUsers.contains(nickname))
205 return _ircUsers[nickname];
210 QList<IrcUser *> NetworkInfo::ircUsers() const {
211 return _ircUsers.values();
214 IrcChannel *NetworkInfo::newIrcChannel(const QString &channelname) {
215 if(!_ircChannels.contains(channelname.toLower())) {
216 IrcChannel *channel = new IrcChannel(channelname, this);
217 // mark IrcUser as already initialized to keep the SignalProxy from requesting initData
219 channel->setInitialized();
222 proxy()->synchronize(channel);
224 qWarning() << "unable to synchronize new IrcChannel" << channelname << "forgot to call NetworkInfo::setProxy(SignalProxy *)?";
226 connect(channel, SIGNAL(initDone()), this, SIGNAL(ircChannelInitDone()));
227 connect(channel, SIGNAL(destroyed()), this, SLOT(channelDestroyed()));
228 _ircChannels[channelname.toLower()] = channel;
229 emit ircChannelAdded(channelname);
231 return _ircChannels[channelname.toLower()];
235 IrcChannel *NetworkInfo::ircChannel(QString channelname) {
236 channelname = channelname.toLower();
237 if(_ircChannels.contains(channelname))
238 return _ircChannels[channelname];
243 QList<IrcChannel *> NetworkInfo::ircChannels() const {
244 return _ircChannels.values();
247 // ====================
249 // ====================
250 void NetworkInfo::setNetworkName(const QString &networkName) {
251 _networkName = networkName;
252 emit networkNameSet(networkName);
255 void NetworkInfo::setCurrentServer(const QString ¤tServer) {
256 _currentServer = currentServer;
257 emit currentServerSet(currentServer);
260 void NetworkInfo::setMyNick(const QString &nickname) {
262 emit myNickSet(nickname);
265 void NetworkInfo::addSupport(const QString ¶m, const QString &value) {
266 if(!_supports.contains(param)) {
267 _supports[param] = value;
268 emit supportAdded(param, value);
272 void NetworkInfo::removeSupport(const QString ¶m) {
273 if(_supports.contains(param)) {
274 _supports.remove(param);
275 emit supportRemoved(param);
279 QVariantMap NetworkInfo::initSupports() const {
280 QVariantMap supports;
281 QHashIterator<QString, QString> iter(_supports);
282 while(iter.hasNext()) {
284 supports[iter.key()] = iter.value();
289 QStringList NetworkInfo::initIrcUsers() const {
290 QStringList hostmasks;
291 foreach(IrcUser *ircuser, ircUsers()) {
292 hostmasks << ircuser->hostmask();
297 QStringList NetworkInfo::initIrcChannels() const {
298 return _ircChannels.keys();
301 void NetworkInfo::initSetSupports(const QVariantMap &supports) {
302 QMapIterator<QString, QVariant> iter(supports);
303 while(iter.hasNext()) {
305 addSupport(iter.key(), iter.value().toString());
309 void NetworkInfo::initSetIrcUsers(const QStringList &hostmasks) {
310 if(!_ircUsers.empty())
312 foreach(QString hostmask, hostmasks) {
313 newIrcUser(hostmask);
317 void NetworkInfo::initSetChannels(const QStringList &channels) {
318 if(!_ircChannels.empty())
320 foreach(QString channel, channels)
321 newIrcChannel(channel);
324 IrcUser *NetworkInfo::updateNickFromMask(const QString &mask) {
325 QString nick(nickFromMask(mask));
328 if(_ircUsers.contains(nick)) {
329 ircuser = _ircUsers[nick];
330 ircuser->updateHostmask(mask);
332 ircuser = newIrcUser(mask);
337 void NetworkInfo::ircUserNickChanged(QString newnick) {
338 QString oldnick = _ircUsers.key(qobject_cast<IrcUser*>(sender()));
343 _ircUsers[newnick.toLower()] = _ircUsers.take(oldnick);
345 if(myNick() == oldnick)
349 void NetworkInfo::ircUserDestroyed() {
350 IrcUser *ircuser = static_cast<IrcUser *>(sender());
352 removeIrcUser(ircuser);
355 void NetworkInfo::channelDestroyed() {
356 IrcChannel *channel = static_cast<IrcChannel *>(sender());
358 _ircChannels.remove(_ircChannels.key(channel));
361 void NetworkInfo::setInitialized() {
366 // ====================
368 // ====================
369 void NetworkInfo::determinePrefixes() {
370 // seems like we have to construct them first
371 QString PREFIX = support("PREFIX");
373 if(PREFIX.startsWith("(") && PREFIX.contains(")")) {
374 _prefixes = PREFIX.section(")", 1);
375 _prefixModes = PREFIX.mid(1).section(")", 0, 0);
377 QString defaultPrefixes("~&@%+");
378 QString defaultPrefixModes("qaohv");
380 // we just assume that in PREFIX are only prefix chars stored
381 for(int i = 0; i < defaultPrefixes.size(); i++) {
382 if(PREFIX.contains(defaultPrefixes[i])) {
383 _prefixes += defaultPrefixes[i];
384 _prefixModes += defaultPrefixModes[i];
388 if(!_prefixes.isNull())
391 // well... our assumption was obviously wrong...
392 // check if it's only prefix modes
393 for(int i = 0; i < defaultPrefixes.size(); i++) {
394 if(PREFIX.contains(defaultPrefixModes[i])) {
395 _prefixes += defaultPrefixes[i];
396 _prefixModes += defaultPrefixModes[i];
399 // now we've done all we've could...