clazy: Convert many old-style connects into function pointer based

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

diff --git a/src/client/treemodel.cpp b/src/client/treemodel.cpp
index f02f731..507a5da 100644 (file)
--- a/src/client/treemodel.cpp
+++ b/src/client/treemodel.cpp
@@ -22,6 +22,7 @@
 
 #include <QCoreApplication>
 #include <QDebug>
+#include <utility>
 
 #include "quassel.h"
 
@@ -41,7 +42,7 @@ private:
 AbstractTreeItem::AbstractTreeItem(AbstractTreeItem *parent)
     : QObject(parent),
     _flags(Qt::ItemIsSelectable | Qt::ItemIsEnabled),
-    _treeItemFlags(0)
+    _treeItemFlags(nullptr)
 {
 }
 
@@ -103,7 +104,7 @@ void AbstractTreeItem::removeAllChilds()
     childIter = _childItems.begin();
     while (childIter != _childItems.end()) {
         child = *childIter;
-        child->setTreeItemFlags(0); // disable self deletion, as this would only fuck up consitency and the child gets deleted anyways
+        child->setTreeItemFlags(nullptr); // disable self deletion, as this would only fuck up consitency and the child gets deleted anyways
         child->removeAllChilds();
         ++childIter;
     }
@@ -135,7 +136,7 @@ void AbstractTreeItem::customEvent(QEvent *event)
 
     event->accept();
 
-    RemoveChildLaterEvent *removeEvent = static_cast<RemoveChildLaterEvent *>(event);
+    auto *removeEvent = static_cast<RemoveChildLaterEvent *>(event);
     int childRow = _childItems.indexOf(removeEvent->child());
     if (childRow == -1)
         return;
@@ -182,7 +183,7 @@ bool AbstractTreeItem::reParent(AbstractTreeItem *newParent)
 AbstractTreeItem *AbstractTreeItem::child(int row) const
 {
     if (childCount() <= row)
-        return 0;
+        return nullptr;
     else
         return _childItems[row];
 }
@@ -230,14 +231,9 @@ void AbstractTreeItem::dumpChildList()
 /*****************************************
  * SimpleTreeItem
  *****************************************/
-SimpleTreeItem::SimpleTreeItem(const QList<QVariant> &data, AbstractTreeItem *parent)
+SimpleTreeItem::SimpleTreeItem(QList<QVariant> data, AbstractTreeItem *parent)
     : AbstractTreeItem(parent),
-    _itemData(data)
-{
-}
-
-
-SimpleTreeItem::~SimpleTreeItem()
+    _itemData(std::move(data))
 {
 }
 
@@ -275,21 +271,8 @@ int SimpleTreeItem::columnCount() const
 /*****************************************
  * PropertyMapItem
  *****************************************/
-PropertyMapItem::PropertyMapItem(const QStringList &propertyOrder, AbstractTreeItem *parent)
-    : AbstractTreeItem(parent),
-    _propertyOrder(propertyOrder)
-{
-}
-
-
 PropertyMapItem::PropertyMapItem(AbstractTreeItem *parent)
-    : AbstractTreeItem(parent),
-    _propertyOrder(QStringList())
-{
-}
-
-
-PropertyMapItem::~PropertyMapItem()
+    : AbstractTreeItem(parent)
 {
 }
 
@@ -304,7 +287,7 @@ QVariant PropertyMapItem::data(int column, int role) const
         return toolTip(column);
     case Qt::DisplayRole:
     case TreeModel::SortRole: // fallthrough, since SortRole should default to DisplayRole
-        return property(_propertyOrder[column].toLatin1());
+        return property(propertyOrder()[column].toLatin1());
     default:
         return QVariant();
     }
@@ -316,20 +299,15 @@ bool PropertyMapItem::setData(int column, const QVariant &value, int role)
     if (column >= columnCount() || role != Qt::DisplayRole)
         return false;
 
+    setProperty(propertyOrder()[column].toLatin1(), value);
     emit dataChanged(column);
-    return setProperty(_propertyOrder[column].toLatin1(), value);
+    return true;
 }
 
 
 int PropertyMapItem::columnCount() const
 {
-    return _propertyOrder.count();
-}
-
-
-void PropertyMapItem::appendProperty(const QString &property)
-{
-    _propertyOrder << property;
+    return propertyOrder().count();
 }
 
 
@@ -341,20 +319,20 @@ TreeModel::TreeModel(const QList<QVariant> &data, QObject *parent)
     _childStatus(QModelIndex(), 0, 0, 0),
     _aboutToRemoveOrInsert(false)
 {
-    rootItem = new SimpleTreeItem(data, 0);
+    rootItem = new SimpleTreeItem(data, nullptr);
     connectItem(rootItem);
 
     if (Quassel::isOptionSet("debugmodel")) {
-        connect(this, SIGNAL(rowsAboutToBeInserted(const QModelIndex &, int, int)),
-            this, SLOT(debug_rowsAboutToBeInserted(const QModelIndex &, int, int)));
-        connect(this, SIGNAL(rowsAboutToBeRemoved(const QModelIndex &, int, int)),
-            this, SLOT(debug_rowsAboutToBeRemoved(const QModelIndex &, int, int)));
-        connect(this, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
-            this, SLOT(debug_rowsInserted(const QModelIndex &, int, int)));
-        connect(this, SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
-            this, SLOT(debug_rowsRemoved(const QModelIndex &, int, int)));
-        connect(this, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)),
-            this, SLOT(debug_dataChanged(const QModelIndex &, const QModelIndex &)));
+        connect(this, &QAbstractItemModel::rowsAboutToBeInserted,
+            this, &TreeModel::debug_rowsAboutToBeInserted);
+        connect(this, &QAbstractItemModel::rowsAboutToBeRemoved,
+            this, &TreeModel::debug_rowsAboutToBeRemoved);
+        connect(this, &QAbstractItemModel::rowsInserted,
+            this, &TreeModel::debug_rowsInserted);
+        connect(this, &QAbstractItemModel::rowsRemoved,
+            this, &TreeModel::debug_rowsRemoved);
+        connect(this, &QAbstractItemModel::dataChanged,
+            this, &TreeModel::debug_dataChanged);
     }
 }
 
@@ -365,10 +343,16 @@ TreeModel::~TreeModel()
 }
 
 
+AbstractTreeItem *TreeModel::root() const
+{
+    return rootItem;
+}
+
+
 QModelIndex TreeModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (row < 0 || row >= rowCount(parent) || column < 0 || column >= columnCount(parent))
-        return QModelIndex();
+        return {};
 
     AbstractTreeItem *parentItem;
 
@@ -382,19 +366,19 @@ QModelIndex TreeModel::index(int row, int column, const QModelIndex &parent) con
     if (childItem)
         return createIndex(row, column, childItem);
     else
-        return QModelIndex();
+        return {};
 }
 
 
 QModelIndex TreeModel::indexByItem(AbstractTreeItem *item) const
 {
-    if (item == 0) {
+    if (item == nullptr) {
         qWarning() << "TreeModel::indexByItem(AbstractTreeItem *item) received NULL-Pointer";
-        return QModelIndex();
+        return {};
     }
 
     if (item == rootItem)
-        return QModelIndex();
+        return {};
     else
         return createIndex(item->row(), 0, item);
 }
@@ -405,15 +389,15 @@ QModelIndex TreeModel::parent(const QModelIndex &index) const
     if (!index.isValid()) {
         // ModelTest does this
         // qWarning() << "TreeModel::parent(): has been asked for the rootItems Parent!";
-        return QModelIndex();
+        return {};
     }
 
-    AbstractTreeItem *childItem = static_cast<AbstractTreeItem *>(index.internalPointer());
+    auto *childItem = static_cast<AbstractTreeItem *>(index.internalPointer());
     AbstractTreeItem *parentItem = childItem->parent();
 
     Q_ASSERT(parentItem);
     if (parentItem == rootItem)
-        return QModelIndex();
+        return {};
 
     return createIndex(parentItem->row(), 0, parentItem);
 }
@@ -454,7 +438,7 @@ QVariant TreeModel::data(const QModelIndex &index, int role) const
     if (!index.isValid())
         return QVariant();
 
-    AbstractTreeItem *item = static_cast<AbstractTreeItem *>(index.internalPointer());
+    auto *item = static_cast<AbstractTreeItem *>(index.internalPointer());
     return item->data(index.column(), role);
 }
 
@@ -464,7 +448,7 @@ bool TreeModel::setData(const QModelIndex &index, const QVariant &value, int rol
     if (!index.isValid())
         return false;
 
-    AbstractTreeItem *item = static_cast<AbstractTreeItem *>(index.internalPointer());
+    auto *item = static_cast<AbstractTreeItem *>(index.internalPointer());
     return item->setData(index.column(), value, role);
 }
 
@@ -475,7 +459,7 @@ Qt::ItemFlags TreeModel::flags(const QModelIndex &index) const
         return rootItem->flags() & Qt::ItemIsDropEnabled;
     }
     else {
-        AbstractTreeItem *item = static_cast<AbstractTreeItem *>(index.internalPointer());
+        auto *item = static_cast<AbstractTreeItem *>(index.internalPointer());
         return item->flags();
     }
 }
@@ -492,7 +476,7 @@ QVariant TreeModel::headerData(int section, Qt::Orientation orientation, int rol
 
 void TreeModel::itemDataChanged(int column)
 {
-    AbstractTreeItem *item = qobject_cast<AbstractTreeItem *>(sender());
+    auto *item = qobject_cast<AbstractTreeItem *>(sender());
     QModelIndex leftIndex, rightIndex;
 
     if (item == rootItem)
@@ -513,24 +497,24 @@ void TreeModel::itemDataChanged(int column)
 
 void TreeModel::connectItem(AbstractTreeItem *item)
 {
-    connect(item, SIGNAL(dataChanged(int)),
-        this, SLOT(itemDataChanged(int)));
+    connect(item, &AbstractTreeItem::dataChanged,
+        this, &TreeModel::itemDataChanged);
 
-    connect(item, SIGNAL(beginAppendChilds(int, int)),
-        this, SLOT(beginAppendChilds(int, int)));
-    connect(item, SIGNAL(endAppendChilds()),
-        this, SLOT(endAppendChilds()));
+    connect(item, &AbstractTreeItem::beginAppendChilds,
+        this, &TreeModel::beginAppendChilds);
+    connect(item, &AbstractTreeItem::endAppendChilds,
+        this, &TreeModel::endAppendChilds);
 
-    connect(item, SIGNAL(beginRemoveChilds(int, int)),
-        this, SLOT(beginRemoveChilds(int, int)));
-    connect(item, SIGNAL(endRemoveChilds()),
-        this, SLOT(endRemoveChilds()));
+    connect(item, &AbstractTreeItem::beginRemoveChilds,
+        this, &TreeModel::beginRemoveChilds);
+    connect(item, &AbstractTreeItem::endRemoveChilds,
+        this, &TreeModel::endRemoveChilds);
 }
 
 
 void TreeModel::beginAppendChilds(int firstRow, int lastRow)
 {
-    AbstractTreeItem *parentItem = qobject_cast<AbstractTreeItem *>(sender());
+    auto *parentItem = qobject_cast<AbstractTreeItem *>(sender());
     if (!parentItem) {
         qWarning() << "TreeModel::beginAppendChilds(): cannot append Children to unknown parent";
         return;
@@ -547,7 +531,7 @@ void TreeModel::beginAppendChilds(int firstRow, int lastRow)
 
 void TreeModel::endAppendChilds()
 {
-    AbstractTreeItem *parentItem = qobject_cast<AbstractTreeItem *>(sender());
+    auto *parentItem = qobject_cast<AbstractTreeItem *>(sender());
     if (!parentItem) {
         qWarning() << "TreeModel::endAppendChilds(): cannot append Children to unknown parent";
         return;
@@ -569,14 +553,14 @@ void TreeModel::endAppendChilds()
 
 void TreeModel::beginRemoveChilds(int firstRow, int lastRow)
 {
-    AbstractTreeItem *parentItem = qobject_cast<AbstractTreeItem *>(sender());
+    auto *parentItem = qobject_cast<AbstractTreeItem *>(sender());
     if (!parentItem) {
         qWarning() << "TreeModel::beginRemoveChilds(): cannot append Children to unknown parent";
         return;
     }
 
     for (int i = firstRow; i <= lastRow; i++) {
-        disconnect(parentItem->child(i), 0, this, 0);
+        disconnect(parentItem->child(i), nullptr, this, nullptr);
     }
 
     // consitency checks
@@ -593,7 +577,7 @@ void TreeModel::beginRemoveChilds(int firstRow, int lastRow)
 
 void TreeModel::endRemoveChilds()
 {
-    AbstractTreeItem *parentItem = qobject_cast<AbstractTreeItem *>(sender());
+    auto *parentItem = qobject_cast<AbstractTreeItem *>(sender());
     if (!parentItem) {
         qWarning() << "TreeModel::endRemoveChilds(): cannot remove Children from unknown parent";
         return;