/***************************************************************************
- * Copyright (C) 2005-2013 by the Quassel Project *
+ * Copyright (C) 2005-2018 by the Quassel Project *
* devel@quassel-irc.org *
* *
* This program is free software; you can redistribute it and/or modify *
#include <QCoreApplication>
#include <QDebug>
+#include <utility>
#include "quassel.h"
AbstractTreeItem::AbstractTreeItem(AbstractTreeItem *parent)
: QObject(parent),
_flags(Qt::ItemIsSelectable | Qt::ItemIsEnabled),
- _treeItemFlags(0)
+ _treeItemFlags(nullptr)
{
}
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++;
+ ++childIter;
}
emit beginRemoveChilds(0, numChilds - 1);
event->accept();
- RemoveChildLaterEvent *removeEvent = static_cast<RemoveChildLaterEvent *>(event);
+ auto *removeEvent = static_cast<RemoveChildLaterEvent *>(event);
int childRow = _childItems.indexOf(removeEvent->child());
if (childRow == -1)
return;
AbstractTreeItem *AbstractTreeItem::child(int row) const
{
if (childCount() <= row)
- return 0;
+ return nullptr;
else
return _childItems[row];
}
while (childIter != _childItems.constEnd()) {
child = *childIter;
qDebug() << "Row:" << child->row() << child << child->data(0, Qt::DisplayRole);
- childIter++;
+ ++childIter;
}
}
qDebug() << "==== End Of Childlist ====";
/*****************************************
* 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))
{
}
/*****************************************
* PropertyMapItem
*****************************************/
-PropertyMapItem::PropertyMapItem(const QStringList &propertyOrder, AbstractTreeItem *parent)
- : AbstractTreeItem(parent),
- _propertyOrder(propertyOrder)
-{
-}
-
-
PropertyMapItem::PropertyMapItem(AbstractTreeItem *parent)
- : AbstractTreeItem(parent),
- _propertyOrder(QStringList())
-{
-}
-
-
-PropertyMapItem::~PropertyMapItem()
+ : AbstractTreeItem(parent)
{
}
return toolTip(column);
case Qt::DisplayRole:
case TreeModel::SortRole: // fallthrough, since SortRole should default to DisplayRole
- return property(_propertyOrder[column].toAscii());
+ return property(propertyOrder()[column].toLatin1());
default:
return QVariant();
}
if (column >= columnCount() || role != Qt::DisplayRole)
return false;
+ setProperty(propertyOrder()[column].toLatin1(), value);
emit dataChanged(column);
- return setProperty(_propertyOrder[column].toAscii(), value);
+ return true;
}
int PropertyMapItem::columnCount() const
{
- return _propertyOrder.count();
-}
-
-
-void PropertyMapItem::appendProperty(const QString &property)
-{
- _propertyOrder << property;
+ return propertyOrder().count();
}
_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);
}
}
}
+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;
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);
}
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);
}
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);
}
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);
}
return rootItem->flags() & Qt::ItemIsDropEnabled;
}
else {
-
AbstractTreeItem *item = static_cast<AbstractTreeItem *>(index.internalPointer());
+
auto *item = static_cast<AbstractTreeItem *>(index.internalPointer());
return item->flags();
}
}
void TreeModel::itemDataChanged(int column)
{
-
AbstractTreeItem *item = qobject_cast<AbstractTreeItem *>(sender());
+
auto *item = qobject_cast<AbstractTreeItem *>(sender());
QModelIndex leftIndex, rightIndex;
if (item == rootItem)
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;
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;
}
Q_ASSERT(_aboutToRemoveOrInsert);
ChildStatus cs = _childStatus;
+#ifndef QT_NO_DEBUG
QModelIndex parent = indexByItem(parentItem);
Q_ASSERT(cs.parent == parent);
Q_ASSERT(rowCount(parent) == cs.childCount + cs.end - cs.start + 1);
-
+#endif
_aboutToRemoveOrInsert = false;
for (int i = cs.start; i <= cs.end; i++) {
connectItem(parentItem->child(i));
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
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;
// concistency checks
Q_ASSERT(_aboutToRemoveOrInsert);
+#ifndef QT_NO_DEBUG
ChildStatus cs = _childStatus;
QModelIndex parent = indexByItem(parentItem);
Q_ASSERT(cs.parent == parent);
Q_ASSERT(rowCount(parent) == cs.childCount - cs.end + cs.start - 1);
+#endif
_aboutToRemoveOrInsert = false;
endRemoveRows();
projects / quassel.git / blobdiff