src/common/networkinfo.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-07 by The Quassel Team                             *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   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.                                   *
   9  *                                                                         *
  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.                          *
  14  *                                                                         *
  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"
  21
  22 #include "signalproxy.h"
  23 #include "synchronizer.h"
  24 #include "ircuser.h"
  25 #include "ircchannel.h"
  26
  27 #include <QDebug>
  28
  29 #include "util.h"
  30
  31 // ====================
  32 //  Public:
  33 // ====================
  34 NetworkInfo::NetworkInfo(const uint &networkid, SignalProxy *proxy, QObject *parent)
  35   : QObject(parent),
  36     _networkId(networkid),
  37     _initialized(false),
  38     _myNick(QString()),
  39     _networkName(QString()),
  40     _currentServer(QString()),
  41     _prefixes(QString()),
  42     _prefixModes(QString())
  43 {
  44   setObjectName(QString::number(networkid));
  45   _synchronizer = new Synchronizer(this, proxy);
  46 }
  47
  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()) {
  52 //     ircuser.next();
  53 //     delete ircuser.value();
  54 //   }
  55 // }
  56
  57 uint NetworkInfo::networkId() const {
  58   return _networkId;
  59 }
  60
  61 bool NetworkInfo::initialized() const {
  62   return _initialized;
  63 }
  64
  65 Synchronizer *NetworkInfo::synchronizer() {
  66   return _synchronizer;
  67 }
  68
  69 bool NetworkInfo::isMyNick(const QString &nick) const {
  70   return (myNick().toLower() == nick.toLower());
  71 }
  72
  73 bool NetworkInfo::isMyNick(IrcUser *ircuser) const {
  74   return (ircuser->nick().toLower() == myNick());
  75 }
  76
  77 bool NetworkInfo::isChannelName(const QString &channelname) const {
  78   if(channelname.isEmpty())
  79     return false;
  80
  81   if(supports("CHANTYPES"))
  82     return support("CHANTYPES").contains(channelname[0]);
  83   else
  84     return QString("#&!+").contains(channelname[0]);
  85 }
  86
  87 QString NetworkInfo::prefixToMode(const QString &prefix) {
  88   if(prefixes().contains(prefix))
  89     return QString(prefixModes()[prefixes().indexOf(prefix)]);
  90   else
  91     return QString();
  92 }
  93
  94 QString NetworkInfo::prefixToMode(const QCharRef &prefix) {
  95   return prefixToMode(QString(prefix));
  96 }
  97
  98 QString NetworkInfo::modeToPrefix(const QString &mode) {
  99   if(prefixModes().contains(mode))
 100     return QString(prefixes()[prefixModes().indexOf(mode)]);
 101   else
 102     return QString();
 103 }
 104
 105 QString NetworkInfo::modeToPrefix(const QCharRef &mode) {
 106   return modeToPrefix(QString(mode));
 107 }
 108
 109 QString NetworkInfo::networkName() const {
 110   return _networkName;
 111 }
 112
 113 QString NetworkInfo::currentServer() const {
 114   return _currentServer;
 115 }
 116
 117 QString NetworkInfo::myNick() const {
 118   return _myNick;
 119 }
 120
 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
 124   QStringList nicks;
 125   foreach(IrcUser *ircuser, _ircUsers.values()) {
 126     nicks << ircuser->nick();
 127   }
 128   return nicks;
 129 }
 130
 131 QStringList NetworkInfo::channels() const {
 132   return _ircChannels.keys();
 133 }
 134
 135 QString NetworkInfo::prefixes() {
 136   if(_prefixes.isNull())
 137     determinePrefixes();
 138
 139   return _prefixes;
 140 }
 141
 142 QString NetworkInfo::prefixModes() {
 143   if(_prefixModes.isNull())
 144     determinePrefixes();
 145
 146   return _prefixModes;
 147 }
 148
 149 bool NetworkInfo::supports(const QString &param) const {
 150   return _supports.contains(param);
 151 }
 152
 153 QString NetworkInfo::support(const QString &param) const {
 154   QString support_ = param.toUpper();
 155   if(_supports.contains(support_))
 156     return _supports[support_];
 157   else
 158     return QString();
 159 }
 160
 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);
 171   }
 172   return  _ircUsers[nick];
 173 }
 174
 175 IrcUser *NetworkInfo::ircUser(const QString &nickname) const {
 176   if(_ircUsers.contains(nickname))
 177     return _ircUsers[nickname];
 178   else
 179     return 0;
 180 }
 181
 182 QList<IrcUser *> NetworkInfo::ircUsers() const {
 183   return _ircUsers.values();
 184 }
 185
 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);
 194   }
 195   return _ircChannels[channelname];
 196 }
 197
 198
 199 IrcChannel *NetworkInfo::ircChannel(const QString &channelname) {
 200   if(_ircChannels.contains(channelname))
 201     return _ircChannels[channelname];
 202   else
 203     return 0;
 204 }
 205
 206 QList<IrcChannel *> NetworkInfo::ircChannels() const {
 207   return _ircChannels.values();
 208 }
 209
 210 // ====================
 211 //  Public Slots:
 212 // ====================
 213 void NetworkInfo::setNetworkName(const QString &networkName) {
 214   _networkName = networkName;
 215   emit networkNameSet(networkName);
 216 }
 217
 218 void NetworkInfo::setCurrentServer(const QString &currentServer) {
 219   _currentServer = currentServer;
 220   emit currentServerSet(currentServer);
 221 }
 222
 223 void NetworkInfo::setMyNick(const QString &nickname) {
 224   _myNick = nickname;
 225   emit myNickSet(nickname);
 226 }
 227
 228 void NetworkInfo::addSupport(const QString &param, const QString &value) {
 229   if(!_supports.contains(param)) {
 230     _supports[param] = value;
 231     emit supportAdded(param, value);
 232   }
 233 }
 234
 235 void NetworkInfo::removeSupport(const QString &param) {
 236   if(_supports.contains(param)) {
 237     _supports.remove(param);
 238     emit supportRemoved(param);
 239   }
 240 }
 241
 242 QVariantMap NetworkInfo::initSupports() const {
 243   QVariantMap supports;
 244   QHashIterator<QString, QString> iter(_supports);
 245   while(iter.hasNext()) {
 246     iter.next();
 247     supports[iter.key()] = iter.value();
 248   }
 249   return supports;
 250 }
 251
 252 QStringList NetworkInfo::initIrcUsers() const {
 253   QStringList hostmasks;
 254   foreach(IrcUser *ircuser, ircUsers()) {
 255     hostmasks << ircuser->hostmask();
 256   }
 257   return hostmasks;
 258 }
 259
 260 QStringList NetworkInfo::initIrcChannels() const {
 261   return _ircChannels.keys();
 262 }
 263
 264 void NetworkInfo::initSetSupports(const QVariantMap &supports) {
 265   QMapIterator<QString, QVariant> iter(supports);
 266   while(iter.hasNext()) {
 267     iter.next();
 268     addSupport(iter.key(), iter.value().toString());
 269   }
 270 }
 271
 272 void NetworkInfo::initSetIrcUsers(const QStringList &hostmasks) {
 273   if(!_ircUsers.empty())
 274     return;
 275   foreach(QString hostmask, hostmasks) {
 276     newIrcUser(hostmask);
 277   }
 278 }
 279
 280 void NetworkInfo::initSetChannels(const QStringList &channels) {
 281   if(!_ircChannels.empty())
 282     return;
 283   foreach(QString channel, channels)
 284     newIrcChannel(channel);
 285 }
 286
 287 IrcUser *NetworkInfo::updateNickFromMask(const QString &mask) {
 288   QString nick(nickFromMask(mask));
 289   IrcUser *ircuser;
 290
 291   if(_ircUsers.contains(nick)) {
 292     ircuser = _ircUsers[nick];
 293     ircuser->updateHostmask(mask);
 294   } else {
 295     ircuser = newIrcUser(mask);
 296   }
 297   return ircuser;
 298 }
 299
 300 void NetworkInfo::ircUserNickChanged(QString newnick) {
 301   QString oldnick = _ircUsers.key(qobject_cast<IrcUser*>(sender()));
 302   if(oldnick.isNull())
 303     return;
 304
 305   _ircUsers[newnick] = _ircUsers.take(oldnick);
 306
 307   if(myNick() == oldnick)
 308     setMyNick(newnick);
 309 }
 310
 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);
 317     } else {
 318       i++;
 319     }
 320   }
 321 }
 322
 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);
 329     } else {
 330       i++;
 331     }
 332   }
 333 }
 334
 335 void NetworkInfo::setInitialized() {
 336   _initialized = true;
 337   emit initDone();
 338 }
 339
 340 // ====================
 341 //  Private:
 342 // ====================
 343 void NetworkInfo::determinePrefixes() {
 344   // seems like we have to construct them first
 345   QString PREFIX = support("PREFIX");
 346
 347   if(PREFIX.startsWith("(") && PREFIX.contains(")")) {
 348     _prefixes = PREFIX.section(")", 1);
 349     _prefixModes = PREFIX.mid(1).section(")", 0, 0);
 350   } else {
 351     QString defaultPrefixes("@%+");
 352     QString defaultPrefixModes("ohv");
 353
 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];
 359       }
 360     }
 361     // check for success
 362     if(!_prefixes.isNull())
 363       return;
 364
 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];
 371       }
 372     }
 373     // now we've done all we've could...
 374   }
 375 }
 376