1 /***************************************************************************
2 * Copyright (C) 2005-07 by The Quassel 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) any later version. *
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"
32 /*****************************************
34 *****************************************/
35 BufferTreeItem::BufferTreeItem(Buffer *buffer, TreeItem *parent) : TreeItem(parent) {
37 activity = Buffer::NoActivity;
40 uint BufferTreeItem::id() const {
41 return buf->bufferInfo().uid();
44 void BufferTreeItem::setActivity(const Buffer::ActivityLevel &level) {
48 QString BufferTreeItem::text(int column) const {
51 return buf->displayName();
53 return buf->networkName();
59 QColor BufferTreeItem::foreground(int /*column*/) const {
60 // for the time beeing we ignore the column :)
61 if(activity & Buffer::Highlight) {
62 return QColor(Qt::red);
63 } else if(activity & Buffer::NewMessage) {
64 return QColor(Qt::darkYellow);
65 } else if(activity & Buffer::OtherActivity) {
66 return QColor(Qt::darkGreen);
69 return QColor(Qt::black);
71 return QColor(Qt::gray);
76 QVariant BufferTreeItem::data(int column, int role) const {
80 case Qt::ForegroundRole:
81 return foreground(column);
82 case BufferTreeModel::BufferNameRole:
83 return buf->bufferName();
84 case BufferTreeModel::BufferTypeRole:
85 return int(buf->bufferType());
86 case BufferTreeModel::BufferActiveRole:
87 return buf->isActive();
88 case BufferTreeModel::BufferUidRole:
89 return buf->bufferInfo().uid();
95 Qt::ItemFlags BufferTreeItem::flags() const {
96 Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
97 if(buf->bufferType() == Buffer::QueryType)
98 flags |= Qt::ItemIsDropEnabled;
103 /*****************************************
105 *****************************************/
106 NetworkTreeItem::NetworkTreeItem(const QString &network, TreeItem *parent) : TreeItem(parent) {
108 itemData << net << "";
111 uint NetworkTreeItem::id() const {
115 Qt::ItemFlags NetworkTreeItem::flags() const {
116 return Qt::ItemIsEnabled | Qt::ItemIsDropEnabled;
119 /*****************************************
121 *****************************************/
122 BufferTreeModel::BufferTreeModel(QObject *parent)
123 : TreeModel(BufferTreeModel::defaultHeader(), parent),
124 _selectionModelSynchronizer(new SelectionModelSynchronizer(this)),
125 _propertyMapper(new ModelPropertyMapper(this))
127 rootItem->setFlags(rootItem->flags() | Qt::ItemIsDropEnabled);
128 _propertyMapper->setModel(this);
129 delete _propertyMapper->selectionModel();
130 MappedSelectionModel *mappedSelectionModel = new MappedSelectionModel(this);
131 _propertyMapper->setSelectionModel(mappedSelectionModel);
132 synchronizeSelectionModel(mappedSelectionModel);
134 connect(_selectionModelSynchronizer, SIGNAL(setCurrentIndex(QModelIndex, QItemSelectionModel::SelectionFlags)),
135 this, SLOT(setCurrentIndex(QModelIndex, QItemSelectionModel::SelectionFlags)));
138 QList<QVariant >BufferTreeModel::defaultHeader() {
139 QList<QVariant> data;
140 data << tr("Buffer") << tr("Network");
144 void BufferTreeModel::synchronizeSelectionModel(MappedSelectionModel *selectionModel) {
145 selectionModelSynchronizer()->addSelectionModel(selectionModel);
148 void BufferTreeModel::synchronizeView(QAbstractItemView *view) {
149 MappedSelectionModel *mappedSelectionModel = new MappedSelectionModel(view->model());
150 selectionModelSynchronizer()->addSelectionModel(mappedSelectionModel);
151 Q_ASSERT(mappedSelectionModel);
152 delete view->selectionModel();
153 view->setSelectionModel(mappedSelectionModel);
156 void BufferTreeModel::mapProperty(int column, int role, QObject *target, const QByteArray &property) {
157 propertyMapper()->addMapping(column, role, target, property);
160 bool BufferTreeModel::isBufferIndex(const QModelIndex &index) const {
162 return parent(index) != QModelIndex();
165 Buffer *BufferTreeModel::getBufferByIndex(const QModelIndex &index) const {
166 BufferTreeItem *item = static_cast<BufferTreeItem *>(index.internalPointer());
167 return item->buffer();
170 QModelIndex BufferTreeModel::getOrCreateNetworkItemIndex(Buffer *buffer) {
171 QString net = buffer->networkName();
172 TreeItem *networkItem;
174 if(!(networkItem = rootItem->childById(qHash(net)))) {
175 int nextRow = rootItem->childCount();
176 networkItem = new NetworkTreeItem(net, rootItem);
178 beginInsertRows(QModelIndex(), nextRow, nextRow);
179 rootItem->appendChild(networkItem);
183 Q_ASSERT(networkItem);
184 return index(networkItem->row(), 0);
187 QModelIndex BufferTreeModel::getOrCreateBufferItemIndex(Buffer *buffer) {
188 QModelIndex networkItemIndex = getOrCreateNetworkItemIndex(buffer);
189 NetworkTreeItem *networkItem = static_cast<NetworkTreeItem*>(networkItemIndex.internalPointer());
190 TreeItem *bufferItem;
192 if(!(bufferItem = networkItem->childById(buffer->bufferInfo().uid()))) {
193 int nextRow = networkItem->childCount();
194 bufferItem = new BufferTreeItem(buffer, networkItem);
196 beginInsertRows(networkItemIndex, nextRow, nextRow);
197 networkItem->appendChild(bufferItem);
201 Q_ASSERT(bufferItem);
202 return index(bufferItem->row(), 0, networkItemIndex);
205 QStringList BufferTreeModel::mimeTypes() const {
207 types << "application/Quassel/BufferItem/row"
208 << "application/Quassel/BufferItem/network"
209 << "application/Quassel/BufferItem/bufferInfo";
213 QMimeData *BufferTreeModel::mimeData(const QModelIndexList &indexes) const {
214 QMimeData *mimeData = new QMimeData();
216 QModelIndex index = indexes.first();
218 mimeData->setData("application/Quassel/BufferItem/row", QByteArray::number(index.row()));
219 mimeData->setData("application/Quassel/BufferItem/network", getBufferByIndex(index)->networkName().toUtf8());
220 mimeData->setData("application/Quassel/BufferItem/bufferInfo", QByteArray::number(getBufferByIndex(index)->bufferInfo().uid()));
224 bool BufferTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction /*action*/, int /*row*/, int /*column*/, const QModelIndex &parent) {
225 foreach(QString mimeType, mimeTypes()) {
226 if(!(data->hasFormat(mimeType)))
227 return false; // whatever the drop is... it's not a buffer...
230 int sourcerow = data->data("application/Quassel/BufferItem/row").toInt();
231 QString network = QString::fromUtf8(data->data("application/Quassel/BufferItem/network"));
233 Q_ASSERT(rootItem->childById(qHash(network)));
235 if(parent == QModelIndex()) // can't be a query...
238 Buffer *sourceBuffer = static_cast<BufferTreeItem *>(rootItem->childById(qHash(network))->child(sourcerow))->buffer();
239 Buffer *targetBuffer = getBufferByIndex(parent);
241 if(!(sourceBuffer->bufferType() & targetBuffer->bufferType() & Buffer::QueryType)) // only queries can be merged
244 if(sourceBuffer == targetBuffer) // we won't merge with ourself :)
247 // TODO: warn user about buffermerge!
248 qDebug() << "merging" << sourceBuffer->bufferName() << "with" << targetBuffer->bufferName();
249 removeRow(parent.row(), BufferTreeModel::parent(parent));
254 void BufferTreeModel::bufferUpdated(Buffer *buffer) {
255 QModelIndex itemindex = getOrCreateBufferItemIndex(buffer);
256 emit invalidateFilter();
257 emit dataChanged(itemindex, itemindex);
260 // This Slot indicates that the user has selected a different buffer in the gui
261 void BufferTreeModel::setCurrentIndex(const QModelIndex &index, QItemSelectionModel::SelectionFlags command) {
263 if(isBufferIndex(index)) {
264 currentBuffer = getBufferByIndex(index);
265 bufferActivity(Buffer::NoActivity, currentBuffer);
266 emit bufferSelected(currentBuffer);
267 emit selectionChanged(index);
271 void BufferTreeModel::bufferActivity(Buffer::ActivityLevel level, Buffer *buffer) {
272 BufferTreeItem *bufferItem = static_cast<BufferTreeItem*>(getOrCreateBufferItemIndex(buffer).internalPointer());
273 if(buffer != currentBuffer)
274 bufferItem->setActivity(level);
276 bufferItem->setActivity(Buffer::NoActivity);
277 bufferUpdated(buffer);
280 void BufferTreeModel::selectBuffer(Buffer *buffer) {
281 QModelIndex index = getOrCreateBufferItemIndex(buffer);
283 setCurrentIndex(index, 0);