X-Git-Url: https://git.quassel-irc.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fclient%2Ftreemodel.cpp;h=42a40f7fd1d68d74d01aa700a697aa04c40688d3;hb=b2cf1b73760eadbeb3452d8d2260e1dc876e6fe5;hp=10baa0728d285de795cc98d3ad878fd22089da39;hpb=e733408e4759473bf38831f498f48a0f2f5e6dc7;p=quassel.git

diff --git a/src/client/treemodel.cpp b/src/client/treemodel.cpp
index 10baa072..42a40f7f 100644
--- a/src/client/treemodel.cpp
+++ b/src/client/treemodel.cpp
@@ -27,22 +27,12 @@
  *****************************************/
 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 {
@@ -52,7 +42,7 @@ 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;
@@ -78,18 +68,58 @@ void AbstractTreeItem::removeChild(int column, int row) {
   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)
@@ -126,29 +156,29 @@ int AbstractTreeItem::childCount() const {
 }
 
 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() const {
-  return _parentItem;
+  return qobject_cast<AbstractTreeItem *>(QObject::parent());
 }
 
 Qt::ItemFlags AbstractTreeItem::flags() const {
@@ -185,7 +215,8 @@ void AbstractTreeItem::childDestroyed() {
   
   _childItems[column].removeAt(row);
   _childHash[column].remove(_childHash[column].key(item));
-  emit childDestroyed(row);
+  emit beginRemoveChilds(row, row);
+  emit endRemoveChilds();
 }
   
 /*****************************************
@@ -201,10 +232,23 @@ SimpleTreeItem::~SimpleTreeItem() {
 }
 
 QVariant SimpleTreeItem::data(int column, int role) const {
-  if(role == Qt::DisplayRole && column < _itemData.count())
+  if(column >= columnCount() || role != Qt::DisplayRole)
+    return QVariant();
+  else
     return _itemData[column];
+}
+
+bool SimpleTreeItem::setData(int column, const QVariant &value, int role) {
+  if(column > columnCount() || role != Qt::DisplayRole)
+    return false;
+
+  if(column == columnCount())
+    _itemData.append(value);
   else
-    return QVariant();
+    _itemData[column] = value;
+
+  emit dataChanged(column);
+  return true;
 }
 
 int SimpleTreeItem::columnCount() const {
@@ -231,15 +275,20 @@ PropertyMapItem::~PropertyMapItem() {
 }
   
 QVariant PropertyMapItem::data(int column, int role) const {
-  if(column >= columnCount())
-    return QVariant();
-
-  if(role != Qt::DisplayRole)
+  if(column >= columnCount() || role != Qt::DisplayRole)
     return QVariant();
 
   return property(_propertyOrder[column].toAscii());
 }
 
+bool PropertyMapItem::setData(int column, const QVariant &value, int role) {
+  if(column >= columnCount() || role != Qt::DisplayRole)
+    return false;
+
+  emit dataChanged(column);
+  return setProperty(_propertyOrder[column].toAscii(), value);
+}
+
 int PropertyMapItem::columnCount() const {
   return _propertyOrder.count();
 }
@@ -257,6 +306,19 @@ TreeModel::TreeModel(const QList<QVariant> &data, QObject *parent)
   : QAbstractItemModel(parent)
 {
   rootItem = new SimpleTreeItem(data, 0);
+
+  connect(rootItem, SIGNAL(dataChanged(int)),
+	  this, SLOT(itemDataChanged(int)));
+  
+  connect(rootItem, SIGNAL(newChild(AbstractTreeItem *)),
+	  this, SLOT(newChild(AbstractTreeItem *)));
+
+  connect(rootItem, SIGNAL(beginRemoveChilds(int, int)),
+	  this, SLOT(beginRemoveChilds(int, int)));
+  
+  connect(rootItem, SIGNAL(endRemoveChilds()),
+	  this, SLOT(endRemoveChilds()));
+
 }
 
 TreeModel::~TreeModel() {
@@ -358,10 +420,18 @@ QVariant TreeModel::data(const QModelIndex &index, int role) const {
   if(!index.isValid())
     return QVariant();
 
-  AbstractTreeItem *item = static_cast<AbstractTreeItem*>(index.internalPointer());
+  AbstractTreeItem *item = static_cast<AbstractTreeItem *>(index.internalPointer());
   return item->data(index.column(), role);
 }
 
+bool TreeModel::setData(const QModelIndex &index, const QVariant &value, int role) {
+  if(!index.isValid())
+    return false;
+
+  AbstractTreeItem *item = static_cast<AbstractTreeItem *>(index.internalPointer());
+  return item->setData(index.column(), value, role);
+}
+
 Qt::ItemFlags TreeModel::flags(const QModelIndex &index) const {
   AbstractTreeItem *item;
   if(!index.isValid())
@@ -397,7 +467,7 @@ void TreeModel::itemDataChanged(int column) {
 }
 
 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;
   }
@@ -413,17 +483,23 @@ void TreeModel::appendChild(AbstractTreeItem *parent, AbstractTreeItem *child) {
   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();
 }
 
@@ -469,6 +545,5 @@ bool TreeModel::removeRows(int row, int count, const QModelIndex &parent) {
 }
 
 void TreeModel::clear() {
-  removeRows(0, rowCount());
-  reset();
+  rootItem->removeAllChilds();
 }