activity = Buffer::NoActivity;
}
+uint BufferTreeItem::id() const {
+ return buf->bufferId().uid();
+}
+
void BufferTreeItem::setActivity(const Buffer::ActivityLevel &level) {
activity = level;
}
}
}
+/*****************************************
+* Network Items
+*****************************************/
+NetworkTreeItem::NetworkTreeItem(const QString &network, TreeItem *parent) : TreeItem(parent) {
+ net = network;
+ itemData << net << "";
+}
+
+uint NetworkTreeItem::id() const {
+ return qHash(net);
+}
+
+
+
/*****************************************
* BufferTreeModel
*****************************************/
}
bool BufferTreeModel::isBufferIndex(const QModelIndex &index) const {
+ // not so purdy...
return parent(index) != QModelIndex();
}
QModelIndex BufferTreeModel::getOrCreateNetworkItemIndex(Buffer *buffer) {
QString net = buffer->networkName();
+ TreeItem *networkItem;
- if(networkItem.contains(net)) {
- return index(networkItem[net]->row(), 0);
- } else {
- QList<QVariant> data;
- data << net << "";
-
+ if(not(networkItem = rootItem->childById(qHash(net)))) {
int nextRow = rootItem->childCount();
+ networkItem = new NetworkTreeItem(net, rootItem);
beginInsertRows(QModelIndex(), nextRow, nextRow);
- rootItem->appendChild(new TreeItem(data, rootItem));
+ rootItem->appendChild(networkItem);
endInsertRows();
-
- networkItem[net] = rootItem->child(nextRow);
- return index(nextRow, 0);
}
+
+ Q_ASSERT(networkItem);
+ return index(networkItem->row(), 0);
}
QModelIndex BufferTreeModel::getOrCreateBufferItemIndex(Buffer *buffer) {
QModelIndex networkItemIndex = getOrCreateNetworkItemIndex(buffer);
-
- if(bufferItem.contains(buffer)) {
- return index(bufferItem[buffer]->row(), 0, networkItemIndex);
- } else {
- // first we determine the parent of the new Item
- TreeItem *networkItem = static_cast<TreeItem*>(networkItemIndex.internalPointer());
- Q_ASSERT(networkItem);
+ NetworkTreeItem *networkItem = static_cast<NetworkTreeItem*>(networkItemIndex.internalPointer());
+ TreeItem *bufferItem;
+
+ if(not(bufferItem = networkItem->childById(buffer->bufferId().uid()))) {
int nextRow = networkItem->childCount();
-
+ bufferItem = new BufferTreeItem(buffer, networkItem);
+
beginInsertRows(networkItemIndex, nextRow, nextRow);
- networkItem->appendChild(new BufferTreeItem(buffer, networkItem));
+ networkItem->appendChild(bufferItem);
endInsertRows();
-
- bufferItem[buffer] = static_cast<BufferTreeItem *>(networkItem->child(nextRow));
- return index(nextRow, 0, networkItemIndex);
}
+
+ Q_ASSERT(bufferItem);
+ return index(bufferItem->row(), 0, networkItemIndex);
}
QStringList BufferTreeModel::mimeTypes() const {
int sourcerow = data->data("application/Quassel/BufferItem/row").toInt();
QString network = QString::fromUtf8(data->data("application/Quassel/BufferItem/network"));
- Q_ASSERT(networkItem.contains(network));
+ Q_ASSERT(rootItem->childById(qHash(network)));
if(parent == QModelIndex()) // can't be a query...
return false;
- Buffer *sourceBuffer = static_cast<BufferTreeItem *>(networkItem[network]->child(sourcerow))->buffer();
+ Buffer *sourceBuffer = static_cast<BufferTreeItem *>(rootItem->childById(qHash(network))->child(sourcerow))->buffer();
Buffer *targetBuffer = getBufferByIndex(parent);
if(!(sourceBuffer->bufferType() & targetBuffer->bufferType() & Buffer::QueryBuffer)) // only queries can be merged
*/
qDebug() << "merging" << sourceBuffer->bufferName() << "with" << targetBuffer->bufferName();
- bufferItem.remove(getBufferByIndex(parent));
removeRow(parent.row(), BufferTreeModel::parent(parent));
return true;
}
void BufferTreeModel::bufferActivity(Buffer::ActivityLevel level, Buffer *buffer) {
- if(bufferItem.contains(buffer) and buffer != currentBuffer)
- bufferItem[buffer]->setActivity(level);
+ BufferTreeItem *bufferItem = static_cast<BufferTreeItem*>(getOrCreateBufferItemIndex(buffer).internalPointer());
+ if(buffer != currentBuffer)
+ bufferItem->setActivity(level);
else
- bufferItem[buffer]->setActivity(Buffer::NoActivity);
+ bufferItem->setActivity(Buffer::NoActivity);
bufferUpdated(buffer);
}
emit selectionChanged(index);
}
-// EgS: check if this makes sense!
-void BufferTreeModel::clear() {
- TreeModel::clear();
- networkItem.clear();
- bufferItem.clear();
-}
public:
BufferTreeItem(Buffer *, TreeItem *parent = 0);
+
+ virtual uint id() const;
+
QVariant data(int column, int role) const;
Buffer *buffer() const { return buf; }
void setActivity(const Buffer::ActivityLevel &);
Buffer::ActivityLevel activity;
};
+/*****************************************
+ * Network Items
+ *****************************************/
+class NetworkTreeItem : public TreeItem {
+ Q_OBJECT
+
+public:
+ NetworkTreeItem(const QString &, TreeItem *parent = 0);
+
+ virtual uint id() const;
+
+private:
+ QString net;
+
+};
/*****************************************
* BufferTreeModel
virtual Qt::ItemFlags flags(const QModelIndex &index) const;
-// void clearActivity(Buffer *buffer);
- void clear(); // EgS: check this
-
public slots:
void bufferUpdated(Buffer *);
void changeCurrent(const QModelIndex &, const QModelIndex &);
QMimeData *mimeData(const QModelIndexList &) const;
bool dropMimeData(const QMimeData *, Qt::DropAction, int, int, const QModelIndex &);
- QHash<QString, TreeItem*> networkItem;
- QHash<Buffer *, BufferTreeItem*> bufferItem;
Buffer *currentBuffer;
};
qDeleteAll(childItems);
}
+uint TreeItem::id() const {
+ return (uint)this;
+}
+
void TreeItem::appendChild(TreeItem *item) {
childItems.append(item);
+ childHash[item->id()] = item;
}
void TreeItem::removeChild(int row) {
+ if(row >= childItems.size())
+ return;
+ TreeItem *treeitem = childItems.value(row);
childItems.removeAt(row);
+ childHash.remove(childHash.key(treeitem));
}
-TreeItem *TreeItem::child(int row) {
- return childItems.value(row);
+TreeItem *TreeItem::child(int row) const {
+ if(row < childItems.size())
+ return childItems.value(row);
+ else
+ return 0;
+}
+
+TreeItem *TreeItem::childById(const uint &id) const {
+ if(childHash.contains(id))
+ return childHash.value(id);
+ else
+ return 0;
}
int TreeItem::childCount() const {
return QModelIndex();
}
+QModelIndex TreeModel::indexById(uint id, const QModelIndex &parent) const {
+ TreeItem *parentItem;
+
+ if(!parent.isValid())
+ parentItem = rootItem;
+ else
+ parentItem = static_cast<TreeItem *>(parent.internalPointer());
+
+ TreeItem *childItem = parentItem->childById(id);
+ if(childItem)
+ return createIndex(childItem->row(), 0, childItem);
+ else
+ return QModelIndex();
+}
+
QModelIndex TreeModel::parent(const QModelIndex &index) const {
if(!index.isValid())
return QModelIndex();
#include <QList>
#include <QVariant>
+#include <QHash>
#include <QAbstractItemModel>
/*****************************************
*****************************************/
class TreeItem : public QObject {
Q_OBJECT
+ Q_PROPERTY(uint id READ id)
public:
TreeItem(const QList<QVariant> &data, TreeItem *parent = 0);
void appendChild(TreeItem *child);
void removeChild(int row);
- TreeItem *child(int row);
+ virtual uint id() const;
+ TreeItem *child(int row) const;
+ TreeItem *childById(const uint &) const;
int childCount() const;
int columnCount() const;
virtual QVariant data(int column, int role) const;
TreeItem *parent();
protected:
- QList<TreeItem*> childItems;
+ QList<TreeItem *> childItems;
+ QHash<uint, TreeItem *> childHash; // uint to be compatible to qHash functions
TreeItem *parentItem;
QList<QVariant> itemData;
};
virtual Qt::ItemFlags flags(const QModelIndex &index) const;
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
+ QModelIndex indexById(uint id, const QModelIndex &parent = QModelIndex()) const;
QModelIndex parent(const QModelIndex &index) const;
int rowCount(const QModelIndex &parent = QModelIndex()) const;
int columnCount(const QModelIndex &parent = QModelIndex()) const;