merged in features from the MeVisLab repository

- added createModuleFromFile/createModuleFromScript/createUniqueModule
- switched object destruction to use QPointer and lazy wrapper removal to avoid expensive objectDestroyed signal connections
- added hash() support for PythnQtWrapper object
- added support for signal to python function connections where the function has less arguments than the emitted signal
- added setQObject[NoLonger]WrappedCallback API to support external reference counting on QObjects that are exposed to PythonQt
- implemented flush on std redirect to support python logging framework
- improved QVariant printing and fixed print error on MacX


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

Author: florianlink

src/PythonQt.cpp

@@ -52,6 +52,7 @@
 #include <pydebug.h>
 
 PythonQt* PythonQt::_self = NULL;
+int       PythonQt::_uniqueModuleCount = 0;
 
 
 void PythonQt::init(int flags)
@@ -211,6 +212,13 @@ void PythonQt::registerClass(const QMetaObject* metaobject)
   _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
@@ -259,7 +267,7 @@ PyObject* PythonQtPrivate::wrapQObject(QObject* obj)
     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());
@@ -268,8 +276,6 @@ PyObject* PythonQtPrivate::wrapQObject(QObject* obj)
       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);
@@ -284,7 +290,7 @@ PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name)
     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) {
@@ -304,8 +310,6 @@ PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name)
         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
@@ -360,7 +364,7 @@ PythonQtWrapper* PythonQtPrivate::createNewPythonQtWrapper(QObject* obj, PythonQ
   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;
@@ -369,6 +373,10 @@ PythonQtWrapper* PythonQtPrivate::createNewPythonQtWrapper(QObject* obj, PythonQ
     _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;
 }
@@ -400,8 +408,6 @@ PythonQtSignalReceiver* PythonQt::getSignalReceiver(QObject* obj)
   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;
 }
@@ -540,6 +546,34 @@ PythonQtObjectPtr PythonQt::parseFile(const QString& filename)
   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));
@@ -763,6 +797,8 @@ const QList<PythonQtConstructorHandler*>& PythonQt::constructorHandlers()
 PythonQtPrivate::PythonQtPrivate()
 {
   _importInterface = NULL;
+  _noLongerWrappedCB = NULL;
+  _wrappedCB = NULL;
 }
 
 void PythonQtPrivate::addDecorators(QObject* o, bool instanceDeco, bool classDeco)
@@ -829,20 +865,9 @@ QList<PythonQtSlotInfo*> PythonQtPrivate::getDecoratorSlots(const QByteArray& cl
   return _knownQtDecoratorSlots.values(className);
 }
 
-void PythonQtPrivate::wrappedObjectDestroyed(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)
+void PythonQtPrivate::removeSignalEmitter(QObject* obj)
 {
-  _signalReceivers.take(obj);
+  _signalReceivers.remove(obj);
 }
 
 bool PythonQt::handleError()
@@ -892,6 +917,16 @@ void PythonQt::stdErrRedirectCB(const QString& str)
   emit PythonQt::self()->pythonStdErr(str);
 }
 
+void PythonQt::setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb)
+{
+  _p->_wrappedCB = cb;
+}
+
+void PythonQt::setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb)
+{
+  _p->_noLongerWrappedCB = cb;
+}
+
 
 
 static PyMethodDef PythonQtMethods[] = {
@@ -944,3 +979,33 @@ PyObject* PythonQt::helpCalled(PythonQtClassInfo* info)
     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

@@ -66,6 +66,9 @@ class PythonQtImportFileInterface;
 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 {
 
@@ -137,6 +140,22 @@ 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
@@ -280,6 +299,14 @@ class PYTHONQT_EXPORT PythonQt : public QObject {
   //! 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);
@@ -313,6 +340,7 @@ class PYTHONQT_EXPORT PythonQt : public QObject {
   ~PythonQt();
 
   static PythonQt* _self;
+  static int _uniqueModuleCount;
 
   PythonQtPrivate* _p;
 
@@ -331,7 +359,10 @@ class PythonQtPrivate : public QObject {
   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);
@@ -379,15 +410,14 @@ class PythonQtPrivate : public QObject {
   //! 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;
 
@@ -412,6 +442,9 @@ protected slots:
   //! the importer interface (if set)
   PythonQtImportFileInterface* _importInterface;
 
+  PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
+  PythonQtQObjectWrappedCB* _wrappedCB;
+
   QStringList _importIgnorePaths;
 
   //! the cpp object wrapper factories

src/PythonQtConversion.cpp

@@ -296,7 +296,8 @@ return Py_None;
          }
        } 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
          }
@@ -487,6 +488,8 @@ return Py_None;
              if (ok) {
                PythonQtValueStorage_ADD_VALUE(global_valueStorage, unsigned int, val, ptr);
                return ptr;
+             } else {
+               return NULL;
              }
            }
          }
@@ -730,7 +733,8 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
         // 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) {
@@ -998,7 +1002,8 @@ bool PythonQtConv::ConvertPythonListToQListOfType(PyObject* obj, QList<void*>* l
           }
         } 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

@@ -620,10 +620,12 @@ PythonQtImport::getCodeFromData(const QString& path, int isbytecode,int ispackag
   else {
   //  mlabDebugConst("MLABPython", "compiling source " << path);
     code = compileSource(path, qdata);
-    // 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());
+    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;
 }
@@ -776,7 +778,7 @@ void PythonQtImport::init()
   PyObject* classobj = PyDict_GetItemString(PyModule_GetDict(mod), "PythonQtImporter");
   PyObject* path_hooks = PySys_GetObject("path_hooks");
   PyList_Append(path_hooks, classobj);
-
+  
 #ifndef WIN32
   // reload the encodings module, because it might fail to custom import requirements (e.g. encryption).
   PyObject* modules         = PyImport_GetModuleDict();

src/PythonQtMetaObjectWrapper.cpp

@@ -143,7 +143,7 @@ static PyObject *PythonQtMetaObjectWrapper_getattro(PyObject *obj,PyObject *name
   if (member._type == PythonQtMemberInfo::Slot && member._slot->isClassDecorator()) {
     return PythonQtSlotFunction_New(member._slot, obj, NULL);
   }
-  
+
   // look for the interal methods (className(), help())
   PyObject* internalMethod = Py_FindMethod( PythonQtMetaObjectWrapper_methods, obj, (char*)attributeName);
   if (internalMethod) {
@@ -194,6 +194,11 @@ static int PythonQtMetaObjectWrapper_compare(PyObject * obj1, PyObject * obj2)
   }
 }
 
+static long PythonQtMetaObjectWrapper_hash(PythonQtMetaObjectWrapper *obj)
+{
+  return reinterpret_cast<long>(obj->_info);
+}
+
 PyTypeObject PythonQtMetaObjectWrapper_Type = {
     PyObject_HEAD_INIT(NULL)
     0,                         /*ob_size*/
@@ -209,7 +214,7 @@ PyTypeObject PythonQtMetaObjectWrapper_Type = {
     0,                         /*tp_as_number*/
     0,                         /*tp_as_sequence*/
     0,                         /*tp_as_mapping*/
-    0,                         /*tp_hash */
+    (hashfunc)PythonQtMetaObjectWrapper_hash,                         /*tp_hash */
     PythonQtMetaObjectWrapper_call,                         /*tp_call*/
     0,                         /*tp_str*/
     PythonQtMetaObjectWrapper_getattro,                         /*tp_getattro*/