blob: 1040081515bebb5c9a5fe0f8f90b5e6b8cd9fc2e [file] [edit]
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt Quick Controls module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <math.h>
#include "qquicktreemodeladaptor_p.h"
#include <QtCore/qstack.h>
#include <QtCore/qdebug.h>
QT_BEGIN_NAMESPACE
//#define QQUICKTREEMODELADAPTOR_DEBUG
#if defined(QQUICKTREEMODELADAPTOR_DEBUG) && !defined(QT_TESTLIB_LIB)
# define ASSERT_CONSISTENCY() Q_ASSERT_X(testConsistency(true /* dumpOnFail */), Q_FUNC_INFO, "Consistency test failed")
#else
# define ASSERT_CONSISTENCY qt_noop
#endif
QQuickTreeModelAdaptor1::QQuickTreeModelAdaptor1(QObject *parent) :
QAbstractListModel(parent), m_model(0), m_lastItemIndex(0),
m_visibleRowsMoved(false), m_signalAggregatorStack(0)
{
}
QAbstractItemModel *QQuickTreeModelAdaptor1::model() const
{
return m_model;
}
void QQuickTreeModelAdaptor1::setModel(QAbstractItemModel *arg)
{
struct Cx {
const char *signal;
const char *slot;
};
static const Cx connections[] = {
{ SIGNAL(destroyed(QObject*)),
SLOT(modelHasBeenDestroyed()) },
{ SIGNAL(modelReset()),
SLOT(modelHasBeenReset()) },
{ SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&, const QVector<int>&)),
SLOT(modelDataChanged(const QModelIndex&, const QModelIndex&, const QVector<int>&)) },
{ SIGNAL(layoutAboutToBeChanged(const QList<QPersistentModelIndex>&, QAbstractItemModel::LayoutChangeHint)),
SLOT(modelLayoutAboutToBeChanged(const QList<QPersistentModelIndex>&, QAbstractItemModel::LayoutChangeHint)) },
{ SIGNAL(layoutChanged(const QList<QPersistentModelIndex>&, QAbstractItemModel::LayoutChangeHint)),
SLOT(modelLayoutChanged(const QList<QPersistentModelIndex>&, QAbstractItemModel::LayoutChangeHint)) },
{ SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)),
SLOT(modelRowsAboutToBeInserted(const QModelIndex &, int, int)) },
{ SIGNAL(rowsInserted(const QModelIndex&, int, int)),
SLOT(modelRowsInserted(const QModelIndex&, int, int)) },
{ SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)),
SLOT(modelRowsAboutToBeRemoved(const QModelIndex&, int, int)) },
{ SIGNAL(rowsRemoved(const QModelIndex&, int, int)),
SLOT(modelRowsRemoved(const QModelIndex&, int, int)) },
{ SIGNAL(rowsAboutToBeMoved(const QModelIndex&, int, int, const QModelIndex&, int)),
SLOT(modelRowsAboutToBeMoved(const QModelIndex&, int, int, const QModelIndex&, int)) },
{ SIGNAL(rowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)),
SLOT(modelRowsMoved(const QModelIndex&, int, int, const QModelIndex&, int)) },
{ 0, 0 }
};
if (m_model != arg) {
if (m_model) {
for (const Cx *c = &connections[0]; c->signal; c++)
disconnect(m_model, c->signal, this, c->slot);
}
clearModelData();
m_model = arg;
if (m_model) {
for (const Cx *c = &connections[0]; c->signal; c++)
connect(m_model, c->signal, this, c->slot);
showModelTopLevelItems();
}
emit modelChanged(arg);
}
}
void QQuickTreeModelAdaptor1::clearModelData()
{
beginResetModel();
m_items.clear();
m_expandedItems.clear();
endResetModel();
}
const QModelIndex &QQuickTreeModelAdaptor1::rootIndex() const
{
return m_rootIndex;
}
void QQuickTreeModelAdaptor1::setRootIndex(const QModelIndex &idx)
{
if (m_rootIndex == idx)
return;
if (m_model)
clearModelData();
m_rootIndex = idx;
if (m_model)
showModelTopLevelItems();
emit rootIndexChanged();
}
void QQuickTreeModelAdaptor1::resetRootIndex()
{
setRootIndex(QModelIndex());
}
QHash<int, QByteArray> QQuickTreeModelAdaptor1::roleNames() const
{
if (!m_model)
return QHash<int, QByteArray>();
QHash<int, QByteArray> modelRoleNames = m_model->roleNames();
modelRoleNames.insert(DepthRole, "_q_TreeView_ItemDepth");
modelRoleNames.insert(ExpandedRole, "_q_TreeView_ItemExpanded");
modelRoleNames.insert(HasChildrenRole, "_q_TreeView_HasChildren");
modelRoleNames.insert(HasSiblingRole, "_q_TreeView_HasSibling");
modelRoleNames.insert(ModelIndexRole, "_q_TreeView_ModelIndex");
return modelRoleNames;
}
int QQuickTreeModelAdaptor1::rowCount(const QModelIndex &) const
{
return m_items.count();
}
QVariant QQuickTreeModelAdaptor1::data(const QModelIndex &index, int role) const
{
if (!m_model)
return QVariant();
const QModelIndex &modelIndex = mapToModel(index);
switch (role) {
case DepthRole:
return m_items.at(index.row()).depth;
case ExpandedRole:
return isExpanded(index.row());
case HasChildrenRole:
return !(modelIndex.flags() & Qt::ItemNeverHasChildren) && m_model->hasChildren(modelIndex);
case HasSiblingRole:
return modelIndex.row() != m_model->rowCount(modelIndex.parent()) - 1;
case ModelIndexRole:
return modelIndex;
default:
return m_model->data(modelIndex, role);
}
}
bool QQuickTreeModelAdaptor1::setData(const QModelIndex &index, const QVariant &value, int role)
{
if (!m_model)
return false;
switch (role) {
case DepthRole:
case ExpandedRole:
case HasChildrenRole:
case HasSiblingRole:
case ModelIndexRole:
return false;
default: {
const QModelIndex &pmi = mapToModel(index);
return m_model->setData(pmi, value, role);
}
}
}
int QQuickTreeModelAdaptor1::itemIndex(const QModelIndex &index) const
{
// This is basically a plagiarism of QTreeViewPrivate::viewIndex()
if (!index.isValid() || index == m_rootIndex || m_items.isEmpty())
return -1;
const int totalCount = m_items.count();
// We start nearest to the lastViewedItem
int localCount = qMin(m_lastItemIndex - 1, totalCount - m_lastItemIndex);
for (int i = 0; i < localCount; ++i) {
const TreeItem &item1 = m_items.at(m_lastItemIndex + i);
if (item1.index == index) {
m_lastItemIndex = m_lastItemIndex + i;
return m_lastItemIndex;
}
const TreeItem &item2 = m_items.at(m_lastItemIndex - i - 1);
if (item2.index == index) {
m_lastItemIndex = m_lastItemIndex - i - 1;
return m_lastItemIndex;
}
}
for (int j = qMax(0, m_lastItemIndex + localCount); j < totalCount; ++j) {
const TreeItem &item = m_items.at(j);
if (item.index == index) {
m_lastItemIndex = j;
return j;
}
}
for (int j = qMin(totalCount, m_lastItemIndex - localCount) - 1; j >= 0; --j) {
const TreeItem &item = m_items.at(j);
if (item.index == index) {
m_lastItemIndex = j;
return j;
}
}
// nothing found
return -1;
}
bool QQuickTreeModelAdaptor1::isVisible(const QModelIndex &index)
{
return itemIndex(index) != -1;
}
bool QQuickTreeModelAdaptor1::childrenVisible(const QModelIndex &index)
{
return (index == m_rootIndex && !m_items.isEmpty())
|| (m_expandedItems.contains(index) && isVisible(index));
}
const QModelIndex &QQuickTreeModelAdaptor1::mapToModel(const QModelIndex &index) const
{
return m_items.at(index.row()).index;
}
QPersistentModelIndex QQuickTreeModelAdaptor1::mapRowToModelIndex(int row) const
{
if (!m_model)
return QModelIndex();
if (row < 0 || row >= m_items.count())
return QModelIndex();
return m_items.at(row).index;
}
QItemSelection QQuickTreeModelAdaptor1::selectionForRowRange(const QModelIndex &fromIndex, const QModelIndex &toIndex) const
{
int from = itemIndex(fromIndex);
int to = itemIndex(toIndex);
if (from == -1) {
if (to == -1)
return QItemSelection();
return QItemSelection(toIndex, toIndex);
}
to = qMax(to, 0);
if (from > to)
qSwap(from, to);
typedef QPair<QModelIndex, QModelIndex> MIPair;
typedef QHash<QModelIndex, MIPair> MI2MIPairHash;
MI2MIPairHash ranges;
QModelIndex firstIndex = m_items.at(from).index;
QModelIndex lastIndex = firstIndex;
QModelIndex previousParent = firstIndex.parent();
bool selectLastRow = false;
for (int i = from + 1; i <= to || (selectLastRow = true); i++) {
// We run an extra iteration to make sure the last row is
// added to the selection. (And also to avoid duplicating
// the insertion code.)
QModelIndex index;
QModelIndex parent;
if (!selectLastRow) {
index = m_items.at(i).index;
parent = index.parent();
}
if (selectLastRow || previousParent != parent) {
const MI2MIPairHash::iterator &it = ranges.find(previousParent);
if (it == ranges.end())
ranges.insert(previousParent, MIPair(firstIndex, lastIndex));
else
it->second = lastIndex;
if (selectLastRow)
break;
firstIndex = index;
previousParent = parent;
}
lastIndex = index;
}
QItemSelection sel;
sel.reserve(ranges.count());
for (const MIPair &pair : qAsConst(ranges))
sel.append(QItemSelectionRange(pair.first, pair.second));
return sel;
}
void QQuickTreeModelAdaptor1::showModelTopLevelItems(bool doInsertRows)
{
if (!m_model)
return;
if (m_model->hasChildren(m_rootIndex) && m_model->canFetchMore(m_rootIndex))
m_model->fetchMore(m_rootIndex);
const long topLevelRowCount = m_model->rowCount(m_rootIndex);
if (topLevelRowCount == 0)
return;
showModelChildItems(TreeItem(m_rootIndex), 0, topLevelRowCount - 1, doInsertRows);
}
void QQuickTreeModelAdaptor1::showModelChildItems(const TreeItem &parentItem, int start, int end, bool doInsertRows, bool doExpandPendingRows)
{
const QModelIndex &parentIndex = parentItem.index;
int rowIdx = parentIndex.isValid() && parentIndex != m_rootIndex ? itemIndex(parentIndex) + 1 : 0;
Q_ASSERT(rowIdx == 0 || parentItem.expanded);
if (parentIndex.isValid() && parentIndex != m_rootIndex && (rowIdx == 0 || !parentItem.expanded))
return;
if (m_model->rowCount(parentIndex) == 0) {
if (m_model->hasChildren(parentIndex) && m_model->canFetchMore(parentIndex))
m_model->fetchMore(parentIndex);
return;
}
int insertCount = end - start + 1;
int startIdx;
if (start == 0) {
startIdx = rowIdx;
} else {
// Prefer to insert before next sibling instead of after last child of previous, as
// the latter is potentially buggy, see QTBUG-66062
const QModelIndex &nextSiblingIdx = m_model->index(end + 1, 0, parentIndex);
if (nextSiblingIdx.isValid()) {
startIdx = itemIndex(nextSiblingIdx);
} else {
const QModelIndex &prevSiblingIdx = m_model->index(start - 1, 0, parentIndex);
startIdx = lastChildIndex(prevSiblingIdx) + 1;
}
}
int rowDepth = rowIdx == 0 ? 0 : parentItem.depth + 1;
if (doInsertRows)
beginInsertRows(QModelIndex(), startIdx, startIdx + insertCount - 1);
m_items.reserve(m_items.count() + insertCount);
for (int i = 0; i < insertCount; i++) {
const QModelIndex &cmi = m_model->index(start + i, 0, parentIndex);
bool expanded = m_expandedItems.contains(cmi);
m_items.insert(startIdx + i, TreeItem(cmi, rowDepth, expanded));
if (expanded)
m_itemsToExpand.append(&m_items[startIdx + i]);
}
if (doInsertRows)
endInsertRows();
if (doExpandPendingRows)
expandPendingRows(doInsertRows);
}
void QQuickTreeModelAdaptor1::expand(const QModelIndex &idx)
{
ASSERT_CONSISTENCY();
if (!m_model)
return;
Q_ASSERT(!idx.isValid() || idx.model() == m_model);
if (!idx.isValid() || !m_model->hasChildren(idx))
return;
if (m_expandedItems.contains(idx))
return;
int row = itemIndex(idx);
if (row != -1)
expandRow(row);
else
m_expandedItems.insert(idx);
ASSERT_CONSISTENCY();
emit expanded(idx);
}
void QQuickTreeModelAdaptor1::collapse(const QModelIndex &idx)
{
ASSERT_CONSISTENCY();
if (!m_model)
return;
Q_ASSERT(!idx.isValid() || idx.model() == m_model);
if (!idx.isValid() || !m_model->hasChildren(idx))
return;
if (!m_expandedItems.contains(idx))
return;
int row = itemIndex(idx);
if (row != -1)
collapseRow(row);
else
m_expandedItems.remove(idx);
ASSERT_CONSISTENCY();
emit collapsed(idx);
}
bool QQuickTreeModelAdaptor1::isExpanded(const QModelIndex &index) const
{
ASSERT_CONSISTENCY();
if (!m_model)
return false;
Q_ASSERT(!index.isValid() || index.model() == m_model);
return !index.isValid() || m_expandedItems.contains(index);
}
bool QQuickTreeModelAdaptor1::isExpanded(int row) const
{
return m_items.at(row).expanded;
}
void QQuickTreeModelAdaptor1::expandRow(int n)
{
if (!m_model || isExpanded(n))
return;
TreeItem &item = m_items[n];
if ((item.index.flags() & Qt::ItemNeverHasChildren) || !m_model->hasChildren(item.index))
return;
item.expanded = true;
m_expandedItems.insert(item.index);
QVector<int> changedRole(1, ExpandedRole);
emit dataChanged(index(n), index(n), changedRole);
m_itemsToExpand.append(&item);
expandPendingRows();
}
void QQuickTreeModelAdaptor1::expandPendingRows(bool doInsertRows)
{
while (!m_itemsToExpand.isEmpty()) {
TreeItem *item = m_itemsToExpand.takeFirst();
Q_ASSERT(item->expanded);
const QModelIndex &index = item->index;
int childrenCount = m_model->rowCount(index);
if (childrenCount == 0) {
if (m_model->hasChildren(index) && m_model->canFetchMore(index))
m_model->fetchMore(index);
continue;
}
// TODO Pre-compute the total number of items made visible
// so that we only call a single beginInsertRows()/endInsertRows()
// pair per expansion (same as we do for collapsing).
showModelChildItems(*item, 0, childrenCount - 1, doInsertRows, false);
}
}
void QQuickTreeModelAdaptor1::collapseRow(int n)
{
if (!m_model || !isExpanded(n))
return;
SignalFreezer aggregator(this);
TreeItem &item = m_items[n];
item.expanded = false;
m_expandedItems.remove(item.index);
QVector<int> changedRole(1, ExpandedRole);
queueDataChanged(index(n), index(n), changedRole);
int childrenCount = m_model->rowCount(item.index);
if ((item.index.flags() & Qt::ItemNeverHasChildren) || !m_model->hasChildren(item.index) || childrenCount == 0)
return;
const QModelIndex &emi = m_model->index(childrenCount - 1, 0, item.index);
int lastIndex = lastChildIndex(emi);
removeVisibleRows(n + 1, lastIndex);
}
int QQuickTreeModelAdaptor1::lastChildIndex(const QModelIndex &index)
{
if (!m_expandedItems.contains(index))
return itemIndex(index);
QModelIndex parent = index.parent();
QModelIndex nextSiblingIndex;
while (parent.isValid()) {
nextSiblingIndex = parent.sibling(parent.row() + 1, 0);
if (nextSiblingIndex.isValid())
break;
parent = parent.parent();
}
int firstIndex = nextSiblingIndex.isValid() ? itemIndex(nextSiblingIndex) : m_items.count();
return firstIndex - 1;
}
void QQuickTreeModelAdaptor1::removeVisibleRows(int startIndex, int endIndex, bool doRemoveRows)
{
if (startIndex < 0 || endIndex < 0 || startIndex > endIndex)
return;
if (doRemoveRows)
beginRemoveRows(QModelIndex(), startIndex, endIndex);
m_items.erase(m_items.begin() + startIndex, m_items.begin() + endIndex + 1);
if (doRemoveRows) {
endRemoveRows();
/* We need to update the model index for all the items below the removed ones */
int lastIndex = m_items.count() - 1;
if (startIndex <= lastIndex) {
const QModelIndex &topLeft = index(startIndex, 0, QModelIndex());
const QModelIndex &bottomRight = index(lastIndex, 0, QModelIndex());
const QVector<int> changedRole(1, ModelIndexRole);
queueDataChanged(topLeft, bottomRight, changedRole);
}
}
}
void QQuickTreeModelAdaptor1::modelHasBeenDestroyed()
{
// The model has been deleted. This should behave as if no model was set
clearModelData();
emit modelChanged(nullptr);
}
void QQuickTreeModelAdaptor1::modelHasBeenReset()
{
clearModelData();
showModelTopLevelItems();
ASSERT_CONSISTENCY();
}
void QQuickTreeModelAdaptor1::modelDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRigth, const QVector<int> &roles)
{
Q_ASSERT(topLeft.parent() == bottomRigth.parent());
const QModelIndex &parent = topLeft.parent();
if (parent.isValid() && !childrenVisible(parent)) {
ASSERT_CONSISTENCY();
return;
}
int topIndex = itemIndex(topLeft);
if (topIndex == -1) // 'parent' is not visible anymore, though it's been expanded previously
return;
for (int i = topLeft.row(); i <= bottomRigth.row(); i++) {
// Group items with same parent to minize the number of 'dataChanged()' emits
int bottomIndex = topIndex;
while (bottomIndex < m_items.count()) {
const QModelIndex &idx = m_items.at(bottomIndex).index;
if (idx.parent() != parent) {
--bottomIndex;
break;
}
if (idx.row() == bottomRigth.row())
break;
++bottomIndex;
}
emit dataChanged(index(topIndex), index(bottomIndex), roles);
i += bottomIndex - topIndex;
if (i == bottomRigth.row())
break;
topIndex = bottomIndex + 1;
while (topIndex < m_items.count()
&& m_items.at(topIndex).index.parent() != parent)
topIndex++;
}
ASSERT_CONSISTENCY();
}
void QQuickTreeModelAdaptor1::modelLayoutAboutToBeChanged(const QList<QPersistentModelIndex> &parents, QAbstractItemModel::LayoutChangeHint hint)
{
ASSERT_CONSISTENCY();
Q_UNUSED(parents);
Q_UNUSED(hint);
}
void QQuickTreeModelAdaptor1::modelLayoutChanged(const QList<QPersistentModelIndex> &parents, QAbstractItemModel::LayoutChangeHint hint)
{
Q_UNUSED(hint);
if (parents.isEmpty()) {
m_items.clear();
showModelTopLevelItems(false /*doInsertRows*/);
emit dataChanged(index(0), index(m_items.count() - 1));
}
for (const QPersistentModelIndex &pmi : parents) {
if (m_expandedItems.contains(pmi)) {
int row = itemIndex(pmi);
if (row != -1) {
int rowCount = m_model->rowCount(pmi);
if (rowCount > 0) {
const QModelIndex &lmi = m_model->index(rowCount - 1, 0, pmi);
int lastRow = lastChildIndex(lmi);
removeVisibleRows(row + 1, lastRow, false /*doRemoveRows*/);
showModelChildItems(m_items.at(row), 0, rowCount - 1, false /*doInsertRows*/);
emit dataChanged(index(row + 1), index(lastRow));
}
}
}
}
ASSERT_CONSISTENCY();
}
void QQuickTreeModelAdaptor1::modelRowsAboutToBeInserted(const QModelIndex & parent, int start, int end)
{
Q_UNUSED(parent);
Q_UNUSED(start);
Q_UNUSED(end);
ASSERT_CONSISTENCY();
}
void QQuickTreeModelAdaptor1::modelRowsInserted(const QModelIndex & parent, int start, int end)
{
TreeItem item;
int parentRow = itemIndex(parent);
if (parentRow >= 0) {
const QModelIndex& parentIndex = index(parentRow);
QVector<int> changedRole(1, HasChildrenRole);
queueDataChanged(parentIndex, parentIndex, changedRole);
item = m_items.at(parentRow);
if (!item.expanded) {
ASSERT_CONSISTENCY();
return;
}
} else if (parent == m_rootIndex) {
item = TreeItem(parent);
} else {
ASSERT_CONSISTENCY();
return;
}
showModelChildItems(item, start, end);
ASSERT_CONSISTENCY();
}
void QQuickTreeModelAdaptor1::modelRowsAboutToBeRemoved(const QModelIndex & parent, int start, int end)
{
ASSERT_CONSISTENCY();
enableSignalAggregation();
if (parent == m_rootIndex || childrenVisible(parent)) {
const QModelIndex &smi = m_model->index(start, 0, parent);
int startIndex = itemIndex(smi);
const QModelIndex &emi = m_model->index(end, 0, parent);
int endIndex = -1;
if (isExpanded(emi)) {
int rowCount = m_model->rowCount(emi);
if (rowCount > 0) {
const QModelIndex &idx = m_model->index(rowCount - 1, 0, emi);
endIndex = lastChildIndex(idx);
}
}
if (endIndex == -1)
endIndex = itemIndex(emi);
removeVisibleRows(startIndex, endIndex);
}
for (int r = start; r <= end; r++) {
const QModelIndex &cmi = m_model->index(r, 0, parent);
m_expandedItems.remove(cmi);
}
}
void QQuickTreeModelAdaptor1::modelRowsRemoved(const QModelIndex & parent, int start, int end)
{
Q_UNUSED(start);
Q_UNUSED(end);
int parentRow = itemIndex(parent);
if (parentRow >= 0) {
const QModelIndex& parentIndex = index(parentRow);
QVector<int> changedRole(1, HasChildrenRole);
queueDataChanged(parentIndex, parentIndex, changedRole);
}
disableSignalAggregation();
ASSERT_CONSISTENCY();
}
void QQuickTreeModelAdaptor1::modelRowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow)
{
ASSERT_CONSISTENCY();
enableSignalAggregation();
m_visibleRowsMoved = false;
if (!childrenVisible(sourceParent))
return; // Do nothing now. See modelRowsMoved() below.
if (!childrenVisible(destinationParent)) {
modelRowsAboutToBeRemoved(sourceParent, sourceStart, sourceEnd);
/* If the destination parent has no children, we'll need to
* report a change on the HasChildrenRole */
if (isVisible(destinationParent) && m_model->rowCount(destinationParent) == 0) {
const QModelIndex &topLeft = index(itemIndex(destinationParent), 0, QModelIndex());
const QModelIndex &bottomRight = topLeft;
const QVector<int> changedRole(1, HasChildrenRole);
queueDataChanged(topLeft, bottomRight, changedRole);
}
} else {
int depthDifference = -1;
if (destinationParent.isValid()) {
int destParentIndex = itemIndex(destinationParent);
depthDifference = m_items.at(destParentIndex).depth;
}
if (sourceParent.isValid()) {
int sourceParentIndex = itemIndex(sourceParent);
depthDifference -= m_items.at(sourceParentIndex).depth;
} else {
depthDifference++;
}
int startIndex = itemIndex(m_model->index(sourceStart, 0, sourceParent));
const QModelIndex &emi = m_model->index(sourceEnd, 0, sourceParent);
int endIndex = -1;
if (isExpanded(emi)) {
int rowCount = m_model->rowCount(emi);
if (rowCount > 0)
endIndex = lastChildIndex(m_model->index(rowCount - 1, 0, emi));
}
if (endIndex == -1)
endIndex = itemIndex(emi);
int destIndex = -1;
if (destinationRow == m_model->rowCount(destinationParent)) {
const QModelIndex &emi = m_model->index(destinationRow - 1, 0, destinationParent);
destIndex = lastChildIndex(emi) + 1;
} else {
destIndex = itemIndex(m_model->index(destinationRow, 0, destinationParent));
}
int totalMovedCount = endIndex - startIndex + 1;
/* This beginMoveRows() is matched by a endMoveRows() in the
* modelRowsMoved() method below. */
m_visibleRowsMoved = startIndex != destIndex &&
beginMoveRows(QModelIndex(), startIndex, endIndex, QModelIndex(), destIndex);
const QList<TreeItem> &buffer = m_items.mid(startIndex, totalMovedCount);
int bufferCopyOffset;
if (destIndex > endIndex) {
for (int i = endIndex + 1; i < destIndex; i++) {
m_items.swapItemsAt(i, i - totalMovedCount); // Fast move from 1st to 2nd position
}
bufferCopyOffset = destIndex - totalMovedCount;
} else {
// NOTE: we will not enter this loop if startIndex == destIndex
for (int i = startIndex - 1; i >= destIndex; i--) {
m_items.swapItemsAt(i, i + totalMovedCount); // Fast move from 1st to 2nd position
}
bufferCopyOffset = destIndex;
}
for (int i = 0; i < buffer.length(); i++) {
TreeItem item = buffer.at(i);
item.depth += depthDifference;
m_items.replace(bufferCopyOffset + i, item);
}
/* If both source and destination items are visible, the indexes of
* all the items in between will change. If they share the same
* parent, then this is all; however, if they belong to different
* parents, their bottom siblings will also get displaced, so their
* index also needs to be updated.
* Given that the bottom siblings of the top moved elements are
* already included in the update (since they lie between the
* source and the dest elements), we only need to worry about the
* siblings of the bottom moved element.
*/
const int top = qMin(startIndex, bufferCopyOffset);
int bottom = qMax(endIndex, bufferCopyOffset + totalMovedCount - 1);
if (sourceParent != destinationParent) {
const QModelIndex &bottomParent =
bottom == endIndex ? sourceParent : destinationParent;
const int rowCount = m_model->rowCount(bottomParent);
if (rowCount > 0)
bottom = qMax(bottom, lastChildIndex(m_model->index(rowCount - 1, 0, bottomParent)));
}
const QModelIndex &topLeft = index(top, 0, QModelIndex());
const QModelIndex &bottomRight = index(bottom, 0, QModelIndex());
const QVector<int> changedRole(1, ModelIndexRole);
queueDataChanged(topLeft, bottomRight, changedRole);
if (depthDifference != 0) {
const QModelIndex &topLeft = index(bufferCopyOffset, 0, QModelIndex());
const QModelIndex &bottomRight = index(bufferCopyOffset + totalMovedCount - 1, 0, QModelIndex());
const QVector<int> changedRole(1, DepthRole);
queueDataChanged(topLeft, bottomRight, changedRole);
}
}
}
void QQuickTreeModelAdaptor1::modelRowsMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow)
{
if (!childrenVisible(sourceParent)) {
modelRowsInserted(destinationParent, destinationRow, destinationRow + sourceEnd - sourceStart);
} else if (!childrenVisible(destinationParent)) {
modelRowsRemoved(sourceParent, sourceStart, sourceEnd);
}
if (m_visibleRowsMoved)
endMoveRows();
if (isVisible(sourceParent) && m_model->rowCount(sourceParent) == 0) {
int parentRow = itemIndex(sourceParent);
collapseRow(parentRow);
const QModelIndex &topLeft = index(parentRow, 0, QModelIndex());
const QModelIndex &bottomRight = topLeft;
const QVector<int> changedRole { ExpandedRole, HasChildrenRole };
queueDataChanged(topLeft, bottomRight, changedRole);
}
disableSignalAggregation();
ASSERT_CONSISTENCY();
}
void QQuickTreeModelAdaptor1::dump() const
{
if (!m_model)
return;
int count = m_items.count();
if (count == 0)
return;
int countWidth = floor(log10(double(count))) + 1;
qInfo() << "Dumping" << this;
for (int i = 0; i < count; i++) {
const TreeItem &item = m_items.at(i);
bool hasChildren = m_model->hasChildren(item.index);
int children = m_model->rowCount(item.index);
qInfo().noquote().nospace()
<< QString("%1 ").arg(i, countWidth) << QString(4 * item.depth, QChar::fromLatin1('.'))
<< QLatin1String(!hasChildren ? ".. " : item.expanded ? " v " : " > ")
<< item.index << children;
}
}
bool QQuickTreeModelAdaptor1::testConsistency(bool dumpOnFail) const
{
if (!m_model) {
if (!m_items.isEmpty()) {
qWarning() << "Model inconsistency: No model but stored visible items";
return false;
}
if (!m_expandedItems.isEmpty()) {
qWarning() << "Model inconsistency: No model but stored expanded items";
return false;
}
return true;
}
QModelIndex parent = m_rootIndex;
QStack<QModelIndex> ancestors;
QModelIndex idx = m_model->index(0, 0, parent);
for (int i = 0; i < m_items.count(); i++) {
bool isConsistent = true;
const TreeItem &item = m_items.at(i);
if (item.index != idx) {
qWarning() << "QModelIndex inconsistency" << i << item.index;
qWarning() << " expected" << idx;
isConsistent = false;
}
if (item.index.parent() != parent) {
qWarning() << "Parent inconsistency" << i << item.index;
qWarning() << " stored index parent" << item.index.parent() << "model parent" << parent;
isConsistent = false;
}
if (item.depth != ancestors.count()) {
qWarning() << "Depth inconsistency" << i << item.index;
qWarning() << " item depth" << item.depth << "ancestors stack" << ancestors.count();
isConsistent = false;
}
if (item.expanded && !m_expandedItems.contains(item.index)) {
qWarning() << "Expanded inconsistency" << i << item.index;
qWarning() << " set" << m_expandedItems.contains(item.index) << "item" << item.expanded;
isConsistent = false;
}
if (!isConsistent) {
if (dumpOnFail)
dump();
return false;
}
QModelIndex firstChildIndex;
if (item.expanded)
firstChildIndex = m_model->index(0, 0, idx);
if (firstChildIndex.isValid()) {
ancestors.push(parent);
parent = idx;
idx = m_model->index(0, 0, parent);
} else {
while (idx.row() == m_model->rowCount(parent) - 1) {
if (ancestors.isEmpty())
break;
idx = parent;
parent = ancestors.pop();
}
idx = m_model->index(idx.row() + 1, 0, parent);
}
}
return true;
}
void QQuickTreeModelAdaptor1::enableSignalAggregation() {
m_signalAggregatorStack++;
}
void QQuickTreeModelAdaptor1::disableSignalAggregation() {
m_signalAggregatorStack--;
Q_ASSERT(m_signalAggregatorStack >= 0);
if (m_signalAggregatorStack == 0) {
emitQueuedSignals();
}
}
void QQuickTreeModelAdaptor1::queueDataChanged(const QModelIndex &topLeft,
const QModelIndex &bottomRight,
const QVector<int> &roles)
{
if (isAggregatingSignals()) {
m_queuedDataChanged.append(DataChangedParams { topLeft, bottomRight, roles });
} else {
emit dataChanged(topLeft, bottomRight, roles);
}
}
void QQuickTreeModelAdaptor1::emitQueuedSignals()
{
QVector<DataChangedParams> combinedUpdates;
/* First, iterate through the queued updates and merge the overlapping ones
* to reduce the number of updates.
* We don't merge adjacent updates, because they are typically filed with a
* different role (a parent row is next to its children).
*/
for (const DataChangedParams &dataChange : m_queuedDataChanged) {
int startRow = dataChange.topLeft.row();
int endRow = dataChange.bottomRight.row();
bool merged = false;
for (DataChangedParams &combined : combinedUpdates) {
int combinedStartRow = combined.topLeft.row();
int combinedEndRow = combined.bottomRight.row();
if ((startRow <= combinedStartRow && endRow >= combinedStartRow) ||
(startRow <= combinedEndRow && endRow >= combinedEndRow)) {
if (startRow < combinedStartRow) {
combined.topLeft = dataChange.topLeft;
}
if (endRow > combinedEndRow) {
combined.bottomRight = dataChange.bottomRight;
}
for (int role : dataChange.roles) {
if (!combined.roles.contains(role))
combined.roles.append(role);
}
merged = true;
break;
}
}
if (!merged) {
combinedUpdates.append(dataChange);
}
}
/* Finally, emit the dataChanged signals */
for (const DataChangedParams &dataChange : combinedUpdates) {
emit dataChanged(dataChange.topLeft, dataChange.bottomRight, dataChange.roles);
}
m_queuedDataChanged.clear();
}
QT_END_NAMESPACE