From 8906d90d8f9d4b6bc39bc6bda25e8d300c2f83c0 Mon Sep 17 00:00:00 2001 From: Simon Hausmann Date: Tue, 18 Nov 2014 17:15:10 +0100 Subject: Cleanup: Fix value type wrapper class name It's supposed to be QQmlFoo instead of QmlFoo. While all this code is being touched, we might as well fix the name. Change-Id: Ia8be0c6ec46e114f7559c1e7a07a9d368932999e Reviewed-by: Lars Knoll --- src/qml/jsruntime/qv4qobjectwrapper.cpp | 6 +- src/qml/jsruntime/qv4variantobject.cpp | 2 +- src/qml/qml/qqmlvaluetypewrapper.cpp | 130 ++++++++++++++++---------------- src/qml/qml/qqmlvaluetypewrapper_p.h | 8 +- src/qml/qml/v8/qv8engine.cpp | 6 +- 5 files changed, 76 insertions(+), 76 deletions(-) (limited to 'src') diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp index c2b3b44bba..b8d0c887fe 100644 --- a/src/qml/jsruntime/qv4qobjectwrapper.cpp +++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp @@ -202,7 +202,7 @@ static QV4::ReturnedValue LoadProperty(QV8Engine *engine, QObject *object, if (QQmlValueTypeFactory::isValueType(v.userType())) { if (const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(v.userType())) - return QV4::QmlValueTypeWrapper::create(engine, object, property.coreIndex, valueTypeMetaObject, v.userType()); // VariantReference value-type. + return QV4::QQmlValueTypeWrapper::create(engine, object, property.coreIndex, valueTypeMetaObject, v.userType()); // VariantReference value-type. } return engine->fromVariant(v); @@ -210,7 +210,7 @@ static QV4::ReturnedValue LoadProperty(QV8Engine *engine, QObject *object, Q_ASSERT(notifier == 0); if (const QMetaObject *valueTypeMetaObject = QQmlValueTypeFactory::metaObjectForMetaType(property.propType)) - return QV4::QmlValueTypeWrapper::create(engine, object, property.coreIndex, valueTypeMetaObject, property.propType); + return QV4::QQmlValueTypeWrapper::create(engine, object, property.coreIndex, valueTypeMetaObject, property.propType); } else { Q_ASSERT(notifier == 0); @@ -1288,7 +1288,7 @@ static int MatchScore(const QV4::ValueRef actual, int conversionType) } } - if (obj->as()) { + if (obj->as()) { if (engine->toVariant(actual, -1).userType() == conversionType) return 0; return 10; diff --git a/src/qml/jsruntime/qv4variantobject.cpp b/src/qml/jsruntime/qv4variantobject.cpp index d08d2a0812..efd0452a18 100644 --- a/src/qml/jsruntime/qv4variantobject.cpp +++ b/src/qml/jsruntime/qv4variantobject.cpp @@ -87,7 +87,7 @@ bool VariantObject::isEqualTo(Managed *m, Managed *other) if (QV4::VariantObject *rv = other->as()) return lv->d()->data == rv->d()->data; - if (QV4::QmlValueTypeWrapper *v = other->as()) + if (QV4::QQmlValueTypeWrapper *v = other->as()) return v->isEqual(lv->d()->data); return false; diff --git a/src/qml/qml/qqmlvaluetypewrapper.cpp b/src/qml/qml/qqmlvaluetypewrapper.cpp index d2fccb5273..cbcc67c39b 100644 --- a/src/qml/qml/qqmlvaluetypewrapper.cpp +++ b/src/qml/qml/qqmlvaluetypewrapper.cpp @@ -48,21 +48,21 @@ QT_BEGIN_NAMESPACE -DEFINE_OBJECT_VTABLE(QV4::QmlValueTypeWrapper); +DEFINE_OBJECT_VTABLE(QV4::QQmlValueTypeWrapper); namespace QV4 { namespace Heap { -struct QmlValueTypeReference : QmlValueTypeWrapper +struct QQmlValueTypeReference : QQmlValueTypeWrapper { - QmlValueTypeReference(QV8Engine *engine); + QQmlValueTypeReference(QV8Engine *engine); QPointer object; int property; }; -struct QmlValueTypeCopy : QmlValueTypeWrapper +struct QQmlValueTypeCopy : QQmlValueTypeWrapper { - QmlValueTypeCopy(QV8Engine *engine); + QQmlValueTypeCopy(QV8Engine *engine); QVariant value; }; @@ -71,40 +71,40 @@ struct QmlValueTypeCopy : QmlValueTypeWrapper using namespace QV4; -struct QmlValueTypeReference : public QmlValueTypeWrapper +struct QQmlValueTypeReference : public QQmlValueTypeWrapper { - V4_OBJECT2(QmlValueTypeReference, QmlValueTypeWrapper) + V4_OBJECT2(QQmlValueTypeReference, QQmlValueTypeWrapper) }; -DEFINE_OBJECT_VTABLE(QmlValueTypeReference); +DEFINE_OBJECT_VTABLE(QQmlValueTypeReference); -struct QmlValueTypeCopy : public QmlValueTypeWrapper +struct QQmlValueTypeCopy : public QQmlValueTypeWrapper { - V4_OBJECT2(QmlValueTypeCopy, QmlValueTypeWrapper) + V4_OBJECT2(QQmlValueTypeCopy, QQmlValueTypeWrapper) }; -DEFINE_OBJECT_VTABLE(QmlValueTypeCopy); +DEFINE_OBJECT_VTABLE(QQmlValueTypeCopy); -Heap::QmlValueTypeWrapper::QmlValueTypeWrapper(QV8Engine *engine, ObjectType objectType) +Heap::QQmlValueTypeWrapper::QQmlValueTypeWrapper(QV8Engine *engine, ObjectType objectType) : Heap::Object(QV8Engine::getV4(engine)) , v8(engine) , objectType(objectType) { - setVTable(QV4::QmlValueTypeWrapper::staticVTable()); + setVTable(QV4::QQmlValueTypeWrapper::staticVTable()); } -Heap::QmlValueTypeReference::QmlValueTypeReference(QV8Engine *engine) - : Heap::QmlValueTypeWrapper(engine, Reference) +Heap::QQmlValueTypeReference::QQmlValueTypeReference(QV8Engine *engine) + : Heap::QQmlValueTypeWrapper(engine, Reference) { } -Heap::QmlValueTypeCopy::QmlValueTypeCopy(QV8Engine *engine) - : Heap::QmlValueTypeWrapper(engine, Copy) +Heap::QQmlValueTypeCopy::QQmlValueTypeCopy(QV8Engine *engine) + : Heap::QQmlValueTypeWrapper(engine, Copy) { } -static bool readReferenceValue(const QmlValueTypeReference *reference) +static bool readReferenceValue(const QQmlValueTypeReference *reference) { // A reference resource may be either a "true" reference (eg, to a QVector3D property) // or a "variant" reference (eg, to a QVariant property which happens to contain a value-type). @@ -139,7 +139,7 @@ static bool readReferenceValue(const QmlValueTypeReference *reference) return true; } -void QmlValueTypeWrapper::initProto(ExecutionEngine *v4) +void QQmlValueTypeWrapper::initProto(ExecutionEngine *v4) { if (v4->qmlExtensions()->valueTypeWrapperPrototype) return; @@ -150,36 +150,36 @@ void QmlValueTypeWrapper::initProto(ExecutionEngine *v4) v4->qmlExtensions()->valueTypeWrapperPrototype = o->d(); } -ReturnedValue QmlValueTypeWrapper::create(QV8Engine *v8, QObject *object, int property, const QMetaObject *metaObject, int typeId) +ReturnedValue QQmlValueTypeWrapper::create(QV8Engine *v8, QObject *object, int property, const QMetaObject *metaObject, int typeId) { ExecutionEngine *v4 = QV8Engine::getV4(v8); Scope scope(v4); initProto(v4); - Scoped r(scope, v4->memoryManager->alloc(v8)); + Scoped r(scope, v4->memoryManager->alloc(v8)); ScopedObject proto(scope, v4->qmlExtensions()->valueTypeWrapperPrototype); r->setPrototype(proto); r->d()->type.reset(new QQmlValueType(typeId, metaObject)); r->d()->object = object; r->d()->property = property; return r->asReturnedValue(); } -ReturnedValue QmlValueTypeWrapper::create(QV8Engine *v8, const QVariant &value, const QMetaObject *metaObject, int typeId) +ReturnedValue QQmlValueTypeWrapper::create(QV8Engine *v8, const QVariant &value, const QMetaObject *metaObject, int typeId) { ExecutionEngine *v4 = QV8Engine::getV4(v8); Scope scope(v4); initProto(v4); - Scoped r(scope, v4->memoryManager->alloc(v8)); + Scoped r(scope, v4->memoryManager->alloc(v8)); ScopedObject proto(scope, v4->qmlExtensions()->valueTypeWrapperPrototype); r->setPrototype(proto); r->d()->type.reset(new QQmlValueType(typeId, metaObject)); r->d()->value = value; return r->asReturnedValue(); } -QVariant QmlValueTypeWrapper::toVariant() const +QVariant QQmlValueTypeWrapper::toVariant() const { - if (d()->objectType == Heap::QmlValueTypeWrapper::Reference) { - const QmlValueTypeReference *reference = static_cast(this); + if (d()->objectType == Heap::QQmlValueTypeWrapper::Reference) { + const QQmlValueTypeReference *reference = static_cast(this); if (reference->d()->object && readReferenceValue(reference)) { return reference->d()->type->value(); @@ -187,38 +187,38 @@ QVariant QmlValueTypeWrapper::toVariant() const return QVariant(); } } else { - Q_ASSERT(d()->objectType == Heap::QmlValueTypeWrapper::Copy); - return static_cast(this)->d()->value; + Q_ASSERT(d()->objectType == Heap::QQmlValueTypeWrapper::Copy); + return static_cast(this)->d()->value; } } -void QmlValueTypeWrapper::destroy(Heap::Base *that) +void QQmlValueTypeWrapper::destroy(Heap::Base *that) { - Heap::QmlValueTypeWrapper *w = static_cast(that); - if (w->objectType == Heap::QmlValueTypeWrapper::Reference) - static_cast(w)->Heap::QmlValueTypeReference::~QmlValueTypeReference(); + Heap::QQmlValueTypeWrapper *w = static_cast(that); + if (w->objectType == Heap::QQmlValueTypeWrapper::Reference) + static_cast(w)->Heap::QQmlValueTypeReference::~QQmlValueTypeReference(); else - static_cast(w)->Heap::QmlValueTypeCopy::~QmlValueTypeCopy(); + static_cast(w)->Heap::QQmlValueTypeCopy::~QQmlValueTypeCopy(); } -bool QmlValueTypeWrapper::isEqualTo(Managed *m, Managed *other) +bool QQmlValueTypeWrapper::isEqualTo(Managed *m, Managed *other) { - Q_ASSERT(m && m->as() && other); - QV4::QmlValueTypeWrapper *lv = static_cast(m); + Q_ASSERT(m && m->as() && other); + QV4::QQmlValueTypeWrapper *lv = static_cast(m); if (QV4::VariantObject *rv = other->as()) return lv->isEqual(rv->d()->data); - if (QV4::QmlValueTypeWrapper *v = other->as()) + if (QV4::QQmlValueTypeWrapper *v = other->as()) return lv->isEqual(v->toVariant()); return false; } -PropertyAttributes QmlValueTypeWrapper::query(const Managed *m, String *name) +PropertyAttributes QQmlValueTypeWrapper::query(const Managed *m, String *name) { - Q_ASSERT(m->as()); - const QmlValueTypeWrapper *r = static_cast(m); + Q_ASSERT(m->as()); + const QQmlValueTypeWrapper *r = static_cast(m); QQmlPropertyData local; QQmlPropertyData *result = 0; @@ -232,18 +232,18 @@ PropertyAttributes QmlValueTypeWrapper::query(const Managed *m, String *name) return result ? Attr_Data : Attr_Invalid; } -bool QmlValueTypeWrapper::isEqual(const QVariant& value) +bool QQmlValueTypeWrapper::isEqual(const QVariant& value) { - if (d()->objectType == Heap::QmlValueTypeWrapper::Reference) { - QmlValueTypeReference *reference = static_cast(this); + if (d()->objectType == Heap::QQmlValueTypeWrapper::Reference) { + QQmlValueTypeReference *reference = static_cast(this); if (reference->d()->object && readReferenceValue(reference)) { return reference->d()->type->isEqual(value); } else { return false; } } else { - Q_ASSERT(d()->objectType == Heap::QmlValueTypeWrapper::Copy); - QmlValueTypeCopy *copy = static_cast(this); + Q_ASSERT(d()->objectType == Heap::QQmlValueTypeWrapper::Copy); + QQmlValueTypeCopy *copy = static_cast(this); d()->type->setValue(copy->d()->value); if (d()->type->isEqual(value)) return true; @@ -251,34 +251,34 @@ bool QmlValueTypeWrapper::isEqual(const QVariant& value) } } -ReturnedValue QmlValueTypeWrapper::method_toString(CallContext *ctx) +ReturnedValue QQmlValueTypeWrapper::method_toString(CallContext *ctx) { Object *o = ctx->d()->callData->thisObject.asObject(); if (!o) return ctx->engine()->throwTypeError(); - QmlValueTypeWrapper *w = o->as(); + QQmlValueTypeWrapper *w = o->as(); if (!w) return ctx->engine()->throwTypeError(); - if (w->d()->objectType == Heap::QmlValueTypeWrapper::Reference) { - QmlValueTypeReference *reference = static_cast(w); + if (w->d()->objectType == Heap::QQmlValueTypeWrapper::Reference) { + QQmlValueTypeReference *reference = static_cast(w); if (reference->d()->object && readReferenceValue(reference)) { return w->d()->v8->toString(w->d()->type->toString()); } else { return QV4::Encode::undefined(); } } else { - Q_ASSERT(w->d()->objectType == Heap::QmlValueTypeWrapper::Copy); - QmlValueTypeCopy *copy = static_cast(w); + Q_ASSERT(w->d()->objectType == Heap::QQmlValueTypeWrapper::Copy); + QQmlValueTypeCopy *copy = static_cast(w); w->d()->type->setValue(copy->d()->value); return w->d()->v8->toString(w->d()->type->toString()); } } -ReturnedValue QmlValueTypeWrapper::get(Managed *m, String *name, bool *hasProperty) +ReturnedValue QQmlValueTypeWrapper::get(Managed *m, String *name, bool *hasProperty) { - Q_ASSERT(m->as()); - QmlValueTypeWrapper *r = static_cast(m); + Q_ASSERT(m->as()); + QQmlValueTypeWrapper *r = static_cast(m); QV4::ExecutionEngine *v4 = m->engine(); // ### Remove this once we can do proper this calls. @@ -286,16 +286,16 @@ ReturnedValue QmlValueTypeWrapper::get(Managed *m, String *name, bool *hasProper return Object::get(m, name, hasProperty); // Note: readReferenceValue() can change the reference->type. - if (r->d()->objectType == Heap::QmlValueTypeWrapper::Reference) { - QmlValueTypeReference *reference = static_cast(r); + if (r->d()->objectType == Heap::QQmlValueTypeWrapper::Reference) { + QQmlValueTypeReference *reference = static_cast(r); if (!reference->d()->object || !readReferenceValue(reference)) return Primitive::undefinedValue().asReturnedValue(); } else { - Q_ASSERT(r->d()->objectType == Heap::QmlValueTypeWrapper::Copy); + Q_ASSERT(r->d()->objectType == Heap::QQmlValueTypeWrapper::Copy); - QmlValueTypeCopy *copy = static_cast(r); + QQmlValueTypeCopy *copy = static_cast(r); r->d()->type->setValue(copy->d()->value); } @@ -344,19 +344,19 @@ ReturnedValue QmlValueTypeWrapper::get(Managed *m, String *name, bool *hasProper #undef VALUE_TYPE_ACCESSOR } -void QmlValueTypeWrapper::put(Managed *m, String *name, const ValueRef value) +void QQmlValueTypeWrapper::put(Managed *m, String *name, const ValueRef value) { - Q_ASSERT(m->as()); + Q_ASSERT(m->as()); ExecutionEngine *v4 = m->engine(); Scope scope(v4); if (scope.hasException()) return; - Scoped r(scope, static_cast(m)); + Scoped r(scope, static_cast(m)); QByteArray propName = name->toQString().toUtf8(); - if (r->d()->objectType == Heap::QmlValueTypeWrapper::Reference) { - Scoped reference(scope, static_cast(r->d())); + if (r->d()->objectType == Heap::QQmlValueTypeWrapper::Reference) { + Scoped reference(scope, static_cast(r->d())); QMetaProperty writebackProperty = reference->d()->object->metaObject()->property(reference->d()->property); if (!reference->d()->object || !writebackProperty.isWritable() || !readReferenceValue(reference)) @@ -420,9 +420,9 @@ void QmlValueTypeWrapper::put(Managed *m, String *name, const ValueRef value) } } else { - Q_ASSERT(r->d()->objectType == Heap::QmlValueTypeWrapper::Copy); + Q_ASSERT(r->d()->objectType == Heap::QQmlValueTypeWrapper::Copy); - Scoped copy(scope, static_cast(r->d())); + Scoped copy(scope, static_cast(r->d())); int index = r->d()->type->metaObject()->indexOfProperty(propName.constData()); if (index == -1) diff --git a/src/qml/qml/qqmlvaluetypewrapper_p.h b/src/qml/qml/qqmlvaluetypewrapper_p.h index 4946c13e42..e1c71c24d3 100644 --- a/src/qml/qml/qqmlvaluetypewrapper_p.h +++ b/src/qml/qml/qqmlvaluetypewrapper_p.h @@ -60,9 +60,9 @@ namespace QV4 { namespace Heap { -struct QmlValueTypeWrapper : Object { +struct QQmlValueTypeWrapper : Object { enum ObjectType { Reference, Copy }; - QmlValueTypeWrapper(QV8Engine *engine, ObjectType type); + QQmlValueTypeWrapper(QV8Engine *engine, ObjectType type); QV8Engine *v8; ObjectType objectType; mutable QScopedPointer type; @@ -70,9 +70,9 @@ struct QmlValueTypeWrapper : Object { } -struct Q_QML_EXPORT QmlValueTypeWrapper : Object +struct Q_QML_EXPORT QQmlValueTypeWrapper : Object { - V4_OBJECT2(QmlValueTypeWrapper, Object) + V4_OBJECT2(QQmlValueTypeWrapper, Object) static void destroy(Heap::Base *b); public: diff --git a/src/qml/qml/v8/qv8engine.cpp b/src/qml/qml/v8/qv8engine.cpp index ee124aeed0..2d36e51c8b 100644 --- a/src/qml/qml/v8/qv8engine.cpp +++ b/src/qml/qml/v8/qv8engine.cpp @@ -188,7 +188,7 @@ QVariant QV8Engine::toVariant(const QV4::ValueRef value, int typeHint, bool crea return QVariant(); } else if (QV4::QmlTypeWrapper *w = object->as()) { return w->toVariant(); - } else if (QV4::QmlValueTypeWrapper *v = object->as()) { + } else if (QV4::QQmlValueTypeWrapper *v = object->as()) { return v->toVariant(); } else if (QV4::QmlListWrapper *l = object->as()) { return l->toVariant(); @@ -414,7 +414,7 @@ QV4::ReturnedValue QV8Engine::fromVariant(const QVariant &variant) } if (const QMetaObject *vtmo = QQmlValueTypeFactory::metaObjectForMetaType(type)) - return QV4::QmlValueTypeWrapper::create(this, variant, vtmo, type); + return QV4::QQmlValueTypeWrapper::create(this, variant, vtmo, type); } else { QV4::Scope scope(m_v4Engine); if (type == qMetaTypeId()) { @@ -455,7 +455,7 @@ QV4::ReturnedValue QV8Engine::fromVariant(const QVariant &variant) return retn.asReturnedValue(); if (const QMetaObject *vtmo = QQmlValueTypeFactory::metaObjectForMetaType(type)) - return QV4::QmlValueTypeWrapper::create(this, variant, vtmo, type); + return QV4::QQmlValueTypeWrapper::create(this, variant, vtmo, type); } // XXX TODO: To be compatible, we still need to handle: -- cgit v1.2.3