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