Revision control
++ // 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 "qquickbehavior_p.h"
++
++ #include "qquickanimation_p.h"
++ #include <qqmlcontext.h>
++ #include <qqmlinfo.h>
++ #include <private/qqmlproperty_p.h>
++ #include <private/qqmlengine_p.h>
++ #include <private/qabstractanimationjob_p.h>
++ #include <private/qquicktransition_p.h>
++
++ #include <private/qquickanimatorjob_p.h>
++
++ #include <private/qobject_p.h>
++ #include <QtCore/qpointer.h>
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \internal
++ \brief The UntypedProxyProperty class is a property used in Behavior to handle bindable properties.
++
++ Whenever a bindable property with a Behavior gets a request for its bindable interface, we instead
++ return the bindable interface of the UntypedProxyProperty. This causes all reads and writes to be
++ intercepted to use \c m_storage instead; moreover, any installed binding will also use \c m_storage
++ as the property data for the binding.
++
++ The BehaviorPrivate acts as an observer, listening to changes of the proxy property. If those occur,
++ QQuickBehavior::write is called with the new value, which will then adjust the actual property (playing
++ animations if necessary).
++
++ \warning The interception mechanism works only via the metaobject system, just like it is the case with
++ non-binadble properties and writes. Bypassing the metaobject system can thus lead to inconsistent results;
++ it is however currently safe, as we do not publically expose the classes, and the code in Quick plays
++ nicely.
++ */
++ class UntypedProxyProperty : public QUntypedPropertyData
++ {
++ QtPrivate::QPropertyBindingData m_bindingData;
++ QUntypedPropertyData *m_sourcePropertyData;
++ const QtPrivate::QBindableInterface *m_sourceInterface;
++ QVariant m_storage;
++ public:
++ void static getter(const QUntypedPropertyData *d, void *value)
++ {
++ auto This = static_cast<const UntypedProxyProperty *>(d);
++ // multiplexing: If the flag is set, we want to receive the metatype instead
++ if (quintptr(value) & QtPrivate::QBindableInterface::MetaTypeAccessorFlag) {
++ *reinterpret_cast<QMetaType *>(quintptr(value) &
++ ~QtPrivate::QBindableInterface::MetaTypeAccessorFlag)
++ = This->type();
++ return;
++ }
++ This->type().construct(value, This->m_storage.constData());
++ This->m_bindingData.registerWithCurrentlyEvaluatingBinding();
++ }
++
++ void static setter(QUntypedPropertyData *d, const void *value)
++ {
++ auto This = static_cast<UntypedProxyProperty *>(d);
++ This->type().construct(This->m_storage.data(), value);
++ This->m_bindingData.notifyObservers(reinterpret_cast<QUntypedPropertyData *>(This->m_storage.data()));
++ }
++
++ static QUntypedPropertyBinding bindingGetter(const QUntypedPropertyData *d)
++ {
++ auto This = static_cast<const UntypedProxyProperty *>(d);
++ return QPropertyBindingPrivate::makeUntyped(This->m_bindingData.binding());
++ }
++
++ static QUntypedPropertyBinding bindingSetter(QUntypedPropertyData *d,
++ const QUntypedPropertyBinding &binding)
++ {
++ auto This = static_cast<UntypedProxyProperty *>(d);
++ const QMetaType type = This->type();
++ if (binding.valueMetaType() != type)
++ return {};
++
++ // We want to notify in any case here because the target property should be set
++ // even if our proxy binding results in the default value.
++ QPropertyBindingPrivate::get(binding)->scheduleNotify();
++ return This->m_bindingData.setBinding(binding,
++ reinterpret_cast<QUntypedPropertyData *>(
++ This->m_storage.data()));
++ }
++
++ static QUntypedPropertyBinding makeBinding(const QUntypedPropertyData *d,
++ const QPropertyBindingSourceLocation &location)
++ {
++ auto This = static_cast<const UntypedProxyProperty *>(d);
++ return This->m_sourceInterface->makeBinding(This->m_sourcePropertyData, location);
++ }
++
++ static void setObserver(const QUntypedPropertyData *d, QPropertyObserver *observer)
++ {
++ auto This = static_cast<const UntypedProxyProperty *>(d);
++ This->m_sourceInterface->setObserver(This->m_sourcePropertyData, observer);
++ }
++
++
++
++ UntypedProxyProperty(QUntypedBindable bindable, QQuickBehaviorPrivate *behavior);
++
++ QUntypedBindable getBindable();
++ QMetaType type() const { return m_storage.metaType(); }
++ QVariant value() const {return m_storage;}
++ };
++
++ static constexpr inline QtPrivate::QBindableInterface untypedProxyPropertyBindableInterafce {
++ &UntypedProxyProperty::getter,
++ &UntypedProxyProperty::setter,
++ &UntypedProxyProperty::bindingGetter,
++ &UntypedProxyProperty::bindingSetter,
++ &UntypedProxyProperty::makeBinding,
++ &UntypedProxyProperty::setObserver,
++ /*metatype*/nullptr
++ };
++
++ struct UntypedProxyPropertyBindable : QUntypedBindable {
++ UntypedProxyPropertyBindable(UntypedProxyProperty *property)
++ :QUntypedBindable (property, &untypedProxyPropertyBindableInterafce)
++ {}
++ };
++
++ QUntypedBindable UntypedProxyProperty::getBindable()
++ {
++ return UntypedProxyPropertyBindable {const_cast<UntypedProxyProperty *>(this)};
++ }
++
++ class QQuickBehaviorPrivate : public QObjectPrivate, public QAnimationJobChangeListener, public QPropertyObserver
++ {
++ Q_DECLARE_PUBLIC(QQuickBehavior)
++ public:
++ static void onProxyChanged(QPropertyObserver *, QUntypedPropertyData *);
++ QQuickBehaviorPrivate()
++ : QPropertyObserver(&QQuickBehaviorPrivate::onProxyChanged) {}
++ void animationStateChanged(QAbstractAnimationJob *, QAbstractAnimationJob::State newState, QAbstractAnimationJob::State oldState) override;
++
++ QQmlProperty property;
++ QVariant targetValue;
++ QPointer<QQuickAbstractAnimation> animation = nullptr;
++ QAbstractAnimationJob *animationInstance = nullptr;
++ std::unique_ptr<UntypedProxyProperty> propertyProxy;
++ bool enabled = true;
++ bool finalized = false;
++ bool blockRunningChanged = false;
++
++ };
++
++ UntypedProxyProperty::UntypedProxyProperty(QUntypedBindable bindable, QQuickBehaviorPrivate *behavior) :
++ m_sourcePropertyData(QUntypedBindablePrivate::getPropertyData(bindable)),
++ m_sourceInterface(QUntypedBindablePrivate::getInterface(bindable)),
++ m_storage(QVariant(bindable.metaType()))
++ {
++ behavior->setSource(m_bindingData);
++ }
++
++ /*!
++ \qmltype Behavior
++ \nativetype QQuickBehavior
++ \inqmlmodule QtQuick
++ \ingroup qtquick-transitions-animations
++ \ingroup qtquick-interceptors
++ \brief Defines a default animation for a property change.
++
++ A Behavior defines the default animation to be applied whenever a
++ particular property value changes.
++
++ For example, the following Behavior defines a NumberAnimation to be run
++ whenever the \l Rectangle's \c width value changes. When the MouseArea
++ is clicked, the \c width is changed, triggering the behavior's animation:
++
++ \snippet qml/behavior.qml 0
++
++ Note that a property cannot have more than one assigned Behavior. To provide
++ multiple animations within a Behavior, use ParallelAnimation or
++ SequentialAnimation.
++
++ If a \l{Qt Quick States}{state change} has a \l Transition that matches the same property as a
++ Behavior, the \l Transition animation overrides the Behavior for that
++ state change. For general advice on using Behaviors to animate state changes, see
++ \l{Using Qt Quick Behaviors with States}.
++
++ \sa {Animation and Transitions in Qt Quick}, {Qt Quick Examples - Animation#Behaviors}{Behavior example}, {Qt Qml}
++ */
++
++
++ QQuickBehavior::QQuickBehavior(QObject *parent)
++ : QObject(*(new QQuickBehaviorPrivate), parent)
++ {
++ }
++
++ QQuickBehavior::~QQuickBehavior()
++ {
++ Q_D(QQuickBehavior);
++ delete d->animationInstance;
++ }
++
++ /*!
++ \qmlproperty Animation QtQuick::Behavior::animation
++ \qmldefault
++
++ This property holds the animation to run when the behavior is triggered.
++ */
++
++ QQuickAbstractAnimation *QQuickBehavior::animation()
++ {
++ Q_D(QQuickBehavior);
++ return d->animation;
++ }
++
++ void QQuickBehavior::setAnimation(QQuickAbstractAnimation *animation)
++ {
++ Q_D(QQuickBehavior);
++ if (d->animation) {
++ qmlWarning(this) << tr("Cannot change the animation assigned to a Behavior.");
++ return;
++ }
++
++ d->animation = animation;
++ if (d->animation) {
++ d->animation->setDefaultTarget(d->property);
++ d->animation->setDisableUserControl();
++ }
++ }
++
++
++ void QQuickBehaviorPrivate::onProxyChanged(QPropertyObserver *observer, QUntypedPropertyData *)
++ {
++ auto This = static_cast<QQuickBehaviorPrivate *>(observer);
++ This->q_func()->write(This->propertyProxy->value());
++ }
++
++ void QQuickBehaviorPrivate::animationStateChanged(QAbstractAnimationJob *, QAbstractAnimationJob::State newState,QAbstractAnimationJob::State)
++ {
++ if (!blockRunningChanged && animation)
++ animation->notifyRunningChanged(newState == QAbstractAnimationJob::Running);
++ }
++
++ /*!
++ \qmlproperty bool QtQuick::Behavior::enabled
++
++ This property holds whether the behavior will be triggered when the tracked
++ property changes value.
++
++ By default a Behavior is enabled.
++ */
++
++ bool QQuickBehavior::enabled() const
++ {
++ Q_D(const QQuickBehavior);
++ return d->enabled;
++ }
++
++ void QQuickBehavior::setEnabled(bool enabled)
++ {
++ Q_D(QQuickBehavior);
++ if (d->enabled == enabled)
++ return;
++ d->enabled = enabled;
++ emit enabledChanged();
++ }
++
++ /*!
++ \qmlproperty Variant QtQuick::Behavior::targetValue
++
++ This property holds the target value of the property being controlled by the Behavior.
++ This value is set by the Behavior before the animation is started.
++
++ \since QtQuick 2.13
++ */
++ QVariant QQuickBehavior::targetValue() const
++ {
++ Q_D(const QQuickBehavior);
++ return d->targetValue;
++ }
++
++ /*!
++ \readonly
++ \qmlpropertygroup QtQuick::Behavior::targetProperty
++ \qmlproperty string QtQuick::Behavior::targetProperty.name
++ \qmlproperty QtObject QtQuick::Behavior::targetProperty.object
++
++ \table
++ \header
++ \li Property
++ \li Description
++ \row
++ \li name
++ \li This property holds the name of the property being controlled by this Behavior.
++ \row
++ \li object
++ \li This property holds the object of the property being controlled by this Behavior.
++ \endtable
++
++ This property can be used to define custom behaviors based on the name or the object of
++ the property being controlled.
++
++ The following example defines a Behavior fading out and fading in its target object
++ when the property it controls changes:
++ \qml
++ // FadeBehavior.qml
++ import QtQuick 2.15
++
++ Behavior {
++ id: root
++ property Item fadeTarget: targetProperty.object
++ SequentialAnimation {
++ NumberAnimation {
++ target: root.fadeTarget
++ property: "opacity"
++ to: 0
++ easing.type: Easing.InQuad
++ }
++ PropertyAction { } // actually change the controlled property between the 2 other animations
++ NumberAnimation {
++ target: root.fadeTarget
++ property: "opacity"
++ to: 1
++ easing.type: Easing.OutQuad
++ }
++ }
++ }
++ \endqml
++
++ This can be used to animate a text when it changes:
++ \qml
++ import QtQuick 2.15
++
++ Text {
++ id: root
++ property int counter
++ text: counter
++ FadeBehavior on text {}
++ Timer {
++ running: true
++ repeat: true
++ interval: 1000
++ onTriggered: ++root.counter
++ }
++ }
++ \endqml
++
++ \since QtQuick 2.15
++ */
++ QQmlProperty QQuickBehavior::targetProperty() const
++ {
++ Q_D(const QQuickBehavior);
++ return d->property;
++ }
++
++ void QQuickBehavior::componentFinalized()
++ {
++ Q_D(QQuickBehavior);
++ d->finalized = true;
++ }
++
++ void QQuickBehavior::write(const QVariant &value)
++ {
++ Q_D(QQuickBehavior);
++ const bool targetValueHasChanged = d->targetValue != value;
++ if (targetValueHasChanged) {
++ d->targetValue = value;
++ emit targetValueChanged(); // emitting the signal here should allow
++ } // d->enabled to change if scripted by the user.
++ bool bypass = !d->enabled || !d->finalized || QQmlEnginePrivate::designerMode();
++ if (!bypass)
++ qmlExecuteDeferred(this);
++ if (QQmlData::wasDeleted(d->animation) || bypass) {
++ if (d->animationInstance)
++ d->animationInstance->stop();
++ QQmlPropertyPrivate::write(d->property, value, QQmlPropertyData::BypassInterceptor | QQmlPropertyData::DontRemoveBinding);
++ return;
++ }
++
++ bool behaviorActive = d->animation->isRunning();
++ if (behaviorActive && !targetValueHasChanged)
++ return;
++
++ if (d->animationInstance
++ && (d->animationInstance->duration() != -1
++ || d->animationInstance->isRenderThreadProxy())
++ && !d->animationInstance->isStopped()) {
++ d->blockRunningChanged = true;
++ d->animationInstance->stop();
++ }
++ // Render thread animations use "stop" to synchronize the property back
++ // to the item, so we need to read the value after.
++ const QVariant ¤tValue = d->property.read();
++
++ // Don't unnecessarily wake up the animation system if no real animation
++ // is needed (value has not changed). If the Behavior was already
++ // running, let it continue as normal to ensure correct behavior and state.
++ if (!behaviorActive && d->targetValue == currentValue) {
++ QQmlPropertyPrivate::write(d->property, value, QQmlPropertyData::BypassInterceptor | QQmlPropertyData::DontRemoveBinding);
++ return;
++ }
++
++ QQuickStateOperation::ActionList actions;
++ QQuickStateAction action;
++ action.property = d->property;
++ action.fromValue = currentValue;
++ action.toValue = value;
++ actions << action;
++
++ QList<QQmlProperty> after;
++ auto *newInstance = d->animation->transition(actions, after, QQuickAbstractAnimation::Forward);
++ Q_ASSERT(!newInstance || newInstance != d->animationInstance);
++ delete d->animationInstance;
++ d->animationInstance = newInstance;
++
++ if (d->animationInstance) {
++ if (d->animation->threadingModel() == QQuickAbstractAnimation::RenderThread)
++ d->animationInstance = new QQuickAnimatorProxyJob(d->animationInstance, d->animation);
++
++ d->animationInstance->addAnimationChangeListener(d, QAbstractAnimationJob::StateChange);
++ d->animationInstance->start();
++ d->blockRunningChanged = false;
++ }
++
++ if (!after.contains(d->property))
++ QQmlPropertyPrivate::write(d->property, value, QQmlPropertyData::BypassInterceptor | QQmlPropertyData::DontRemoveBinding);
++ }
++
++ bool QQuickBehavior::bindable(QUntypedBindable *untypedBindable, QUntypedBindable target)
++ {
++ Q_D(QQuickBehavior);
++ if (!d->propertyProxy)
++ d->propertyProxy = std::make_unique<UntypedProxyProperty>(target, d);
++ *untypedBindable = d->propertyProxy->getBindable();
++ return true;
++ }
++
++ void QQuickBehavior::setTarget(const QQmlProperty &property)
++ {
++ Q_D(QQuickBehavior);
++ d->property = property;
++ if (d->animation)
++ d->animation->setDefaultTarget(property);
++
++ if (QMetaProperty metaProp = property.property(); metaProp.isBindable()) {
++ QUntypedBindable untypedBindable = metaProp.bindable(property.object());
++ d->propertyProxy = std::make_unique<UntypedProxyProperty>(untypedBindable, d);
++ if (untypedBindable.hasBinding()) {
++ // should not happen as bindings should get initialized only after interceptors
++ UntypedProxyProperty::bindingSetter(d->propertyProxy.get(), untypedBindable.takeBinding());
++ }
++ }
++
++ Q_EMIT targetPropertyChanged();
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qquickbehavior_p.cpp"