Fixing the Bug where a clear of the BufferTreeModel would not result in cleard hashlists.

[quassel.git] / src / client / buffertreemodel.cpp

diff --git a/src/client/buffertreemodel.cpp b/src/client/buffertreemodel.cpp
index 43f624e..e1b5266 100644 (file)
--- a/src/client/buffertreemodel.cpp
+++ b/src/client/buffertreemodel.cpp
@@ -20,7 +20,7 @@
 
 #include <QColor>  // FIXME Dependency on QtGui!
 
-#include "global.h"
+#include "clientproxy.h"
 #include "buffertreemodel.h"
 
 /*****************************************
@@ -31,6 +31,10 @@ BufferTreeItem::BufferTreeItem(Buffer *buffer, TreeItem *parent) : TreeItem(pare
   activity = Buffer::NoActivity;
 }
 
+uint BufferTreeItem::id() const {
+  return buf->bufferId().uid();
+}
+
 void BufferTreeItem::setActivity(const Buffer::ActivityLevel &level) {
   activity = level;
 }
@@ -46,7 +50,7 @@ QString BufferTreeItem::text(int column) const {
   }
 }
 
-QColor BufferTreeItem::foreground(int column) const {
+QColor BufferTreeItem::foreground(int /*column*/) const {
   // for the time beeing we ignore the column :)
   if(activity & Buffer::Highlight) {
     return QColor(Qt::red);
@@ -82,11 +86,26 @@ QVariant BufferTreeItem::data(int column, int role) const {
   }
 }
 
+/*****************************************
+*  Network Items
+*****************************************/
+NetworkTreeItem::NetworkTreeItem(const QString &network, TreeItem *parent) : TreeItem(parent) {
+  net = network;
+  itemData << net << "";
+}
+
+uint NetworkTreeItem::id() const {
+  return qHash(net);
+}
+
+
+
 /*****************************************
  * BufferTreeModel
  *****************************************/
 BufferTreeModel::BufferTreeModel(QObject *parent) : TreeModel(BufferTreeModel::defaultHeader(), parent) {
-  connect(this, SIGNAL(fakeUserInput(BufferId, QString)), ClientProxy::instance(), SLOT(gsUserInput(BufferId, QString)));
+  connect(this, SIGNAL(fakeUserInput(BufferId, QString)),
+          ClientProxy::instance(), SLOT(gsUserInput(BufferId, QString)));
 }
 
 QList<QVariant >BufferTreeModel::defaultHeader() {
@@ -114,6 +133,7 @@ Qt::ItemFlags BufferTreeModel::flags(const QModelIndex &index) const {
 }
 
 bool BufferTreeModel::isBufferIndex(const QModelIndex &index) const {
+  // not so purdy...
   return parent(index) != QModelIndex();
 }
 
@@ -124,42 +144,37 @@ Buffer *BufferTreeModel::getBufferByIndex(const QModelIndex &index) const {
 
 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);
+  NetworkTreeItem *networkItem = static_cast<NetworkTreeItem*>(networkItemIndex.internalPointer());
+  TreeItem *bufferItem;
   
-  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());
-
+  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 {
@@ -181,7 +196,7 @@ QMimeData *BufferTreeModel::mimeData(const QModelIndexList &indexes) const {
   return mimeData;
 }
 
-bool BufferTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) {
+bool BufferTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction /*action*/, int /*row*/, int /*column*/, const QModelIndex &parent) {
   if(!(data->hasFormat("application/Quassel/BufferItem/row")
        && data->hasFormat("application/Quassel/BufferItem/network")
        && data->hasFormat("application/Quassel/BufferItem/bufferId")))
@@ -190,24 +205,16 @@ bool BufferTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
   int sourcerow = data->data("application/Quassel/BufferItem/row").toInt();
   QString network = QString::fromUtf8(data->data("application/Quassel/BufferItem/network"));
   
-  if(!networkItem.contains(network))
-    return false;
+  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();
-
-  if(parent == QModelIndex()) { // droping into empty space
-    emit addBuffer(sourceBuffer->bufferId().uid(), network);
-    return true;
-  }
-    
-  if(!isBufferIndex(parent)) { // dropping at a network
-    emit addBuffer(sourceBuffer->bufferId().uid(), network);
-    return true;
-  }
-
-
+  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
+    return false;
   
   if(sourceBuffer == targetBuffer) // we won't merge with ourself :)
     return false;
@@ -221,7 +228,6 @@ bool BufferTreeModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
 
   */
   qDebug() << "merging" << sourceBuffer->bufferName() << "with" << targetBuffer->bufferName();
-  bufferItem.remove(getBufferByIndex(parent));
   removeRow(parent.row(), BufferTreeModel::parent(parent));
   
   return true;
@@ -234,12 +240,12 @@ void BufferTreeModel::bufferUpdated(Buffer *buffer) {
 }
 
 // This Slot indicates that the user has selected a different buffer in the gui
-void BufferTreeModel::changeCurrent(const QModelIndex &current, const QModelIndex &previous) {
+void BufferTreeModel::changeCurrent(const QModelIndex &current, const QModelIndex &/*previous*/) {
   if(isBufferIndex(current)) {
     currentBuffer = getBufferByIndex(current);
     bufferActivity(Buffer::NoActivity, currentBuffer);
     emit bufferSelected(currentBuffer);
-    emit updateSelection(current, QItemSelectionModel::ClearAndSelect);
+    emit selectionChanged(current);
   }
 }
 
@@ -250,18 +256,20 @@ void BufferTreeModel::doubleClickReceived(const QModelIndex &clicked) {
     if(!buffer->isStatusBuffer()) 
       emit fakeUserInput(buffer->bufferId(), QString("/join " + buffer->bufferName()));
   }
-    
 }
 
 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);
 }
 
 void BufferTreeModel::selectBuffer(Buffer *buffer) {
   QModelIndex index = getOrCreateBufferItemIndex(buffer);
-  emit updateSelection(index, QItemSelectionModel::ClearAndSelect);
+  emit selectionChanged(index);
 }
+
+