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