GIT_REPOSITORIES/LPP/PythonQt Commit - r54:8f57e6dac237

cleanup of code and addition of (yet unused) classinfo passed to method/slot info to allow local enum support on creation...

florianlink -

r54:8f57e6dac237

parent child

Context file:

r54:8f57e6dac237

Collapse all files

src/PythonQt.cpp +6 -8

                 QMetaMethod m = o->metaObject()->method(i);
                 if ((m.methodType() == QMetaMethod::Method ||
                   m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
-                 const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m);
+                  const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                   if (qstrncmp(m.signature(), "new_", 4)==0) {
                     if ((decoTypes & ConstructorDecorator) == 0) continue;
-                    // either it returns a * or a QVariant and the name starts with "new_"
+                    if (info->parameters().at(0).isPointer) {
-                    bool isVariantReturn = info->parameters().at(0).typeId == PythonQtMethodInfo::Variant;
-                    if ((info->parameters().at(0).isPointer || isVariantReturn)) {
                       QByteArray signature = m.signature();
                       QByteArray nameOfClass = signature.mid(4, signature.indexOf('(')-4);
                       PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
-                      PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(m, i, o, PythonQtSlotInfo::ClassDecorator);
+                      PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                       classInfo->addConstructor(newSlot);
                     }
                   } else if (qstrncmp(m.signature(), "delete_", 7)==0) {
                     QByteArray signature = m.signature();
                     QByteArray nameOfClass = signature.mid(7, signature.indexOf('(')-7);
                     PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
-                    PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(m, i, o, PythonQtSlotInfo::ClassDecorator);
+                    PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                     classInfo->setDestructor(newSlot);
                   } else if (qstrncmp(m.signature(), "static_", 7)==0) {
                     if ((decoTypes & StaticDecorator) == 0) continue;
                     QByteArray nameOfClass = signature.mid(signature.indexOf('_')+1);
                     nameOfClass = nameOfClass.mid(0, nameOfClass.indexOf('_'));
                     PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
-                    PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(m, i, o, PythonQtSlotInfo::ClassDecorator);
+                    PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                     classInfo->addDecoratorSlot(newSlot);
                   } else {
                     if ((decoTypes & InstanceDecorator) == 0) continue;
                       PythonQtMethodInfo::ParameterInfo p = info->parameters().at(1);
                       if (p.isPointer) {
                         PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(p.name);
-                        PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(m, i, o, PythonQtSlotInfo::InstanceDecorator);
+                        PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::InstanceDecorator);
                         classInfo->addDecoratorSlot(newSlot);
                       }
                     }

src/PythonQtClassInfo.cpp +10 -12

                     // check if same length and same name
                     if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
                       found = true;
-                      PythonQtSlotInfo* info = new PythonQtSlotInfo(m, i, decoratorProvider, isClassDeco?PythonQtSlotInfo::ClassDecorator:PythonQtSlotInfo::InstanceDecorator);
+                      PythonQtSlotInfo* info = new PythonQtSlotInfo(this, m, i, decoratorProvider, isClassDeco?PythonQtSlotInfo::ClassDecorator:PythonQtSlotInfo::InstanceDecorator);
                       info->setUpcastingOffset(upcastingOffset);
                       //qDebug()<< "adding " << decoratorProvider->metaObject()->className() << " " << memberName << " " << upcastingOffset;
                       if (tail) {
                     // check if same length and same name
                     if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
                       found = true;
-                      PythonQtSlotInfo* info = new PythonQtSlotInfo(m, i);
+                      PythonQtSlotInfo* info = new PythonQtSlotInfo(this, m, i);
                       if (tail) {
                         tail->setNextInfo(info);
                       } else {
                   if ((m.methodType() == QMetaMethod::Method ||
                     m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     QByteArray signa(m.signature());
-                    if (signa.startsWith("new_")) continue;
+                    signa = signa.left(signa.indexOf('('));
-                    if (signa.startsWith("delete_")) continue;
+                    l << signa;
-                    if (signa.startsWith("static_")) continue;
-                    PythonQtSlotInfo slot(m, i);
-                    l << slot.slotName();
                   }
                 }
               }
                   QMetaMethod m = _meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                     m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
-                    QByteArray signa(m.signature());
+                    PythonQtSlotInfo slot(this, m, i);
-                    if (signa.startsWith("new_")) continue;
-                    if (signa.startsWith("delete_")) continue;
-                    if (signa.startsWith("static_")) continue;
-                    PythonQtSlotInfo slot(m, i);
                     h += slot.fullSignature()+ "\n";
                   }
                 }
                 _decoratorProvider = (*_decoratorProviderCB)();
                 if (_decoratorProvider) {
                   _decoratorProvider->setParent(PythonQt::priv());
+                  // setup enums early, since they might be needed by the constructor decorators:
+                  if (!_enumsCreated) {
+                    createEnumWrappers();
+                  }
                   PythonQt::priv()->addDecorators(_decoratorProvider, PythonQtPrivate::ConstructorDecorator | PythonQtPrivate::DestructorDecorator);
                 }
               }
+              // check if enums need to be created and create them if they are not yet created
               if (!_enumsCreated) {
                 createEnumWrappers();
               }

src/PythonQtMethodInfo.cpp +5 -4

             //----------------------------------------------------------------------------------
             #include "PythonQtMethodInfo.h"
+            #include "PythonQtClassInfo.h"
             #include <iostream>
             QHash<QByteArray, PythonQtMethodInfo*> PythonQtMethodInfo::_cachedSignatures;
             QHash<QByteArray, QByteArray> PythonQtMethodInfo::_parameterNameAliases;
-            PythonQtMethodInfo::PythonQtMethodInfo(const QMetaMethod& meta)
+            PythonQtMethodInfo::PythonQtMethodInfo(const QMetaMethod& meta, PythonQtClassInfo* classInfo)
             {
             #ifdef PYTHONQT_DEBUG
               QByteArray sig(meta.signature());
               }
             }
-            const PythonQtMethodInfo* PythonQtMethodInfo::getCachedMethodInfo(const QMetaMethod& signal)
+            const PythonQtMethodInfo* PythonQtMethodInfo::getCachedMethodInfo(const QMetaMethod& signal, PythonQtClassInfo* classInfo)
             {
               QByteArray sig(signal.signature());
               sig = sig.mid(sig.indexOf('('));
               QByteArray fullSig = QByteArray(signal.typeName()) + " " + sig;
               PythonQtMethodInfo* result = _cachedSignatures.value(fullSig);
               if (!result) {
-                result = new PythonQtMethodInfo(signal);
+                result = new PythonQtMethodInfo(signal, classInfo);
                 _cachedSignatures.insert(fullSig, result);
               }
               return result;
               QByteArray sig = QMetaObject::normalizedSignature(signature);
               int idx = metaObject->indexOfMethod(sig);
               QMetaMethod meta = metaObject->method(idx);
-              return PythonQtMethodInfo::getCachedMethodInfo(meta);
+              return PythonQtMethodInfo::getCachedMethodInfo(meta, NULL);
             }
             void PythonQtMethodInfo::fillParameterInfo(ParameterInfo& type, const QByteArray& orgName)

src/PythonQtMethodInfo.h +8 -6

             #include <QList>
             #include <QMetaMethod>
+            class PythonQtClassInfo;
             //! stores information about a specific signal/slot/method
             class PYTHONQT_EXPORT PythonQtMethodInfo
             {
               PythonQtMethodInfo() {};
               ~PythonQtMethodInfo() {};
-              PythonQtMethodInfo(const QMetaMethod& meta);
+              PythonQtMethodInfo(const QMetaMethod& meta, PythonQtClassInfo* classInfo);
               PythonQtMethodInfo(const PythonQtMethodInfo& other) {
                 _parameters = other._parameters;
               }
               //! returns the method info of the signature, uses a cache internally to speed up
-              //! multiple requests for the same method
+              //! multiple requests for the same method, classInfo is passed to allow local enum resolution (if NULL is passed, no local enums are recognized)
-              static const PythonQtMethodInfo* getCachedMethodInfo(const QMetaMethod& method);
+              static const PythonQtMethodInfo* getCachedMethodInfo(const QMetaMethod& method, PythonQtClassInfo* classInfo);
-              //! get the cached method info by finding the meta method on the meta object via its signature
+              //! get the cached method info by finding the meta method on the meta object via its signature, enums are only supported with leading namespace::
               static const PythonQtMethodInfo* getCachedMethodInfoFromMetaObjectAndSignature(const QMetaObject* metaObject, const char* signature);
               //! cleanup the cache
                 _upcastingOffset = 0;
               }
-              PythonQtSlotInfo(const QMetaMethod& meta, int slotIndex, QObject* decorator = NULL, Type type = MemberSlot ):PythonQtMethodInfo()
+              PythonQtSlotInfo(PythonQtClassInfo* classInfo, const QMetaMethod& meta, int slotIndex, QObject* decorator = NULL, Type type = MemberSlot ):PythonQtMethodInfo()
               {
-                const PythonQtMethodInfo* info = getCachedMethodInfo(meta);
+                const PythonQtMethodInfo* info = getCachedMethodInfo(meta, classInfo);
                 _meta = meta;
                 _parameters = info->parameters();
                 _slotIndex = slotIndex;

src/PythonQtSignalReceiver.cpp +12 -1

             PythonQtSignalReceiver::PythonQtSignalReceiver(QObject* obj):PythonQtSignalReceiverBase(obj)
             {
               _obj = obj;
+              // fetch the class info for object, since we will need to for correct enum resolution in
+              // signals
+              _objClassInfo = PythonQt::priv()->getClassInfo(obj->metaObject());
+              if (!_objClassInfo || !_objClassInfo->isQObject()) {
+                PythonQt::self()->registerClass(obj->metaObject());
+                _objClassInfo = PythonQt::priv()->getClassInfo(obj->metaObject());
+              }
+              // force decorator/enum creation
+              _objClassInfo->decorator();
               _slotCount = staticMetaObject.methodOffset();
             }
               if (sigId>=0) {
                 // create PythonQtMethodInfo from signal
                 QMetaMethod meta = _obj->metaObject()->method(sigId);
-                const PythonQtMethodInfo* signalInfo = PythonQtMethodInfo::getCachedMethodInfo(meta);
+                const PythonQtMethodInfo* signalInfo = PythonQtMethodInfo::getCachedMethodInfo(meta, _objClassInfo);
                 PythonQtSignalTarget t(sigId, signalInfo, _slotCount, callable);
                 _targets.append(t);
                 // now connect to ourselves with the new slot id

src/PythonQtSignalReceiver.h +2 0

             #include "PythonQtObjectPtr.h"
             class PythonQtMethodInfo;
+            class PythonQtClassInfo;
             //! stores information about a signal target
             /*! copy construction and assignment works fine with the C++ standard behaviour and are thus not implemented
               int getSignalIndex(const char* signal);
               QObject* _obj;
+              PythonQtClassInfo* _objClassInfo;
               int _slotCount;
               // linear list may get slow on multiple targets, but I think typically we have many objects and just a few signals
               QList<PythonQtSignalTarget> _targets;

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages