qquick3dloader.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 "qquick3dloader_p.h"
 
#include "qquick3dobject_p.h"
 
#include <QtQml/qqmlinfo.h>
 
#include <private/qqmlengine_p.h>
#include <private/qqmlglobal_p.h>
 
#include <private/qqmlcomponent_p.h>
#include <private/qqmlincubator_p.h>
 
QT_BEGIN_NAMESPACE
 
void QQuick3DLoaderIncubator::statusChanged(QQmlIncubator::Status status)
{
    m_loader->incubatorStateChanged(status);
}
 
void QQuick3DLoaderIncubator::setInitialState(QObject *o)
{
    m_loader->setInitialState(o);
}
 
QQuick3DLoader::QQuick3DLoader(QQuick3DNode *parent)
    : QQuick3DNode(parent)
    , m_item(nullptr)
    , m_object(nullptr)
    , m_itemContext(nullptr)
    , m_incubator(nullptr)
    , m_active(true)
    , m_loadingFromSource(false)
    , m_asynchronous(false)
{
}
 
QQuick3DLoader::~QQuick3DLoader()
{
    delete m_itemContext;
    m_itemContext = nullptr;
    delete m_incubator;
    m_incubator = nullptr;
    disposeInitialPropertyValues();
    clear();
}
 
bool QQuick3DLoader::active() const
{
    return m_active;
}
 
void QQuick3DLoader::setActive(bool newVal)
{
    if (m_active == newVal)
        return;
 
    m_active = newVal;
    if (newVal) {
        if (m_loadingFromSource) {
            loadFromSource();
        } else {
            loadFromSourceComponent();
        }
    } else {
        // cancel any current incubation
        if (m_incubator) {
            m_incubator->clear();
            delete m_itemContext;
            m_itemContext = nullptr;
        }
 
        // Prevent any bindings from running while waiting for deletion. Without
        // this we may get transient errors from use of 'parent', for example.
        QQmlContext *context = qmlContext(m_object);
        if (context)
            QQmlContextData::get(context)->clearContextRecursively();
 
        if (m_item) {
            // We can't delete immediately because our item may have triggered
            // the Loader to load a different item.
            m_item->setParentItem(nullptr);
            m_item->setVisible(false);
            m_item = nullptr;
        }
        if (m_object) {
            m_object->deleteLater();
            m_object = nullptr;
            emit itemChanged();
        }
        emit statusChanged();
    }
    emit activeChanged();
}
 
void QQuick3DLoader::setSource(QQmlV4Function *args)
{
    bool ipvError = false;
    args->setReturnValue(QV4::Encode::undefined());
    QV4::Scope scope(args->v4engine());
    QV4::ScopedValue ipv(scope, extractInitialPropertyValues(args, &ipvError));
    if (ipvError)
        return;
 
    clear();
    QUrl sourceUrl = resolveSourceUrl(args);
    if (!ipv->isUndefined()) {
        disposeInitialPropertyValues();
        m_initialPropertyValues.set(args->v4engine(), ipv);
    }
    m_qmlCallingContext.set(scope.engine, scope.engine->qmlContext());
 
    setSource(sourceUrl, false); // already cleared and set ipv above.
}
 
QUrl QQuick3DLoader::source() const
{
    return m_source;
}
 
void QQuick3DLoader::setSource(const QUrl &url)
{
    setSource(url, true);
}
 
QQmlComponent *QQuick3DLoader::sourceComponent() const
{
    return m_component;
}
 
void QQuick3DLoader::setSourceComponent(QQmlComponent *comp)
{
    if (comp == m_component)
        return;
 
    clear();
 
    m_component.setObject(comp, this);
    m_loadingFromSource = false;
 
    if (m_active)
        loadFromSourceComponent();
    else
        emit sourceComponentChanged();
}
 
void QQuick3DLoader::resetSourceComponent()
{
    setSourceComponent(nullptr);
}
 
QQuick3DLoader::Status QQuick3DLoader::status() const
{
    if (!m_active)
        return Null;
 
    if (m_component) {
        switch (m_component->status()) {
        case QQmlComponent::Loading:
            return Loading;
        case QQmlComponent::Error:
            return Error;
        case QQmlComponent::Null:
            return Null;
        default:
            break;
        }
    }
 
    if (m_incubator) {
        switch (m_incubator->status()) {
        case QQmlIncubator::Loading:
            return Loading;
        case QQmlIncubator::Error:
            return Error;
        default:
            break;
        }
    }
 
    if (m_object)
        return Ready;
 
    return m_source.isEmpty() ? Null : Error;
}
 
qreal QQuick3DLoader::progress() const
{
 
    if (m_object)
        return 1.0;
 
    if (m_component)
        return m_component->progress();
 
    return 0.0;
}
 
bool QQuick3DLoader::asynchronous() const
{
    return m_asynchronous;
}
 
void QQuick3DLoader::setAsynchronous(bool a)
{
    if (m_asynchronous == a)
        return;
 
    m_asynchronous = a;
 
    if (!m_asynchronous && isComponentComplete() && m_active) {
        if (m_loadingFromSource && m_component && m_component->isLoading()) {
            // Force a synchronous component load
            QUrl currentSource = m_source;
            clear();
            m_source = currentSource;
            loadFromSource();
        } else if (m_incubator && m_incubator->isLoading()) {
            m_incubator->forceCompletion();
        }
    }
 
    emit asynchronousChanged();
}
 
QObject *QQuick3DLoader::item() const
{
    return m_object;
}
 
void QQuick3DLoader::componentComplete()
{
    QQuick3DNode::componentComplete();
    if (active()) {
        if (m_loadingFromSource)
            createComponent();
        load();
    }
}
 
void QQuick3DLoader::sourceLoaded()
{
    if (!m_component || !m_component->errors().isEmpty()) {
        if (m_component)
            QQmlEnginePrivate::warning(qmlEngine(this), m_component->errors());
        if (m_loadingFromSource)
            emit sourceChanged();
        else
            emit sourceComponentChanged();
        emit statusChanged();
        emit progressChanged();
        emit itemChanged(); //Like clearing source, emit itemChanged even if previous item was also null
        disposeInitialPropertyValues(); // cleanup
        return;
    }
 
    QQmlContext *creationContext = m_component->creationContext();
    if (!creationContext) creationContext = qmlContext(this);
    m_itemContext = new QQmlContext(creationContext);
    m_itemContext->setContextObject(this);
 
    delete m_incubator;
    m_incubator = new QQuick3DLoaderIncubator(this, m_asynchronous ? QQmlIncubator::Asynchronous : QQmlIncubator::AsynchronousIfNested);
 
    m_component->create(*m_incubator, m_itemContext);
 
    if (m_incubator && m_incubator->status() == QQmlIncubator::Loading)
        emit statusChanged();
}
 
void QQuick3DLoader::setSource(const QUrl &sourceUrl, bool needsClear)
{
    if (m_source == sourceUrl)
        return;
 
    if (needsClear)
        clear();
 
    m_source = sourceUrl;
    m_loadingFromSource = true;
 
    if (m_active)
        loadFromSource();
    else
        emit sourceChanged();
}
 
void QQuick3DLoader::loadFromSource()
{
    if (m_source.isEmpty()) {
        emit sourceChanged();
        emit statusChanged();
        emit progressChanged();
        emit itemChanged();
        return;
    }
 
    if (isComponentComplete()) {
        if (!m_component)
            createComponent();
        load();
    }
}
 
void QQuick3DLoader::loadFromSourceComponent()
{
    if (!m_component) {
        emit sourceComponentChanged();
        emit statusChanged();
        emit progressChanged();
        emit itemChanged();
        return;
    }
 
    if (isComponentComplete())
        load();
}
 
void QQuick3DLoader::clear()
{
    disposeInitialPropertyValues();
 
    if (m_incubator)
        m_incubator->clear();
 
    delete m_itemContext;
    m_itemContext = nullptr;
 
    // Prevent any bindings from running while waiting for deletion. Without
    // this we may get transient errors from use of 'parent', for example.
    QQmlContext *context = qmlContext(m_object);
    if (context)
        QQmlContextData::get(context)->clearContextRecursively();
 
    if (m_loadingFromSource && m_component) {
        // disconnect since we deleteLater
        QObject::disconnect(m_component, SIGNAL(statusChanged(QQmlComponent::Status)),
                this, SLOT(sourceLoaded()));
        QObject::disconnect(m_component, SIGNAL(progressChanged(qreal)),
                this, SIGNAL(progressChanged()));
        m_component->deleteLater();
        m_component.setObject(nullptr, this);
    } else if (m_component) {
        m_component.setObject(nullptr, this);
    }
    m_source = QUrl();
 
    if (m_item) {
        // We can't delete immediately because our item may have triggered
        // the Loader to load a different item.
        m_item->setParentItem(nullptr);
        m_item->setVisible(false);
        m_item = nullptr;
    }
    if (m_object) {
        m_object->deleteLater();
        m_object = nullptr;
    }
}
 
void QQuick3DLoader::load()
{
 
    if (!isComponentComplete() || !m_component)
        return;
 
    if (!m_component->isLoading()) {
        sourceLoaded();
    } else {
        QObject::connect(m_component, SIGNAL(statusChanged(QQmlComponent::Status)),
                this, SLOT(sourceLoaded()));
        QObject::connect(m_component, SIGNAL(progressChanged(qreal)),
                this, SIGNAL(progressChanged()));
        emit statusChanged();
        emit progressChanged();
        if (m_loadingFromSource)
            emit sourceChanged();
        else
            emit sourceComponentChanged();
        emit itemChanged();
    }
}
 
void QQuick3DLoader::incubatorStateChanged(QQmlIncubator::Status status)
{
    if (status == QQmlIncubator::Loading || status == QQmlIncubator::Null)
        return;
 
    if (status == QQmlIncubator::Ready) {
        m_object = m_incubator->object();
        m_item = qmlobject_cast<QQuick3DNode*>(m_object);
        emit itemChanged();
        m_incubator->clear();
    } else if (status == QQmlIncubator::Error) {
        if (!m_incubator->errors().isEmpty())
            QQmlEnginePrivate::warning(qmlEngine(this), m_incubator->errors());
        delete m_itemContext;
        m_itemContext = nullptr;
        delete m_incubator->object();
        m_source = QUrl();
        emit itemChanged();
    }
    if (m_loadingFromSource)
        emit sourceChanged();
    else
        emit sourceComponentChanged();
    emit statusChanged();
    emit progressChanged();
    if (status == QQmlIncubator::Ready)
        emit loaded();
    disposeInitialPropertyValues(); // cleanup
}
 
void QQuick3DLoader::setInitialState(QObject *obj)
{
    QQuick3DObject *item = qmlobject_cast<QQuick3DObject*>(obj);
    if (item) {
        item->setParentItem(this);
    }
    if (obj) {
        QQml_setParent_noEvent(m_itemContext, obj);
        QQml_setParent_noEvent(obj, this);
        m_itemContext = nullptr;
    }
 
    if (m_initialPropertyValues.isUndefined())
        return;
 
    QQmlComponentPrivate *d = QQmlComponentPrivate::get(m_component);
    Q_ASSERT(d && d->engine);
    QV4::ExecutionEngine *v4 = d->engine->handle();
    Q_ASSERT(v4);
    QV4::Scope scope(v4);
    QV4::ScopedValue ipv(scope, m_initialPropertyValues.value());
    QV4::Scoped<QV4::QmlContext> qmlContext(scope, m_qmlCallingContext.value());
    d->initializeObjectWithInitialProperties(qmlContext, ipv, obj, QQmlIncubatorPrivate::get(m_incubator)->requiredProperties());
}
 
void QQuick3DLoader::disposeInitialPropertyValues()
{
 
}
 
QUrl QQuick3DLoader::resolveSourceUrl(QQmlV4Function *args)
{
    QV4::Scope scope(args->v4engine());
    QV4::ScopedValue v(scope, (*args)[0]);
    QString arg = v->toQString();
    if (arg.isEmpty())
        return QUrl();
 
    auto context = scope.engine->callingQmlContext();
    Q_ASSERT(!context.isNull());
    return context->resolvedUrl(QUrl(arg));
}
 
QV4::ReturnedValue QQuick3DLoader::extractInitialPropertyValues(QQmlV4Function *args, bool *error)
{
    QV4::Scope scope(args->v4engine());
    QV4::ScopedValue valuemap(scope, QV4::Encode::undefined());
    if (args->length() >= 2) {
        QV4::ScopedValue v(scope, (*args)[1]);
        if (!v->isObject() || v->as<QV4::ArrayObject>()) {
            *error = true;
            qmlWarning(this) << QQuick3DLoader::tr("setSource: value is not an object");
        } else {
            *error = false;
            valuemap = v;
        }
    }
 
    return valuemap->asReturnedValue();
}
 
void QQuick3DLoader::createComponent()
{
    const QQmlComponent::CompilationMode mode = m_asynchronous
            ? QQmlComponent::Asynchronous
            : QQmlComponent::PreferSynchronous;
    QQmlContext *context = qmlContext(this);
    m_component.setObject(new QQmlComponent(context->engine(),
                                            context->resolvedUrl(m_source),
                                            mode,
                                            this),
                          this);
}
 
QT_END_NAMESPACE
 
#include "moc_qquick3dloader_p.cpp"