/***************************************************************************
- * Copyright (C) 2005-07 by the Quassel IRC Team *
+ * Copyright (C) 2005-08 by the Quassel Project *
* devel@quassel-irc.org *
* *
* This program is free software; you can redistribute it and/or modify *
*****************************************/
AbstractTreeItem::AbstractTreeItem(AbstractTreeItem *parent)
: QObject(parent),
- _parentItem(parent),
_flags(Qt::ItemIsSelectable | Qt::ItemIsEnabled)
{
}
AbstractTreeItem::~AbstractTreeItem() {
- AbstractTreeItem *child;
- foreach(int key, _childItems.keys()) {
- QList<AbstractTreeItem *>::iterator iter = _childItems[key].begin();
- while(iter != _childItems[key].end()) {
- child = *iter;
- iter = _childItems[key].erase(iter);
- disconnect(child, 0, this, 0);
- child->deleteLater();
- }
- }
+ removeAllChilds();
}
quint64 AbstractTreeItem::id() const {
int AbstractTreeItem::defaultColumn() const {
// invalid QModelIndexes aka rootNodes get their Childs stuffed into column -1
// all others to 0
- if(_parentItem == 0)
+ if(parent() == 0)
return -1;
else
return 0;
if(!_childItems.contains(column)
|| _childItems[column].size() <= row)
return;
+
+ if(column == defaultColumn())
+ emit beginRemoveChilds(row, row);
AbstractTreeItem *treeitem = _childItems[column].value(row);
_childItems[column].removeAt(row);
_childHash[column].remove(_childHash[column].key(treeitem));
disconnect(treeitem, 0, this, 0);
treeitem->deleteLater();
+
+ if(column == defaultColumn())
+ emit endRemoveChilds();
}
void AbstractTreeItem::removeChild(int row) {
removeChild(defaultColumn(), row);
}
+void AbstractTreeItem::removeChildById(int column, const quint64 &id) {
+ if(!_childHash[column].contains(id))
+ return;
+
+ AbstractTreeItem *treeItem = _childHash[column][id];
+ int row = _childItems[column].indexOf(treeItem);
+ Q_ASSERT(row >= 0);
+ removeChild(column, row);
+}
+
+void AbstractTreeItem::removeChildById(const quint64 &id) {
+ removeChildById(defaultColumn(), id);
+}
+
+void AbstractTreeItem::removeAllChilds() {
+ if(childCount() == 0)
+ return;
+
+ emit beginRemoveChilds(0, childCount() - 1);
+
+ AbstractTreeItem *child;
+ foreach(int column, _childItems.keys()) {
+ QList<AbstractTreeItem *>::iterator iter = _childItems[column].begin();
+ while(iter != _childItems[column].end()) {
+ child = *iter;
+ _childHash[column].remove(_childHash[column].key(child));
+ iter = _childItems[column].erase(iter);
+ disconnect(child, 0, this, 0);
+ child->removeAllChilds();
+ child->deleteLater();
+ }
+ }
+ emit endRemoveChilds();
+}
+
AbstractTreeItem *AbstractTreeItem::child(int column, int row) const {
if(!_childItems.contains(column)
|| _childItems[column].size() <= row)
return child(defaultColumn(), row);
}
-AbstractTreeItem *AbstractTreeItem::childById(int column, const uint &id) const {
+AbstractTreeItem *AbstractTreeItem::childById(int column, const quint64 &id) const {
if(!_childHash.contains(column)
|| !_childHash[column].contains(id))
return 0;
return _childHash[column].value(id);
}
-AbstractTreeItem *AbstractTreeItem::childById(const uint &id) const {
+AbstractTreeItem *AbstractTreeItem::childById(const quint64 &id) const {
return childById(defaultColumn(), id);
}
}
int AbstractTreeItem::column() const {
- if(!_parentItem)
+ if(!parent())
return -1;
- QHash<int, QList<AbstractTreeItem*> >::const_iterator iter = _parentItem->_childItems.constBegin();
- while(iter != _parentItem->_childItems.constEnd()) {
+ QHash<int, QList<AbstractTreeItem*> >::const_iterator iter = parent()->_childItems.constBegin();
+ while(iter != parent()->_childItems.constEnd()) {
if(iter.value().contains(const_cast<AbstractTreeItem *>(this)))
return iter.key();
iter++;
}
// unable to find us o_O
- return _parentItem->defaultColumn();
+ return parent()->defaultColumn();
}
int AbstractTreeItem::row() const {
- if(!_parentItem)
+ if(!parent())
return -1;
else
- return _parentItem->_childItems[column()].indexOf(const_cast<AbstractTreeItem*>(this));
+ return parent()->_childItems[column()].indexOf(const_cast<AbstractTreeItem*>(this));
}
-AbstractTreeItem *AbstractTreeItem::parent() {
- return _parentItem;
+AbstractTreeItem *AbstractTreeItem::parent() const {
+ return qobject_cast<AbstractTreeItem *>(QObject::parent());
}
Qt::ItemFlags AbstractTreeItem::flags() const {
_childItems[column].removeAt(row);
_childHash[column].remove(_childHash[column].key(item));
- emit childDestroyed(row);
+ emit beginRemoveChilds(row, row);
+ emit endRemoveChilds();
}
/*****************************************
return QModelIndex();
}
-QModelIndex TreeModel::indexById(uint id, const QModelIndex &parent) const {
+QModelIndex TreeModel::indexById(quint64 id, const QModelIndex &parent) const {
AbstractTreeItem *parentItem;
if(!parent.isValid())
void TreeModel::itemDataChanged(int column) {
AbstractTreeItem *item = qobject_cast<AbstractTreeItem *>(sender());
- QModelIndex itemIndex;
+ QModelIndex leftIndex, rightIndex;
- if(item == rootItem)
- itemIndex = QModelIndex();
- else
- itemIndex = createIndex(item->row(), column, item);
+ if(item == rootItem)
+ return;
+
+ if(column == -1) {
+ leftIndex = createIndex(item->row(), 0, item);
+ rightIndex = createIndex(item->row(), item->columnCount()-1, item);
+ } else {
+ leftIndex = createIndex(item->row(), column, item);
+ rightIndex = leftIndex;
+ }
- emit dataChanged(itemIndex, itemIndex);
+ emit dataChanged(leftIndex, rightIndex);
}
void TreeModel::appendChild(AbstractTreeItem *parent, AbstractTreeItem *child) {
- if(parent == 0 or child == 0) {
+ if(parent == 0 || child == 0) {
qWarning() << "TreeModel::appendChild(parent, child) parent and child have to be valid pointers!" << parent << child;
return;
}
connect(child, SIGNAL(newChild(AbstractTreeItem *)),
this, SLOT(newChild(AbstractTreeItem *)));
- connect(child, SIGNAL(childDestroyed(int)),
- this, SLOT(childDestroyed(int)));
+ connect(child, SIGNAL(beginRemoveChilds(int, int)),
+ this, SLOT(beginRemoveChilds(int, int)));
+
+ connect(child, SIGNAL(endRemoveChilds()),
+ this, SLOT(endRemoveChilds()));
}
void TreeModel::newChild(AbstractTreeItem *child) {
appendChild(static_cast<AbstractTreeItem *>(sender()), child);
}
-void TreeModel::childDestroyed(int row) {
+void TreeModel::beginRemoveChilds(int firstRow, int lastRow) {
QModelIndex parent = indexByItem(static_cast<AbstractTreeItem *>(sender()));
- beginRemoveRows(parent, row, row);
+ beginRemoveRows(parent, firstRow, lastRow);
+}
+
+void TreeModel::endRemoveChilds() {
endRemoveRows();
}