/***************************************************************************
- * 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 *child;
foreach(int key, _childItems.keys()) {
- qDeleteAll(_childItems[key]);
+ 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();
+ }
}
}
AbstractTreeItem *treeitem = _childItems[column].value(row);
_childItems[column].removeAt(row);
_childHash[column].remove(_childHash[column].key(treeitem));
+ disconnect(treeitem, 0, this, 0);
treeitem->deleteLater();
}
return -1;
QHash<int, QList<AbstractTreeItem*> >::const_iterator iter = _parentItem->_childItems.constBegin();
- int pos;
while(iter != _parentItem->_childItems.constEnd()) {
- pos = iter.value().indexOf(const_cast<AbstractTreeItem *>(this));
- if(pos != -1)
+ if(iter.value().contains(const_cast<AbstractTreeItem *>(this)))
return iter.key();
iter++;
}
return _parentItem->_childItems[column()].indexOf(const_cast<AbstractTreeItem*>(this));
}
-AbstractTreeItem *AbstractTreeItem::parent() {
+AbstractTreeItem *AbstractTreeItem::parent() const {
return _parentItem;
}
void AbstractTreeItem::childDestroyed() {
AbstractTreeItem *item = static_cast<AbstractTreeItem*>(sender());
- removeChild(item->column(), item->row());
+
+ if(!item) {
+ qWarning() << "AbstractTreeItem::childDestroyed() received null pointer!";
+ return;
+ }
+
+ QHash<int, QList<AbstractTreeItem*> >::const_iterator iter = _childItems.constBegin();
+ int column, row = -1;
+ while(iter != _childItems.constEnd()) {
+ row = iter.value().indexOf(item);
+ if(row != -1) {
+ column = iter.key();
+ break;
+ }
+ iter++;
+ }
+
+ if(row == -1) {
+ qWarning() << "AbstractTreeItem::childDestroyed(): unknown Child died:" << item << "parent:" << this;
+ return;
+ }
+
+ _childItems[column].removeAt(row);
+ _childHash[column].remove(_childHash[column].key(item));
+ emit childDestroyed(row);
}
/*****************************************
}
int TreeModel::columnCount(const QModelIndex &parent) const {
- if(parent.isValid())
- return static_cast<AbstractTreeItem*>(parent.internalPointer())->columnCount();
- else
- return rootItem->columnCount();
+ Q_UNUSED(parent)
+ // since there the Qt Views don't draw more columns than the header has columns
+ // we can be lazy and simply return the count of header columns
+ // actually this gives us more freedom cause we don't have to ensure that a rows parent
+ // has equal or more columns than that row
+
+// if(parent.isValid()) {
+// AbstractTreeItem *child;
+// if(child = static_cast<AbstractTreeItem *>(parent.internalPointer())->child(parent.column(), parent.row()))
+// return child->columnCount();
+// else
+// return static_cast<AbstractTreeItem*>(parent.internalPointer())->columnCount();
+// } else {
+// return rootItem->columnCount();
+// }
+
+ return rootItem->columnCount();
}
QVariant TreeModel::data(const QModelIndex &index, int role) const {
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;
- emit dataChanged(itemIndex, itemIndex);
+ 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(leftIndex, rightIndex);
}
void TreeModel::appendChild(AbstractTreeItem *parent, AbstractTreeItem *child) {
if(parent == 0 or child == 0) {
- qWarning() << "TreeModel::apendChild(parent, child) parent and child have to be valid pointers!" << parent << child;
+ qWarning() << "TreeModel::appendChild(parent, child) parent and child have to be valid pointers!" << parent << child;
return;
}
connect(child, SIGNAL(dataChanged(int)),
this, SLOT(itemDataChanged(int)));
+
+ connect(child, SIGNAL(newChild(AbstractTreeItem *)),
+ this, SLOT(newChild(AbstractTreeItem *)));
+
+ connect(child, SIGNAL(childDestroyed(int)),
+ this, SLOT(childDestroyed(int)));
+}
+
+void TreeModel::newChild(AbstractTreeItem *child) {
+ appendChild(static_cast<AbstractTreeItem *>(sender()), child);
}
+void TreeModel::childDestroyed(int row) {
+ QModelIndex parent = indexByItem(static_cast<AbstractTreeItem *>(sender()));
+ beginRemoveRows(parent, row, row);
+ endRemoveRows();
+}
bool TreeModel::removeRow(int row, const QModelIndex &parent) {
if(row > rowCount(parent))