qqmltreemodel.cpp

Go to the documentation of this file.

// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
#include "qqmltreemodel_p.h"
#include "qqmltreerow_p.h"
 
#include <QtCore/qloggingcategory.h>
 
#include <QtQml/qqmlinfo.h>
#include <QtQml/qqmlengine.h>
 
QT_BEGIN_NAMESPACE
 
Q_STATIC_LOGGING_CATEGORY(lcTreeModel, "qt.qml.treemodel")
 
/*!
    \qmltype TreeModel
//!    \nativetype QQmlTreeModel
    \inqmlmodule Qt.labs.qmlmodels
    \brief Encapsulates a simple tree model.
    \since 6.10
 
    The TreeModel type stores JavaScript/JSON objects as data for a tree
    model that can be used with \l TreeView. It is intended to support
    very simple models without requiring the creation of a custom
    \l QAbstractItemModel subclass in C++.
 
    \snippet qml/treemodel/treemodel-filesystem-basic.qml file
 
    The model's initial data is set with either the \l rows property or by
    calling \l appendRow(). Each column in the model is specified by declaring
    a \l TableModelColumn instance, where the order of each instance determines
    its column index. Once the model's \l Component::completed() signal has been
    emitted, the columns and roles will have been established and are then
    fixed for the lifetime of the model.
 
    \section1 Supported Row Data Structures
 
    Each row represents a node in the tree. Each node has the same type of
    columns. The TreeModel is designed to work with JavaScript/JSON data so
    each row is a list of simple key-value pairs:
 
    \snippet qml/treemodel/treemodel-filesystem-basic.qml rows
 
    A node can have child nodes and these will be stored in an array
    associated with the "rows" key. "rows" is reserved for this purpose: only
    the list of child nodes should be associated with this key.
 
    The model is manipulated via \l {QModelIndex} {QModelIndices}. To access
    a specific row/node, the \l getRow() function can be used. It's also
    possible to access the model's JavaScript data directly via the \l rows
    property, but it is not possible to modify the model data this way.
 
    To add new rows, use \l appendRow(). To modify existing rows, use
    \l setRow(), \l removeRow() and \l clear().
 
    \section1 Using the TreeModel with External JSON Sources
 
    While the intended use of the TreeModel is to define the JSON data in-place in
    the QML file, you can use any JSON object with the model as long as
    its structure matches the structure defined by the TreeModel. If all the rows
    of the JSON object conform to the columns defined by the model, you can
    assign it directly through the rows property.
 
    The source of the JSON object can be a file. For example, if the model is
    defined as
 
    \snippet setRowsViaJSON.qml model
 
    and the JSON object stored in the file and looks like
 
    \snippet TreeData.js file
 
    then this object can be provided by importing the JavaScript file as a
 
    module
 
    \snippet setRowsViaJSON.qml import
 
    and then it can be assigned directly
 
    \snippet setRowsViaJSON.qml assignment
 
    \warning Ensure that the JSON data comes from a trusted source. Since the
    model dynamically populates its rows based on the input, malformed or
    untrusted JSON can lead to unexpected behavior or performance issues.
 
    See \l TableModel for an another example where a JSON object is parsed
    into and assigned as a JavaScript array.
 
    \sa TableModelColumn, TreeView
*/
 
QQmlTreeModel::QQmlTreeModel(QObject *parent)
    : QQmlAbstractColumnModel(parent)
{
}
 
QQmlTreeModel::~QQmlTreeModel() = default;
 
/*!
    \qmlproperty var TreeModel::rows
 
    This property holds the model data in the form of an array of rows.
 
    \sa getRow(), setRow(), appendRow(), clear(), columnCount
*/
QVariant QQmlTreeModel::rows() const
{
    QVariantList rowsAsVariant;
    for (const auto &row : mRows)
        rowsAsVariant.append(row->toVariant());
 
    return rowsAsVariant;
}
 
void QQmlTreeModel::setRows(const QVariant &rows)
{
    const std::optional<QVariantList> validated = validateRowsArgument(rows);
    if (!validated || rowConversionFailed("TreeModel::setRows"_L1))
        return;
 
    const QVariantList rowsAsVariantList = *validated;
 
    if (!mComponentCompleted) {
        // Store the rows until we can call setRowsPrivate() after component completion.
        mInitialRows = rowsAsVariantList;
        return;
    }
 
    setRowsPrivate(rowsAsVariantList);
}
 
void QQmlTreeModel::setRowsPrivate(const QVariantList &rowsAsVariantList)
{
    Q_ASSERT(mComponentCompleted);
 
    // By now, all TableModelColumns should have been set.
    if (mColumns.isEmpty()) {
        qmlWarning(this) << "No TableModelColumns were set; model will be empty";
        return;
    }
 
    const bool firstTimeValidRowsHaveBeenSet = mColumnMetadata.isEmpty();
    if (!firstTimeValidRowsHaveBeenSet) {
        // This is not the first time rows have been set; validate each one.
        for (const auto &row : rowsAsVariantList) {
            // validateNewRow() expects a QVariant wrapping a QJSValue, so to
            // simplify the code, just create one here.
            const QVariant wrappedRow = QVariant::fromValue(row);
            if (!validateNewRow("TreeModel::setRows"_L1, wrappedRow, SetRowsOperation))
                return;
        }
    }
 
    beginResetModel();
 
    // In case the model is empty and we cannot insert any new rows in the loop below,
    // we don't want to emit rowsChanged
    const bool wasEmpty = mRows.empty();
 
    // We don't clear the column or role data, because a TreeModel should not be reused in that way.
    // Once it has valid data, its columns and roles are fixed.
    mRows.clear();
 
    for (const auto &rowAsVariant : rowsAsVariantList) {
        if (rowAsVariant.canConvert<QVariantMap>())
            mRows.push_back(std::make_unique<QQmlTreeRow>(rowAsVariant));
        else
            qmlWarning(this) << "Cannot create tree row as the row does not contain "
                             << "key-value pairs";
    }
 
    // Gather metadata the first time rows is set.
    // If we call setrows on an empty model, mInitialRows will be empty, but mRows is not
    if (firstTimeValidRowsHaveBeenSet && (!mRows.empty() || !mInitialRows.isEmpty()))
        fetchColumnMetadata();
 
    endResetModel();
 
    // was empty, still empty => no emit
    // was empty, now non-empty => emit
    // was not empty, now empty => emit
    // was not empty, now non-empty => emit (there was a clear in-between)
 
    if (!wasEmpty || !mRows.empty())
        emit rowsChanged();
}
 
QVariant QQmlTreeModel::dataPrivate(const QModelIndex &index, const QString &roleName) const
{
    const ColumnMetadata columnMetadata = mColumnMetadata.at(index.column());
    const QString propertyName = columnMetadata.roles.value(roleName).name;
    const auto *thisRow = static_cast<const QQmlTreeRow *>(index.internalPointer());
    return thisRow->data(propertyName);
}
 
void QQmlTreeModel::setDataPrivate(const QModelIndex &index, const QString &roleName, QVariant value)
{
    auto *row = static_cast<QQmlTreeRow *>(index.internalPointer());
    row->setField(roleName, value);
}
 
// TODO: Turn this into a snippet that compiles in CI
/*!
    \qmlmethod void TreeModel::appendRow(parent, var treeRow)
 
    Appends a new treeRow to \a parent, with the values (cells) in \a treeRow.
 
    \code
        treeModel.appendRow(index, {
            checked: false,
            size: "-",
            type: "folder",
            name: "Orders",
            lastModified: "2025-07-02",
            rows: [
                {
                    checked: true,
                    size: "38 KB",
                    type: "file",
                    name: "monitors.xlsx",
                    lastModified: "2025-07-02"
                },
                {
                    checked: true,
                    size: "54 KB",
                    type: "file",
                    name: "notebooks.xlsx",
                    lastModified: "2025-07-02"
                }
            ]
        });
    \endcode
 
    \a parent is an anonymous QML type backed by \l QModelIndex.
    If \a parent is invalid, \a treeRow gets appended to the root node.
 
    \sa setRow(), removeRow()
*/
void QQmlTreeModel::appendRow(QModelIndex parent, const QVariant &row)
{
    // Convert before validating: validation of incompletely converted rows would fail with a
    // misleading warning.
    const QVariant data =
            row.userType() == QMetaType::QVariantMap
               ? row
               : row.value<QJSValue>().toVariant();
 
    if (rowConversionFailed("TreeModel::appendRow"_L1))
        return;
 
    if (!validateNewRow("TreeModel::appendRow"_L1, row))
        return;
 
    if (parent.isValid()) {
        auto *parentRow = static_cast<QQmlTreeRow *>(parent.internalPointer());
        auto *newChild = new QQmlTreeRow(data);
 
        beginInsertRows(parent, static_cast<int>(parentRow->rowCount()), static_cast<int>(parentRow->rowCount()));
        parentRow->addChild(newChild);
 
               // Gather metadata the first time a row is added.
        if (mColumnMetadata.isEmpty())
            fetchColumnMetadata();
 
        endInsertRows();
    } else {
        qmlWarning(this) << "append: could not find any node at the specified index"
                         << " - the new row will be appended to root";
 
        if (data.canConvert<QVariantMap>()) {
            beginInsertRows(QModelIndex(),
                        static_cast<int>(mRows.size()),
                        static_cast<int>(mRows.size()));
 
            mRows.push_back(std::make_unique<QQmlTreeRow>(data));
 
            // Gather metadata the first time a row is added.
            if (mColumnMetadata.isEmpty())
                fetchColumnMetadata();
 
            endInsertRows();
        } else {
            qmlWarning(this) << "Cannot create tree row as the row does not contain "
                             << "key-value pairs";
            return;
        }
    }
 
    emit rowsChanged();
}
 
/*!
    \qmlmethod void TreeModel::appendRow(var treeRow)
 
    Appends \a treeRow to the root node.
 
    \sa setRow(), removeRow()
*/
void QQmlTreeModel::appendRow(const QVariant &row)
{
    appendRow({}, row);
}
 
/*!
    \qmlmethod void TreeModel::clear()
 
    Removes all rows from the model.
 
    \sa removeRow()
*/
void QQmlTreeModel::clear()
{
    if (mRows.empty())
        return;
 
    beginResetModel();
    mRows.clear();
    endResetModel();
    emit rowsChanged();
}
 
/*!
    \qmlmethod var TreeModel::getRow(rowIndex)
 
    Returns the treeRow at specified index in the model.
    \a rowIndex is an anonymous QML type backed by \l QModelIndex.
 
    \note the returned object cannot be used to modify the contents of the
    model; use setTreeRow() instead.
 
    \sa setRow(), appendRow(), removeRow()
*/
QVariant QQmlTreeModel::getRow(const QModelIndex &rowIndex) const
{
    if (rowIndex.isValid())
        return static_cast<QQmlTreeRow*>(rowIndex.internalPointer())->toVariant();
 
    qmlWarning(this) << "getRow: could not find any node at the specified index";
    return {};
}
 
/*!
    \qmlmethod void TreeModel::insertRow(int rowIndex, QModelIndex parent, object row)
    \since 6.12
 
    Inserts a new row to the \a parent at position \a rowIndex, with the
    values (cells) in \a row.
 
    \code
        model.insertRow(2, parentIndex, {
            checkable: true, checked: false,
            amount: 1,
            fruitType: "Pear",
            fruitName: "Williams",
            fruitPrice: 1.50,
        })
    \endcode
 
    \sa appendRow(), setRow(), removeRow()
*/
 
void QQmlTreeModel::insertRow(int rowIndex, QModelIndex parent, const QVariant &row)
{
    if (rowIndex < 0) {
        qmlWarning(this).noquote() << "insertRow(): rowIndex cannot be negative";
        return;
    }
    if (rowIndex > rowCount(parent)) {
        qmlWarning(this).noquote() << "insertRow(): rowIndex " << rowIndex
                                   << " is greater than rowCount() of "
                                   << rowCount(parent);
        return;
    }
 
    // Convert here rather than in doInsert(), which is too late to reject the
    // row, and before validating: validation of incompletely converted rows
    // would fail with a misleading warning.
    const QVariant data =
            row.userType() == QMetaType::QVariantMap
                ? row
                : row.value<QJSValue>().toVariant();
    if (rowConversionFailed("insertRow()"_L1))
        return;
 
    if (!validateNewRow("insertRow()"_L1, row))
        return;
 
    doInsert(parent, rowIndex, data);
}
 
/*!
    \qmlmethod void TreeModel::insertRow(int rowIndex, object row)
    \since 6.12
 
    Inserts a new row to the root item at position \a rowIndex, with the
    values (cells) in \a row.
 
    \sa appendRow(), setRow(), removeRow()
*/
void QQmlTreeModel::insertRow(int rowIndex, const QVariant &row)
{
    insertRow(rowIndex, {}, row);
}
 
void QQmlTreeModel::doInsert(const QModelIndex &parent, int rowIndex, const QVariant &row)
{
    beginInsertRows(parent, rowIndex, rowIndex);
 
    const QVariant data =
            row.userType() == QMetaType::QVariantMap
                ? row
                : row.value<QJSValue>().toVariant();
 
    auto newChild = std::make_unique<QQmlTreeRow>(data);
    if (parent.isValid())
        static_cast<QQmlTreeRow *>(parent.internalPointer())->insertChild(rowIndex, std::move(newChild));
    else
        mRows.insert(mRows.begin() + rowIndex, std::move(newChild));
 
    qCDebug(lcTreeModel).nospace() << "inserted the following row to the row "
        << parent << " at index "
        << rowIndex << " (child rows omitted):\n"
        << [&data] { QVariantMap map = data.toMap(); map.remove(ROWS_PROPERTY_NAME); return map; }();
 
    // Gather metadata the first time a row is added.
    if (mColumnMetadata.isEmpty())
        fetchColumnMetadata();
 
    endInsertRows();
    emit rowsChanged();
}
 
QVariant QQmlTreeModel::firstRow() const
{
    if (mRows.empty()) {
        qmlWarning(this) << "TreeModel::firstRow(): model is empty";
        return {};
    }
 
    return mRows.front().get()->data();
}
 
void QQmlTreeModel::setInitialRows()
{
    setRowsPrivate(mInitialRows);
}
 
/*!
    \qmlmethod void TreeModel::removeRow(rowIndex)
 
    Removes the TreeRow referenced by \a rowIndex from the model.
    \a rowIndex is an anonymous QML type backed by \l QModelIndex.
 
    \code
        treeModel.removeTreeRow(rowIndex)
    \endcode
 
\sa clear()
*/
void QQmlTreeModel::removeRow(QModelIndex rowIndex)
{
    if (rowIndex.isValid()) {
        QModelIndex mIndexParent = rowIndex.parent();
 
        beginRemoveRows(mIndexParent, rowIndex.row(), rowIndex.row());
 
        if (mIndexParent.isValid()) {
            auto *parent = static_cast<QQmlTreeRow *>(mIndexParent.internalPointer());
            parent->removeChildAt(rowIndex.row());
        } else {
            mRows.erase(std::next(mRows.begin(), rowIndex.row()));
        }
 
        endRemoveRows();
    } else {
        qmlWarning(this) << "TreeModel::removeRow could not find any node at the specified index";
        return;
    }
 
    emit rowsChanged();
}
 
// TODO: Turn this into a snippet that compiles in CI
 
/*!
    \qmlmethod void TreeModel::setRow(rowIndex, var treeRow)
 
    Replaces the TreeRow at \a rowIndex in the model with \a treeRow.
    \a rowIndex is an anonymous QML type back by \l QModelIndex.
 
    A row with child rows will be rejected.
 
    All columns/cells must be present in \c treeRow, and in the correct order.
    The child rows of the row remain unaffected.
 
    \code
        treeModel.setRow(rowIndex, {
            checked: true,
            size: "-",
            type: "folder",
            name: "Subtitles",
            lastModified: "2025-07-07",
            iconColor: "blue"
        });
    \endcode
 
    \sa appendRow()
*/
void QQmlTreeModel::setRow(QModelIndex rowIndex, const QVariant &rowData)
{
    if (!rowIndex.isValid()) {
        qmlWarning(this) << "TreeModel::setRow: invalid modelIndex";
        return;
    }
 
    const QVariantMap rowAsMap = rowData.toMap();
    if (rowAsMap.contains(ROWS_PROPERTY_NAME) && rowAsMap[ROWS_PROPERTY_NAME].userType() == QMetaType::Type::QVariantList) {
        qmlWarning(this) << "TreeModel::setRow: child rows are not allowed";
        return;
    }
 
    if (!validateNewRow("TreeModel::setRow"_L1, rowData))
        return;
 
    const QVariant rowAsVariant = rowData.userType() == QMetaType::QVariantMap ? rowData : rowData.value<QJSValue>().toVariant();
    if (rowConversionFailed("TreeModel::setRow"_L1))
        return;
 
    auto *row = static_cast<QQmlTreeRow *>(rowIndex.internalPointer());
    row->setData(rowAsVariant);
 
    const QModelIndex topLeftModelIndex(createIndex(rowIndex.row(), 0, rowIndex.internalPointer()));
    const QModelIndex bottomRightModelIndex(createIndex(rowIndex.row(), mColumnCount-1, rowIndex.internalPointer()));
 
    emit dataChanged(topLeftModelIndex, bottomRightModelIndex);
    emit rowsChanged();
}
 
/*!
    \qmlmethod QModelIndex TreeModel::index(int row, int column, var parent)
 
    Returns an object referencing the given \a row and \a column of
    a given \a parent which can be passed to the data() function to get the data
    from that cell, or to setData() to edit the contents of that cell.
 
    The returned object is of an anonymous QML type backed by \l QModelIndex.
 
    \sa {QModelIndex and related Classes in QML}, data()
*/
QModelIndex QQmlTreeModel::index(int row, int column, const QModelIndex &parent) const
{
    if (!parent.isValid()){
        if (static_cast<size_t>(row) >= mRows.size())
            return {};
 
        return createIndex(row, column, mRows.at(row).get());
    }
 
    const auto *treeRow = static_cast<const QQmlTreeRow *>(parent.internalPointer());
    if (treeRow->rowCount() <= static_cast<size_t>(row))
        return {};
 
    return createIndex(row, column, treeRow->getRow(row));
}
 
/*!
    \qmlmethod QModelIndex TreeModel::index(list<int> treeIndex, int column)
 
    Returns an object referencing the given \a treeIndex and \a column,
    which can be passed to the data() function to get the data from that cell,
    or to setData() to edit the contents of that cell.
 
    The returned object is of an anonymous QML type backed by \l QModelIndex.
 
    The first parameter \a treeIndex represents a path of row numbers tracing from
    the root to the desired row and is used for navigation inside the tree.
    This is best explained through an example.
 
    \table
 
    \row \li \inlineimage treemodel.svg
                          {Tree diagram showing nodes A through F with index paths}
    \li \list
 
    \li The root of the tree is special, as it can be referenced by an invalid
    \l QModelIndex.
 
    \li Node A is the first child of the root and the corresponding \a treeIndex is \c [0].
 
    \li Node B is the first child of node A. Since the \a treeIndex of A is \c [0]
    the \a treeIndex of B will be \c [0,0].
 
    \li Node C is the second child of A and its \a treeIndex is \c [0,1].
 
    \li Node D is the third child of A and its \a treeIndex is \c [0,2].
 
    \li Node E is the second child of the root and its \a treeIndex is \c [1].
 
    \li Node F is the third child of the root and its \a treeIndex is \c [2].
 
    \endlist
 
    \endtable
 
    With this overload it is possible to obtain a \l QModelIndex to a node without
    having a \l QModelIndex to its parent node.
 
    If no node is found by the list specified, an invalid model index is returned.
    Please note that an invalid model index is referencing the root of the node.
 
    \sa {QModelIndex and related Classes in QML}, data()
*/
QModelIndex QQmlTreeModel::index(const std::vector<int> &treeIndex, int column)
{
    QModelIndex mIndex;
    QQmlTreeRow *row = getPointerToTreeRow(mIndex, treeIndex);
 
    if (row)
        return createIndex(treeIndex.back(), column, row);
 
    qmlWarning(this) << "TreeModel::index: could not find any node at the specified index: "
                     << treeIndex;
    return {};
}
 
QModelIndex QQmlTreeModel::parent(const QModelIndex &index) const
{
    if (!index.isValid())
        return {};
 
    const auto *thisRow = static_cast<const QQmlTreeRow *>(index.internalPointer());
    const QQmlTreeRow *parentRow = thisRow->parent();
 
    if (!parentRow) // parent is root
        return {};
 
    const QQmlTreeRow *grandparentRow = parentRow->parent();
 
    if (!grandparentRow) {// grandparent is root, parent is in mRows
        for (size_t i = 0; i < mRows.size(); i++) {
            if (mRows[i].get() == parentRow)
                return createIndex(static_cast<int>(i), 0, parentRow);
        }
        Q_UNREACHABLE_RETURN(QModelIndex());
    }
 
    for (size_t i = 0; i < grandparentRow->rowCount(); i++) {
        if (grandparentRow->getRow(static_cast<int>(i)) == parentRow)
            return createIndex(static_cast<int>(i), 0, parentRow);
    }
    Q_UNREACHABLE_RETURN(QModelIndex());
}
 
 
int QQmlTreeModel::rowCount(const QModelIndex &parent) const
{
    if (!parent.isValid())
        return static_cast<int>(mRows.size());
 
    const auto *row = static_cast<const QQmlTreeRow *>(parent.internalPointer());
    return static_cast<int>(row->rowCount());
}
 
/*!
    \qmlproperty int TreeModel::columnCount
    \readonly
 
    This read-only property holds the number of columns in the model.
 
    The number of columns is fixed for the lifetime of the model
    after the \l rows property is set or \l appendRow() is called for the first
    time.
*/
int QQmlTreeModel::columnCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
 
    return mColumnCount;
}
 
/*!
    \qmlmethod variant TreeModel::data(index, string role)
 
    Returns the data from the TreeModel at the given \a index belonging to the
    given \a role.
 
    \a index is an anonymous QML type backed by \l QModelIndex.
 
    \sa index(), setData()
*/
 
/*!
    \qmlmethod bool TreeModel::setData(index, variant value, string role)
 
    Inserts or updates the data field named by \a role in the TreeRow at the
    given \a index with \a value. Returns true if successful, false if not.
 
    \a index is an anonymous QML type backed by \l QModelIndex.
 
    \sa data(), index()
*/
 
bool QQmlTreeModel::validateNewRow(QLatin1StringView functionName, const QVariant &row,
                                   NewRowOperationFlag operation) const
{
    // Validates the row and all its descendants, children before their parent,
    // in the same order as a recursive traversal would, but without recursing
    // once per level of the nested rows, which can be arbitrarily deep.
    struct Frame
     {
        QVariant row;
        NewRowOperationFlag operation;
        QVariantList children;
        qsizetype nextChild = 0;
    };
 
    std::vector<Frame> pending;
    const auto push = [&pending](const QVariant &newRow, NewRowOperationFlag newRowOperation) {
        const bool isVariantMap = (newRow.userType() == QMetaType::QVariantMap);
        const QVariant rowAsVariant = newRowOperation == SetRowsOperation || isVariantMap
            ? newRow : newRow.value<QJSValue>().toVariant();
        const QVariantMap rowAsMap = rowAsVariant.toMap();
 
        QVariantList children;
        const auto it = rowAsMap.constFind(ROWS_PROPERTY_NAME);
        if (it != rowAsMap.cend() && it->userType() == QMetaType::Type::QVariantList)
            children = it->toList();
 
        pending.push_back({ newRow, newRowOperation, std::move(children) });
    };
 
    push(row, operation);
    while (!pending.empty()) {
        Frame &top = pending.back();
        if (top.nextChild < top.children.size()) {
            const QVariant child = top.children.at(top.nextChild++);
            push(child, OtherOperation); // invalidates top
            continue;
        }
 
        if (!QQmlAbstractColumnModel::validateNewRow(functionName, top.row, top.operation))
            return false;
        pending.pop_back();
     }
 
    return true;
}
 
/*
    QJSValue::toVariant() stops converting when it runs out of stack space: it
    returns an incomplete result and raises a RangeError on the engine. Rows
    converted that way must not end up in the model.
*/
bool QQmlTreeModel::rowConversionFailed(QLatin1StringView functionName) const
{
    const QJSEngine *engine = qjsEngine(this);
    if (!engine || !engine->hasError())
        return false;
 
    qmlWarning(this).nospace() << functionName
                               << ": rows are nested too deeply to be converted";
    return true;
}
 
int QQmlTreeModel::treeSize() const
{
    int treeSize = 0;
 
    for (const auto &treeRow : mRows)
        treeSize += treeRow->subTreeSize();
 
    return treeSize;
}
 
QQmlTreeRow *QQmlTreeModel::getPointerToTreeRow(QModelIndex &modIndex,
                                                const std::vector<int> &rowIndex) const
{
    for (int r : rowIndex) {
        modIndex = index(r, 0, modIndex);
        if (!modIndex.isValid())
            return nullptr;
    }
 
    return static_cast<QQmlTreeRow*>(modIndex.internalPointer());
}
 
/*!
    \qmlmethod bool TreeModel::moveRows(QModelIndex sourceParent, int sourceRow, int count,
                        QModelIndex destinationParent, int destinationChild)
    \since 6.12
    Moves \a count rows starting at \a sourceRow from \a sourceParent to
    \a destinationParent, inserting before \a destinationChild.
 
    The \a destinationChild refers to the position in the \a destinationParent
    \e before the move (pre-removal index), consistent with
    QAbstractItemModel::beginMoveRows().
 
    The source and destination ranges must exist, and \a sourceParent and
    \a destinationParent must not overlap such that a parent would be moved
    under its own child.
 
    Returns \c true if the rows were successfully moved; otherwise returns
    \c false.
 
    \sa appendRow(), insertRow(), removeRow()
*/
bool QQmlTreeModel::moveRows(const QModelIndex &sourceParent, int sourceRow, int count,
                             const QModelIndex &destinationParent, int destinationChild)
{
    if (count <= 0)
        return false;
 
    // beginMoveRows does not validate bounds against rowCount,
    // so we must check before calling it.
    if (sourceRow < 0 || sourceRow + count > rowCount(sourceParent))
        return false;
    if (destinationChild < 0 || destinationChild > rowCount(destinationParent))
        return false;
 
    if (!beginMoveRows(sourceParent, sourceRow, sourceRow + count - 1,
                       destinationParent, destinationChild))
        return false;
 
   // Root-level children live in mRows on the model, not in a QQmlTreeRow,
    // so internalPointer() is nullptr for the root QModelIndex.
    auto takeChild = [this](const QModelIndex &parent, int row) -> std::unique_ptr<QQmlTreeRow> {
        if (parent.isValid())
            return static_cast<QQmlTreeRow *>(parent.internalPointer())->takeChild(row);
        auto it = std::next(mRows.begin(), row);
        std::unique_ptr<QQmlTreeRow> child = std::move(*it);
        mRows.erase(it);
        return child;
    };
 
    auto insertChild = [this](const QModelIndex &parent, int row, std::unique_ptr<QQmlTreeRow> child) {
        if (parent.isValid()) {
            static_cast<QQmlTreeRow *>(parent.internalPointer())->insertChild(row, std::move(child));
        } else {
            child->setParent(nullptr);
            mRows.insert(std::next(mRows.begin(), row), std::move(child));
        }
    };
 
    std::vector<std::unique_ptr<QQmlTreeRow>> buffer;
    buffer.reserve(count);
    for (int i = 0; i < count; ++i)
        buffer.push_back(takeChild(sourceParent, sourceRow));
 
    // beginMoveRows uses pre-removal indexing, but after takeChild the
    // parent's child vector has already shrunk.  Adjust for same-parent
    // backward moves.
    int insertAt = destinationChild;
    if (sourceParent == destinationParent && destinationChild > sourceRow)
        insertAt -= count;
 
    for (int i = 0; i < count; ++i)
        insertChild(destinationParent, insertAt + i, std::move(buffer[i]));
 
    endMoveRows();
    emit rowsChanged();
    return true;
}
 
QT_END_NAMESPACE
 
#include "moc_qqmltreemodel_p.cpp"