src/client/networkmodel.cpp

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