1 /***************************************************************************
2 * Copyright (C) 2005-07 by the Quassel IRC Team *
3 * devel@quassel-irc.org *
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. *
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. *
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 ***************************************************************************/
21 #include <QColor> // FIXME Dependency on QtGui!
23 #include "buffertreemodel.h"
25 #include "mappedselectionmodel.h"
26 #include <QAbstractItemView>
28 #include "bufferinfo.h"
30 #include "signalproxy.h"
31 #include "networkinfo.h"
32 #include "ircchannel.h"
35 /*****************************************
37 *****************************************/
38 BufferTreeItem::BufferTreeItem(Buffer *buffer, AbstractTreeItem *parent)
39 : PropertyMapItem(QStringList() << "bufferName" << "topic" << "nickCount", parent),
41 activity(Buffer::NoActivity)
43 Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
44 if(buf->bufferType() == Buffer::QueryType)
45 flags |= Qt::ItemIsDropEnabled;
49 quint64 BufferTreeItem::id() const {
50 return buf->bufferInfo().uid();
53 void BufferTreeItem::setActivity(const Buffer::ActivityLevel &level) {
57 QColor BufferTreeItem::foreground(int column) const {
59 // for the time beeing we ignore the column :)
60 if(activity & Buffer::Highlight) {
61 return QColor(Qt::red);
62 } else if(activity & Buffer::NewMessage) {
63 return QColor(Qt::darkYellow);
64 } else if(activity & Buffer::OtherActivity) {
65 return QColor(Qt::darkGreen);
68 return QColor(Qt::black);
70 return QColor(Qt::gray);
74 QVariant BufferTreeItem::data(int column, int role) const {
76 case BufferTreeModel::BufferUidRole:
77 return buf->bufferInfo().uid();
78 case BufferTreeModel::NetworkIdRole:
79 return buf->bufferInfo().networkId();
80 case BufferTreeModel::BufferTypeRole:
81 return int(buf->bufferType());
82 case BufferTreeModel::BufferActiveRole:
83 return buf->isActive();
84 case Qt::ForegroundRole:
85 return foreground(column);
87 return PropertyMapItem::data(column, role);
91 void BufferTreeItem::attachIrcChannel(IrcChannel *ircChannel) {
95 _ircChannel = ircChannel;
97 connect(ircChannel, SIGNAL(topicSet(QString)),
98 this, SLOT(setTopic(QString)));
99 connect(ircChannel, SIGNAL(ircUserJoined(IrcUser *)),
100 this, SLOT(join(IrcUser *)));
101 connect(ircChannel, SIGNAL(ircUserParted(IrcUser *)),
102 this, SLOT(part(IrcUser *)));
105 QString BufferTreeItem::bufferName() const {
109 QString BufferTreeItem::topic() const {
111 return _ircChannel->topic();
116 int BufferTreeItem::nickCount() const {
118 return _ircChannel->ircUsers().count();
123 void BufferTreeItem::setTopic(const QString &topic) {
128 void BufferTreeItem::join(IrcUser *ircUser) {
133 void BufferTreeItem::part(IrcUser *ircUser) {
138 /*****************************************
140 *****************************************/
141 NetworkTreeItem::NetworkTreeItem(const uint &netid, const QString &network, AbstractTreeItem *parent)
142 : PropertyMapItem(QList<QString>() << "networkName" << "currentServer" << "nickCount", parent),
144 _networkName(network)
146 setFlags(Qt::ItemIsEnabled);
149 QVariant NetworkTreeItem::data(int column, int role) const {
151 case BufferTreeModel::NetworkIdRole:
153 case BufferTreeModel::ItemTypeRole:
154 return BufferTreeModel::NetworkItem;
156 return PropertyMapItem::data(column, role);
160 quint64 NetworkTreeItem::id() const {
164 QString NetworkTreeItem::networkName() const {
166 return _networkInfo->networkName();
171 QString NetworkTreeItem::currentServer() const {
173 return _networkInfo->currentServer();
178 int NetworkTreeItem::nickCount() const {
179 BufferTreeItem *bufferItem;
181 for(int i = 0; i < childCount(); i++) {
182 bufferItem = qobject_cast<BufferTreeItem *>(child(i));
185 count += bufferItem->nickCount();
190 void NetworkTreeItem::attachNetworkInfo(NetworkInfo *networkInfo) {
194 _networkInfo = networkInfo;
196 connect(networkInfo, SIGNAL(networkNameSet(QString)),
197 this, SLOT(setNetworkName(QString)));
198 connect(networkInfo, SIGNAL(currentServerSet(QString)),
199 this, SLOT(setCurrentServer(QString)));
200 connect(networkInfo, SIGNAL(ircChannelAdded(QString)),
201 this, SLOT(attachIrcChannel(QString)));
202 // FIXME: connect this and that...
205 void NetworkTreeItem::attachIrcChannel(const QString &channelName) {
206 IrcChannel *ircChannel = _networkInfo->ircChannel(channelName);
208 qWarning() << "NetworkTreeItem::attachIrcChannel(): unkown Channel" << channelName;
212 BufferTreeItem *bufferItem;
213 for(int i = 0; i < childCount(); i++) {
214 bufferItem = qobject_cast<BufferTreeItem *>(child(i));
215 if(bufferItem->bufferName() == ircChannel->name()) {
216 bufferItem->attachIrcChannel(ircChannel);
222 void NetworkTreeItem::setNetworkName(const QString &networkName) {
223 Q_UNUSED(networkName);
227 void NetworkTreeItem::setCurrentServer(const QString &serverName) {
228 Q_UNUSED(serverName);
232 /*****************************************
234 *****************************************/
235 BufferTreeModel::BufferTreeModel(QObject *parent)
236 : TreeModel(BufferTreeModel::defaultHeader(), parent),
237 _selectionModelSynchronizer(new SelectionModelSynchronizer(this)),
238 _propertyMapper(new ModelPropertyMapper(this))
240 // initialize the Property Mapper
241 _propertyMapper->setModel(this);
242 delete _propertyMapper->selectionModel();
243 MappedSelectionModel *mappedSelectionModel = new MappedSelectionModel(this);
244 _propertyMapper->setSelectionModel(mappedSelectionModel);
245 synchronizeSelectionModel(mappedSelectionModel);
247 connect(_selectionModelSynchronizer, SIGNAL(setCurrentIndex(QModelIndex, QItemSelectionModel::SelectionFlags)),
248 this, SLOT(setCurrentIndex(QModelIndex, QItemSelectionModel::SelectionFlags)));
251 QList<QVariant >BufferTreeModel::defaultHeader() {
252 QList<QVariant> data;
253 data << tr("Buffer") << tr("Topic") << tr("Nick Count");
257 void BufferTreeModel::synchronizeSelectionModel(MappedSelectionModel *selectionModel) {
258 selectionModelSynchronizer()->addSelectionModel(selectionModel);
261 void BufferTreeModel::synchronizeView(QAbstractItemView *view) {
262 MappedSelectionModel *mappedSelectionModel = new MappedSelectionModel(view->model());
263 selectionModelSynchronizer()->addSelectionModel(mappedSelectionModel);
264 Q_ASSERT(mappedSelectionModel);
265 delete view->selectionModel();
266 view->setSelectionModel(mappedSelectionModel);
269 void BufferTreeModel::mapProperty(int column, int role, QObject *target, const QByteArray &property) {
270 propertyMapper()->addMapping(column, role, target, property);
273 bool BufferTreeModel::isBufferIndex(const QModelIndex &index) const {
275 return parent(index) != QModelIndex();
278 Buffer *BufferTreeModel::getBufferByIndex(const QModelIndex &index) const {
279 BufferTreeItem *item = static_cast<BufferTreeItem *>(index.internalPointer());
280 // FIXME get rid of this
281 Q_ASSERT(item->buffer() == Client::instance()->buffer(item->id()));
282 return item->buffer();
286 // experimental stuff :)
287 QModelIndex BufferTreeModel::networkIndex(uint networkId) {
288 return indexById(networkId);
291 NetworkTreeItem *BufferTreeModel::network(uint networkId) {
292 return qobject_cast<NetworkTreeItem *>(rootItem->childById(networkId));
295 NetworkTreeItem *BufferTreeModel::newNetwork(uint networkId, const QString &networkName) {
296 NetworkTreeItem *networkItem = network(networkId);
298 if(networkItem == 0) {
299 networkItem = new NetworkTreeItem(networkId, networkName, rootItem);
300 appendChild(rootItem, networkItem);
303 Q_ASSERT(networkItem);
307 QModelIndex BufferTreeModel::bufferIndex(BufferInfo bufferInfo) {
308 QModelIndex networkIdx = networkIndex(bufferInfo.networkId());
309 if(!networkIdx.isValid())
310 return QModelIndex();
312 return indexById(bufferInfo.uid(), networkIdx);
315 BufferTreeItem *BufferTreeModel::buffer(BufferInfo bufferInfo) {
316 QModelIndex bufferIdx = bufferIndex(bufferInfo);
317 if(bufferIdx.isValid())
318 return static_cast<BufferTreeItem *>(bufferIdx.internalPointer());
323 BufferTreeItem *BufferTreeModel::newBuffer(BufferInfo bufferInfo) {
324 BufferTreeItem *bufferItem = buffer(bufferInfo);
325 if(bufferItem == 0) {
326 NetworkTreeItem *networkItem = newNetwork(bufferInfo.networkId(), bufferInfo.network());
328 // FIXME: get rid of the buffer pointer
329 Buffer *buffer = Client::instance()->buffer(bufferInfo.uid());
330 bufferItem = new BufferTreeItem(buffer, networkItem);
331 appendChild(networkItem, bufferItem);
334 Q_ASSERT(bufferItem);
338 QStringList BufferTreeModel::mimeTypes() const {
339 // mimetypes we accept for drops
341 // comma separated list of colon separated pairs of networkid and bufferid
342 // example: 0:1,0:2,1:4
343 types << "application/Quassel/BufferItemList";
347 bool BufferTreeModel::mimeContainsBufferList(const QMimeData *mimeData) {
348 return mimeData->hasFormat("application/Quassel/BufferItemList");
351 QList< QPair<uint, uint> > BufferTreeModel::mimeDataToBufferList(const QMimeData *mimeData) {
352 QList< QPair<uint, uint> > bufferList;
354 if(!mimeContainsBufferList(mimeData))
357 QStringList rawBufferList = QString::fromAscii(mimeData->data("application/Quassel/BufferItemList")).split(",");
358 uint networkId, bufferUid;
359 foreach(QString rawBuffer, rawBufferList) {
360 if(!rawBuffer.contains(":"))
362 networkId = rawBuffer.section(":", 0, 0).toUInt();
363 bufferUid = rawBuffer.section(":", 1, 1).toUInt();
364 bufferList.append(qMakePair(networkId, bufferUid));
370 QMimeData *BufferTreeModel::mimeData(const QModelIndexList &indexes) const {
371 QMimeData *mimeData = new QMimeData();
373 QStringList bufferlist;
374 QString netid, uid, bufferid;
375 foreach(QModelIndex index, indexes) {
376 netid = QString::number(index.data(NetworkIdRole).toUInt());
377 uid = QString::number(index.data(BufferUidRole).toUInt());
378 bufferid = QString("%1:%2").arg(netid).arg(uid);
379 if(!bufferlist.contains(bufferid))
380 bufferlist << bufferid;
383 mimeData->setData("application/Quassel/BufferItemList", bufferlist.join(",").toAscii());
388 bool BufferTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) {
393 if(!mimeContainsBufferList(data))
396 // target must be a query
397 Buffer::Type targetType = (Buffer::Type)parent.data(BufferTreeModel::BufferTypeRole).toInt();
398 if(targetType != Buffer::QueryType)
401 QList< QPair<uint, uint> > bufferList = mimeDataToBufferList(data);
403 // exactly one buffer has to be dropped
404 if(bufferList.count() != 1)
407 uint netId = bufferList.first().first;
408 uint bufferId = bufferList.first().second;
410 // no self merges (would kill us)
411 if(bufferId == parent.data(BufferUidRole).toUInt())
414 Q_ASSERT(rootItem->childById(netId));
415 Q_ASSERT(rootItem->childById(netId)->childById(bufferId));
417 // source must be a query too
418 Buffer::Type sourceType = (Buffer::Type)rootItem->childById(netId)->childById(bufferId)->data(0, BufferTypeRole).toInt();
419 if(sourceType != Buffer::QueryType)
422 // TODO: warn user about buffermerge!
423 qDebug() << "merging" << bufferId << parent.data(BufferUidRole).toInt();
424 removeRow(parent.row(), parent.parent());
429 void BufferTreeModel::attachNetworkInfo(NetworkInfo *networkInfo) {
430 NetworkTreeItem *networkItem = network(networkInfo->networkId());
432 qWarning() << "BufferTreeModel::attachNetworkInfo(): network is unknown!";
435 networkItem->attachNetworkInfo(networkInfo);
438 void BufferTreeModel::bufferUpdated(Buffer *buffer) {
439 BufferTreeItem *bufferItem = newBuffer(buffer->bufferInfo());
440 QModelIndex itemindex = indexByItem(bufferItem);
441 emit dataChanged(itemindex, itemindex);
444 // This Slot indicates that the user has selected a different buffer in the gui
445 void BufferTreeModel::setCurrentIndex(const QModelIndex &index, QItemSelectionModel::SelectionFlags command) {
447 Buffer *newCurrentBuffer;
448 if(isBufferIndex(index) && currentBuffer != (newCurrentBuffer = getBufferByIndex(index))) {
449 currentBuffer = newCurrentBuffer;
450 bufferActivity(Buffer::NoActivity, currentBuffer);
451 emit bufferSelected(currentBuffer);
452 emit selectionChanged(index);
456 void BufferTreeModel::bufferActivity(Buffer::ActivityLevel level, Buffer *buf) {
457 BufferTreeItem *bufferItem = buffer(buf->bufferInfo());
459 qWarning() << "BufferTreeModel::bufferActivity(): received Activity Info for uknown Buffer";
463 if(buf != currentBuffer)
464 bufferItem->setActivity(level);
466 bufferItem->setActivity(Buffer::NoActivity);
470 void BufferTreeModel::selectBuffer(Buffer *buffer) {
471 QModelIndex index = bufferIndex(buffer->bufferInfo());
472 if(!index.isValid()) {
473 qWarning() << "BufferTreeModel::selectBuffer(): unknown Buffer has been selected.";
477 setCurrentIndex(index, 0);