qquickpropertychanges.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 "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 <private/qobject_p.h>
 
QT_BEGIN_NAMESPACE
 
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<QPair<QString, QVariant> > properties;
    QList<ExpressionChange> expressions;
    QList<QQuickReplaceSignalHandler*> signalReplacements;
 
    QQmlProperty property(const QString &);
};
 
void QQuickPropertyChangesParser::verifyList(const QQmlRefPointer<QV4::ExecutableCompilationUnit> &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_GroupProperty:
    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_GroupProperty:
    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 (binding->isSignalHandler() || QmlIR::IRBuilder::isSignalPropertyName(propertyName)) {
        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 << qMakePair(propertyName, var);
}
 
void QQuickPropertyChangesParser::verifyBindings(const QQmlRefPointer<QV4::ExecutableCompilationUnit> &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();
    }
}
 
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;
}
 
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 QPair<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 QPair<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 QPair<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 QPair<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"