diff options
author | Alan Alpert <416365416c@gmail.com> | 2012-12-15 13:58:38 -0800 |
---|---|---|
committer | The Qt Project <gerrit-noreply@qt-project.org> | 2013-01-08 17:18:35 +0100 |
commit | 6576728b885cb89be715db9f9e2038527a14a455 (patch) | |
tree | 057052ee0b7c5f50ded5f43b631cf423c5029e77 | |
parent | 5a902969566a4ca7e3937cfe61876a7fbaeb775b (diff) |
Remove m_ in property names of QQmlTypePrivate
There's already a d-> to indicate they are internal variables. Doesn't
need both.
Change-Id: I9b127dff7955456aacb25138fa6ea8efb7bb921f
Reviewed-by: Christopher Adams <chris.adams@jollamobile.com>
-rw-r--r-- | src/qml/qml/qqmlmetatype.cpp | 366 |
1 files changed, 183 insertions, 183 deletions
diff --git a/src/qml/qml/qqmlmetatype.cpp b/src/qml/qml/qqmlmetatype.cpp index 595f9e8de0..89c505fb6d 100644 --- a/src/qml/qml/qqmlmetatype.cpp +++ b/src/qml/qml/qqmlmetatype.cpp @@ -155,41 +155,41 @@ public: void initEnums() const; void insertEnums(const QMetaObject *metaObject) const; - bool m_isInterface : 1; - const char *m_iid; - QHashedString m_module; - QString m_name; - QString m_elementName; - int m_version_maj; - int m_version_min; - int m_typeId; int m_listId; - int m_revision; - mutable bool m_containsRevisionedAttributes; - mutable QQmlType *m_superType; - - int m_allocationSize; - void (*m_newFunc)(void *); - QString m_noCreationReason; - - const QMetaObject *m_baseMetaObject; - QQmlAttachedPropertiesFunc m_attachedPropertiesFunc; - const QMetaObject *m_attachedPropertiesType; - int m_attachedPropertiesId; - int m_parserStatusCast; - int m_propertyValueSourceCast; - int m_propertyValueInterceptorCast; - QObject *(*m_extFunc)(QObject *); - const QMetaObject *m_extMetaObject; - int m_index; - QQmlCustomParser *m_customParser; - mutable volatile bool m_isSetup:1; - mutable volatile bool m_isEnumSetup:1; - mutable bool m_haveSuperType:1; - mutable QList<QQmlProxyMetaObject::ProxyData> m_metaObjects; - mutable QStringHash<int> m_enums; - QQmlType::SingletonInstanceInfo *m_singletonInstanceInfo; - - static QHash<const QMetaObject *, int> m_attachedPropertyIds; + bool isInterface : 1; + const char *iid; + QHashedString module; + QString name; + QString elementName; + int version_maj; + int version_min; + int typeId; int listId; + int revision; + mutable bool containsRevisionedAttributes; + mutable QQmlType *superType; + + int allocationSize; + void (*newFunc)(void *); + QString noCreationReason; + + const QMetaObject *baseMetaObject; + QQmlAttachedPropertiesFunc attachedPropertiesFunc; + const QMetaObject *attachedPropertiesType; + int attachedPropertiesId; + int parserStatusCast; + int propertyValueSourceCast; + int propertyValueInterceptorCast; + QObject *(*extFunc)(QObject *); + const QMetaObject *extMetaObject; + int index; + QQmlCustomParser *customParser; + mutable volatile bool isSetup:1; + mutable volatile bool isEnumSetup:1; + mutable bool haveSuperType:1; + mutable QList<QQmlProxyMetaObject::ProxyData> metaObjects; + mutable QStringHash<int> enums; + QQmlType::SingletonInstanceInfo *singletonInstanceInfo; + + static QHash<const QMetaObject *, int> attachedPropertyIds; }; // Avoid multiple fromUtf8(), copies and hashing of the module name. @@ -250,147 +250,147 @@ QJSValue QQmlType::SingletonInstanceInfo::scriptApi(QQmlEngine *e) const return scriptApis.value(e); } -QHash<const QMetaObject *, int> QQmlTypePrivate::m_attachedPropertyIds; +QHash<const QMetaObject *, int> QQmlTypePrivate::attachedPropertyIds; QQmlTypePrivate::QQmlTypePrivate() -: m_isInterface(false), m_iid(0), m_typeId(0), m_listId(0), m_revision(0), m_containsRevisionedAttributes(false), - m_superType(0), m_allocationSize(0), m_newFunc(0), m_baseMetaObject(0), m_attachedPropertiesFunc(0), - m_attachedPropertiesType(0), m_parserStatusCast(-1), m_propertyValueSourceCast(-1), - m_propertyValueInterceptorCast(-1), m_extFunc(0), m_extMetaObject(0), m_index(-1), m_customParser(0), - m_isSetup(false), m_isEnumSetup(false), m_haveSuperType(false), m_singletonInstanceInfo(0) +: isInterface(false), iid(0), typeId(0), listId(0), revision(0), containsRevisionedAttributes(false), + superType(0), allocationSize(0), newFunc(0), baseMetaObject(0), attachedPropertiesFunc(0), + attachedPropertiesType(0), parserStatusCast(-1), propertyValueSourceCast(-1), + propertyValueInterceptorCast(-1), extFunc(0), extMetaObject(0), index(-1), customParser(0), + isSetup(false), isEnumSetup(false), haveSuperType(false), singletonInstanceInfo(0) { } QQmlTypePrivate::~QQmlTypePrivate() { - delete m_singletonInstanceInfo; + delete singletonInstanceInfo; } QQmlType::QQmlType(int index, const QQmlPrivate::RegisterInterface &interface) : d(new QQmlTypePrivate) { - d->m_isInterface = true; - d->m_iid = interface.iid; - d->m_typeId = interface.typeId; - d->m_listId = interface.listId; - d->m_newFunc = 0; - d->m_index = index; - d->m_isSetup = true; - d->m_version_maj = 0; - d->m_version_min = 0; + d->isInterface = true; + d->iid = interface.iid; + d->typeId = interface.typeId; + d->listId = interface.listId; + d->newFunc = 0; + d->index = index; + d->isSetup = true; + d->version_maj = 0; + d->version_min = 0; } QQmlType::QQmlType(int index, const QString &elementName, const QQmlPrivate::RegisterSingletonType &type) : d(new QQmlTypePrivate) { - d->m_elementName = elementName; - d->m_module = moduleFromUtf8(type.uri); + d->elementName = elementName; + d->module = moduleFromUtf8(type.uri); - d->m_version_maj = type.versionMajor; - d->m_version_min = type.versionMinor; + d->version_maj = type.versionMajor; + d->version_min = type.versionMinor; if (type.qobjectApi) { if (type.version >= 1) // static metaobject added in version 1 - d->m_baseMetaObject = type.instanceMetaObject; + d->baseMetaObject = type.instanceMetaObject; if (type.version >= 2) // typeId added in version 2 - d->m_typeId = type.typeId; + d->typeId = type.typeId; if (type.version >= 2) // revisions added in version 2 - d->m_revision = type.revision; + d->revision = type.revision; } - d->m_newFunc = 0; - d->m_index = index; + d->newFunc = 0; + d->index = index; - d->m_singletonInstanceInfo = new SingletonInstanceInfo; - d->m_singletonInstanceInfo->scriptCallback = type.scriptApi; - d->m_singletonInstanceInfo->qobjectCallback = type.qobjectApi; - d->m_singletonInstanceInfo->typeName = QString::fromUtf8(type.typeName); - d->m_singletonInstanceInfo->instanceMetaObject = (type.qobjectApi && type.version >= 1) ? type.instanceMetaObject : 0; + d->singletonInstanceInfo = new SingletonInstanceInfo; + d->singletonInstanceInfo->scriptCallback = type.scriptApi; + d->singletonInstanceInfo->qobjectCallback = type.qobjectApi; + d->singletonInstanceInfo->typeName = QString::fromUtf8(type.typeName); + d->singletonInstanceInfo->instanceMetaObject = (type.qobjectApi && type.version >= 1) ? type.instanceMetaObject : 0; } QQmlType::QQmlType(int index, const QString &elementName, const QQmlPrivate::RegisterType &type) : d(new QQmlTypePrivate) { - d->m_elementName = elementName; - d->m_module = moduleFromUtf8(type.uri); + d->elementName = elementName; + d->module = moduleFromUtf8(type.uri); - d->m_version_maj = type.versionMajor; - d->m_version_min = type.versionMinor; + d->version_maj = type.versionMajor; + d->version_min = type.versionMinor; if (type.version >= 1) // revisions added in version 1 - d->m_revision = type.revision; - d->m_typeId = type.typeId; - d->m_listId = type.listId; - d->m_allocationSize = type.objectSize; - d->m_newFunc = type.create; - d->m_noCreationReason = type.noCreationReason; - d->m_baseMetaObject = type.metaObject; - d->m_attachedPropertiesFunc = type.attachedPropertiesFunction; - d->m_attachedPropertiesType = type.attachedPropertiesMetaObject; - if (d->m_attachedPropertiesType) { - QHash<const QMetaObject *, int>::Iterator iter = d->m_attachedPropertyIds.find(d->m_baseMetaObject); - if (iter == d->m_attachedPropertyIds.end()) - iter = d->m_attachedPropertyIds.insert(d->m_baseMetaObject, index); - d->m_attachedPropertiesId = *iter; + d->revision = type.revision; + d->typeId = type.typeId; + d->listId = type.listId; + d->allocationSize = type.objectSize; + d->newFunc = type.create; + d->noCreationReason = type.noCreationReason; + d->baseMetaObject = type.metaObject; + d->attachedPropertiesFunc = type.attachedPropertiesFunction; + d->attachedPropertiesType = type.attachedPropertiesMetaObject; + if (d->attachedPropertiesType) { + QHash<const QMetaObject *, int>::Iterator iter = d->attachedPropertyIds.find(d->baseMetaObject); + if (iter == d->attachedPropertyIds.end()) + iter = d->attachedPropertyIds.insert(d->baseMetaObject, index); + d->attachedPropertiesId = *iter; } else { - d->m_attachedPropertiesId = -1; + d->attachedPropertiesId = -1; } - d->m_parserStatusCast = type.parserStatusCast; - d->m_propertyValueSourceCast = type.valueSourceCast; - d->m_propertyValueInterceptorCast = type.valueInterceptorCast; - d->m_extFunc = type.extensionObjectCreate; - d->m_index = index; - d->m_customParser = type.customParser; + d->parserStatusCast = type.parserStatusCast; + d->propertyValueSourceCast = type.valueSourceCast; + d->propertyValueInterceptorCast = type.valueInterceptorCast; + d->extFunc = type.extensionObjectCreate; + d->index = index; + d->customParser = type.customParser; if (type.extensionMetaObject) - d->m_extMetaObject = type.extensionMetaObject; + d->extMetaObject = type.extensionMetaObject; } QQmlType::~QQmlType() { - delete d->m_customParser; + delete d->customParser; delete d; } const QHashedString &QQmlType::module() const { - return d->m_module; + return d->module; } int QQmlType::majorVersion() const { - return d->m_version_maj; + return d->version_maj; } int QQmlType::minorVersion() const { - return d->m_version_min; + return d->version_min; } bool QQmlType::availableInVersion(int vmajor, int vminor) const { Q_ASSERT(vmajor >= 0 && vminor >= 0); - return vmajor == d->m_version_maj && vminor >= d->m_version_min; + return vmajor == d->version_maj && vminor >= d->version_min; } bool QQmlType::availableInVersion(const QHashedStringRef &module, int vmajor, int vminor) const { Q_ASSERT(vmajor >= 0 && vminor >= 0); - return module == d->m_module && vmajor == d->m_version_maj && vminor >= d->m_version_min; + return module == d->module && vmajor == d->version_maj && vminor >= d->version_min; } // returns the nearest _registered_ super class QQmlType *QQmlType::superType() const { - if (!d->m_haveSuperType && d->m_baseMetaObject) { - const QMetaObject *mo = d->m_baseMetaObject->superClass(); - while (mo && !d->m_superType) { - d->m_superType = QQmlMetaType::qmlType(mo, d->m_module, d->m_version_maj, d->m_version_min); + if (!d->haveSuperType && d->baseMetaObject) { + const QMetaObject *mo = d->baseMetaObject->superClass(); + while (mo && !d->superType) { + d->superType = QQmlMetaType::qmlType(mo, d->module, d->version_maj, d->version_min); mo = mo->superClass(); } - d->m_haveSuperType = true; + d->haveSuperType = true; } - return d->m_superType; + return d->superType; } static void clone(QMetaObjectBuilder &builder, const QMetaObject *mo, @@ -481,13 +481,13 @@ static bool isPropertyRevisioned(const QMetaObject *mo, int index) void QQmlTypePrivate::init() const { - if (m_isSetup) return; + if (isSetup) return; QWriteLocker lock(metaTypeDataLock()); - if (m_isSetup) + if (isSetup) return; - const QMetaObject *mo = m_baseMetaObject; + const QMetaObject *mo = baseMetaObject; if (!mo) { // singleton type without metaobject information return; @@ -495,78 +495,78 @@ void QQmlTypePrivate::init() const // Setup extended meta object // XXX - very inefficient - if (m_extFunc) { + if (extFunc) { QMetaObjectBuilder builder; - clone(builder, m_extMetaObject, m_extMetaObject, m_extMetaObject); + clone(builder, extMetaObject, extMetaObject, extMetaObject); builder.setFlags(QMetaObjectBuilder::DynamicMetaObject); QMetaObject *mmo = builder.toMetaObject(); mmo->d.superdata = mo; - QQmlProxyMetaObject::ProxyData data = { mmo, m_extFunc, 0, 0 }; - m_metaObjects << data; + QQmlProxyMetaObject::ProxyData data = { mmo, extFunc, 0, 0 }; + metaObjects << data; } mo = mo->d.superdata; while(mo) { QQmlType *t = metaTypeData()->metaObjectToType.value(mo); if (t) { - if (t->d->m_extFunc) { + if (t->d->extFunc) { QMetaObjectBuilder builder; - clone(builder, t->d->m_extMetaObject, t->d->m_baseMetaObject, m_baseMetaObject); + clone(builder, t->d->extMetaObject, t->d->baseMetaObject, baseMetaObject); builder.setFlags(QMetaObjectBuilder::DynamicMetaObject); QMetaObject *mmo = builder.toMetaObject(); - mmo->d.superdata = m_baseMetaObject; - if (!m_metaObjects.isEmpty()) - m_metaObjects.last().metaObject->d.superdata = mmo; - QQmlProxyMetaObject::ProxyData data = { mmo, t->d->m_extFunc, 0, 0 }; - m_metaObjects << data; + mmo->d.superdata = baseMetaObject; + if (!metaObjects.isEmpty()) + metaObjects.last().metaObject->d.superdata = mmo; + QQmlProxyMetaObject::ProxyData data = { mmo, t->d->extFunc, 0, 0 }; + metaObjects << data; } } mo = mo->d.superdata; } - for (int ii = 0; ii < m_metaObjects.count(); ++ii) { - m_metaObjects[ii].propertyOffset = - m_metaObjects.at(ii).metaObject->propertyOffset(); - m_metaObjects[ii].methodOffset = - m_metaObjects.at(ii).metaObject->methodOffset(); + for (int ii = 0; ii < metaObjects.count(); ++ii) { + metaObjects[ii].propertyOffset = + metaObjects.at(ii).metaObject->propertyOffset(); + metaObjects[ii].methodOffset = + metaObjects.at(ii).metaObject->methodOffset(); } // Check for revisioned details { const QMetaObject *mo = 0; - if (m_metaObjects.isEmpty()) - mo = m_baseMetaObject; + if (metaObjects.isEmpty()) + mo = baseMetaObject; else - mo = m_metaObjects.first().metaObject; + mo = metaObjects.first().metaObject; - for (int ii = 0; !m_containsRevisionedAttributes && ii < mo->propertyCount(); ++ii) { + for (int ii = 0; !containsRevisionedAttributes && ii < mo->propertyCount(); ++ii) { if (isPropertyRevisioned(mo, ii)) - m_containsRevisionedAttributes = true; + containsRevisionedAttributes = true; } - for (int ii = 0; !m_containsRevisionedAttributes && ii < mo->methodCount(); ++ii) { + for (int ii = 0; !containsRevisionedAttributes && ii < mo->methodCount(); ++ii) { if (mo->method(ii).revision() != 0) - m_containsRevisionedAttributes = true; + containsRevisionedAttributes = true; } } - m_isSetup = true; + isSetup = true; lock.unlock(); } void QQmlTypePrivate::initEnums() const { - if (m_isEnumSetup) return; + if (isEnumSetup) return; init(); QWriteLocker lock(metaTypeDataLock()); - if (m_isEnumSetup) return; + if (isEnumSetup) return; - if (m_baseMetaObject) // could be singleton type without metaobject - insertEnums(m_baseMetaObject); + if (baseMetaObject) // could be singleton type without metaobject + insertEnums(baseMetaObject); - m_isEnumSetup = true; + isEnumSetup = true; } void QQmlTypePrivate::insertEnums(const QMetaObject *metaObject) const @@ -584,46 +584,46 @@ void QQmlTypePrivate::insertEnums(const QMetaObject *metaObject) const for (int ii = 0; ii < metaObject->enumeratorCount(); ++ii) { QMetaEnum e = metaObject->enumerator(ii); for (int jj = 0; jj < e.keyCount(); ++jj) - m_enums.insert(QString::fromUtf8(e.key(jj)), e.value(jj)); + enums.insert(QString::fromUtf8(e.key(jj)), e.value(jj)); } } QByteArray QQmlType::typeName() const { - if (d->m_singletonInstanceInfo) - return d->m_singletonInstanceInfo->typeName.toUtf8(); - if (d->m_baseMetaObject) - return d->m_baseMetaObject->className(); + if (d->singletonInstanceInfo) + return d->singletonInstanceInfo->typeName.toUtf8(); + if (d->baseMetaObject) + return d->baseMetaObject->className(); else return QByteArray(); } const QString &QQmlType::elementName() const { - return d->m_elementName; + return d->elementName; } const QString &QQmlType::qmlTypeName() const { - if (d->m_name.isEmpty()) { - if (!d->m_module.isEmpty()) - d->m_name = static_cast<QString>(d->m_module) + QLatin1Char('/') + d->m_elementName; + if (d->name.isEmpty()) { + if (!d->module.isEmpty()) + d->name = static_cast<QString>(d->module) + QLatin1Char('/') + d->elementName; else - d->m_name = d->m_elementName; + d->name = d->elementName; } - return d->m_name; + return d->name; } QObject *QQmlType::create() const { d->init(); - QObject *rv = (QObject *)operator new(d->m_allocationSize); - d->m_newFunc(rv); + QObject *rv = (QObject *)operator new(d->allocationSize); + d->newFunc(rv); - if (rv && !d->m_metaObjects.isEmpty()) - (void)new QQmlProxyMetaObject(rv, &d->m_metaObjects); + if (rv && !d->metaObjects.isEmpty()) + (void)new QQmlProxyMetaObject(rv, &d->metaObjects); return rv; } @@ -632,109 +632,109 @@ void QQmlType::create(QObject **out, void **memory, size_t additionalMemory) con { d->init(); - QObject *rv = (QObject *)operator new(d->m_allocationSize + additionalMemory); - d->m_newFunc(rv); + QObject *rv = (QObject *)operator new(d->allocationSize + additionalMemory); + d->newFunc(rv); - if (rv && !d->m_metaObjects.isEmpty()) - (void)new QQmlProxyMetaObject(rv, &d->m_metaObjects); + if (rv && !d->metaObjects.isEmpty()) + (void)new QQmlProxyMetaObject(rv, &d->metaObjects); *out = rv; - *memory = ((char *)rv) + d->m_allocationSize; + *memory = ((char *)rv) + d->allocationSize; } QQmlType::SingletonInstanceInfo *QQmlType::singletonInstanceInfo() const { - return d->m_singletonInstanceInfo; + return d->singletonInstanceInfo; } QQmlCustomParser *QQmlType::customParser() const { - return d->m_customParser; + return d->customParser; } QQmlType::CreateFunc QQmlType::createFunction() const { - return d->m_newFunc; + return d->newFunc; } QString QQmlType::noCreationReason() const { - return d->m_noCreationReason; + return d->noCreationReason; } int QQmlType::createSize() const { - return d->m_allocationSize; + return d->allocationSize; } bool QQmlType::isCreatable() const { - return d->m_newFunc != 0; + return d->newFunc != 0; } bool QQmlType::isExtendedType() const { d->init(); - return !d->m_metaObjects.isEmpty(); + return !d->metaObjects.isEmpty(); } bool QQmlType::isSingleton() const { - return d->m_singletonInstanceInfo != 0; + return d->singletonInstanceInfo != 0; } bool QQmlType::isInterface() const { - return d->m_isInterface; + return d->isInterface; } int QQmlType::typeId() const { - return d->m_typeId; + return d->typeId; } int QQmlType::qListTypeId() const { - return d->m_listId; + return d->listId; } const QMetaObject *QQmlType::metaObject() const { d->init(); - if (d->m_metaObjects.isEmpty()) - return d->m_baseMetaObject; + if (d->metaObjects.isEmpty()) + return d->baseMetaObject; else - return d->m_metaObjects.first().metaObject; + return d->metaObjects.first().metaObject; } const QMetaObject *QQmlType::baseMetaObject() const { - return d->m_baseMetaObject; + return d->baseMetaObject; } bool QQmlType::containsRevisionedAttributes() const { d->init(); - return d->m_containsRevisionedAttributes; + return d->containsRevisionedAttributes; } int QQmlType::metaObjectRevision() const { - return d->m_revision; + return d->revision; } QQmlAttachedPropertiesFunc QQmlType::attachedPropertiesFunction() const { - return d->m_attachedPropertiesFunc; + return d->attachedPropertiesFunc; } const QMetaObject *QQmlType::attachedPropertiesType() const { - return d->m_attachedPropertiesType; + return d->attachedPropertiesType; } /* @@ -744,32 +744,32 @@ Qt 4.7 and QtQuick 1.0). */ int QQmlType::attachedPropertiesId() const { - return d->m_attachedPropertiesId; + return d->attachedPropertiesId; } int QQmlType::parserStatusCast() const { - return d->m_parserStatusCast; + return d->parserStatusCast; } int QQmlType::propertyValueSourceCast() const { - return d->m_propertyValueSourceCast; + return d->propertyValueSourceCast; } int QQmlType::propertyValueInterceptorCast() const { - return d->m_propertyValueInterceptorCast; + return d->propertyValueInterceptorCast; } const char *QQmlType::interfaceIId() const { - return d->m_iid; + return d->iid; } int QQmlType::index() const { - return d->m_index; + return d->index; } int QQmlType::enumValue(const QHashedStringRef &name, bool *ok) const @@ -779,7 +779,7 @@ int QQmlType::enumValue(const QHashedStringRef &name, bool *ok) const d->initEnums(); - int *rv = d->m_enums.value(name); + int *rv = d->enums.value(name); if (rv) return *rv; @@ -794,7 +794,7 @@ int QQmlType::enumValue(const QHashedCStringRef &name, bool *ok) const d->initEnums(); - int *rv = d->m_enums.value(name); + int *rv = d->enums.value(name); if (rv) return *rv; @@ -809,7 +809,7 @@ int QQmlType::enumValue(const QHashedV8String &name, bool *ok) const d->initEnums(); - int *rv = d->m_enums.value(name); + int *rv = d->enums.value(name); if (rv) return *rv; |