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 "qquickpropertychanges_p.h"
++
++ #include <private/qqmlopenmetaobject_p.h>
++ #include <private/qqmlengine_p.h>
++
++ #include <qqmlinfo.h>
++ #include <private/qqmlcustomparser_p.h>
++ #include <qqmlexpression.h>
++ #include <private/qqmlbinding_p.h>
++ #include <qqmlcontext.h>
++ #include <private/qqmlproperty_p.h>
++ #include <private/qqmlcontext_p.h>
++ #include <private/qquickstate_p_p.h>
++ #include <private/qqmlboundsignal_p.h>
++ #include <private/qv4qmlcontext_p.h>
++ #include <private/qqmlpropertybinding_p.h>
++ #include <private/qqmlirbuilder_p.h>
++
++ #include <QtCore/qdebug.h>
++ #include <QtQml/private/qqmlsignalnames_p.h>
++
++ #include <private/qobject_p.h>
++ #include <QtCore/qpointer.h>
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \qmltype PropertyChanges
++ \inqmlmodule QtQuick
++ \ingroup qtquick-states
++ \brief Describes new property bindings or values for a state.
++
++ PropertyChanges is used to define the property values or bindings in a
++ \l State. This enables an item's property values to be changed when it
++ \l {Qt Quick States}{changes between states}.
++
++ To create a PropertyChanges object, bind to properties of the target
++ item like you would bind to local properties. This way you can define
++ the new property values or bindings. For example:
++
++ \snippet qml/propertychanges.qml import
++ \codeline
++ \snippet qml/propertychanges.qml 0
++
++ When the mouse is pressed, the \l Rectangle changes to the \e resized
++ state. In this state, the PropertyChanges object sets the rectangle's
++ color to blue and the \c height value to that of \c container.height.
++
++ Note this automatically binds \c rect.height to \c container.height
++ in the \e resized state. If a property binding should not be
++ established, and the height should just be set to the value of
++ \c container.height at the time of the state change, set the \l explicit
++ property to \c true.
++
++ A PropertyChanges object can also override the default signal handler
++ for an object to implement a signal handler specific to the new state:
++
++ \qml
++ PropertyChanges {
++ myMouseArea.onClicked: doSomethingDifferent()
++ }
++ \endqml
++
++ \note PropertyChanges can be used to change anchor margins, but not other anchor
++ values; use AnchorChanges for this instead. Similarly, to change an \l Item's
++ \l {Item::}{parent} value, use ParentChange instead.
++
++
++ \section2 Resetting Property Values
++
++ The \c undefined value can be used to reset the property value for a state.
++ In the following example, when \c myText changes to the \e widerText
++ state, its \c width property is reset, giving the text its natural width
++ and displaying the whole string on a single line.
++
++ \snippet qml/propertychanges.qml reset
++
++
++ \section2 Immediate Property Changes in Transitions
++
++ When \l{Animation and Transitions in Qt Quick}{Transitions} are used to animate
++ state changes, they animate properties from their values in the current
++ state to those defined in the new state (as defined by PropertyChanges
++ objects). However, it is sometimes desirable to set a property value
++ \e immediately during a \l Transition, without animation; in these cases,
++ the PropertyAction type can be used to force an immediate property
++ change.
++
++ See the PropertyAction documentation for more details.
++
++ \note The \l{Item::}{visible} and \l{Item::}{enabled} properties of \l Item do not behave
++ exactly the same as other properties in PropertyChanges. Since these properties can be
++ changed implicitly through their parent's state, they should be set explicitly in all PropertyChanges.
++ An item will still not be enabled/visible if one of its parents is not enabled or visible.
++
++ \note For backwards compatibility with Qt 5, you can also specify PropertyChanges using
++ the \l target property and plain property names without IDs. For example:
++ \c {PropertyChanges { target: myItem; x: 15 }}. The form with ID instead of \l target
++ is recommended. You may also need to use the form with \l target if the file is to be
++ edited with \l{Qt Design Studio}. Mind that \l{Qt Design Studio} also imposes a number
++ of further restrictions on the files it can work with.
++
++ \sa {Qt Quick Examples - Animation#States}{States example}, {Qt Quick States}, {Qt Qml}
++ */
++
++ /*!
++ \qmlproperty QtObject QtQuick::PropertyChanges::target
++ This property holds the object which contains the properties to be changed.
++
++ \note You generally don't have to use this property. It only exists for
++ compatibility with Qt 5 and for compatibility with \l{Qt Design Studio}.
++ */
++
++ class QQuickReplaceSignalHandler : public QQuickStateActionEvent
++ {
++ public:
++ QQuickReplaceSignalHandler() {}
++ ~QQuickReplaceSignalHandler() {}
++
++ EventType type() const override { return SignalHandler; }
++
++ QQmlProperty property;
++ QQmlRefPointer<QQmlBoundSignalExpression> expression;
++ QQmlRefPointer<QQmlBoundSignalExpression> reverseExpression;
++ QQmlRefPointer<QQmlBoundSignalExpression> rewindExpression;
++
++ void execute() override {
++ QQmlPropertyPrivate::setSignalExpression(property, expression.data());
++ }
++
++ bool isReversable() override { return true; }
++ void reverse() override {
++ QQmlPropertyPrivate::setSignalExpression(property, reverseExpression.data());
++ }
++
++ void saveOriginals() override {
++ saveCurrentValues();
++ reverseExpression = rewindExpression;
++ }
++
++ bool needsCopy() override { return true; }
++ void copyOriginals(QQuickStateActionEvent *other) override
++ {
++ QQuickReplaceSignalHandler *rsh = static_cast<QQuickReplaceSignalHandler*>(other);
++ saveCurrentValues();
++ if (rsh == this)
++ return;
++ reverseExpression = rsh->reverseExpression;
++ }
++
++ void rewind() override {
++ QQmlPropertyPrivate::setSignalExpression(property, rewindExpression.data());
++ }
++ void saveCurrentValues() override {
++ rewindExpression = QQmlPropertyPrivate::signalExpression(property);
++ }
++
++ bool mayOverride(QQuickStateActionEvent *other) override {
++ if (other == this)
++ return true;
++ if (other->type() != type())
++ return false;
++ if (static_cast<QQuickReplaceSignalHandler*>(other)->property == property)
++ return true;
++ return false;
++ }
++ };
++
++
++ class QQuickPropertyChangesPrivate : public QQuickStateOperationPrivate
++ {
++ Q_DECLARE_PUBLIC(QQuickPropertyChanges)
++ public:
++ QQuickPropertyChangesPrivate() : decoded(true), restore(true),
++ isExplicit(false) {}
++
++ QPointer<QObject> object;
++ QList<const QV4::CompiledData::Binding *> bindings;
++ QQmlRefPointer<QV4::ExecutableCompilationUnit> compilationUnit;
++
++ bool decoded : 1;
++ bool restore : 1;
++ bool isExplicit : 1;
++
++ void decode();
++ void decodeBinding(const QString &propertyPrefix, const QQmlRefPointer<QV4::ExecutableCompilationUnit> &qmlUnit, const QV4::CompiledData::Binding *binding);
++
++ class ExpressionChange {
++ public:
++ ExpressionChange(const QString &_name,
++ const QV4::CompiledData::Binding *_binding,
++ QQmlBinding::Identifier _id,
++ const QString& _expr,
++ const QUrl &_url,
++ int _line,
++ int _column)
++ : name(_name), binding(_binding), id(_id), expression(_expr), url(_url), line(_line), column(_column) {}
++ QString name;
++ const QV4::CompiledData::Binding *binding;
++ QQmlBinding::Identifier id;
++ QString expression;
++ QUrl url;
++ int line;
++ int column;
++ };
++
++ QList<std::pair<QString, QVariant> > properties;
++ QList<ExpressionChange> expressions;
++ QList<QQuickReplaceSignalHandler*> signalReplacements;
++
++ QQmlProperty property(const QString &);
++ };
++
++ void QQuickPropertyChangesParser::verifyList(
++ const QQmlRefPointer<QV4::CompiledData::CompilationUnit> &compilationUnit,
++ const QV4::CompiledData::Binding *binding)
++ {
++ switch (binding->type()) {
++ case QV4::CompiledData::Binding::Type_Object:
++ error(compilationUnit->objectAt(binding->value.objectIndex),
++ QQuickPropertyChanges::tr(
++ "PropertyChanges does not support creating state-specific objects."));
++ break;
++ case QV4::CompiledData::Binding::Type_GroupedProperty:
++ case QV4::CompiledData::Binding::Type_AttachedProperty: {
++ const QV4::CompiledData::Object *subObj = compilationUnit->objectAt(binding->value.objectIndex);
++ const QV4::CompiledData::Binding *subBinding = subObj->bindingTable();
++ for (quint32 i = 0; i < subObj->nBindings; ++i, ++subBinding)
++ verifyList(compilationUnit, subBinding);
++ break;
++ }
++ default:
++ break;
++ }
++ }
++
++ void QQuickPropertyChangesPrivate::decode()
++ {
++ if (decoded)
++ return;
++
++ for (const QV4::CompiledData::Binding *binding : std::as_const(bindings))
++ decodeBinding(QString(), compilationUnit, binding);
++
++ bindings.clear();
++
++ decoded = true;
++ }
++
++ void QQuickPropertyChangesPrivate::decodeBinding(const QString &propertyPrefix, const QQmlRefPointer<QV4::ExecutableCompilationUnit> &compilationUnit, const QV4::CompiledData::Binding *binding)
++ {
++ Q_Q(QQuickPropertyChanges);
++
++ QString propertyName = propertyPrefix + compilationUnit->stringAt(binding->propertyNameIndex);
++
++ switch (binding->type()) {
++ case QV4::CompiledData::Binding::Type_GroupedProperty:
++ case QV4::CompiledData::Binding::Type_AttachedProperty: {
++ QString pre = propertyName + QLatin1Char('.');
++ const QV4::CompiledData::Object *subObj = compilationUnit->objectAt(binding->value.objectIndex);
++ const QV4::CompiledData::Binding *subBinding = subObj->bindingTable();
++ for (quint32 i = 0; i < subObj->nBindings; ++i, ++subBinding) {
++ decodeBinding(pre, compilationUnit, subBinding);
++ }
++ return;
++ }
++ default:
++ break;
++ }
++
++ if (QQmlSignalNames::isHandlerName(compilationUnit->stringAt(binding->propertyNameIndex))) {
++ QQmlProperty prop = property(propertyName);
++ if (prop.isSignalProperty()) {
++ QQuickReplaceSignalHandler *handler = new QQuickReplaceSignalHandler;
++ handler->property = prop;
++ handler->expression.adopt(
++ new QQmlBoundSignalExpression(
++ prop.object(), QQmlPropertyPrivate::get(prop)->signalIndex(),
++ QQmlContextData::get(qmlContext(q)), prop.object(),
++ compilationUnit->runtimeFunctions.at(binding->value.compiledScriptIndex)));
++ signalReplacements << handler;
++ return;
++ }
++ }
++
++ if (binding->type() == QV4::CompiledData::Binding::Type_Script
++ || binding->isTranslationBinding()) {
++ QUrl url = QUrl();
++ int line = -1;
++ int column = -1;
++
++ QQmlData *ddata = QQmlData::get(q);
++ if (ddata && ddata->outerContext && !ddata->outerContext->url().isEmpty()) {
++ url = ddata->outerContext->url();
++ line = ddata->lineNumber;
++ column = ddata->columnNumber;
++ }
++
++ QString expression;
++ QQmlBinding::Identifier id = QQmlBinding::Invalid;
++
++ if (!binding->isTranslationBinding()) {
++ expression = compilationUnit->bindingValueAsString(binding);
++ id = binding->value.compiledScriptIndex;
++ }
++ expressions << ExpressionChange(propertyName, binding, id, expression, url, line, column);
++ return;
++ }
++
++ QVariant var;
++ switch (binding->type()) {
++ case QV4::CompiledData::Binding::Type_Script:
++ case QV4::CompiledData::Binding::Type_Translation:
++ case QV4::CompiledData::Binding::Type_TranslationById:
++ Q_UNREACHABLE();
++ case QV4::CompiledData::Binding::Type_String:
++ var = compilationUnit->bindingValueAsString(binding);
++ break;
++ case QV4::CompiledData::Binding::Type_Number:
++ var = compilationUnit->bindingValueAsNumber(binding);
++ break;
++ case QV4::CompiledData::Binding::Type_Boolean:
++ var = binding->valueAsBoolean();
++ break;
++ case QV4::CompiledData::Binding::Type_Null:
++ var = QVariant::fromValue(nullptr);
++ break;
++ default:
++ break;
++ }
++
++ properties << std::make_pair(propertyName, var);
++ }
++
++ void QQuickPropertyChangesParser::verifyBindings(
++ const QQmlRefPointer<QV4::CompiledData::CompilationUnit> &compilationUnit,
++ const QList<const QV4::CompiledData::Binding *> &props)
++ {
++ for (int ii = 0; ii < props.size(); ++ii)
++ verifyList(compilationUnit, props.at(ii));
++ }
++
++ void QQuickPropertyChangesParser::applyBindings(
++ QObject *obj, const QQmlRefPointer<QV4::ExecutableCompilationUnit> &compilationUnit,
++ const QList<const QV4::CompiledData::Binding *> &bindings)
++ {
++ QQuickPropertyChangesPrivate *p =
++ static_cast<QQuickPropertyChangesPrivate *>(QObjectPrivate::get(obj));
++ p->bindings = bindings;
++ p->compilationUnit = compilationUnit;
++ p->decoded = false;
++
++ QQmlData *data = QQmlData::get(obj);
++ Q_ASSERT(data && !data->wasDeleted(obj));
++ data->releaseDeferredData();
++ }
++
++ QQuickPropertyChanges::QQuickPropertyChanges()
++ : QQuickStateOperation(*(new QQuickPropertyChangesPrivate))
++ {
++ }
++
++ QQuickPropertyChanges::~QQuickPropertyChanges()
++ {
++ Q_D(QQuickPropertyChanges);
++ for(int ii = 0; ii < d->signalReplacements.size(); ++ii)
++ delete d->signalReplacements.at(ii);
++ }
++
++ QObject *QQuickPropertyChanges::object() const
++ {
++ Q_D(const QQuickPropertyChanges);
++ return d->object;
++ }
++
++ void QQuickPropertyChanges::setObject(QObject *o)
++ {
++ Q_D(QQuickPropertyChanges);
++ if (o != d->object) {
++ d->object = o;
++ emit objectChanged();
++ }
++ }
++
++ /*!
++ \qmlproperty bool QtQuick::PropertyChanges::restoreEntryValues
++
++ This property holds whether the previous values should be restored when
++ leaving the state.
++
++ The default value is \c true. Setting this value to \c false creates a
++ temporary state that has permanent effects on property values.
++ */
++ bool QQuickPropertyChanges::restoreEntryValues() const
++ {
++ Q_D(const QQuickPropertyChanges);
++ return d->restore;
++ }
++
++ void QQuickPropertyChanges::setRestoreEntryValues(bool v)
++ {
++ Q_D(QQuickPropertyChanges);
++ if (v != d->restore) {
++ d->restore = v;
++ emit restoreEntryValuesChanged();
++ }
++ }
++
++ QQmlProperty
++ QQuickPropertyChangesPrivate::property(const QString &property)
++ {
++ Q_Q(QQuickPropertyChanges);
++ QQmlData *ddata = QQmlData::get(q);
++ QQmlProperty prop = QQmlPropertyPrivate::create(
++ object, property, ddata ? ddata->outerContext : QQmlRefPointer<QQmlContextData>(),
++ QQmlPropertyPrivate::InitFlag::AllowId | QQmlPropertyPrivate::InitFlag::AllowSignal);
++ if (!prop.isValid()) {
++ qmlWarning(q) << QQuickPropertyChanges::tr("Cannot assign to non-existent property \"%1\"").arg(property);
++ return QQmlProperty();
++ } else if (!(prop.type() & QQmlProperty::SignalProperty) && !prop.isWritable()) {
++ qmlWarning(q) << QQuickPropertyChanges::tr("Cannot assign to read-only property \"%1\"").arg(property);
++ return QQmlProperty();
++ }
++ return prop;
++ }
++
++ QQuickPropertyChanges::ActionList QQuickPropertyChanges::actions()
++ {
++ Q_D(QQuickPropertyChanges);
++
++ d->decode();
++
++ ActionList list;
++
++ for (int ii = 0; ii < d->properties.size(); ++ii) {
++ QQmlProperty prop = d->property(d->properties.at(ii).first);
++
++ QQuickStateAction a(d->object, prop, d->properties.at(ii).first,
++ d->properties.at(ii).second);
++
++ if (a.property.isValid()) {
++ a.restore = restoreEntryValues();
++ list << a;
++ }
++ }
++
++ for (int ii = 0; ii < d->signalReplacements.size(); ++ii) {
++ QQuickReplaceSignalHandler *handler = d->signalReplacements.at(ii);
++
++ if (handler->property.isValid()) {
++ QQuickStateAction a;
++ a.event = handler;
++ list << a;
++ }
++ }
++
++ for (int ii = 0; ii < d->expressions.size(); ++ii) {
++
++ QQuickPropertyChangesPrivate::ExpressionChange e = d->expressions.at(ii);
++ const QString &property = e.name;
++ QQmlProperty prop = d->property(property);
++
++ if (prop.isValid()) {
++ QQuickStateAction a;
++ a.restore = restoreEntryValues();
++ a.property = prop;
++ a.fromValue = a.property.read();
++ a.specifiedObject = d->object;
++ a.specifiedProperty = property;
++
++ QQmlRefPointer<QQmlContextData> context = QQmlContextData::get(qmlContext(this));
++ QV4::Scope scope(qmlEngine(this)->handle());
++ QV4::Scoped<QV4::QmlContext> qmlCtxt(scope, QV4::QmlContext::create(scope.engine->rootContext(), context, object()));
++
++ if (d->isExplicit) {
++ // in this case, we don't want to assign a binding, per se,
++ // so we evaluate the expression and assign the result.
++ // XXX TODO: add a static QQmlJavaScriptExpression::evaluate(QString)
++ // so that we can avoid creating then destroying the binding in this case.
++ std::unique_ptr<QQmlBinding> newBinding = nullptr;
++ if (e.binding && e.binding->isTranslationBinding()) {
++ newBinding.reset(QQmlBinding::createTranslationBinding(d->compilationUnit, e.binding, object(), context));
++ } else if (e.id != QQmlBinding::Invalid) {
++ newBinding.reset(QQmlBinding::create(&QQmlPropertyPrivate::get(prop)->core, d->compilationUnit->runtimeFunctions.at(e.id), object(), context, qmlCtxt));
++ } else {
++ newBinding.reset(QQmlBinding::create(&QQmlPropertyPrivate::get(prop)->core, e.expression, object(), context, e.url.toString(), e.line));
++ }
++ a.toValue = newBinding->evaluate();
++ } else {
++ QQmlAnyBinding newBinding = nullptr;
++ if (e.binding && e.binding->isTranslationBinding()) {
++ newBinding = QQmlAnyBinding::createTranslationBinding(prop, d->compilationUnit, e.binding, object(), context);
++ } else if (e.id != QQmlBinding::Invalid) {
++ newBinding = QQmlAnyBinding::createFromFunction(prop,
++ d->compilationUnit->runtimeFunctions.at(e.id),
++ object(), context, qmlCtxt);
++ } else {
++ newBinding = QQmlAnyBinding::createFromCodeString(prop, e.expression, object(), context, e.url.toString(), e.line);
++ }
++
++ a.toBinding = newBinding;
++ a.deletableToBinding = true;
++ }
++
++ list << a;
++ }
++ }
++
++ return list;
++ }
++
++ /*!
++ \qmlproperty bool QtQuick::PropertyChanges::explicit
++
++ If explicit is set to true, bindings will be interpreted as assignments.
++ The expression will only be evaluated once, and no updates happen, even if
++ dependencies change.
++
++ In the following example, the addition of explicit prevents \c myItem.width from
++ being bound to \c parent.width. Instead, it is assigned the value of \c parent.width
++ at the time of the state change.
++ \qml
++ PropertyChanges {
++ target: myItem
++ explicit: true
++ width: parent.width
++ }
++ \endqml
++
++ By default, explicit is false.
++ */
++ bool QQuickPropertyChanges::isExplicit() const
++ {
++ Q_D(const QQuickPropertyChanges);
++ return d->isExplicit;
++ }
++
++ void QQuickPropertyChanges::setIsExplicit(bool e)
++ {
++ Q_D(QQuickPropertyChanges);
++ if (e != d->isExplicit) {
++ d->isExplicit = e;
++ emit isExplicitChanged();
++ }
++ }
++
++ bool QQuickPropertyChanges::containsValue(const QString &name) const
++ {
++ Q_D(const QQuickPropertyChanges);
++ typedef std::pair<QString, QVariant> PropertyEntry;
++
++ for (const PropertyEntry &entry : d->properties) {
++ if (entry.first == name) {
++ return true;
++ }
++ }
++
++ return false;
++ }
++
++ bool QQuickPropertyChanges::containsExpression(const QString &name) const
++ {
++ Q_D(const QQuickPropertyChanges);
++ typedef QQuickPropertyChangesPrivate::ExpressionChange ExpressionEntry;
++
++ for (const ExpressionEntry &entry : d->expressions) {
++ if (entry.name == name) {
++ return true;
++ }
++ }
++
++ return false;
++ }
++
++ bool QQuickPropertyChanges::containsProperty(const QString &name) const
++ {
++ return containsValue(name) || containsExpression(name);
++ }
++
++ void QQuickPropertyChanges::changeValue(const QString &name, const QVariant &value)
++ {
++ Q_D(QQuickPropertyChanges);
++ typedef std::pair<QString, QVariant> PropertyEntry;
++
++ for (auto it = d->expressions.begin(), end = d->expressions.end(); it != end; ++it) {
++ if (it->name == name) {
++ d->expressions.erase(it);
++ if (state() && state()->isStateActive()) {
++ QQmlPropertyPrivate::removeBinding(d->property(name));
++ d->property(name).write(value);
++ }
++
++ d->properties.append(PropertyEntry(name, value));
++ return;
++ }
++ }
++
++ for (auto it = d->properties.begin(), end = d->properties.end(); it != end; ++it) {
++ if (it->first == name) {
++ it->second = value;
++ if (state() && state()->isStateActive())
++ d->property(name).write(value);
++ return;
++ }
++ }
++
++ QQuickStateAction action;
++ action.restore = restoreEntryValues();
++ action.property = d->property(name);
++ action.fromValue = action.property.read();
++ action.specifiedObject = object();
++ action.specifiedProperty = name;
++ action.toValue = value;
++
++ d->properties.append(PropertyEntry(name, value));
++ if (state() && state()->isStateActive()) {
++ state()->addEntryToRevertList(action);
++ QQmlAbstractBinding *oldBinding = QQmlPropertyPrivate::binding(action.property);
++ if (oldBinding)
++ oldBinding->setEnabled(false, QQmlPropertyData::DontRemoveBinding | QQmlPropertyData::BypassInterceptor);
++ d->property(name).write(value);
++ }
++ }
++
++ void QQuickPropertyChanges::changeExpression(const QString &name, const QString &expression)
++ {
++ Q_D(QQuickPropertyChanges);
++ typedef QQuickPropertyChangesPrivate::ExpressionChange ExpressionEntry;
++
++ bool hadValue = false;
++
++ for (auto it = d->properties.begin(), end = d->properties.end(); it != end; ++it) {
++ if (it->first == name) {
++ d->properties.erase(it);
++ hadValue = true;
++ break;
++ }
++ }
++
++ for (auto it = d->expressions.begin(), end = d->expressions.end(); it != end; ++it) {
++ if (it->name == name) {
++ it->expression = expression;
++ if (state() && state()->isStateActive()) {
++ auto prop = d->property(name);
++ auto context = QQmlContextData::get(qmlContext(this));
++ QString url;
++ int lineNumber = 0;
++ QQmlAnyBinding::createFromCodeString(prop, expression, object(), context, url, lineNumber).installOn(prop);
++ }
++ return;
++ }
++ }
++
++ // adding a new expression.
++ d->expressions.append(ExpressionEntry(name, nullptr, QQmlBinding::Invalid, expression, QUrl(), -1, -1));
++
++ const QString url;
++ const quint16 lineNumber = 0;
++ if (state() && state()->isStateActive()) {
++ if (hadValue) {
++ auto prop = d->property(name);
++ QQmlAnyBinding oldBinding = QQmlAnyBinding::takeFrom(prop);
++ if (oldBinding)
++ state()->changeBindingInRevertList(object(), name, oldBinding);
++
++ QQmlAnyBinding::createFromCodeString(prop, expression, object(), QQmlContextData::get(qmlContext(this)), url, lineNumber).installOn(prop);
++ } else {
++ QQuickStateAction action;
++ action.restore = restoreEntryValues();
++ action.property = d->property(name);
++ action.fromValue = action.property.read();
++ action.specifiedObject = object();
++ action.specifiedProperty = name;
++
++ QQmlAnyBinding newBinding;
++ if (d->isExplicit) {
++ newBinding = QQmlBinding::create(
++ &QQmlPropertyPrivate::get(action.property)->core, expression,
++ object(), QQmlContextData::get(qmlContext(this)));
++ } else {
++ const auto prop = action.property;
++ const auto context = QQmlContextData::get(qmlContext(this));
++ newBinding = QQmlAnyBinding::createFromCodeString(prop, expression, object(), context, url, lineNumber);
++ }
++ if (d->isExplicit) {
++ // don't assign the binding, merely evaluate the expression.
++ // XXX TODO: add a static QQmlJavaScriptExpression::evaluate(QString)
++ // so that we can avoid creating then destroying the binding in this case.
++ action.toValue = static_cast<QQmlBinding *>(newBinding.asAbstractBinding())->evaluate();
++ } else {
++ // TODO: replace binding would be more efficient for new-style properties
++ QQmlAnyBinding::removeBindingFrom(action.property);
++ newBinding.installOn(action.property);
++ action.toBinding = newBinding;
++ action.deletableToBinding = true;
++ state()->addEntryToRevertList(action);
++ }
++ }
++ }
++ // what about the signal handler?
++ }
++
++ QVariant QQuickPropertyChanges::property(const QString &name) const
++ {
++ Q_D(const QQuickPropertyChanges);
++ typedef std::pair<QString, QVariant> PropertyEntry;
++ typedef QQuickPropertyChangesPrivate::ExpressionChange ExpressionEntry;
++
++ for (const PropertyEntry &entry : d->properties) {
++ if (entry.first == name) {
++ return entry.second;
++ }
++ }
++
++ for (const ExpressionEntry &entry : d->expressions) {
++ if (entry.name == name) {
++ return QVariant(entry.expression);
++ }
++ }
++
++ return QVariant();
++ }
++
++ void QQuickPropertyChanges::removeProperty(const QString &name)
++ {
++ Q_D(QQuickPropertyChanges);
++
++ for (auto it = d->expressions.begin(), end = d->expressions.end(); it != end; ++it) {
++ if (it->name == name) {
++ d->expressions.erase(it);
++ state()->removeEntryFromRevertList(object(), name);
++ return;
++ }
++ }
++
++ for (auto it = d->properties.begin(), end = d->properties.end(); it != end; ++it) {
++ if (it->first == name) {
++ d->properties.erase(it);
++ state()->removeEntryFromRevertList(object(), name);
++ return;
++ }
++ }
++ }
++
++ QVariant QQuickPropertyChanges::value(const QString &name) const
++ {
++ Q_D(const QQuickPropertyChanges);
++ typedef std::pair<QString, QVariant> PropertyEntry;
++
++ for (const PropertyEntry &entry : d->properties) {
++ if (entry.first == name) {
++ return entry.second;
++ }
++ }
++
++ return QVariant();
++ }
++
++ QString QQuickPropertyChanges::expression(const QString &name) const
++ {
++ Q_D(const QQuickPropertyChanges);
++ typedef QQuickPropertyChangesPrivate::ExpressionChange ExpressionEntry;
++
++ for (const ExpressionEntry &entry : d->expressions) {
++ if (entry.name == name) {
++ return entry.expression;
++ }
++ }
++
++ return QString();
++ }
++
++ void QQuickPropertyChanges::detachFromState()
++ {
++ if (state())
++ state()->removeAllEntriesFromRevertList(object());
++ }
++
++ void QQuickPropertyChanges::attachToState()
++ {
++ if (state())
++ state()->addEntriesToRevertList(actions());
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qquickpropertychanges_p.cpp"