qquickrepeater.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 "qquickrepeater_p.h"
#include "qquickrepeater_p_p.h"
 
#include <private/qqmlglobal_p.h>
#include <private/qqmlchangeset_p.h>
#include <private/qqmldelegatemodel_p.h>
 
#include <QtQml/QQmlInfo>
#include <QtQml/qqmlcomponent.h>
 
QT_BEGIN_NAMESPACE
 
QQuickRepeaterPrivate::QQuickRepeaterPrivate()
    : model(nullptr)
    , ownModel(false)
    , delegateValidated(false)
    , explicitDelegate(false)
    , explicitDelegateModelAccess(false)
    , itemCount(0)
{
    setTransparentForPositioner(true);
}
 
QQuickRepeaterPrivate::~QQuickRepeaterPrivate()
{
    if (ownModel)
        delete model;
}
 
/*!
    \qmltype Repeater
    \nativetype QQuickRepeater
    \inqmlmodule QtQuick
    \ingroup qtquick-models
    \ingroup qtquick-positioning
    \inherits Item
    \brief Instantiates a number of Item-based components using a provided model.
 
    The Repeater type is used to create a large number of
    similar items. Like other view types, a Repeater has a \l model and a \l delegate:
    for each entry in the model, the delegate is instantiated
    in a context seeded with data from the model. A Repeater item is usually
    enclosed in a positioner type such as \l Row or \l Column to visually
    position the multiple delegate items created by the Repeater.
 
    The following Repeater creates three instances of a \l Rectangle item within
    a \l Row:
 
    \snippet qml/repeaters/repeater.qml import
    \codeline
    \snippet qml/repeaters/repeater.qml simple
 
    \image repeater-simple.png {Three yellow rectangles in a row created
           by Repeater}
 
    A Repeater's \l model can be any of the supported \l {qml-data-models}{data models}.
    Additionally, like delegates for other views, a Repeater delegate can access
    its index within the repeater, as well as the model data relevant to the
    delegate. See the \l delegate property documentation for details.
 
    Items instantiated by the Repeater are inserted, in order, as
    children of the Repeater's parent.  The insertion starts immediately after
    the repeater's position in its parent stacking list.  This allows
    a Repeater to be used inside a layout. For example, the following Repeater's
    items are stacked between a red rectangle and a blue rectangle:
 
    \snippet qml/repeaters/repeater.qml layout
 
    \image repeater.png {Row with red rectangle, ten green circles from
           Repeater, and blue rectangle}
 
 
    \note A Repeater item owns all items it instantiates. Removing or dynamically destroying
    an item created by a Repeater results in unpredictable behavior.
 
 
    \section2 Considerations when using Repeater
 
    The Repeater type creates all of its delegate items when the repeater is first
    created. This can be inefficient if there are a large number of delegate items and
    not all of the items are required to be visible at the same time. If this is the case,
    consider using other view types like ListView (which only creates delegate items
    when they are scrolled into view) or use the \l {Dynamic Object Creation} methods to
    create items as they are required.
 
    Also, note that Repeater is \l {Item}-based, and can only repeat \l {Item}-derived objects.
    For example, it cannot be used to repeat QtObjects:
 
    \qml
    // bad code:
    Item {
        // Can't repeat QtObject as it doesn't derive from Item.
        Repeater {
            model: 10
            QtObject {}
        }
    }
    \endqml
 */
 
/*!
    \qmlsignal QtQuick::Repeater::itemAdded(int index, Item item)
 
    This signal is emitted when an item is added to the repeater. The \a index
    parameter holds the index at which the item has been inserted within the
    repeater, and the \a item parameter holds the \l Item that has been added.
*/
 
/*!
    \qmlsignal QtQuick::Repeater::itemRemoved(int index, Item item)
 
    This signal is emitted when an item is removed from the repeater. The \a index
    parameter holds the index at which the item was removed from the repeater,
    and the \a item parameter holds the \l Item that was removed.
 
    Do not keep a reference to \a item if it was created by this repeater, as
    in these cases it will be deleted shortly after the signal is handled.
*/
QQuickRepeater::QQuickRepeater(QQuickItem *parent)
  : QQuickItem(*(new QQuickRepeaterPrivate), parent)
{
}
 
QQuickRepeater::~QQuickRepeater()
{
    Q_D(QQuickRepeater);
    QQmlDelegateModelPointer model(d->model);
    d->disconnectModel(this, &model);
}
 
/*!
    \qmlproperty var QtQuick::Repeater::model
 
    The model providing data for the repeater.
 
    This property can be set to any of the supported \l {qml-data-models}{data models}:
 
    \list
    \li A number that indicates the number of delegates to be created by the repeater
    \li A model (e.g. a ListModel item, or a QAbstractItemModel subclass)
    \li A string list
    \li An object list
    \endlist
 
    The type of model affects the properties that are exposed to the \l delegate.
 
    \sa {qml-data-models}{Data Models}
*/
QVariant QQuickRepeater::model() const
{
    Q_D(const QQuickRepeater);
 
    if (d->ownModel)
        return static_cast<QQmlDelegateModel *>(d->model.data())->model();
    if (d->model)
        return QVariant::fromValue(d->model.data());
    return QVariant();
}
 
void QQuickRepeater::setModel(const QVariant &m)
{
    Q_D(QQuickRepeater);
    QVariant model = m;
    if (model.userType() == qMetaTypeId<QJSValue>())
        model = model.value<QJSValue>().toVariant();
 
    QQmlDelegateModelPointer oldModel(d->model);
    if (d->ownModel) {
        if (oldModel.delegateModel()->model() == model)
            return;
    } else if (QVariant::fromValue(d->model) == model) {
        return;
    }
 
    clear();
 
    d->disconnectModel(this, &oldModel);
    d->model = nullptr;
 
    QObject *object = qvariant_cast<QObject *>(model);
 
    QQmlDelegateModelPointer newModel(qobject_cast<QQmlInstanceModel *>(object));
    if (newModel) {
        if (d->explicitDelegate) {
            QQmlComponent *delegate = nullptr;
            if (QQmlDelegateModel *old = oldModel.delegateModel())
                delegate = old->delegate();
 
            if (QQmlDelegateModel *delegateModel = newModel.delegateModel()) {
                delegateModel->setDelegate(delegate);
            } else if (delegate) {
                qmlWarning(this) << "Cannot retain explicitly set delegate on non-DelegateModel";
                d->explicitDelegate = false;
            }
        }
 
        if (d->explicitDelegateModelAccess) {
            QQmlDelegateModel::DelegateModelAccess access = QQmlDelegateModel::Qt5ReadWrite;
            if (QQmlDelegateModel *old = oldModel.delegateModel())
                access = old->delegateModelAccess();
 
            if (QQmlDelegateModel *delegateModel = newModel.delegateModel()) {
                delegateModel->setDelegateModelAccess(access);
            } else if (access != QQmlDelegateModel::Qt5ReadWrite) {
                qmlWarning(this) << "Cannot retain explicitly set delegate model access "
                                    "on non-DelegateModel";
                d->explicitDelegateModelAccess = false;
            }
        }
 
        if (d->ownModel) {
            delete oldModel.instanceModel();
            d->ownModel = false;
        }
        d->model = newModel.instanceModel();
    } else if (d->ownModel) {
        // d->ownModel can only be set if the old model is a QQmlDelegateModel.
        Q_ASSERT(oldModel.delegateModel());
        newModel = oldModel;
        d->model = newModel.instanceModel();
        newModel.delegateModel()->setModel(model);
    } else {
        newModel = QQmlDelegateModel::createForView(this, d);
        if (d->explicitDelegate) {
            QQmlComponent *delegate = nullptr;
            if (QQmlDelegateModel *old = oldModel.delegateModel())
                delegate = old->delegate();
            newModel.delegateModel()->setDelegate(delegate);
        }
 
        if (d->explicitDelegateModelAccess) {
            QQmlDelegateModel::DelegateModelAccess access = QQmlDelegateModel::Qt5ReadWrite;
            if (QQmlDelegateModel *old = oldModel.delegateModel())
                access = old->delegateModelAccess();
            newModel.delegateModel()->setDelegateModelAccess(access);
        }
 
        newModel.delegateModel()->setModel(model);
    }
 
    d->connectModel(this, &newModel);
    emit modelChanged();
    emit countChanged();
}
 
/*!
    \qmlproperty Component QtQuick::Repeater::delegate
    \qmldefault
 
    The delegate provides a template defining each item instantiated by the repeater.
 
    Delegates are exposed to a read-only \c index property that indicates the index
    of the delegate within the repeater. For example, the following \l Text delegate
    displays the index of each repeated item:
 
    \table
    \row
    \li \snippet qml/repeaters/repeater.qml index
    \li \image repeater-index.png {Text items displaying "I'm item 0"
               through "I'm item 9"}
    \endtable
 
    If the \l model is a \l{QStringList-based model}{string list} or
    \l{QObjectList-based model}{object list}, the delegate is also exposed to
    a read-only \c modelData property that holds the string or object data. For
    example:
 
    \table
    \row
    \li \snippet qml/repeaters/repeater.qml modeldata
    \li \image repeater-modeldata.png {Text items displaying "Data: apples",
               "Data: oranges", "Data: pears"}
    \endtable
 
    If the \l model is a model object (such as a \l ListModel) the delegate
    can access all model roles as named properties, in the same way that delegates
    do for view classes like ListView.
 
    \sa {QML Data Models}
 */
QQmlComponent *QQuickRepeater::delegate() const
{
    Q_D(const QQuickRepeater);
    if (d->model) {
        if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(d->model))
            return dataModel->delegate();
    }
 
    return nullptr;
}
 
void QQuickRepeater::setDelegate(QQmlComponent *delegate)
{
    Q_D(QQuickRepeater);
    const auto setExplicitDelegate = [&](QQmlDelegateModel *delegateModel) {
        if (delegateModel->delegate() == delegate) {
            d->explicitDelegate = true;
            return;
        }
 
        const int oldCount = delegateModel->count();
        delegateModel->setDelegate(delegate);
        regenerate();
        if (oldCount != delegateModel->count())
            emit countChanged();
        d->explicitDelegate = true;
        d->delegateValidated = false;
    };
 
    if (!d->model) {
        if (!delegate) {
            // Explicitly set a null delegate. We can do this without model.
            d->explicitDelegate = true;
            return;
        }
 
        setExplicitDelegate(QQmlDelegateModel::createForView(this, d));
        // The new model is not connected to applyDelegateChange, yet. We only do this once
        // there is actual data, via an explicit setModel(). So we have to manually emit the
        // delegateChanged() here.
        emit delegateChanged();
        return;
    }
 
    if (QQmlDelegateModel *delegateModel = qobject_cast<QQmlDelegateModel *>(d->model)) {
        // Disable the warning in applyDelegateChange since the new delegate is also explicit.
        d->explicitDelegate = false;
        setExplicitDelegate(delegateModel);
        return;
    }
 
    if (delegate)
        qmlWarning(this) << "Cannot set a delegate on an explicitly provided non-DelegateModel";
    else
        d->explicitDelegate = true; // Explicitly set null delegate always works
}
 
/*!
    \qmlproperty int QtQuick::Repeater::count
 
    This property holds the number of items in the \l model.
 
    The value of \c count does not always match the number of instantiated
    \l {delegate}{delegates}; use \l itemAt() to check if a delegate at a given
    index exists. It returns \c null if the delegate is not instantiated.
 
    \list
    \li While the Repeater is in the process of instantiating delegates (at
        startup, or because of \c model changes), the \l itemAdded signal is
        emitted for each delegate created, and the \c count property changes
        afterwards.
    \li If the Repeater is not part of a completed
        \l {Concepts - Visual Parent in Qt Quick}{visual hierarchy},
        \c count reflects the model size, but no delegates are created.
    \li If the Repeater destroys delegates because of \c model changes,
        the \l itemRemoved() signal is emitted for each, and the \c count
        property changes afterwards.
    \li If the Repeater is taken out of the visual hierarchy (for example by
        setting \c {parent = null}), delegates are destroyed, the \l itemRemoved()
        signal is emitted for each, but \c count does not change.
    \endlist
 
    \sa itemAt(), itemAdded(), itemRemoved()
*/
int QQuickRepeater::count() const
{
    Q_D(const QQuickRepeater);
    if (d->model)
        return d->model->count();
    return 0;
}
 
/*!
    \qmlmethod Item QtQuick::Repeater::itemAt(index)
 
    Returns the \l Item that has been created at the given \a index, or \c null
    if no item exists at \a index.
*/
QQuickItem *QQuickRepeater::itemAt(int index) const
{
    Q_D(const QQuickRepeater);
    if (index >= 0 && index < d->deletables.size())
        return d->deletables[index];
    return nullptr;
}
 
void QQuickRepeater::componentComplete()
{
    Q_D(QQuickRepeater);
    if (d->model && d->ownModel)
        static_cast<QQmlDelegateModel *>(d->model.data())->componentComplete();
    QQuickItem::componentComplete();
    regenerate();
    if (d->model && d->model->count())
        emit countChanged();
}
 
void QQuickRepeater::itemChange(ItemChange change, const ItemChangeData &value)
{
    QQuickItem::itemChange(change, value);
    if (change == ItemParentHasChanged) {
        regenerate();
    }
}
 
void QQuickRepeater::clear()
{
    Q_D(QQuickRepeater);
    bool complete = isComponentComplete();
 
    if (d->model) {
        // We remove in reverse order deliberately; so that signals are emitted
        // with sensible indices.
        for (int i = d->deletables.size() - 1; i >= 0; --i) {
            if (QQuickItem *item = d->deletables.at(i)) {
                if (complete)
                    emit itemRemoved(i, item);
                d->model->release(item);
            }
        }
        for (QQuickItem *item : std::as_const(d->deletables)) {
            if (item)
                item->setParentItem(nullptr);
        }
    }
    d->deletables.clear();
    d->itemCount = 0;
}
 
void QQuickRepeater::regenerate()
{
    Q_D(QQuickRepeater);
    if (!isComponentComplete())
        return;
 
    clear();
 
    if (!d->model || !d->model->count() || !d->model->isValid() || !parentItem() || !isComponentComplete())
        return;
 
    d->itemCount = count();
    d->deletables.resize(d->itemCount);
    d->requestItems();
}
 
void QQuickRepeaterPrivate::requestItems()
{
    for (int i = 0; i < itemCount; i++) {
        QObject *object = model->object(i, QQmlIncubator::AsynchronousIfNested);
        if (object)
            model->release(object);
    }
}
 
void QQuickRepeaterPrivate::connectModel(QQuickRepeater *q, QQmlDelegateModelPointer *model)
{
    QQmlInstanceModel *instanceModel = model->instanceModel();
    if (!instanceModel)
        return;
 
    QObject::connect(instanceModel, &QQmlInstanceModel::modelUpdated,
                     q, &QQuickRepeater::modelUpdated);
    QObject::connect(instanceModel, &QQmlInstanceModel::createdItem,
                     q, &QQuickRepeater::createdItem);
    QObject::connect(instanceModel, &QQmlInstanceModel::initItem,
                     q, &QQuickRepeater::initItem);
    if (QQmlDelegateModel *dataModel = model->delegateModel()) {
        QObjectPrivate::connect(
                dataModel, &QQmlDelegateModel::delegateChanged,
                this, &QQuickRepeaterPrivate::applyDelegateChange);
        QObjectPrivate::connect(
                dataModel, &QQmlDelegateModel::delegateModelAccessChanged,
                this, &QQuickRepeaterPrivate::applyDelegateModelAccessChange);
        if (ownModel) {
            QObject::connect(dataModel, &QQmlDelegateModel::modelChanged,
                             q, &QQuickRepeater::modelChanged);
        }
    }
    q->regenerate();
}
 
void QQuickRepeaterPrivate::disconnectModel(QQuickRepeater *q, QQmlDelegateModelPointer *model)
{
    QQmlInstanceModel *instanceModel = model->instanceModel();
    if (!instanceModel)
        return;
 
    QObject::disconnect(instanceModel, &QQmlInstanceModel::modelUpdated,
                        q, &QQuickRepeater::modelUpdated);
    QObject::disconnect(instanceModel, &QQmlInstanceModel::createdItem,
                        q, &QQuickRepeater::createdItem);
    QObject::disconnect(instanceModel, &QQmlInstanceModel::initItem,
                        q, &QQuickRepeater::initItem);
    if (QQmlDelegateModel *delegateModel = model->delegateModel()) {
        QObjectPrivate::disconnect(
                delegateModel, &QQmlDelegateModel::delegateChanged,
                this, &QQuickRepeaterPrivate::applyDelegateChange);
        QObjectPrivate::disconnect(
                delegateModel, &QQmlDelegateModel::delegateModelAccessChanged,
                this, &QQuickRepeaterPrivate::applyDelegateModelAccessChange);
        if (ownModel) {
            QObject::disconnect(delegateModel, &QQmlDelegateModel::modelChanged,
                                q, &QQuickRepeater::modelChanged);
        }
    }
}
 
void QQuickRepeater::createdItem(int index, QObject *)
{
    Q_D(QQuickRepeater);
    QObject *object = d->model->object(index, QQmlIncubator::AsynchronousIfNested);
    QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
    emit itemAdded(index, item);
}
 
void QQuickRepeater::initItem(int index, QObject *object)
{
    Q_D(QQuickRepeater);
    if (index >= d->deletables.size()) {
        // this can happen when Package is used
        // calling regenerate does too much work, all we need is to call resize
        // so that d->deletables[index] = item below works
        d->deletables.resize(d->model->count() + 1);
    }
    QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
 
    if (!d->deletables.at(index)) {
        if (!item) {
            if (object) {
                d->model->release(object);
                if (!d->delegateValidated) {
                    d->delegateValidated = true;
                    QObject* delegate = this->delegate();
                    qmlWarning(delegate ? delegate : this) << QQuickRepeater::tr("Delegate must be of Item type");
                }
            }
            return;
        }
        d->deletables[index] = item;
        item->setParentItem(parentItem());
 
        // If the item comes from an ObjectModel, it might be used as
        // ComboBox/Menu/TabBar's contentItem. These types unconditionally cull items
        // that are inserted, so account for that here.
        if (d->model && !d->ownModel)
            QQuickItemPrivate::get(item)->setCulled(false);
        if (index > 0 && d->deletables.at(index-1)) {
            item->stackAfter(d->deletables.at(index-1));
        } else {
            QQuickItem *after = this;
            for (int si = index+1; si < d->itemCount; ++si) {
                if (d->deletables.at(si)) {
                    after = d->deletables.at(si);
                    break;
                }
            }
            item->stackBefore(after);
        }
    }
}
 
void QQuickRepeater::modelUpdated(const QQmlChangeSet &changeSet, bool reset)
{
    Q_D(QQuickRepeater);
 
    if (!isComponentComplete())
        return;
 
    if (reset) {
        regenerate();
        if (changeSet.difference() != 0)
            emit countChanged();
        return;
    }
 
    int difference = 0;
    QHash<int, QList<QPointer<QQuickItem> > > moved;
    for (const QQmlChangeSet::Change &remove : changeSet.removes()) {
        int index = qMin(remove.index, d->deletables.size());
        int count = qMin(remove.index + remove.count, d->deletables.size()) - index;
        if (remove.isMove()) {
            moved.insert(remove.moveId, d->deletables.mid(index, count));
            d->deletables.erase(
                    d->deletables.begin() + index,
                    d->deletables.begin() + index + count);
        } else while (count--) {
            QQuickItem *item = d->deletables.at(index);
            d->deletables.remove(index);
            emit itemRemoved(index, item);
            if (item) {
                d->model->release(item);
                item->setParentItem(nullptr);
            }
            --d->itemCount;
        }
 
        difference -= remove.count;
    }
 
    for (const QQmlChangeSet::Change &insert : changeSet.inserts()) {
        int index = qMin(insert.index, d->deletables.size());
        if (insert.isMove()) {
            QList<QPointer<QQuickItem> > items = moved.value(insert.moveId);
            d->deletables = d->deletables.mid(0, index) + items + d->deletables.mid(index);
            QQuickItem *stackBefore = index + items.size() < d->deletables.size()
                    ? d->deletables.at(index + items.size())
                    : this;
            if (stackBefore) {
                for (int i = index; i < index + items.size(); ++i) {
                    if (i < d->deletables.size()) {
                        QPointer<QQuickItem> item = d->deletables.at(i);
                        if (item)
                            item->stackBefore(stackBefore);
                    }
                }
            }
        } else for (int i = 0; i < insert.count; ++i) {
            int modelIndex = index + i;
            ++d->itemCount;
            d->deletables.insert(modelIndex, nullptr);
            QObject *object = d->model->object(modelIndex, QQmlIncubator::AsynchronousIfNested);
            if (object)
                d->model->release(object);
        }
        difference += insert.count;
    }
 
    if (difference != 0)
        emit countChanged();
}
 
/*!
    \qmlproperty enumeration QtQuick::Repeater::delegateModelAccess
    \since 6.10
 
    \include delegatemodelaccess.qdocinc
*/
QQmlDelegateModel::DelegateModelAccess QQuickRepeater::delegateModelAccess() const
{
    Q_D(const QQuickRepeater);
    if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel *>(d->model))
        return dataModel->delegateModelAccess();
    return QQmlDelegateModel::Qt5ReadWrite;
}
 
void QQuickRepeater::setDelegateModelAccess(
        QQmlDelegateModel::DelegateModelAccess delegateModelAccess)
{
    Q_D(QQuickRepeater);
    const auto setExplicitDelegateModelAccess = [&](QQmlDelegateModel *delegateModel) {
        delegateModel->setDelegateModelAccess(delegateModelAccess);
        d->explicitDelegateModelAccess = true;
    };
 
    if (!d->model) {
        if (delegateModelAccess == QQmlDelegateModel::Qt5ReadWrite) {
            // Explicitly set delegateModelAccess to Legacy. We can do this without model.
            d->explicitDelegateModelAccess = true;
            return;
        }
 
        setExplicitDelegateModelAccess(QQmlDelegateModel::createForView(this, d));
 
        // The new model is not connected to applyDelegateModelAccessChange, yet. We only do this
        // once there is actual data, via an explicit setModel(). So we have to manually emit the
        // delegateModelAccessChanged() here.
        emit delegateModelAccessChanged();
        return;
    }
 
    if (QQmlDelegateModel *delegateModel = qobject_cast<QQmlDelegateModel *>(d->model)) {
        // Disable the warning in applyDelegateModelAccessChange since the new delegate model
        // access is also explicit.
        d->explicitDelegateModelAccess = false;
        setExplicitDelegateModelAccess(delegateModel);
        return;
    }
 
    if (delegateModelAccess == QQmlDelegateModel::Qt5ReadWrite) {
        d->explicitDelegateModelAccess = true; // Explicitly set null delegate always works
    } else {
        qmlWarning(this) << "Cannot set a delegateModelAccess on an explicitly provided "
                            "non-DelegateModel";
    }
}
 
QT_END_NAMESPACE
 
#include "moc_qquickrepeater_p.cpp"