added initial support for passing ownership to C++ and Python using templates as markup

git-svn-id: http://svn.code.sf.net/p/pythonqt/code/trunk@375 ea8d5007-eb21-0410-b261-ccb3ea6e24a9

Author: florianlink

src/PythonQt.cpp

@@ -238,6 +238,8 @@ void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
       Py_INCREF(obj);
       PyModule_AddObject(pack2, enumNames[i], obj);
     }
+
+    _self->priv()->pythonQtModule().addObject("Debug", _self->priv()->_debugAPI);
   }
 }
 
@@ -314,7 +316,6 @@ PythonQt::PythonQt(int flags, const QByteArray& pythonQtModuleName)
   Py_INCREF(&PythonQtStdInRedirectType);
 
   initPythonQtModule(flags & RedirectStdOut, pythonQtModuleName);
-
 }
 
 PythonQt::~PythonQt() {
@@ -1290,6 +1291,7 @@ PythonQtPrivate::PythonQtPrivate()
   _profilingCB = NULL;
   _hadError = false;
   _systemExitExceptionHandlerEnabled = false;
+  _debugAPI = new PythonQtDebugAPI(this);
 }
 
 void PythonQtPrivate::setupSharedLibrarySuffixes()
@@ -2013,16 +2015,26 @@ QString PythonQtPrivate::getSignature(PyObject* object)
 void PythonQtPrivate::shellClassDeleted( void* shellClass )
 {
   PythonQtInstanceWrapper* wrap = _wrappedObjects.value(shellClass);
-  if (wrap && wrap->_wrappedPtr) {
-    // this is a pure C++ wrapper and the shell has gone, so we need
-    // to set the _wrappedPtr to NULL on the wrapper
-    wrap->_wrappedPtr = NULL;
-    // and then we remove the wrapper, since the wrapped class is gone
-    _wrappedObjects.remove(shellClass);
-  }
-  // if the wrapper is a QObject, we do not handle this here,
-  // it will be handled by the QPointer<> to the QObject, which becomes NULL
-  // via the QObject destructor.
+  if (wrap) {
+    if (wrap->_wrappedPtr) {
+      // this is a pure C++ wrapper and the shell has gone, so we need
+      // to set the _wrappedPtr to NULL on the wrapper
+      wrap->_wrappedPtr = NULL;
+      // and then we remove the wrapper, since the wrapped class is gone
+      _wrappedObjects.remove(shellClass);
+    }
+    // if the wrapper is a QObject, we do not handle this here,
+    // it will be handled by the QPointer<> to the QObject, which becomes NULL
+    // via the QObject destructor.
+
+    // if the shell was owned by C++ and is deleted via C++, we
+    // need to decrement the ref-count of the wrapper so that is can
+    // be released.
+    if (wrap->_shellInstanceRefCountsWrapper) {
+      Py_DECREF((PyObject*)wrap);
+      wrap->_shellInstanceRefCountsWrapper = false;
+    }
+  }
 }
 
 PyObject* PythonQtPrivate::wrapMemoryAsBuffer( const void* data, Py_ssize_t size )

src/PythonQt.h

@@ -79,6 +79,58 @@ template<class T> void PythonQtSetInstanceWrapperOnShell(void* object, PythonQtI
   (reinterpret_cast<T*>(object))->_wrapper = wrapper;
 }
 
+//! Helper template that allows to pass the ownership of a C++ instance between C++ and Python
+//! (it is used as a slot return type or parameter type so that it can be detected by the PythonQt
+//!  slot calling code).
+template<class T>
+class PythonQtPassOwnershipToCPP
+{
+  public:
+    //! Allow conversion from T to PythonQtPassOwnershipToCPP<T>
+    PythonQtPassOwnershipToCPP(const T& t):_t(t) {}
+    //! Allow conversion from PythonQtPassOwnershipToCPP<T> to T
+    operator T() const { return _t; }
+
+    //! Stored value. This is important so that it has the same memory layout
+    //! as a pointer if T is a pointer type (which is the typical use case for this class).
+    T _t;
+};
+
+//! Helper template that allows to pass the ownership of a C++ instance between C++ and Python
+//! (it is used as a slot return type or parameter type so that it can be detected by the PythonQt
+//!  slot calling code).
+template<class T>
+class PythonQtPassOwnershipToPython
+{
+public:
+  //! Allow conversion from T to PythonQtPassOwnershipToPython<T>
+  PythonQtPassOwnershipToPython(const T& t):_t(t) {}
+  //! Allow conversion from PythonQtPassOwnershipToPython<T> to T
+  operator T() const { return _t; }
+
+  //! Stored value. This is important so that it has the same memory layout
+  //! as a pointer if T is a pointer type (which is the typical use case for this class).
+  T _t;
+};
+
+//! Helper template that allows to pass the ownership of a C++ instance between C++ and Python
+//! (it is used as a slot return type or parameter type so that it can be detected by the PythonQt
+//!  slot calling code).
+template<class T>
+class PythonQtNewOwnerOfThis
+{
+public:
+  //! Allow conversion from T to PythonQtNewOwnerOfThis<T>
+  PythonQtNewOwnerOfThis(const T& t):_t(t) {}
+  //! Allow conversion from PythonQtNewOwnerOfThis<T> to T
+  operator T() const { return _t; }
+
+  //! Stored value. This is important so that it has the same memory layout
+  //! as a pointer if T is a pointer type (which is the typical use case for this class).
+  T _t;
+};
+
+
 //! returns the offset that needs to be added to upcast an object of type T1 to T2
 template<class T1, class T2> int PythonQtUpcastingOffset() {
   return ((reinterpret_cast<char*>(static_cast<T2*>(reinterpret_cast<T1*>(0x100)))) 
@@ -554,6 +606,8 @@ class PYTHONQT_EXPORT PythonQt : public QObject {
 
 };
 
+class PythonQtDebugAPI;
+
 //! internal PythonQt details
 class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
 
@@ -739,6 +793,8 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
 
   PythonQt::ProfilingCB* _profilingCB;
 
+  PythonQtDebugAPI* _debugAPI;
+
   int _initFlags;
   int _PythonQtObjectPtr_metaId;
 

src/PythonQtClassWrapper.cpp

@@ -443,7 +443,9 @@ static PyObject *PythonQtClassWrapper_getattro(PyObject *obj, PyObject *name)
     return NULL;
   }
   if (obj == (PyObject*)&PythonQtInstanceWrapper_Type) {
-    return NULL;
+    // if we are called as PythonQtInstanceWrapper_Type, we need to get the properties from the type...
+    PyObject* superAttr = PyType_Type.tp_getattro(obj, name);
+    return superAttr;
   }
 
   if (qstrcmp(attributeName, "__dict__")==0) {

src/PythonQtConversion.cpp

@@ -391,6 +391,13 @@ void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& i
      PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)obj;
      void* object = castWrapperTo(wrap, info.name, ok);
      if (ok) {
+       if (info.passOwnershipToCPP) {
+         // Example: QLayout::addWidget(QWidget*)
+         wrap->passOwnershipToCPP();
+       } else if (info.passOwnershipToPython) {
+         // Example: QLayout::removeWidget(QWidget*)
+         wrap->passOwnershipToPython();
+       }
        if (info.pointerCount==1) {
          // store the wrapped pointer in an extra pointer and let ptr point to the extra pointer
          PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, object, ptr);

src/PythonQtInstanceWrapper.cpp

@@ -140,6 +140,7 @@ static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * /*ar
     self->_ownedByPythonQt = false;
     self->_useQMetaTypeDestroy = false;
     self->_isShellInstance = false;
+    self->_shellInstanceRefCountsWrapper = false;
   }
   return (PyObject *)self;
 }
@@ -154,7 +155,8 @@ int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args
   // we are called from python, try to construct our object
   if (self->classInfo()->constructors()) {
     void* directCPPPointer = NULL;
-    PythonQtSlotFunction_CallImpl(self->classInfo(), NULL, self->classInfo()->constructors(), args, kwds, NULL, &directCPPPointer);
+    PythonQtPassThisOwnershipType ownership;
+    PythonQtSlotFunction_CallImpl(self->classInfo(), NULL, self->classInfo()->constructors(), args, kwds, NULL, &directCPPPointer, &ownership);
     if (PyErr_Occurred()) {
       return -1;
     }
@@ -164,11 +166,11 @@ int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args
       if (refCB) {
         (*refCB)(directCPPPointer);
       }
-
-      // change ownershipflag to be owned by PythonQt
+      // change ownership flag to be owned by PythonQt
       self->_ownedByPythonQt = true;
       self->_useQMetaTypeDestroy = false;
-      if (self->classInfo()->isCPPWrapper()) {
+      bool isQObject = !self->classInfo()->isCPPWrapper();
+      if (!isQObject) {
         self->_wrappedPtr = directCPPPointer;
         // TODO xxx: if there is a wrapper factory, we might want to generate a wrapper for our class?!
       } else {
@@ -189,6 +191,16 @@ int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args
           self->_isShellInstance = true;
         }
       }
+      // if the constructor has a PythonQtPassThisOwnership parameter and that owner is not NULL,
+      // this wrapper is immediately owned by CPP
+      // (Example: QGraphicsItem(QGraphicsItem* parent), if parent != NULL, ownership needs to be passed
+      //  to C++ immediately)
+      // Alternatively, if it is a QObject and the object already has a parent when it is constructed,
+      // the ownership should be moved to C++ as well, so that the shell instance stays alive.
+      if (ownership == PassOwnershipToCPP ||
+          (isQObject && self->_obj && self->_obj->parent())) {
+        self->passOwnershipToCPP();
+      }
     }
   } else {
     QString error = QString("No constructors available for ") + self->classInfo()->className();

src/PythonQtInstanceWrapper.h

@@ -73,6 +73,33 @@ typedef struct PythonQtInstanceWrapperStruct {
     _objPointerCopy = object;
   }
 
+  //! Passes the ownership of the wrapped object to C++
+  void passOwnershipToCPP() {
+    // we pass the ownership to C++
+    _ownedByPythonQt = false;
+    // handle shell instance
+    if (_isShellInstance) {
+      if (!_shellInstanceRefCountsWrapper) {
+        // ref count the wrapper, so that the Python part of the shell instance can not go
+        // away until the C++ object gets deleted...
+        Py_INCREF((PyObject*)this);
+        _shellInstanceRefCountsWrapper = true;
+      }
+    }
+  }
+
+  //! Passes the ownership to Python
+  void passOwnershipToPython() {
+    _ownedByPythonQt = true;
+    // if the shell instance was owned by C++ and the ownership goes to Python,
+    // we need to remove the extra ref count that kept the Python part alive from the C++ side.
+    if (_shellInstanceRefCountsWrapper) {
+      Py_DECREF((PyObject*)this);
+      _shellInstanceRefCountsWrapper = false;
+    }
+  }
+
+
   //! pointer to the wrapped Qt object or if _wrappedPtr is set, the Qt object that wraps the C++ Ptr
   QPointer<QObject> _obj;
   //! a copy of the _obj pointer, which is required because the wrapper needs to
@@ -93,6 +120,9 @@ typedef struct PythonQtInstanceWrapperStruct {
   //! stores if the object is a shell instance
   bool _isShellInstance;
 
+  //! stores if the shell instance (C++) owns the wrapper with its ref count
+  bool _shellInstanceRefCountsWrapper;
+
 } PythonQtInstanceWrapper;
 
 int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds);

src/PythonQtMethodInfo.cpp

@@ -120,9 +120,27 @@ void PythonQtMethodInfo::fillParameterInfo(ParameterInfo& type, const QByteArray
   type.enumWrapper = NULL;
   type.innerNamePointerCount = 0;
   type.isQList = false;
-  
+  type.passOwnershipToCPP = false;
+  type.passOwnershipToPython = false;
+  type.newOwnerOfThis = false;
+
   int len = name.length();
   if (len>0) {
+    if (name.startsWith("PythonQtPassOwnershipToCPP<")) {
+      type.passOwnershipToCPP = true;
+      name = name.mid(27, len-28);
+      len -= 28;
+    }
+    if (name.startsWith("PythonQtPassOwnershipToPython<")) {
+      type.passOwnershipToPython = true;
+      name = name.mid(30, len-31);
+      len -= 31;
+    }
+    if (name.startsWith("PythonQtNewOwnerOfThis<")) {
+      type.newOwnerOfThis = true;
+      name = name.mid(23, len-24);
+      len -= 24;
+    }
     if (strncmp(name.constData(), "const ", 6)==0) {
       name = name.mid(6);
       len -= 6;

src/PythonQtMethodInfo.h

@@ -73,6 +73,9 @@ class PYTHONQT_EXPORT PythonQtMethodInfo
     bool isConst;
     bool isReference;
     bool isQList;
+    bool passOwnershipToCPP;
+    bool passOwnershipToPython;
+    bool newOwnerOfThis;
   };
 
   PythonQtMethodInfo() {};