diff options
| -rw-r--r-- | meta/recipes-qt/qt4/qt-mobility-1.2.0/fix_metaobjectbuilder_build_err.patch | 4707 | ||||
| -rw-r--r-- | meta/recipes-qt/qt4/qt-mobility_1.2.0.inc | 1 |
2 files changed, 4708 insertions, 0 deletions
diff --git a/meta/recipes-qt/qt4/qt-mobility-1.2.0/fix_metaobjectbuilder_build_err.patch b/meta/recipes-qt/qt4/qt-mobility-1.2.0/fix_metaobjectbuilder_build_err.patch new file mode 100644 index 0000000000..cffb06706f --- /dev/null +++ b/meta/recipes-qt/qt4/qt-mobility-1.2.0/fix_metaobjectbuilder_build_err.patch @@ -0,0 +1,4707 @@ +Fix metaobjectbuilder build errors against Qt 4.8 and 4.7 + +Error message: +ipc/qmetaobjectbuilder.cpp:803:65: error: invalid conversion from \ +'QMetaObjectExtraData::StaticMetacallFunction {aka void (*)(QObject*, \ +QMetaObject::Call, int, void**)}' to 'QtMobility::QMetaObjectBuilder:: \ +StaticMetacallFunction {aka int (*)(QMetaObject::Call, int, void**)} + +Upstream-commit: +http://qt.gitorious.org/qt-mobility/qt-mobility/commit/f102053b28009b3094b0e5777177208afa6097c5 + +Task-number: QTMOBILITY-1990 + +Upstream-Status: Backport + +Signed-off-by: Wenzong Fan <wenzong.fan@windriver.com> +------------------------------------------------------ +diff --git a/plugins/declarative/common/dynamicproperties.pri b/plugins/declarative/common/dynamicproperties.pri +index 52737a3..4bd06de 100644 +--- a/plugins/declarative/common/dynamicproperties.pri ++++ b/plugins/declarative/common/dynamicproperties.pri +@@ -1,6 +1,8 @@ + INCLUDEPATH += ../../../plugins/declarative/common/dynamicproperties/ +-HEADERS += ../../../plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject_p.h \ +- ../../../plugins/declarative/common/dynamicproperties/qmetaobjectbuilder_p.h +-SOURCES += ../../../plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp \ +- ../../../src/serviceframework/ipc/qmetaobjectbuilder.cpp +- ++HEADERS += ../../../plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject_p.h ++SOURCES += ../../../plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp ++include(../../../src/serviceframework/ipc/metaobjectbuilder.pri) ++INCLUDEPATH += ../../../src/serviceframework/$$OBJECTBUILDER_INCLUDEPATH ++DEPENDPATH += ../../../src/serviceframework/$$OBJECTBUILDER_DEPENDPATH ++HEADERS += ../../../src/serviceframework/$$OBJECTBUILDER_HEADERS ++SOURCES += ../../../src/serviceframework/$$OBJECTBUILDER_SOURCES +diff --git a/plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp b/plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp +index 79a2064..9eb6810 100644 +--- a/plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp ++++ b/plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp +@@ -65,8 +65,7 @@ public: + { + int id = mob.propertyCount(); + mob.addSignal("__" + QByteArray::number(id) + "()"); +- QMetaPropertyBuilder build = mob.addProperty(name, type, id); +- build.setDynamic(true); ++ mob.addProperty(name, type, id); + qFree(mem); + mem = mob.toMetaObject(); + +diff --git a/plugins/declarative/common/dynamicproperties/qmetaobjectbuilder_p.h b/plugins/declarative/common/dynamicproperties/qmetaobjectbuilder_p.h +deleted file mode 100644 +index bd937e4..0000000 +--- a/plugins/declarative/common/dynamicproperties/qmetaobjectbuilder_p.h ++++ /dev/null +@@ -1,48 +0,0 @@ +-/**************************************************************************** +-** +-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +-** All rights reserved. +-** Contact: Nokia Corporation (qt-info@nokia.com) +-** +-** This file is part of the Qt Mobility Components. +-** +-** $QT_BEGIN_LICENSE:LGPL$ +-** No Commercial Usage +-** This file contains pre-release code and may not be distributed. +-** You may use this file in accordance with the terms and conditions +-** contained in the Technology Preview License Agreement accompanying +-** this package. +-** +-** GNU Lesser General Public License Usage +-** Alternatively, this file may be used under the terms of the GNU Lesser +-** General Public License version 2.1 as published by the Free Software +-** Foundation and appearing in the file LICENSE.LGPL included in the +-** packaging of this file. Please review the following information to +-** ensure the GNU Lesser General Public License version 2.1 requirements +-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +-** +-** In addition, as a special exception, Nokia gives you certain additional +-** rights. These rights are described in the Nokia Qt LGPL Exception +-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +-** +-** If you have questions regarding the use of this file, please contact +-** Nokia at qt-info@nokia.com. +-** +-** +-** +-** +-** +-** +-** +-** +-** $QT_END_LICENSE$ +-** +-****************************************************************************/ +- +-/* +-This header gets used in a number of different QML plugins +-and also in the source tree of Mobility itself. +- +-So this header is just a wrapper to grab it from there. +-*/ +-#include "../../../../src/serviceframework/ipc/qmetaobjectbuilder_p.h" +diff --git a/src/serviceframework/ipc/ipc.pri b/src/serviceframework/ipc/ipc.pri +index 28b910f..d809f59 100644 +--- a/src/serviceframework/ipc/ipc.pri ++++ b/src/serviceframework/ipc/ipc.pri +@@ -25,9 +25,14 @@ else { + } + } + ++include(metaobjectbuilder.pri) ++INCLUDEPATH += $$OBJECTBUILDER_INCLUDEPATH ++DEPENDPATH += $$OBJECTBUILDER_DEPENDPATH ++PRIVATE_HEADERS += $$OBJECTBUILDER_HEADERS ++SOURCES += $$OBJECTBUILDER_SOURCES ++ + PRIVATE_HEADERS += ipc/qslotinvoker_p.h \ + ipc/qsignalintercepter_p.h \ +- ipc/qmetaobjectbuilder_p.h \ + ipc/instancemanager_p.h \ + ipc/qservicepackage_p.h \ + ipc/proxyobject_p.h \ +@@ -37,7 +42,6 @@ PRIVATE_HEADERS += ipc/qslotinvoker_p.h \ + + SOURCES += ipc/qslotinvoker.cpp \ + ipc/qsignalintercepter.cpp \ +- ipc/qmetaobjectbuilder.cpp \ + ipc/instancemanager.cpp \ + ipc/qservicepackage.cpp \ + ipc/proxyobject.cpp \ +diff --git a/src/serviceframework/ipc/metaobjectbuilder.pri b/src/serviceframework/ipc/metaobjectbuilder.pri +new file mode 100644 +index 0000000..cc905f9 +--- /dev/null ++++ b/src/serviceframework/ipc/metaobjectbuilder.pri +@@ -0,0 +1,12 @@ ++#check version for 4.7 ... ++contains(QT_MAJOR_VERSION, 4):lessThan(QT_MINOR_VERSION, 8) { ++ OBJECTBUILDER_INCLUDEPATH += ipc ++ OBJECTBUILDER_DEPENDPATH += ipc ++ OBJECTBUILDER_HEADERS += ipc/qmetaobjectbuilder_47_p.h ++ OBJECTBUILDER_SOURCES += ipc/qmetaobjectbuilder_47.cpp ++} else { ++ OBJECTBUILDER_INCLUDEPATH += ipc ++ OBJECTBUILDER_DEPENDPATH += ipc ++ OBJECTBUILDER_HEADERS += ipc/qmetaobjectbuilder_p.h ++ OBJECTBUILDER_SOURCES += ipc/qmetaobjectbuilder.cpp ++} +diff --git a/src/serviceframework/ipc/qmetaobjectbuilder.cpp b/src/serviceframework/ipc/qmetaobjectbuilder.cpp +index b19eb1a..6ffaa20 100644 +--- a/src/serviceframework/ipc/qmetaobjectbuilder.cpp ++++ b/src/serviceframework/ipc/qmetaobjectbuilder.cpp +@@ -117,6 +117,8 @@ enum PropertyFlags { + EnumOrFlag = 0x00000008, + StdCppSet = 0x00000100, + // Override = 0x00000200, ++ Constant = 0x00000400, ++ Final = 0x00000800, + Designable = 0x00001000, + ResolveDesignable = 0x00002000, + Scriptable = 0x00004000, +@@ -128,7 +130,7 @@ enum PropertyFlags { + User = 0x00100000, + ResolveUser = 0x00200000, + Notify = 0x00400000, +- Dynamic = 0x00800000 ++ Revisioned = 0x00800000 + }; + + enum MethodFlags { +@@ -145,7 +147,8 @@ enum MethodFlags { + + MethodCompatibility = 0x10, + MethodCloned = 0x20, +- MethodScriptable = 0x40 ++ MethodScriptable = 0x40, ++ MethodRevisioned = 0x80 + }; + + struct QMetaObjectPrivate +@@ -623,6 +626,8 @@ QMetaPropertyBuilder QMetaObjectBuilder::addProperty(const QMetaProperty& protot + property.setUser(prototype.isUser()); + property.setStdCppSet(prototype.hasStdCppSet()); + property.setEnumOrFlag(prototype.isEnumType()); ++ property.setConstant(prototype.isConstant()); ++ property.setFinal(prototype.isFinal()); + if (prototype.hasNotifySignal()) { + // Find an existing method for the notify signal, or add a new one. + QMetaMethod method = prototype.notifySignal(); +@@ -796,7 +801,7 @@ void QMetaObjectBuilder::addMetaObject + } + + if ((members & StaticMetacall) != 0) { +- if (priv(prototype->d.data)->revision >= 2) { ++ if (priv(prototype->d.data)->revision >= 6) { + const QMetaObjectExtraData *extra = + (const QMetaObjectExtraData *)(prototype->d.extradata); + if (extra && extra->static_metacall) +@@ -1266,8 +1271,8 @@ static int buildMetaObject(QMetaObjectBuilderPrivate *d, char *buf, + char *str = reinterpret_cast<char *>(buf + size); + if (buf) { + if (relocatable) { +- meta->d.stringdata = reinterpret_cast<const char *>((intptr_t)size); +- meta->d.data = reinterpret_cast<uint *>((intptr_t)pmetaSize); ++ meta->d.stringdata = reinterpret_cast<const char *>((quintptr)size); ++ meta->d.data = reinterpret_cast<uint *>((quintptr)pmetaSize); + } else { + meta->d.stringdata = str; + meta->d.data = reinterpret_cast<uint *>(data); +@@ -1504,8 +1509,8 @@ void QMetaObjectBuilder::fromRelocatableData(QMetaObject *output, + const char *buf = data.constData(); + const QMetaObject *dataMo = reinterpret_cast<const QMetaObject *>(buf); + +- intptr_t stringdataOffset = (intptr_t)dataMo->d.stringdata; +- intptr_t dataOffset = (intptr_t)dataMo->d.data; ++ quintptr stringdataOffset = (quintptr)dataMo->d.stringdata; ++ quintptr dataOffset = (quintptr)dataMo->d.data; + + output->d.superdata = superclass; + output->d.stringdata = buf + stringdataOffset; +@@ -2289,16 +2294,27 @@ bool QMetaPropertyBuilder::isEnumOrFlag() const + } + + /*! +- Returns true if the property has the dynamic flag set; +- otherwise returns false. The default value is false. ++ Returns true if the property is constant; otherwise returns false. ++ The default value is false. ++*/ ++bool QMetaPropertyBuilder::isConstant() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(Constant); ++ else ++ return false; ++} + +- \sa setDynamic() ++/*! ++ Returns true if the property is final; otherwise returns false. ++ The default value is false. + */ +-bool QMetaPropertyBuilder::isDynamic() const ++bool QMetaPropertyBuilder::isFinal() const + { + QMetaPropertyBuilderPrivate *d = d_func(); + if (d) +- return d->flag(Dynamic); ++ return d->flag(Final); + else + return false; + } +@@ -2427,16 +2443,27 @@ void QMetaPropertyBuilder::setEnumOrFlag(bool value) + } + + /*! +- Sets this property to have the dynamic flag if \a value is +- true. ++ Sets the \c CONSTANT flag on this property to \a value. ++ ++ \sa isConstant() ++*/ ++void QMetaPropertyBuilder::setConstant(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(Constant, value); ++} ++ ++/*! ++ Sets the \c FINAL flag on this property to \a value. + +- \sa isDynamic() ++ \sa isFinal() + */ +-void QMetaPropertyBuilder::setDynamic(bool value) ++void QMetaPropertyBuilder::setFinal(bool value) + { + QMetaPropertyBuilderPrivate *d = d_func(); + if (d) +- d->setFlag(Dynamic, value); ++ d->setFlag(Final, value); + } + + /*! +diff --git a/src/serviceframework/ipc/qmetaobjectbuilder_47.cpp b/src/serviceframework/ipc/qmetaobjectbuilder_47.cpp +new file mode 100644 +index 0000000..509d6c6 +--- /dev/null ++++ b/src/serviceframework/ipc/qmetaobjectbuilder_47.cpp +@@ -0,0 +1,2583 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). ++** All rights reserved. ++** Contact: Nokia Corporation (qt-info@nokia.com) ++** ++** This file is part of the QtDeclarative module of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** No Commercial Usage ++** This file contains pre-release code and may not be distributed. ++** You may use this file in accordance with the terms and conditions ++** contained in the Technology Preview License Agreement accompanying ++** this package. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 2.1 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 2.1 requirements ++** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ++** ++** In addition, as a special exception, Nokia gives you certain additional ++** rights. These rights are described in the Nokia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** If you have questions regarding the use of this file, please contact ++** Nokia at qt-info@nokia.com. ++** ++** ++** ++** ++** ++** ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#include "qmetaobjectbuilder_47_p.h" ++#include <QDebug> ++ ++#ifndef Q_OS_WIN ++#include <stdint.h> ++#endif ++ ++QTM_BEGIN_NAMESPACE ++ ++/*! ++ \class QMetaObjectBuilder ++ \internal ++ \brief The QMetaObjectBuilder class supports building QMetaObject objects at runtime. ++ \since 1.1 ++ ++*/ ++ ++/*! ++ \enum QMetaObjectBuilder::AddMember ++ This enum defines which members of QMetaObject should be copied by QMetaObjectBuilder::addMetaObject() ++ ++ \value ClassName Add the class name. ++ \value SuperClass Add the super class. ++ \value Methods Add methods that aren't signals or slots. ++ \value Signals Add signals. ++ \value Slots Add slots. ++ \value Constructors Add constructors. ++ \value Properties Add properties. ++ \value Enumerators Add enumerators. ++ \value ClassInfos Add items of class information. ++ \value RelatedMetaObjects Add related meta objects. ++ \value StaticMetacall Add the static metacall function. ++ \value PublicMethods Add public methods (ignored for signals). ++ \value ProtectedMethods Add protected methods (ignored for signals). ++ \value PrivateMethods All private methods (ignored for signals). ++ \value AllMembers Add all members. ++ \value AllPrimaryMembers Add everything except the class name, super class, and static metacall function. ++*/ ++ ++// copied from moc's generator.cpp ++uint qvariant_nameToType(const char* name) ++{ ++ if (!name) ++ return 0; ++ ++ if (strcmp(name, "QVariant") == 0) ++ return 0xffffffff; ++ if (strcmp(name, "QCString") == 0) ++ return QMetaType::QByteArray; ++ if (strcmp(name, "Q_LLONG") == 0) ++ return QMetaType::LongLong; ++ if (strcmp(name, "Q_ULLONG") == 0) ++ return QMetaType::ULongLong; ++ if (strcmp(name, "QIconSet") == 0) ++ return QMetaType::QIcon; ++ ++ uint tp = QMetaType::type(name); ++ return tp < QMetaType::User ? tp : 0; ++} ++ ++/* ++ Returns true if the type is a QVariant types. ++*/ ++bool isVariantType(const char* type) ++{ ++ return qvariant_nameToType(type) != 0; ++} ++ ++// copied from qmetaobject.cpp ++// do not touch without touching the moc as well ++enum PropertyFlags { ++ Invalid = 0x00000000, ++ Readable = 0x00000001, ++ Writable = 0x00000002, ++ Resettable = 0x00000004, ++ EnumOrFlag = 0x00000008, ++ StdCppSet = 0x00000100, ++// Override = 0x00000200, ++ Designable = 0x00001000, ++ ResolveDesignable = 0x00002000, ++ Scriptable = 0x00004000, ++ ResolveScriptable = 0x00008000, ++ Stored = 0x00010000, ++ ResolveStored = 0x00020000, ++ Editable = 0x00040000, ++ ResolveEditable = 0x00080000, ++ User = 0x00100000, ++ ResolveUser = 0x00200000, ++ Notify = 0x00400000, ++ Dynamic = 0x00800000 ++}; ++ ++enum MethodFlags { ++ AccessPrivate = 0x00, ++ AccessProtected = 0x01, ++ AccessPublic = 0x02, ++ AccessMask = 0x03, //mask ++ ++ MethodMethod = 0x00, ++ MethodSignal = 0x04, ++ MethodSlot = 0x08, ++ MethodConstructor = 0x0c, ++ MethodTypeMask = 0x0c, ++ ++ MethodCompatibility = 0x10, ++ MethodCloned = 0x20, ++ MethodScriptable = 0x40 ++}; ++ ++struct QMetaObjectPrivate ++{ ++ int revision; ++ int className; ++ int classInfoCount, classInfoData; ++ int methodCount, methodData; ++ int propertyCount, propertyData; ++ int enumeratorCount, enumeratorData; ++ int constructorCount, constructorData; ++ int flags; ++}; ++ ++static inline const QMetaObjectPrivate *priv(const uint* data) ++{ return reinterpret_cast<const QMetaObjectPrivate*>(data); } ++// end of copied lines from qmetaobject.cpp ++ ++class QMetaMethodBuilderPrivate ++{ ++public: ++ QMetaMethodBuilderPrivate ++ (QMetaMethod::MethodType _methodType, ++ const QByteArray& _signature, ++ const QByteArray& _returnType = QByteArray(), ++ QMetaMethod::Access _access = QMetaMethod::Public) ++ : signature(QMetaObject::normalizedSignature(_signature.constData())), ++ returnType(QMetaObject::normalizedType(_returnType)), ++ attributes(((int)_access) | (((int)_methodType) << 2)) ++ { ++ } ++ ++ QByteArray signature; ++ QByteArray returnType; ++ QList<QByteArray> parameterNames; ++ QByteArray tag; ++ int attributes; ++ ++ QMetaMethod::MethodType methodType() const ++ { ++ return (QMetaMethod::MethodType)((attributes & MethodTypeMask) >> 2); ++ } ++ ++ QMetaMethod::Access access() const ++ { ++ return (QMetaMethod::Access)(attributes & AccessMask); ++ } ++ ++ void setAccess(QMetaMethod::Access value) ++ { ++ attributes = ((attributes & ~AccessMask) | (int)value); ++ } ++}; ++ ++class QMetaPropertyBuilderPrivate ++{ ++public: ++ QMetaPropertyBuilderPrivate ++ (const QByteArray& _name, const QByteArray& _type, int notifierIdx=-1) ++ : name(_name), ++ type(QMetaObject::normalizedType(_type.constData())), ++ flags(Readable | Writable | Scriptable), notifySignal(-1) ++ { ++ if (notifierIdx >= 0) { ++ flags |= Notify; ++ notifySignal = notifierIdx; ++ } ++ } ++ ++ QByteArray name; ++ QByteArray type; ++ int flags; ++ int notifySignal; ++ ++ bool flag(int f) const ++ { ++ return ((flags & f) != 0); ++ } ++ ++ void setFlag(int f, bool value) ++ { ++ if (value) ++ flags |= f; ++ else ++ flags &= ~f; ++ } ++}; ++ ++class QMetaEnumBuilderPrivate ++{ ++public: ++ QMetaEnumBuilderPrivate(const QByteArray& _name) ++ : name(_name), isFlag(false) ++ { ++ } ++ ++ QByteArray name; ++ bool isFlag; ++ QList<QByteArray> keys; ++ QList<int> values; ++}; ++ ++class QMetaObjectBuilderPrivate ++{ ++public: ++ QMetaObjectBuilderPrivate() ++ : flags(0) ++ { ++ superClass = &QObject::staticMetaObject; ++ staticMetacallFunction = 0; ++ } ++ ++ QByteArray className; ++ const QMetaObject *superClass; ++ QMetaObjectBuilder::StaticMetacallFunction staticMetacallFunction; ++ QList<QMetaMethodBuilderPrivate> methods; ++ QList<QMetaMethodBuilderPrivate> constructors; ++ QList<QMetaPropertyBuilderPrivate> properties; ++ QList<QByteArray> classInfoNames; ++ QList<QByteArray> classInfoValues; ++ QList<QMetaEnumBuilderPrivate> enumerators; ++#ifdef Q_NO_DATA_RELOCATION ++ QList<QMetaObjectAccessor> relatedMetaObjects; ++#else ++ QList<const QMetaObject *> relatedMetaObjects; ++#endif ++ int flags; ++}; ++ ++/*! ++ Constructs a new QMetaObjectBuilder. ++*/ ++QMetaObjectBuilder::QMetaObjectBuilder() ++{ ++ d = new QMetaObjectBuilderPrivate(); ++} ++ ++/*! ++ Constructs a new QMetaObjectBuilder which is a copy of the ++ meta object information in \a prototype. Note: the super class ++ contents for \a prototype are not copied, only the immediate ++ class that is defined by \a prototype. ++ ++ The \a members parameter indicates which members of \a prototype ++ should be added. The default is AllMembers. ++ ++ \sa addMetaObject() ++*/ ++QMetaObjectBuilder::QMetaObjectBuilder ++ (const QMetaObject *prototype, QMetaObjectBuilder::AddMembers members) ++{ ++ d = new QMetaObjectBuilderPrivate(); ++ addMetaObject(prototype, members); ++} ++ ++/*! ++ Destroys this meta object builder. ++*/ ++QMetaObjectBuilder::~QMetaObjectBuilder() ++{ ++ delete d; ++} ++ ++/*! ++ Returns the name of the class being constructed by this ++ meta object builder. The default value is an empty QByteArray. ++ ++ \sa setClassName(), superClass() ++*/ ++QByteArray QMetaObjectBuilder::className() const ++{ ++ return d->className; ++} ++ ++/*! ++ Sets the \a name of the class being constructed by this ++ meta object builder. ++ ++ \sa className(), setSuperClass() ++*/ ++void QMetaObjectBuilder::setClassName(const QByteArray& name) ++{ ++ d->className = name; ++} ++ ++/*! ++ Returns the superclass meta object of the class being constructed ++ by this meta object builder. The default value is the meta object ++ for QObject. ++ ++ \sa setSuperClass(), className() ++*/ ++const QMetaObject *QMetaObjectBuilder::superClass() const ++{ ++ return d->superClass; ++} ++ ++/*! ++ Sets the superclass meta object of the class being constructed ++ by this meta object builder to \a meta. The \a meta parameter ++ must not be null. ++ ++ \sa superClass(), setClassName() ++*/ ++void QMetaObjectBuilder::setSuperClass(const QMetaObject *meta) ++{ ++ Q_ASSERT(meta); ++ d->superClass = meta; ++} ++ ++/*! ++ Returns the flags of the class being constructed by this meta object ++ builder. ++ ++ \sa setFlags() ++*/ ++QMetaObjectBuilder::MetaObjectFlags QMetaObjectBuilder::flags() const ++{ ++ return (QMetaObjectBuilder::MetaObjectFlags)d->flags; ++} ++ ++/*! ++ Sets the \a flags of the class being constructed by this meta object ++ builder. ++ ++ \sa flags() ++*/ ++void QMetaObjectBuilder::setFlags(MetaObjectFlags flags) ++{ ++ d->flags = flags; ++} ++ ++/*! ++ Returns the number of methods in this class, excluding the number ++ of methods in the base class. These include signals and slots ++ as well as normal member functions. ++ ++ \sa addMethod(), method(), removeMethod(), indexOfMethod() ++*/ ++int QMetaObjectBuilder::methodCount() const ++{ ++ return d->methods.size(); ++} ++ ++/*! ++ Returns the number of constructors in this class. ++ ++ \sa addConstructor(), constructor(), removeConstructor(), indexOfConstructor() ++*/ ++int QMetaObjectBuilder::constructorCount() const ++{ ++ return d->constructors.size(); ++} ++ ++/*! ++ Returns the number of properties in this class, excluding the number ++ of properties in the base class. ++ ++ \sa addProperty(), property(), removeProperty(), indexOfProperty() ++*/ ++int QMetaObjectBuilder::propertyCount() const ++{ ++ return d->properties.size(); ++} ++ ++/*! ++ Returns the number of enumerators in this class, excluding the ++ number of enumerators in the base class. ++ ++ \sa addEnumerator(), enumerator(), removeEnumerator() ++ \sa indexOfEnumerator() ++*/ ++int QMetaObjectBuilder::enumeratorCount() const ++{ ++ return d->enumerators.size(); ++} ++ ++/*! ++ Returns the number of items of class information in this class, ++ exclusing the number of items of class information in the base class. ++ ++ \sa addClassInfo(), classInfoName(), classInfoValue(), removeClassInfo() ++ \sa indexOfClassInfo() ++*/ ++int QMetaObjectBuilder::classInfoCount() const ++{ ++ return d->classInfoNames.size(); ++} ++ ++/*! ++ Returns the number of related meta objects that are associated ++ with this class. ++ ++ Related meta objects are used when resolving the enumerated type ++ associated with a property, where the enumerated type is in a ++ different class from the property. ++ ++ \sa addRelatedMetaObject(), relatedMetaObject() ++ \sa removeRelatedMetaObject() ++*/ ++int QMetaObjectBuilder::relatedMetaObjectCount() const ++{ ++ return d->relatedMetaObjects.size(); ++} ++ ++/*! ++ Adds a new public method to this class with the specified \a signature. ++ Returns an object that can be used to adjust the other attributes ++ of the method. The \a signature will be normalized before it is ++ added to the class. ++ ++ \sa method(), methodCount(), removeMethod(), indexOfMethod() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addMethod(const QByteArray& signature) ++{ ++ int index = d->methods.size(); ++ d->methods.append(QMetaMethodBuilderPrivate(QMetaMethod::Method, signature)); ++ return QMetaMethodBuilder(this, index); ++} ++ ++/*! ++ Adds a new public method to this class with the specified ++ \a signature and \a returnType. Returns an object that can be ++ used to adjust the other attributes of the method. The \a signature ++ and \a returnType will be normalized before they are added to ++ the class. If \a returnType is empty, then it indicates that ++ the method has \c{void} as its return type. ++ ++ \sa method(), methodCount(), removeMethod(), indexOfMethod() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addMethod ++ (const QByteArray& signature, const QByteArray& returnType) ++{ ++ int index = d->methods.size(); ++ d->methods.append(QMetaMethodBuilderPrivate ++ (QMetaMethod::Method, signature, returnType)); ++ return QMetaMethodBuilder(this, index); ++} ++ ++/*! ++ Adds a new public method to this class that has the same information as ++ \a prototype. This is used to clone the methods of an existing ++ QMetaObject. Returns an object that can be used to adjust the ++ attributes of the method. ++ ++ This function will detect if \a prototype is an ordinary method, ++ signal, slot, or constructor and act accordingly. ++ ++ \sa method(), methodCount(), removeMethod(), indexOfMethod() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addMethod(const QMetaMethod& prototype) ++{ ++ QMetaMethodBuilder method; ++ if (prototype.methodType() == QMetaMethod::Method) ++ method = addMethod(prototype.signature()); ++ else if (prototype.methodType() == QMetaMethod::Signal) ++ method = addSignal(prototype.signature()); ++ else if (prototype.methodType() == QMetaMethod::Slot) ++ method = addSlot(prototype.signature()); ++ else if (prototype.methodType() == QMetaMethod::Constructor) ++ method = addConstructor(prototype.signature()); ++ method.setReturnType(prototype.typeName()); ++ method.setParameterNames(prototype.parameterNames()); ++ method.setTag(prototype.tag()); ++ method.setAccess(prototype.access()); ++ method.setAttributes(prototype.attributes()); ++ return method; ++} ++ ++/*! ++ Adds a new public slot to this class with the specified \a signature. ++ Returns an object that can be used to adjust the other attributes ++ of the slot. The \a signature will be normalized before it is ++ added to the class. ++ ++ \sa addMethod(), addSignal(), indexOfSlot() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addSlot(const QByteArray& signature) ++{ ++ int index = d->methods.size(); ++ d->methods.append(QMetaMethodBuilderPrivate(QMetaMethod::Slot, signature)); ++ return QMetaMethodBuilder(this, index); ++} ++ ++/*! ++ Adds a new signal to this class with the specified \a signature. ++ Returns an object that can be used to adjust the other attributes ++ of the signal. The \a signature will be normalized before it is ++ added to the class. ++ ++ \sa addMethod(), addSlot(), indexOfSignal() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addSignal(const QByteArray& signature) ++{ ++ int index = d->methods.size(); ++ d->methods.append(QMetaMethodBuilderPrivate ++ (QMetaMethod::Signal, signature, QByteArray(), QMetaMethod::Protected)); ++ return QMetaMethodBuilder(this, index); ++} ++ ++/*! ++ Adds a new constructor to this class with the specified \a signature. ++ Returns an object that can be used to adjust the other attributes ++ of the constructor. The \a signature will be normalized before it is ++ added to the class. ++ ++ \sa constructor(), constructorCount(), removeConstructor() ++ \sa indexOfConstructor() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addConstructor(const QByteArray& signature) ++{ ++ int index = d->constructors.size(); ++ d->constructors.append(QMetaMethodBuilderPrivate(QMetaMethod::Constructor, signature)); ++ return QMetaMethodBuilder(this, -(index + 1)); ++} ++ ++/*! ++ Adds a new constructor to this class that has the same information as ++ \a prototype. This is used to clone the constructors of an existing ++ QMetaObject. Returns an object that can be used to adjust the ++ attributes of the constructor. ++ ++ This function requires that \a prototype be a constructor. ++ ++ \sa constructor(), constructorCount(), removeConstructor() ++ \sa indexOfConstructor() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addConstructor(const QMetaMethod& prototype) ++{ ++ Q_ASSERT(prototype.methodType() == QMetaMethod::Constructor); ++ QMetaMethodBuilder ctor = addConstructor(prototype.signature()); ++ ctor.setReturnType(prototype.typeName()); ++ ctor.setParameterNames(prototype.parameterNames()); ++ ctor.setTag(prototype.tag()); ++ ctor.setAccess(prototype.access()); ++ ctor.setAttributes(prototype.attributes()); ++ return ctor; ++} ++ ++/*! ++ Adds a new readable/writable property to this class with the ++ specified \a name and \a type. Returns an object that can be used ++ to adjust the other attributes of the property. The \a type will ++ be normalized before it is added to the class. \a notifierId will ++ be registered as the property's \e notify signal. ++ ++ \sa property(), propertyCount(), removeProperty(), indexOfProperty() ++*/ ++QMetaPropertyBuilder QMetaObjectBuilder::addProperty ++ (const QByteArray& name, const QByteArray& type, int notifierId) ++{ ++ int index = d->properties.size(); ++ d->properties.append(QMetaPropertyBuilderPrivate(name, type, notifierId)); ++ return QMetaPropertyBuilder(this, index); ++} ++ ++/*! ++ Adds a new property to this class that has the same information as ++ \a prototype. This is used to clone the properties of an existing ++ QMetaObject. Returns an object that can be used to adjust the ++ attributes of the property. ++ ++ \sa property(), propertyCount(), removeProperty(), indexOfProperty() ++*/ ++QMetaPropertyBuilder QMetaObjectBuilder::addProperty(const QMetaProperty& prototype) ++{ ++ QMetaPropertyBuilder property = addProperty(prototype.name(), prototype.typeName()); ++ property.setReadable(prototype.isReadable()); ++ property.setWritable(prototype.isWritable()); ++ property.setResettable(prototype.isResettable()); ++ property.setDesignable(prototype.isDesignable()); ++ property.setScriptable(prototype.isScriptable()); ++ property.setStored(prototype.isStored()); ++ property.setEditable(prototype.isEditable()); ++ property.setUser(prototype.isUser()); ++ property.setStdCppSet(prototype.hasStdCppSet()); ++ property.setEnumOrFlag(prototype.isEnumType()); ++ if (prototype.hasNotifySignal()) { ++ // Find an existing method for the notify signal, or add a new one. ++ QMetaMethod method = prototype.notifySignal(); ++ int index = indexOfMethod(method.signature()); ++ if (index == -1) ++ index = addMethod(method).index(); ++ d->properties[property._index].notifySignal = index; ++ d->properties[property._index].setFlag(Notify, true); ++ } ++ return property; ++} ++ ++/*! ++ Adds a new enumerator to this class with the specified ++ \a name. Returns an object that can be used to adjust ++ the other attributes of the enumerator. ++ ++ \sa enumerator(), enumeratorCount(), removeEnumerator(), ++ \sa indexOfEnumerator() ++*/ ++QMetaEnumBuilder QMetaObjectBuilder::addEnumerator(const QByteArray& name) ++{ ++ int index = d->enumerators.size(); ++ d->enumerators.append(QMetaEnumBuilderPrivate(name)); ++ return QMetaEnumBuilder(this, index); ++} ++ ++/*! ++ Adds a new enumerator to this class that has the same information as ++ \a prototype. This is used to clone the enumerators of an existing ++ QMetaObject. Returns an object that can be used to adjust the ++ attributes of the enumerator. ++ ++ \sa enumerator(), enumeratorCount(), removeEnumerator(), ++ \sa indexOfEnumerator() ++*/ ++QMetaEnumBuilder QMetaObjectBuilder::addEnumerator(const QMetaEnum& prototype) ++{ ++ QMetaEnumBuilder en = addEnumerator(prototype.name()); ++ en.setIsFlag(prototype.isFlag()); ++ int count = prototype.keyCount(); ++ for (int index = 0; index < count; ++index) ++ en.addKey(prototype.key(index), prototype.value(index)); ++ return en; ++} ++ ++/*! ++ Adds \a name and \a value as an item of class information to this class. ++ Returns the index of the new item of class information. ++ ++ \sa classInfoCount(), classInfoName(), classInfoValue(), removeClassInfo() ++ \sa indexOfClassInfo() ++*/ ++int QMetaObjectBuilder::addClassInfo(const QByteArray& name, const QByteArray& value) ++{ ++ int index = d->classInfoNames.size(); ++ d->classInfoNames += name; ++ d->classInfoValues += value; ++ return index; ++} ++ ++/*! ++ Adds \a meta to this class as a related meta object. Returns ++ the index of the new related meta object entry. ++ ++ Related meta objects are used when resolving the enumerated type ++ associated with a property, where the enumerated type is in a ++ different class from the property. ++ ++ \sa relatedMetaObjectCount(), relatedMetaObject() ++ \sa removeRelatedMetaObject() ++*/ ++#ifdef Q_NO_DATA_RELOCATION ++int QMetaObjectBuilder::addRelatedMetaObject(const QMetaObjectAccessor &meta) ++#else ++int QMetaObjectBuilder::addRelatedMetaObject(const QMetaObject *meta) ++#endif ++{ ++ Q_ASSERT(meta); ++ int index = d->relatedMetaObjects.size(); ++ d->relatedMetaObjects.append(meta); ++ return index; ++} ++ ++/*! ++ Adds the contents of \a prototype to this meta object builder. ++ This function is useful for cloning the contents of an existing QMetaObject. ++ ++ The \a members parameter indicates which members of \a prototype ++ should be added. The default is AllMembers. ++*/ ++void QMetaObjectBuilder::addMetaObject ++ (const QMetaObject *prototype, QMetaObjectBuilder::AddMembers members) ++{ ++ Q_ASSERT(prototype); ++ int index; ++ ++ if ((members & ClassName) != 0) ++ d->className = prototype->className(); ++ ++ if ((members & SuperClass) != 0) ++ d->superClass = prototype->superClass(); ++ ++ if ((members & (Methods | Signals | Slots)) != 0) { ++ for (index = prototype->methodOffset(); index < prototype->methodCount(); ++index) { ++ QMetaMethod method = prototype->method(index); ++ if (method.methodType() != QMetaMethod::Signal) { ++ if (method.access() == QMetaMethod::Public && (members & PublicMethods) == 0) ++ continue; ++ if (method.access() == QMetaMethod::Private && (members & PrivateMethods) == 0) ++ continue; ++ if (method.access() == QMetaMethod::Protected && (members & ProtectedMethods) == 0) ++ continue; ++ } ++ if (method.methodType() == QMetaMethod::Method && (members & Methods) != 0) { ++ |