diff options
| author | Mitch Curtis <mitch.curtis@qt.io> | 2022-11-18 15:15:16 +0800 |
|---|---|---|
| committer | Mitch Curtis <mitch.curtis@qt.io> | 2022-12-01 10:26:20 +0800 |
| commit | 4bd87b903b355b53e3105ba1ae7c154c4e55cdaf (patch) | |
| tree | cc2edb597f0d5871302eb86e9dda78217384a5aa /src/quicktemplates/qquickdeferredexecute.cpp | |
| parent | 786e1748d4469c135a922a221024f3f9c421c0de (diff) | |
Remove "2" from Qt Quick Controls directories
Qt Quick Controls 2 was named that way because it was a follow-up to
Qt Quick Controls 1.x. Now that Qt Quick Controls 1 is no longer
supported, we don't need to have "2" in the name. Work on this was
already started for the documentation in
1abdfe5d5a052f2298b7bf657513dfa7e0c66a56.
By doing this renaming a few weeks before feature freeze, it won't
affect the release but still results in as little time possible spent
manually fixing conflicts in cherry-picks from non-LTS releases as a
result of the renaming.
This patch does the following:
- Renames directories.
- Adapts CMakeLists.txt and other files to account for the new paths.
A follow-up patch will handle documentation.
It does not touch library names or other user-facing stuff, as that
will have to be done in Qt 7.
Task-number: QTBUG-95413
Change-Id: I170d8db19033ee71e495ff0c5c1a517a41ed7634
Reviewed-by: Mitch Curtis <mitch.curtis@qt.io>
Diffstat (limited to 'src/quicktemplates/qquickdeferredexecute.cpp')
| -rw-r--r-- | src/quicktemplates/qquickdeferredexecute.cpp | 120 |
1 files changed, 120 insertions, 0 deletions
diff --git a/src/quicktemplates/qquickdeferredexecute.cpp b/src/quicktemplates/qquickdeferredexecute.cpp new file mode 100644 index 0000000000..ebb0528ec7 --- /dev/null +++ b/src/quicktemplates/qquickdeferredexecute.cpp @@ -0,0 +1,120 @@ +// Copyright (C) 2017 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 "qquickdeferredexecute_p_p.h" + +#include <QtCore/qhash.h> +#include <QtQml/qqmlengine.h> +#include <QtQml/private/qqmldata_p.h> +#include <QtQml/private/qqmlcomponent_p.h> +#include <QtQml/private/qqmlobjectcreator_p.h> + +#include <deque> + +QT_BEGIN_NAMESPACE + +namespace QtQuickPrivate { + +static void cancelDeferred(QQmlData *ddata, int propertyIndex) +{ + auto dit = ddata->deferredData.rbegin(); + while (dit != ddata->deferredData.rend()) { + (*dit)->bindings.remove(propertyIndex); + ++dit; + } +} + +static bool beginDeferred(QQmlEnginePrivate *enginePriv, const QQmlProperty &property, QQmlComponentPrivate::DeferredState *deferredState) +{ + QObject *object = property.object(); + QQmlData *ddata = QQmlData::get(object); + Q_ASSERT(!ddata->deferredData.isEmpty()); + + int propertyIndex = property.index(); + int wasInProgress = enginePriv->inProgressCreations; + + for (auto dit = ddata->deferredData.rbegin(); dit != ddata->deferredData.rend(); ++dit) { + QQmlData::DeferredData *deferData = *dit; + + auto bindings = deferData->bindings; + auto range = bindings.equal_range(propertyIndex); + if (range.first == bindings.end()) + continue; + + QQmlComponentPrivate::ConstructionState state; + state.setCompletePending(true); + + QQmlContextData *creationContext = nullptr; + state.initCreator(deferData->context->parent(), deferData->compilationUnit, creationContext); + + enginePriv->inProgressCreations++; + + std::deque<const QV4::CompiledData::Binding *> reversedBindings; + std::copy(range.first, range.second, std::front_inserter(reversedBindings)); + state.creator()->beginPopulateDeferred(deferData->context); + for (const QV4::CompiledData::Binding *binding : reversedBindings) + state.creator()->populateDeferredBinding(property, deferData->deferredIdx, binding); + state.creator()->finalizePopulateDeferred(); + state.appendCreatorErrors(); + + deferredState->push_back(std::move(state)); + + // Cleanup any remaining deferred bindings for this property, also in inner contexts, + // to avoid executing them later and overriding the property that was just populated. + cancelDeferred(ddata, propertyIndex); + break; + } + + return enginePriv->inProgressCreations > wasInProgress; +} + +void beginDeferred(QObject *object, const QString &property, + QQuickUntypedDeferredPointer *delegate, bool isOwnState) +{ + QQmlData *data = QQmlData::get(object); + if (data && !data->deferredData.isEmpty() && !data->wasDeleted(object) && data->context) { + QQmlEnginePrivate *ep = QQmlEnginePrivate::get(data->context->engine()); + + QQmlComponentPrivate::DeferredState state; + if (beginDeferred(ep, QQmlProperty(object, property), &state)) { + if (QQmlComponentPrivate::DeferredState *delegateState = delegate->deferredState()) + delegateState->swap(state); + } else if (isOwnState) { + delegate->clearDeferredState(); + } + + // Release deferred data for those compilation units that no longer have deferred bindings + data->releaseDeferredData(); + } else if (isOwnState) { + delegate->clearDeferredState(); + } +} + +void cancelDeferred(QObject *object, const QString &property) +{ + QQmlData *data = QQmlData::get(object); + if (data) + cancelDeferred(data, QQmlProperty(object, property).index()); +} + +void completeDeferred(QObject *object, const QString &property, QQuickUntypedDeferredPointer *delegate) +{ + Q_UNUSED(property); + QQmlComponentPrivate::DeferredState *state = delegate->deferredState(); + if (!state) + return; + + QQmlData *data = QQmlData::get(object); + if (data && !data->wasDeleted(object)) { + QQmlComponentPrivate::DeferredState localState = std::move(*state); + delegate->clearDeferredState(); + QQmlEnginePrivate *ep = QQmlEnginePrivate::get(data->context->engine()); + QQmlComponentPrivate::completeDeferred(ep, &localState); + } else { + delegate->clearDeferredState(); + } +} + +} // QtQuickPrivate + +QT_END_NAMESPACE |