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