src/client/networkmodel.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-08 by the Quassel Project                          *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "networkmodel.h"
  22
  23 #include <QAbstractItemView>
  24
  25 #include "buffermodel.h"
  26 #include "client.h"
  27 #include "signalproxy.h"
  28 #include "network.h"
  29 #include "ircchannel.h"
  30
  31 #include "buffersettings.h"
  32
  33 #include "util.h" // get rid of this (needed for isChannelName)
  34
  35 /*****************************************
  36 *  Network Items
  37 *****************************************/
  38 NetworkItem::NetworkItem(const NetworkId &netid, AbstractTreeItem *parent)
  39   : PropertyMapItem(QList<QString>() << "networkName" << "currentServer" << "nickCount", parent),
  40     _networkId(netid)
  41 {
  42   setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
  43 }
  44
  45 QVariant NetworkItem::data(int column, int role) const {
  46   switch(role) {
  47   case NetworkModel::BufferIdRole:
  48   case NetworkModel::BufferInfoRole:
  49   case NetworkModel::BufferTypeRole:
  50     if(childCount())
  51       return child(0)->data(column, role);
  52     else
  53       return QVariant();
  54   case NetworkModel::NetworkIdRole:
  55     return qVariantFromValue(_networkId);
  56   case NetworkModel::ItemTypeRole:
  57     return NetworkModel::NetworkItemType;
  58   case NetworkModel::ItemActiveRole:
  59     return isActive();
  60   default:
  61     return PropertyMapItem::data(column, role);
  62   }
  63 }
  64
  65 BufferItem *NetworkItem::findBufferItem(BufferId bufferId) {
  66   BufferItem *bufferItem = 0;
  67
  68   for(int i = 0; i < childCount(); i++) {
  69     bufferItem = qobject_cast<BufferItem *>(child(i));
  70     if(!bufferItem)
  71       continue;
  72     if(bufferItem->bufferId() == bufferId)
  73       return bufferItem;
  74   }
  75   return 0;
  76 }
  77
  78
  79 BufferItem *NetworkItem::bufferItem(const BufferInfo &bufferInfo) {
  80   BufferItem *bufferItem = findBufferItem(bufferInfo);
  81   if(bufferItem)
  82     return bufferItem;
  83
  84   switch(bufferInfo.type()) {
  85   case BufferInfo::StatusBuffer:
  86     bufferItem = new StatusBufferItem(bufferInfo, this);
  87     break;
  88   case BufferInfo::ChannelBuffer:
  89     bufferItem = new ChannelBufferItem(bufferInfo, this);
  90     break;
  91   case BufferInfo::QueryBuffer:
  92     bufferItem = new QueryBufferItem(bufferInfo, this);
  93     break;
  94   default:
  95     bufferItem = new BufferItem(bufferInfo, this);
  96   }
  97
  98   newChild(bufferItem);
  99   return bufferItem;
 100 }
 101
 102 void NetworkItem::attachNetwork(Network *network) {
 103   if(!network)
 104     return;
 105
 106   _network = network;
 107
 108   connect(network, SIGNAL(networkNameSet(QString)),
 109           this, SLOT(setNetworkName(QString)));
 110   connect(network, SIGNAL(currentServerSet(QString)),
 111           this, SLOT(setCurrentServer(QString)));
 112   connect(network, SIGNAL(ircChannelAdded(IrcChannel *)),
 113           this, SLOT(attachIrcChannel(IrcChannel *)));
 114   connect(network, SIGNAL(ircUserAdded(IrcUser *)),
 115           this, SLOT(attachIrcUser(IrcUser *)));
 116   connect(network, SIGNAL(connectedSet(bool)),
 117           this, SIGNAL(dataChanged()));
 118   connect(network, SIGNAL(destroyed()),
 119           this, SIGNAL(dataChanged()));
 120
 121   emit dataChanged();
 122 }
 123
 124 void NetworkItem::attachIrcChannel(IrcChannel *ircChannel) {
 125   ChannelBufferItem *channelItem;
 126   for(int i = 0; i < childCount(); i++) {
 127     channelItem = qobject_cast<ChannelBufferItem *>(child(i));
 128     if(!channelItem)
 129       continue;
 130
 131     if(channelItem->bufferName().toLower() == ircChannel->name().toLower()) {
 132       channelItem->attachIrcChannel(ircChannel);
 133       return;
 134     }
 135   }
 136 }
 137
 138 void NetworkItem::attachIrcUser(IrcUser *ircUser) {
 139   QueryBufferItem *queryItem = 0;
 140   for(int i = 0; i < childCount(); i++) {
 141     queryItem = qobject_cast<QueryBufferItem *>(child(i));
 142     if(!queryItem)
 143       continue;
 144
 145     if(queryItem->bufferName().toLower() == ircUser->nick().toLower()) {
 146       queryItem->attachIrcUser(ircUser);
 147       break;
 148     }
 149   }
 150 }
 151
 152 void NetworkItem::setNetworkName(const QString &networkName) {
 153   Q_UNUSED(networkName);
 154   emit dataChanged(0);
 155 }
 156
 157 void NetworkItem::setCurrentServer(const QString &serverName) {
 158   Q_UNUSED(serverName);
 159   emit dataChanged(1);
 160 }
 161
 162
 163 QString NetworkItem::toolTip(int column) const {
 164   Q_UNUSED(column);
 165
 166   QStringList toolTip(QString("<b>%1</b>").arg(networkName()));
 167   toolTip.append(tr("Server: %1").arg(currentServer()));
 168   toolTip.append(tr("Users: %1").arg(nickCount()));
 169
 170   if(_network) {
 171     toolTip.append(tr("Lag: %1 msecs").arg(_network->latency()));
 172   }
 173
 174   return QString("<p> %1 </p>").arg(toolTip.join("<br />"));
 175 }
 176
 177 /*****************************************
 178 *  Fancy Buffer Items
 179 *****************************************/
 180 BufferItem::BufferItem(const BufferInfo &bufferInfo, AbstractTreeItem *parent)
 181   : PropertyMapItem(QStringList() << "bufferName" << "topic" << "nickCount", parent),
 182     _bufferInfo(bufferInfo),
 183     _activity(BufferInfo::NoActivity)
 184 {
 185   setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled);
 186 }
 187
 188 void BufferItem::setActivityLevel(BufferInfo::ActivityLevel level) {
 189   if(_activity != level) {
 190     _activity = level;
 191     emit dataChanged();
 192   }
 193 }
 194
 195 void BufferItem::clearActivityLevel() {
 196   _activity = BufferInfo::NoActivity;
 197   _lastSeenMarkerMsgId = _lastSeenMsgId;
 198   emit dataChanged();
 199 }
 200
 201 void BufferItem::updateActivityLevel(const Message &msg) {
 202   if(isCurrentBuffer()) {
 203     return;
 204   }
 205
 206   if(msg.flags() & Message::Self)       // don't update activity for our own messages
 207     return;
 208
 209   if(lastSeenMsgId() >= msg.msgId())
 210     return;
 211
 212   BufferInfo::ActivityLevel oldLevel = activityLevel();
 213
 214   _activity |= BufferInfo::OtherActivity;
 215   if(msg.type() & (Message::Plain | Message::Notice | Message::Action))
 216     _activity |= BufferInfo::NewMessage;
 217
 218   if(msg.flags() & Message::Highlight)
 219     _activity |= BufferInfo::Highlight;
 220
 221   if(oldLevel != _activity)
 222     emit dataChanged();
 223 }
 224
 225 QVariant BufferItem::data(int column, int role) const {
 226   switch(role) {
 227   case NetworkModel::ItemTypeRole:
 228     return NetworkModel::BufferItemType;
 229   case NetworkModel::BufferIdRole:
 230     return qVariantFromValue(bufferInfo().bufferId());
 231   case NetworkModel::NetworkIdRole:
 232     return qVariantFromValue(bufferInfo().networkId());
 233   case NetworkModel::BufferInfoRole:
 234     return qVariantFromValue(bufferInfo());
 235   case NetworkModel::BufferTypeRole:
 236     return int(bufferType());
 237   case NetworkModel::ItemActiveRole:
 238     return isActive();
 239   case NetworkModel::BufferActivityRole:
 240     return (int)activityLevel();
 241   default:
 242     return PropertyMapItem::data(column, role);
 243   }
 244 }
 245
 246 bool BufferItem::setData(int column, const QVariant &value, int role) {
 247   switch(role) {
 248   case NetworkModel::BufferActivityRole:
 249     setActivityLevel((BufferInfo::ActivityLevel)value.toInt());
 250     return true;
 251   default:
 252     return PropertyMapItem::setData(column, value, role);
 253   }
 254   return true;
 255 }
 256
 257 void BufferItem::setBufferName(const QString &name) {
 258   _bufferInfo = BufferInfo(_bufferInfo.bufferId(), _bufferInfo.networkId(), _bufferInfo.type(), _bufferInfo.groupId(), name);
 259   emit dataChanged(0);
 260 }
 261
 262 void BufferItem::setLastSeenMsgId(const MsgId &msgId) {
 263   _lastSeenMsgId = msgId;
 264   if(!isCurrentBuffer()) {
 265     _lastSeenMarkerMsgId = msgId;
 266   }
 267   setActivityLevel(BufferInfo::NoActivity);
 268 }
 269
 270 bool BufferItem::isCurrentBuffer() const {
 271   return _bufferInfo.bufferId() == Client::bufferModel()->currentIndex().data(NetworkModel::BufferIdRole).value<BufferId>();
 272 }
 273
 274 QString BufferItem::toolTip(int column) const {
 275   Q_UNUSED(column);
 276   return tr("<p> %1 - %2 </p>").arg(bufferInfo().bufferId().toInt()).arg(bufferName());
 277 }
 278
 279 /*****************************************
 280 *  StatusBufferItem
 281 *****************************************/
 282 StatusBufferItem::StatusBufferItem(const BufferInfo &bufferInfo, NetworkItem *parent)
 283   : BufferItem(bufferInfo, parent)
 284 {
 285   Q_ASSERT(parent);
 286   connect(parent, SIGNAL(dataChanged()), this, SIGNAL(dataChanged()));
 287 }
 288
 289 QString StatusBufferItem::toolTip(int column) const {
 290   Q_UNUSED(column);
 291   QStringList toolTip;
 292
 293   QString netName = Client::network(bufferInfo().networkId())->networkName();
 294   toolTip.append(tr("<b>Status buffer of %1</b>").arg(netName));
 295
 296   return tr("<p> %1 </p>").arg(toolTip.join("<br />"));
 297 }
 298
 299 /*****************************************
 300 *  QueryBufferItem
 301 *****************************************/
 302 QueryBufferItem::QueryBufferItem(const BufferInfo &bufferInfo, NetworkItem *parent)
 303   : BufferItem(bufferInfo, parent),
 304     _ircUser(0)
 305 {
 306   setFlags(flags() | Qt::ItemIsDropEnabled | Qt::ItemIsEditable);
 307
 308   const Network *net = Client::network(bufferInfo.networkId());
 309   if(!net)
 310     return;
 311
 312   IrcUser *ircUser = net->ircUser(bufferInfo.bufferName());
 313   if(ircUser)
 314     attachIrcUser(ircUser);
 315 }
 316
 317 QVariant QueryBufferItem::data(int column, int role) const {
 318   switch(role) {
 319   case NetworkModel::IrcUserRole:
 320     return QVariant::fromValue<QObject *>(_ircUser);
 321   case NetworkModel::UserAwayRole:
 322     return (bool)_ircUser ? _ircUser->isAway() : false;
 323   default:
 324     return BufferItem::data(column, role);
 325   }
 326 }
 327
 328 bool QueryBufferItem::setData(int column, const QVariant &value, int role) {
 329   switch(role) {
 330   case Qt::EditRole:
 331     {
 332       QString newName = value.toString();
 333       if(!newName.isEmpty()) {
 334         Client::renameBuffer(bufferId(), newName);
 335         return true;
 336       } else {
 337         return false;
 338       }
 339     }
 340     break;
 341   default:
 342     return BufferItem::setData(column, value, role);
 343   }
 344 }
 345
 346 QString QueryBufferItem::toolTip(int column) const {
 347   // pretty much code duplication of IrcUserItem::toolTip() but inheritance won't solve this...
 348   Q_UNUSED(column);
 349   QStringList toolTip;
 350
 351   toolTip.append(tr("<b>Query with %1</b>").arg(bufferName()));
 352
 353   if(_ircUser) {
 354     if(_ircUser->userModes() != "") toolTip[0].append(QString(" (%1)").arg(_ircUser->userModes()));
 355     if(_ircUser->isAway()) {
 356       toolTip[0].append(QString(" (away%1)").arg(!_ircUser->awayMessage().isEmpty() ? (QString(" ") + _ircUser->awayMessage()) : QString()));
 357     }
 358     if(!_ircUser->realName().isEmpty()) toolTip.append(_ircUser->realName());
 359     if(!_ircUser->ircOperator().isEmpty()) toolTip.append(QString("%1 %2").arg(_ircUser->nick()).arg(_ircUser->ircOperator()));
 360     if(!_ircUser->suserHost().isEmpty()) toolTip.append(_ircUser->suserHost());
 361     if(!_ircUser->whoisServiceReply().isEmpty()) toolTip.append(_ircUser->whoisServiceReply());
 362
 363     toolTip.append(_ircUser->hostmask().remove(0, _ircUser->hostmask().indexOf("!")+1));
 364
 365     if(_ircUser->idleTime().isValid()) {
 366       QDateTime now = QDateTime::currentDateTime();
 367       QDateTime idle = _ircUser->idleTime();
 368       int idleTime = idle.secsTo(now);
 369       toolTip.append(tr("idling since %1").arg(secondsToString(idleTime)));
 370     }
 371     if(_ircUser->loginTime().isValid()) {
 372       toolTip.append(tr("login time: %1").arg(_ircUser->loginTime().toString()));
 373     }
 374
 375     if(!_ircUser->server().isEmpty()) toolTip.append(tr("server: %1").arg(_ircUser->server()));
 376   }
 377
 378   return QString("<p> %1 </p>").arg(toolTip.join("<br />"));
 379 }
 380
 381 void QueryBufferItem::attachIrcUser(IrcUser *ircUser) {
 382   _ircUser = ircUser;
 383   connect(_ircUser, SIGNAL(quited()), this, SLOT(ircUserQuited()));
 384   connect(_ircUser, SIGNAL(awaySet(bool)), this, SIGNAL(dataChanged()));
 385   emit dataChanged();
 386 }
 387
 388 void QueryBufferItem::ircUserQuited() {
 389   _ircUser = 0;
 390   emit dataChanged();
 391 }
 392
 393 /*****************************************
 394 *  ChannelBufferItem
 395 *****************************************/
 396 ChannelBufferItem::ChannelBufferItem(const BufferInfo &bufferInfo, AbstractTreeItem *parent)
 397   : BufferItem(bufferInfo, parent),
 398     _ircChannel(0)
 399 {
 400   const Network *net = Client::network(bufferInfo.networkId());
 401   if(!net)
 402     return;
 403
 404   IrcChannel *ircChannel = net->ircChannel(bufferInfo.bufferName());
 405   if(ircChannel)
 406     attachIrcChannel(ircChannel);
 407 }
 408
 409 QVariant ChannelBufferItem::data(int column, int role) const {
 410   switch(role) {
 411     case NetworkModel::IrcChannelRole:
 412       return QVariant::fromValue<QObject *>(_ircChannel);
 413     default:
 414       return BufferItem::data(column, role);
 415   }
 416 }
 417
 418 QString ChannelBufferItem::toolTip(int column) const {
 419   Q_UNUSED(column);
 420   QStringList toolTip;
 421
 422   toolTip.append(tr("<b>Channel %1</b>").arg(bufferName()));
 423   if(isActive()) {
 424     //TODO: add channel modes
 425     toolTip.append(tr("<b>Users:</b> %1").arg(nickCount()));
 426     if(_ircChannel) {
 427       QString channelMode = _ircChannel->channelModeString(); // channelModeString is compiled on the fly -> thus cache the result
 428       if(!channelMode.isEmpty())
 429         toolTip.append(tr("<b>Mode:</b> %1").arg(channelMode));
 430     }
 431
 432     BufferSettings s;
 433     bool showTopic = s.value("DisplayTopicInTooltip", QVariant(false)).toBool();
 434     if(showTopic) {
 435       QString _topic = topic();
 436       if(_topic != "") {
 437         _topic = stripFormatCodes(_topic);
 438         _topic.replace(QString("<"), QString("&lt;"));
 439         _topic.replace(QString(">"), QString("&gt;"));
 440         toolTip.append(QString("<font size='-2'>&nbsp;</font>"));
 441         toolTip.append(tr("<b>Topic:</b> %1").arg(_topic));
 442       }
 443     }
 444   } else {
 445     toolTip.append(tr("Not active <br /> Double-click to join"));
 446   }
 447
 448   return tr("<p> %1 </p>").arg(toolTip.join("<br />"));
 449 }
 450
 451 void ChannelBufferItem::attachIrcChannel(IrcChannel *ircChannel) {
 452   Q_ASSERT(!_ircChannel && ircChannel);
 453
 454   _ircChannel = ircChannel;
 455
 456   connect(ircChannel, SIGNAL(topicSet(QString)),
 457           this, SLOT(setTopic(QString)));
 458   connect(ircChannel, SIGNAL(ircUsersJoined(QList<IrcUser *>)),
 459           this, SLOT(join(QList<IrcUser *>)));
 460   connect(ircChannel, SIGNAL(ircUserParted(IrcUser *)),
 461           this, SLOT(part(IrcUser *)));
 462   connect(ircChannel, SIGNAL(parted()),
 463           this, SLOT(ircChannelParted()));
 464   connect(ircChannel, SIGNAL(ircUserModesSet(IrcUser *, QString)),
 465           this, SLOT(userModeChanged(IrcUser *)));
 466   connect(ircChannel, SIGNAL(ircUserModeAdded(IrcUser *, QString)),
 467           this, SLOT(userModeChanged(IrcUser *)));
 468   connect(ircChannel, SIGNAL(ircUserModeRemoved(IrcUser *, QString)),
 469           this, SLOT(userModeChanged(IrcUser *)));
 470
 471   if(!ircChannel->ircUsers().isEmpty())
 472     join(ircChannel->ircUsers());
 473
 474   emit dataChanged();
 475 }
 476
 477 void ChannelBufferItem::ircChannelParted() {
 478   Q_CHECK_PTR(_ircChannel);
 479   disconnect(_ircChannel, 0, this, 0);
 480   _ircChannel = 0;
 481   emit dataChanged();
 482   removeAllChilds();
 483 }
 484
 485 void ChannelBufferItem::join(const QList<IrcUser *> &ircUsers) {
 486   addUsersToCategory(ircUsers);
 487   emit dataChanged(2);
 488 }
 489
 490 UserCategoryItem *ChannelBufferItem::findCategoryItem(int categoryId) {
 491   UserCategoryItem *categoryItem = 0;
 492
 493   for(int i = 0; i < childCount(); i++) {
 494     categoryItem = qobject_cast<UserCategoryItem *>(child(i));
 495     if(!categoryItem)
 496       continue;
 497     if(categoryItem->categoryId() == categoryId)
 498       return categoryItem;
 499   }
 500   return 0;
 501 }
 502
 503 void ChannelBufferItem::addUserToCategory(IrcUser *ircUser) {
 504   addUsersToCategory(QList<IrcUser *>() << ircUser);
 505 }
 506
 507 void ChannelBufferItem::addUsersToCategory(const QList<IrcUser *> &ircUsers) {
 508   Q_ASSERT(_ircChannel);
 509
 510   QHash<UserCategoryItem *, QList<IrcUser *> > categories;
 511
 512   int categoryId = -1;
 513   UserCategoryItem *categoryItem = 0;
 514
 515   foreach(IrcUser *ircUser, ircUsers) {
 516     categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
 517     categoryItem = findCategoryItem(categoryId);
 518     if(!categoryItem) {
 519       categoryItem = new UserCategoryItem(categoryId, this);
 520       categories[categoryItem] = QList<IrcUser *>();
 521       newChild(categoryItem);
 522     }
 523     categories[categoryItem] << ircUser;
 524   }
 525
 526   QHash<UserCategoryItem *, QList<IrcUser *> >::const_iterator catIter = categories.constBegin();
 527   while(catIter != categories.constEnd()) {
 528     catIter.key()->addUsers(catIter.value());
 529     catIter++;
 530   }
 531 }
 532
 533 void ChannelBufferItem::part(IrcUser *ircUser) {
 534   if(!ircUser) {
 535     qWarning() << bufferName() << "ChannelBufferItem::part(): unknown User" << ircUser;
 536     return;
 537   }
 538
 539   disconnect(ircUser, 0, this, 0);
 540   removeUserFromCategory(ircUser);
 541   emit dataChanged(2);
 542 }
 543
 544 void ChannelBufferItem::removeUserFromCategory(IrcUser *ircUser) {
 545   if(!_ircChannel) {
 546     // If we parted the channel there might still be some ircUsers connected.
 547     // in that case we just ignore the call
 548     Q_ASSERT(childCount() == 0);
 549     return;
 550   }
 551
 552   UserCategoryItem *categoryItem = 0;
 553   for(int i = 0; i < childCount(); i++) {
 554     categoryItem = qobject_cast<UserCategoryItem *>(child(i));
 555     if(categoryItem->removeUser(ircUser)) {
 556       if(categoryItem->childCount() == 0)
 557         removeChild(i);
 558       break;
 559     }
 560   }
 561 }
 562
 563 void ChannelBufferItem::userModeChanged(IrcUser *ircUser) {
 564   Q_ASSERT(_ircChannel);
 565
 566   int categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
 567   UserCategoryItem *categoryItem = findCategoryItem(categoryId);
 568
 569   if(categoryItem) {
 570     if(categoryItem->findIrcUser(ircUser)) {
 571       return; // already in the right category;
 572     }
 573   } else {
 574     categoryItem = new UserCategoryItem(categoryId, this);
 575     newChild(categoryItem);
 576   }
 577
 578   // find the item that needs reparenting
 579   IrcUserItem *ircUserItem = 0;
 580   for(int i = 0; i < childCount(); i++) {
 581     UserCategoryItem *oldCategoryItem = qobject_cast<UserCategoryItem *>(child(i));
 582     Q_ASSERT(oldCategoryItem);
 583     IrcUserItem *userItem = oldCategoryItem->findIrcUser(ircUser);
 584     if(userItem) {
 585       ircUserItem = userItem;
 586       break;
 587     }
 588   }
 589
 590   if(!ircUserItem) {
 591     qWarning() << "ChannelBufferItem::userModeChanged(IrcUser *): unable to determine old category of" << ircUser;
 592     return;
 593   }
 594   ircUserItem->reParent(categoryItem);
 595 }
 596
 597 /*****************************************
 598 *  User Category Items (like @vh etc.)
 599 *****************************************/
 600 // we hardcode this even though we have PREFIX in network... but that wouldn't help with mapping modes to
 601 // category strings anyway.
 602 const QList<QChar> UserCategoryItem::categories = QList<QChar>() << 'q' << 'a' << 'o' << 'h' << 'v';
 603
 604 UserCategoryItem::UserCategoryItem(int category, AbstractTreeItem *parent)
 605   : PropertyMapItem(QStringList() << "categoryName", parent),
 606     _category(category)
 607 {
 608   setTreeItemFlags(AbstractTreeItem::DeleteOnLastChildRemoved);
 609   setObjectName(parent->data(0, Qt::DisplayRole).toString() + "/" + QString::number(category));
 610 }
 611
 612 // caching this makes no sense, since we display the user number dynamically
 613 QString UserCategoryItem::categoryName() const {
 614   int n = childCount();
 615   switch(_category) {
 616     case 0: return tr("%n Owner(s)", 0, n);
 617     case 1: return tr("%n Admin(s)", 0, n);
 618     case 2: return tr("%n Operator(s)", 0, n);
 619     case 3: return tr("%n Half-Op(s)", 0, n);
 620     case 4: return tr("%n Voiced", 0, n);
 621     default: return tr("%n User(s)", 0, n);
 622   }
 623 }
 624
 625 IrcUserItem *UserCategoryItem::findIrcUser(IrcUser *ircUser) {
 626   IrcUserItem *userItem = 0;
 627
 628   for(int i = 0; i < childCount(); i++) {
 629     userItem = qobject_cast<IrcUserItem *>(child(i));
 630     if(!userItem)
 631       continue;
 632     if(userItem->ircUser() == ircUser)
 633       return userItem;
 634   }
 635   return 0;
 636 }
 637
 638 void UserCategoryItem::addUsers(const QList<IrcUser *> &ircUsers) {
 639   QList<AbstractTreeItem *> userItems;
 640   foreach(IrcUser *ircUser, ircUsers)
 641     userItems << new IrcUserItem(ircUser, this);
 642   newChilds(userItems);
 643   emit dataChanged(0);
 644 }
 645
 646 bool UserCategoryItem::removeUser(IrcUser *ircUser) {
 647   IrcUserItem *userItem = findIrcUser(ircUser);
 648   bool success = (bool)userItem;
 649   if(success) {
 650     removeChild(userItem);
 651     emit dataChanged(0);
 652   }
 653   return success;
 654 }
 655
 656 int UserCategoryItem::categoryFromModes(const QString &modes) {
 657   for(int i = 0; i < categories.count(); i++) {
 658     if(modes.contains(categories[i]))
 659       return i;
 660   }
 661   return categories.count();
 662 }
 663
 664 QVariant UserCategoryItem::data(int column, int role) const {
 665   switch(role) {
 666   case TreeModel::SortRole:
 667     return _category;
 668   case NetworkModel::ItemActiveRole:
 669     return true;
 670   case NetworkModel::ItemTypeRole:
 671     return NetworkModel::UserCategoryItemType;
 672   case NetworkModel::BufferIdRole:
 673     return parent()->data(column, role);
 674   case NetworkModel::NetworkIdRole:
 675     return parent()->data(column, role);
 676   case NetworkModel::BufferInfoRole:
 677     return parent()->data(column, role);
 678   default:
 679     return PropertyMapItem::data(column, role);
 680   }
 681 }
 682
 683
 684 /*****************************************
 685 *  Irc User Items
 686 *****************************************/
 687 IrcUserItem::IrcUserItem(IrcUser *ircUser, AbstractTreeItem *parent)
 688   : PropertyMapItem(QStringList() << "nickName", parent),
 689     _ircUser(ircUser)
 690 {
 691   setObjectName(ircUser->nick());
 692   connect(ircUser, SIGNAL(quited()), this, SLOT(ircUserQuited()));
 693   connect(ircUser, SIGNAL(nickSet(QString)), this, SIGNAL(dataChanged()));
 694   connect(ircUser, SIGNAL(awaySet(bool)), this, SIGNAL(dataChanged()));
 695 }
 696
 697 QVariant IrcUserItem::data(int column, int role) const {
 698   switch(role) {
 699   case NetworkModel::ItemActiveRole:
 700     return isActive();
 701   case NetworkModel::ItemTypeRole:
 702     return NetworkModel::IrcUserItemType;
 703   case NetworkModel::BufferIdRole:
 704     return parent()->data(column, role);
 705   case NetworkModel::NetworkIdRole:
 706     return parent()->data(column, role);
 707   case NetworkModel::BufferInfoRole:
 708     return parent()->data(column, role);
 709   case NetworkModel::IrcChannelRole:
 710     return parent()->data(column, role);
 711   case NetworkModel::IrcUserRole:
 712     return QVariant::fromValue<QObject *>(_ircUser.data());
 713   case NetworkModel::UserAwayRole:
 714     return (bool)_ircUser ? _ircUser->isAway() : false;
 715   default:
 716     return PropertyMapItem::data(column, role);
 717   }
 718 }
 719
 720 QString IrcUserItem::toolTip(int column) const {
 721   Q_UNUSED(column);
 722   QStringList toolTip(QString("<b>%1</b>").arg(nickName()));
 723   if(_ircUser->userModes() != "") toolTip[0].append(QString(" (%1)").arg(_ircUser->userModes()));
 724   if(_ircUser->isAway()) {
 725     toolTip[0].append(" is away");
 726     if(!_ircUser->awayMessage().isEmpty())
 727       toolTip[0].append(QString(" (%1)").arg(_ircUser->awayMessage()));
 728   }
 729   if(!_ircUser->realName().isEmpty()) toolTip.append(_ircUser->realName());
 730   if(!_ircUser->ircOperator().isEmpty()) toolTip.append(QString("%1 %2").arg(nickName()).arg(_ircUser->ircOperator()));
 731   if(!_ircUser->suserHost().isEmpty()) toolTip.append(_ircUser->suserHost());
 732   if(!_ircUser->whoisServiceReply().isEmpty()) toolTip.append(_ircUser->whoisServiceReply());
 733
 734   toolTip.append(_ircUser->hostmask().remove(0, _ircUser->hostmask().indexOf("!")+1));
 735
 736   if(_ircUser->idleTime().isValid()) {
 737     QDateTime now = QDateTime::currentDateTime();
 738     QDateTime idle = _ircUser->idleTime();
 739     int idleTime = idle.secsTo(now);
 740     toolTip.append(tr("idling since %1").arg(secondsToString(idleTime)));
 741   }
 742   if(_ircUser->loginTime().isValid()) {
 743     toolTip.append(tr("login time: %1").arg(_ircUser->loginTime().toString()));
 744   }
 745
 746   if(!_ircUser->server().isEmpty()) toolTip.append(tr("server: %1").arg(_ircUser->server()));
 747
 748   return QString("<p> %1 </p>").arg(toolTip.join("<br />"));
 749 }
 750
 751 /*****************************************
 752  * NetworkModel
 753  *****************************************/
 754 NetworkModel::NetworkModel(QObject *parent)
 755   : TreeModel(NetworkModel::defaultHeader(), parent)
 756 {
 757   connect(this, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
 758           this, SLOT(checkForNewBuffers(const QModelIndex &, int, int)));
 759   connect(this, SIGNAL(rowsAboutToBeRemoved(const QModelIndex &, int, int)),
 760           this, SLOT(checkForRemovedBuffers(const QModelIndex &, int, int)));
 761 }
 762
 763 QList<QVariant >NetworkModel::defaultHeader() {
 764   QList<QVariant> data;
 765   data << tr("Buffer") << tr("Topic") << tr("Nick Count");
 766   return data;
 767 }
 768
 769 bool NetworkModel::isBufferIndex(const QModelIndex &index) const {
 770   return index.data(NetworkModel::ItemTypeRole) == NetworkModel::BufferItemType;
 771 }
 772
 773 int NetworkModel::networkRow(NetworkId networkId) const {
 774   NetworkItem *netItem = 0;
 775   for(int i = 0; i < rootItem->childCount(); i++) {
 776     netItem = qobject_cast<NetworkItem *>(rootItem->child(i));
 777     if(!netItem)
 778       continue;
 779     if(netItem->networkId() == networkId)
 780       return i;
 781   }
 782   return -1;
 783 }
 784
 785 QModelIndex NetworkModel::networkIndex(NetworkId networkId) {
 786   int netRow = networkRow(networkId);
 787   if(netRow == -1)
 788     return QModelIndex();
 789   else
 790     return indexByItem(qobject_cast<NetworkItem *>(rootItem->child(netRow)));
 791 }
 792
 793 NetworkItem *NetworkModel::findNetworkItem(NetworkId networkId) const {
 794   int netRow = networkRow(networkId);
 795   if(netRow == -1)
 796     return 0;
 797   else
 798     return qobject_cast<NetworkItem *>(rootItem->child(netRow));
 799 }
 800
 801 NetworkItem *NetworkModel::networkItem(NetworkId networkId) {
 802   NetworkItem *netItem = findNetworkItem(networkId);
 803
 804   if(netItem == 0) {
 805     netItem = new NetworkItem(networkId, rootItem);
 806     rootItem->newChild(netItem);
 807   }
 808   return netItem;
 809 }
 810
 811 void NetworkModel::networkRemoved(const NetworkId &networkId) {
 812   int netRow = networkRow(networkId);
 813   if(netRow != -1) {
 814     rootItem->removeChild(netRow);
 815   }
 816 }
 817
 818 QModelIndex NetworkModel::bufferIndex(BufferId bufferId) {
 819   if(!_bufferItemCache.contains(bufferId))
 820     return QModelIndex();
 821
 822   return indexByItem(_bufferItemCache[bufferId]);
 823 }
 824
 825 BufferItem *NetworkModel::findBufferItem(BufferId bufferId) const {
 826   if(_bufferItemCache.contains(bufferId))
 827     return _bufferItemCache[bufferId];
 828   else
 829     return 0;
 830 }
 831
 832 BufferItem *NetworkModel::bufferItem(const BufferInfo &bufferInfo) {
 833   if(_bufferItemCache.contains(bufferInfo.bufferId()))
 834     return _bufferItemCache[bufferInfo.bufferId()];
 835
 836   NetworkItem *netItem = networkItem(bufferInfo.networkId());
 837   return netItem->bufferItem(bufferInfo);
 838 }
 839
 840 QStringList NetworkModel::mimeTypes() const {
 841   // mimetypes we accept for drops
 842   QStringList types;
 843   // comma separated list of colon separated pairs of networkid and bufferid
 844   // example: 0:1,0:2,1:4
 845   types << "application/Quassel/BufferItemList";
 846   return types;
 847 }
 848
 849 bool NetworkModel::mimeContainsBufferList(const QMimeData *mimeData) {
 850   return mimeData->hasFormat("application/Quassel/BufferItemList");
 851 }
 852
 853 QList< QPair<NetworkId, BufferId> > NetworkModel::mimeDataToBufferList(const QMimeData *mimeData) {
 854   QList< QPair<NetworkId, BufferId> > bufferList;
 855
 856   if(!mimeContainsBufferList(mimeData))
 857     return bufferList;
 858
 859   QStringList rawBufferList = QString::fromAscii(mimeData->data("application/Quassel/BufferItemList")).split(",");
 860   NetworkId networkId;
 861   BufferId bufferUid;
 862   foreach(QString rawBuffer, rawBufferList) {
 863     if(!rawBuffer.contains(":"))
 864       continue;
 865     networkId = rawBuffer.section(":", 0, 0).toInt();
 866     bufferUid = rawBuffer.section(":", 1, 1).toInt();
 867     bufferList.append(qMakePair(networkId, bufferUid));
 868   }
 869   return bufferList;
 870 }
 871
 872
 873 QMimeData *NetworkModel::mimeData(const QModelIndexList &indexes) const {
 874   QMimeData *mimeData = new QMimeData();
 875
 876   QStringList bufferlist;
 877   QString netid, uid, bufferid;
 878   foreach(QModelIndex index, indexes) {
 879     netid = QString::number(index.data(NetworkIdRole).value<NetworkId>().toInt());
 880     uid = QString::number(index.data(BufferIdRole).value<BufferId>().toInt());
 881     bufferid = QString("%1:%2").arg(netid).arg(uid);
 882     if(!bufferlist.contains(bufferid))
 883       bufferlist << bufferid;
 884   }
 885
 886   mimeData->setData("application/Quassel/BufferItemList", bufferlist.join(",").toAscii());
 887
 888   return mimeData;
 889 }
 890
 891 bool NetworkModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) {
 892   Q_UNUSED(action)
 893   Q_UNUSED(row)
 894   Q_UNUSED(column)
 895
 896   if(!mimeContainsBufferList(data))
 897     return false;
 898
 899   // target must be a query
 900   BufferInfo::Type targetType = (BufferInfo::Type)parent.data(NetworkModel::BufferTypeRole).toInt();
 901   if(targetType != BufferInfo::QueryBuffer)
 902     return false;
 903
 904   QList< QPair<NetworkId, BufferId> > bufferList = mimeDataToBufferList(data);
 905
 906   // exactly one buffer has to be dropped
 907   if(bufferList.count() != 1)
 908     return false;
 909
 910   NetworkId netId = bufferList.first().first;
 911   BufferId bufferId = bufferList.first().second;
 912
 913   // no self merges (would kill us)
 914   if(bufferId == parent.data(BufferIdRole).value<BufferId>())
 915     return false;
 916
 917   NetworkItem *netItem = findNetworkItem(netId);
 918   Q_ASSERT(netItem);
 919
 920   BufferItem *bufferItem = netItem->findBufferItem(bufferId);
 921   Q_ASSERT(bufferItem);
 922
 923   // source must be a query too
 924   if(bufferItem->bufferType() != BufferInfo::QueryBuffer)
 925     return false;
 926
 927   // TODO: warn user about buffermerge!
 928   qDebug() << "merging" << bufferId << parent.data(BufferIdRole).value<BufferId>();
 929   removeRow(parent.row(), parent.parent());
 930
 931   return true;
 932 }
 933
 934 void NetworkModel::attachNetwork(Network *net) {
 935   NetworkItem *netItem = networkItem(net->networkId());
 936   netItem->attachNetwork(net);
 937 }
 938
 939 void NetworkModel::bufferUpdated(BufferInfo bufferInfo) {
 940   BufferItem *bufItem = bufferItem(bufferInfo);
 941   QModelIndex itemindex = indexByItem(bufItem);
 942   emit dataChanged(itemindex, itemindex);
 943 }
 944
 945 void NetworkModel::removeBuffer(BufferId bufferId) {
 946   BufferItem *buffItem = findBufferItem(bufferId);
 947   if(!buffItem)
 948     return;
 949
 950   buffItem->parent()->removeChild(buffItem);
 951 }
 952
 953 MsgId NetworkModel::lastSeenMsgId(BufferId bufferId) const {
 954   if(!_bufferItemCache.contains(bufferId))
 955     return MsgId();
 956
 957   return _bufferItemCache[bufferId]->lastSeenMsgId();
 958 }
 959
 960 MsgId NetworkModel::lastSeenMarkerMsgId(BufferId bufferId) const {
 961   if(!_bufferItemCache.contains(bufferId))
 962     return MsgId();
 963
 964   return _bufferItemCache[bufferId]->lastSeenMarkerMsgId();
 965 }
 966
 967 void NetworkModel::setLastSeenMsgId(const BufferId &bufferId, const MsgId &msgId) {
 968   BufferItem *bufferItem = findBufferItem(bufferId);
 969   if(!bufferItem) {
 970     qDebug() << "NetworkModel::setLastSeenMsgId(): buffer is unknown:" << bufferId;
 971     return;
 972   }
 973   bufferItem->setLastSeenMsgId(msgId);
 974 }
 975
 976 void NetworkModel::updateBufferActivity(const Message &msg) {
 977   BufferItem *item = bufferItem(msg.bufferInfo());
 978   item->updateActivityLevel(msg);
 979   if(item->isCurrentBuffer())
 980     emit setLastSeenMsg(item->bufferId(), msg.msgId());
 981 }
 982
 983 void NetworkModel::setBufferActivity(const BufferId &bufferId, BufferInfo::ActivityLevel level) {
 984   BufferItem *bufferItem = findBufferItem(bufferId);
 985   if(!bufferItem) {
 986     qDebug() << "NetworkModel::setBufferActivity(): buffer is unknown:" << bufferId;
 987     return;
 988   }
 989   bufferItem->setActivityLevel(level);
 990 }
 991
 992 void NetworkModel::clearBufferActivity(const BufferId &bufferId) {
 993   BufferItem *bufferItem = findBufferItem(bufferId);
 994   if(!bufferItem) {
 995     qDebug() << "NetworkModel::clearBufferActivity(): buffer is unknown:" << bufferId;
 996     return;
 997   }
 998   bufferItem->clearActivityLevel();
 999 }
1000
1001 const Network *NetworkModel::networkByIndex(const QModelIndex &index) const {
1002   QVariant netVariant = index.data(NetworkIdRole);
1003   if(!netVariant.isValid())
1004     return 0;
1005
1006   NetworkId networkId = netVariant.value<NetworkId>();
1007   return Client::network(networkId);
1008 }
1009
1010 void NetworkModel::checkForRemovedBuffers(const QModelIndex &parent, int start, int end) {
1011   if(parent.data(ItemTypeRole) != NetworkItemType)
1012     return;
1013
1014   for(int row = start; row <= end; row++) {
1015     _bufferItemCache.remove(parent.child(row, 0).data(BufferIdRole).value<BufferId>());
1016   }
1017 }
1018
1019 void NetworkModel::checkForNewBuffers(const QModelIndex &parent, int start, int end) {
1020   if(parent.data(ItemTypeRole) != NetworkItemType)
1021     return;
1022
1023   for(int row = start; row <= end; row++) {
1024     QModelIndex child = parent.child(row, 0);
1025     _bufferItemCache[child.data(BufferIdRole).value<BufferId>()] = static_cast<BufferItem *>(child.internalPointer());
1026   }
1027 }
1028
1029 QString NetworkModel::bufferName(BufferId bufferId) const {
1030   if(!_bufferItemCache.contains(bufferId))
1031     return QString();
1032
1033   return _bufferItemCache[bufferId]->bufferName();
1034 }
1035
1036 BufferInfo::Type NetworkModel::bufferType(BufferId bufferId) const {
1037   if(!_bufferItemCache.contains(bufferId))
1038     return BufferInfo::InvalidBuffer;
1039
1040   return _bufferItemCache[bufferId]->bufferType();
1041 }
1042
1043 BufferInfo NetworkModel::bufferInfo(BufferId bufferId) const {
1044   if(!_bufferItemCache.contains(bufferId))
1045     return BufferInfo();
1046
1047   return _bufferItemCache[bufferId]->bufferInfo();
1048 }
1049
1050 NetworkId NetworkModel::networkId(BufferId bufferId) const {
1051   if(!_bufferItemCache.contains(bufferId))
1052     return NetworkId();
1053
1054   NetworkItem *netItem = qobject_cast<NetworkItem *>(_bufferItemCache[bufferId]->parent());
1055   if(netItem)
1056     return netItem->networkId();
1057   else
1058     return NetworkId();
1059 }
1060
1061 QString NetworkModel::networkName(BufferId bufferId) const {
1062   if(!_bufferItemCache.contains(bufferId))
1063     return QString();
1064
1065   NetworkItem *netItem = qobject_cast<NetworkItem *>(_bufferItemCache[bufferId]->parent());
1066   if(netItem)
1067     return netItem->networkName();
1068   else
1069     return QString();
1070 }
1071
1072 BufferId NetworkModel::bufferId(NetworkId networkId, const QString &bufferName, Qt::CaseSensitivity cs) const {
1073   const NetworkItem *netItem = findNetworkItem(networkId);
1074   if(!netItem)
1075     return BufferId();
1076
1077   for(int i = 0; i < netItem->childCount(); i++) {
1078     BufferItem *bufferItem = qobject_cast<BufferItem *>(netItem->child(i));
1079     if(bufferItem && !bufferItem->bufferName().compare(bufferName, cs))
1080       return bufferItem->bufferId();
1081   }
1082   return BufferId();
1083 }