qquick3drepeater.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qquick3drepeater_p.h"
 
#include <private/qqmlglobal_p.h>
#include <private/qqmllistaccessor_p.h>
#include <private/qqmlchangeset_p.h>
#include <private/qqmldelegatemodel_p.h>
 
#include <QtQml/QQmlInfo>
 
QT_BEGIN_NAMESPACE
 
 
QQuick3DRepeater::QQuick3DRepeater(QQuick3DNode *parent)
    : QQuick3DNode(parent)
    , m_model(nullptr)
    , m_itemCount(0)
    , m_ownModel(false)
    , m_dataSourceIsObject(false)
    , m_delegateValidated(false)
{
}
 
QQuick3DRepeater::~QQuick3DRepeater()
{
    if (m_ownModel)
        delete m_model;
}
 
QVariant QQuick3DRepeater::model() const
{
    if (m_dataSourceIsObject) {
        QObject *o = m_dataSourceAsObject;
        return QVariant::fromValue(o);
    }
 
    return m_dataSource;
 
}
 
void QQuick3DRepeater::setModel(const QVariant &m)
{
    QVariant model = m;
    if (model.userType() == qMetaTypeId<QJSValue>())
        model = model.value<QJSValue>().toVariant();
 
    if (m_dataSource == model)
        return;
 
    clear();
    if (m_model) {
        qmlobject_disconnect(m_model, QQmlInstanceModel, SIGNAL(modelUpdated(QQmlChangeSet,bool)),
                this, QQuick3DRepeater, SLOT(modelUpdated(QQmlChangeSet,bool)));
        qmlobject_disconnect(m_model, QQmlInstanceModel, SIGNAL(createdItem(int,QObject*)),
                this, QQuick3DRepeater, SLOT(createdObject(int,QObject*)));
        qmlobject_disconnect(m_model, QQmlInstanceModel, SIGNAL(initItem(int,QObject*)),
                this, QQuick3DRepeater, SLOT(initObject(int,QObject*)));
    }
    m_dataSource = model;
    QObject *object = qvariant_cast<QObject*>(model);
    m_dataSourceAsObject = object;
    m_dataSourceIsObject = object != nullptr;
    QQmlInstanceModel *vim = nullptr;
    if (object && (vim = qobject_cast<QQmlInstanceModel *>(object))) {
        if (m_ownModel) {
            delete m_model;
            m_ownModel = false;
        }
        m_model = vim;
    } else {
        if (!m_ownModel) {
            m_model = new QQmlDelegateModel(qmlContext(this));
            m_ownModel = true;
            if (isComponentComplete())
                static_cast<QQmlDelegateModel *>(m_model.data())->componentComplete();
        }
        if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(m_model))
            dataModel->setModel(model);
    }
    if (m_model) {
        qmlobject_connect(m_model, QQmlInstanceModel, SIGNAL(modelUpdated(QQmlChangeSet,bool)),
                this, QQuick3DRepeater, SLOT(modelUpdated(QQmlChangeSet,bool)));
        qmlobject_connect(m_model, QQmlInstanceModel, SIGNAL(createdItem(int,QObject*)),
                this, QQuick3DRepeater, SLOT(createdObject(int,QObject*)));
        qmlobject_connect(m_model, QQmlInstanceModel, SIGNAL(initItem(int,QObject*)),
                this, QQuick3DRepeater, SLOT(initObject(int,QObject*)));
        regenerate();
    }
    emit modelChanged();
    emit countChanged();
}
 
QQmlComponent *QQuick3DRepeater::delegate() const
{
    if (m_model) {
        if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(m_model))
            return dataModel->delegate();
    }
 
    return nullptr;
}
 
void QQuick3DRepeater::setDelegate(QQmlComponent *delegate)
{
    if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(m_model))
       if (delegate == dataModel->delegate())
           return;
 
    if (!m_ownModel) {
        m_model = new QQmlDelegateModel(qmlContext(this));
        m_ownModel = true;
        if (isComponentComplete())
            static_cast<QQmlDelegateModel *>(m_model.data())->componentComplete();
    }
 
    if (QQmlDelegateModel *dataModel = qobject_cast<QQmlDelegateModel*>(m_model)) {
        dataModel->setDelegate(delegate);
        regenerate();
        emit delegateChanged();
        m_delegateValidated = false;
    }
}
 
int QQuick3DRepeater::count() const
{
    if (m_model)
        return m_model->count();
    return 0;
}
 
QQuick3DObject *QQuick3DRepeater::objectAt(int index) const
{
    if (index >= 0 && index < m_deletables.size())
        return m_deletables[index];
    return nullptr;
}
 
void QQuick3DRepeater::clear()
{
    bool complete = isComponentComplete();
 
    if (m_model) {
        // We remove in reverse order deliberately; so that signals are emitted
        // with sensible indices.
        for (int i = m_deletables.size() - 1; i >= 0; --i) {
            if (QQuick3DObject *item = m_deletables.at(i)) {
                if (complete)
                    emit objectRemoved(i, item);
                m_model->release(item);
            }
        }
        for (QQuick3DObject *item : std::as_const(m_deletables)) {
            if (item)
                item->setParentItem(nullptr);
        }
    }
    m_deletables.clear();
    m_itemCount = 0;
}
 
void QQuick3DRepeater::regenerate()
{
    if (!isComponentComplete())
        return;
 
    clear();
 
    if (!m_model || !m_model->count() || !m_model->isValid() || !parentItem() || !isComponentComplete())
        return;
 
    m_itemCount = count();
    m_deletables.resize(m_itemCount);
    requestItems();
}
 
void QQuick3DRepeater::componentComplete()
{
    if (m_model && m_ownModel)
        static_cast<QQmlDelegateModel *>(m_model.data())->componentComplete();
    QQuick3DNode::componentComplete();
    regenerate();
    if (m_model && m_model->count())
        emit countChanged();
}
 
void QQuick3DRepeater::itemChange(QQuick3DObject::ItemChange change, const QQuick3DObject::ItemChangeData &value)
{
    QQuick3DObject::itemChange(change, value);
    if (change == ItemParentHasChanged) {
        regenerate();
    }
}
 
void QQuick3DRepeater::createdObject(int index, QObject *)
{
    QObject *object = m_model->object(index, QQmlIncubator::AsynchronousIfNested);
    QQuick3DObject *item = qmlobject_cast<QQuick3DObject*>(object);
    emit objectAdded(index, item);
}
 
void QQuick3DRepeater::initObject(int index, QObject *object)
{
    QQuick3DNode *item = qmlobject_cast<QQuick3DNode*>(object);
 
    if (!m_deletables.at(index)) {
        if (!item) {
            if (object) {
                m_model->release(object);
                if (!m_delegateValidated) {
                    m_delegateValidated = true;
                    QObject* delegate = this->delegate();
                    qmlWarning(delegate ? delegate : this) << QQuick3DRepeater::tr("Delegate must be of Node type");
                }
            }
            return;
        }
        m_deletables[index] = item;
        item->setParent(this);
        item->setParentItem(static_cast<QQuick3DNode*>(this));
        initDelegate(index, item);
    }
}
 
void QQuick3DRepeater::modelUpdated(const QQmlChangeSet &changeSet, bool reset)
{
    if (!isComponentComplete())
        return;
 
    if (reset) {
        regenerate();
        if (changeSet.difference() != 0)
            emit countChanged();
        return;
    }
 
    int difference = 0;
    QHash<int, QVector<QPointer<QQuick3DNode> > > moved;
    for (const QQmlChangeSet::Change &remove : changeSet.removes()) {
        int index = qMin(remove.index, m_deletables.size());
        int count = qMin(remove.index + remove.count, m_deletables.size()) - index;
        if (remove.isMove()) {
            moved.insert(remove.moveId, m_deletables.mid(index, count));
            m_deletables.erase(
                    m_deletables.begin() + index,
                    m_deletables.begin() + index + count);
        } else while (count--) {
            QQuick3DNode *item = m_deletables.at(index);
            m_deletables.remove(index);
            emit objectRemoved(index, item);
            if (item) {
                m_model->release(item);
                item->setParentItem(nullptr);
            }
            --m_itemCount;
        }
 
        difference -= remove.count;
    }
 
    for (const QQmlChangeSet::Change &insert : changeSet.inserts()) {
        int index = qMin(insert.index, m_deletables.size());
        if (insert.isMove()) {
            QVector<QPointer<QQuick3DNode> > items = moved.value(insert.moveId);
            m_deletables = m_deletables.mid(0, index) + items + m_deletables.mid(index);
        } else for (int i = 0; i < insert.count; ++i) {
            int modelIndex = index + i;
            ++m_itemCount;
            m_deletables.insert(modelIndex, nullptr);
            QObject *object = m_model->object(modelIndex, QQmlIncubator::AsynchronousIfNested);
            if (object)
                m_model->release(object);
        }
        difference += insert.count;
    }
 
    if (difference != 0)
        emit countChanged();
}
 
void QQuick3DRepeater::requestItems()
{
    for (int i = 0; i < m_itemCount; i++) {
        QObject *object = m_model->object(i, QQmlIncubator::AsynchronousIfNested);
        if (object)
            m_model->release(object);
    }
}
 
QT_END_NAMESPACE
 
#include "moc_qquick3drepeater_p.cpp"