added ircserverhandler for whois, who and whowas
[quassel.git] / 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 "util.h" // get rid of this (needed for isChannelName)
33
34 /*****************************************
35 *  Fancy Buffer Items
36 *****************************************/
37 BufferItem::BufferItem(BufferInfo bufferInfo, AbstractTreeItem *parent)
38   : PropertyMapItem(QStringList() << "bufferName" << "topic" << "nickCount", parent),
39     _bufferInfo(bufferInfo),
40     _activity(NoActivity)
41 {
42   // determine BufferType
43   if(bufferInfo.buffer().isEmpty())
44     _type = StatusType;
45   else if(isChannelName(bufferInfo.buffer()))
46     _type = ChannelType;
47   else
48     _type = QueryType;
49
50   Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
51   if(bufferType() == QueryType)
52     flags |= Qt::ItemIsDropEnabled;
53   setFlags(flags);
54 }
55
56
57 const BufferInfo &BufferItem::bufferInfo() const {
58   return _bufferInfo;
59 }
60
61 quint64 BufferItem::id() const {
62   return bufferInfo().uid().toInt();
63 }
64
65 bool BufferItem::isStatusBuffer() const {
66    return bufferType() == StatusType;
67 }
68
69 BufferItem::Type BufferItem::bufferType() const {
70   return _type;
71 }
72
73 bool BufferItem::isActive() const {
74   if(bufferType() == ChannelType)
75     return _ircChannel;
76   else
77     return qobject_cast<NetworkItem *>(parent())->isActive();
78 }
79
80 BufferItem::ActivityLevel BufferItem::activity() const {
81   return _activity;
82 }
83
84 void BufferItem::setActivity(const ActivityLevel &level) {
85   _activity = level;
86   emit dataChanged();
87 }
88
89 void BufferItem::updateActivity(const ActivityLevel &level) {
90   _activity |= level;
91   emit dataChanged();
92 }
93
94 QVariant BufferItem::data(int column, int role) const {
95   switch(role) {
96   case NetworkModel::ItemTypeRole:
97     return NetworkModel::BufferItemType;
98   case NetworkModel::BufferIdRole:
99     return qVariantFromValue(bufferInfo().uid());
100   case NetworkModel::NetworkIdRole:
101     return qVariantFromValue(bufferInfo().networkId());
102   case NetworkModel::BufferInfoRole:
103     return qVariantFromValue(bufferInfo());
104   case NetworkModel::BufferTypeRole:
105     return int(bufferType());
106   case NetworkModel::ItemActiveRole:
107     return isActive();
108   case NetworkModel::BufferActivityRole:
109     return qVariantFromValue((int)activity());
110   default:
111     return PropertyMapItem::data(column, role);
112   }
113 }
114
115 bool BufferItem::setData(int column, const QVariant &value, int role) {
116   switch(role) {
117   case NetworkModel::BufferActivityRole:
118     setActivity((ActivityLevel)value.toInt());
119   default:
120     return PropertyMapItem::setData(column, value, role);
121   }
122   return true;
123 }
124
125
126 void BufferItem::attachIrcChannel(IrcChannel *ircChannel) {
127   if(!ircChannel)
128     return;
129   
130   _ircChannel = ircChannel;
131
132   connect(ircChannel, SIGNAL(topicSet(QString)),
133           this, SLOT(setTopic(QString)));
134   connect(ircChannel, SIGNAL(ircUserJoined(IrcUser *)),
135           this, SLOT(join(IrcUser *)));
136   connect(ircChannel, SIGNAL(ircUserParted(IrcUser *)),
137           this, SLOT(part(IrcUser *)));
138   connect(ircChannel, SIGNAL(destroyed()),
139           this, SLOT(ircChannelDestroyed()));
140   connect(ircChannel, SIGNAL(ircUserModesSet(IrcUser *, QString)),
141           this, SLOT(userModeChanged(IrcUser *)));
142   connect(ircChannel, SIGNAL(ircUserModeAdded(IrcUser *, QString)),
143           this, SLOT(userModeChanged(IrcUser *)));
144   connect(ircChannel, SIGNAL(ircUserModeRemoved(IrcUser *, QString)),
145           this, SLOT(userModeChanged(IrcUser *)));
146
147   if(!ircChannel->ircUsers().isEmpty()) {
148     qWarning() << "Channel" << ircChannel->name() << "has already users which is quite surprising :)";
149     foreach(IrcUser *ircUser, ircChannel->ircUsers()) {
150       join(ircUser);
151     }
152   }
153   
154   emit dataChanged();
155 }
156
157 void BufferItem::ircChannelDestroyed() {
158   emit dataChanged();
159   removeAllChilds();
160 }
161
162 QString BufferItem::bufferName() const {
163   if(bufferType() == StatusType)
164     return tr("Status Buffer");
165   else
166     return bufferInfo().buffer();
167 }
168
169 QString BufferItem::topic() const {
170   if(_ircChannel)
171     return _ircChannel->topic();
172   else
173     return QString();
174 }
175
176 int BufferItem::nickCount() const {
177   if(_ircChannel)
178     return _ircChannel->ircUsers().count();
179   else
180     return 0;
181 }
182
183 void BufferItem::setTopic(const QString &topic) {
184   Q_UNUSED(topic);
185   emit dataChanged(1);
186 }
187
188 void BufferItem::join(IrcUser *ircUser) {
189   if(!ircUser)
190     return;
191
192   addUserToCategory(ircUser);
193   emit dataChanged(2);
194 }
195
196 void BufferItem::addUserToCategory(IrcUser *ircUser) {
197   Q_ASSERT(_ircChannel);
198
199   UserCategoryItem *categoryItem;
200   int categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
201   if(!(categoryItem = qobject_cast<UserCategoryItem *>(childById(qHash(categoryId))))) {
202     categoryItem = new UserCategoryItem(categoryId, this);
203     newChild(categoryItem);
204   }
205   categoryItem->addUser(ircUser);
206
207   int totalusers = 0;
208   for(int i = 0; i < childCount(); i++) {
209     totalusers += child(i)->childCount();
210   }
211 }
212
213 void BufferItem::part(IrcUser *ircUser) {
214   if(!ircUser) {
215     qWarning() << bufferName() << "BufferItem::part(): unknown User" << ircUser;
216     return;
217   }
218
219   removeUserFromCategory(ircUser);
220   emit dataChanged(2);
221 }
222
223 void BufferItem::removeUserFromCategory(IrcUser *ircUser) {
224   Q_ASSERT(_ircChannel);
225
226   bool success = false;
227   UserCategoryItem *categoryItem = 0;
228   for(int i = 0; i < childCount(); i++) {
229     categoryItem = qobject_cast<UserCategoryItem *>(child(i));
230     if(success = categoryItem->removeChildById((quint64)ircUser)) {
231       if(categoryItem->childCount() == 0)
232         removeChild(i);
233       break;
234     }
235   }
236
237   
238   if(!success) {
239     qDebug() << "didn't find User:" << ircUser << (quint64)ircUser;
240     qDebug() << "==== Childlist for Item:" << this << id() << bufferName() << "====";
241     for(int i = 0; i < childCount(); i++) {
242       categoryItem = qobject_cast<UserCategoryItem *>(child(i));
243       categoryItem->dumpChildList();
244     }
245     qDebug() << "==== End Of Childlist for Item:" << this << id() << bufferName() << "====";
246   }
247   Q_ASSERT(success);
248
249   int totalusers = 0;
250   for(int i = 0; i < childCount(); i++) {
251     totalusers += child(i)->childCount();
252   }
253 }
254
255 void BufferItem::userModeChanged(IrcUser *ircUser) {
256   Q_ASSERT(_ircChannel);
257
258   UserCategoryItem *categoryItem;
259   int categoryId = UserCategoryItem::categoryFromModes(_ircChannel->userModes(ircUser));
260   if((categoryItem = qobject_cast<UserCategoryItem *>(childById(qHash(categoryId)))) && categoryItem->childById((quint64)(ircUser)))
261     return; // already in the right category;
262   
263   removeUserFromCategory(ircUser);
264   addUserToCategory(ircUser);
265 }
266
267 /*****************************************
268 *  Network Items
269 *****************************************/
270 NetworkItem::NetworkItem(const NetworkId &netid, AbstractTreeItem *parent)
271   : PropertyMapItem(QList<QString>() << "networkName" << "currentServer" << "nickCount", parent),
272     _networkId(netid)
273 {
274   setFlags(Qt::ItemIsEnabled);
275 }
276
277 QVariant NetworkItem::data(int column, int role) const {
278   switch(role) {
279   case NetworkModel::NetworkIdRole:
280     return qVariantFromValue(_networkId);
281   case NetworkModel::ItemTypeRole:
282     return NetworkModel::NetworkItemType;
283   case NetworkModel::ItemActiveRole:
284     return isActive();
285   default:
286     return PropertyMapItem::data(column, role);
287   }
288 }
289
290 quint64 NetworkItem::id() const {
291   return _networkId.toInt();
292 }
293
294 void NetworkItem::setActive(bool connected) {
295   Q_UNUSED(connected);
296   emit dataChanged();
297 }
298
299 bool NetworkItem::isActive() const {
300   if(_network)
301     return _network->isConnected();
302   else
303     return false;
304 }
305
306 QString NetworkItem::networkName() const {
307   if(_network)
308     return _network->networkName();
309   else
310     return QString();
311 }
312
313 QString NetworkItem::currentServer() const {
314   if(_network)
315     return _network->currentServer();
316   else
317     return QString();
318 }
319
320 int NetworkItem::nickCount() const {
321   if(_network)
322     return _network->ircUsers().count();
323   else
324     return 0;
325 }
326
327 void NetworkItem::attachNetwork(Network *network) {
328   if(!network)
329     return;
330   
331   _network = network;
332
333   connect(network, SIGNAL(networkNameSet(QString)),
334           this, SLOT(setNetworkName(QString)));
335   connect(network, SIGNAL(currentServerSet(QString)),
336           this, SLOT(setCurrentServer(QString)));
337   connect(network, SIGNAL(ircChannelAdded(QString)),
338           this, SLOT(attachIrcChannel(QString)));
339   connect(network, SIGNAL(connectedSet(bool)),
340           this, SLOT(setActive(bool)));
341   
342   // FIXME: connect this and that...
343
344   emit dataChanged();
345 }
346
347 void NetworkItem::attachIrcChannel(const QString &channelName) {
348   IrcChannel *ircChannel = _network->ircChannel(channelName);
349   if(!ircChannel) {
350     qWarning() << "NetworkItem::attachIrcChannel(): unkown Channel" << channelName;
351     return;
352   }
353   
354   BufferItem *bufferItem;
355   for(int i = 0; i < childCount(); i++) {
356     bufferItem = qobject_cast<BufferItem *>(child(i));
357     if(bufferItem->bufferName() == ircChannel->name()) {
358       bufferItem->attachIrcChannel(ircChannel);
359       break;
360     }
361   }
362 }
363
364 void NetworkItem::setNetworkName(const QString &networkName) {
365   Q_UNUSED(networkName);
366   emit dataChanged(0);
367 }
368
369 void NetworkItem::setCurrentServer(const QString &serverName) {
370   Q_UNUSED(serverName);
371   emit dataChanged(1);
372 }
373
374 /*****************************************
375 *  User Category Items (like @vh etc.)
376 *****************************************/
377 // we hardcode this even though we have PREFIX in network... but that wouldn't help with mapping modes to
378 // category strings anyway.
379 const QList<UserCategoryItem::Category> UserCategoryItem::categories = QList<UserCategoryItem::Category>()
380   << UserCategoryItem::Category('q', "Owners")
381   << UserCategoryItem::Category('a', "Admins")
382   << UserCategoryItem::Category('a', "Admins")
383   << UserCategoryItem::Category('o', "Operators")
384   << UserCategoryItem::Category('h', "Half-Ops")
385   << UserCategoryItem::Category('v', "Voiced");
386
387 UserCategoryItem::UserCategoryItem(int category, AbstractTreeItem *parent)
388   : PropertyMapItem(QStringList() << "categoryId", parent),
389     _category(category)
390 {
391 }
392
393 QString UserCategoryItem::categoryId() {
394   if(_category < categories.count())
395     return categories[_category].displayString;
396   else
397     return QString("Users");
398 }
399
400 quint64 UserCategoryItem::id() const {
401   return qHash(_category);
402 }
403
404 void UserCategoryItem::addUser(IrcUser *ircUser) {
405   newChild(new IrcUserItem(ircUser, this));
406 }
407
408 int UserCategoryItem::categoryFromModes(const QString &modes) {
409   for(int i = 0; i < categories.count(); i++) {
410     if(modes.contains(categories[i].mode))
411       return i;
412   }
413   return categories.count();
414 }
415
416 QVariant UserCategoryItem::data(int column, int role) const {
417   switch(role) {
418   case NetworkModel::ItemTypeRole:
419     return NetworkModel::UserCategoryItemType;
420   case NetworkModel::BufferIdRole:
421     return parent()->data(column, role);
422   case NetworkModel::NetworkIdRole:
423     return parent()->data(column, role);
424   case NetworkModel::BufferInfoRole:
425     return parent()->data(column, role);
426   default:
427     return PropertyMapItem::data(column, role);
428   }
429 }
430
431      
432 /*****************************************
433 *  Irc User Items
434 *****************************************/
435 IrcUserItem::IrcUserItem(IrcUser *ircUser, AbstractTreeItem *parent)
436   : PropertyMapItem(QStringList() << "nickName", parent),
437     _ircUser(ircUser)
438 {
439   // we don't need to handle the ircUser's destroyed signal since it's automatically removed
440   // by the IrcChannel::ircUserParted();
441   
442   connect(ircUser, SIGNAL(nickSet(QString)),
443           this, SLOT(setNick(QString)));
444 }
445
446 QString IrcUserItem::nickName() const {
447   return _ircUser->nick();
448 }
449
450 IrcUser *IrcUserItem::ircUser() {
451   return _ircUser;
452 }
453
454 quint64 IrcUserItem::id() const {
455   return (quint64)_ircUser;
456 }
457
458 QVariant IrcUserItem::data(int column, int role) const {
459   switch(role) {
460   case NetworkModel::ItemTypeRole:
461     return NetworkModel::IrcUserItemType;
462   case NetworkModel::BufferIdRole:
463     return parent()->data(column, role);
464   case NetworkModel::NetworkIdRole:
465     return parent()->data(column, role);
466   case NetworkModel::BufferInfoRole:
467     return parent()->data(column, role);
468   default:
469     return PropertyMapItem::data(column, role);
470   }
471 }
472
473 QString IrcUserItem::toolTip(int column) const {
474   Q_UNUSED(column);
475   QString toolTip = "<b>" + nickName() + "</b><br />" + _ircUser->hostmask();
476   if(_ircUser->isAway()) {
477     toolTip += "<br /> away";
478     if(!_ircUser->awayMessage().isEmpty()) { 
479       toolTip += " (" + _ircUser->awayMessage() + ")"; 
480     }
481   }
482   return "<p>" + toolTip + "</p>";
483 }
484
485 void IrcUserItem::setNick(QString newNick) {
486   Q_UNUSED(newNick);
487   emit dataChanged(0);
488 }
489
490 /*****************************************
491  * NetworkModel
492  *****************************************/
493 NetworkModel::NetworkModel(QObject *parent)
494   : TreeModel(NetworkModel::defaultHeader(), parent)
495 {
496 }
497
498 QList<QVariant >NetworkModel::defaultHeader() {
499   QList<QVariant> data;
500   data << tr("Buffer") << tr("Topic") << tr("Nick Count");
501   return data;
502 }
503
504 bool NetworkModel::isBufferIndex(const QModelIndex &index) const {
505   return index.data(NetworkModel::ItemTypeRole) == NetworkModel::BufferItemType;
506 }
507
508 /*
509 Buffer *NetworkModel::getBufferByIndex(const QModelIndex &index) const {
510   BufferItem *item = static_cast<BufferItem *>(index.internalPointer());
511   return Client::instance()->buffer(item->id());
512 }
513 */
514
515
516 // experimental stuff :)
517 QModelIndex NetworkModel::networkIndex(NetworkId networkId) {
518   return indexById(networkId.toInt());
519 }
520
521 NetworkItem *NetworkModel::existsNetworkItem(NetworkId networkId) {
522   return qobject_cast<NetworkItem *>(rootItem->childById(networkId.toInt()));
523 }
524
525 NetworkItem *NetworkModel::networkItem(NetworkId networkId) {
526   NetworkItem *netItem = existsNetworkItem(networkId);
527
528   if(netItem == 0) {
529     netItem = new NetworkItem(networkId, rootItem);
530     rootItem->newChild(netItem);
531   }
532
533   Q_ASSERT(netItem);
534   return netItem;
535 }
536
537 QModelIndex NetworkModel::bufferIndex(BufferId bufferId) {
538   AbstractTreeItem *netItem, *bufferItem;
539   for(int i = 0; i < rootItem->childCount(); i++) {
540     netItem = rootItem->child(i);
541     if((bufferItem = netItem->childById(bufferId.toInt()))) {
542       return indexById(bufferItem->id(), networkIndex(netItem->id()));
543     }
544   }
545   return QModelIndex();
546 }
547
548 BufferItem *NetworkModel::existsBufferItem(const BufferInfo &bufferInfo) {
549   QModelIndex bufferIdx = bufferIndex(bufferInfo.uid());
550   if(bufferIdx.isValid())
551     return static_cast<BufferItem *>(bufferIdx.internalPointer());
552   else
553     return 0;
554 }
555
556 BufferItem *NetworkModel::bufferItem(const BufferInfo &bufferInfo) {
557   BufferItem *bufItem = existsBufferItem(bufferInfo);
558   if(bufItem == 0) {
559     NetworkItem *netItem = networkItem(bufferInfo.networkId());
560     bufItem = new BufferItem(bufferInfo, netItem);
561     netItem->newChild(bufItem);
562   }
563
564   Q_ASSERT(bufItem);
565   return bufItem;
566 }
567
568 QStringList NetworkModel::mimeTypes() const {
569   // mimetypes we accept for drops
570   QStringList types;
571   // comma separated list of colon separated pairs of networkid and bufferid
572   // example: 0:1,0:2,1:4
573   types << "application/Quassel/BufferItemList";
574   return types;
575 }
576
577 bool NetworkModel::mimeContainsBufferList(const QMimeData *mimeData) {
578   return mimeData->hasFormat("application/Quassel/BufferItemList");
579 }
580
581 QList< QPair<NetworkId, BufferId> > NetworkModel::mimeDataToBufferList(const QMimeData *mimeData) {
582   QList< QPair<NetworkId, BufferId> > bufferList;
583
584   if(!mimeContainsBufferList(mimeData))
585     return bufferList;
586
587   QStringList rawBufferList = QString::fromAscii(mimeData->data("application/Quassel/BufferItemList")).split(",");
588   NetworkId networkId;
589   BufferId bufferUid;
590   foreach(QString rawBuffer, rawBufferList) {
591     if(!rawBuffer.contains(":"))
592       continue;
593     networkId = rawBuffer.section(":", 0, 0).toInt();
594     bufferUid = rawBuffer.section(":", 1, 1).toInt();
595     bufferList.append(qMakePair(networkId, bufferUid));
596   }
597   return bufferList;
598 }
599
600
601 QMimeData *NetworkModel::mimeData(const QModelIndexList &indexes) const {
602   QMimeData *mimeData = new QMimeData();
603
604   QStringList bufferlist;
605   QString netid, uid, bufferid;
606   foreach(QModelIndex index, indexes) {
607     netid = QString::number(index.data(NetworkIdRole).value<NetworkId>().toInt());
608     uid = QString::number(index.data(BufferIdRole).value<BufferId>().toInt());
609     bufferid = QString("%1:%2").arg(netid).arg(uid);
610     if(!bufferlist.contains(bufferid))
611       bufferlist << bufferid;
612   }
613
614   mimeData->setData("application/Quassel/BufferItemList", bufferlist.join(",").toAscii());
615
616   return mimeData;
617 }
618
619 bool NetworkModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) {
620   Q_UNUSED(action)
621   Q_UNUSED(row)
622   Q_UNUSED(column)
623
624   if(!mimeContainsBufferList(data))
625     return false;
626
627   // target must be a query
628   BufferItem::Type targetType = (BufferItem::Type)parent.data(NetworkModel::BufferTypeRole).toInt();
629   if(targetType != BufferItem::QueryType)
630     return false;
631
632   QList< QPair<NetworkId, BufferId> > bufferList = mimeDataToBufferList(data);
633
634   // exactly one buffer has to be dropped
635   if(bufferList.count() != 1)
636     return false;
637
638   NetworkId netId = bufferList.first().first;
639   BufferId bufferId = bufferList.first().second;
640
641   // no self merges (would kill us)
642   if(bufferId == parent.data(BufferIdRole).value<BufferId>())
643     return false; 
644   
645   Q_ASSERT(rootItem->childById(netId.toInt()));
646   Q_ASSERT(rootItem->childById(netId.toInt())->childById(bufferId.toInt()));
647
648   // source must be a query too
649   BufferItem::Type sourceType = (BufferItem::Type)rootItem->childById(netId.toInt())->childById(bufferId.toInt())->data(0, BufferTypeRole).toInt();
650   if(sourceType != BufferItem::QueryType)
651     return false;
652     
653   // TODO: warn user about buffermerge!
654   qDebug() << "merging" << bufferId << parent.data(BufferIdRole).value<BufferId>();
655   removeRow(parent.row(), parent.parent());
656   
657   return true;
658 }
659
660 void NetworkModel::attachNetwork(Network *net) {
661   NetworkItem *netItem = networkItem(net->networkId());
662   netItem->attachNetwork(net);
663 }
664
665 void NetworkModel::bufferUpdated(BufferInfo bufferInfo) {
666   BufferItem *bufItem = bufferItem(bufferInfo);
667   QModelIndex itemindex = indexByItem(bufItem);
668   emit dataChanged(itemindex, itemindex);
669 }
670
671 void NetworkModel::updateBufferActivity(const Message &msg) {
672   BufferItem::ActivityLevel level = BufferItem::OtherActivity;
673   if(msg.type() == Message::Plain || msg.type() == Message::Notice)
674     level |= BufferItem::NewMessage;
675
676   if(msg.flags() & Message::Highlight)
677     level |= BufferItem::Highlight;
678   
679   bufferItem(msg.buffer())->updateActivity(level);
680 }
681