qqmlexpression.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 "qqmlexpression.h"
#include "qqmlexpression_p.h"
 
#include "qqmlengine_p.h"
#include "qqmlscriptstring_p.h"
#include "qqmlbinding_p.h"
#include <private/qqmlsourcecoordinate_p.h>
#include <private/qv4qmlcontext_p.h>
 
#include <QtCore/qdebug.h>
 
QT_BEGIN_NAMESPACE
 
QQmlExpressionPrivate::QQmlExpressionPrivate()
: QQmlJavaScriptExpression(),
  expressionFunctionValid(true),
  line(0), column(0)
{
}
 
QQmlExpressionPrivate::~QQmlExpressionPrivate()
{
}
 
void QQmlExpressionPrivate::init(const QQmlRefPointer<QQmlContextData> &ctxt, const QString &expr,
                                 QObject *me)
{
    expression = expr;
 
    QQmlJavaScriptExpression::setContext(ctxt);
    setScopeObject(me);
    expressionFunctionValid = false;
}
 
void QQmlExpressionPrivate::init(const QQmlRefPointer<QQmlContextData> &ctxt,
                                 QV4::Function *runtimeFunction, QObject *me)
{
    expressionFunctionValid = true;
    QV4::ExecutionEngine *engine = ctxt->engine()->handle();
    QV4::Scope scope(engine);
    QV4::Scoped<QV4::QmlContext> qmlContext(scope, QV4::QmlContext::create(engine->rootContext(), ctxt, me));
    setupFunction(qmlContext, runtimeFunction);
 
    QQmlJavaScriptExpression::setContext(ctxt);
    setScopeObject(me);
}
 
QQmlExpression::QQmlExpression()
: QObject(*new QQmlExpressionPrivate, nullptr)
{
}
 
QQmlExpression::QQmlExpression(const QQmlScriptString &script, QQmlContext *ctxt, QObject *scope, QObject *parent)
: QObject(*new QQmlExpressionPrivate, parent)
{
    Q_D(QQmlExpression);
    if (ctxt && !ctxt->isValid())
        return;
 
    const QQmlScriptStringPrivate *scriptPrivate = script.d.data();
    if (!scriptPrivate) {
        // A null QQmlScriptStringPrivate is an empty expression without context.
        // We may still want the explicitly passed context, though.
        if (ctxt)
            d->init(QQmlContextData::get(ctxt), QString(), scope);
        return;
    }
 
    if (!ctxt && (!scriptPrivate->context || !scriptPrivate->context->isValid()))
        return;
 
    QQmlRefPointer<QQmlContextData> evalCtxtData
            = QQmlContextData::get(ctxt ? ctxt : scriptPrivate->context);
    QObject *scopeObject = scope ? scope : scriptPrivate->scope;
    QV4::Function *runtimeFunction = nullptr;
 
    if (scriptPrivate->context) {
        QQmlRefPointer<QQmlContextData> ctxtdata = QQmlContextData::get(scriptPrivate->context);
        QQmlEnginePrivate *engine = QQmlEnginePrivate::get(scriptPrivate->context->engine());
        if (engine
                && ctxtdata
                && !ctxtdata->urlString().isEmpty()
                && ctxtdata->typeCompilationUnit()) {
            d->url = ctxtdata->urlString();
            d->line = scriptPrivate->lineNumber;
            d->column = scriptPrivate->columnNumber;
 
            if (scriptPrivate->bindingId != QQmlBinding::Invalid)
                runtimeFunction = ctxtdata->typeCompilationUnit()->runtimeFunctions.at(scriptPrivate->bindingId);
        }
    }
 
    if (runtimeFunction) {
        d->expression = scriptPrivate->script;
        d->init(evalCtxtData, runtimeFunction, scopeObject);
    } else
        d->init(evalCtxtData, scriptPrivate->script, scopeObject);
}
 
QQmlExpression::QQmlExpression(QQmlContext *ctxt, QObject *scope, const QString &expression,
                               QObject *parent)
: QObject(*new QQmlExpressionPrivate, parent)
{
    Q_D(QQmlExpression);
    d->init(QQmlContextData::get(ctxt), expression, scope);
}
 
QQmlExpression::QQmlExpression(QQmlExpressionPrivate &dd, QObject *parent) : QObject(dd, parent)
{
//    Q_D(QQmlExpression);
//    d->init(QQmlContextData::get(ctxt), expression, scope);
}
 
QQmlExpression::~QQmlExpression()
{
}
 
QQmlEngine *QQmlExpression::engine() const
{
    Q_D(const QQmlExpression);
    return d->engine();
}
 
QQmlContext *QQmlExpression::context() const
{
    Q_D(const QQmlExpression);
    return d->publicContext();
}
 
QString QQmlExpression::expression() const
{
    Q_D(const QQmlExpression);
    return d->expression;
}
 
void QQmlExpression::setExpression(const QString &expression)
{
    Q_D(QQmlExpression);
 
    d->resetNotifyOnValueChanged();
    d->expression = expression;
    d->expressionFunctionValid = false;
}
 
// Must be called with a valid handle scope
QV4::ReturnedValue QQmlExpressionPrivate::v4value(bool *isUndefined)
{
    if (!expressionFunctionValid) {
        createQmlBinding(context(), scopeObject(), expression, url, line);
        expressionFunctionValid = true;
        if (hasError()) {
            if (isUndefined)
                *isUndefined = true;
            return QV4::Encode::undefined();
        }
    }
 
    return evaluate(isUndefined);
}
 
QVariant QQmlExpressionPrivate::value(bool *isUndefined)
{
    Q_Q(QQmlExpression);
 
    if (!hasValidContext()) {
        qWarning("QQmlExpression: Attempted to evaluate an expression in an invalid context");
        return QVariant();
    }
 
    QQmlEngine *engine = q->engine();
    QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine);
    QVariant rv;
 
    ep->referenceScarceResources(); // "hold" scarce resources in memory during evaluation.
 
    {
        QV4::Scope scope(engine->handle());
        QV4::ScopedValue result(scope, v4value(isUndefined));
        if (!hasError())
            rv = QV4::ExecutionEngine::toVariant(result, QMetaType {});
    }
 
    ep->dereferenceScarceResources(); // "release" scarce resources if top-level expression evaluation is complete.
 
    return rv;
}
 
QVariant QQmlExpression::evaluate(bool *valueIsUndefined)
{
    Q_D(QQmlExpression);
    return d->value(valueIsUndefined);
}
 
bool QQmlExpression::notifyOnValueChanged() const
{
    Q_D(const QQmlExpression);
    return d->notifyOnValueChanged();
}
 
void QQmlExpression::setNotifyOnValueChanged(bool notifyOnChange)
{
    Q_D(QQmlExpression);
    d->setNotifyOnValueChanged(notifyOnChange);
}
 
QString QQmlExpression::sourceFile() const
{
    Q_D(const QQmlExpression);
    return d->url;
}
 
int QQmlExpression::lineNumber() const
{
    Q_D(const QQmlExpression);
    return qmlConvertSourceCoordinate<quint16, int>(d->line);
}
 
int QQmlExpression::columnNumber() const
{
    Q_D(const QQmlExpression);
    return qmlConvertSourceCoordinate<quint16, int>(d->column);
}
 
void QQmlExpression::setSourceLocation(const QString &url, int line, int column)
{
    Q_D(QQmlExpression);
    d->url = url;
    d->line = qmlConvertSourceCoordinate<int, quint16>(line);
    d->column = qmlConvertSourceCoordinate<int, quint16>(column);
}
 
QObject *QQmlExpression::scopeObject() const
{
    Q_D(const QQmlExpression);
    return d->scopeObject();
}
 
bool QQmlExpression::hasError() const
{
    Q_D(const QQmlExpression);
    return d->hasError();
}
 
void QQmlExpression::clearError()
{
    Q_D(QQmlExpression);
    d->clearError();
}
 
QQmlError QQmlExpression::error() const
{
    Q_D(const QQmlExpression);
    return d->error(engine());
}
 
void QQmlExpressionPrivate::expressionChanged()
{
    Q_Q(QQmlExpression);
    emit q->valueChanged();
}
 
QString QQmlExpressionPrivate::expressionIdentifier() const
{
    return QLatin1Char('"') + expression + QLatin1Char('"');
}
 
QT_END_NAMESPACE
 
#include <moc_qqmlexpression.cpp>