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());
-               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);
+               _signalReceivers.remove(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:
-               //! called when a wrapped QObject is destroyed
-               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);
+               //! creates the new module from the given pycode
+               PythonQtObjectPtr createModule(const QString& name, PyObject* pycode);
              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

              #include "PythonQtConversion.h"
              #include <QMetaObject>
              #include <QMetaMethod>
+             #include "funcobject.h"
              void PythonQtSignalTarget::call(void **arguments) const
              {
+               // Note: we check if the callable is a PyFunctionObject and has a fixed number of arguments
+               // if that is the case, we only pass these arguments to python and skip the additional arguments from the signal
+               int numPythonArgs = -1;
+               if (PyFunction_Check(_callable)) {
+                 PyObject* o = _callable;
+                 PyFunctionObject* func = (PyFunctionObject*)o;
+                 PyCodeObject* code = (PyCodeObject*)func->func_code;
+                 if (!(code->co_flags & 0x04)) {
+                   numPythonArgs = code->co_argcount;
+                 } else {
+                   // variable numbers of arguments allowed
+                 }
+               } else if (PyMethod_Check(_callable)) {
+                 PyObject* o = _callable;
+                 PyMethodObject* method = (PyMethodObject*)o;
+                 if (PyFunction_Check(method->im_func)) {
+                   PyFunctionObject* func = (PyFunctionObject*)method->im_func;
+                   PyCodeObject* code = (PyCodeObject*)func->func_code;
+                   if (!(code->co_flags & 0x04)) {
+                     numPythonArgs = code->co_argcount - 1; // we subtract one because the first is "self"
+                   } else {
+                     // variable numbers of arguments allowed
+                   }
+                 }
+               }
                const PythonQtMethodInfo* m = methodInfo();
-               // paramterCount includes return value:
+               // parameterCount includes return value:
                int count = m->parameterCount();
+               if (numPythonArgs!=-1) {
+                 if (count>numPythonArgs+1) {
+                   // take less arguments
+                   count = numPythonArgs+1;
+                 }
+               }
                PyObject* pargs = NULL;
                if (count>1) {
              PythonQtSignalReceiver::~PythonQtSignalReceiver()
              {
+               PythonQt::priv()->removeSignalEmitter(_obj);
              }

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