for (int ii = 0; ii < record.count(); ++ii) {
QVariant v = record.value(ii);
ScopedString s(scope, v4->newIdentifier(record.fieldName(ii)));
- ScopedValue val(scope, v.isNull() ? Encode::null() : QV4::ExecutionEngine::fromVariant(v4, v));
+ ScopedValue val(scope, v.isNull() ? Encode::null() : v4->fromVariant(v));
row->put(s.getPointer(), val);
}
if (hasProperty)
quint32 size = array->getLength();
QV4::ScopedValue v(scope);
for (quint32 ii = 0; ii < size; ++ii)
- query.bindValue(ii, QV4::ExecutionEngine::toVariant(scope.engine, (v = array->getIndexed(ii)), -1));
+ query.bindValue(ii, scope.engine->toVariant((v = array->getIndexed(ii)), -1));
} else if (values->asObject()) {
ScopedObject object(scope, values);
ObjectIterator it(scope, object, ObjectIterator::WithProtoChain|ObjectIterator::EnumerableOnly);
key = it.nextPropertyName(val);
if (key->isNull())
break;
- QVariant v = QV4::ExecutionEngine::toVariant(scope.engine, val, -1);
+ QVariant v = scope.engine->toVariant(val, -1);
if (key->isString()) {
query.bindValue(key->stringValue()->toQString(), v);
} else {
}
}
} else {
- query.bindValue(0, QV4::ExecutionEngine::toVariant(scope.engine, values, -1));
+ query.bindValue(0, scope.engine->toVariant(values, -1));
}
}
if (query.exec()) {
ScopedValue value(scope);
for (int ii = 0; ii < d->roleObjects.count(); ++ii) {
name = v4engine->newIdentifier(d->roleObjects[ii]->name());
- value = QV4::ExecutionEngine::fromVariant(v4engine, d->data.value(ii).value(index));
+ value = v4engine->fromVariant(d->data.value(ii).value(index));
o->insertMember(name.getPointer(), value);
}
{
Q_D(QJSEngine);
QV4::Scope scope(d->m_v4Engine);
- QV4::ScopedValue v(scope, QV4::ExecutionEngine::metaTypeToJS(scope.engine, type, ptr));
+ QV4::ScopedValue v(scope, scope.engine->metaTypeToJS(type, ptr));
return new QJSValuePrivate(d->m_v4Engine, v);
}
if (vp->engine) {
QV4::Scope scope(vp->engine);
QV4::ScopedValue v(scope, vp->getValue(scope.engine));
- return QV4::ExecutionEngine::metaTypeFromJS(scope.engine, v, type, ptr);
+ return scope.engine->metaTypeFromJS(v, type, ptr);
} else if (vp->value.isEmpty()) {
if (vp->unboundData.userType() == QMetaType::QString) {
QString string = vp->unboundData.toString();
}
if (value.isEmpty()) {
- value = QV4::Encode(QV4::ExecutionEngine::fromVariant(e, unboundData));
+ value = QV4::Encode(e->fromVariant(unboundData));
PersistentValuePrivate **listRoot = &engine->memoryManager->m_persistentValues;
prev = listRoot;
next = *listRoot;
return d->unboundData;
if (d->value.asObject())
- return QV4::ExecutionEngine::toVariant(d->value.engine(), d->value, /*typeHint*/ -1, /*createJSValueForObjects*/ false);
+ return d->value.engine()->toVariant(d->value, /*typeHint*/ -1, /*createJSValueForObjects*/ false);
if (d->value.isString())
return QVariant(d->value.stringValue()->toQString());
return (reinterpret_cast<quintptr>(&dummy) >= cStackLimit);
}
-QVariant ExecutionEngine::toVariant(QV4::ExecutionEngine *e, const QV4::ValueRef value, int typeHint, bool createJSValueForObjects, V4ObjectSet *visitedObjects)
+
+// Variant conversion code
+
+typedef QSet<QV4::Heap::Object *> V4ObjectSet;
+static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::ValueRef value, int typeHint, bool createJSValueForObjects, V4ObjectSet *visitedObjects);
+static QObject *qtObjectFromJS(QV4::ExecutionEngine *engine, const QV4::ValueRef value);
+static QVariant objectToVariant(QV4::ExecutionEngine *e, QV4::Object *o, V4ObjectSet *visitedObjects = 0);
+static bool convertToNativeQObject(QV4::ExecutionEngine *e, const QV4::ValueRef value,
+ const QByteArray &targetType,
+ void **result);
+static QV4::ReturnedValue variantListToJS(QV4::ExecutionEngine *v4, const QVariantList &lst);
+static QV4::ReturnedValue variantMapToJS(QV4::ExecutionEngine *v4, const QVariantMap &vmap);
+static QV4::ReturnedValue variantToJS(QV4::ExecutionEngine *v4, const QVariant &value)
+{
+ return v4->metaTypeToJS(value.userType(), value.constData());
+}
+
+
+QVariant ExecutionEngine::toVariant(const ValueRef value, int typeHint, bool createJSValueForObjects)
+{
+ return ::toVariant(this, value, typeHint, createJSValueForObjects, 0);
+}
+
+
+static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::ValueRef value, int typeHint, bool createJSValueForObjects, V4ObjectSet *visitedObjects)
{
Q_ASSERT (!value->isEmpty());
QV4::Scope scope(e);
return objectToVariant(e, o, visitedObjects);
}
-QVariant ExecutionEngine::objectToVariant(QV4::ExecutionEngine *e, QV4::Object *o, V4ObjectSet *visitedObjects)
+static QVariant objectToVariant(QV4::ExecutionEngine *e, QV4::Object *o, V4ObjectSet *visitedObjects)
{
Q_ASSERT(o);
int length = a->getLength();
for (int ii = 0; ii < length; ++ii) {
v = a->getIndexed(ii);
- list << toVariant(e, v, -1, /*createJSValueForObjects*/false, visitedObjects);
+ list << ::toVariant(e, v, -1, /*createJSValueForObjects*/false, visitedObjects);
}
result = list;
break;
QString key = name->toQStringNoThrow();
- map.insert(key, toVariant(e, val, /*type hint*/-1, /*createJSValueForObjects*/false, visitedObjects));
+ map.insert(key, ::toVariant(e, val, /*type hint*/-1, /*createJSValueForObjects*/false, visitedObjects));
}
result = map;
a->arrayReserve(len);
QV4::ScopedValue v(scope);
for (int ii = 0; ii < len; ++ii)
- a->arrayPut(ii, (v = ExecutionEngine::fromVariant(scope.engine, list.at(ii))));
+ a->arrayPut(ii, (v = scope.engine->fromVariant(list.at(ii))));
a->setArrayLengthUnchecked(len);
return a.asReturnedValue();
uint idx = s->asArrayIndex();
if (idx > 16 && (!o->arrayData() || idx > o->arrayData()->length() * 2))
o->initSparseArray();
- o->put(s, (v = ExecutionEngine::fromVariant(e, iter.value())));
+ o->put(s, (v = e->fromVariant(iter.value())));
}
return o.asReturnedValue();
}
Q_CORE_EXPORT QString qt_regexp_toCanonical(const QString &, QRegExp::PatternSyntax);
-QV4::ReturnedValue ExecutionEngine::fromVariant(QV4::ExecutionEngine *e, const QVariant &variant)
+QV4::ReturnedValue QV4::ExecutionEngine::fromVariant(const QVariant &variant)
{
int type = variant.userType();
const void *ptr = variant.constData();
case QMetaType::Double:
return QV4::Encode(*reinterpret_cast<const double*>(ptr));
case QMetaType::QString:
- return e->currentContext()->engine->newString(*reinterpret_cast<const QString*>(ptr))->asReturnedValue();
+ return newString(*reinterpret_cast<const QString*>(ptr))->asReturnedValue();
case QMetaType::Float:
return QV4::Encode(*reinterpret_cast<const float*>(ptr));
case QMetaType::Short:
case QMetaType::QChar:
return QV4::Encode((int)(*reinterpret_cast<const QChar*>(ptr)).unicode());
case QMetaType::QDateTime:
- return QV4::Encode(e->newDateObject(*reinterpret_cast<const QDateTime *>(ptr)));
+ return QV4::Encode(newDateObject(*reinterpret_cast<const QDateTime *>(ptr)));
case QMetaType::QDate:
- return QV4::Encode(e->newDateObject(QDateTime(*reinterpret_cast<const QDate *>(ptr))));
+ return QV4::Encode(newDateObject(QDateTime(*reinterpret_cast<const QDate *>(ptr))));
case QMetaType::QTime:
- return QV4::Encode(e->newDateObject(QDateTime(QDate(1970,1,1), *reinterpret_cast<const QTime *>(ptr))));
+ return QV4::Encode(newDateObject(QDateTime(QDate(1970,1,1), *reinterpret_cast<const QTime *>(ptr))));
case QMetaType::QRegExp:
- return QV4::Encode(e->newRegExpObject(*reinterpret_cast<const QRegExp *>(ptr)));
+ return QV4::Encode(newRegExpObject(*reinterpret_cast<const QRegExp *>(ptr)));
case QMetaType::QObjectStar:
- return QV4::QObjectWrapper::wrap(e, *reinterpret_cast<QObject* const *>(ptr));
+ return QV4::QObjectWrapper::wrap(this, *reinterpret_cast<QObject* const *>(ptr));
case QMetaType::QStringList:
{
bool succeeded = false;
- QV4::Scope scope(e);
- QV4::ScopedValue retn(scope, QV4::SequencePrototype::fromVariant(e, variant, &succeeded));
+ QV4::Scope scope(this);
+ QV4::ScopedValue retn(scope, QV4::SequencePrototype::fromVariant(this, variant, &succeeded));
if (succeeded)
return retn.asReturnedValue();
- return QV4::Encode(e->newArrayObject(*reinterpret_cast<const QStringList *>(ptr)));
+ return QV4::Encode(newArrayObject(*reinterpret_cast<const QStringList *>(ptr)));
}
case QMetaType::QVariantList:
- return arrayFromVariantList(e, *reinterpret_cast<const QVariantList *>(ptr));
+ return arrayFromVariantList(this, *reinterpret_cast<const QVariantList *>(ptr));
case QMetaType::QVariantMap:
- return objectFromVariantMap(e, *reinterpret_cast<const QVariantMap *>(ptr));
+ return objectFromVariantMap(this, *reinterpret_cast<const QVariantMap *>(ptr));
case QMetaType::QJsonValue:
- return QV4::JsonObject::fromJsonValue(e, *reinterpret_cast<const QJsonValue *>(ptr));
+ return QV4::JsonObject::fromJsonValue(this, *reinterpret_cast<const QJsonValue *>(ptr));
case QMetaType::QJsonObject:
- return QV4::JsonObject::fromJsonObject(e, *reinterpret_cast<const QJsonObject *>(ptr));
+ return QV4::JsonObject::fromJsonObject(this, *reinterpret_cast<const QJsonObject *>(ptr));
case QMetaType::QJsonArray:
- return QV4::JsonObject::fromJsonArray(e, *reinterpret_cast<const QJsonArray *>(ptr));
+ return QV4::JsonObject::fromJsonArray(this, *reinterpret_cast<const QJsonArray *>(ptr));
case QMetaType::QLocale:
- return QQmlLocale::wrap(e, *reinterpret_cast<const QLocale*>(ptr));
+ return QQmlLocale::wrap(this, *reinterpret_cast<const QLocale*>(ptr));
default:
break;
}
if (const QMetaObject *vtmo = QQmlValueTypeFactory::metaObjectForMetaType(type))
- return QV4::QQmlValueTypeWrapper::create(e, variant, vtmo, type);
+ return QV4::QQmlValueTypeWrapper::create(this, variant, vtmo, type);
} else {
- QV4::Scope scope(e);
+ QV4::Scope scope(this);
if (type == qMetaTypeId<QQmlListReference>()) {
typedef QQmlListReferencePrivate QDLRP;
QDLRP *p = QDLRP::get((QQmlListReference*)ptr);
} else if (type == qMetaTypeId<QJSValue>()) {
const QJSValue *value = reinterpret_cast<const QJSValue *>(ptr);
QJSValuePrivate *valuep = QJSValuePrivate::get(*value);
- return valuep->getValue(e);
+ return valuep->getValue(this);
} else if (type == qMetaTypeId<QList<QObject *> >()) {
// XXX Can this be made more by using Array as a prototype and implementing
// directly against QList<QObject*>?
const QList<QObject *> &list = *(QList<QObject *>*)ptr;
- QV4::ScopedArrayObject a(scope, e->newArrayObject());
+ QV4::ScopedArrayObject a(scope, newArrayObject());
a->arrayReserve(list.count());
QV4::ScopedValue v(scope);
for (int ii = 0; ii < list.count(); ++ii)
- a->arrayPut(ii, (v = QV4::QObjectWrapper::wrap(e, list.at(ii))));
+ a->arrayPut(ii, (v = QV4::QObjectWrapper::wrap(this, list.at(ii))));
a->setArrayLengthUnchecked(list.count());
return a.asReturnedValue();
} else if (QMetaType::typeFlags(type) & QMetaType::PointerToQObject) {
- return QV4::QObjectWrapper::wrap(e, *reinterpret_cast<QObject* const *>(ptr));
+ return QV4::QObjectWrapper::wrap(this, *reinterpret_cast<QObject* const *>(ptr));
}
bool objOk;
QObject *obj = QQmlMetaType::toQObject(variant, &objOk);
if (objOk)
- return QV4::QObjectWrapper::wrap(e, obj);
+ return QV4::QObjectWrapper::wrap(this, obj);
bool succeeded = false;
- QV4::ScopedValue retn(scope, QV4::SequencePrototype::fromVariant(e, variant, &succeeded));
+ QV4::ScopedValue retn(scope, QV4::SequencePrototype::fromVariant(this, variant, &succeeded));
if (succeeded)
return retn.asReturnedValue();
if (const QMetaObject *vtmo = QQmlValueTypeFactory::metaObjectForMetaType(type))
- return QV4::QQmlValueTypeWrapper::create(e, variant, vtmo, type);
+ return QV4::QQmlValueTypeWrapper::create(this, variant, vtmo, type);
}
// XXX TODO: To be compatible, we still need to handle:
// + QObjectList
// + QList<int>
- return QV4::Encode(e->newVariantObject(variant));
+ return QV4::Encode(newVariantObject(variant));
}
QVariantMap ExecutionEngine::variantMapFromJS(Object *o)
{
- return objectToVariant(o->engine(), o).toMap();
+ return objectToVariant(this, o).toMap();
}
// The result is a new Array object with length equal to the length
// of the QVariantList, and the elements being the QVariantList's
// elements converted to JS, recursively.
-QV4::ReturnedValue ExecutionEngine::variantListToJS(QV4::ExecutionEngine *v4, const QVariantList &lst)
+static QV4::ReturnedValue variantListToJS(QV4::ExecutionEngine *v4, const QVariantList &lst)
{
QV4::Scope scope(v4);
QV4::ScopedArrayObject a(scope, v4->newArrayObject());
// The result is a new Object object with property names being
// the keys of the QVariantMap, and values being the values of
// the QVariantMap converted to JS, recursively.
-QV4::ReturnedValue ExecutionEngine::variantMapToJS(QV4::ExecutionEngine *v4, const QVariantMap &vmap)
+static QV4::ReturnedValue variantMapToJS(QV4::ExecutionEngine *v4, const QVariantMap &vmap)
{
QV4::Scope scope(v4);
QV4::ScopedObject o(scope, v4->newObject());
// Converts the meta-type defined by the given type and data to JS.
// Returns the value if conversion succeeded, an empty handle otherwise.
-QV4::ReturnedValue ExecutionEngine::metaTypeToJS(QV4::ExecutionEngine *v4, int type, const void *data)
+QV4::ReturnedValue ExecutionEngine::metaTypeToJS(int type, const void *data)
{
Q_ASSERT(data != 0);
case QMetaType::Double:
return QV4::Encode(*reinterpret_cast<const double*>(data));
case QMetaType::QString:
- return v4->currentContext()->engine->newString(*reinterpret_cast<const QString*>(data))->asReturnedValue();
+ return newString(*reinterpret_cast<const QString*>(data))->asReturnedValue();
case QMetaType::Float:
return QV4::Encode(*reinterpret_cast<const float*>(data));
case QMetaType::Short:
case QMetaType::QChar:
return QV4::Encode((int)(*reinterpret_cast<const QChar*>(data)).unicode());
case QMetaType::QStringList:
- return QV4::Encode(v4->newArrayObject(*reinterpret_cast<const QStringList *>(data)));
+ return QV4::Encode(newArrayObject(*reinterpret_cast<const QStringList *>(data)));
case QMetaType::QVariantList:
- return variantListToJS(v4, *reinterpret_cast<const QVariantList *>(data));
+ return variantListToJS(this, *reinterpret_cast<const QVariantList *>(data));
case QMetaType::QVariantMap:
- return variantMapToJS(v4, *reinterpret_cast<const QVariantMap *>(data));
+ return variantMapToJS(this, *reinterpret_cast<const QVariantMap *>(data));
case QMetaType::QDateTime:
- return QV4::Encode(v4->newDateObject(*reinterpret_cast<const QDateTime *>(data)));
+ return QV4::Encode(newDateObject(*reinterpret_cast<const QDateTime *>(data)));
case QMetaType::QDate:
- return QV4::Encode(v4->newDateObject(QDateTime(*reinterpret_cast<const QDate *>(data))));
+ return QV4::Encode(newDateObject(QDateTime(*reinterpret_cast<const QDate *>(data))));
case QMetaType::QRegExp:
- return QV4::Encode(v4->newRegExpObject(*reinterpret_cast<const QRegExp *>(data)));
+ return QV4::Encode(newRegExpObject(*reinterpret_cast<const QRegExp *>(data)));
case QMetaType::QObjectStar:
- return QV4::QObjectWrapper::wrap(v4, *reinterpret_cast<QObject* const *>(data));
+ return QV4::QObjectWrapper::wrap(this, *reinterpret_cast<QObject* const *>(data));
case QMetaType::QVariant:
- return variantToJS(v4, *reinterpret_cast<const QVariant*>(data));
+ return variantToJS(this, *reinterpret_cast<const QVariant*>(data));
case QMetaType::QJsonValue:
- return QV4::JsonObject::fromJsonValue(v4, *reinterpret_cast<const QJsonValue *>(data));
+ return QV4::JsonObject::fromJsonValue(this, *reinterpret_cast<const QJsonValue *>(data));
case QMetaType::QJsonObject:
- return QV4::JsonObject::fromJsonObject(v4, *reinterpret_cast<const QJsonObject *>(data));
+ return QV4::JsonObject::fromJsonObject(this, *reinterpret_cast<const QJsonObject *>(data));
case QMetaType::QJsonArray:
- return QV4::JsonObject::fromJsonArray(v4, *reinterpret_cast<const QJsonArray *>(data));
+ return QV4::JsonObject::fromJsonArray(this, *reinterpret_cast<const QJsonArray *>(data));
default:
if (type == qMetaTypeId<QJSValue>()) {
- return QJSValuePrivate::get(*reinterpret_cast<const QJSValue*>(data))->getValue(v4);
+ return QJSValuePrivate::get(*reinterpret_cast<const QJSValue*>(data))->getValue(this);
} else {
QByteArray typeName = QMetaType::typeName(type);
if (typeName.endsWith('*') && !*reinterpret_cast<void* const *>(data)) {
QMetaType mt(type);
if (mt.flags() & QMetaType::IsGadget) {
Q_ASSERT(mt.metaObject());
- return QV4::QQmlValueTypeWrapper::create(v4, QVariant(type, data), mt.metaObject(), type);
+ return QV4::QQmlValueTypeWrapper::create(this, QVariant(type, data), mt.metaObject(), type);
}
// Fall back to wrapping in a QVariant.
- return QV4::Encode(v4->newVariantObject(QVariant(type, data)));
+ return QV4::Encode(newVariantObject(QVariant(type, data)));
}
}
Q_UNREACHABLE();
// Converts a JS value to a meta-type.
// data must point to a place that can store a value of the given type.
// Returns true if conversion succeeded, false otherwise.
-bool ExecutionEngine::metaTypeFromJS(QV4::ExecutionEngine *engine, const QV4::ValueRef value, int type, void *data)
+bool ExecutionEngine::metaTypeFromJS(const QV4::ValueRef value, int type, void *data)
{
- QV4::Scope scope(engine);
+ QV4::Scope scope(this);
// check if it's one of the types we know
switch (QMetaType::Type(type)) {
case QMetaType::QVariantList: {
QV4::ScopedArrayObject a(scope, value);
if (a) {
- *reinterpret_cast<QVariantList *>(data) = toVariant(scope.engine, a, /*typeHint*/-1, /*createJSValueForObjects*/false).toList();
+ *reinterpret_cast<QVariantList *>(data) = scope.engine->toVariant(a, /*typeHint*/-1, /*createJSValueForObjects*/false).toList();
return true;
}
break;
break;
}
case QMetaType::QVariant:
- *reinterpret_cast<QVariant*>(data) = toVariant(scope.engine, value, /*typeHint*/-1, /*createJSValueForObjects*/false);
+ *reinterpret_cast<QVariant*>(data) = scope.engine->toVariant(value, /*typeHint*/-1, /*createJSValueForObjects*/false);
return true;
case QMetaType::QJsonValue:
*reinterpret_cast<QJsonValue *>(data) = QV4::JsonObject::toJsonValue(value);
// Try to use magic; for compatibility with qscriptvalue_cast.
QByteArray name = QMetaType::typeName(type);
- if (convertToNativeQObject(engine, value, name, reinterpret_cast<void* *>(data)))
+ if (convertToNativeQObject(this, value, name, reinterpret_cast<void* *>(data)))
return true;
if (value->as<QV4::VariantObject>() && name.endsWith('*')) {
int valueType = QMetaType::type(name.left(name.size()-1));
*reinterpret_cast<void* *>(data) = 0;
return true;
} else if (type == qMetaTypeId<QJSValue>()) {
- *reinterpret_cast<QJSValue*>(data) = QJSValuePrivate::get(new QJSValuePrivate(engine, value));
+ *reinterpret_cast<QJSValue*>(data) = QJSValuePrivate::get(new QJSValuePrivate(this, value));
return true;
}
return false;
}
-// Converts a QVariant to JS.
-QV4::ReturnedValue ExecutionEngine::variantToJS(QV4::ExecutionEngine *v4, const QVariant &value)
-{
- return metaTypeToJS(v4, value.userType(), value.constData());
-}
-
-bool ExecutionEngine::convertToNativeQObject(QV4::ExecutionEngine *e, const QV4::ValueRef value, const QByteArray &targetType, void **result)
+static bool convertToNativeQObject(QV4::ExecutionEngine *e, const QV4::ValueRef value, const QByteArray &targetType, void **result)
{
if (!targetType.endsWith('*'))
return false;
return false;
}
-QObject *ExecutionEngine::qtObjectFromJS(QV4::ExecutionEngine *engine, const QV4::ValueRef value)
+static QObject *qtObjectFromJS(QV4::ExecutionEngine *engine, const QV4::ValueRef value)
{
if (!value->isObject())
return 0;
QQmlError catchExceptionAsQmlError();
// variant conversions
- typedef QSet<QV4::Heap::Object *> V4ObjectSet;
- static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::ValueRef value, int typeHint, bool createJSValueForObjects = true, V4ObjectSet *visitedObjects = 0);
- static QV4::ReturnedValue fromVariant(QV4::ExecutionEngine *e, const QVariant &);
+ QVariant toVariant(const QV4::ValueRef value, int typeHint, bool createJSValueForObjects = true);
+ QV4::ReturnedValue fromVariant(const QVariant &);
- static QVariantMap variantMapFromJS(QV4::Object *o);
+ QVariantMap variantMapFromJS(QV4::Object *o);
- static bool metaTypeFromJS(QV4::ExecutionEngine *e, const QV4::ValueRef value, int type, void *data);
- static QV4::ReturnedValue metaTypeToJS(QV4::ExecutionEngine *v4, int type, const void *data);
-
-private:
- static QObject *qtObjectFromJS(QV4::ExecutionEngine *engine, const QV4::ValueRef value);
- static QVariant objectToVariant(QV4::ExecutionEngine *e, QV4::Object *o, V4ObjectSet *visitedObjects = 0);
- static bool convertToNativeQObject(QV4::ExecutionEngine *e, const QV4::ValueRef value,
- const QByteArray &targetType,
- void **result);
- static QV4::ReturnedValue variantListToJS(QV4::ExecutionEngine *v4, const QVariantList &lst);
- static QV4::ReturnedValue variantMapToJS(QV4::ExecutionEngine *v4, const QVariantMap &vmap);
- static QV4::ReturnedValue variantToJS(QV4::ExecutionEngine *v4, const QVariant &value);
+ bool metaTypeFromJS(const QV4::ValueRef value, int type, void *data);
+ QV4::ReturnedValue metaTypeToJS(int type, const void *data);
private:
QmlExtensions *m_qmlExtensions;
return QV4::QQmlValueTypeWrapper::create(v4, object, property.coreIndex, valueTypeMetaObject, v.userType()); // VariantReference value-type.
}
- return QV4::ExecutionEngine::fromVariant(scope.engine, v);
+ return scope.engine->fromVariant(v);
} else if (QQmlValueTypeFactory::isValueType(property.propType)) {
Q_ASSERT(notifier == 0);
} else {
QVariant v(property.propType, (void *)0);
ReadFunction(object, property, v.data(), notifier);
- return QV4::ExecutionEngine::fromVariant(scope.engine, v);
+ return scope.engine->fromVariant(v);
}
}
} else {
QVariant v;
if (property->isQList())
- v = QV4::ExecutionEngine::toVariant(ctx->d()->engine, value, qMetaTypeId<QList<QObject *> >());
+ v = ctx->d()->engine->toVariant(value, qMetaTypeId<QList<QObject *> >());
else
- v = QV4::ExecutionEngine::toVariant(ctx->d()->engine, value, property->propType);
+ v = ctx->d()->engine->toVariant(value, property->propType);
QQmlContextData *callingQmlContext = QV4::QmlContextWrapper::callingContext(ctx->d()->engine);
if (!QQmlPropertyPrivate::write(object, *property, v, callingQmlContext)) {
for (int ii = 0; ii < argCount; ++ii) {
int type = argsTypes[ii + 1];
if (type == qMetaTypeId<QVariant>()) {
- callData->args[ii] = QV4::ExecutionEngine::fromVariant(v4, *((QVariant *)metaArgs[ii + 1]));
+ callData->args[ii] = v4->fromVariant(*((QVariant *)metaArgs[ii + 1]));
} else {
- callData->args[ii] = QV4::ExecutionEngine::fromVariant(v4, QVariant(type, metaArgs[ii + 1]));
+ callData->args[ii] = v4->fromVariant(QVariant(type, metaArgs[ii + 1]));
}
}
if (obj->as<QV4::VariantObject>()) {
if (conversionType == qMetaTypeId<QVariant>())
return 0;
- if (QV4::ExecutionEngine::toVariant(obj->engine(), actual, -1).userType() == conversionType)
+ if (obj->engine()->toVariant(actual, -1).userType() == conversionType)
return 0;
else
return 10;
}
if (obj->as<QV4::QQmlValueTypeWrapper>()) {
- if (QV4::ExecutionEngine::toVariant(obj->engine(), actual, -1).userType() == conversionType)
+ if (obj->engine()->toVariant(actual, -1).userType() == conversionType)
return 0;
return 10;
} else if (conversionType == QMetaType::QJsonObject) {
queryEngine = qmlTypeWrapper->isSingleton();
type = callType;
} else if (callType == qMetaTypeId<QVariant>()) {
- qvariantPtr = new (&allocData) QVariant(QV4::ExecutionEngine::toVariant(scope.engine, value, -1));
+ qvariantPtr = new (&allocData) QVariant(scope.engine->toVariant(value, -1));
type = callType;
} else if (callType == qMetaTypeId<QList<QObject*> >()) {
qlistPtr = new (&allocData) QList<QObject *>();
type = -1;
QQmlEnginePrivate *ep = engine->qmlEngine() ? QQmlEnginePrivate::get(engine->qmlEngine()) : 0;
- QVariant v = QV4::ExecutionEngine::toVariant(scope.engine, value, callType);
+ QVariant v = scope.engine->toVariant(value, callType);
if (v.userType() == callType) {
*qvariantPtr = v;
return QV4::JsonObject::fromJsonValue(scope.engine, *jsonValuePtr);
} else if (type == -1 || type == qMetaTypeId<QVariant>()) {
QVariant value = *qvariantPtr;
- QV4::ScopedValue rv(scope, QV4::ExecutionEngine::fromVariant(scope.engine, value));
+ QV4::ScopedValue rv(scope, scope.engine->fromVariant(value));
QV4::Scoped<QV4::QObjectWrapper> qobjectWrapper(scope, rv);
if (!!qobjectWrapper) {
if (QObject *object = qobjectWrapper->object())
// ### Find a better solution then the ugly property
QQmlListModelWorkerAgent::VariantRef ref(agent);
QVariant var = qVariantFromValue(ref);
- QV4::ScopedValue v(scope, QV4::ExecutionEngine::fromVariant(scope.engine, var));
+ QV4::ScopedValue v(scope, scope.engine->fromVariant(var));
QV4::ScopedString s(scope, engine->newString(QStringLiteral("__qml:hidden:ref")));
rv->asObject()->defineReadonlyProperty(s, v);
ep->dereferenceScarceResources();
- return QV4::ExecutionEngine::toVariant(scope.engine, result, qMetaTypeId<QList<QObject*> >());
+ return scope.engine->toVariant(result, qMetaTypeId<QList<QObject*> >());
}
QString QQmlBinding::expressionIdentifier(QQmlJavaScriptExpression *e)
// for several cases (such as QVariant type and QObject-derived types)
//args[ii] = engine->metaTypeToJS(type, a[ii + 1]);
if (type == QMetaType::QVariant) {
- callData->args[ii] = QV4::ExecutionEngine::fromVariant(scope.engine, *((QVariant *)a[ii + 1]));
+ callData->args[ii] = scope.engine->fromVariant(*((QVariant *)a[ii + 1]));
} else if (type == QMetaType::Int) {
//### optimization. Can go away if we switch to metaTypeToJS, or be expanded otherwise
callData->args[ii] = QV4::Primitive::fromInt32(*reinterpret_cast<const int*>(a[ii + 1]));
else
callData->args[ii] = QV4::QObjectWrapper::wrap(ep->v4engine(), *reinterpret_cast<QObject* const *>(a[ii + 1]));
} else {
- callData->args[ii] = QV4::ExecutionEngine::fromVariant(scope.engine, QVariant(type, a[ii + 1]));
+ callData->args[ii] = scope.engine->fromVariant(QVariant(type, a[ii + 1]));
}
}
QQmlContextPrivate::context_at);
return QmlListWrapper::create(v4, prop, qMetaTypeId<QQmlListProperty<QObject> >());
} else {
- return QV4::ExecutionEngine::fromVariant(scope.engine, cp->propertyValues.at(propertyIdx));
+ return scope.engine->fromVariant(cp->propertyValues.at(propertyIdx));
}
}
}
QV4::Scope scope(QV8Engine::getV4(ep->v8engine()));
QV4::ScopedValue result(scope, v4value(isUndefined));
if (!hasError())
- rv = QV4::ExecutionEngine::toVariant(scope.engine, result, -1);
+ rv = scope.engine->toVariant(result, -1);
}
ep->dereferenceScarceResources(); // "release" scarce resources if top-level expression evaluation is complete.
if (isUndefined) {
} else if (core.isQList()) {
- value = QV4::ExecutionEngine::toVariant(QV8Engine::getV4(v8engine), result, qMetaTypeId<QList<QObject *> >());
+ value = QV8Engine::getV4(v8engine)->toVariant(result, qMetaTypeId<QList<QObject *> >());
} else if (result->isNull() && core.isQObject()) {
value = QVariant::fromValue((QObject *)0);
} else if (core.propType == qMetaTypeId<QList<QUrl> >()) {
- value = resolvedUrlSequence(QV4::ExecutionEngine::toVariant(QV8Engine::getV4(v8engine), result, qMetaTypeId<QList<QUrl> >()), context);
+ value = resolvedUrlSequence(QV8Engine::getV4(v8engine)->toVariant(result, qMetaTypeId<QList<QUrl> >()), context);
} else if (!isVarProperty && type != qMetaTypeId<QJSValue>()) {
- value = QV4::ExecutionEngine::toVariant(QV8Engine::getV4(v8engine), result, type);
+ value = QV8Engine::getV4(v8engine)->toVariant(result, type);
}
if (expression->hasError()) {
QVariant v(result->propType, (void *)0);
void *args[] = { v.data(), 0 };
metaObject->d.static_metacall(reinterpret_cast<QObject*>(gadget), QMetaObject::ReadProperty, index, args);
- return QV4::ExecutionEngine::fromVariant(v4, v);
+ return v4->fromVariant(v);
+#undef VALUE_TYPE_ACCESSOR
}
void QQmlValueTypeWrapper::put(Managed *m, String *name, const ValueRef value)
if (newBinding)
return;
- QVariant v = QV4::ExecutionEngine::toVariant(v4, value, property.userType());
+ QVariant v = v4->toVariant(value, property.userType());
if (property.isEnumType() && (QMetaType::Type)v.type() == QMetaType::Double)
v = v.toInt();
callData->thisObject = ep->v8engine()->global();
for (int ii = 0; ii < data->parameterCount; ++ii)
- callData->args[ii] = QV4::ExecutionEngine::fromVariant(scope.engine, *(QVariant *)a[ii + 1]);
+ callData->args[ii] = scope.engine->fromVariant(*(QVariant *)a[ii + 1]);
QV4::ScopedValue result(scope);
result = function->call(callData);
ep->warning(error);
if (a[0]) *(QVariant *)a[0] = QVariant();
} else {
- if (a[0]) *(QVariant *)a[0] = QV4::ExecutionEngine::toVariant(scope.engine, result, 0);
+ if (a[0]) *(QVariant *)a[0] = scope.engine->toVariant(result, 0);
}
ep->dereferenceScarceResources(); // "release" scarce resources if top-level expression evaluation is complete.
QV4::Scope scope(v4);
QV4::ScopedObject o(scope, varProperties.value());
QV4::ScopedValue val(scope, o->getIndexed(id - firstVarPropertyIndex));
- return QV4::ExecutionEngine::toVariant(scope.engine, val, -1);
+ return scope.engine->toVariant(val, -1);
}
return QVariant();
} else {
// And, if the new value is a scarce resource, we need to ensure that it does not get
// automatically released by the engine until no other references to it exist.
- QV4::ScopedValue newv(scope, QV4::ExecutionEngine::fromVariant(scope.engine, value));
+ QV4::ScopedValue newv(scope, scope.engine->fromVariant(value));
QV4::Scoped<QV4::VariantObject> v(scope, newv);
if (!!v)
v->addVmePropertyReference();
if (a < 0.0) a=0.0;
if (a > 1.0) a=1.0;
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QQml_colorProvider()->fromRgbF(r, g, b, a));
+ return ctx->engine()->fromVariant(QQml_colorProvider()->fromRgbF(r, g, b, a));
}
/*!
if (a < 0.0) a=0.0;
if (a > 1.0) a=1.0;
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QQml_colorProvider()->fromHslF(h, s, l, a));
+ return ctx->engine()->fromVariant(QQml_colorProvider()->fromHslF(h, s, l, a));
}
/*!
bool ok = false;
- QVariant lhs = QV4::ExecutionEngine::toVariant(ctx->d()->engine, ctx->d()->callData->args[0], -1);
+ QVariant lhs = ctx->d()->engine->toVariant(ctx->d()->callData->args[0], -1);
if (lhs.userType() == QVariant::String) {
lhs = QQmlStringConverters::colorFromString(lhs.toString(), &ok);
if (!ok) {
V4THROW_ERROR("Qt.colorEqual(): Invalid arguments");
}
- QVariant rhs = QV4::ExecutionEngine::toVariant(ctx->engine(), ctx->d()->callData->args[1], -1);
+ QVariant rhs = ctx->engine()->toVariant(ctx->d()->callData->args[1], -1);
if (rhs.userType() == QVariant::String) {
rhs = QQmlStringConverters::colorFromString(rhs.toString(), &ok);
if (!ok) {
double w = ctx->d()->callData->args[2].toNumber();
double h = ctx->d()->callData->args[3].toNumber();
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QVariant::fromValue(QRectF(x, y, w, h)));
+ return ctx->engine()->fromVariant(QVariant::fromValue(QRectF(x, y, w, h)));
}
/*!
double x = ctx->d()->callData->args[0].toNumber();
double y = ctx->d()->callData->args[1].toNumber();
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QVariant::fromValue(QPointF(x, y)));
+ return ctx->engine()->fromVariant(QVariant::fromValue(QPointF(x, y)));
}
/*!
double w = ctx->d()->callData->args[0].toNumber();
double h = ctx->d()->callData->args[1].toNumber();
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QVariant::fromValue(QSizeF(w, h)));
+ return ctx->engine()->fromVariant(QVariant::fromValue(QSizeF(w, h)));
}
/*!
QVariant v = QQml_valueTypeProvider()->createVariantFromJsObject(QMetaType::QFont, QQmlV4Handle(ctx->d()->callData->args[0]), v4, &ok);
if (!ok)
V4THROW_ERROR("Qt.font(): Invalid argument: no valid font subproperties specified");
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), v);
+ return ctx->engine()->fromVariant(v);
}
xy[1] = ctx->d()->callData->args[1].toNumber();
const void *params[] = { xy };
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QQml_valueTypeProvider()->createValueType(QMetaType::QVector2D, 1, params));
+ return ctx->engine()->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QVector2D, 1, params));
}
/*!
xyz[2] = ctx->d()->callData->args[2].toNumber();
const void *params[] = { xyz };
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QQml_valueTypeProvider()->createValueType(QMetaType::QVector3D, 1, params));
+ return ctx->engine()->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QVector3D, 1, params));
}
/*!
xyzw[3] = ctx->d()->callData->args[3].toNumber();
const void *params[] = { xyzw };
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QQml_valueTypeProvider()->createValueType(QMetaType::QVector4D, 1, params));
+ return ctx->engine()->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QVector4D, 1, params));
}
/*!
sxyz[3] = ctx->d()->callData->args[3].toNumber();
const void *params[] = { sxyz };
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QQml_valueTypeProvider()->createValueType(QMetaType::QQuaternion, 1, params));
+ return ctx->engine()->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QQuaternion, 1, params));
}
/*!
QVariant v = QQml_valueTypeProvider()->createVariantFromJsObject(QMetaType::QMatrix4x4, QQmlV4Handle(ctx->d()->callData->args[0]), v4, &ok);
if (!ok)
V4THROW_ERROR("Qt.matrix4x4(): Invalid argument: not a valid matrix4x4 values array");
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), v);
+ return ctx->engine()->fromVariant(v);
}
if (ctx->d()->callData->argc != 16)
vals[15] = ctx->d()->callData->args[15].toNumber();
const void *params[] = { vals };
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QQml_valueTypeProvider()->createValueType(QMetaType::QMatrix4x4, 1, params));
+ return ctx->engine()->fromVariant(QQml_valueTypeProvider()->createValueType(QMetaType::QMatrix4x4, 1, params));
}
/*!
if (ctx->d()->callData->argc != 1 && ctx->d()->callData->argc != 2)
V4THROW_ERROR("Qt.lighter(): Invalid arguments");
- QVariant v = QV4::ExecutionEngine::toVariant(ctx->engine(), ctx->d()->callData->args[0], -1);
+ QVariant v = ctx->engine()->toVariant(ctx->d()->callData->args[0], -1);
if (v.userType() == QVariant::String) {
bool ok = false;
v = QQmlStringConverters::colorFromString(v.toString(), &ok);
if (ctx->d()->callData->argc == 2)
factor = ctx->d()->callData->args[1].toNumber();
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QQml_colorProvider()->lighter(v, factor));
+ return ctx->engine()->fromVariant(QQml_colorProvider()->lighter(v, factor));
}
/*!
if (ctx->d()->callData->argc != 1 && ctx->d()->callData->argc != 2)
V4THROW_ERROR("Qt.darker(): Invalid arguments");
- QVariant v = QV4::ExecutionEngine::toVariant(ctx->engine(), ctx->d()->callData->args[0], -1);
+ QVariant v = ctx->engine()->toVariant(ctx->d()->callData->args[0], -1);
if (v.userType() == QVariant::String) {
bool ok = false;
v = QQmlStringConverters::colorFromString(v.toString(), &ok);
if (ctx->d()->callData->argc == 2)
factor = ctx->d()->callData->args[1].toNumber();
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QQml_colorProvider()->darker(v, factor));
+ return ctx->engine()->fromVariant(QQml_colorProvider()->darker(v, factor));
}
/*!
V4THROW_ERROR("Qt.tint(): Invalid arguments");
// base color
- QVariant v1 = QV4::ExecutionEngine::toVariant(ctx->engine(), ctx->d()->callData->args[0], -1);
+ QVariant v1 = ctx->engine()->toVariant(ctx->d()->callData->args[0], -1);
if (v1.userType() == QVariant::String) {
bool ok = false;
v1 = QQmlStringConverters::colorFromString(v1.toString(), &ok);
}
// tint color
- QVariant v2 = QV4::ExecutionEngine::toVariant(ctx->engine(), ctx->d()->callData->args[1], -1);
+ QVariant v2 = ctx->engine()->toVariant(ctx->d()->callData->args[1], -1);
if (v2.userType() == QVariant::String) {
bool ok = false;
v2 = QQmlStringConverters::colorFromString(v2.toString(), &ok);
return QV4::Encode::null();
}
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QQml_colorProvider()->tint(v1, v2));
+ return ctx->engine()->fromVariant(QQml_colorProvider()->tint(v1, v2));
}
/*!
QV4::Scope scope(ctx);
Qt::DateFormat enumFormat = Qt::DefaultLocaleShortDate;
- QDate date = QV4::ExecutionEngine::toVariant(ctx->engine(), ctx->d()->callData->args[0], -1).toDateTime().date();
+ QDate date = ctx->engine()->toVariant(ctx->d()->callData->args[0], -1).toDateTime().date();
QString formattedDate;
if (ctx->d()->callData->argc == 2) {
QV4::ScopedString s(scope, ctx->d()->callData->args[1]);
V4THROW_ERROR("Qt.formatTime(): Invalid arguments");
QV4::Scope scope(ctx);
- QVariant argVariant = QV4::ExecutionEngine::toVariant(ctx->engine(), ctx->d()->callData->args[0], -1);
+ QVariant argVariant = ctx->engine()->toVariant(ctx->d()->callData->args[0], -1);
QTime time;
if (ctx->d()->callData->args[0].asDateObject() || (argVariant.type() == QVariant::String))
time = argVariant.toDateTime().time();
QV4::Scope scope(ctx);
Qt::DateFormat enumFormat = Qt::DefaultLocaleShortDate;
- QDateTime dt = QV4::ExecutionEngine::toVariant(ctx->engine(), ctx->d()->callData->args[0], -1).toDateTime();
+ QDateTime dt = ctx->engine()->toVariant(ctx->d()->callData->args[0], -1).toDateTime();
QString formattedDt;
if (ctx->d()->callData->argc == 2) {
QV4::ScopedString s(scope, ctx->d()->callData->args[1]);
return QV4::Encode(false);
QUrl url(Value::fromReturnedValue(method_resolvedUrl(ctx)).toQStringNoThrow());
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QQml_guiProvider()->openUrlExternally(url));
+ return ctx->engine()->fromVariant(QQml_guiProvider()->openUrlExternally(url));
}
/*!
{
QV8Engine *v8engine = ctx->d()->engine->v8Engine;
- QUrl url = QV4::ExecutionEngine::toVariant(ctx->engine(), ctx->d()->callData->args[0], -1).toUrl();
+ QUrl url = ctx->engine()->toVariant(ctx->d()->callData->args[0], -1).toUrl();
QQmlEngine *e = v8engine->engine();
QQmlEnginePrivate *p = 0;
if (e) p = QQmlEnginePrivate::get(e);
if (ctx->d()->callData->argc != 0)
V4THROW_ERROR("Qt.fontFamilies(): Invalid arguments");
- return QV4::ExecutionEngine::fromVariant(ctx->engine(), QVariant(QQml_guiProvider()->fontFamilies()));
+ return ctx->engine()->fromVariant(QVariant(QQml_guiProvider()->fontFamilies()));
}
/*!
propertyName = it.nextPropertyNameAsString(v);
if (propertyName->isNull())
break;
- cacheItem->setValue(propertyName->toQStringNoThrow(), QV4::ExecutionEngine::toVariant(scope.engine, v, QVariant::Invalid));
+ cacheItem->setValue(propertyName->toQStringNoThrow(), scope.engine->toVariant(v, QVariant::Invalid));
}
cacheItem->groups = groups | Compositor::UnresolvedFlag | Compositor::CacheFlag;
groups.append(o->d()->item->metaType->groupNames.at(i - 1));
}
- return QV4::ExecutionEngine::fromVariant(scope.engine, groups);
+ return scope.engine->fromVariant(groups);
}
QV4::ReturnedValue QQmlDelegateModelItem::set_groups(QV4::CallContext *ctx)
QVariantMap *map = reinterpret_cast<QVariantMap *>(mem);
map->~QMap();
}
- new (mem) QVariantMap(QV4::ExecutionEngine::variantMapFromJS(o));
+ new (mem) QVariantMap(o->engine()->variantMapFromJS(o));
roleIndex = role.index;
}
{
char *mem = getPropertyMemory(role);
QVariantMap *map = new (mem) QVariantMap;
- *map = QV4::ExecutionEngine::variantMapFromJS(o);
+ *map = o->engine()->variantMapFromJS(o);
}
void ListElement::setDateTimePropertyFast(const ListLayout::Role &role, const QDateTime &dt)
QVariant value = operator[](index);
QV4::Scope scope(m_obj->m_model->engine());
- QV4::ScopedValue v(scope, QV4::ExecutionEngine::fromVariant(scope.engine, value));
+ QV4::ScopedValue v(scope, scope.engine->fromVariant(value));
int roleIndex = m_obj->m_model->m_listModel->setExistingProperty(m_obj->m_elementIndex, propName, v, scope.engine);
if (roleIndex != -1) {
argObject = objectArray->getIndexed(i);
if (m_dynamicRoles) {
- m_modelObjects.insert(index+i, DynamicRoleModelNode::create(QV4::ExecutionEngine::variantMapFromJS(argObject), this));
+ m_modelObjects.insert(index+i, DynamicRoleModelNode::create(scope.engine->variantMapFromJS(argObject), this));
} else {
m_listModel->insert(index+i, argObject);
}
emitItemsAboutToBeInserted(index, 1);
if (m_dynamicRoles) {
- m_modelObjects.insert(index, DynamicRoleModelNode::create(QV4::ExecutionEngine::variantMapFromJS(argObject), this));
+ m_modelObjects.insert(index, DynamicRoleModelNode::create(scope.engine->variantMapFromJS(argObject), this));
} else {
m_listModel->insert(index, argObject);
}
argObject = objectArray->getIndexed(i);
if (m_dynamicRoles) {
- m_modelObjects.append(DynamicRoleModelNode::create(QV4::ExecutionEngine::variantMapFromJS(argObject), this));
+ m_modelObjects.append(DynamicRoleModelNode::create(scope.engine->variantMapFromJS(argObject), this));
} else {
m_listModel->append(argObject);
}
if (m_dynamicRoles) {
index = m_modelObjects.count();
emitItemsAboutToBeInserted(index, 1);
- m_modelObjects.append(DynamicRoleModelNode::create(QV4::ExecutionEngine::variantMapFromJS(argObject), this));
+ m_modelObjects.append(DynamicRoleModelNode::create(scope.engine->variantMapFromJS(argObject), this));
} else {
index = m_listModel->elementCount();
emitItemsAboutToBeInserted(index, 1);
emitItemsAboutToBeInserted(index, 1);
if (m_dynamicRoles) {
- m_modelObjects.append(DynamicRoleModelNode::create(QV4::ExecutionEngine::variantMapFromJS(object), this));
+ m_modelObjects.append(DynamicRoleModelNode::create(scope.engine->variantMapFromJS(object), this));
} else {
m_listModel->insert(index, object);
}
QVector<int> roles;
if (m_dynamicRoles) {
- m_modelObjects[index]->updateValues(QV4::ExecutionEngine::variantMapFromJS(object), roles);
+ m_modelObjects[index]->updateValues(scope.engine->variantMapFromJS(object), roles);
} else {
m_listModel->set(index, object, &roles);
}
QQmlDMCachedModelData *modelData = static_cast<QQmlDMCachedModelData *>(o->d()->item);
if (o->d()->item->index == -1) {
if (!modelData->cachedData.isEmpty()) {
- return QV4::ExecutionEngine::fromVariant(scope.engine,
+ return scope.engine->fromVariant(
modelData->cachedData.at(modelData->type->hasModelData ? 0 : propertyId));
}
} else if (*modelData->type->model) {
- return QV4::ExecutionEngine::fromVariant(scope.engine,
+ return scope.engine->fromVariant(
modelData->value(modelData->type->propertyRoles.at(propertyId)));
}
return QV4::Encode::undefined();
QQmlDMCachedModelData *modelData = static_cast<QQmlDMCachedModelData *>(o->d()->item);
if (!modelData->cachedData.isEmpty()) {
if (modelData->cachedData.count() > 1) {
- modelData->cachedData[propertyId] = QV4::ExecutionEngine::toVariant(scope.engine, ctx->d()->callData->args[0], QVariant::Invalid);
+ modelData->cachedData[propertyId] = scope.engine->toVariant(ctx->d()->callData->args[0], QVariant::Invalid);
QMetaObject::activate(o->d()->item, o->d()->item->metaObject(), propertyId, 0);
} else if (modelData->cachedData.count() == 1) {
- modelData->cachedData[0] = QV4::ExecutionEngine::toVariant(scope.engine, ctx->d()->callData->args[0], QVariant::Invalid);
+ modelData->cachedData[0] = scope.engine->toVariant(ctx->d()->callData->args[0], QVariant::Invalid);
QMetaObject::activate(o->d()->item, o->d()->item->metaObject(), 0, 0);
QMetaObject::activate(o->d()->item, o->d()->item->metaObject(), 1, 0);
}
if (!o)
return ctx->engine()->throwTypeError(QStringLiteral("Not a valid VisualData object"));
- return QV4::ExecutionEngine::fromVariant(scope.engine, static_cast<QQmlDMListAccessorData *>(o->d()->item)->cachedData);
+ return scope.engine->fromVariant(static_cast<QQmlDMListAccessorData *>(o->d()->item)->cachedData);
}
static QV4::ReturnedValue set_modelData(QV4::CallContext *ctx)
if (!ctx->d()->callData->argc)
return ctx->engine()->throwTypeError();
- static_cast<QQmlDMListAccessorData *>(o->d()->item)->setModelData(QV4::ExecutionEngine::toVariant(scope.engine, ctx->d()->callData->args[0], QVariant::Invalid));
+ static_cast<QQmlDMListAccessorData *>(o->d()->item)->setModelData(scope.engine->toVariant(ctx->d()->callData->args[0], QVariant::Invalid));
return QV4::Encode::undefined();
}
if (value->isObject()
&& !value->asFunctionObject()
&& !value->asArrayObject()) {
- QVariant v = QV4::ExecutionEngine::toVariant(scope.engine, value, QMetaType::UnknownType);
+ QVariant v = scope.engine->toVariant(value, QMetaType::UnknownType);
if (v.isValid()) {
switch (v.type()) {
case QVariant::Vector3D:
QV4::ScopedValue value(scope, ctx->argument(0));
if (value->asObject()) {
- QColor color = QV4::ExecutionEngine::toVariant(scope.engine, value, qMetaTypeId<QColor>()).value<QColor>();
+ QColor color = scope.engine->toVariant(value, qMetaTypeId<QColor>()).value<QColor>();
if (color.isValid()) {
r->d()->context->state.fillStyle = color;
r->d()->context->buffer()->setFillStyle(color);
QV4::Scoped<QQuickJSContext2D> r(scope, ctx->d()->callData->thisObject.as<QQuickJSContext2D>());
CHECK_CONTEXT(r)
- return QV4::ExecutionEngine::fromVariant(scope.engine, r->d()->context->state.fillRule);
+ return scope.engine->fromVariant(r->d()->context->state.fillRule);
}
QV4::ReturnedValue QQuickJSContext2D::method_set_fillRule(QV4::CallContext *ctx)
QV4::ScopedValue value(scope, ctx->argument(0));
if (value->asObject()) {
- QColor color = QV4::ExecutionEngine::toVariant(scope.engine, value, qMetaTypeId<QColor>()).value<QColor>();
+ QColor color = scope.engine->toVariant(value, qMetaTypeId<QColor>()).value<QColor>();
if (color.isValid()) {
r->d()->context->state.fillStyle = color;
r->d()->context->buffer()->setStrokeStyle(color);
if (ctx->d()->callData->argc >= 2) {
QV4::Scoped<QQuickContext2DStyle> pattern(scope, scope.engine->memoryManager->alloc<QQuickContext2DStyle>(scope.engine));
- QColor color = QV4::ExecutionEngine::toVariant(scope.engine, ctx->d()->callData->args[0], qMetaTypeId<QColor>()).value<QColor>();
+ QColor color = scope.engine->toVariant(ctx->d()->callData->args[0], qMetaTypeId<QColor>()).value<QColor>();
if (color.isValid()) {
int patternMode = ctx->d()->callData->args[1].toInt32();
Qt::BrushStyle style = Qt::SolidPattern;
QColor color;
if (ctx->d()->callData->args[1].asObject()) {
- color = QV4::ExecutionEngine::toVariant(scope.engine, ctx->d()->callData->args[1], qMetaTypeId<QColor>()).value<QColor>();
+ color = scope.engine->toVariant(ctx->d()->callData->args[1], qMetaTypeId<QColor>()).value<QColor>();
} else {
color = qt_color_from_string(ctx->d()->callData->args[1]);
}
{
QV4::ScopedValue ret(scope, EVALUATE("object.method_NoArgs_QPointF()"));
QVERIFY(!ret->isUndefined());
- QCOMPARE(QV4::ExecutionEngine::toVariant(scope.engine, ret, -1), QVariant(QPointF(123, 4.5)));
+ QCOMPARE(scope.engine->toVariant(ret, -1), QVariant(QPointF(123, 4.5)));
QCOMPARE(o->error(), false);
QCOMPARE(o->invoked(), 3);
QCOMPARE(o->actuals().count(), 0);