improved enum generation for decorators

florianlink · florianlink · commit f3bcda840634 · 2017-04-18T13:41:47.000Z
improved sequence conversion callback
added support for inheritance chain of Python classes when deriving from a Qt wrapper
diff --git a/src/PythonQt.cpp b/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;
 }
 
 
diff --git a/src/PythonQt.h b/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);
diff --git a/src/PythonQtClassInfo.cpp b/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;
diff --git a/src/PythonQtClassInfo.h b/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);
 
diff --git a/src/PythonQtClassWrapper.cpp b/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;
diff --git a/src/PythonQtConversion.cpp b/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:
     {
diff --git a/src/PythonQtInstanceWrapper.cpp b/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);
           }
         }
       }

Original file line number	Diff line number	Diff line change
`@@ -738,14 +738,14 @@ QObject* PythonQtClassInfo::decorator()`
`738`	`738`	`_decoratorProvider->setParent(PythonQt::priv());`
`739`	`739`	`// setup enums early, since they might be needed by the constructor decorators:`
`740`	`740`	`if (!_enumsCreated) {`
`741`		`- createEnumWrappers();`
	`741`	`+ createEnumWrappers(_decoratorProvider);`
`742`	`742`	`}`
`743`	`743`	`PythonQt::priv()->addDecorators(_decoratorProvider, PythonQtPrivate::ConstructorDecorator \| PythonQtPrivate::DestructorDecorator);`
`744`	`744`	`}`
`745`	`745`	`}`
`746`	`746`	`// check if enums need to be created and create them if they are not yet created`
`747`	`747`	`if (!_enumsCreated) {`
`748`		`- createEnumWrappers();`
	`748`	`+ createEnumWrappers(_decoratorProvider);`
`749`	`749`	`}`
`750`	`750`	`return _decoratorProvider;`
`751`	`751`	`}`
`@@ -857,26 +857,30 @@ void PythonQtClassInfo::createEnumWrappers(const QMetaObject* meta)`
`857`	`857`	`}`
`858`	`858`	`}`
`859`	`859`
`860`		`-void PythonQtClassInfo::createEnumWrappers()`
	`860`	`+void PythonQtClassInfo::createEnumWrappers(const QObject* decoratorProvider)`
`861`	`861`	`{`
`862`	`862`	`if (!_enumsCreated) {`
`863`	`863`	`_enumsCreated = true;`
`864`	`864`	`if (_meta) {`
`865`	`865`	`createEnumWrappers(_meta);`
`866`	`866`	`}`
`867`		`- if (decorator()) {`
`868`		`- createEnumWrappers(decorator()->metaObject());`
	`867`	`+ if (decoratorProvider) {`
	`868`	`+ createEnumWrappers(decoratorProvider->metaObject());`
`869`	`869`	`}`
`870`	`870`	`Q_FOREACH(const ParentClassInfo& info, _parentClasses) {`
`871`		`- info._parent->createEnumWrappers();`
	`871`	`+ // trigger decorator() instead of createEnumWrappers(),`
	`872`	`+ // which will then call createEnumWrappers().`
	`873`	`+ info._parent->decorator();`
`872`	`874`	`}`
`873`	`875`	`}`
`874`	`876`	`}`
`875`	`877`
`876`	`878`	`PyObject* PythonQtClassInfo::findEnumWrapper(const char* name) {`
`877`	`879`	`// force enum creation`
`878`	`880`	`if (!_enumsCreated) {`
`879`		`- createEnumWrappers();`
	`881`	`+ // trigger decorator() instead of createEnumWrappers(),`
	`882`	`+ // which will then call createEnumWrappers().`
	`883`	`+ decorator();`
`880`	`884`	`}`
`881`	`885`	`Q_FOREACH(const PythonQtObjectPtr& p, _enumWrappers) {`
`882`	`886`	`const char* className = ((PyTypeObject*)p.object())->tp_name;`
Original file line number	Diff line number	Diff line change
`@@ -452,12 +452,21 @@ static PyObject PythonQtInstanceWrapper_getattro(PyObject obj,PyObject *name)`
`452`	`452`	`wrapper->_obj->metaObject();`
`453`	`453`	`}`
`454`	`454`	`}`
`455`		`- if (wrapper->dynamicClassInfo() && wrapper->dynamicClassInfo()->_classInfo) {`
`456`		`- PythonQtMemberInfo member = wrapper->dynamicClassInfo()->_classInfo->member(attributeName);`
`457`		`- if (member._type == PythonQtMemberInfo::Signal) {`
`458`		`- PyObject* boundSignal = PythonQtSignalFunction_New(member._slot, (PyObject*)wrapper, NULL);`
`459`		`- Py_DECREF(superAttr);`
`460`		`- return boundSignal;`
	`455`	`+ if (wrapper->dynamicClassInfo()) {`
	`456`	`+ // go through the whole inheritance chain to find a signal in the dynamic class info:`
	`457`	`+ PythonQtClassInfo* classInfo = NULL;`
	`458`	`+ PythonQtClassWrapper* classType = (PythonQtClassWrapper*)Py_TYPE(wrapper);`
	`459`	`+ while (classType->_dynamicClassInfo) {`
	`460`	`+ classInfo = classType->_dynamicClassInfo->_classInfo;`
	`461`	`+ if (classInfo) {`
	`462`	`+ PythonQtMemberInfo member = classInfo->member(attributeName);`
	`463`	`+ if (member._type == PythonQtMemberInfo::Signal) {`
	`464`	`+ PyObject* boundSignal = PythonQtSignalFunction_New(member._slot, (PyObject*)wrapper, NULL);`
	`465`	`+ Py_DECREF(superAttr);`
	`466`	`+ return boundSignal;`
	`467`	`+ }`
	`468`	`+ }`
	`469`	`+ classType = (PythonQtClassWrapper)(((PyTypeObject)classType)->tp_base);`
`461`	`470`	`}`
`462`	`471`	`}`
`463`	`472`	`}`