qquickloader.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
 
#include "qquickloader_p_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
 
Q_DECLARE_LOGGING_CATEGORY(lcTransient)
 
static const QQuickItemPrivate::ChangeTypes watchedChanges
    = QQuickItemPrivate::Geometry | QQuickItemPrivate::ImplicitWidth | QQuickItemPrivate::ImplicitHeight;
 
QQuickLoaderPrivate::QQuickLoaderPrivate()
    : item(nullptr), object(nullptr), itemContext(nullptr), incubator(nullptr), updatingSize(false),
      active(true), loadingFromSource(false), asynchronous(false), status(computeStatus())
{
}
 
QQuickLoaderPrivate::~QQuickLoaderPrivate()
{
    delete itemContext;
    itemContext = nullptr;
    delete incubator;
    disposeInitialPropertyValues();
}
 
void QQuickLoaderPrivate::itemGeometryChanged(QQuickItem *resizeItem, QQuickGeometryChange change,
                                              const QRectF &oldGeometry)
{
    if (resizeItem == item)
        _q_updateSize(false);
    QQuickItemChangeListener::itemGeometryChanged(resizeItem, change, oldGeometry);
}
 
void QQuickLoaderPrivate::itemImplicitWidthChanged(QQuickItem *)
{
    Q_Q(QQuickLoader);
    q->setImplicitWidth(getImplicitWidth());
}
 
void QQuickLoaderPrivate::itemImplicitHeightChanged(QQuickItem *)
{
    Q_Q(QQuickLoader);
    q->setImplicitHeight(getImplicitHeight());
}
 
void QQuickLoaderPrivate::clear()
{
    Q_Q(QQuickLoader);
    disposeInitialPropertyValues();
 
    if (incubator)
        incubator->clear();
 
    delete itemContext;
    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(object);
    if (context)
        QQmlContextData::get(context)->clearContextRecursively();
 
    if (loadingFromSource && component) {
        // disconnect since we deleteLater
        QObject::disconnect(component, SIGNAL(statusChanged(QQmlComponent::Status)),
                q, SLOT(_q_sourceLoaded()));
        QObject::disconnect(component, SIGNAL(progressChanged(qreal)),
                q, SIGNAL(progressChanged()));
        component->deleteLater();
        component.setObject(nullptr, q);
    } else if (component) {
        component.setObject(nullptr, q);
    }
    source = QUrl();
 
    if (item) {
        QQuickItemPrivate *p = QQuickItemPrivate::get(item);
        p->removeItemChangeListener(this, watchedChanges);
 
        // We can't delete immediately because our item may have triggered
        // the Loader to load a different item.
        item->setParentItem(nullptr);
        item->setVisible(false);
        item = nullptr;
    }
    if (object) {
        object->deleteLater();
        object = nullptr;
    }
}
 
void QQuickLoaderPrivate::initResize()
{
    if (!item)
        return;
    QQuickItemPrivate *p = QQuickItemPrivate::get(item);
    p->addItemChangeListener(this, watchedChanges);
    _q_updateSize();
}
 
qreal QQuickLoaderPrivate::getImplicitWidth() const
{
    Q_Q(const QQuickLoader);
    // If the Loader has a valid width then Loader has set an explicit width on the
    // item, and we want the item's implicitWidth.  If the Loader's width has
    // not been set then its implicitWidth is the width of the item.
    if (item)
        return q->widthValid() ? item->implicitWidth() : item->width();
    return QQuickImplicitSizeItemPrivate::getImplicitWidth();
}
 
qreal QQuickLoaderPrivate::getImplicitHeight() const
{
    Q_Q(const QQuickLoader);
    // If the Loader has a valid height then Loader has set an explicit height on the
    // item, and we want the item's implicitHeight.  If the Loader's height has
    // not been set then its implicitHeight is the height of the item.
    if (item)
        return q->heightValid() ? item->implicitHeight() : item->height();
    return QQuickImplicitSizeItemPrivate::getImplicitHeight();
}
 
QQuickLoader::QQuickLoader(QQuickItem *parent)
  : QQuickImplicitSizeItem(*(new QQuickLoaderPrivate), parent)
{
    setFlag(ItemIsFocusScope);
}
 
QQuickLoader::~QQuickLoader()
{
    Q_D(QQuickLoader);
    d->clear();
}
 
bool QQuickLoader::active() const
{
    Q_D(const QQuickLoader);
    return d->active;
}
 
void QQuickLoader::setActive(bool newVal)
{
    Q_D(QQuickLoader);
    if (d->active == newVal)
        return;
 
    d->active = newVal;
    if (newVal == true) {
        if (d->loadingFromSource) {
            loadFromSource();
        } else {
            loadFromSourceComponent();
        }
    } else {
        // cancel any current incubation
        if (d->incubator) {
            d->incubator->clear();
            delete d->itemContext;
            d->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(d->object);
        if (context)
            QQmlContextData::get(context)->clearContextRecursively();
 
        if (d->item) {
            QQuickItemPrivate *p = QQuickItemPrivate::get(d->item);
            p->removeItemChangeListener(d, watchedChanges);
 
            // We can't delete immediately because our item may have triggered
            // the Loader to load a different item.
            d->item->setParentItem(nullptr);
            d->item->setVisible(false);
            d->item = nullptr;
        }
        if (d->object) {
            d->object->deleteLater();
            d->object = nullptr;
            emit itemChanged();
        }
        d->updateStatus();
    }
    emit activeChanged();
}
 
 
QUrl QQuickLoader::source() const
{
    Q_D(const QQuickLoader);
    return d->source;
}
 
void QQuickLoader::setSourceWithoutResolve(const QUrl &url)
{
    setSource(url, true); // clear previous values
}
 
void QQuickLoader::setSource(const QUrl &url, bool needsClear)
{
    Q_D(QQuickLoader);
    if (d->source == url)
        return;
 
    if (needsClear)
        d->clear();
 
    d->source = url;
    d->loadingFromSource = true;
 
    if (d->active)
        loadFromSource();
    else
        emit sourceChanged();
}
 
void QQuickLoader::loadFromSource()
{
    Q_D(QQuickLoader);
    if (d->source.isEmpty()) {
        emit sourceChanged();
        d->updateStatus();
        emit progressChanged();
        emit itemChanged();
        return;
    }
 
    if (isComponentComplete()) {
        if (!d->component)
            d->createComponent();
        d->load();
    }
}
 
QQmlComponent *QQuickLoader::sourceComponent() const
{
    Q_D(const QQuickLoader);
    return d->component;
}
 
void QQuickLoader::setSourceComponent(QQmlComponent *comp)
{
    Q_D(QQuickLoader);
    if (comp == d->component)
        return;
 
    d->clear();
 
    d->component.setObject(comp, this);
    d->loadingFromSource = false;
 
    if (d->active)
        loadFromSourceComponent();
    else
        emit sourceComponentChanged();
}
 
void QQuickLoader::resetSourceComponent()
{
    setSourceComponent(nullptr);
}
 
void QQuickLoader::loadFromSourceComponent()
{
    Q_D(QQuickLoader);
    if (!d->component) {
        emit sourceComponentChanged();
        d->updateStatus();
        emit progressChanged();
        emit itemChanged();
        return;
    }
 
    if (isComponentComplete())
        d->load();
}
 
 
QUrl QQuickLoader::setSourceUrlHelper(const QUrl &unresolvedUrl)
{
    Q_D(QQuickLoader);
 
    // 1. If setSource is called with a valid url, clear the old component and its corresponding url
    // 2. If setSource is called with an invalid url(e.g. empty url), clear the old component but
    // hold the url for old one.(we will compare it with new url later and may update status of loader to Loader.Null)
    QUrl oldUrl = d->source;
    d->clear();
    QUrl sourceUrl = qmlEngine(this)->handle()->callingQmlContext()->resolvedUrl(unresolvedUrl);
    if (!sourceUrl.isValid())
        d->source = oldUrl;
    return sourceUrl;
}
 
void QQuickLoader::setSource(const QUrl &source, QJSValue properties)
{
    Q_D(QQuickLoader);
 
    if (!(properties.isArray() || properties.isObject())) {
        qmlWarning(this) << QQuickLoader::tr("setSource: value is not an object");
        return;
    }
 
    QUrl sourceUrl = setSourceUrlHelper(source);
 
    d->disposeInitialPropertyValues();
    auto engine = qmlEngine(this)->handle();
    d->initialPropertyValues.set(engine, QJSValuePrivate::takeManagedValue(&properties)->asReturnedValue());
    d->qmlCallingContext.set(engine, engine->qmlContext());
 
    setSource(sourceUrl, false); // already cleared and set ipv above.
}
 
void QQuickLoader::setSource(const QUrl &source)
{
    Q_D(QQuickLoader);
 
    QUrl sourceUrl = setSourceUrlHelper(source);
 
    d->disposeInitialPropertyValues();
    auto engine = qmlEngine(this)->handle();
    d->qmlCallingContext.set(engine, engine->qmlContext());
 
    setSource(sourceUrl, false); // already cleared and set ipv above.
}
 
void QQuickLoaderPrivate::disposeInitialPropertyValues()
{
    initialPropertyValues.clear();
}
 
void QQuickLoaderPrivate::load()
{
    Q_Q(QQuickLoader);
 
    if (!q->isComponentComplete() || !component)
        return;
 
    if (!component->isLoading()) {
        _q_sourceLoaded();
    } else {
        QObject::connect(component, SIGNAL(statusChanged(QQmlComponent::Status)),
                q, SLOT(_q_sourceLoaded()));
        QObject::connect(component, SIGNAL(progressChanged(qreal)),
                q, SIGNAL(progressChanged()));
        updateStatus();
        emit q->progressChanged();
        if (loadingFromSource)
            emit q->sourceChanged();
        else
            emit q->sourceComponentChanged();
        emit q->itemChanged();
    }
}
 
void QQuickLoaderIncubator::setInitialState(QObject *o)
{
    loader->setInitialState(o);
}
 
void QQuickLoaderPrivate::setInitialState(QObject *obj)
{
    Q_Q(QQuickLoader);
 
    QQuickItem *item = qmlobject_cast<QQuickItem*>(obj);
    if (item) {
        // If the item doesn't have an explicit size, but the Loader
        // does, then set the item's size now before bindings are
        // evaluated, otherwise we will end up resizing the item
        // later and triggering any affected bindings/anchors.
        if (widthValid() && !QQuickItemPrivate::get(item)->widthValid())
            item->setWidth(q->width());
        if (heightValid() && !QQuickItemPrivate::get(item)->heightValid())
            item->setHeight(q->height());
        item->setParentItem(q);
    }
    if (obj) {
        if (itemContext)
            QQml_setParent_noEvent(itemContext, obj);
        QQml_setParent_noEvent(obj, q);
        itemContext = nullptr;
    }
 
    if (initialPropertyValues.isUndefined())
        return;
 
    QQmlComponentPrivate *d = QQmlComponentPrivate::get(component);
    Q_ASSERT(d && d->engine);
    QV4::ExecutionEngine *v4 = d->engine->handle();
    Q_ASSERT(v4);
    QV4::Scope scope(v4);
    QV4::ScopedValue ipv(scope, initialPropertyValues.value());
    QV4::Scoped<QV4::QmlContext> qmlContext(scope, qmlCallingContext.value());
    auto incubatorPriv = QQmlIncubatorPrivate::get(incubator);
    d->initializeObjectWithInitialProperties(qmlContext, ipv, obj, incubatorPriv->requiredProperties());
}
 
void QQuickLoaderIncubator::statusChanged(Status status)
{
    loader->incubatorStateChanged(status);
}
 
void QQuickLoaderPrivate::incubatorStateChanged(QQmlIncubator::Status status)
{
    Q_Q(QQuickLoader);
    if (status == QQmlIncubator::Loading || status == QQmlIncubator::Null)
        return;
 
    if (status == QQmlIncubator::Ready) {
        object = incubator->object();
        item = qmlobject_cast<QQuickItem*>(object);
        emit q->itemChanged();
        initResize();
        incubator->clear();
    } else if (status == QQmlIncubator::Error) {
        if (!incubator->errors().isEmpty())
            QQmlEnginePrivate::warning(qmlEngine(q), incubator->errors());
        delete itemContext;
        itemContext = nullptr;
        delete incubator->object();
        source = QUrl();
        emit q->itemChanged();
    }
    if (loadingFromSource)
        emit q->sourceChanged();
    else
        emit q->sourceComponentChanged();
    updateStatus();
    emit q->progressChanged();
    if (status == QQmlIncubator::Ready)
        emit q->loaded();
}
 
void QQuickLoaderPrivate::_q_sourceLoaded()
{
    Q_Q(QQuickLoader);
    if (!component || !component->errors().isEmpty()) {
        if (component)
            QQmlEnginePrivate::warning(qmlEngine(q), component->errors());
        if (loadingFromSource)
            emit q->sourceChanged();
        else
            emit q->sourceComponentChanged();
        updateStatus();
        emit q->progressChanged();
        emit q->itemChanged(); //Like clearing source, emit itemChanged even if previous item was also null
        disposeInitialPropertyValues(); // cleanup
        return;
    }
 
    if (!active)
        return;
 
    QQmlContext *creationContext = component->creationContext();
    if (!creationContext)
        creationContext = qmlContext(q);
 
    QQmlComponentPrivate *cp = QQmlComponentPrivate::get(component);
    QQmlContext *context = [&](){
        if (cp->isBound())
            return creationContext;
        itemContext = new QQmlContext(creationContext);
        itemContext->setContextObject(q);
        return itemContext;
    }();
 
    delete incubator;
    incubator = new QQuickLoaderIncubator(this, asynchronous ? QQmlIncubator::Asynchronous : QQmlIncubator::AsynchronousIfNested);
 
    component->create(*incubator, context);
 
    if (incubator && incubator->status() == QQmlIncubator::Loading)
        updateStatus();
}
 
QQuickLoader::Status QQuickLoader::status() const
{
    Q_D(const QQuickLoader);
 
    return static_cast<Status>(d->status);
}
 
void QQuickLoader::componentComplete()
{
    Q_D(QQuickLoader);
    QQuickItem::componentComplete();
    if (active() && (status() != Ready)) {
        if (d->loadingFromSource)
            d->createComponent();
        d->load();
    }
}
 
void QQuickLoader::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value)
{
    switch (change) {
    case ItemChildAddedChange:
        Q_ASSERT(value.item);
        if (value.item->flags().testFlag(QQuickItem::ItemObservesViewport))
            // Re-trigger the parent traversal to get subtreeTransformChangedEnabled turned on
            value.item->setFlag(QQuickItem::ItemObservesViewport);
        break;
    default:
        break;
    }
    QQuickItem::itemChange(change, value);
}
 
qreal QQuickLoader::progress() const
{
    Q_D(const QQuickLoader);
 
    if (d->object)
        return 1.0;
 
    if (d->component)
        return d->component->progress();
 
    return 0.0;
}
 
bool QQuickLoader::asynchronous() const
{
    Q_D(const QQuickLoader);
    return d->asynchronous;
}
 
void QQuickLoader::setAsynchronous(bool a)
{
    Q_D(QQuickLoader);
    if (d->asynchronous == a)
        return;
 
    d->asynchronous = a;
 
    if (!d->asynchronous && isComponentComplete() && d->active) {
        if (d->loadingFromSource && d->component && d->component->isLoading()) {
            // Force a synchronous component load
            QUrl currentSource = d->source;
            d->clear();
            d->source = currentSource;
            loadFromSource();
        } else if (d->incubator && d->incubator->isLoading()) {
            d->incubator->forceCompletion();
        }
    }
 
    emit asynchronousChanged();
}
 
void QQuickLoaderPrivate::_q_updateSize(bool loaderGeometryChanged)
{
    Q_Q(QQuickLoader);
    if (!item)
        return;
 
    const bool needToUpdateWidth = loaderGeometryChanged && q->widthValid();
    const bool needToUpdateHeight = loaderGeometryChanged && q->heightValid();
 
    if (needToUpdateWidth && needToUpdateHeight) {
        /* setSize keeps bindings intact (for backwards compatibility reasons),
           but here we actually want the loader to control the size, so any
           prexisting bindings ought to be removed
        */
        auto *itemPriv = QQuickItemPrivate::get(item);
        // takeBinding  would work without the check, but this is more efficient
        // for the common case where we don't have a binding
        if (itemPriv->width.hasBinding())
            itemPriv->width.takeBinding();
        if (itemPriv->height.hasBinding())
            itemPriv->height.takeBinding();
        item->setSize(QSizeF(q->width(), q->height()));
    } else if (needToUpdateWidth) {
        item->setWidth(q->width());
    } else if (needToUpdateHeight) {
        item->setHeight(q->height());
    }
 
    if (updatingSize)
        return;
 
    updatingSize = true;
 
    q->setImplicitSize(getImplicitWidth(), getImplicitHeight());
 
    updatingSize = false;
}
 
QObject *QQuickLoader::item() const
{
    Q_D(const QQuickLoader);
    return d->object;
}
 
void QQuickLoader::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
{
    Q_D(QQuickLoader);
    if (newGeometry != oldGeometry) {
        d->_q_updateSize();
    }
    QQuickItem::geometryChange(newGeometry, oldGeometry);
}
 
QQuickLoader::Status QQuickLoaderPrivate::computeStatus() const
{
    if (!active)
        return QQuickLoader::Status::Null;
 
    if (component) {
        switch (component->status()) {
        case QQmlComponent::Loading:
            return QQuickLoader::Status::Loading;
        case QQmlComponent::Error:
            return QQuickLoader::Status::Error;
        case QQmlComponent::Null:
            return QQuickLoader::Status::Null;
        default:
            break;
        }
    }
 
    if (incubator) {
        switch (incubator->status()) {
        case QQmlIncubator::Loading:
            return QQuickLoader::Status::Loading;
        case QQmlIncubator::Error:
            return QQuickLoader::Status::Error;
        default:
            break;
        }
    }
 
    if (object)
        return QQuickLoader::Status::Ready;
 
    return source.isEmpty() ? QQuickLoader::Status::Null : QQuickLoader::Status::Error;
}
 
void QQuickLoaderPrivate::updateStatus()
{
    Q_Q(QQuickLoader);
    auto newStatus = computeStatus();
    if (status != newStatus) {
        status = newStatus;
        emit q->statusChanged();
    }
}
 
void QQuickLoaderPrivate::createComponent()
{
    Q_Q(QQuickLoader);
    const QQmlComponent::CompilationMode mode = asynchronous
            ? QQmlComponent::Asynchronous
            : QQmlComponent::PreferSynchronous;
    if (QQmlContext *context = qmlContext(q)) {
        if (QQmlEngine *engine = context->engine()) {
            component.setObject(new QQmlComponent(
                                    engine, context->resolvedUrl(source), mode, q), q);
            return;
        }
    }
 
    qmlWarning(q) << "createComponent: Cannot find a QML engine.";
}
 
QT_END_NAMESPACE
 
#include <moc_qquickloader_p.cpp>