improved enum generation for decorators

improved sequence conversion callback
added support for inheritance chain of Python classes when deriving from a Qt wrapper

Author: florianlink

src/PythonQt.cpp

@@ -1936,15 +1936,31 @@ const QMetaObject* PythonQtPrivate::getDynamicMetaObject(PythonQtInstanceWrapper
   PythonQtDynamicClassInfo* info = wrapper->dynamicClassInfo();
   if (info) {
     if (!info->_dynamicMetaObject) {
-      buildDynamicMetaObject(((PythonQtClassWrapper*)Py_TYPE(wrapper)), prototypeMetaObject);
+      setupDynamicMetaObjectChain(((PythonQtClassWrapper*)Py_TYPE(wrapper)), prototypeMetaObject);
     }
     return info->_dynamicMetaObject;
   }
   return prototypeMetaObject;
 }
 
-void PythonQtPrivate::buildDynamicMetaObject(PythonQtClassWrapper* type, const QMetaObject* prototypeMetaObject)
+const QMetaObject* PythonQtPrivate::setupDynamicMetaObjectChain(PythonQtClassWrapper* type, const QMetaObject* prototypeMetaObject)
 {
+  if (!type->_dynamicClassInfo->_dynamicMetaObject) {
+    PyTypeObject*  superType = ((PyTypeObject *)type)->tp_base;
+    const QMetaObject* metaObjectOfParent = prototypeMetaObject;
+    if (((PythonQtClassWrapper*)superType)->_dynamicClassInfo) {
+      metaObjectOfParent = setupDynamicMetaObjectChain((PythonQtClassWrapper*)superType, prototypeMetaObject);
+    }
+    return buildDynamicMetaObject(type, metaObjectOfParent);
+  } else {
+    return type->_dynamicClassInfo->_dynamicMetaObject;
+  }
+}
+
+const QMetaObject* PythonQtPrivate::buildDynamicMetaObject(PythonQtClassWrapper* type, const QMetaObject* prototypeMetaObject)
+{
+  //std::cout << "creating " << ((PyTypeObject*)type)->tp_name << " derived from " << prototypeMetaObject->className() << std::endl;
+
   QMetaObjectBuilder builder;
   builder.setSuperClass(prototypeMetaObject);
   builder.setClassName(((PyTypeObject*)type)->tp_name);
@@ -2029,6 +2045,7 @@ void PythonQtPrivate::buildDynamicMetaObject(PythonQtClassWrapper* type, const Q
     // we don't need an own meta object, just use the one from our base class
     type->_dynamicClassInfo->_dynamicMetaObject = prototypeMetaObject;
   }
+  return type->_dynamicClassInfo->_dynamicMetaObject;
 }
 
 

src/PythonQt.h

@@ -742,7 +742,11 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
   //! get the dynamic meta object for the given wrapper. It will contain the signals/slots that have been added in Python
   const QMetaObject* getDynamicMetaObject(PythonQtInstanceWrapper* wrapper, const QMetaObject* prototypeMetaObject);
 
-  void buildDynamicMetaObject(PythonQtClassWrapper* type, const QMetaObject* prototypeMetaObject);
+  //! recursively creates the dynamic meta object chain down to the Qt class wrapper. 
+  const QMetaObject* setupDynamicMetaObjectChain(PythonQtClassWrapper* type, const QMetaObject* prototypeMetaObject);
+
+  //! builds and returns the dynamic meta object for the given type, derived from prototypeMetaObject.
+  const QMetaObject* buildDynamicMetaObject(PythonQtClassWrapper* type, const QMetaObject* prototypeMetaObject);
 
   //! redirected from shell classes, tries to call the given meta call on the Python wrapper. 
   int handleMetaCall(QObject* object, PythonQtInstanceWrapper* wrapper, QMetaObject::Call call, int id, void** args);

src/PythonQtClassInfo.cpp

@@ -738,14 +738,14 @@ QObject* PythonQtClassInfo::decorator()
       _decoratorProvider->setParent(PythonQt::priv());
       // setup enums early, since they might be needed by the constructor decorators:
       if (!_enumsCreated) {
-        createEnumWrappers();
+        createEnumWrappers(_decoratorProvider);
       }
       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();
+    createEnumWrappers(_decoratorProvider);
   }
   return _decoratorProvider;
 }
@@ -857,26 +857,30 @@ void PythonQtClassInfo::createEnumWrappers(const QMetaObject* meta)
   }
 }
 
-void PythonQtClassInfo::createEnumWrappers()
+void PythonQtClassInfo::createEnumWrappers(const QObject* decoratorProvider)
 {
   if (!_enumsCreated) {
     _enumsCreated = true;
     if (_meta) {
       createEnumWrappers(_meta);
     }
-    if (decorator()) {
-      createEnumWrappers(decorator()->metaObject());
+    if (decoratorProvider) {
+      createEnumWrappers(decoratorProvider->metaObject());
     }
     Q_FOREACH(const ParentClassInfo& info, _parentClasses) {
-      info._parent->createEnumWrappers();
+      // trigger decorator() instead of createEnumWrappers(),
+      // which will then call createEnumWrappers().
+      info._parent->decorator();
     }
   }
 }
 
 PyObject* PythonQtClassInfo::findEnumWrapper(const char* name) {
   // force enum creation
   if (!_enumsCreated) {
-    createEnumWrappers();
+    // trigger decorator() instead of createEnumWrappers(),
+    // which will then call createEnumWrappers().
+    decorator();
   }
   Q_FOREACH(const PythonQtObjectPtr& p, _enumWrappers) {
     const char* className = ((PyTypeObject*)p.object())->tp_name;

src/PythonQtClassInfo.h

@@ -239,7 +239,7 @@ class PYTHONQT_EXPORT PythonQtClassInfo {
 private:
   void updateRefCountingCBs();
 
-  void createEnumWrappers();
+  void createEnumWrappers(const QObject* decoratorProvider);
   void createEnumWrappers(const QMetaObject* meta);
   PyObject* findEnumWrapper(const char* name);
 

src/PythonQtClassWrapper.cpp

@@ -366,8 +366,17 @@ static int PythonQtClassWrapper_init(PythonQtClassWrapper* self, PyObject* args,
 
     // take the class info from the superType
     self->_classInfo = ((PythonQtClassWrapper*)superType)->classInfo();
-
     self->_dynamicClassInfo = new PythonQtDynamicClassInfo();
+
+    // take the class info from the superType and fill the whole chain
+    PyTypeObject* typeChain = (PyTypeObject *)self;
+    while (typeChain && Py_TYPE(typeChain) != &PythonQtClassWrapper_Type) {
+
+      ((PythonQtClassWrapper*)typeChain)->_classInfo = ((PythonQtClassWrapper*)superType)->classInfo();
+      ((PythonQtClassWrapper*)typeChain)->_dynamicClassInfo = new PythonQtDynamicClassInfo();
+
+      typeChain = typeChain->tp_base;
+    }
   }
 
   return 0;

src/PythonQtConversion.cpp

@@ -1153,8 +1153,11 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
     pythonToMapVariant<QVariantHash>(val, v);
     break;
   case QVariant::List:
-    if (PySequence_Check(val)) {
-      if (_pythonSequenceToQVariantListCB) {
+  {
+    bool isListOrTuple = PyList_Check(val) || PyTuple_Check(val);
+    if (isListOrTuple || PySequence_Check(val)) {
+      if (!isListOrTuple && _pythonSequenceToQVariantListCB) {
+        // Only call this if we don't have a tuple or list.
         QVariant result = (*_pythonSequenceToQVariantListCB)(val);
         if (result.isValid()) {
           return result;
@@ -1165,14 +1168,15 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
         // only get items if size is valid (>= 0)
         QVariantList list;
         PyObject* value;
-        for (int i = 0;i<count;i++) {
-          value = PySequence_GetItem(val,i);
+        for (int i = 0; i < count; i++) {
+          value = PySequence_GetItem(val, i);
           list.append(PyObjToQVariant(value, -1));
           Py_XDECREF(value);
         }
         v = list;
       }
     }
+  }
     break;
   case QVariant::StringList:
     {

src/PythonQtInstanceWrapper.cpp

@@ -452,12 +452,21 @@ static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name)
             wrapper->_obj->metaObject();
           }
         }
-        if (wrapper->dynamicClassInfo() && wrapper->dynamicClassInfo()->_classInfo) {
-          PythonQtMemberInfo member = wrapper->dynamicClassInfo()->_classInfo->member(attributeName);
-          if (member._type == PythonQtMemberInfo::Signal) {
-            PyObject* boundSignal = PythonQtSignalFunction_New(member._slot, (PyObject*)wrapper, NULL);
-            Py_DECREF(superAttr);
-            return boundSignal;
+        if (wrapper->dynamicClassInfo()) {
+          // go through the whole inheritance chain to find a signal in the dynamic class info:
+          PythonQtClassInfo* classInfo = NULL;
+          PythonQtClassWrapper* classType = (PythonQtClassWrapper*)Py_TYPE(wrapper);
+          while (classType->_dynamicClassInfo) {
+            classInfo = classType->_dynamicClassInfo->_classInfo;
+            if (classInfo) {
+              PythonQtMemberInfo member = classInfo->member(attributeName);
+              if (member._type == PythonQtMemberInfo::Signal) {
+                PyObject* boundSignal = PythonQtSignalFunction_New(member._slot, (PyObject*)wrapper, NULL);
+                Py_DECREF(superAttr);
+                return boundSignal;
+              }
+            }
+            classType = (PythonQtClassWrapper*)(((PyTypeObject*)classType)->tp_base);
           }
         }
       }