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_"
-                     bool isVariantReturn = info->parameters().at(0).typeId == PythonQtMethodInfo::Variant;
-                     if ((info->parameters().at(0).isPointer || isVariantReturn)) {
+                     if (info->parameters().at(0).isPointer) {
                        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;
-                     if (signa.startsWith("delete_")) continue;
-                     if (signa.startsWith("static_")) continue;
-                     PythonQtSlotInfo slot(m, i);
-                     l << slot.slotName();
+                     signa = signa.left(signa.indexOf('('));
+                     l << signa;
                    }
                  }
                }
                    QMetaMethod m = _meta->method(i);
                    if ((m.methodType() == QMetaMethod::Method ||
                      m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
-                     QByteArray signa(m.signature());
-                     if (signa.startsWith("new_")) continue;
-                     if (signa.startsWith("delete_")) continue;
-                     if (signa.startsWith("static_")) continue;
-                     PythonQtSlotInfo slot(m, i);
+                     PythonQtSlotInfo slot(this, 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
-               static const PythonQtMethodInfo* getCachedMethodInfo(const QMetaMethod& 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, 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