GIT_REPOSITORIES/LPP/PythonQt Commit - r4:41816e302524

merged in features from the MeVisLab repository...

florianlink -

r4:41816e302524

parent child

Context file:

r4:41816e302524

Collapse all files

src/PythonQt.cpp +87 -22

             #include <pydebug.h>
             PythonQt* PythonQt::_self = NULL;
+            int       PythonQt::_uniqueModuleCount = 0;
             void PythonQt::init(int flags)
               _p->registerClass(metaobject);
             }
+            void PythonQt::qObjectNoLongerWrappedCB(QObject* o)
+            {
+              if (_self->_p->_noLongerWrappedCB) {
+                (*_self->_p->_noLongerWrappedCB)(o);
+              };
+            }
             void PythonQtPrivate::registerClass(const QMetaObject* metaobject)
             {
               // we register all classes in the hierarchy
                 Py_INCREF(Py_None);
                 return Py_None;
               }
-              PythonQtWrapper* wrap = _wrappedObjects.value(obj);
+              PythonQtWrapper* wrap = findWrapperAndRemoveUnused(obj);
               if (!wrap) {
                 // smuggling it in...
                 PythonQtClassInfo* classInfo = _knownQtClasses.value(obj->metaObject()->className());
                   classInfo = _knownQtClasses.value(obj->metaObject()->className());
                 }
                 wrap = createNewPythonQtWrapper(obj, classInfo);
-                // insert destroyed handler
-                connect(obj, SIGNAL(destroyed(QObject*)), this, SLOT(wrappedObjectDestroyed(QObject*)));
                 //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
               } else {
                 Py_INCREF(wrap);
                 Py_INCREF(Py_None);
                 return Py_None;
               }
-              PythonQtWrapper* wrap = _wrappedObjects.value(ptr);
+              PythonQtWrapper* wrap = findWrapperAndRemoveUnused(ptr);
               if (!wrap) {
                 PythonQtClassInfo* info = _knownQtClasses.value(name);
                 if (!info) {
                     info = _knownQtClasses.value(qptr->metaObject()->className());
                   }
                   wrap = createNewPythonQtWrapper(qptr, info);
-                  // insert destroyed handler
-                  connect(qptr, SIGNAL(destroyed(QObject*)), this, SLOT(wrappedObjectDestroyed(QObject*)));
                   //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
                 } else {
                   // maybe it is a PyObject, which we can return directly
               result = (PythonQtWrapper *)PythonQtWrapper_Type.tp_new(&PythonQtWrapper_Type,
                 NULL, NULL);
-              result->_obj = obj;
+              result->setQObject(obj);
               result->_info = info;
               result->_wrappedPtr = wrappedPtr;
               result->_ownedByPythonQt = false;
                 _wrappedObjects.insert(wrappedPtr, result);
               } else {
                 _wrappedObjects.insert(obj, result);
+                if (obj->parent()== NULL && _wrappedCB) {
+                  // tell someone who is interested that the qobject is wrapped the first time, if it has no parent
+                  (*_wrappedCB)(obj);
+                }
               }
               return result;
             }
               if (!r) {
                 r = new PythonQtSignalReceiver(obj);
                 _p->_signalReceivers.insert(obj, r);
-                // insert destroyed handler
-                connect(obj, SIGNAL(destroyed(QObject*)), _p ,SLOT(destroyedSignalEmitter(QObject*)));
               }
               return r;
             }
               return p;
             }
+            PythonQtObjectPtr PythonQt::createModuleFromFile(const QString& name, const QString& filename)
+            {
+              PythonQtObjectPtr code = parseFile(filename);
+              PythonQtObjectPtr module = _p->createModule(name, code);
+              return module;
+            }
+            PythonQtObjectPtr PythonQt::createModuleFromScript(const QString& name, const QString& script)
+            {
+              PyErr_Clear();
+              QString scriptCode = script;
+              if (scriptCode.isEmpty()) {
+                // we always need at least a linefeed
+                scriptCode = "\n";
+              }
+              PythonQtObjectPtr pycode;
+              pycode.setNewRef(Py_CompileString((char*)scriptCode.toLatin1().data(), "",  Py_file_input));
+              PythonQtObjectPtr module = _p->createModule(name, pycode);
+              return module;
+            }
+            PythonQtObjectPtr PythonQt::createUniqueModule()
+            {
+              static QString pyQtStr("PythonQt_module");
+              QString moduleName = pyQtStr+QString::number(_uniqueModuleCount++);
+              return createModuleFromScript(moduleName);
+            }
             void PythonQt::addObject(PyObject* module, const QString& name, QObject* object)
             {
               PyModule_AddObject(module, name.toLatin1().data(), _p->wrapQObject(object));
             PythonQtPrivate::PythonQtPrivate()
             {
               _importInterface = NULL;
+              _noLongerWrappedCB = NULL;
+              _wrappedCB = NULL;
             }
             void PythonQtPrivate::addDecorators(QObject* o, bool instanceDeco, bool classDeco)
               return _knownQtDecoratorSlots.values(className);
             }
-            void PythonQtPrivate::wrappedObjectDestroyed(QObject* obj)
+            void PythonQtPrivate::removeSignalEmitter(QObject* obj)
             {
-              // mlabDebugConst("MLABPython","PyWrapper QObject destroyed " << o << " " << o->name() << " " << o->className());
+              _signalReceivers.remove(obj);
-              PythonQtWrapper* wrap = _wrappedObjects[obj];
-              if (wrap) {
-                _wrappedObjects.remove(obj);
-                // remove the pointer but keep the wrapper alive in python
-                wrap->_obj = NULL;
-            void PythonQtPrivate::destroyedSignalEmitter(QObject* obj)
-              _signalReceivers.take(obj);
             }
             bool PythonQt::handleError()
               emit PythonQt::self()->pythonStdErr(str);
             }
+            void PythonQt::setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb)
+            {
+              _p->_wrappedCB = cb;
+            }
+            void PythonQt::setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb)
+            {
+              _p->_noLongerWrappedCB = cb;
+            }
             static PyMethodDef PythonQtMethods[] = {
                 return PyString_FromString(info->help().toLatin1().data());
               }
             }
+            void PythonQtPrivate::removeWrapperPointer(void* obj)
+            {
+              _wrappedObjects.remove(obj);
+            }
+            PythonQtWrapper* PythonQtPrivate::findWrapperAndRemoveUnused(void* obj)
+            {
+              PythonQtWrapper* wrap = _wrappedObjects.value(obj);
+              if (wrap && !wrap->_wrappedPtr && wrap->_obj == NULL) {
+                // this is a wrapper whose QObject was already removed due to destruction
+                // so the obj pointer has to be a new QObject with the same address...
+                // we remove the old one and set the copy to NULL
+                wrap->_objPointerCopy = NULL;
+                removeWrapperPointer(obj);
+                wrap = NULL;
+              }
+              return wrap;
+            }
+            PythonQtObjectPtr PythonQtPrivate::createModule(const QString& name, PyObject* pycode)
+            {
+              PythonQtObjectPtr result;
+              if (pycode) {
+                result.setNewRef(PyImport_ExecCodeModule((char*)name.toLatin1().data(), pycode));
+              } else {
+                PythonQt::self()->handleError();
+              }
+              return result;
+            }

src/PythonQt.h +40 -7

             class PythonQtCppWrapperFactory;
             class PythonQtConstructorHandler;
+            typedef void PythonQtQObjectWrappedCB(QObject* object);
+            typedef void PythonQtQObjectNoLongerWrappedCB(QObject* object);
             //! the main interface to the Python Qt binding, realized as a singleton
             class PYTHONQT_EXPORT PythonQt : public QObject {
               //! evaluates the given script code from file
               void evalFile(PyObject* module, const QString& filename);
+              //! creates the new module \c name and evaluates the given file in the context of that module
+              //! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code
+              //! to a module later on.
+              //! The user needs to make sure that the \c name is unique in the python module dictionary.
+              PythonQtObjectPtr createModuleFromFile(const QString& name, const QString& filename);
+              //! creates the new module \c name and evaluates the given script in the context of that module.
+              //! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code
+              //! to a module later on.
+              //! The user needs to make sure that the \c name is unique in the python module dictionary.
+              PythonQtObjectPtr createModuleFromScript(const QString& name, const QString& script = QString());
+              //! create a uniquely named module, you can use evalFile or evalScript to populate the module with
+              //! script code
+              PythonQtObjectPtr createUniqueModule();
               //@{ Signal handlers
               //! add a signal handler to the given \c signal of \c obj  and connect it to a callable \c objectname in module
               //! The error is currently just output to the python stderr, future version might implement better trace printing
               bool handleError();
+              //! set a callback that is called when a QObject with parent == NULL is wrapped by pythonqt
+              void setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb);
+              //! set a callback that is called when a QObject with parent == NULL is no longer wrapped by pythonqt
+              void setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb);
+              //! call the callback if it is set
+              static void qObjectNoLongerWrappedCB(QObject* o);
             signals:
               //! emitted when python outputs something to stdout (and redirection is turned on)
               void pythonStdOut(const QString& str);
               ~PythonQt();
               static PythonQt* _self;
+              static int _uniqueModuleCount;
               PythonQtPrivate* _p;
               bool isPythonQtObjectPtrMetaId(int id) { return _PythonQtObjectPtr_metaId == id; }
               //! remove the wrapper ptr again
-              void removeWrapperPointer(void* obj) { _wrappedObjects.take(obj); }
+              void removeWrapperPointer(void* obj);
+              //! called when a signal emitting QObject is destroyed to remove the signal handler from the hash map
+              void removeSignalEmitter(QObject* obj);
               //! wrap the given QObject into a Python object (or return existing wrapper!)
               PyObject* wrapQObject(QObject* obj);
               //! get the destructor slot for the given classname
               PythonQtSlotInfo* getDestructorSlot(const QByteArray& className) { return _destructorSlots.value(className); }
-            protected slots:
+              //! creates the new module from the given pycode
-              //! called when a wrapped QObject is destroyed
+              PythonQtObjectPtr createModule(const QString& name, PyObject* pycode);
-              void wrappedObjectDestroyed(QObject* obj);
-              //! called when a signal emitting QObject is destroyed to remove the signal handler from the hash map
-              void destroyedSignalEmitter(QObject* obj);
             private:
+              //! get the wrapper for a given pointer (and remove a wrapper of an already destroyed qobject)
+              PythonQtWrapper* findWrapperAndRemoveUnused(void* obj);
               //! stores pointer to PyObject mapping of wrapped QObjects AND C++ objects
               QHash<void* , PythonQtWrapper *>       _wrappedObjects;
               //! the importer interface (if set)
               PythonQtImportFileInterface* _importInterface;
+              PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
+              PythonQtQObjectWrappedCB* _wrappedCB;
               QStringList _importIgnorePaths;
               //! the cpp object wrapper factories

src/PythonQtConversion.cpp +8 -3

                      }
                    } else {
                      if (wrap->_info->inherits(info.name)) {
-                       PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, wrap->_obj, ptr);
+                       QObject* myObject = wrap->_obj;
+                       PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, myObject, ptr);
                      } else {
                        // not matching
                      }
                          if (ok) {
                            PythonQtValueStorage_ADD_VALUE(global_valueStorage, unsigned int, val, ptr);
                            return ptr;
+                         } else {
+                           return NULL;
                          }
                        }
                      }
                     // is this worth anything? we loose the knowledge of the cpp object type
                     v = qVariantFromValue(wrap->_wrappedPtr);
                   } else {
-                    v = qVariantFromValue(wrap->_obj);
+                    QObject* myObject = wrap->_obj;
+                    v = qVariantFromValue(myObject);
                   }
                   return v;
                 } else if (val->ob_type==&PyDict_Type) {
                       }
                     } else {
                       if (wrap->_info->inherits(type)) {
-                        list->append((void*)wrap->_obj);
+                        QObject* myObject = wrap->_obj;
+                        list->append((void*)myObject);
                       } else {
                         result = false;
                         break;

src/PythonQtImporter.cpp +2 0

               else {
               //  mlabDebugConst("MLABPython", "compiling source " << path);
                 code = compileSource(path, qdata);
+                if (code) {
                   // save a pyc file if possible
                   QDateTime time;
                   time = hasImporter?PythonQt::importInterface()->lastModifiedDate(path):QFileInfo(path).lastModified();
                   writeCompiledModule((PyCodeObject*)code, path+"c", time.toTime_t());
                 }
+              }
               return code;
             }

src/PythonQtMetaObjectWrapper.cpp +6 -1

               }
             }
+            static long PythonQtMetaObjectWrapper_hash(PythonQtMetaObjectWrapper *obj)
+            {
+              return reinterpret_cast<long>(obj->_info);
+            }
             PyTypeObject PythonQtMetaObjectWrapper_Type = {
                 PyObject_HEAD_INIT(NULL)
 ,                         /*ob_size*/
 ,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
-,                         /*tp_hash */
+                (hashfunc)PythonQtMetaObjectWrapper_hash,                         /*tp_hash */
                 PythonQtMetaObjectWrapper_call,                         /*tp_call*/
 ,                         /*tp_str*/
                 PythonQtMetaObjectWrapper_getattro,                         /*tp_getattro*/

src/PythonQtSignalReceiver.cpp +36 -1

@@ -45,12 +45,46
45	#include "PythonQtConversion.h"	45	#include "PythonQtConversion.h"
46	#include <QMetaObject>	46	#include <QMetaObject>
47	#include <QMetaMethod>	47	#include <QMetaMethod>
		48	#include "funcobject.h"
48		49
49	void PythonQtSignalTarget::call(void **arguments) const	50	void PythonQtSignalTarget::call(void **arguments) const
50	{	51	{
		52	// Note: we check if the callable is a PyFunctionObject and has a fixed number of arguments
		53	// if that is the case, we only pass these arguments to python and skip the additional arguments from the signal
		54
		55	int numPythonArgs = -1;
		56	if (PyFunction_Check(_callable)) {
		57	PyObject* o = _callable;
		58	PyFunctionObject* func = (PyFunctionObject*)o;
		59	PyCodeObject* code = (PyCodeObject*)func->func_code;
		60	if (!(code->co_flags & 0x04)) {
		61	numPythonArgs = code->co_argcount;
		62	} else {
		63	// variable numbers of arguments allowed
		64	}
		65	} else if (PyMethod_Check(_callable)) {
		66	PyObject* o = _callable;
		67	PyMethodObject* method = (PyMethodObject*)o;
		68	if (PyFunction_Check(method->im_func)) {
		69	PyFunctionObject* func = (PyFunctionObject*)method->im_func;
		70	PyCodeObject* code = (PyCodeObject*)func->func_code;
		71	if (!(code->co_flags & 0x04)) {
		72	numPythonArgs = code->co_argcount - 1; // we subtract one because the first is "self"
		73	} else {
		74	// variable numbers of arguments allowed
		75	}
		76	}
		77	}
		78
51	const PythonQtMethodInfo* m = methodInfo();	79	const PythonQtMethodInfo* m = methodInfo();
52	// paramterCount includes return value:	80	// parameterCount includes return value:
53	int count = m->parameterCount();	81	int count = m->parameterCount();
		82	if (numPythonArgs!=-1) {
		83	if (count>numPythonArgs+1) {
		84	// take less arguments
		85	count = numPythonArgs+1;
		86	}
		87	}
54		88
55	PyObject* pargs = NULL;	89	PyObject* pargs = NULL;
56	if (count>1) {	90	if (count>1) {
@@ -97,6 +131,7 PythonQtSignalReceiver::PythonQtSignalReceiver(QObject* obj):PythonQtSignalRecei
97		131
98	PythonQtSignalReceiver::~PythonQtSignalReceiver()	132	PythonQtSignalReceiver::~PythonQtSignalReceiver()
99	{	133	{
		134	PythonQt::priv()->removeSignalEmitter(_obj);
100	}	135	}
101		136
102		137

src/PythonQtStdOut.cpp +9 -1

               return Py_BuildValue("");
             }
+            static PyObject *PythonQtStdOutRedirect_flush(PyObject *self, PyObject *args)
+            {
+              return Py_BuildValue("");
+            }
             static PyMethodDef PythonQtStdOutRedirect_methods[] = {
               {"write", (PyCFunction)PythonQtStdOutRedirect_write, METH_VARARGS,
-                "redirect the writing to a callback"
+              "redirect the writing to a callback"},
+              {"flush", (PyCFunction)PythonQtStdOutRedirect_flush, METH_VARARGS,
+              "flush the output, currently not implemented but needed for logging framework"
               },
               {NULL}  /* Sentinel */
             };

src/PythonQtVariantWrapper.cpp +15 0

               case QVariant::Time:
                 r = v.toTime().toString(Qt::ISODate);
                 break;
+              case QVariant::Pixmap:
+                {
+                  QPixmap p = qvariant_cast<QPixmap>(v);
+                  r = QString("Pixmap ") + QString::number(p.width()) + ", " + QString::number(p.height());
+                }
+                break;
+              case QVariant::Image:
+                {
+                  QImage img = qvariant_cast<QImage>(v);
+                  r = QString("Image ") + QString::number(img.width()) + ", " + QString::number(img.height());
+                }
+                break;
                 //TODO: add more printing for other variant types
               default:
                 r = v.toString();
             {
               PythonQtVariantWrapper* wt = (PythonQtVariantWrapper*)obj;
               QString val = qVariantToString(*wt->_variant);
+              if (val.isEmpty()) {
+                val = wt->_variant->typeName();
+              }
               return PyString_FromFormat("%s", val.toLatin1().constData());
             }

src/PythonQtWrapper.cpp +32 -8

                     // TODO: print a warning? we can not destroy that object
                   }
                 }
-              } else if (self->_obj) {
+              } else {
                 //mlabDebugConst("Python","qobject wrapper removed " << self->_obj->className() << " " << self->_info->wrappedClassName().latin1());
-                PythonQt::priv()->removeWrapperPointer(self->_obj);
+                if (self->_objPointerCopy) {
+                  PythonQt::priv()->removeWrapperPointer(self->_objPointerCopy);
+                }
+                if (self->_obj) {
                   if (self->_ownedByPythonQt) {
                     if (!self->_obj->parent()) {
                       delete self->_obj;
-                    self->_obj = NULL;
+                  } else {
+                    if (self->_obj->parent()==NULL) {
+                      // tell someone who is interested that the qobject is no longer wrapped, if it has no parent
+                      PythonQt::qObjectNoLongerWrappedCB(self->_obj);
+                    }
                   }
                 }
               }
+              self->_obj = NULL;
+              self->_obj.~QPointer<QObject>();
               self->ob_type->tp_free((PyObject*)self);
             }
               self = (PythonQtWrapper *)type->tp_alloc(type, 0);
               if (self != NULL) {
                 self->_info = NULL;
-                self->_obj = NULL;
+                new (&self->_obj) QPointer<QObject>();
                 self->_wrappedPtr = NULL;
                 self->_ownedByPythonQt = false;
               }
             static PyObject * PythonQtWrapper_repr(PyObject * obj)
             {
               PythonQtWrapper* wt = (PythonQtWrapper*)obj;
+              QObject *qobj = wt->_obj;
               if (wt->_wrappedPtr) {
                 if (wt->_obj) {
-                  return PyString_FromFormat("%s (C++ Object 0x%x wrapped by %s 0x%x))", wt->_info->className(), wt->_wrappedPtr, wt->_obj->metaObject()->className(), wt->_obj);
+                  return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wt->_info->className(), wt->_wrappedPtr, wt->_obj->metaObject()->className(), qobj);
                 } else {
-                  return PyString_FromFormat("%s (C++ Object 0x%x unwrapped)", wt->_info->className(), wt->_wrappedPtr);
+                  return PyString_FromFormat("%s (C++ Object %p unwrapped)", wt->_info->className(), wt->_wrappedPtr);
                 }
               } else {
-                return PyString_FromFormat("%s (QObject 0x%x)", wt->_info->className(), wt->_obj, wt->_wrappedPtr);
+                return PyString_FromFormat("%s (QObject %p)", wt->_info->className(), qobj);
               }
             }
               return (wt->_wrappedPtr == NULL && wt->_obj == NULL)?0:1;
             }
+            static long PythonQtWrapper_hash(PythonQtWrapper *obj)
+            {
+              if (obj->_wrappedPtr != NULL) {
+                return reinterpret_cast<long>(obj->_wrappedPtr);
+              } else {
+                QObject* qobj = obj->_obj; // get pointer from QPointer wrapper
+                return reinterpret_cast<long>(qobj);
+              }
+            }
             // we override nb_nonzero, so that one can do 'if' expressions to test for a NULL ptr
             static PyNumberMethods PythonQtWrapper_as_number = {
 ,      /* nb_add */
                 &PythonQtWrapper_as_number,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
-,                         /*tp_hash */
+                (hashfunc)PythonQtWrapper_hash,                         /*tp_hash */
 ,                         /*tp_call*/
 ,                         /*tp_str*/
                 PythonQtWrapper_getattro,                         /*tp_getattro*/

src/PythonQtWrapper.h +12 -1

             #include <Python.h>
             #include "PythonQtSystem.h"
+            #include <QPointer>
             #include "structmember.h"
             #include "methodobject.h"
             typedef struct {
               PyObject_HEAD
+              //! set the QObject pointer
+              void setQObject(QObject* object) {
+                _obj = object;
+                _objPointerCopy = object;
+              }
               //! pointer to the wrapped Qt object or if _wrappedPtr is set, the Qt object that wraps the C++ Ptr
-              QObject* _obj;
+              QPointer<QObject> _obj;
+              //! a copy of the _obj pointer, which is required because the wrapper needs to
+              //! deregister itself via the _obj pointer, even when the QPointer<QObject> object was destroyed
+              void* _objPointerCopy;
               //! optional C++ object Ptr that is wrapped by the above _obj
               void*    _wrappedPtr;

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