src/client/networkmodel.cpp

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