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 "bufferinfo.h"
  26 #include "client.h"
  27 #include "signalproxy.h"
  28 #include "network.h"
  29 #include "ircchannel.h"
  30 #include "ircuser.h"
  31
  32 #include "buffersettings.h"
  33
  34 #include "util.h" // get rid of this (needed for isChannelName)
  35
  36
  37 /*****************************************
  38 *  Fancy Buffer Items
  39 *****************************************/
  40 BufferItem::BufferItem(BufferInfo bufferInfo, AbstractTreeItem *parent)
  41   : PropertyMapItem(QStringList() << "bufferName" << "topic" << "nickCount", parent),
  42     _bufferInfo(bufferInfo),
  43     _bufferName(bufferInfo.bufferName()),
  44     _activity(Buffer::NoActivity),
  45     _ircChannel(0)
  46 {
  47   Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
  48   if(bufferType() == BufferInfo::QueryBuffer)
  49     flags |= Qt::ItemIsDropEnabled;
  50
  51   if(bufferType() == BufferInfo::StatusBuffer) {
  52     NetworkItem *networkItem = qobject_cast<NetworkItem *>(parent);
  53     connect(networkItem, SIGNAL(dataChanged()), this, SIGNAL(dataChanged()));
  54   }
  55   setFlags(flags);
  56 }
  57
  58 quint64 BufferItem::id() const {
  59   return qHash(bufferInfo().bufferId());
  60 }
  61
  62 // bool BufferItem::isStatusBuffer() const {
  63 //   return bufferType() == BufferInfo::StatusBuffer;
  64 // }
  65
  66 bool BufferItem::isActive() const {
  67   if(bufferType() == BufferInfo::ChannelBuffer)
  68     return _ircChannel;
  69   else
  70     return qobject_cast<NetworkItem *>(parent())->isActive();
  71 }
  72
  73 bool BufferItem::setActivityLevel(Buffer::ActivityLevel level) {
  74   _activity = level;
  75   emit dataChanged();
  76   return true;
  77 }
  78
  79 void BufferItem::updateActivityLevel(Buffer::ActivityLevel level) {
  80   Buffer::ActivityLevel oldActivity = _activity;
  81   _activity |= level;
  82   if(oldActivity != _activity)
  83     emit dataChanged();
  84 }
  85
  86 QVariant BufferItem::data(int column, int role) const {
  87   switch(role) {
  88   case NetworkModel::ItemTypeRole:
  89     return NetworkModel::BufferItemType;
  90   case NetworkModel::BufferIdRole:
  91     return qVariantFromValue(bufferInfo().bufferId());
  92   case NetworkModel::NetworkIdRole:
  93     return qVariantFromValue(bufferInfo().networkId());
  94   case NetworkModel::BufferInfoRole:
  95     return qVariantFromValue(bufferInfo());
  96   case NetworkModel::BufferTypeRole:
  97     return int(bufferType());
  98   case NetworkModel::ItemActiveRole:
  99     return isActive();
 100   case NetworkModel::BufferActivityRole:
 101     return (int)activityLevel();
 102   default:
 103     return PropertyMapItem::data(column, role);
 104   }
 105 }
 106
 107 bool BufferItem::setData(int column, const QVariant &value, int role) {
 108   switch(role) {
 109   case NetworkModel::BufferActivityRole:
 110     return setActivityLevel((Buffer::ActivityLevel)value.toInt());
 111   default:
 112     return PropertyMapItem::setData(column, value, role);
 113   }
 114   return true;
 115 }
 116
 117
 118 void BufferItem::attachIrcChannel(IrcChannel *ircChannel) {
 119   if(!ircChannel)
 120     return;
 121
 122   _ircChannel = ircChannel;
 123
 124   connect(ircChannel, SIGNAL(topicSet(QString)),
 125           this, SLOT(setTopic(QString)));
 126   connect(ircChannel, SIGNAL(ircUsersJoined(QList<IrcUser *>)),
 127           this, SLOT(join(QList<IrcUser *>)));
 128   connect(ircChannel, SIGNAL(ircUserParted(IrcUser *)),
 129           this, SLOT(part(IrcUser *)));
 130   connect(ircChannel, SIGNAL(destroyed()),
 131           this, SLOT(ircChannelDestroyed()));
 132   connect(ircChannel, SIGNAL(ircUserModesSet(IrcUser *, QString)),
 133           this, SLOT(userModeChanged(IrcUser *)));
 134   connect(ircChannel, SIGNAL(ircUserModeAdded(IrcUser *, QString)),
 135           this, SLOT(userModeChanged(IrcUser *)));
 136   connect(ircChannel, SIGNAL(ircUserModeRemoved(IrcUser *, QString)),
 137           this, SLOT(userModeChanged(IrcUser *)));
 138
 139   if(!ircChannel->ircUsers().isEmpty()) {
 140     qWarning() << "Channel" << ircChannel->name() << "has already users which is quite surprising :)";
 141     join(ircChannel->ircUsers());
 142   }
 143
 144   emit dataChanged();
 145 }
 146
 147 void BufferItem::ircChannelDestroyed() {
 148   Q_CHECK_PTR(_ircChannel);
 149   disconnect(_ircChannel, 0, this, 0);
 150   _ircChannel = 0;
 151   emit dataChanged();
 152   removeAllChilds();
 153 }
 154
 155 QString BufferItem::bufferName() const {
 156   if(bufferType() == BufferInfo::StatusBuffer)
 157     return tr("Status Buffer");
 158   else
 159     return _bufferName;
 160 }
 161
 162 void BufferItem::setBufferName(const QString &name) {
 163   _bufferName = name;
 164   // as long as we need those bufferInfos, we have to update that one aswell.
 165   // pretty ugly though :/
 166   _bufferInfo = BufferInfo(_bufferInfo.bufferId(), _bufferInfo.networkId(), _bufferInfo.type(), _bufferInfo.groupId(), name);
 167   emit dataChanged(0);
 168 }
 169
 170 QString BufferItem::topic() const {
 171   if(_ircChannel)
 172     return _ircChannel->topic();
 173   else
 174     return QString();
 175 }
 176
 177 void BufferItem::ircUserDestroyed() {
 178   // PRIVATE
 179   IrcUser *ircUser = static_cast<IrcUser *>(sender());
 180   removeUserFromCategory(ircUser);
 181   emit dataChanged(2);
 182 }
 183
 184 int BufferItem::nickCount() const {
 185   if(_ircChannel)
 186     return _ircChannel->ircUsers().count();
 187   else
 188     return 0;
 189 }
 190
 191 void BufferItem::setTopic(const QString &topic) {
 192   Q_UNUSED(topic);
 193   emit dataChanged(1);
 194 }
 195
 196 void BufferItem::join(const QList<IrcUser *> &ircUsers) {
 197   addUsersToCategory(ircUsers);
 198
 199   foreach(IrcUser *ircUser, ircUsers) {
 200     if(!ircUser)
 201       continue;
 202     connect(ircUser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed()));
 203   }
 204
 205   emit dataChanged(2);
 206 }
 207
 208 void BufferItem::addUserToCategory(IrcUser *ircUser) {
 209   addUsersToCategory(QList<IrcUser *>() << ircUser);
 210 }
 211
 212 void BufferItem::addUsersToCategory(const QList<IrcUser *> &ircUsers) {
 213   Q_ASSERT(_ircChannel);
 214
 215   QHash<UserCategoryItem *, QList<IrcUser *> > categories;
 216   foreach(IrcUser *ircUser, ircUsers) {
 217     UserCategoryItem *categoryItem;
 218     int categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
 219     if(!(categoryItem = qobject_cast<UserCategoryItem *>(childById(qHash(categoryId))))) {
 220       categoryItem = new UserCategoryItem(categoryId, this);
 221       categories[categoryItem] = QList<IrcUser *>();
 222       newChild(categoryItem);
 223     }
 224     categories[categoryItem] << ircUser;
 225   }
 226
 227   QHash<UserCategoryItem *, QList<IrcUser *> >::const_iterator catIter = categories.constBegin();
 228   while(catIter != categories.constEnd()) {
 229     catIter.key()->addUsers(catIter.value());
 230     catIter++;
 231   }
 232 }
 233
 234 void BufferItem::part(IrcUser *ircUser) {
 235   if(!ircUser) {
 236     qWarning() << bufferName() << "BufferItem::part(): unknown User" << ircUser;
 237     return;
 238   }
 239
 240   disconnect(ircUser, 0, this, 0);
 241   removeUserFromCategory(ircUser);
 242   emit dataChanged(2);
 243 }
 244
 245 void BufferItem::removeUserFromCategory(IrcUser *ircUser) {
 246   if(!_ircChannel) {
 247     // If we parted the channel there might still be some ircUsers connected.
 248     // in that case we just ignore the call
 249     Q_ASSERT(childCount() == 0);
 250     return;
 251   }
 252
 253   bool success = false;
 254   UserCategoryItem *categoryItem = 0;
 255   for(int i = 0; i < childCount(); i++) {
 256     categoryItem = qobject_cast<UserCategoryItem *>(child(i));
 257     if(success = categoryItem->removeUser(ircUser)) {
 258       if(categoryItem->childCount() == 0)
 259         removeChild(i);
 260       break;
 261     }
 262   }
 263
 264   if(!success) {
 265     qDebug() << "didn't find User:" << ircUser << qHash(ircUser);
 266     qDebug() << "==== Childlist for Item:" << this << id() << bufferName() << "====";
 267     for(int i = 0; i < childCount(); i++) {
 268       categoryItem = qobject_cast<UserCategoryItem *>(child(i));
 269       categoryItem->dumpChildList();
 270     }
 271     qDebug() << "==== End Of Childlist for Item:" << this << id() << bufferName() << "====";
 272   }
 273   Q_ASSERT(success);
 274 }
 275
 276 void BufferItem::userModeChanged(IrcUser *ircUser) {
 277   Q_ASSERT(_ircChannel);
 278
 279   UserCategoryItem *categoryItem;
 280   int categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
 281   if((categoryItem = qobject_cast<UserCategoryItem *>(childById(qHash(categoryId)))) && categoryItem->childById(qHash(ircUser)))
 282     return; // already in the right category;
 283
 284   removeUserFromCategory(ircUser);
 285   addUserToCategory(ircUser);
 286 }
 287
 288 QString BufferItem::toolTip(int column) const {
 289   Q_UNUSED(column);
 290   QStringList toolTip;
 291
 292   switch(bufferType()) {
 293     case BufferInfo::StatusBuffer: {
 294       QString netName = Client::network(bufferInfo().networkId())->networkName();
 295       toolTip.append(tr("<b>Status buffer of %1</b>").arg(netName));
 296       break;
 297     }
 298     case BufferInfo::ChannelBuffer:
 299       toolTip.append(tr("<b>Channel %1</b>").arg(bufferName()));
 300       if(isActive()) {
 301         //TODO: add channel modes
 302         toolTip.append(tr("<b>Users:</b> %1").arg(nickCount()));
 303
 304         BufferSettings s;
 305         bool showTopic = s.value("DisplayTopicInTooltip", QVariant(false)).toBool();
 306         if(showTopic) {
 307           QString _topic = topic();
 308           if(_topic != "") {
 309             _topic.replace(QString("<"), QString("&lt;"));
 310             _topic.replace(QString(">"), QString("&gt;"));
 311             toolTip.append(QString("<font size='-2'>&nbsp;</font>"));
 312             toolTip.append(tr("<b>Topic:</b> %1").arg(_topic));
 313           }
 314         }
 315       } else {
 316         toolTip.append(tr("Not active <br /> Double-click to join"));
 317       }
 318       break;
 319     case BufferInfo::QueryBuffer:
 320       toolTip.append(tr("<b>Query with %1</b>").arg(bufferName()));
 321       if(topic() != "") toolTip.append(tr("Away Message: %1").arg(topic()));
 322       break;
 323     default: //this should not happen
 324       toolTip.append(tr("%1 - %2").arg(bufferInfo().bufferId().toInt()).arg(bufferName()));
 325       break;
 326   }
 327
 328   return tr("<p> %1 </p>").arg(toolTip.join("<br />"));
 329 }
 330
 331 /*
 332 void BufferItem::setLastMsgInsert(QDateTime msgDate) {
 333   if(msgDate.isValid() && msgDate > _lastMsgInsert)
 334     _lastMsgInsert = msgDate;
 335 }
 336 */
 337 /*
 338 // FIXME emit dataChanged()
 339 bool BufferItem::setLastSeen() {
 340   if(_lastSeen > _lastMsgInsert)
 341     return false;
 342
 343   _lastSeen = _lastMsgInsert;
 344   BufferSettings(bufferInfo().bufferId()).setLastSeen(_lastSeen);
 345   return true;
 346 }
 347
 348 QDateTime BufferItem::lastSeen() {
 349   return _lastSeen;
 350 }
 351 */
 352 /*****************************************
 353 *  Network Items
 354 *****************************************/
 355 NetworkItem::NetworkItem(const NetworkId &netid, AbstractTreeItem *parent)
 356   : PropertyMapItem(QList<QString>() << "networkName" << "currentServer" << "nickCount", parent),
 357     _networkId(netid)
 358 {
 359   setFlags(Qt::ItemIsEnabled);
 360 }
 361
 362 QVariant NetworkItem::data(int column, int role) const {
 363   switch(role) {
 364   case NetworkModel::NetworkIdRole:
 365     return qVariantFromValue(_networkId);
 366   case NetworkModel::ItemTypeRole:
 367     return NetworkModel::NetworkItemType;
 368   case NetworkModel::ItemActiveRole:
 369     return isActive();
 370   default:
 371     return PropertyMapItem::data(column, role);
 372   }
 373 }
 374
 375 quint64 NetworkItem::id() const {
 376   return qHash(_networkId);
 377 }
 378
 379 bool NetworkItem::isActive() const {
 380   if(_network)
 381     return _network->isConnected();
 382   else
 383     return false;
 384 }
 385
 386 QString NetworkItem::networkName() const {
 387   if(_network)
 388     return _network->networkName();
 389   else
 390     return QString();
 391 }
 392
 393 QString NetworkItem::currentServer() const {
 394   if(_network)
 395     return _network->currentServer();
 396   else
 397     return QString();
 398 }
 399
 400 int NetworkItem::nickCount() const {
 401   if(_network)
 402     return _network->ircUsers().count();
 403   else
 404     return 0;
 405 }
 406
 407 void NetworkItem::attachNetwork(Network *network) {
 408   if(!network)
 409     return;
 410
 411   _network = network;
 412
 413   connect(network, SIGNAL(networkNameSet(QString)),
 414           this, SLOT(setNetworkName(QString)));
 415   connect(network, SIGNAL(currentServerSet(QString)),
 416           this, SLOT(setCurrentServer(QString)));
 417   connect(network, SIGNAL(ircChannelAdded(QString)),
 418           this, SLOT(attachIrcChannel(QString)));
 419   connect(network, SIGNAL(connectedSet(bool)),
 420           this, SIGNAL(dataChanged()));
 421   connect(network, SIGNAL(destroyed()),
 422           this, SIGNAL(dataChanged()));
 423
 424   emit dataChanged();
 425 }
 426
 427 void NetworkItem::attachIrcChannel(const QString &channelName) {
 428   IrcChannel *ircChannel = _network->ircChannel(channelName);
 429   if(!ircChannel) {
 430     qWarning() << "NetworkItem::attachIrcChannel(): unkown Channel" << channelName;
 431     return;
 432   }
 433
 434   BufferItem *bufferItem;
 435   for(int i = 0; i < childCount(); i++) {
 436     bufferItem = qobject_cast<BufferItem *>(child(i));
 437     if(bufferItem->bufferName().toLower() == ircChannel->name().toLower()) {
 438       bufferItem->attachIrcChannel(ircChannel);
 439       break;
 440     }
 441   }
 442 }
 443
 444 void NetworkItem::setNetworkName(const QString &networkName) {
 445   Q_UNUSED(networkName);
 446   emit dataChanged(0);
 447 }
 448
 449 void NetworkItem::setCurrentServer(const QString &serverName) {
 450   Q_UNUSED(serverName);
 451   emit dataChanged(1);
 452 }
 453
 454
 455 QString NetworkItem::toolTip(int column) const {
 456   Q_UNUSED(column);
 457
 458   QStringList toolTip(QString("<b>%1</b>").arg(networkName()));
 459   toolTip.append(QString("Server: %1").arg(currentServer()));
 460   toolTip.append(QString("Users: %1").arg(nickCount()));
 461
 462   return QString("<p> %1 </p>").arg(toolTip.join("<br />"));
 463 }
 464
 465
 466 /*****************************************
 467 *  User Category Items (like @vh etc.)
 468 *****************************************/
 469 // we hardcode this even though we have PREFIX in network... but that wouldn't help with mapping modes to
 470 // category strings anyway.
 471 const QList<QChar> UserCategoryItem::categories = QList<QChar>() << 'q' << 'a' << 'o' << 'h' << 'v';
 472
 473 UserCategoryItem::UserCategoryItem(int category, AbstractTreeItem *parent)
 474   : PropertyMapItem(QStringList() << "categoryName", parent),
 475     _category(category)
 476 {
 477
 478 }
 479
 480 // caching this makes no sense, since we display the user number dynamically
 481 QString UserCategoryItem::categoryName() const {
 482   int n = childCount();
 483   switch(_category) {
 484     case 0: return tr("%n Owner(s)", 0, n);
 485     case 1: return tr("%n Admin(s)", 0, n);
 486     case 2: return tr("%n Operator(s)", 0, n);
 487     case 3: return tr("%n Half-Op(s)", 0, n);
 488     case 4: return tr("%n Voiced", 0, n);
 489     default: return tr("%n User(s)", 0, n);
 490   }
 491 }
 492
 493 quint64 UserCategoryItem::id() const {
 494   return qHash(_category);
 495 }
 496
 497 void UserCategoryItem::addUsers(const QList<IrcUser *> &ircUsers) {
 498   QList<AbstractTreeItem *> userItems;
 499   foreach(IrcUser *ircUser, ircUsers)
 500     userItems << new IrcUserItem(ircUser, this);
 501   newChilds(userItems);
 502 }
 503
 504 bool UserCategoryItem::removeUser(IrcUser *ircUser) {
 505   return removeChildById(qHash(ircUser));
 506 }
 507
 508 int UserCategoryItem::categoryFromModes(const QString &modes) {
 509   for(int i = 0; i < categories.count(); i++) {
 510     if(modes.contains(categories[i]))
 511       return i;
 512   }
 513   return categories.count();
 514 }
 515
 516 QVariant UserCategoryItem::data(int column, int role) const {
 517   switch(role) {
 518   case TreeModel::SortRole:
 519     return _category;
 520   case NetworkModel::ItemActiveRole:
 521     return true;
 522   case NetworkModel::ItemTypeRole:
 523     return NetworkModel::UserCategoryItemType;
 524   case NetworkModel::BufferIdRole:
 525     return parent()->data(column, role);
 526   case NetworkModel::NetworkIdRole:
 527     return parent()->data(column, role);
 528   case NetworkModel::BufferInfoRole:
 529     return parent()->data(column, role);
 530   default:
 531     return PropertyMapItem::data(column, role);
 532   }
 533 }
 534
 535
 536 /*****************************************
 537 *  Irc User Items
 538 *****************************************/
 539 IrcUserItem::IrcUserItem(IrcUser *ircUser, AbstractTreeItem *parent)
 540   : PropertyMapItem(QStringList() << "nickName", parent),
 541     _ircUser(ircUser),
 542     _id(qHash(ircUser))
 543 {
 544   // we don't need to handle the ircUser's destroyed signal since it's automatically removed
 545   // by the IrcChannel::ircUserParted();
 546
 547   connect(ircUser, SIGNAL(nickSet(QString)),
 548           this, SLOT(setNick(QString)));
 549   connect(ircUser, SIGNAL(awaySet(bool)),
 550           this, SLOT(setAway(bool)));
 551 }
 552
 553 QString IrcUserItem::nickName() const {
 554   if(_ircUser)
 555     return _ircUser->nick();
 556   else
 557     return QString();
 558 }
 559
 560 bool IrcUserItem::isActive() const {
 561   if(_ircUser)
 562     return !_ircUser->isAway();
 563   else
 564     return false;
 565 }
 566
 567 IrcUser *IrcUserItem::ircUser() {
 568   return _ircUser;
 569 }
 570
 571 quint64 IrcUserItem::id() const {
 572   return _id;
 573 }
 574
 575 QVariant IrcUserItem::data(int column, int role) const {
 576   switch(role) {
 577   case NetworkModel::ItemActiveRole:
 578     return isActive();
 579   case NetworkModel::ItemTypeRole:
 580     return NetworkModel::IrcUserItemType;
 581   case NetworkModel::BufferIdRole:
 582     return parent()->data(column, role);
 583   case NetworkModel::NetworkIdRole:
 584     return parent()->data(column, role);
 585   case NetworkModel::BufferInfoRole:
 586     return parent()->data(column, role);
 587   default:
 588     return PropertyMapItem::data(column, role);
 589   }
 590 }
 591
 592 QString IrcUserItem::toolTip(int column) const {
 593   Q_UNUSED(column);
 594   QStringList toolTip(QString("<b>%1</b>").arg(nickName()));
 595   if(_ircUser->userModes() != "") toolTip[0].append(QString(" (%1)").arg(_ircUser->userModes()));
 596   if(_ircUser->isAway()) toolTip[0].append(" is away");
 597   if(!_ircUser->awayMessage().isEmpty()) toolTip[0].append(QString(" (%1)").arg(_ircUser->awayMessage()));
 598   if(!_ircUser->realName().isEmpty()) toolTip.append(_ircUser->realName());
 599   if(!_ircUser->ircOperator().isEmpty()) toolTip.append(QString("%1 %2").arg(nickName()).arg(_ircUser->ircOperator()));
 600   if(!_ircUser->suserHost().isEmpty()) toolTip.append(_ircUser->suserHost());
 601   if(!_ircUser->whoisServiceReply().isEmpty()) toolTip.append(_ircUser->whoisServiceReply());
 602
 603   toolTip.append(_ircUser->hostmask().remove(0, _ircUser->hostmask().indexOf("!")+1));
 604
 605   if(_ircUser->idleTime().isValid()) {
 606     QDateTime now = QDateTime::currentDateTime();
 607     QDateTime idle = _ircUser->idleTime();
 608     int idleTime = idle.secsTo(now);
 609     toolTip.append(tr("idling since %1").arg(secondsToString(idleTime)));
 610   }
 611   if(_ircUser->loginTime().isValid()) {
 612     toolTip.append(tr("login time: %1").arg(_ircUser->loginTime().toString()));
 613   }
 614
 615   if(!_ircUser->server().isEmpty()) toolTip.append(tr("server: %1").arg(_ircUser->server()));
 616
 617   return QString("<p> %1 </p>").arg(toolTip.join("<br />"));
 618 }
 619
 620 void IrcUserItem::setNick(QString newNick) {
 621   Q_UNUSED(newNick);
 622   emit dataChanged(0);
 623 }
 624
 625 void IrcUserItem::setAway(bool away) {
 626   Q_UNUSED(away);
 627   emit dataChanged(0);
 628 }
 629
 630 /*****************************************
 631  * NetworkModel
 632  *****************************************/
 633 NetworkModel::NetworkModel(QObject *parent)
 634   : TreeModel(NetworkModel::defaultHeader(), parent)
 635 {
 636 }
 637
 638 QList<QVariant >NetworkModel::defaultHeader() {
 639   QList<QVariant> data;
 640   data << tr("Buffer") << tr("Topic") << tr("Nick Count");
 641   return data;
 642 }
 643
 644 bool NetworkModel::isBufferIndex(const QModelIndex &index) const {
 645   return index.data(NetworkModel::ItemTypeRole) == NetworkModel::BufferItemType;
 646 }
 647
 648 /*
 649 Buffer *NetworkModel::getBufferByIndex(const QModelIndex &index) const {
 650   BufferItem *item = static_cast<BufferItem *>(index.internalPointer());
 651   return Client::instance()->buffer(item->id());
 652 }
 653 */
 654
 655
 656 // experimental stuff :)
 657 QModelIndex NetworkModel::networkIndex(NetworkId networkId) {
 658   return indexById(qHash(networkId));
 659 }
 660
 661 NetworkItem *NetworkModel::existsNetworkItem(NetworkId networkId) {
 662   return qobject_cast<NetworkItem *>(rootItem->childById(networkId.toInt()));
 663 }
 664
 665 NetworkItem *NetworkModel::networkItem(NetworkId networkId) {
 666   NetworkItem *netItem = existsNetworkItem(networkId);
 667
 668   if(netItem == 0) {
 669     netItem = new NetworkItem(networkId, rootItem);
 670     rootItem->newChild(netItem);
 671   }
 672
 673   Q_ASSERT(netItem);
 674   return netItem;
 675 }
 676
 677 void NetworkModel::networkRemoved(const NetworkId &networkId) {
 678   rootItem->removeChildById(qHash(networkId));
 679 }
 680
 681 QModelIndex NetworkModel::bufferIndex(BufferId bufferId) {
 682   AbstractTreeItem *netItem, *bufferItem;
 683   for(int i = 0; i < rootItem->childCount(); i++) {
 684     netItem = rootItem->child(i);
 685     if((bufferItem = netItem->childById(qHash(bufferId)))) {
 686       return indexByItem(bufferItem);
 687     }
 688   }
 689   return QModelIndex();
 690 }
 691
 692 BufferItem *NetworkModel::existsBufferItem(const BufferInfo &bufferInfo) {
 693   QModelIndex bufferIdx = bufferIndex(bufferInfo.bufferId());
 694   if(bufferIdx.isValid())
 695     return static_cast<BufferItem *>(bufferIdx.internalPointer());
 696   else
 697     return 0;
 698 }
 699
 700 BufferItem *NetworkModel::bufferItem(const BufferInfo &bufferInfo) {
 701   BufferItem *bufItem = existsBufferItem(bufferInfo);
 702   if(bufItem == 0) {
 703     NetworkItem *netItem = networkItem(bufferInfo.networkId());
 704     bufItem = new BufferItem(bufferInfo, netItem);
 705     netItem->newChild(bufItem);
 706   }
 707
 708   Q_ASSERT(bufItem);
 709   return bufItem;
 710 }
 711
 712 QStringList NetworkModel::mimeTypes() const {
 713   // mimetypes we accept for drops
 714   QStringList types;
 715   // comma separated list of colon separated pairs of networkid and bufferid
 716   // example: 0:1,0:2,1:4
 717   types << "application/Quassel/BufferItemList";
 718   return types;
 719 }
 720
 721 bool NetworkModel::mimeContainsBufferList(const QMimeData *mimeData) {
 722   return mimeData->hasFormat("application/Quassel/BufferItemList");
 723 }
 724
 725 QList< QPair<NetworkId, BufferId> > NetworkModel::mimeDataToBufferList(const QMimeData *mimeData) {
 726   QList< QPair<NetworkId, BufferId> > bufferList;
 727
 728   if(!mimeContainsBufferList(mimeData))
 729     return bufferList;
 730
 731   QStringList rawBufferList = QString::fromAscii(mimeData->data("application/Quassel/BufferItemList")).split(",");
 732   NetworkId networkId;
 733   BufferId bufferUid;
 734   foreach(QString rawBuffer, rawBufferList) {
 735     if(!rawBuffer.contains(":"))
 736       continue;
 737     networkId = rawBuffer.section(":", 0, 0).toInt();
 738     bufferUid = rawBuffer.section(":", 1, 1).toInt();
 739     bufferList.append(qMakePair(networkId, bufferUid));
 740   }
 741   return bufferList;
 742 }
 743
 744
 745 QMimeData *NetworkModel::mimeData(const QModelIndexList &indexes) const {
 746   QMimeData *mimeData = new QMimeData();
 747
 748   QStringList bufferlist;
 749   QString netid, uid, bufferid;
 750   foreach(QModelIndex index, indexes) {
 751     netid = QString::number(index.data(NetworkIdRole).value<NetworkId>().toInt());
 752     uid = QString::number(index.data(BufferIdRole).value<BufferId>().toInt());
 753     bufferid = QString("%1:%2").arg(netid).arg(uid);
 754     if(!bufferlist.contains(bufferid))
 755       bufferlist << bufferid;
 756   }
 757
 758   mimeData->setData("application/Quassel/BufferItemList", bufferlist.join(",").toAscii());
 759
 760   return mimeData;
 761 }
 762
 763 bool NetworkModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) {
 764   Q_UNUSED(action)
 765   Q_UNUSED(row)
 766   Q_UNUSED(column)
 767
 768   if(!mimeContainsBufferList(data))
 769     return false;
 770
 771   // target must be a query
 772   BufferInfo::Type targetType = (BufferInfo::Type)parent.data(NetworkModel::BufferTypeRole).toInt();
 773   if(targetType != BufferInfo::QueryBuffer)
 774     return false;
 775
 776   QList< QPair<NetworkId, BufferId> > bufferList = mimeDataToBufferList(data);
 777
 778   // exactly one buffer has to be dropped
 779   if(bufferList.count() != 1)
 780     return false;
 781
 782   NetworkId netId = bufferList.first().first;
 783   BufferId bufferId = bufferList.first().second;
 784
 785   // no self merges (would kill us)
 786   if(bufferId == parent.data(BufferIdRole).value<BufferId>())
 787     return false;
 788
 789   Q_ASSERT(rootItem->childById(qHash(netId)));
 790   Q_ASSERT(rootItem->childById(qHash(netId))->childById(qHash(bufferId)));
 791
 792   // source must be a query too
 793   BufferInfo::Type sourceType = (BufferInfo::Type)rootItem->childById(qHash(netId))->childById(qHash(bufferId))->data(0, BufferTypeRole).toInt();
 794   if(sourceType != BufferInfo::QueryBuffer)
 795     return false;
 796
 797   // TODO: warn user about buffermerge!
 798   qDebug() << "merging" << bufferId << parent.data(BufferIdRole).value<BufferId>();
 799   removeRow(parent.row(), parent.parent());
 800
 801   return true;
 802 }
 803
 804 void NetworkModel::attachNetwork(Network *net) {
 805   NetworkItem *netItem = networkItem(net->networkId());
 806   netItem->attachNetwork(net);
 807 }
 808
 809 void NetworkModel::bufferUpdated(BufferInfo bufferInfo) {
 810   BufferItem *bufItem = bufferItem(bufferInfo);
 811   QModelIndex itemindex = indexByItem(bufItem);
 812   emit dataChanged(itemindex, itemindex);
 813 }
 814
 815 void NetworkModel::removeBuffer(BufferId bufferId) {
 816   const int numNetworks = rootItem->childCount();
 817   if(numNetworks == 0)
 818     return;
 819
 820   for(int i = 0; i < numNetworks; i++) {
 821     if(rootItem->child(i)->removeChildById(qHash(bufferId)))
 822       break;
 823   }
 824 }
 825
 826 /*
 827 void NetworkModel::updateBufferActivity(const Message &msg) {
 828   BufferItem *buff = bufferItem(msg.bufferInfo());
 829   Q_ASSERT(buff);
 830
 831   buff->setLastMsgInsert(msg.timestamp());
 832
 833   if(buff->lastSeen() >= msg.timestamp())
 834     return;
 835
 836   BufferItem::ActivityLevel level = BufferItem::OtherActivity;
 837   if(msg.type() == Message::Plain || msg.type() == Message::Notice)
 838     level |= BufferItem::NewMessage;
 839
 840   if(msg.flags() & Message::Highlight)
 841       level |= BufferItem::Highlight;
 842
 843   bufferItem(msg.bufferInfo())->updateActivity(level);
 844 }
 845 */
 846
 847 void NetworkModel::setBufferActivity(const BufferInfo &info, Buffer::ActivityLevel level) {
 848   BufferItem *buff = bufferItem(info);
 849   Q_ASSERT(buff);
 850
 851   buff->setActivityLevel(level);
 852 }
 853
 854 const Network *NetworkModel::networkByIndex(const QModelIndex &index) const {
 855   QVariant netVariant = index.data(NetworkIdRole);
 856   if(!netVariant.isValid())
 857     return 0;
 858
 859   NetworkId networkId = netVariant.value<NetworkId>();
 860   return Client::network(networkId);
 861 }
 862