src/client/networkmodel.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2019 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  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  19  ***************************************************************************/
  20
  21 #include "networkmodel.h"
  22
  23 #include <utility>
  24
  25 #include <QAbstractItemView>
  26 #include <QMimeData>
  27
  28 #include "buffermodel.h"
  29 #include "buffersettings.h"
  30 #include "buffersyncer.h"
  31 #include "client.h"
  32 #include "clientignorelistmanager.h"
  33 #include "clientsettings.h"
  34 #include "ircchannel.h"
  35 #include "network.h"
  36 #include "signalproxy.h"
  37
  38 /*****************************************
  39  *  Network Items
  40  *****************************************/
  41 NetworkItem::NetworkItem(const NetworkId& netid, AbstractTreeItem* parent)
  42     : PropertyMapItem(parent)
  43     , _networkId(netid)
  44     , _statusBufferItem(nullptr)
  45 {
  46     // DO NOT EMIT dataChanged() DIRECTLY IN NetworkItem
  47     // use networkDataChanged() instead. Otherwise you will end up in a infinite loop
  48     // as we "sync" the dataChanged() signals of NetworkItem and StatusBufferItem
  49     setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
  50     connect(this, &NetworkItem::networkDataChanged, this, &NetworkItem::dataChanged);
  51     connect(this, &NetworkItem::beginRemoveChilds, this, &NetworkItem::onBeginRemoveChilds);
  52 }
  53
  54 QStringList NetworkItem::propertyOrder() const
  55 {
  56     static QStringList order{"networkName", "currentServer", "nickCount"};
  57     return order;
  58 }
  59
  60 QVariant NetworkItem::data(int column, int role) const
  61 {
  62     switch (role) {
  63     case NetworkModel::BufferIdRole:
  64     case NetworkModel::BufferInfoRole:
  65     case NetworkModel::BufferTypeRole:
  66     case NetworkModel::BufferActivityRole:
  67         if (_statusBufferItem)
  68             return _statusBufferItem->data(column, role);
  69         else
  70             return QVariant();
  71     case NetworkModel::NetworkIdRole:
  72         return qVariantFromValue(_networkId);
  73     case NetworkModel::ItemTypeRole:
  74         return NetworkModel::NetworkItemType;
  75     case NetworkModel::ItemActiveRole:
  76         return isActive();
  77     default:
  78         return PropertyMapItem::data(column, role);
  79     }
  80 }
  81
  82 QString NetworkItem::escapeHTML(const QString& string, bool useNonbreakingSpaces)
  83 {
  84     // QString.replace() doesn't guarantee the source string will remain constant.
  85     // Use a local variable to avoid compiler errors.
  86     QString formattedString = string.toHtmlEscaped();
  87     return (useNonbreakingSpaces ? formattedString.replace(" ", "&nbsp;") : formattedString);
  88 }
  89
  90 // FIXME shouldn't we check the bufferItemCache here?
  91 BufferItem* NetworkItem::findBufferItem(BufferId bufferId)
  92 {
  93     BufferItem* bufferItem = nullptr;
  94
  95     for (int i = 0; i < childCount(); i++) {
  96         bufferItem = qobject_cast<BufferItem*>(child(i));
  97         if (!bufferItem)
  98             continue;
  99         if (bufferItem->bufferId() == bufferId)
 100             return bufferItem;
 101     }
 102     return nullptr;
 103 }
 104
 105 BufferItem* NetworkItem::bufferItem(const BufferInfo& bufferInfo)
 106 {
 107     BufferItem* bufferItem = findBufferItem(bufferInfo);
 108     if (bufferItem)
 109         return bufferItem;
 110
 111     switch (bufferInfo.type()) {
 112     case BufferInfo::StatusBuffer:
 113         _statusBufferItem = new StatusBufferItem(bufferInfo, this);
 114         bufferItem = _statusBufferItem;
 115         disconnect(this, &NetworkItem::networkDataChanged, this, &NetworkItem::dataChanged);
 116         connect(this, &NetworkItem::networkDataChanged, bufferItem, &BufferItem::dataChanged);
 117         connect(bufferItem, &BufferItem::dataChanged, this, &NetworkItem::dataChanged);
 118         break;
 119     case BufferInfo::ChannelBuffer:
 120         bufferItem = new ChannelBufferItem(bufferInfo, this);
 121         break;
 122     case BufferInfo::QueryBuffer:
 123         bufferItem = new QueryBufferItem(bufferInfo, this);
 124         break;
 125     default:
 126         bufferItem = new BufferItem(bufferInfo, this);
 127     }
 128
 129     newChild(bufferItem);
 130
 131     // postprocess... this is necessary because Qt doesn't seem to like adding children which already have children on their own
 132     switch (bufferInfo.type()) {
 133     case BufferInfo::ChannelBuffer: {
 134         auto* channelBufferItem = static_cast<ChannelBufferItem*>(bufferItem);
 135         if (_network) {
 136             IrcChannel* ircChannel = _network->ircChannel(bufferInfo.bufferName());
 137             if (ircChannel)
 138                 channelBufferItem->attachIrcChannel(ircChannel);
 139         }
 140     } break;
 141     default:
 142         break;
 143     }
 144
 145     BufferSyncer* bufferSyncer = Client::bufferSyncer();
 146     if (bufferSyncer) {
 147         bufferItem->addActivity(bufferSyncer->activity(bufferItem->bufferId()), bufferSyncer->highlightCount(bufferItem->bufferId()) > 0);
 148     }
 149
 150     return bufferItem;
 151 }
 152
 153 void NetworkItem::attachNetwork(Network* network)
 154 {
 155     if (!network)
 156         return;
 157
 158     _network = network;
 159
 160     connect(network, &Network::networkNameSet, this, &NetworkItem::setNetworkName);
 161     connect(network, &Network::currentServerSet, this, &NetworkItem::setCurrentServer);
 162     connect(network, &Network::ircChannelAdded, this, &NetworkItem::attachIrcChannel);
 163     connect(network, &Network::ircUserAdded, this, &NetworkItem::attachIrcUser);
 164     connect(network, &Network::connectedSet, this, [this]() { emit networkDataChanged(); });
 165     connect(network, &QObject::destroyed, this, &NetworkItem::onNetworkDestroyed);
 166
 167     emit networkDataChanged();
 168 }
 169
 170 void NetworkItem::attachIrcChannel(IrcChannel* ircChannel)
 171 {
 172     ChannelBufferItem* channelItem;
 173     for (int i = 0; i < childCount(); i++) {
 174         channelItem = qobject_cast<ChannelBufferItem*>(child(i));
 175         if (!channelItem)
 176             continue;
 177
 178         if (channelItem->bufferName().toLower() == ircChannel->name().toLower()) {
 179             channelItem->attachIrcChannel(ircChannel);
 180             return;
 181         }
 182     }
 183 }
 184
 185 void NetworkItem::attachIrcUser(IrcUser* ircUser)
 186 {
 187     QueryBufferItem* queryItem = nullptr;
 188     for (int i = 0; i < childCount(); i++) {
 189         queryItem = qobject_cast<QueryBufferItem*>(child(i));
 190         if (!queryItem)
 191             continue;
 192
 193         if (queryItem->bufferName().toLower() == ircUser->nick().toLower()) {
 194             queryItem->setIrcUser(ircUser);
 195             break;
 196         }
 197     }
 198 }
 199
 200 void NetworkItem::setNetworkName(const QString& networkName)
 201 {
 202     Q_UNUSED(networkName);
 203     emit networkDataChanged(0);
 204 }
 205
 206 void NetworkItem::setCurrentServer(const QString& serverName)
 207 {
 208     Q_UNUSED(serverName);
 209     emit networkDataChanged(1);
 210 }
 211
 212 QString NetworkItem::toolTip(int column) const
 213 {
 214     Q_UNUSED(column);
 215     QString strTooltip;
 216     QTextStream tooltip(&strTooltip, QIODevice::WriteOnly);
 217     tooltip << "<qt><style>.bold { font-weight: bold; } .italic { font-style: italic; }</style>";
 218
 219     // Function to add a row to the tooltip table
 220     auto addRow = [&](const QString& key, const QString& value, bool condition) {
 221         if (condition) {
 222             tooltip << "<tr><td class='bold' align='right'>" << key << "</td><td>" << value << "</td></tr>";
 223         }
 224     };
 225
 226     tooltip << "<p class='bold' align='center'>" << NetworkItem::escapeHTML(networkName(), true) << "</p>";
 227     if (isActive()) {
 228         tooltip << "<table cellspacing='5' cellpadding='0'>";
 229         addRow(tr("Server"), NetworkItem::escapeHTML(currentServer(), true), !currentServer().isEmpty());
 230         addRow(tr("Users"), QString::number(nickCount()), true);
 231         if (_network)
 232             addRow(tr("Lag"), NetworkItem::escapeHTML(tr("%1 msecs").arg(_network->latency()), true), true);
 233
 234         tooltip << "</table>";
 235     }
 236     else {
 237         tooltip << "<p class='italic' align='center'>" << tr("Not connected") << "</p>";
 238     }
 239     tooltip << "</qt>";
 240     return strTooltip;
 241 }
 242
 243 void NetworkItem::onBeginRemoveChilds(int start, int end)
 244 {
 245     for (int i = start; i <= end; i++) {
 246         auto* statusBufferItem = qobject_cast<StatusBufferItem*>(child(i));
 247         if (statusBufferItem) {
 248             _statusBufferItem = nullptr;
 249             break;
 250         }
 251     }
 252 }
 253
 254 void NetworkItem::onNetworkDestroyed()
 255 {
 256     _network = nullptr;
 257     emit networkDataChanged();
 258     removeAllChilds();
 259 }
 260
 261 /*****************************************
 262  *  Fancy Buffer Items
 263  *****************************************/
 264 BufferItem::BufferItem(BufferInfo bufferInfo, AbstractTreeItem* parent)
 265     : PropertyMapItem(parent)
 266     , _bufferInfo(std::move(bufferInfo))
 267     , _activity(BufferInfo::NoActivity)
 268 {
 269     setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);
 270 }
 271
 272 QStringList BufferItem::propertyOrder() const
 273 {
 274     static QStringList order{"bufferName", "topic", "nickCount"};
 275     return order;
 276 }
 277
 278 void BufferItem::setActivityLevel(BufferInfo::ActivityLevel level)
 279 {
 280     if (_activity != level) {
 281         _activity = level;
 282         emit dataChanged();
 283     }
 284 }
 285
 286 void BufferItem::clearActivityLevel()
 287 {
 288     if (Client::isCoreFeatureEnabled(Quassel::Feature::BufferActivitySync)) {
 289         // If the core handles activity sync, clear only the highlight flag
 290         _activity &= ~BufferInfo::Highlight;
 291     }
 292     else {
 293         _activity = BufferInfo::NoActivity;
 294     }
 295     _firstUnreadMsgId = MsgId();
 296
 297     // FIXME remove with core proto v11
 298     if (!Client::isCoreFeatureEnabled(Quassel::Feature::SynchronizedMarkerLine)) {
 299         _markerLineMsgId = _lastSeenMsgId;
 300     }
 301
 302     emit dataChanged();
 303 }
 304
 305 void BufferItem::updateActivityLevel(const Message& msg)
 306 {
 307     // If the core handles activity, and this message is not a highlight, ignore this
 308     if (Client::isCoreFeatureEnabled(Quassel::Feature::BufferActivitySync) && !msg.flags().testFlag(Message::Highlight)) {
 309         return;
 310     }
 311
 312     if (isCurrentBuffer()) {
 313         return;
 314     }
 315
 316     if (msg.flags() & Message::Self)  // don't update activity for our own messages
 317         return;
 318
 319     if (Client::ignoreListManager() && Client::ignoreListManager()->match(msg, qobject_cast<NetworkItem*>(parent())->networkName()))
 320         return;
 321
 322     if (msg.msgId() <= lastSeenMsgId())
 323         return;
 324
 325     bool stateChanged = false;
 326     if (!firstUnreadMsgId().isValid() || msg.msgId() < firstUnreadMsgId()) {
 327         stateChanged = true;
 328         _firstUnreadMsgId = msg.msgId();
 329     }
 330
 331     Message::Types type;
 332     // If the core handles activities, ignore types
 333     if (Client::isCoreFeatureEnabled(Quassel::Feature::BufferActivitySync)) {
 334         type = Message::Types();
 335     }
 336     else {
 337         type = msg.type();
 338     }
 339
 340     if (addActivity(type, msg.flags().testFlag(Message::Highlight)) || stateChanged) {
 341         emit dataChanged();
 342     }
 343 }
 344
 345 void BufferItem::setActivity(Message::Types type, bool highlight)
 346 {
 347     BufferInfo::ActivityLevel oldLevel = activityLevel();
 348
 349     _activity &= BufferInfo::Highlight;
 350     addActivity(type, highlight);
 351
 352     if (_activity != oldLevel) {
 353         emit dataChanged();
 354     }
 355 }
 356
 357 bool BufferItem::addActivity(Message::Types type, bool highlight)
 358 {
 359     auto oldActivity = activityLevel();
 360
 361     if (type != Message::Types())
 362         _activity |= BufferInfo::OtherActivity;
 363
 364     if (type.testFlag(Message::Plain) || type.testFlag(Message::Notice) || type.testFlag(Message::Action))
 365         _activity |= BufferInfo::NewMessage;
 366
 367     if (highlight)
 368         _activity |= BufferInfo::Highlight;
 369
 370     return oldActivity != _activity;
 371 }
 372
 373 QVariant BufferItem::data(int column, int role) const
 374 {
 375     switch (role) {
 376     case NetworkModel::ItemTypeRole:
 377         return NetworkModel::BufferItemType;
 378     case NetworkModel::BufferIdRole:
 379         return qVariantFromValue(bufferInfo().bufferId());
 380     case NetworkModel::NetworkIdRole:
 381         return qVariantFromValue(bufferInfo().networkId());
 382     case NetworkModel::BufferInfoRole:
 383         return qVariantFromValue(bufferInfo());
 384     case NetworkModel::BufferTypeRole:
 385         return int(bufferType());
 386     case NetworkModel::ItemActiveRole:
 387         return isActive();
 388     case NetworkModel::BufferActivityRole:
 389         return (int)activityLevel();
 390     case NetworkModel::BufferFirstUnreadMsgIdRole:
 391         return qVariantFromValue(firstUnreadMsgId());
 392     case NetworkModel::MarkerLineMsgIdRole:
 393         return qVariantFromValue(markerLineMsgId());
 394     default:
 395         return PropertyMapItem::data(column, role);
 396     }
 397 }
 398
 399 bool BufferItem::setData(int column, const QVariant& value, int role)
 400 {
 401     switch (role) {
 402     case NetworkModel::BufferActivityRole:
 403         setActivityLevel((BufferInfo::ActivityLevel)value.toInt());
 404         return true;
 405     default:
 406         return PropertyMapItem::setData(column, value, role);
 407     }
 408 }
 409
 410 void BufferItem::setBufferName(const QString& name)
 411 {
 412     _bufferInfo = BufferInfo(_bufferInfo.bufferId(), _bufferInfo.networkId(), _bufferInfo.type(), _bufferInfo.groupId(), name);
 413     emit dataChanged(0);
 414 }
 415
 416 void BufferItem::setLastSeenMsgId(MsgId msgId)
 417 {
 418     _lastSeenMsgId = msgId;
 419
 420     // FIXME remove with core protocol v11
 421     if (!Client::isCoreFeatureEnabled(Quassel::Feature::SynchronizedMarkerLine)) {
 422         if (!isCurrentBuffer())
 423             _markerLineMsgId = msgId;
 424     }
 425
 426     setActivityLevel(BufferInfo::NoActivity);
 427 }
 428
 429 void BufferItem::setMarkerLineMsgId(MsgId msgId)
 430 {
 431     _markerLineMsgId = msgId;
 432     emit dataChanged();
 433 }
 434
 435 bool BufferItem::isCurrentBuffer() const
 436 {
 437     return _bufferInfo.bufferId() == Client::bufferModel()->currentIndex().data(NetworkModel::BufferIdRole).value<BufferId>();
 438 }
 439
 440 QString BufferItem::toolTip(int column) const
 441 {
 442     Q_UNUSED(column);
 443     return tr("<p> %1 - %2 </p>").arg(bufferInfo().bufferId().toInt()).arg(bufferName());
 444 }
 445
 446 /*****************************************
 447  *  StatusBufferItem
 448  *****************************************/
 449 StatusBufferItem::StatusBufferItem(const BufferInfo& bufferInfo, NetworkItem* parent)
 450     : BufferItem(bufferInfo, parent)
 451 {}
 452
 453 QString StatusBufferItem::toolTip(int column) const
 454 {
 455     auto* networkItem = qobject_cast<NetworkItem*>(parent());
 456     if (networkItem)
 457         return networkItem->toolTip(column);
 458     else
 459         return QString();
 460 }
 461
 462 /*****************************************
 463  *  QueryBufferItem
 464  *****************************************/
 465 QueryBufferItem::QueryBufferItem(const BufferInfo& bufferInfo, NetworkItem* parent)
 466     : BufferItem(bufferInfo, parent)
 467     , _ircUser(nullptr)
 468 {
 469     setFlags(flags() | Qt::ItemIsDropEnabled | Qt::ItemIsEditable);
 470
 471     const Network* net = Client::network(bufferInfo.networkId());
 472     if (!net)
 473         return;
 474
 475     IrcUser* ircUser = net->ircUser(bufferInfo.bufferName());
 476     setIrcUser(ircUser);
 477 }
 478
 479 QVariant QueryBufferItem::data(int column, int role) const
 480 {
 481     switch (role) {
 482     case Qt::EditRole:
 483         return BufferItem::data(column, Qt::DisplayRole);
 484     case NetworkModel::IrcUserRole:
 485         return QVariant::fromValue<QObject*>(_ircUser);
 486     case NetworkModel::UserAwayRole:
 487         return (bool)_ircUser ? _ircUser->isAway() : false;
 488     default:
 489         return BufferItem::data(column, role);
 490     }
 491 }
 492
 493 bool QueryBufferItem::setData(int column, const QVariant& value, int role)
 494 {
 495     if (column != 0)
 496         return BufferItem::setData(column, value, role);
 497
 498     switch (role) {
 499     case Qt::EditRole: {
 500         QString newName = value.toString();
 501
 502         // Sanity check - buffer names must not contain newlines!
 503         int nlpos = newName.indexOf('\n');
 504         if (nlpos >= 0)
 505             newName = newName.left(nlpos);
 506
 507         if (!newName.isEmpty()) {
 508             Client::renameBuffer(bufferId(), newName);
 509             return true;
 510         }
 511         else {
 512             return false;
 513         }
 514     } break;
 515     default:
 516         return BufferItem::setData(column, value, role);
 517     }
 518 }
 519
 520 void QueryBufferItem::setBufferName(const QString& name)
 521 {
 522     BufferItem::setBufferName(name);
 523     NetworkId netId = data(0, NetworkModel::NetworkIdRole).value<NetworkId>();
 524     const Network* net = Client::network(netId);
 525     if (net)
 526         setIrcUser(net->ircUser(name));
 527 }
 528
 529 QString QueryBufferItem::toolTip(int column) const
 530 {
 531     // pretty much code duplication of IrcUserItem::toolTip() but inheritance won't solve this...
 532     Q_UNUSED(column);
 533     QString strTooltip;
 534     QTextStream tooltip(&strTooltip, QIODevice::WriteOnly);
 535     tooltip << "<qt><style>.bold { font-weight: bold; } .italic { font-style: italic; }</style>";
 536
 537     // Keep track of whether or not information has been added
 538     bool infoAdded = false;
 539
 540     // Use bufferName() for QueryBufferItem, nickName() for IrcUserItem
 541     tooltip << "<p class='bold' align='center'>";
 542     tooltip << tr("Query with %1").arg(NetworkItem::escapeHTML(bufferName(), true));
 543     if (!_ircUser) {
 544         // User seems to be offline, let the no information message be added below
 545         tooltip << "</p>";
 546     }
 547     else {
 548         // Function to add a row to the tooltip table
 549         auto addRow = [&](const QString& key, const QString& value, bool condition) {
 550             if (condition) {
 551                 tooltip << "<tr><td class='bold' align='right'>" << key << "</td><td>" << value << "</td></tr>";
 552                 infoAdded = true;
 553             }
 554         };
 555
 556         // User information is available
 557         if (_ircUser->userModes() != "") {
 558             // TODO Translate user Modes and add them to the table below and in IrcUserItem::toolTip
 559             tooltip << " (" << _ircUser->userModes() << ")";
 560         }
 561         tooltip << "</p>";
 562
 563         tooltip << "<table cellspacing='5' cellpadding='0'>";
 564         if (_ircUser->isAway()) {
 565             QString awayMessageHTML = QString("<p class='italic'>%1</p>").arg(tr("Unknown"));
 566
 567             // If away message is known, replace with the escaped message.
 568             if (!_ircUser->awayMessage().isEmpty()) {
 569                 awayMessageHTML = NetworkItem::escapeHTML(_ircUser->awayMessage());
 570             }
 571             addRow(NetworkItem::escapeHTML(tr("Away message"), true), awayMessageHTML, true);
 572         }
 573         addRow(tr("Realname"), NetworkItem::escapeHTML(_ircUser->realName()), !_ircUser->realName().isEmpty());
 574         // suserHost may return "<nick> is available for help", which should be translated.
 575         // See https://www.alien.net.au/irc/irc2numerics.html
 576         if (_ircUser->suserHost().endsWith("available for help")) {
 577             addRow(NetworkItem::escapeHTML(tr("Help status"), true), NetworkItem::escapeHTML(tr("Available for help")), true);
 578         }
 579         else {
 580             addRow(NetworkItem::escapeHTML(tr("Service status"), true),
 581                    NetworkItem::escapeHTML(_ircUser->suserHost()),
 582                    !_ircUser->suserHost().isEmpty());
 583         }
 584
 585         // Keep track of whether or not the account information's been added.  Don't show it twice.
 586         bool accountAdded = false;
 587         if (!_ircUser->account().isEmpty()) {
 588             // IRCv3 account-notify is supported by the core and IRC server.
 589             // Assume logged out (seems to be more common)
 590             QString accountHTML = QString("<p class='italic'>%1</p>").arg(tr("Not logged in"));
 591
 592             // If account is logged in, replace with the escaped account name.
 593             if (_ircUser->account() != "*") {
 594                 accountHTML = NetworkItem::escapeHTML(_ircUser->account());
 595             }
 596             addRow(NetworkItem::escapeHTML(tr("Account"), true), accountHTML, true);
 597             // Mark the row as added
 598             accountAdded = true;
 599         }
 600         // whoisServiceReply may return "<nick> is identified for this nick", which should be translated.
 601         // See https://www.alien.net.au/irc/irc2numerics.html
 602         if (_ircUser->whoisServiceReply().endsWith("identified for this nick")) {
 603             addRow(NetworkItem::escapeHTML(tr("Account"), true), NetworkItem::escapeHTML(tr("Identified for this nick")), !accountAdded);
 604             // Don't add the account row again if information's already added via account-notify
 605             // Not used further down...
 606             // accountAdded = true;
 607         }
 608         else {
 609             addRow(NetworkItem::escapeHTML(tr("Service Reply"), true),
 610                    NetworkItem::escapeHTML(_ircUser->whoisServiceReply()),
 611                    !_ircUser->whoisServiceReply().isEmpty());
 612         }
 613         addRow(tr("Hostmask"),
 614                NetworkItem::escapeHTML(_ircUser->hostmask().remove(0, _ircUser->hostmask().indexOf("!") + 1)),
 615                !(_ircUser->hostmask().remove(0, _ircUser->hostmask().indexOf("!") + 1) == "@"));
 616         // ircOperator may contain "is an" or "is a", which should be removed.
 617         addRow(tr("Operator"),
 618                NetworkItem::escapeHTML(_ircUser->ircOperator().replace("is an ", "").replace("is a ", "")),
 619                !_ircUser->ircOperator().isEmpty());
 620
 621         if (_ircUser->idleTime().isValid()) {
 622             QDateTime now = QDateTime::currentDateTime();
 623             QDateTime idle = _ircUser->idleTime();
 624             int idleTime = idle.secsTo(now);
 625             addRow(NetworkItem::escapeHTML(tr("Idling since"), true), secondsToString(idleTime), true);
 626         }
 627
 628         if (_ircUser->loginTime().isValid()) {
 629             addRow(NetworkItem::escapeHTML(tr("Login time"), true), _ircUser->loginTime().toString(), true);
 630         }
 631
 632         addRow(tr("Server"), NetworkItem::escapeHTML(_ircUser->server()), !_ircUser->server().isEmpty());
 633         tooltip << "</table>";
 634     }
 635
 636     // If no further information found, offer an explanatory message
 637     if (!infoAdded)
 638         tooltip << "<p class='italic' align='center'>" << tr("No information available") << "</p>";
 639
 640     tooltip << "</qt>";
 641     return strTooltip;
 642 }
 643
 644 void QueryBufferItem::setIrcUser(IrcUser* ircUser)
 645 {
 646     if (_ircUser == ircUser)
 647         return;
 648
 649     if (_ircUser) {
 650         disconnect(_ircUser, nullptr, this, nullptr);
 651     }
 652
 653     if (ircUser) {
 654         connect(ircUser, &IrcUser::destroyed, this, &QueryBufferItem::removeIrcUser);
 655         connect(ircUser, &IrcUser::quited, this, &QueryBufferItem::removeIrcUser);
 656         connect(ircUser, &IrcUser::awaySet, this, [this]() { emit dataChanged(); });
 657         connect(ircUser, &IrcUser::encryptedSet, this, &BufferItem::setEncrypted);
 658     }
 659
 660     _ircUser = ircUser;
 661     emit dataChanged();
 662 }
 663
 664 void QueryBufferItem::removeIrcUser()
 665 {
 666     if (_ircUser) {
 667         // Disconnect the active IrcUser before removing it, otherwise it will fire removeIrcUser()
 668         // a second time when the object's destroyed due to QueryBufferItem::setIrcUser() connecting
 669         // SIGNAL destroyed(QObject*) to SLOT removeIrcUser().
 670         // This fixes removing an active IrcUser if the user had quit then rejoined in a nonstandard
 671         // manner (e.g. updateNickFromHost calling newIrcUser, triggered by an away-notify message).
 672         disconnect(_ircUser, nullptr, this, nullptr);
 673
 674         // Clear IrcUser (only set to 0 if not already 0)
 675         _ircUser = nullptr;
 676
 677         // Only emit dataChanged() if data actually changed.  This might serve as a small
 678         // optimization, but it can be moved outside the if statement if other behavior depends on
 679         // it always being called.
 680         emit dataChanged();
 681     }
 682 }
 683
 684 /*****************************************
 685  *  ChannelBufferItem
 686  *****************************************/
 687 ChannelBufferItem::ChannelBufferItem(const BufferInfo& bufferInfo, AbstractTreeItem* parent)
 688     : BufferItem(bufferInfo, parent)
 689     , _ircChannel(nullptr)
 690 {
 691     setFlags(flags() | Qt::ItemIsDropEnabled);
 692 }
 693
 694 QVariant ChannelBufferItem::data(int column, int role) const
 695 {
 696     switch (role) {
 697     case NetworkModel::IrcChannelRole:
 698         return QVariant::fromValue<QObject*>(_ircChannel);
 699     default:
 700         return BufferItem::data(column, role);
 701     }
 702 }
 703
 704 QString ChannelBufferItem::toolTip(int column) const
 705 {
 706     Q_UNUSED(column);
 707     QString strTooltip;
 708     QTextStream tooltip(&strTooltip, QIODevice::WriteOnly);
 709     tooltip << "<qt><style>.bold { font-weight: bold; } .italic { font-style: italic; }</style>";
 710
 711     // Function to add a row to the tooltip table
 712     auto addRow = [&](const QString& key, const QString& value, bool condition) {
 713         if (condition) {
 714             tooltip << "<tr><td class='bold' align='right'>" << key << "</td><td>" << value << "</td></tr>";
 715         }
 716     };
 717
 718     tooltip << "<p class='bold' align='center'>";
 719     tooltip << NetworkItem::escapeHTML(tr("Channel %1").arg(bufferName()), true) << "</p>";
 720
 721     if (isActive()) {
 722         tooltip << "<table cellspacing='5' cellpadding='0'>";
 723         addRow(tr("Users"), QString::number(nickCount()), true);
 724
 725         if (_ircChannel) {
 726             QString channelMode = _ircChannel->channelModeString();  // channelModeString is compiled on the fly -> thus cache the result
 727             if (!channelMode.isEmpty())
 728                 addRow(tr("Mode"), channelMode, true);
 729         }
 730
 731         ItemViewSettings s;
 732         bool showTopic = s.displayTopicInTooltip();
 733         if (showTopic) {
 734             QString _topic = topic();
 735             if (_topic != "") {
 736                 _topic = stripFormatCodes(_topic);
 737                 _topic = NetworkItem::escapeHTML(_topic);
 738                 addRow(tr("Topic"), _topic, true);
 739             }
 740         }
 741
 742         tooltip << "</table>";
 743     }
 744     else {
 745         tooltip << "<p class='italic' align='center'>" << tr("Not active, double-click to join") << "</p>";
 746     }
 747
 748     tooltip << "</qt>";
 749     return strTooltip;
 750 }
 751
 752 void ChannelBufferItem::attachIrcChannel(IrcChannel* ircChannel)
 753 {
 754     if (_ircChannel) {
 755         qWarning() << Q_FUNC_INFO << "IrcChannel already set; cleanup failed!?";
 756         disconnect(_ircChannel, nullptr, this, nullptr);
 757     }
 758
 759     _ircChannel = ircChannel;
 760
 761     connect(ircChannel, &QObject::destroyed, this, &ChannelBufferItem::ircChannelDestroyed);
 762     connect(ircChannel, &IrcChannel::topicSet, this, &ChannelBufferItem::setTopic);
 763     connect(ircChannel, &IrcChannel::encryptedSet, this, &ChannelBufferItem::setEncrypted);
 764     connect(ircChannel, &IrcChannel::ircUsersJoined, this, &ChannelBufferItem::join);
 765     connect(ircChannel, &IrcChannel::ircUserParted, this, &ChannelBufferItem::part);
 766     connect(ircChannel, &IrcChannel::parted, this, &ChannelBufferItem::ircChannelParted);
 767     connect(ircChannel, &IrcChannel::ircUserModesSet, this, &ChannelBufferItem::userModeChanged);
 768     connect(ircChannel, &IrcChannel::ircUserModeAdded, this, &ChannelBufferItem::userModeChanged);
 769     connect(ircChannel, &IrcChannel::ircUserModeRemoved, this, &ChannelBufferItem::userModeChanged);
 770
 771     if (!ircChannel->ircUsers().isEmpty())
 772         join(ircChannel->ircUsers());
 773
 774     emit dataChanged();
 775 }
 776
 777 QString ChannelBufferItem::nickChannelModes(const QString& nick) const
 778 {
 779     if (!_ircChannel) {
 780         qDebug() << Q_FUNC_INFO << "IrcChannel not set, can't get user modes";
 781         return QString();
 782     }
 783
 784     return _ircChannel->userModes(nick);
 785 }
 786
 787 void ChannelBufferItem::ircChannelParted()
 788 {
 789     Q_CHECK_PTR(_ircChannel);
 790     disconnect(_ircChannel, nullptr, this, nullptr);
 791     _ircChannel = nullptr;
 792     emit dataChanged();
 793     removeAllChilds();
 794 }
 795
 796 void ChannelBufferItem::ircChannelDestroyed()
 797 {
 798     if (_ircChannel) {
 799         _ircChannel = nullptr;
 800         emit dataChanged();
 801         removeAllChilds();
 802     }
 803 }
 804
 805 void ChannelBufferItem::join(const QList<IrcUser*>& ircUsers)
 806 {
 807     addUsersToCategory(ircUsers);
 808     emit dataChanged(2);
 809 }
 810
 811 UserCategoryItem* ChannelBufferItem::findCategoryItem(int categoryId)
 812 {
 813     UserCategoryItem* categoryItem = nullptr;
 814
 815     for (int i = 0; i < childCount(); i++) {
 816         categoryItem = qobject_cast<UserCategoryItem*>(child(i));
 817         if (!categoryItem)
 818             continue;
 819         if (categoryItem->categoryId() == categoryId)
 820             return categoryItem;
 821     }
 822     return nullptr;
 823 }
 824
 825 void ChannelBufferItem::addUserToCategory(IrcUser* ircUser)
 826 {
 827     addUsersToCategory(QList<IrcUser*>() << ircUser);
 828 }
 829
 830 void ChannelBufferItem::addUsersToCategory(const QList<IrcUser*>& ircUsers)
 831 {
 832     Q_ASSERT(_ircChannel);
 833
 834     QHash<UserCategoryItem*, QList<IrcUser*>> categories;
 835
 836     int categoryId = -1;
 837     UserCategoryItem* categoryItem = nullptr;
 838
 839     foreach (IrcUser* ircUser, ircUsers) {
 840         categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
 841         categoryItem = findCategoryItem(categoryId);
 842         if (!categoryItem) {
 843             categoryItem = new UserCategoryItem(categoryId, this);
 844             categories[categoryItem] = QList<IrcUser*>();
 845             newChild(categoryItem);
 846         }
 847         categories[categoryItem] << ircUser;
 848     }
 849
 850     QHash<UserCategoryItem*, QList<IrcUser*>>::const_iterator catIter = categories.constBegin();
 851     while (catIter != categories.constEnd()) {
 852         catIter.key()->addUsers(catIter.value());
 853         ++catIter;
 854     }
 855 }
 856
 857 void ChannelBufferItem::part(IrcUser* ircUser)
 858 {
 859     if (!ircUser) {
 860         qWarning() << bufferName() << "ChannelBufferItem::part(): unknown User" << ircUser;
 861         return;
 862     }
 863
 864     disconnect(ircUser, nullptr, this, nullptr);
 865     removeUserFromCategory(ircUser);
 866     emit dataChanged(2);
 867 }
 868
 869 void ChannelBufferItem::removeUserFromCategory(IrcUser* ircUser)
 870 {
 871     if (!_ircChannel) {
 872         // If we parted the channel there might still be some ircUsers connected.
 873         // in that case we just ignore the call
 874         Q_ASSERT(childCount() == 0);
 875         return;
 876     }
 877
 878     UserCategoryItem* categoryItem = nullptr;
 879     for (int i = 0; i < childCount(); i++) {
 880         categoryItem = qobject_cast<UserCategoryItem*>(child(i));
 881         if (categoryItem->removeUser(ircUser)) {
 882             if (categoryItem->childCount() == 0)
 883                 removeChild(i);
 884             break;
 885         }
 886     }
 887 }
 888
 889 void ChannelBufferItem::userModeChanged(IrcUser* ircUser)
 890 {
 891     Q_ASSERT(_ircChannel);
 892
 893     int categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
 894     UserCategoryItem* categoryItem = findCategoryItem(categoryId);
 895
 896     if (categoryItem) {
 897         if (categoryItem->findIrcUser(ircUser)) {
 898             return;  // already in the right category;
 899         }
 900     }
 901     else {
 902         categoryItem = new UserCategoryItem(categoryId, this);
 903         newChild(categoryItem);
 904     }
 905
 906     // find the item that needs reparenting
 907     IrcUserItem* ircUserItem = nullptr;
 908     for (int i = 0; i < childCount(); i++) {
 909         auto* oldCategoryItem = qobject_cast<UserCategoryItem*>(child(i));
 910         Q_ASSERT(oldCategoryItem);
 911         IrcUserItem* userItem = oldCategoryItem->findIrcUser(ircUser);
 912         if (userItem) {
 913             ircUserItem = userItem;
 914             break;
 915         }
 916     }
 917
 918     if (!ircUserItem) {
 919         qWarning() << "ChannelBufferItem::userModeChanged(IrcUser *): unable to determine old category of" << ircUser;
 920         return;
 921     }
 922     ircUserItem->reParent(categoryItem);
 923 }
 924
 925 /*****************************************
 926  *  User Category Items (like @vh etc.)
 927  *****************************************/
 928 // we hardcode this even though we have PREFIX in network... but that wouldn't help with mapping modes to
 929 // category strings anyway.
 930 const QList<QChar> UserCategoryItem::categories = QList<QChar>() << 'q' << 'a' << 'o' << 'h' << 'v';
 931
 932 UserCategoryItem::UserCategoryItem(int category, AbstractTreeItem* parent)
 933     : PropertyMapItem(parent)
 934     , _category(category)
 935 {
 936     setFlags(Qt::ItemIsEnabled);
 937     setTreeItemFlags(AbstractTreeItem::DeleteOnLastChildRemoved);
 938     setObjectName(parent->data(0, Qt::DisplayRole).toString() + "/" + QString::number(category));
 939 }
 940
 941 QStringList UserCategoryItem::propertyOrder() const
 942 {
 943     static QStringList order{"categoryName"};
 944     return order;
 945 }
 946
 947 // caching this makes no sense, since we display the user number dynamically
 948 QString UserCategoryItem::categoryName() const
 949 {
 950     int n = childCount();
 951     switch (_category) {
 952     case 0:
 953         return tr("%n Owner(s)", "", n);
 954     case 1:
 955         return tr("%n Admin(s)", "", n);
 956     case 2:
 957         return tr("%n Operator(s)", "", n);
 958     case 3:
 959         return tr("%n Half-Op(s)", "", n);
 960     case 4:
 961         return tr("%n Voiced", "", n);
 962     default:
 963         return tr("%n User(s)", "", n);
 964     }
 965 }
 966
 967 IrcUserItem* UserCategoryItem::findIrcUser(IrcUser* ircUser)
 968 {
 969     IrcUserItem* userItem = nullptr;
 970
 971     for (int i = 0; i < childCount(); i++) {
 972         userItem = qobject_cast<IrcUserItem*>(child(i));
 973         if (!userItem)
 974             continue;
 975         if (userItem->ircUser() == ircUser)
 976             return userItem;
 977     }
 978     return nullptr;
 979 }
 980
 981 void UserCategoryItem::addUsers(const QList<IrcUser*>& ircUsers)
 982 {
 983     QList<AbstractTreeItem*> userItems;
 984     foreach (IrcUser* ircUser, ircUsers)
 985         userItems << new IrcUserItem(ircUser, this);
 986     newChilds(userItems);
 987     emit dataChanged(0);
 988 }
 989
 990 bool UserCategoryItem::removeUser(IrcUser* ircUser)
 991 {
 992     IrcUserItem* userItem = findIrcUser(ircUser);
 993     auto success = (bool)userItem;
 994     if (success) {
 995         removeChild(userItem);
 996         emit dataChanged(0);
 997     }
 998     return success;
 999 }
1000
1001 int UserCategoryItem::categoryFromModes(const QString& modes)
1002 {
1003     for (int i = 0; i < categories.count(); i++) {
1004         if (modes.contains(categories[i]))
1005             return i;
1006     }
1007     return categories.count();
1008 }
1009
1010 QVariant UserCategoryItem::data(int column, int role) const
1011 {
1012     switch (role) {
1013     case TreeModel::SortRole:
1014         return _category;
1015     case NetworkModel::ItemActiveRole:
1016         return true;
1017     case NetworkModel::ItemTypeRole:
1018         return NetworkModel::UserCategoryItemType;
1019     case NetworkModel::BufferIdRole:
1020         return parent()->data(column, role);
1021     case NetworkModel::NetworkIdRole:
1022         return parent()->data(column, role);
1023     case NetworkModel::BufferInfoRole:
1024         return parent()->data(column, role);
1025     default:
1026         return PropertyMapItem::data(column, role);
1027     }
1028 }
1029
1030 /*****************************************
1031  *  Irc User Items
1032  *****************************************/
1033 IrcUserItem::IrcUserItem(IrcUser* ircUser, AbstractTreeItem* parent)
1034     : PropertyMapItem(parent)
1035     , _ircUser(ircUser)
1036 {
1037     setObjectName(ircUser->nick());
1038     connect(ircUser, &IrcUser::quited, this, &IrcUserItem::ircUserQuited);
1039     connect(ircUser, &IrcUser::nickSet, this, [this]() { emit dataChanged(); });
1040     connect(ircUser, &IrcUser::awaySet, this, [this]() { emit dataChanged(); });
1041 }
1042
1043 QStringList IrcUserItem::propertyOrder() const
1044 {
1045     static QStringList order{"nickName"};
1046     return order;
1047 }
1048
1049 QVariant IrcUserItem::data(int column, int role) const
1050 {
1051     switch (role) {
1052     case NetworkModel::ItemActiveRole:
1053         return isActive();
1054     case NetworkModel::ItemTypeRole:
1055         return NetworkModel::IrcUserItemType;
1056     case NetworkModel::BufferIdRole:
1057         return parent()->data(column, role);
1058     case NetworkModel::NetworkIdRole:
1059         return parent()->data(column, role);
1060     case NetworkModel::BufferInfoRole:
1061         return parent()->data(column, role);
1062     case NetworkModel::IrcChannelRole:
1063         return parent()->data(column, role);
1064     case NetworkModel::IrcUserRole:
1065         return QVariant::fromValue<QObject*>(_ircUser.data());
1066     case NetworkModel::UserAwayRole:
1067         return (bool)_ircUser ? _ircUser->isAway() : false;
1068     default:
1069         return PropertyMapItem::data(column, role);
1070     }
1071 }
1072
1073 QString IrcUserItem::toolTip(int column) const
1074 {
1075     Q_UNUSED(column);
1076     QString strTooltip;
1077     QTextStream tooltip(&strTooltip, QIODevice::WriteOnly);
1078     tooltip << "<qt><style>.bold { font-weight: bold; } .italic { font-style: italic; }</style>";
1079
1080     // Keep track of whether or not information has been added
1081     bool infoAdded = false;
1082
1083     // Use bufferName() for QueryBufferItem, nickName() for IrcUserItem
1084     tooltip << "<p class='bold' align='center'>" << NetworkItem::escapeHTML(nickName(), true);
1085     if (_ircUser->userModes() != "") {
1086         // TODO: Translate user Modes and add them to the table below and in QueryBufferItem::toolTip
1087         tooltip << " (" << _ircUser->userModes() << ")";
1088     }
1089     tooltip << "</p>";
1090
1091     auto addRow = [&](const QString& key, const QString& value, bool condition) {
1092         if (condition) {
1093             tooltip << "<tr><td class='bold' align='right'>" << key << "</td><td>" << value << "</td></tr>";
1094             infoAdded = true;
1095         }
1096     };
1097
1098     tooltip << "<table cellspacing='5' cellpadding='0'>";
1099     addRow(tr("Modes"), NetworkItem::escapeHTML(channelModes()), !channelModes().isEmpty());
1100     if (_ircUser->isAway()) {
1101         QString awayMessageHTML = QString("<p class='italic'>%1</p>").arg(tr("Unknown"));
1102
1103         // If away message is known, replace with the escaped message.
1104         if (!_ircUser->awayMessage().isEmpty()) {
1105             awayMessageHTML = NetworkItem::escapeHTML(_ircUser->awayMessage());
1106         }
1107         addRow(NetworkItem::escapeHTML(tr("Away message"), true), awayMessageHTML, true);
1108     }
1109     addRow(tr("Realname"), NetworkItem::escapeHTML(_ircUser->realName()), !_ircUser->realName().isEmpty());
1110
1111     // suserHost may return "<nick> is available for help", which should be translated.
1112     // See https://www.alien.net.au/irc/irc2numerics.html
1113     if (_ircUser->suserHost().endsWith("available for help")) {
1114         addRow(NetworkItem::escapeHTML(tr("Help status"), true), NetworkItem::escapeHTML(tr("Available for help")), true);
1115     }
1116     else {
1117         addRow(NetworkItem::escapeHTML(tr("Service status"), true),
1118                NetworkItem::escapeHTML(_ircUser->suserHost()),
1119                !_ircUser->suserHost().isEmpty());
1120     }
1121
1122     // Keep track of whether or not the account information's been added.  Don't show it twice.
1123     bool accountAdded = false;
1124     if (!_ircUser->account().isEmpty()) {
1125         // IRCv3 account-notify is supported by the core and IRC server.
1126         // Assume logged out (seems to be more common)
1127         QString accountHTML = QString("<p class='italic'>%1</p>").arg(tr("Not logged in"));
1128
1129         // If account is logged in, replace with the escaped account name.
1130         if (_ircUser->account() != "*") {
1131             accountHTML = NetworkItem::escapeHTML(_ircUser->account());
1132         }
1133         addRow(NetworkItem::escapeHTML(tr("Account"), true), accountHTML, true);
1134         // Mark the row as added
1135         accountAdded = true;
1136     }
1137     // whoisServiceReply may return "<nick> is identified for this nick", which should be translated.
1138     // See https://www.alien.net.au/irc/irc2numerics.html
1139     if (_ircUser->whoisServiceReply().endsWith("identified for this nick")) {
1140         addRow(NetworkItem::escapeHTML(tr("Account"), true), NetworkItem::escapeHTML(tr("Identified for this nick")), !accountAdded);
1141         // Don't add the account row again if information's already added via account-notify
1142         // Not used further down...
1143         // accountAdded = true;
1144     }
1145     else {
1146         addRow(NetworkItem::escapeHTML(tr("Service Reply"), true),
1147                NetworkItem::escapeHTML(_ircUser->whoisServiceReply()),
1148                !_ircUser->whoisServiceReply().isEmpty());
1149     }
1150     addRow(tr("Hostmask"),
1151            NetworkItem::escapeHTML(_ircUser->hostmask().remove(0, _ircUser->hostmask().indexOf("!") + 1)),
1152            !(_ircUser->hostmask().remove(0, _ircUser->hostmask().indexOf("!") + 1) == "@"));
1153     // ircOperator may contain "is an" or "is a", which should be removed.
1154     addRow(tr("Operator"),
1155            NetworkItem::escapeHTML(_ircUser->ircOperator().replace("is an ", "").replace("is a ", "")),
1156            !_ircUser->ircOperator().isEmpty());
1157
1158     if (_ircUser->idleTime().isValid()) {
1159         QDateTime now = QDateTime::currentDateTime();
1160         QDateTime idle = _ircUser->idleTime();
1161         int idleTime = idle.secsTo(now);
1162         addRow(NetworkItem::escapeHTML(tr("Idling since"), true), secondsToString(idleTime), true);
1163     }
1164
1165     if (_ircUser->loginTime().isValid()) {
1166         addRow(NetworkItem::escapeHTML(tr("Login time"), true), _ircUser->loginTime().toString(), true);
1167     }
1168
1169     addRow(tr("Server"), NetworkItem::escapeHTML(_ircUser->server()), !_ircUser->server().isEmpty());
1170     tooltip << "</table>";
1171
1172     // If no further information found, offer an explanatory message
1173     if (!infoAdded)
1174         tooltip << "<p class='italic' align='center'>" << tr("No information available") << "</p>";
1175
1176     tooltip << "</qt>";
1177     return strTooltip;
1178 }
1179
1180 QString IrcUserItem::channelModes() const
1181 {
1182     // IrcUserItems are parented to UserCategoryItem, which are parented to ChannelBufferItem.
1183     // We want the channel buffer item in order to get the channel-specific user modes.
1184     auto* category = qobject_cast<UserCategoryItem*>(parent());
1185     if (!category)
1186         return QString();
1187
1188     auto* channel = qobject_cast<ChannelBufferItem*>(category->parent());
1189     if (!channel)
1190         return QString();
1191
1192     return channel->nickChannelModes(nickName());
1193 }
1194
1195 /*****************************************
1196  * NetworkModel
1197  *****************************************/
1198 NetworkModel::NetworkModel(QObject* parent)
1199     : TreeModel(NetworkModel::defaultHeader(), parent)
1200 {
1201     connect(this, &NetworkModel::rowsInserted, this, &NetworkModel::checkForNewBuffers);
1202     connect(this, &NetworkModel::rowsAboutToBeRemoved, this, &NetworkModel::checkForRemovedBuffers);
1203
1204     BufferSettings defaultSettings;
1205     defaultSettings.notify("UserNoticesTarget", this, &NetworkModel::messageRedirectionSettingsChanged);
1206     defaultSettings.notify("ServerNoticesTarget", this, &NetworkModel::messageRedirectionSettingsChanged);
1207     defaultSettings.notify("ErrorMsgsTarget", this, &NetworkModel::messageRedirectionSettingsChanged);
1208     messageRedirectionSettingsChanged();
1209 }
1210
1211 QList<QVariant> NetworkModel::defaultHeader()
1212 {
1213     QList<QVariant> data;
1214     data << tr("Chat") << tr("Topic") << tr("Nick Count");
1215     return data;
1216 }
1217
1218 bool NetworkModel::isBufferIndex(const QModelIndex& index) const
1219 {
1220     return index.data(NetworkModel::ItemTypeRole) == NetworkModel::BufferItemType;
1221 }
1222
1223 int NetworkModel::networkRow(NetworkId networkId) const
1224 {
1225     NetworkItem* netItem = nullptr;
1226     for (int i = 0; i < rootItem->childCount(); i++) {
1227         netItem = qobject_cast<NetworkItem*>(rootItem->child(i));
1228         if (!netItem)
1229             continue;
1230         if (netItem->networkId() == networkId)
1231             return i;
1232     }
1233     return -1;
1234 }
1235
1236 QModelIndex NetworkModel::networkIndex(NetworkId networkId)
1237 {
1238     int netRow = networkRow(networkId);
1239     if (netRow == -1)
1240         return {};
1241     else
1242         return indexByItem(qobject_cast<NetworkItem*>(rootItem->child(netRow)));
1243 }
1244
1245 NetworkItem* NetworkModel::findNetworkItem(NetworkId networkId) const
1246 {
1247     int netRow = networkRow(networkId);
1248     if (netRow == -1)
1249         return nullptr;
1250     else
1251         return qobject_cast<NetworkItem*>(rootItem->child(netRow));
1252 }
1253
1254 NetworkItem* NetworkModel::networkItem(NetworkId networkId)
1255 {
1256     NetworkItem* netItem = findNetworkItem(networkId);
1257
1258     if (netItem == nullptr) {
1259         netItem = new NetworkItem(networkId, rootItem);
1260         rootItem->newChild(netItem);
1261     }
1262     return netItem;
1263 }
1264
1265 void NetworkModel::networkRemoved(const NetworkId& networkId)
1266 {
1267     int netRow = networkRow(networkId);
1268     if (netRow != -1) {
1269         rootItem->removeChild(netRow);
1270     }
1271 }
1272
1273 QModelIndex NetworkModel::bufferIndex(BufferId bufferId)
1274 {
1275     if (!_bufferItemCache.contains(bufferId))
1276         return {};
1277
1278     return indexByItem(_bufferItemCache[bufferId]);
1279 }
1280
1281 BufferItem* NetworkModel::findBufferItem(BufferId bufferId) const
1282 {
1283     if (_bufferItemCache.contains(bufferId))
1284         return _bufferItemCache[bufferId];
1285     else
1286         return nullptr;
1287 }
1288
1289 BufferItem* NetworkModel::bufferItem(const BufferInfo& bufferInfo)
1290 {
1291     if (_bufferItemCache.contains(bufferInfo.bufferId()))
1292         return _bufferItemCache[bufferInfo.bufferId()];
1293
1294     NetworkItem* netItem = networkItem(bufferInfo.networkId());
1295     return netItem->bufferItem(bufferInfo);
1296 }
1297
1298 QStringList NetworkModel::mimeTypes() const
1299 {
1300     // mimetypes we accept for drops
1301     QStringList types;
1302     // comma separated list of colon separated pairs of networkid and bufferid
1303     // example: 0:1,0:2,1:4
1304     types << "application/Quassel/BufferItemList";
1305     return types;
1306 }
1307
1308 bool NetworkModel::mimeContainsBufferList(const QMimeData* mimeData)
1309 {
1310     return mimeData->hasFormat("application/Quassel/BufferItemList");
1311 }
1312
1313 QList<QPair<NetworkId, BufferId>> NetworkModel::mimeDataToBufferList(const QMimeData* mimeData)
1314 {
1315     QList<QPair<NetworkId, BufferId>> bufferList;
1316
1317     if (!mimeContainsBufferList(mimeData))
1318         return bufferList;
1319
1320     QStringList rawBufferList = QString::fromLatin1(mimeData->data("application/Quassel/BufferItemList")).split(",");
1321     NetworkId networkId;
1322     BufferId bufferUid;
1323     foreach (QString rawBuffer, rawBufferList) {
1324         if (!rawBuffer.contains(":"))
1325             continue;
1326         networkId = rawBuffer.section(":", 0, 0).toInt();
1327         bufferUid = rawBuffer.section(":", 1, 1).toInt();
1328         bufferList.append(qMakePair(networkId, bufferUid));
1329     }
1330     return bufferList;
1331 }
1332
1333 QMimeData* NetworkModel::mimeData(const QModelIndexList& indexes) const
1334 {
1335     auto* mimeData = new QMimeData();
1336
1337     QStringList bufferlist;
1338     QString netid, uid, bufferid;
1339     foreach (QModelIndex index, indexes) {
1340         netid = QString::number(index.data(NetworkIdRole).value<NetworkId>().toInt());
1341         uid = QString::number(index.data(BufferIdRole).value<BufferId>().toInt());
1342         bufferid = QString("%1:%2").arg(netid).arg(uid);
1343         if (!bufferlist.contains(bufferid))
1344             bufferlist << bufferid;
1345     }
1346
1347     mimeData->setData("application/Quassel/BufferItemList", bufferlist.join(",").toLatin1());
1348
1349     return mimeData;
1350 }
1351
1352 void NetworkModel::attachNetwork(Network* net)
1353 {
1354     NetworkItem* netItem = networkItem(net->networkId());
1355     netItem->attachNetwork(net);
1356 }
1357
1358 void NetworkModel::bufferUpdated(BufferInfo bufferInfo)
1359 {
1360     BufferItem* bufItem = bufferItem(bufferInfo);
1361     QModelIndex itemindex = indexByItem(bufItem);
1362     emit dataChanged(itemindex, itemindex);
1363 }
1364
1365 void NetworkModel::removeBuffer(BufferId bufferId)
1366 {
1367     BufferItem* buffItem = findBufferItem(bufferId);
1368     if (!buffItem)
1369         return;
1370
1371     buffItem->parent()->removeChild(buffItem);
1372 }
1373
1374 MsgId NetworkModel::lastSeenMsgId(BufferId bufferId) const
1375 {
1376     if (!_bufferItemCache.contains(bufferId))
1377         return {};
1378
1379     return _bufferItemCache[bufferId]->lastSeenMsgId();
1380 }
1381
1382 MsgId NetworkModel::markerLineMsgId(BufferId bufferId) const
1383 {
1384     if (!_bufferItemCache.contains(bufferId))
1385         return {};
1386
1387     return _bufferItemCache[bufferId]->markerLineMsgId();
1388 }
1389
1390 // FIXME we always seem to use this (expensive) non-const version
1391 MsgId NetworkModel::lastSeenMsgId(const BufferId& bufferId)
1392 {
1393     BufferItem* bufferItem = findBufferItem(bufferId);
1394     if (!bufferItem) {
1395         qDebug() << "NetworkModel::lastSeenMsgId(): buffer is unknown:" << bufferId;
1396         Client::purgeKnownBufferIds();
1397         return {};
1398     }
1399     return bufferItem->lastSeenMsgId();
1400 }
1401
1402 void NetworkModel::setLastSeenMsgId(const BufferId& bufferId, const MsgId& msgId)
1403 {
1404     BufferItem* bufferItem = findBufferItem(bufferId);
1405     if (!bufferItem) {
1406         qDebug() << "NetworkModel::setLastSeenMsgId(): buffer is unknown:" << bufferId;
1407         Client::purgeKnownBufferIds();
1408         return;
1409     }
1410     bufferItem->setLastSeenMsgId(msgId);
1411     emit lastSeenMsgSet(bufferId, msgId);
1412 }
1413
1414 void NetworkModel::setMarkerLineMsgId(const BufferId& bufferId, const MsgId& msgId)
1415 {
1416     BufferItem* bufferItem = findBufferItem(bufferId);
1417     if (!bufferItem) {
1418         qDebug() << "NetworkModel::setMarkerLineMsgId(): buffer is unknown:" << bufferId;
1419         Client::purgeKnownBufferIds();
1420         return;
1421     }
1422     bufferItem->setMarkerLineMsgId(msgId);
1423     emit markerLineSet(bufferId, msgId);
1424 }
1425
1426 void NetworkModel::updateBufferActivity(Message& msg)
1427 {
1428     int redirectionTarget = 0;
1429     switch (msg.type()) {
1430     case Message::Notice:
1431         if (bufferType(msg.bufferId()) != BufferInfo::ChannelBuffer) {
1432             msg.setFlags(msg.flags() | Message::Redirected);
1433             if (msg.flags() & Message::ServerMsg) {
1434                 // server notice
1435                 redirectionTarget = _serverNoticesTarget;
1436             }
1437             else {
1438                 redirectionTarget = _userNoticesTarget;
1439             }
1440         }
1441         break;
1442     case Message::Error:
1443         msg.setFlags(msg.flags() | Message::Redirected);
1444         redirectionTarget = _errorMsgsTarget;
1445         break;
1446     // Update IrcUser's last activity
1447     case Message::Plain:
1448     case Message::Action:
1449         if (bufferType(msg.bufferId()) == BufferInfo::ChannelBuffer) {
1450             const Network* net = Client::network(msg.bufferInfo().networkId());
1451             IrcUser* user = net ? net->ircUser(nickFromMask(msg.sender())) : nullptr;
1452             if (user)
1453                 user->setLastChannelActivity(msg.bufferId(), msg.timestamp());
1454         }
1455         break;
1456     default:
1457         break;
1458     }
1459
1460     if (msg.flags() & Message::Redirected) {
1461         if (redirectionTarget & BufferSettings::DefaultBuffer)
1462             updateBufferActivity(bufferItem(msg.bufferInfo()), msg);
1463
1464         if (redirectionTarget & BufferSettings::StatusBuffer) {
1465             const NetworkItem* netItem = findNetworkItem(msg.bufferInfo().networkId());
1466             if (netItem) {
1467                 updateBufferActivity(netItem->statusBufferItem(), msg);
1468             }
1469         }
1470     }
1471     else {
1472         if ((BufferSettings(msg.bufferId()).messageFilter() & msg.type()) != msg.type())
1473             updateBufferActivity(bufferItem(msg.bufferInfo()), msg);
1474     }
1475 }
1476
1477 void NetworkModel::updateBufferActivity(BufferItem* bufferItem, const Message& msg)
1478 {
1479     if (!bufferItem)
1480         return;
1481
1482     bufferItem->updateActivityLevel(msg);
1483     if (bufferItem->isCurrentBuffer())
1484         emit requestSetLastSeenMsg(bufferItem->bufferId(), msg.msgId());
1485 }
1486
1487 void NetworkModel::setBufferActivity(const BufferId& bufferId, BufferInfo::ActivityLevel level)
1488 {
1489     BufferItem* bufferItem = findBufferItem(bufferId);
1490     if (!bufferItem) {
1491         qDebug() << "NetworkModel::setBufferActivity(): buffer is unknown:" << bufferId;
1492         return;
1493     }
1494     bufferItem->setActivityLevel(level);
1495 }
1496
1497 void NetworkModel::clearBufferActivity(const BufferId& bufferId)
1498 {
1499     BufferItem* bufferItem = findBufferItem(bufferId);
1500     if (!bufferItem) {
1501         qDebug() << "NetworkModel::clearBufferActivity(): buffer is unknown:" << bufferId;
1502         return;
1503     }
1504     bufferItem->clearActivityLevel();
1505 }
1506
1507 const Network* NetworkModel::networkByIndex(const QModelIndex& index) const
1508 {
1509     QVariant netVariant = index.data(NetworkIdRole);
1510     if (!netVariant.isValid())
1511         return nullptr;
1512
1513     NetworkId networkId = netVariant.value<NetworkId>();
1514     return Client::network(networkId);
1515 }
1516
1517 void NetworkModel::checkForRemovedBuffers(const QModelIndex& parent, int start, int end)
1518 {
1519     if (parent.data(ItemTypeRole) != NetworkItemType)
1520         return;
1521
1522     for (int row = start; row <= end; row++) {
1523         _bufferItemCache.remove(index(row, 0, parent).data(BufferIdRole).value<BufferId>());
1524     }
1525 }
1526
1527 void NetworkModel::checkForNewBuffers(const QModelIndex& parent, int start, int end)
1528 {
1529     if (parent.data(ItemTypeRole) != NetworkItemType)
1530         return;
1531
1532     for (int row = start; row <= end; row++) {
1533         QModelIndex child = parent.model()->index(row, 0, parent);
1534         _bufferItemCache[child.data(BufferIdRole).value<BufferId>()] = static_cast<BufferItem*>(child.internalPointer());
1535     }
1536 }
1537
1538 QString NetworkModel::bufferName(BufferId bufferId) const
1539 {
1540     if (!_bufferItemCache.contains(bufferId))
1541         return QString();
1542
1543     return _bufferItemCache[bufferId]->bufferName();
1544 }
1545
1546 BufferInfo::Type NetworkModel::bufferType(BufferId bufferId) const
1547 {
1548     if (!_bufferItemCache.contains(bufferId))
1549         return BufferInfo::InvalidBuffer;
1550
1551     return _bufferItemCache[bufferId]->bufferType();
1552 }
1553
1554 BufferInfo NetworkModel::bufferInfo(BufferId bufferId) const
1555 {
1556     if (!_bufferItemCache.contains(bufferId))
1557         return BufferInfo();
1558
1559     return _bufferItemCache[bufferId]->bufferInfo();
1560 }
1561
1562 NetworkId NetworkModel::networkId(BufferId bufferId) const
1563 {
1564     if (!_bufferItemCache.contains(bufferId))
1565         return {};
1566
1567     auto* netItem = qobject_cast<NetworkItem*>(_bufferItemCache[bufferId]->parent());
1568     if (netItem)
1569         return netItem->networkId();
1570     else
1571         return {};
1572 }
1573
1574 QString NetworkModel::networkName(BufferId bufferId) const
1575 {
1576     if (!_bufferItemCache.contains(bufferId))
1577         return QString();
1578
1579     auto* netItem = qobject_cast<NetworkItem*>(_bufferItemCache[bufferId]->parent());
1580     if (netItem)
1581         return netItem->networkName();
1582     else
1583         return QString();
1584 }
1585
1586 BufferId NetworkModel::bufferId(NetworkId networkId, const QString& bufferName, Qt::CaseSensitivity cs) const
1587 {
1588     const NetworkItem* netItem = findNetworkItem(networkId);
1589     if (!netItem)
1590         return {};
1591
1592     for (int i = 0; i < netItem->childCount(); i++) {
1593         auto* bufferItem = qobject_cast<BufferItem*>(netItem->child(i));
1594         if (bufferItem && !bufferItem->bufferName().compare(bufferName, cs))
1595             return bufferItem->bufferId();
1596     }
1597     return {};
1598 }
1599
1600 void NetworkModel::sortBufferIds(QList<BufferId>& bufferIds) const
1601 {
1602     QList<BufferItem*> bufferItems;
1603     foreach (BufferId bufferId, bufferIds) {
1604         if (_bufferItemCache.contains(bufferId))
1605             bufferItems << _bufferItemCache[bufferId];
1606     }
1607
1608     std::sort(bufferItems.begin(), bufferItems.end(), bufferItemLessThan);
1609
1610     bufferIds.clear();
1611     foreach (BufferItem* bufferItem, bufferItems) {
1612         bufferIds << bufferItem->bufferId();
1613     }
1614 }
1615
1616 QList<BufferId> NetworkModel::allBufferIdsSorted() const
1617 {
1618     QList<BufferId> bufferIds = allBufferIds();
1619     sortBufferIds(bufferIds);
1620     return bufferIds;
1621 }
1622
1623 bool NetworkModel::bufferItemLessThan(const BufferItem* left, const BufferItem* right)
1624 {
1625     int leftType = left->bufferType();
1626     int rightType = right->bufferType();
1627
1628     if (leftType != rightType)
1629         return leftType < rightType;
1630     else
1631         return QString::compare(left->bufferName(), right->bufferName(), Qt::CaseInsensitive) < 0;
1632 }
1633
1634 void NetworkModel::messageRedirectionSettingsChanged()
1635 {
1636     BufferSettings bufferSettings;
1637
1638     _userNoticesTarget = bufferSettings.userNoticesTarget();
1639     _serverNoticesTarget = bufferSettings.serverNoticesTarget();
1640     _errorMsgsTarget = bufferSettings.errorMsgsTarget();
1641 }
1642
1643 void NetworkModel::bufferActivityChanged(BufferId bufferId, const Message::Types activity)
1644 {
1645     auto _bufferItem = findBufferItem(bufferId);
1646     if (!_bufferItem) {
1647         qDebug() << "NetworkModel::bufferActivityChanged(): buffer is unknown:" << bufferId;
1648         return;
1649     }
1650     auto hiddenTypes = BufferSettings(bufferId).messageFilter();
1651     auto visibleTypes = ~hiddenTypes;
1652     auto activityVisibleTypesIntersection = activity & visibleTypes;
1653     _bufferItem->setActivity(activityVisibleTypesIntersection, false);
1654 }
1655
1656 void NetworkModel::highlightCountChanged(BufferId bufferId, int count)
1657 {
1658     auto _bufferItem = findBufferItem(bufferId);
1659     if (!_bufferItem) {
1660         qDebug() << "NetworkModel::highlightCountChanged(): buffer is unknown:" << bufferId;
1661         return;
1662     }
1663     _bufferItem->addActivity(Message::Types{}, count > 0);
1664 }