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 "client.h"
  28 #include "signalproxy.h"
  29 #include "network.h"
  30 #include "ircchannel.h"
  31
  32 #include "buffersettings.h"
  33
  34 #include "util.h" // get rid of this (needed for isChannelName)
  35
  36 /*****************************************
  37 *  Network Items
  38 *****************************************/
  39 NetworkItem::NetworkItem(const NetworkId &netid, AbstractTreeItem *parent)
  40   : PropertyMapItem(QList<QString>() << "networkName" << "currentServer" << "nickCount", parent),
  41     _networkId(netid),
  42     _statusBufferItem(0)
  43 {
  44   // DO NOT EMIT dataChanged() DIRECTLY IN NetworkItem
  45   // use networkDataChanged() instead. Otherwise you will end up in a infinite loop
  46   // as we "sync" the dataChanged() signals of NetworkItem and StatusBufferItem
  47   setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
  48   connect(this, SIGNAL(networkDataChanged(int)), this, SIGNAL(dataChanged(int)));
  49   connect(this, SIGNAL(beginRemoveChilds(int, int)), this, SLOT(onBeginRemoveChilds(int, int)));
  50 }
  51
  52 QVariant NetworkItem::data(int column, int role) const {
  53   switch(role) {
  54   case NetworkModel::BufferIdRole:
  55   case NetworkModel::BufferInfoRole:
  56   case NetworkModel::BufferTypeRole:
  57   case NetworkModel::BufferActivityRole:
  58     if(_statusBufferItem)
  59       return _statusBufferItem->data(column, role);
  60     else
  61       return QVariant();
  62   case NetworkModel::NetworkIdRole:
  63     return qVariantFromValue(_networkId);
  64   case NetworkModel::ItemTypeRole:
  65     return NetworkModel::NetworkItemType;
  66   case NetworkModel::ItemActiveRole:
  67     return isActive();
  68   default:
  69     return PropertyMapItem::data(column, role);
  70   }
  71 }
  72
  73 BufferItem *NetworkItem::findBufferItem(BufferId bufferId) {
  74   BufferItem *bufferItem = 0;
  75
  76   for(int i = 0; i < childCount(); i++) {
  77     bufferItem = qobject_cast<BufferItem *>(child(i));
  78     if(!bufferItem)
  79       continue;
  80     if(bufferItem->bufferId() == bufferId)
  81       return bufferItem;
  82   }
  83   return 0;
  84 }
  85
  86
  87 BufferItem *NetworkItem::bufferItem(const BufferInfo &bufferInfo) {
  88   BufferItem *bufferItem = findBufferItem(bufferInfo);
  89   if(bufferItem)
  90     return bufferItem;
  91
  92   switch(bufferInfo.type()) {
  93   case BufferInfo::StatusBuffer:
  94     _statusBufferItem = new StatusBufferItem(bufferInfo, this);
  95     bufferItem = _statusBufferItem;
  96     disconnect(this, SIGNAL(networkDataChanged(int)), this, SIGNAL(dataChanged(int)));
  97     connect(this, SIGNAL(networkDataChanged(int)), bufferItem, SIGNAL(dataChanged(int)));
  98     connect(bufferItem, SIGNAL(dataChanged(int)), this, SIGNAL(dataChanged(int)));
  99     break;
 100   case BufferInfo::ChannelBuffer:
 101     bufferItem = new ChannelBufferItem(bufferInfo, this);
 102     break;
 103   case BufferInfo::QueryBuffer:
 104     bufferItem = new QueryBufferItem(bufferInfo, this);
 105     break;
 106   default:
 107     bufferItem = new BufferItem(bufferInfo, this);
 108   }
 109
 110   newChild(bufferItem);
 111
 112   // postprocess... this is necessary because Qt doesn't seem to like adding childs which already have childs on their own
 113   switch(bufferInfo.type()) {
 114   case BufferInfo::ChannelBuffer:
 115     {
 116       ChannelBufferItem *channelBufferItem = static_cast<ChannelBufferItem *>(bufferItem);
 117       if(_network) {
 118         IrcChannel *ircChannel = _network->ircChannel(bufferInfo.bufferName());
 119         if(ircChannel)
 120           channelBufferItem->attachIrcChannel(ircChannel);
 121       }
 122     }
 123     break;
 124   default:
 125     break;
 126   }
 127
 128   return bufferItem;
 129 }
 130
 131 void NetworkItem::attachNetwork(Network *network) {
 132   if(!network)
 133     return;
 134
 135   _network = network;
 136
 137   connect(network, SIGNAL(networkNameSet(QString)),
 138           this, SLOT(setNetworkName(QString)));
 139   connect(network, SIGNAL(currentServerSet(QString)),
 140           this, SLOT(setCurrentServer(QString)));
 141   connect(network, SIGNAL(ircChannelAdded(IrcChannel *)),
 142           this, SLOT(attachIrcChannel(IrcChannel *)));
 143   connect(network, SIGNAL(ircUserAdded(IrcUser *)),
 144           this, SLOT(attachIrcUser(IrcUser *)));
 145   connect(network, SIGNAL(connectedSet(bool)),
 146           this, SIGNAL(networkDataChanged()));
 147   connect(network, SIGNAL(destroyed()),
 148           this, SIGNAL(networkDataChanged()));
 149
 150   emit networkDataChanged();
 151 }
 152
 153 void NetworkItem::attachIrcChannel(IrcChannel *ircChannel) {
 154   ChannelBufferItem *channelItem;
 155   for(int i = 0; i < childCount(); i++) {
 156     channelItem = qobject_cast<ChannelBufferItem *>(child(i));
 157     if(!channelItem)
 158       continue;
 159
 160     if(channelItem->bufferName().toLower() == ircChannel->name().toLower()) {
 161       channelItem->attachIrcChannel(ircChannel);
 162       return;
 163     }
 164   }
 165 }
 166
 167 void NetworkItem::attachIrcUser(IrcUser *ircUser) {
 168   QueryBufferItem *queryItem = 0;
 169   for(int i = 0; i < childCount(); i++) {
 170     queryItem = qobject_cast<QueryBufferItem *>(child(i));
 171     if(!queryItem)
 172       continue;
 173
 174     if(queryItem->bufferName().toLower() == ircUser->nick().toLower()) {
 175       queryItem->setIrcUser(ircUser);
 176       break;
 177     }
 178   }
 179 }
 180
 181 void NetworkItem::setNetworkName(const QString &networkName) {
 182   Q_UNUSED(networkName);
 183   emit networkDataChanged(0);
 184 }
 185
 186 void NetworkItem::setCurrentServer(const QString &serverName) {
 187   Q_UNUSED(serverName);
 188   emit networkDataChanged(1);
 189 }
 190
 191
 192 QString NetworkItem::toolTip(int column) const {
 193   Q_UNUSED(column);
 194
 195   QStringList toolTip(QString("<b>%1</b>").arg(Qt::escape(networkName())));
 196   toolTip.append(tr("Server: %1").arg(Qt::escape(currentServer())));
 197   toolTip.append(tr("Users: %1").arg(nickCount()));
 198
 199   if(_network) {
 200     toolTip.append(tr("Lag: %1 msecs").arg(_network->latency()));
 201   }
 202
 203   return QString("<p> %1 </p>").arg(toolTip.join("<br />"));
 204 }
 205
 206 void NetworkItem::onBeginRemoveChilds(int start, int end) {
 207   for(int i = start; i <= end; i++) {
 208     StatusBufferItem *statusBufferItem = qobject_cast<StatusBufferItem *>(child(i));
 209     if(statusBufferItem) {
 210       _statusBufferItem = 0;
 211       break;
 212     }
 213   }
 214 }
 215
 216 /*****************************************
 217 *  Fancy Buffer Items
 218 *****************************************/
 219 BufferItem::BufferItem(const BufferInfo &bufferInfo, AbstractTreeItem *parent)
 220   : PropertyMapItem(QStringList() << "bufferName" << "topic" << "nickCount", parent),
 221     _bufferInfo(bufferInfo),
 222     _activity(BufferInfo::NoActivity)
 223 {
 224   setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);
 225 }
 226
 227 void BufferItem::setActivityLevel(BufferInfo::ActivityLevel level) {
 228   if(_activity != level) {
 229     _activity = level;
 230     emit dataChanged();
 231   }
 232 }
 233
 234 void BufferItem::clearActivityLevel() {
 235   _activity = BufferInfo::NoActivity;
 236   _lastSeenMarkerMsgId = _lastSeenMsgId;
 237   _firstUnreadMsgId = MsgId();
 238   emit dataChanged();
 239 }
 240
 241 void BufferItem::updateActivityLevel(const Message &msg) {
 242   if(isCurrentBuffer()) {
 243     return;
 244   }
 245
 246   if(msg.flags() & Message::Self)       // don't update activity for our own messages
 247     return;
 248
 249   if(msg.msgId() <= lastSeenMsgId())
 250     return;
 251
 252   bool stateChanged = false;
 253   if(!firstUnreadMsgId().isValid() || msg.msgId() < firstUnreadMsgId()) {
 254     stateChanged = true;
 255     _firstUnreadMsgId = msg.msgId();
 256   }
 257
 258   BufferInfo::ActivityLevel oldLevel = activityLevel();
 259
 260   _activity |= BufferInfo::OtherActivity;
 261   if(msg.type() & (Message::Plain | Message::Notice | Message::Action))
 262     _activity |= BufferInfo::NewMessage;
 263
 264   if(msg.flags() & Message::Highlight)
 265     _activity |= BufferInfo::Highlight;
 266
 267   stateChanged |= (oldLevel != _activity);
 268
 269   if(stateChanged)
 270     emit dataChanged();
 271 }
 272
 273 QVariant BufferItem::data(int column, int role) const {
 274   switch(role) {
 275   case NetworkModel::ItemTypeRole:
 276     return NetworkModel::BufferItemType;
 277   case NetworkModel::BufferIdRole:
 278     return qVariantFromValue(bufferInfo().bufferId());
 279   case NetworkModel::NetworkIdRole:
 280     return qVariantFromValue(bufferInfo().networkId());
 281   case NetworkModel::BufferInfoRole:
 282     return qVariantFromValue(bufferInfo());
 283   case NetworkModel::BufferTypeRole:
 284     return int(bufferType());
 285   case NetworkModel::ItemActiveRole:
 286     return isActive();
 287   case NetworkModel::BufferActivityRole:
 288     return (int)activityLevel();
 289   case NetworkModel::BufferFirstUnreadMsgIdRole:
 290     return qVariantFromValue(firstUnreadMsgId());
 291   default:
 292     return PropertyMapItem::data(column, role);
 293   }
 294 }
 295
 296 bool BufferItem::setData(int column, const QVariant &value, int role) {
 297   switch(role) {
 298   case NetworkModel::BufferActivityRole:
 299     setActivityLevel((BufferInfo::ActivityLevel)value.toInt());
 300     return true;
 301   default:
 302     return PropertyMapItem::setData(column, value, role);
 303   }
 304   return true;
 305 }
 306
 307 void BufferItem::setBufferName(const QString &name) {
 308   _bufferInfo = BufferInfo(_bufferInfo.bufferId(), _bufferInfo.networkId(), _bufferInfo.type(), _bufferInfo.groupId(), name);
 309   emit dataChanged(0);
 310 }
 311
 312 void BufferItem::setLastSeenMsgId(const MsgId &msgId) {
 313   _lastSeenMsgId = msgId;
 314   if(!isCurrentBuffer()) {
 315     _lastSeenMarkerMsgId = msgId;
 316   }
 317   setActivityLevel(BufferInfo::NoActivity);
 318 }
 319
 320 bool BufferItem::isCurrentBuffer() const {
 321   return _bufferInfo.bufferId() == Client::bufferModel()->currentIndex().data(NetworkModel::BufferIdRole).value<BufferId>();
 322 }
 323
 324 QString BufferItem::toolTip(int column) const {
 325   Q_UNUSED(column);
 326   return tr("<p> %1 - %2 </p>").arg(bufferInfo().bufferId().toInt()).arg(bufferName());
 327 }
 328
 329 /*****************************************
 330 *  StatusBufferItem
 331 *****************************************/
 332 StatusBufferItem::StatusBufferItem(const BufferInfo &bufferInfo, NetworkItem *parent)
 333   : BufferItem(bufferInfo, parent)
 334 {
 335 }
 336
 337 QString StatusBufferItem::toolTip(int column) const {
 338   NetworkItem *networkItem = qobject_cast<NetworkItem *>(parent());
 339   if(networkItem)
 340     return networkItem->toolTip(column);
 341   else
 342     return QString();
 343 }
 344
 345 /*****************************************
 346 *  QueryBufferItem
 347 *****************************************/
 348 QueryBufferItem::QueryBufferItem(const BufferInfo &bufferInfo, NetworkItem *parent)
 349   : BufferItem(bufferInfo, parent),
 350     _ircUser(0)
 351 {
 352   setFlags(flags() | Qt::ItemIsDropEnabled | Qt::ItemIsEditable);
 353
 354   const Network *net = Client::network(bufferInfo.networkId());
 355   if(!net)
 356     return;
 357
 358   IrcUser *ircUser = net->ircUser(bufferInfo.bufferName());
 359   setIrcUser(ircUser);
 360 }
 361
 362 QVariant QueryBufferItem::data(int column, int role) const {
 363   switch(role) {
 364   case Qt::EditRole:
 365     return BufferItem::data(column, Qt::DisplayRole);
 366   case NetworkModel::IrcUserRole:
 367     return QVariant::fromValue<QObject *>(_ircUser);
 368   case NetworkModel::UserAwayRole:
 369     return (bool)_ircUser ? _ircUser->isAway() : false;
 370   default:
 371     return BufferItem::data(column, role);
 372   }
 373 }
 374
 375 bool QueryBufferItem::setData(int column, const QVariant &value, int role) {
 376   if(column != 0)
 377     return BufferItem::setData(column, value, role);
 378
 379   switch(role) {
 380   case Qt::EditRole:
 381     {
 382       QString newName = value.toString();
 383       if(!newName.isEmpty()) {
 384         Client::renameBuffer(bufferId(), newName);
 385         return true;
 386       } else {
 387         return false;
 388       }
 389     }
 390     break;
 391   default:
 392     return BufferItem::setData(column, value, role);
 393   }
 394 }
 395
 396 void QueryBufferItem::setBufferName(const QString &name) {
 397   BufferItem::setBufferName(name);
 398   NetworkId netId = data(0, NetworkModel::NetworkIdRole).value<NetworkId>();
 399   const Network *net = Client::network(netId);
 400   if(net)
 401     setIrcUser(net->ircUser(name));
 402 }
 403
 404 QString QueryBufferItem::toolTip(int column) const {
 405   // pretty much code duplication of IrcUserItem::toolTip() but inheritance won't solve this...
 406   Q_UNUSED(column);
 407   QStringList toolTip;
 408
 409   toolTip.append(tr("<b>Query with %1</b>").arg(bufferName()));
 410
 411   if(_ircUser) {
 412     if(_ircUser->userModes() != "") toolTip[0].append(QString(" (%1)").arg(_ircUser->userModes()));
 413     if(_ircUser->isAway()) {
 414       toolTip[0].append(QString(" (away%1)").arg(!_ircUser->awayMessage().isEmpty() ? (QString(" ") + _ircUser->awayMessage()) : QString()));
 415     }
 416     if(!_ircUser->realName().isEmpty()) toolTip.append(_ircUser->realName());
 417     if(!_ircUser->ircOperator().isEmpty()) toolTip.append(QString("%1 %2").arg(_ircUser->nick()).arg(_ircUser->ircOperator()));
 418     if(!_ircUser->suserHost().isEmpty()) toolTip.append(_ircUser->suserHost());
 419     if(!_ircUser->whoisServiceReply().isEmpty()) toolTip.append(_ircUser->whoisServiceReply());
 420
 421     toolTip.append(_ircUser->hostmask().remove(0, _ircUser->hostmask().indexOf("!")+1));
 422
 423     if(_ircUser->idleTime().isValid()) {
 424       QDateTime now = QDateTime::currentDateTime();
 425       QDateTime idle = _ircUser->idleTime();
 426       int idleTime = idle.secsTo(now);
 427       toolTip.append(tr("idling since %1").arg(secondsToString(idleTime)));
 428     }
 429     if(_ircUser->loginTime().isValid()) {
 430       toolTip.append(tr("login time: %1").arg(_ircUser->loginTime().toString()));
 431     }
 432
 433     if(!_ircUser->server().isEmpty()) toolTip.append(tr("server: %1").arg(_ircUser->server()));
 434   }
 435
 436   return QString("<p> %1 </p>").arg(toolTip.join("<br />"));
 437 }
 438
 439 void QueryBufferItem::setIrcUser(IrcUser *ircUser) {
 440   if(_ircUser == ircUser)
 441     return;
 442
 443   if(_ircUser) {
 444     disconnect(_ircUser, 0, this, 0);
 445   }
 446
 447   if(ircUser) {
 448     connect(ircUser, SIGNAL(quited()), this, SLOT(removeIrcUser()));
 449     connect(ircUser, SIGNAL(awaySet(bool)), this, SIGNAL(dataChanged()));
 450   }
 451
 452   _ircUser = ircUser;
 453   emit dataChanged();
 454 }
 455
 456 void QueryBufferItem::removeIrcUser() {
 457   _ircUser = 0;
 458   emit dataChanged();
 459 }
 460
 461 /*****************************************
 462 *  ChannelBufferItem
 463 *****************************************/
 464 ChannelBufferItem::ChannelBufferItem(const BufferInfo &bufferInfo, AbstractTreeItem *parent)
 465   : BufferItem(bufferInfo, parent),
 466     _ircChannel(0)
 467 {
 468 }
 469
 470 QVariant ChannelBufferItem::data(int column, int role) const {
 471   switch(role) {
 472     case NetworkModel::IrcChannelRole:
 473       return QVariant::fromValue<QObject *>(_ircChannel);
 474     default:
 475       return BufferItem::data(column, role);
 476   }
 477 }
 478
 479 QString ChannelBufferItem::toolTip(int column) const {
 480   Q_UNUSED(column);
 481   QStringList toolTip;
 482
 483   toolTip.append(tr("<b>Channel %1</b>").arg(Qt::escape(bufferName())));
 484   if(isActive()) {
 485     //TODO: add channel modes
 486     toolTip.append(tr("<b>Users:</b> %1").arg(nickCount()));
 487     if(_ircChannel) {
 488       QString channelMode = _ircChannel->channelModeString(); // channelModeString is compiled on the fly -> thus cache the result
 489       if(!channelMode.isEmpty())
 490         toolTip.append(tr("<b>Mode:</b> %1").arg(channelMode));
 491     }
 492
 493     BufferSettings s;
 494     bool showTopic = s.value("DisplayTopicInTooltip", QVariant(false)).toBool();
 495     if(showTopic) {
 496       QString _topic = topic();
 497       if(_topic != "") {
 498         _topic = stripFormatCodes(_topic);
 499         _topic = Qt::escape(_topic);
 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 }