GIT_REPOSITORIES/LPP/PythonQt Commit - r167:2184742f9ca8

added initial version of foreign wrappers, needs testing...

florianlink -

r167:2184742f9ca8

parent child

Context file:

r167:2184742f9ca8

Collapse all files

src/PythonQt.cpp +26 -2

                    return (PyObject*)wrap;
                  }
+                 // not a known QObject, try to wrap via foreign wrapper factories
+                 PyObject* foreignWrapper = NULL;
+                 for (int i=0; i<_foreignWrapperFactories.size(); i++) {
+                   foreignWrapper = _foreignWrapperFactories.at(i)->wrap(name, ptr);
+                   if (foreignWrapper) {
+                     return foreignWrapper;
+                   }
+                 }
                  // not a known QObject, so try our wrapper factory:
                  QObject* wrapper = NULL;
                  for (int i=0; i<_cppWrapperFactories.size(); i++) {
                    info->setMetaObject(wrapper->metaObject());
                  }
-                 // TODO XXX: delegate wrapping via CB here (pass name and ptr)
                  wrap = createNewPythonQtInstanceWrapper(wrapper, info, ptr);
                  //          mlabDebugConst("MLABPython","new c++ wrapper added " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
                } else {
                _p->_cppWrapperFactories.append(factory);
              }
+             void PythonQt::addWrapperFactory( PythonQtForeignWrapperFactory* factory )
+             {
+               _p->_foreignWrapperFactories.append(factory);
+             }
              //---------------------------------------------------------------------------------------------------
              PythonQtPrivate::PythonQtPrivate()
              {
                }
                return result;
              }
+             void* PythonQtPrivate::unwrapForeignWrapper( const QByteArray& classname, PyObject* obj )
+             {
+               void* foreignObject = NULL;
+               for (int i=0; i<_foreignWrapperFactories.size(); i++) {
+                 foreignObject = _foreignWrapperFactories.at(i)->unwrap(classname, obj);
+                 if (foreignObject) {
+                   return foreignObject;
+                 }
+               }
+               return NULL;
+             }
  No newline at end of file

src/PythonQt.h +9 0

              class PythonQtSignalReceiver;
              class PythonQtImportFileInterface;
              class PythonQtCppWrapperFactory;
+             class PythonQtForeignWrapperFactory;
              class PythonQtQFileImporter;
              typedef void  PythonQtQObjectWrappedCB(QObject* object);
                //! add the given factory to PythonQt (ownership stays with caller)
                void addWrapperFactory(PythonQtCppWrapperFactory* factory);
+               //! add the given factory to PythonQt (ownership stays with caller)
+               void addWrapperFactory(PythonQtForeignWrapperFactory* factory);
                //@}
                //---------------------------------------------------------------------------
                //! remove the wrapper ptr again
                void removeWrapperPointer(void* obj);
+               //! try to unwrap the given object to a C++ pointer using the foreign wrapper factories
+               void* unwrapForeignWrapper(const QByteArray& classname, PyObject* obj);
                //! add parent class relation
                bool addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset);
                //! the cpp object wrapper factories
                QList<PythonQtCppWrapperFactory*> _cppWrapperFactories;
+               QList<PythonQtForeignWrapperFactory*> _foreignWrapperFactories;
                QHash<QByteArray, PyObject*> _packages;
                PythonQtClassInfo* _currentClassInfoForClassWrapperCreation;

src/PythonQtConversion.cpp +6 -3

                   } else if (info.name == "PyObject") {
                     // handle low level PyObject directly
                     PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, obj, ptr);
+                  }
-                  // TODO XXX: pass obj and name and add when it returns a pointer
-                  else if (obj == Py_None) {
+                  } else if (obj == Py_None) {
                     // None is treated as a NULL ptr
                     PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, NULL, ptr);
                   } else {
+                    void* foreignWrapper = PythonQt::priv()->unwrapForeignWrapper(info.name, obj);
+                    if (foreignWrapper) {
+                      PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, foreignWrapper, ptr);
+                    } else {
                     // if we are not strict, we try if we are passed a 0 integer
                     if (!strict) {
                       bool ok;
                       }
                     }
                   }
+                  }
                 } else if (info.pointerCount == 0) {
                   // not a pointer
                   switch (info.typeId) {

src/PythonQtCppWrapperFactory.h +19 -1

                virtual ~PythonQtCppWrapperFactory() {};
                //! create a wrapper for the given object
-               virtual QObject* create(const QByteArray& name, void *ptr) = 0;
+               virtual QObject* create(const QByteArray& classname, void *ptr) = 0;
+             };
+             //! Factory interface for C++ classes that can be mapped directly from/to
+             //! Python with other means than PythonQt/QObjects.
+             class PYTHONQT_EXPORT PythonQtForeignWrapperFactory
+             {
+             public:
+               PythonQtForeignWrapperFactory() {};
+               virtual ~PythonQtForeignWrapperFactory() {};
+               //! create a Python object (with new reference count), wrapping the given \p ptr as class of type \p classname
+               //! Return NULL (and not Py_None) if the object could not be wrapped.
+               virtual PyObject* wrap(const QByteArray& classname, void *ptr) = 0;
+               //! unwrap the given object to a C++ object of type \p classname if possible
+               //! Return NULL otherwise.
+               virtual void*     unwrap(const QByteArray& classname, PyObject* object) = 0;
              };

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