src/client/networkmodel.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-09 by the Quassel Project                          *
   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) version 3.                                           *
   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
  21 #include "networkmodel.h"
  22
  23 #include <QAbstractItemView>
  24 #include <QTextDocument>        // for Qt::escape()
  25
  26 #include "buffermodel.h"
  27 #include "buffersettings.h"
  28 #include "client.h"
  29 #include "clientsettings.h"
  30 #include "ircchannel.h"
  31 #include "network.h"
  32 #include "signalproxy.h"
  33
  34 /*****************************************
  35 *  Network Items
  36 *****************************************/
  37 NetworkItem::NetworkItem(const NetworkId &netid, AbstractTreeItem *parent)
  38   : PropertyMapItem(QList<QString>() << "networkName" << "currentServer" << "nickCount", parent),
  39     _networkId(netid),
  40     _statusBufferItem(0)
  41 {
  42   // DO NOT EMIT dataChanged() DIRECTLY IN NetworkItem
  43   // use networkDataChanged() instead. Otherwise you will end up in a infinite loop
  44   // as we "sync" the dataChanged() signals of NetworkItem and StatusBufferItem
  45   setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
  46   connect(this, SIGNAL(networkDataChanged(int)), this, SIGNAL(dataChanged(int)));
  47   connect(this, SIGNAL(beginRemoveChilds(int, int)), this, SLOT(onBeginRemoveChilds(int, int)));
  48 }
  49
  50 QVariant NetworkItem::data(int column, int role) const {
  51   switch(role) {
  52   case NetworkModel::BufferIdRole:
  53   case NetworkModel::BufferInfoRole:
  54   case NetworkModel::BufferTypeRole:
  55   case NetworkModel::BufferActivityRole:
  56     if(_statusBufferItem)
  57       return _statusBufferItem->data(column, role);
  58     else
  59       return QVariant();
  60   case NetworkModel::NetworkIdRole:
  61     return qVariantFromValue(_networkId);
  62   case NetworkModel::ItemTypeRole:
  63     return NetworkModel::NetworkItemType;
  64   case NetworkModel::ItemActiveRole:
  65     return isActive();
  66   default:
  67     return PropertyMapItem::data(column, role);
  68   }
  69 }
  70
  71 BufferItem *NetworkItem::findBufferItem(BufferId bufferId) {
  72   BufferItem *bufferItem = 0;
  73
  74   for(int i = 0; i < childCount(); i++) {
  75     bufferItem = qobject_cast<BufferItem *>(child(i));
  76     if(!bufferItem)
  77       continue;
  78     if(bufferItem->bufferId() == bufferId)
  79       return bufferItem;
  80   }
  81   return 0;
  82 }
  83
  84
  85 BufferItem *NetworkItem::bufferItem(const BufferInfo &bufferInfo) {
  86   BufferItem *bufferItem = findBufferItem(bufferInfo);
  87   if(bufferItem)
  88     return bufferItem;
  89
  90   switch(bufferInfo.type()) {
  91   case BufferInfo::StatusBuffer:
  92     _statusBufferItem = new StatusBufferItem(bufferInfo, this);
  93     bufferItem = _statusBufferItem;
  94     disconnect(this, SIGNAL(networkDataChanged(int)), this, SIGNAL(dataChanged(int)));
  95     connect(this, SIGNAL(networkDataChanged(int)), bufferItem, SIGNAL(dataChanged(int)));
  96     connect(bufferItem, SIGNAL(dataChanged(int)), this, SIGNAL(dataChanged(int)));
  97     break;
  98   case BufferInfo::ChannelBuffer:
  99     bufferItem = new ChannelBufferItem(bufferInfo, this);
 100     break;
 101   case BufferInfo::QueryBuffer:
 102     bufferItem = new QueryBufferItem(bufferInfo, this);
 103     break;
 104   default:
 105     bufferItem = new BufferItem(bufferInfo, this);
 106   }
 107
 108   newChild(bufferItem);
 109
 110   // postprocess... this is necessary because Qt doesn't seem to like adding childs which already have childs on their own
 111   switch(bufferInfo.type()) {
 112   case BufferInfo::ChannelBuffer:
 113     {
 114       ChannelBufferItem *channelBufferItem = static_cast<ChannelBufferItem *>(bufferItem);
 115       if(_network) {
 116         IrcChannel *ircChannel = _network->ircChannel(bufferInfo.bufferName());
 117         if(ircChannel)
 118           channelBufferItem->attachIrcChannel(ircChannel);
 119       }
 120     }
 121     break;
 122   default:
 123     break;
 124   }
 125
 126   return bufferItem;
 127 }
 128
 129 void NetworkItem::attachNetwork(Network *network) {
 130   if(!network)
 131     return;
 132
 133   _network = network;
 134
 135   connect(network, SIGNAL(networkNameSet(QString)),
 136           this, SLOT(setNetworkName(QString)));
 137   connect(network, SIGNAL(currentServerSet(QString)),
 138           this, SLOT(setCurrentServer(QString)));
 139   connect(network, SIGNAL(ircChannelAdded(IrcChannel *)),
 140           this, SLOT(attachIrcChannel(IrcChannel *)));
 141   connect(network, SIGNAL(ircUserAdded(IrcUser *)),
 142           this, SLOT(attachIrcUser(IrcUser *)));
 143   connect(network, SIGNAL(connectedSet(bool)),
 144           this, SIGNAL(networkDataChanged()));
 145   connect(network, SIGNAL(destroyed()),
 146           this, SIGNAL(networkDataChanged()));
 147
 148   emit networkDataChanged();
 149 }
 150
 151 void NetworkItem::attachIrcChannel(IrcChannel *ircChannel) {
 152   ChannelBufferItem *channelItem;
 153   for(int i = 0; i < childCount(); i++) {
 154     channelItem = qobject_cast<ChannelBufferItem *>(child(i));
 155     if(!channelItem)
 156       continue;
 157
 158     if(channelItem->bufferName().toLower() == ircChannel->name().toLower()) {
 159       channelItem->attachIrcChannel(ircChannel);
 160       return;
 161     }
 162   }
 163 }
 164
 165 void NetworkItem::attachIrcUser(IrcUser *ircUser) {
 166   QueryBufferItem *queryItem = 0;
 167   for(int i = 0; i < childCount(); i++) {
 168     queryItem = qobject_cast<QueryBufferItem *>(child(i));
 169     if(!queryItem)
 170       continue;
 171
 172     if(queryItem->bufferName().toLower() == ircUser->nick().toLower()) {
 173       queryItem->setIrcUser(ircUser);
 174       break;
 175     }
 176   }
 177 }
 178
 179 void NetworkItem::setNetworkName(const QString &networkName) {
 180   Q_UNUSED(networkName);
 181   emit networkDataChanged(0);
 182 }
 183
 184 void NetworkItem::setCurrentServer(const QString &serverName) {
 185   Q_UNUSED(serverName);
 186   emit networkDataChanged(1);
 187 }
 188
 189
 190 QString NetworkItem::toolTip(int column) const {
 191   Q_UNUSED(column);
 192
 193   QStringList toolTip(QString("<b>%1</b>").arg(Qt::escape(networkName())));
 194   toolTip.append(tr("Server: %1").arg(Qt::escape(currentServer())));
 195   toolTip.append(tr("Users: %1").arg(nickCount()));
 196
 197   if(_network) {
 198     toolTip.append(tr("Lag: %1 msecs").arg(_network->latency()));
 199   }
 200
 201   return QString("<p> %1 </p>").arg(toolTip.join("<br />"));
 202 }
 203
 204 void NetworkItem::onBeginRemoveChilds(int start, int end) {
 205   for(int i = start; i <= end; i++) {
 206     StatusBufferItem *statusBufferItem = qobject_cast<StatusBufferItem *>(child(i));
 207     if(statusBufferItem) {
 208       _statusBufferItem = 0;
 209       break;
 210     }
 211   }
 212 }
 213
 214 /*****************************************
 215 *  Fancy Buffer Items
 216 *****************************************/
 217 BufferItem::BufferItem(const BufferInfo &bufferInfo, AbstractTreeItem *parent)
 218   : PropertyMapItem(QStringList() << "bufferName" << "topic" << "nickCount", parent),
 219     _bufferInfo(bufferInfo),
 220     _activity(BufferInfo::NoActivity)
 221 {
 222   setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);
 223 }
 224
 225 void BufferItem::setActivityLevel(BufferInfo::ActivityLevel level) {
 226   if(_activity != level) {
 227     _activity = level;
 228     emit dataChanged();
 229   }
 230 }
 231
 232 void BufferItem::clearActivityLevel() {
 233   _activity = BufferInfo::NoActivity;
 234   _lastSeenMarkerMsgId = _lastSeenMsgId;
 235   _firstUnreadMsgId = MsgId();
 236   emit dataChanged();
 237 }
 238
 239 void BufferItem::updateActivityLevel(const Message &msg) {
 240   if(isCurrentBuffer()) {
 241     return;
 242   }
 243
 244   if(msg.flags() & Message::Self)       // don't update activity for our own messages
 245     return;
 246
 247   if(msg.msgId() <= lastSeenMsgId())
 248     return;
 249
 250   bool stateChanged = false;
 251   if(!firstUnreadMsgId().isValid() || msg.msgId() < firstUnreadMsgId()) {
 252     stateChanged = true;
 253     _firstUnreadMsgId = msg.msgId();
 254   }
 255
 256   BufferInfo::ActivityLevel oldLevel = activityLevel();
 257
 258   _activity |= BufferInfo::OtherActivity;
 259   if(msg.type() & (Message::Plain | Message::Notice | Message::Action))
 260     _activity |= BufferInfo::NewMessage;
 261
 262   if(msg.flags() & Message::Highlight)
 263     _activity |= BufferInfo::Highlight;
 264
 265   stateChanged |= (oldLevel != _activity);
 266
 267   if(stateChanged)
 268     emit dataChanged();
 269 }
 270
 271 QVariant BufferItem::data(int column, int role) const {
 272   switch(role) {
 273   case NetworkModel::ItemTypeRole:
 274     return NetworkModel::BufferItemType;
 275   case NetworkModel::BufferIdRole:
 276     return qVariantFromValue(bufferInfo().bufferId());
 277   case NetworkModel::NetworkIdRole:
 278     return qVariantFromValue(bufferInfo().networkId());
 279   case NetworkModel::BufferInfoRole:
 280     return qVariantFromValue(bufferInfo());
 281   case NetworkModel::BufferTypeRole:
 282     return int(bufferType());
 283   case NetworkModel::ItemActiveRole:
 284     return isActive();
 285   case NetworkModel::BufferActivityRole:
 286     return (int)activityLevel();
 287   case NetworkModel::BufferFirstUnreadMsgIdRole:
 288     return qVariantFromValue(firstUnreadMsgId());
 289   default:
 290     return PropertyMapItem::data(column, role);
 291   }
 292 }
 293
 294 bool BufferItem::setData(int column, const QVariant &value, int role) {
 295   switch(role) {
 296   case NetworkModel::BufferActivityRole:
 297     setActivityLevel((BufferInfo::ActivityLevel)value.toInt());
 298     return true;
 299   default:
 300     return PropertyMapItem::setData(column, value, role);
 301   }
 302   return true;
 303 }
 304
 305 void BufferItem::setBufferName(const QString &name) {
 306   _bufferInfo = BufferInfo(_bufferInfo.bufferId(), _bufferInfo.networkId(), _bufferInfo.type(), _bufferInfo.groupId(), name);
 307   emit dataChanged(0);
 308 }
 309
 310 void BufferItem::setLastSeenMsgId(const MsgId &msgId) {
 311   _lastSeenMsgId = msgId;
 312   if(!isCurrentBuffer()) {
 313     _lastSeenMarkerMsgId = msgId;
 314   }
 315   setActivityLevel(BufferInfo::NoActivity);
 316 }
 317
 318 bool BufferItem::isCurrentBuffer() const {
 319   return _bufferInfo.bufferId() == Client::bufferModel()->currentIndex().data(NetworkModel::BufferIdRole).value<BufferId>();
 320 }
 321
 322 QString BufferItem::toolTip(int column) const {
 323   Q_UNUSED(column);
 324   return tr("<p> %1 - %2 </p>").arg(bufferInfo().bufferId().toInt()).arg(bufferName());
 325 }
 326
 327 /*****************************************
 328 *  StatusBufferItem
 329 *****************************************/
 330 StatusBufferItem::StatusBufferItem(const BufferInfo &bufferInfo, NetworkItem *parent)
 331   : BufferItem(bufferInfo, parent)
 332 {
 333 }
 334
 335 QString StatusBufferItem::toolTip(int column) const {
 336   NetworkItem *networkItem = qobject_cast<NetworkItem *>(parent());
 337   if(networkItem)
 338     return networkItem->toolTip(column);
 339   else
 340     return QString();
 341 }
 342
 343 /*****************************************
 344 *  QueryBufferItem
 345 *****************************************/
 346 QueryBufferItem::QueryBufferItem(const BufferInfo &bufferInfo, NetworkItem *parent)
 347   : BufferItem(bufferInfo, parent),
 348     _ircUser(0)
 349 {
 350   setFlags(flags() | Qt::ItemIsDropEnabled | Qt::ItemIsEditable);
 351
 352   const Network *net = Client::network(bufferInfo.networkId());
 353   if(!net)
 354     return;
 355
 356   IrcUser *ircUser = net->ircUser(bufferInfo.bufferName());
 357   setIrcUser(ircUser);
 358 }
 359
 360 QVariant QueryBufferItem::data(int column, int role) const {
 361   switch(role) {
 362   case Qt::EditRole:
 363     return BufferItem::data(column, Qt::DisplayRole);
 364   case NetworkModel::IrcUserRole:
 365     return QVariant::fromValue<QObject *>(_ircUser);
 366   case NetworkModel::UserAwayRole:
 367     return (bool)_ircUser ? _ircUser->isAway() : false;
 368   default:
 369     return BufferItem::data(column, role);
 370   }
 371 }
 372
 373 bool QueryBufferItem::setData(int column, const QVariant &value, int role) {
 374   if(column != 0)
 375     return BufferItem::setData(column, value, role);
 376
 377   switch(role) {
 378   case Qt::EditRole:
 379     {
 380       QString newName = value.toString();
 381       if(!newName.isEmpty()) {
 382         Client::renameBuffer(bufferId(), newName);
 383         return true;
 384       } else {
 385         return false;
 386       }
 387     }
 388     break;
 389   default:
 390     return BufferItem::setData(column, value, role);
 391   }
 392 }
 393
 394 void QueryBufferItem::setBufferName(const QString &name) {
 395   BufferItem::setBufferName(name);
 396   NetworkId netId = data(0, NetworkModel::NetworkIdRole).value<NetworkId>();
 397   const Network *net = Client::network(netId);
 398   if(net)
 399     setIrcUser(net->ircUser(name));
 400 }
 401
 402 QString QueryBufferItem::toolTip(int column) const {
 403   // pretty much code duplication of IrcUserItem::toolTip() but inheritance won't solve this...
 404   Q_UNUSED(column);
 405   QStringList toolTip;
 406
 407   toolTip.append(tr("<b>Query with %1</b>").arg(bufferName()));
 408
 409   if(_ircUser) {
 410     if(_ircUser->userModes() != "") toolTip[0].append(QString(" (%1)").arg(_ircUser->userModes()));
 411     if(_ircUser->isAway()) {
 412       toolTip[0].append(QString(" (away%1)").arg(!_ircUser->awayMessage().isEmpty() ? (QString(" ") + _ircUser->awayMessage()) : QString()));
 413     }
 414     if(!_ircUser->realName().isEmpty()) toolTip.append(_ircUser->realName());
 415     if(!_ircUser->ircOperator().isEmpty()) toolTip.append(QString("%1 %2").arg(_ircUser->nick()).arg(_ircUser->ircOperator()));
 416     if(!_ircUser->suserHost().isEmpty()) toolTip.append(_ircUser->suserHost());
 417     if(!_ircUser->whoisServiceReply().isEmpty()) toolTip.append(_ircUser->whoisServiceReply());
 418
 419     toolTip.append(_ircUser->hostmask().remove(0, _ircUser->hostmask().indexOf("!")+1));
 420
 421     if(_ircUser->idleTime().isValid()) {
 422       QDateTime now = QDateTime::currentDateTime();
 423       QDateTime idle = _ircUser->idleTime();
 424       int idleTime = idle.secsTo(now);
 425       toolTip.append(tr("idling since %1").arg(secondsToString(idleTime)));
 426     }
 427     if(_ircUser->loginTime().isValid()) {
 428       toolTip.append(tr("login time: %1").arg(_ircUser->loginTime().toString()));
 429     }
 430
 431     if(!_ircUser->server().isEmpty()) toolTip.append(tr("server: %1").arg(_ircUser->server()));
 432   }
 433
 434   return QString("<p> %1 </p>").arg(toolTip.join("<br />"));
 435 }
 436
 437 void QueryBufferItem::setIrcUser(IrcUser *ircUser) {
 438   if(_ircUser == ircUser)
 439     return;
 440
 441   if(_ircUser) {
 442     disconnect(_ircUser, 0, this, 0);
 443   }
 444
 445   if(ircUser) {
 446     connect(ircUser, SIGNAL(quited()), this, SLOT(removeIrcUser()));
 447     connect(ircUser, SIGNAL(awaySet(bool)), this, SIGNAL(dataChanged()));
 448   }
 449
 450   _ircUser = ircUser;
 451   emit dataChanged();
 452 }
 453
 454 void QueryBufferItem::removeIrcUser() {
 455   _ircUser = 0;
 456   emit dataChanged();
 457 }
 458
 459 /*****************************************
 460 *  ChannelBufferItem
 461 *****************************************/
 462 ChannelBufferItem::ChannelBufferItem(const BufferInfo &bufferInfo, AbstractTreeItem *parent)
 463   : BufferItem(bufferInfo, parent),
 464     _ircChannel(0)
 465 {
 466 }
 467
 468 QVariant ChannelBufferItem::data(int column, int role) const {
 469   switch(role) {
 470     case NetworkModel::IrcChannelRole:
 471       return QVariant::fromValue<QObject *>(_ircChannel);
 472     default:
 473       return BufferItem::data(column, role);
 474   }
 475 }
 476
 477 QString ChannelBufferItem::toolTip(int column) const {
 478   Q_UNUSED(column);
 479   QStringList toolTip;
 480
 481   toolTip.append(tr("<b>Channel %1</b>").arg(Qt::escape(bufferName())));
 482   if(isActive()) {
 483     //TODO: add channel modes
 484     toolTip.append(tr("<b>Users:</b> %1").arg(nickCount()));
 485     if(_ircChannel) {
 486       QString channelMode = _ircChannel->channelModeString(); // channelModeString is compiled on the fly -> thus cache the result
 487       if(!channelMode.isEmpty())
 488         toolTip.append(tr("<b>Mode:</b> %1").arg(channelMode));
 489     }
 490
 491     ItemViewSettings s;
 492     bool showTopic = s.displayTopicInTooltip();
 493     if(showTopic) {
 494       QString _topic = topic();
 495       if(_topic != "") {
 496         _topic = stripFormatCodes(_topic);
 497         _topic = Qt::escape(_topic);
 498         toolTip.append(QString("<font size='-2'>&nbsp;</font>"));
 499         toolTip.append(tr("<b>Topic:</b> %1").arg(_topic));
 500       }
 501     }
 502   } else {
 503     toolTip.append(tr("Not active <br /> Double-click to join"));
 504   }
 505
 506   return tr("<p> %1 </p>").arg(toolTip.join("<br />"));
 507 }
 508
 509 void ChannelBufferItem::attachIrcChannel(IrcChannel *ircChannel) {
 510   Q_ASSERT(!_ircChannel && ircChannel);
 511
 512   _ircChannel = ircChannel;
 513
 514   connect(ircChannel, SIGNAL(topicSet(QString)),
 515           this, SLOT(setTopic(QString)));
 516   connect(ircChannel, SIGNAL(ircUsersJoined(QList<IrcUser *>)),
 517           this, SLOT(join(QList<IrcUser *>)));
 518   connect(ircChannel, SIGNAL(ircUserParted(IrcUser *)),
 519           this, SLOT(part(IrcUser *)));
 520   connect(ircChannel, SIGNAL(parted()),
 521           this, SLOT(ircChannelParted()));
 522   connect(ircChannel, SIGNAL(ircUserModesSet(IrcUser *, QString)),
 523           this, SLOT(userModeChanged(IrcUser *)));
 524   connect(ircChannel, SIGNAL(ircUserModeAdded(IrcUser *, QString)),
 525           this, SLOT(userModeChanged(IrcUser *)));
 526   connect(ircChannel, SIGNAL(ircUserModeRemoved(IrcUser *, QString)),
 527           this, SLOT(userModeChanged(IrcUser *)));
 528
 529   if(!ircChannel->ircUsers().isEmpty())
 530     join(ircChannel->ircUsers());
 531
 532   emit dataChanged();
 533 }
 534
 535 void ChannelBufferItem::ircChannelParted() {
 536   Q_CHECK_PTR(_ircChannel);
 537   disconnect(_ircChannel, 0, this, 0);
 538   _ircChannel = 0;
 539   emit dataChanged();
 540   removeAllChilds();
 541 }
 542
 543 void ChannelBufferItem::join(const QList<IrcUser *> &ircUsers) {
 544   addUsersToCategory(ircUsers);
 545   emit dataChanged(2);
 546 }
 547
 548 UserCategoryItem *ChannelBufferItem::findCategoryItem(int categoryId) {
 549   UserCategoryItem *categoryItem = 0;
 550
 551   for(int i = 0; i < childCount(); i++) {
 552     categoryItem = qobject_cast<UserCategoryItem *>(child(i));
 553     if(!categoryItem)
 554       continue;
 555     if(categoryItem->categoryId() == categoryId)
 556       return categoryItem;
 557   }
 558   return 0;
 559 }
 560
 561 void ChannelBufferItem::addUserToCategory(IrcUser *ircUser) {
 562   addUsersToCategory(QList<IrcUser *>() << ircUser);
 563 }
 564
 565 void ChannelBufferItem::addUsersToCategory(const QList<IrcUser *> &ircUsers) {
 566   Q_ASSERT(_ircChannel);
 567
 568   QHash<UserCategoryItem *, QList<IrcUser *> > categories;
 569
 570   int categoryId = -1;
 571   UserCategoryItem *categoryItem = 0;
 572
 573   foreach(IrcUser *ircUser, ircUsers) {
 574     categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
 575     categoryItem = findCategoryItem(categoryId);
 576     if(!categoryItem) {
 577       categoryItem = new UserCategoryItem(categoryId, this);
 578       categories[categoryItem] = QList<IrcUser *>();
 579       newChild(categoryItem);
 580     }
 581     categories[categoryItem] << ircUser;
 582   }
 583
 584   QHash<UserCategoryItem *, QList<IrcUser *> >::const_iterator catIter = categories.constBegin();
 585   while(catIter != categories.constEnd()) {
 586     catIter.key()->addUsers(catIter.value());
 587     catIter++;
 588   }
 589 }
 590
 591 void ChannelBufferItem::part(IrcUser *ircUser) {
 592   if(!ircUser) {
 593     qWarning() << bufferName() << "ChannelBufferItem::part(): unknown User" << ircUser;
 594     return;
 595   }
 596
 597   disconnect(ircUser, 0, this, 0);
 598   removeUserFromCategory(ircUser);
 599   emit dataChanged(2);
 600 }
 601
 602 void ChannelBufferItem::removeUserFromCategory(IrcUser *ircUser) {
 603   if(!_ircChannel) {
 604     // If we parted the channel there might still be some ircUsers connected.
 605     // in that case we just ignore the call
 606     Q_ASSERT(childCount() == 0);
 607     return;
 608   }
 609
 610   UserCategoryItem *categoryItem = 0;
 611   for(int i = 0; i < childCount(); i++) {
 612     categoryItem = qobject_cast<UserCategoryItem *>(child(i));
 613     if(categoryItem->removeUser(ircUser)) {
 614       if(categoryItem->childCount() == 0)
 615         removeChild(i);
 616       break;
 617     }
 618   }
 619 }
 620
 621 void ChannelBufferItem::userModeChanged(IrcUser *ircUser) {
 622   Q_ASSERT(_ircChannel);
 623
 624   int categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
 625   UserCategoryItem *categoryItem = findCategoryItem(categoryId);
 626
 627   if(categoryItem) {
 628     if(categoryItem->findIrcUser(ircUser)) {
 629       return; // already in the right category;
 630     }
 631   } else {
 632     categoryItem = new UserCategoryItem(categoryId, this);
 633     newChild(categoryItem);
 634   }
 635
 636   // find the item that needs reparenting
 637   IrcUserItem *ircUserItem = 0;
 638   for(int i = 0; i < childCount(); i++) {
 639     UserCategoryItem *oldCategoryItem = qobject_cast<UserCategoryItem *>(child(i));
 640     Q_ASSERT(oldCategoryItem);
 641     IrcUserItem *userItem = oldCategoryItem->findIrcUser(ircUser);
 642     if(userItem) {
 643       ircUserItem = userItem;
 644       break;
 645     }
 646   }
 647
 648   if(!ircUserItem) {
 649     qWarning() << "ChannelBufferItem::userModeChanged(IrcUser *): unable to determine old category of" << ircUser;
 650     return;
 651   }
 652   ircUserItem->reParent(categoryItem);
 653 }
 654
 655 /*****************************************
 656 *  User Category Items (like @vh etc.)
 657 *****************************************/
 658 // we hardcode this even though we have PREFIX in network... but that wouldn't help with mapping modes to
 659 // category strings anyway.
 660 const QList<QChar> UserCategoryItem::categories = QList<QChar>() << 'q' << 'a' << 'o' << 'h' << 'v';
 661
 662 UserCategoryItem::UserCategoryItem(int category, AbstractTreeItem *parent)
 663   : PropertyMapItem(QStringList() << "categoryName", parent),
 664     _category(category)
 665 {
 666   setFlags(Qt::ItemIsEnabled);
 667   setTreeItemFlags(AbstractTreeItem::DeleteOnLastChildRemoved);
 668   setObjectName(parent->data(0, Qt::DisplayRole).toString() + "/" + QString::number(category));
 669 }
 670
 671 // caching this makes no sense, since we display the user number dynamically
 672 QString UserCategoryItem::categoryName() const {
 673   int n = childCount();
 674   switch(_category) {
 675     case 0: return tr("%n Owner(s)", 0, n);
 676     case 1: return tr("%n Admin(s)", 0, n);
 677     case 2: return tr("%n Operator(s)", 0, n);
 678     case 3: return tr("%n Half-Op(s)", 0, n);
 679     case 4: return tr("%n Voiced", 0, n);
 680     default: return tr("%n User(s)", 0, n);
 681   }
 682 }
 683
 684 IrcUserItem *UserCategoryItem::findIrcUser(IrcUser *ircUser) {
 685   IrcUserItem *userItem = 0;
 686
 687   for(int i = 0; i < childCount(); i++) {
 688     userItem = qobject_cast<IrcUserItem *>(child(i));
 689     if(!userItem)
 690       continue;
 691     if(userItem->ircUser() == ircUser)
 692       return userItem;
 693   }
 694   return 0;
 695 }
 696
 697 void UserCategoryItem::addUsers(const QList<IrcUser *> &ircUsers) {
 698   QList<AbstractTreeItem *> userItems;
 699   foreach(IrcUser *ircUser, ircUsers)
 700     userItems << new IrcUserItem(ircUser, this);
 701   newChilds(userItems);
 702   emit dataChanged(0);
 703 }
 704
 705 bool UserCategoryItem::removeUser(IrcUser *ircUser) {
 706   IrcUserItem *userItem = findIrcUser(ircUser);
 707   bool success = (bool)userItem;
 708   if(success) {
 709     removeChild(userItem);
 710     emit dataChanged(0);
 711   }
 712   return success;
 713 }
 714
 715 int UserCategoryItem::categoryFromModes(const QString &modes) {
 716   for(int i = 0; i < categories.count(); i++) {
 717     if(modes.contains(categories[i]))
 718       return i;
 719   }
 720   return categories.count();
 721 }
 722
 723 QVariant UserCategoryItem::data(int column, int role) const {
 724   switch(role) {
 725   case TreeModel::SortRole:
 726     return _category;
 727   case NetworkModel::ItemActiveRole:
 728     return true;
 729   case NetworkModel::ItemTypeRole:
 730     return NetworkModel::UserCategoryItemType;
 731   case NetworkModel::BufferIdRole:
 732     return parent()->data(column, role);
 733   case NetworkModel::NetworkIdRole:
 734     return parent()->data(column, role);
 735   case NetworkModel::BufferInfoRole:
 736     return parent()->data(column, role);
 737   default:
 738     return PropertyMapItem::data(column, role);
 739   }
 740 }
 741
 742
 743 /*****************************************
 744 *  Irc User Items
 745 *****************************************/
 746 IrcUserItem::IrcUserItem(IrcUser *ircUser, AbstractTreeItem *parent)
 747   : PropertyMapItem(QStringList() << "nickName", parent),
 748     _ircUser(ircUser)
 749 {
 750   setObjectName(ircUser->nick());
 751   connect(ircUser, SIGNAL(quited()), this, SLOT(ircUserQuited()));
 752   connect(ircUser, SIGNAL(nickSet(QString)), this, SIGNAL(dataChanged()));
 753   connect(ircUser, SIGNAL(awaySet(bool)), this, SIGNAL(dataChanged()));
 754 }
 755
 756 QVariant IrcUserItem::data(int column, int role) const {
 757   switch(role) {
 758   case NetworkModel::ItemActiveRole:
 759     return isActive();
 760   case NetworkModel::ItemTypeRole:
 761     return NetworkModel::IrcUserItemType;
 762   case NetworkModel::BufferIdRole:
 763     return parent()->data(column, role);
 764   case NetworkModel::NetworkIdRole:
 765     return parent()->data(column, role);
 766   case NetworkModel::BufferInfoRole:
 767     return parent()->data(column, role);
 768   case NetworkModel::IrcChannelRole:
 769     return parent()->data(column, role);
 770   case NetworkModel::IrcUserRole:
 771     return QVariant::fromValue<QObject *>(_ircUser.data());
 772   case NetworkModel::UserAwayRole:
 773     return (bool)_ircUser ? _ircUser->isAway() : false;
 774   default:
 775     return PropertyMapItem::data(column, role);
 776   }
 777 }
 778
 779 QString IrcUserItem::toolTip(int column) const {
 780   Q_UNUSED(column);
 781   QStringList toolTip(QString("<b>%1</b>").arg(nickName()));
 782   if(_ircUser->userModes() != "") toolTip[0].append(QString(" (%1)").arg(_ircUser->userModes()));
 783   if(_ircUser->isAway()) {
 784     toolTip[0].append(" is away");
 785     if(!_ircUser->awayMessage().isEmpty())
 786       toolTip[0].append(QString(" (%1)").arg(_ircUser->awayMessage()));
 787   }
 788   if(!_ircUser->realName().isEmpty()) toolTip.append(_ircUser->realName());
 789   if(!_ircUser->ircOperator().isEmpty()) toolTip.append(QString("%1 %2").arg(nickName()).arg(_ircUser->ircOperator()));
 790   if(!_ircUser->suserHost().isEmpty()) toolTip.append(_ircUser->suserHost());
 791   if(!_ircUser->whoisServiceReply().isEmpty()) toolTip.append(_ircUser->whoisServiceReply());
 792
 793   toolTip.append(_ircUser->hostmask().remove(0, _ircUser->hostmask().indexOf("!")+1));
 794
 795   if(_ircUser->idleTime().isValid()) {
 796     QDateTime now = QDateTime::currentDateTime();
 797     QDateTime idle = _ircUser->idleTime();
 798     int idleTime = idle.secsTo(now);
 799     toolTip.append(tr("idling since %1").arg(secondsToString(idleTime)));
 800   }
 801   if(_ircUser->loginTime().isValid()) {
 802     toolTip.append(tr("login time: %1").arg(_ircUser->loginTime().toString()));
 803   }
 804
 805   if(!_ircUser->server().isEmpty()) toolTip.append(tr("server: %1").arg(_ircUser->server()));
 806
 807   return QString("<p> %1 </p>").arg(toolTip.join("<br />"));
 808 }
 809
 810 /*****************************************
 811  * NetworkModel
 812  *****************************************/
 813 NetworkModel::NetworkModel(QObject *parent)
 814   : TreeModel(NetworkModel::defaultHeader(), parent)
 815 {
 816   connect(this, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
 817           this, SLOT(checkForNewBuffers(const QModelIndex &, int, int)));
 818   connect(this, SIGNAL(rowsAboutToBeRemoved(const QModelIndex &, int, int)),
 819           this, SLOT(checkForRemovedBuffers(const QModelIndex &, int, int)));
 820
 821   BufferSettings defaultSettings;
 822   defaultSettings.notify("UserNoticesTarget", this, SLOT(messageRedirectionSettingsChanged()));
 823   defaultSettings.notify("ServerNoticesTarget", this, SLOT(messageRedirectionSettingsChanged()));
 824   defaultSettings.notify("ErrorMsgsTarget", this, SLOT(messageRedirectionSettingsChanged()));
 825   messageRedirectionSettingsChanged();
 826 }
 827
 828 QList<QVariant >NetworkModel::defaultHeader() {
 829   QList<QVariant> data;
 830   data << tr("Buffer") << tr("Topic") << tr("Nick Count");
 831   return data;
 832 }
 833
 834 bool NetworkModel::isBufferIndex(const QModelIndex &index) const {
 835   return index.data(NetworkModel::ItemTypeRole) == NetworkModel::BufferItemType;
 836 }
 837
 838 int NetworkModel::networkRow(NetworkId networkId) const {
 839   NetworkItem *netItem = 0;
 840   for(int i = 0; i < rootItem->childCount(); i++) {
 841     netItem = qobject_cast<NetworkItem *>(rootItem->child(i));
 842     if(!netItem)
 843       continue;
 844     if(netItem->networkId() == networkId)
 845       return i;
 846   }
 847   return -1;
 848 }
 849
 850 QModelIndex NetworkModel::networkIndex(NetworkId networkId) {
 851   int netRow = networkRow(networkId);
 852   if(netRow == -1)
 853     return QModelIndex();
 854   else
 855     return indexByItem(qobject_cast<NetworkItem *>(rootItem->child(netRow)));
 856 }
 857
 858 NetworkItem *NetworkModel::findNetworkItem(NetworkId networkId) const {
 859   int netRow = networkRow(networkId);
 860   if(netRow == -1)
 861     return 0;
 862   else
 863     return qobject_cast<NetworkItem *>(rootItem->child(netRow));
 864 }
 865
 866 NetworkItem *NetworkModel::networkItem(NetworkId networkId) {
 867   NetworkItem *netItem = findNetworkItem(networkId);
 868
 869   if(netItem == 0) {
 870     netItem = new NetworkItem(networkId, rootItem);
 871     rootItem->newChild(netItem);
 872   }
 873   return netItem;
 874 }
 875
 876 void NetworkModel::networkRemoved(const NetworkId &networkId) {
 877   int netRow = networkRow(networkId);
 878   if(netRow != -1) {
 879     rootItem->removeChild(netRow);
 880   }
 881 }
 882
 883 QModelIndex NetworkModel::bufferIndex(BufferId bufferId) {
 884   if(!_bufferItemCache.contains(bufferId))
 885     return QModelIndex();
 886
 887   return indexByItem(_bufferItemCache[bufferId]);
 888 }
 889
 890 BufferItem *NetworkModel::findBufferItem(BufferId bufferId) const {
 891   if(_bufferItemCache.contains(bufferId))
 892     return _bufferItemCache[bufferId];
 893   else
 894     return 0;
 895 }
 896
 897 BufferItem *NetworkModel::bufferItem(const BufferInfo &bufferInfo) {
 898   if(_bufferItemCache.contains(bufferInfo.bufferId()))
 899     return _bufferItemCache[bufferInfo.bufferId()];
 900
 901   NetworkItem *netItem = networkItem(bufferInfo.networkId());
 902   return netItem->bufferItem(bufferInfo);
 903 }
 904
 905 QStringList NetworkModel::mimeTypes() const {
 906   // mimetypes we accept for drops
 907   QStringList types;
 908   // comma separated list of colon separated pairs of networkid and bufferid
 909   // example: 0:1,0:2,1:4
 910   types << "application/Quassel/BufferItemList";
 911   return types;
 912 }
 913
 914 bool NetworkModel::mimeContainsBufferList(const QMimeData *mimeData) {
 915   return mimeData->hasFormat("application/Quassel/BufferItemList");
 916 }
 917
 918 QList< QPair<NetworkId, BufferId> > NetworkModel::mimeDataToBufferList(const QMimeData *mimeData) {
 919   QList< QPair<NetworkId, BufferId> > bufferList;
 920
 921   if(!mimeContainsBufferList(mimeData))
 922     return bufferList;
 923
 924   QStringList rawBufferList = QString::fromAscii(mimeData->data("application/Quassel/BufferItemList")).split(",");
 925   NetworkId networkId;
 926   BufferId bufferUid;
 927   foreach(QString rawBuffer, rawBufferList) {
 928     if(!rawBuffer.contains(":"))
 929       continue;
 930     networkId = rawBuffer.section(":", 0, 0).toInt();
 931     bufferUid = rawBuffer.section(":", 1, 1).toInt();
 932     bufferList.append(qMakePair(networkId, bufferUid));
 933   }
 934   return bufferList;
 935 }
 936
 937
 938 QMimeData *NetworkModel::mimeData(const QModelIndexList &indexes) const {
 939   QMimeData *mimeData = new QMimeData();
 940
 941   QStringList bufferlist;
 942   QString netid, uid, bufferid;
 943   foreach(QModelIndex index, indexes) {
 944     netid = QString::number(index.data(NetworkIdRole).value<NetworkId>().toInt());
 945     uid = QString::number(index.data(BufferIdRole).value<BufferId>().toInt());
 946     bufferid = QString("%1:%2").arg(netid).arg(uid);
 947     if(!bufferlist.contains(bufferid))
 948       bufferlist << bufferid;
 949   }
 950
 951   mimeData->setData("application/Quassel/BufferItemList", bufferlist.join(",").toAscii());
 952
 953   return mimeData;
 954 }
 955
 956 void NetworkModel::attachNetwork(Network *net) {
 957   NetworkItem *netItem = networkItem(net->networkId());
 958   netItem->attachNetwork(net);
 959 }
 960
 961 void NetworkModel::bufferUpdated(BufferInfo bufferInfo) {
 962   BufferItem *bufItem = bufferItem(bufferInfo);
 963   QModelIndex itemindex = indexByItem(bufItem);
 964   emit dataChanged(itemindex, itemindex);
 965 }
 966
 967 void NetworkModel::removeBuffer(BufferId bufferId) {
 968   BufferItem *buffItem = findBufferItem(bufferId);
 969   if(!buffItem)
 970     return;
 971
 972   buffItem->parent()->removeChild(buffItem);
 973 }
 974
 975 MsgId NetworkModel::lastSeenMsgId(BufferId bufferId) const {
 976   if(!_bufferItemCache.contains(bufferId))
 977     return MsgId();
 978
 979   return _bufferItemCache[bufferId]->lastSeenMsgId();
 980 }
 981
 982 MsgId NetworkModel::lastSeenMarkerMsgId(BufferId bufferId) const {
 983   if(!_bufferItemCache.contains(bufferId))
 984     return MsgId();
 985
 986   return _bufferItemCache[bufferId]->lastSeenMarkerMsgId();
 987 }
 988
 989 MsgId NetworkModel::lastSeenMsgId(const BufferId &bufferId) {
 990   BufferItem *bufferItem = findBufferItem(bufferId);
 991   if(!bufferItem) {
 992     qDebug() << "NetworkModel::lastSeenMsgId(): buffer is unknown:" << bufferId;
 993     Client::purgeKnownBufferIds();
 994     return MsgId();
 995   }
 996   return bufferItem->lastSeenMsgId();
 997 }
 998
 999 void NetworkModel::setLastSeenMsgId(const BufferId &bufferId, const MsgId &msgId) {
1000   BufferItem *bufferItem = findBufferItem(bufferId);
1001   if(!bufferItem) {
1002     qDebug() << "NetworkModel::setLastSeenMsgId(): buffer is unknown:" << bufferId;
1003     Client::purgeKnownBufferIds();
1004     return;
1005   }
1006   bufferItem->setLastSeenMsgId(msgId);
1007 }
1008
1009 void NetworkModel::updateBufferActivity(Message &msg) {
1010   int redirectionTarget = 0;
1011   switch(msg.type()) {
1012   case Message::Notice:
1013     if(bufferType(msg.bufferId()) != BufferInfo::ChannelBuffer) {
1014       msg.setFlags(msg.flags() | Message::Redirected);
1015       if(msg.flags() & Message::ServerMsg) {
1016         // server notice
1017         redirectionTarget = _serverNoticesTarget;
1018       } else {
1019         redirectionTarget = _userNoticesTarget;
1020       }
1021     }
1022     break;
1023   case Message::Error:
1024     msg.setFlags(msg.flags() | Message::Redirected);
1025     redirectionTarget = _errorMsgsTarget;
1026     break;
1027   // Update IrcUser's last activity
1028   case Message::Plain:
1029   case Message::Action:
1030     if(bufferType(msg.bufferId()) == BufferInfo::ChannelBuffer) {
1031       const Network *net = Client::network(msg.bufferInfo().networkId());
1032       IrcUser *user = net ? net->ircUser(nickFromMask(msg.sender())) : 0;
1033       if(user)
1034         user->setLastChannelActivity(msg.bufferId(), msg.timestamp());
1035     }
1036     break;
1037   default:
1038     break;
1039   }
1040
1041   if(msg.flags() & Message::Redirected) {
1042     if(redirectionTarget & BufferSettings::DefaultBuffer)
1043       updateBufferActivity(bufferItem(msg.bufferInfo()), msg);
1044
1045     if(redirectionTarget & BufferSettings::StatusBuffer) {
1046       const NetworkItem *netItem = findNetworkItem(msg.bufferInfo().networkId());
1047       if(netItem) {
1048         updateBufferActivity(netItem->statusBufferItem(), msg);
1049       }
1050     }
1051   } else {
1052     updateBufferActivity(bufferItem(msg.bufferInfo()), msg);
1053   }
1054 }
1055
1056 void NetworkModel::updateBufferActivity(BufferItem *bufferItem, const Message &msg) {
1057   if(!bufferItem)
1058     return;
1059
1060   bufferItem->updateActivityLevel(msg);
1061   if(bufferItem->isCurrentBuffer())
1062     emit setLastSeenMsg(bufferItem->bufferId(), msg.msgId());
1063 }
1064
1065 void NetworkModel::setBufferActivity(const BufferId &bufferId, BufferInfo::ActivityLevel level) {
1066   BufferItem *bufferItem = findBufferItem(bufferId);
1067   if(!bufferItem) {
1068     qDebug() << "NetworkModel::setBufferActivity(): buffer is unknown:" << bufferId;
1069     return;
1070   }
1071   bufferItem->setActivityLevel(level);
1072 }
1073
1074 void NetworkModel::clearBufferActivity(const BufferId &bufferId) {
1075   BufferItem *bufferItem = findBufferItem(bufferId);
1076   if(!bufferItem) {
1077     qDebug() << "NetworkModel::clearBufferActivity(): buffer is unknown:" << bufferId;
1078     return;
1079   }
1080   bufferItem->clearActivityLevel();
1081 }
1082
1083 const Network *NetworkModel::networkByIndex(const QModelIndex &index) const {
1084   QVariant netVariant = index.data(NetworkIdRole);
1085   if(!netVariant.isValid())
1086     return 0;
1087
1088   NetworkId networkId = netVariant.value<NetworkId>();
1089   return Client::network(networkId);
1090 }
1091
1092 void NetworkModel::checkForRemovedBuffers(const QModelIndex &parent, int start, int end) {
1093   if(parent.data(ItemTypeRole) != NetworkItemType)
1094     return;
1095
1096   for(int row = start; row <= end; row++) {
1097     _bufferItemCache.remove(parent.child(row, 0).data(BufferIdRole).value<BufferId>());
1098   }
1099 }
1100
1101 void NetworkModel::checkForNewBuffers(const QModelIndex &parent, int start, int end) {
1102   if(parent.data(ItemTypeRole) != NetworkItemType)
1103     return;
1104
1105   for(int row = start; row <= end; row++) {
1106     QModelIndex child = parent.child(row, 0);
1107     _bufferItemCache[child.data(BufferIdRole).value<BufferId>()] = static_cast<BufferItem *>(child.internalPointer());
1108   }
1109 }
1110
1111 QString NetworkModel::bufferName(BufferId bufferId) const {
1112   if(!_bufferItemCache.contains(bufferId))
1113     return QString();
1114
1115   return _bufferItemCache[bufferId]->bufferName();
1116 }
1117
1118 BufferInfo::Type NetworkModel::bufferType(BufferId bufferId) const {
1119   if(!_bufferItemCache.contains(bufferId))
1120     return BufferInfo::InvalidBuffer;
1121
1122   return _bufferItemCache[bufferId]->bufferType();
1123 }
1124
1125 BufferInfo NetworkModel::bufferInfo(BufferId bufferId) const {
1126   if(!_bufferItemCache.contains(bufferId))
1127     return BufferInfo();
1128
1129   return _bufferItemCache[bufferId]->bufferInfo();
1130 }
1131
1132 NetworkId NetworkModel::networkId(BufferId bufferId) const {
1133   if(!_bufferItemCache.contains(bufferId))
1134     return NetworkId();
1135
1136   NetworkItem *netItem = qobject_cast<NetworkItem *>(_bufferItemCache[bufferId]->parent());
1137   if(netItem)
1138     return netItem->networkId();
1139   else
1140     return NetworkId();
1141 }
1142
1143 QString NetworkModel::networkName(BufferId bufferId) const {
1144   if(!_bufferItemCache.contains(bufferId))
1145     return QString();
1146
1147   NetworkItem *netItem = qobject_cast<NetworkItem *>(_bufferItemCache[bufferId]->parent());
1148   if(netItem)
1149     return netItem->networkName();
1150   else
1151     return QString();
1152 }
1153
1154 BufferId NetworkModel::bufferId(NetworkId networkId, const QString &bufferName, Qt::CaseSensitivity cs) const {
1155   const NetworkItem *netItem = findNetworkItem(networkId);
1156   if(!netItem)
1157     return BufferId();
1158
1159   for(int i = 0; i < netItem->childCount(); i++) {
1160     BufferItem *bufferItem = qobject_cast<BufferItem *>(netItem->child(i));
1161     if(bufferItem && !bufferItem->bufferName().compare(bufferName, cs))
1162       return bufferItem->bufferId();
1163   }
1164   return BufferId();
1165 }
1166
1167 void NetworkModel::sortBufferIds(QList<BufferId> &bufferIds) const {
1168   QList<BufferItem *> bufferItems;
1169   foreach(BufferId bufferId, bufferIds) {
1170     if(_bufferItemCache.contains(bufferId))
1171       bufferItems << _bufferItemCache[bufferId];
1172   }
1173
1174   qSort(bufferItems.begin(), bufferItems.end(), bufferItemLessThan);
1175
1176   bufferIds.clear();
1177   foreach(BufferItem *bufferItem, bufferItems) {
1178     bufferIds << bufferItem->bufferId();
1179   }
1180 }
1181
1182 QList<BufferId> NetworkModel::allBufferIdsSorted() const {
1183   QList<BufferId> bufferIds = allBufferIds();
1184   sortBufferIds(bufferIds);
1185   return bufferIds;
1186 }
1187
1188 bool NetworkModel::bufferItemLessThan(const BufferItem *left, const BufferItem *right) {
1189   int leftType = left->bufferType();
1190   int rightType = right->bufferType();
1191
1192   if(leftType != rightType)
1193     return leftType < rightType;
1194   else
1195     return QString::compare(left->bufferName(), right->bufferName(), Qt::CaseInsensitive) < 0;
1196 }
1197
1198 void NetworkModel::messageRedirectionSettingsChanged() {
1199   BufferSettings bufferSettings;
1200
1201   _userNoticesTarget = bufferSettings.userNoticesTarget();
1202   _serverNoticesTarget = bufferSettings.serverNoticesTarget();
1203   _errorMsgsTarget = bufferSettings.errorMsgsTarget();
1204 }