merged various changes from MeVisLab repository

Author: florianlink

src/PythonQt.cpp

@@ -78,11 +78,12 @@ void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
     PythonQtRegisterToolClassesTemplateConverter(quint64);
     // TODO: which other POD types should be available for QList etc.
 
-    PythonQt::self()->addDecorators(new PythonQtStdDecorators());
-
     PythonQt_init_QtCoreBuiltin(NULL);
     PythonQt_init_QtGuiBuiltin(NULL);
 
+    PythonQt::self()->addDecorators(new PythonQtStdDecorators());
+    PythonQt::self()->registerCPPClass("QMetaObject",0, "QtCore", PythonQtCreateObject<PythonQtWrapper_QMetaObject>);
+
     PythonQtRegisterToolClassesTemplateConverter(QByteArray);
     PythonQtRegisterToolClassesTemplateConverter(QDate);
     PythonQtRegisterToolClassesTemplateConverter(QTime);
@@ -919,6 +920,13 @@ QStringList PythonQt::introspectObject(PyObject* object, ObjectType type)
       }
       Py_DECREF(keys);
     }
+    if ((type == Anything) || (type == Variable)) {
+      if (object->ob_type == &PythonQtClassWrapper_Type) {
+        PythonQtClassWrapper* o = (PythonQtClassWrapper*)object;
+        PythonQtClassInfo* info = o->classInfo();
+        results += info->propertyList();
+      }
+    }
   }
   return results;
 }
@@ -958,7 +966,13 @@ QStringList PythonQt::introspectType(const QString& typeName, ObjectType type)
     // the last item may be a member, split it away and try again
     QStringList tmp = typeName.split(".");
     QString memberName = tmp.takeLast();
-    QString typeName = tmp.takeLast();
+    QString typeName;
+    if (tmp.isEmpty()) {
+      typeName = memberName;
+      memberName.clear();
+    } else {
+      typeName = tmp.takeLast();
+    }
     PyObject* typeObject = getObjectByType(typeName);
     if (typeObject) {
       object = PyObject_GetAttrString(typeObject, memberName.toLatin1().constData());
@@ -1690,3 +1704,18 @@ QString PythonQtPrivate::getSignature(PyObject* object)
 
   return signature;
 }
+
+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.
+}

src/PythonQt.h

@@ -563,6 +563,9 @@ class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
   //! remove the wrapper ptr again
   void removeWrapperPointer(void* obj);
 
+  //! called by destructor of shells to allow invalidation of the Python wrapper
+  void shellClassDeleted(void* shellClass);
+
   //! try to unwrap the given object to a C++ pointer using the foreign wrapper factories
   void* unwrapForeignWrapper(const QByteArray& classname, PyObject* obj);
 

src/PythonQtClassInfo.cpp

@@ -205,46 +205,53 @@ PythonQtSlotInfo* PythonQtClassInfo::findDecoratorSlotsFromDecoratorProvider(con
   }
 
   tail = findDecoratorSlots(memberName, memberNameLen, tail, found, memberCache, upcastingOffset);
-  
-  return tail;
-}
 
-bool PythonQtClassInfo::lookForMethodAndCache(const char* memberName)
-{
-  bool found = false;
-  int memberNameLen =  static_cast<int>(strlen(memberName));
-  PythonQtSlotInfo* tail = NULL;
+  // now look for slots/signals/methods on this level of the meta object
   if (_meta) {
     int numMethods = _meta->methodCount();
-    for (int i = 0; i < numMethods; i++) {
+    // start from methodOffset, to only add slots which are located in this class,
+    // and not in the parent class, which is traversed recursively later on.
+    // (if the class in not a QObject, we are working with a script wrapper QObject
+    //  and need to read all slots/signals starting from 0).
+    int methodOffset = _isQObject?_meta->methodOffset():0;
+    for (int i = methodOffset; i < numMethods; i++) {
       QMetaMethod m = _meta->method(i);
       if (((m.methodType() == QMetaMethod::Method ||
-           m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public)
+        m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public)
         || m.methodType()==QMetaMethod::Signal) {
-        
-        const char* sigStart = m.signature();
-        // find the first '('
-        int offset = findCharOffset(sigStart, '(');
-        
-        // check if same length and same name
-        if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
-          found = true;
-          PythonQtSlotInfo* info = new PythonQtSlotInfo(this, m, i);
-          if (tail) {
-            tail->setNextInfo(info);
-          } else {
-            PythonQtMemberInfo newInfo(info);
-            _cachedMembers.insert(memberName, newInfo);
+
+          const char* sigStart = m.signature();
+          // find the first '('
+          int offset = findCharOffset(sigStart, '(');
+
+          // check if same length and same name
+          if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
+            found = true;
+            PythonQtSlotInfo* info = new PythonQtSlotInfo(this, m, i);
+            if (tail) {
+              tail->setNextInfo(info);
+            } else {
+              PythonQtMemberInfo newInfo(info);
+              memberCache.insert(memberName, newInfo);
+            }
+            tail = info;
           }
-          tail = info;
-        }
       }
     }
   }
+  return tail;
+}
+
+bool PythonQtClassInfo::lookForMethodAndCache(const char* memberName)
+{
+  bool found = false;
+  PythonQtSlotInfo* tail = NULL;
 
   // look for dynamic decorators in this class and in derived classes
+  // (do this first to allow overloading of existing slots with generated wrappers,
+  //  e.g. QDialog::accept is overloaded with PythonQtWrapper_QDialog::accept decorator)
   tail = recursiveFindDecoratorSlotsFromDecoratorProvider(memberName, tail, found, _cachedMembers, 0);
-
+  
   return found;
 }
 
@@ -710,22 +717,6 @@ QObject* PythonQtClassInfo::decorator()
   return _decoratorProvider;
 }
 
-bool PythonQtClassInfo::hasOwnerMethodButNoOwner(void* object)
-{
-  PythonQtMemberInfo info = member("py_hasOwner");
-  if (info._type == PythonQtMemberInfo::Slot) {
-    void* obj = object;
-    bool result = false;
-    void* args[2];
-    args[0] = &result;
-    args[1] = &obj;
-    info._slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
-    return !result;
-  } else {
-    return false;
-  }
-}
-
 void* PythonQtClassInfo::recursiveCastDownIfPossible(void* ptr, const char** resultClassName)
 {
   if (!_polymorphicHandlers.isEmpty()) {

src/PythonQtClassInfo.h

@@ -159,9 +159,6 @@ class PYTHONQT_EXPORT PythonQtClassInfo {
   //! add the parent class info of a CPP object
   void addParentClass(const ParentClassInfo& info) { _parentClasses.append(info); }
 
-  //! check if the special method "py_hasOwner" is implemented and if it returns false, which means that the object may be destroyed
-  bool hasOwnerMethodButNoOwner(void* object);
-
   //! set the associated PythonQtClassWrapper (which handles instance creation of this type)
   void setPythonQtClassWrapper(PyObject* obj) { _pythonQtClassWrapper = obj; }
 

src/PythonQtConversion.cpp

@@ -377,11 +377,32 @@ void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& i
      // a pointer
      if (info.typeId == QMetaType::Char || info.typeId == QMetaType::UChar)
      {
+       if (obj->ob_type == &PyString_Type) {
+         // take direct reference to string data
+         const char* data = PyString_AS_STRING(obj);
+         PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, (void*)data, ptr);
+       } else {
+         // convert to string
+         QString str = PyObjGetString(obj, strict, ok);
+         if (ok) {
+           QByteArray bytes;
+           bytes = str.toUtf8();
+           if (ok) {
+             void* ptr2 = NULL;
+             PythonQtValueStorage_ADD_VALUE_IF_NEEDED(NULL,global_variantStorage, QVariant, QVariant(bytes), ptr2);
+             PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, (((QByteArray*)((QVariant*)ptr2)->constData())->data()), ptr);
+           }
+         }
+       }
+     } else if (info.typeId == QMetaType::QString) {
+       // TODO: this is a special case for bad Qt APIs which take a QString*, like QtGui.QFileDialog.getSaveFileName
+       // In general we would need to decide to either support * args for all basic types (ignoring the fact that the
+       // result value is not useable in Python), or if all these APIs need to be wrapped manually/differently, like PyQt/PySide do.
        QString str = PyObjGetString(obj, strict, ok);
        if (ok) {
          void* ptr2 = NULL;
-         PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(str.toUtf8()), ptr2);
-         PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, (((QByteArray*)((QVariant*)ptr2)->constData())->data()), ptr);
+         PythonQtValueStorage_ADD_VALUE_IF_NEEDED(NULL,global_variantStorage, QVariant, QVariant(str), ptr2);
+         PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, (void*)((QVariant*)ptr2)->constData(), ptr);
        }
      } else if (info.name == "PyObject") {
        // handle low level PyObject directly
@@ -746,7 +767,13 @@ int PythonQtConv::PyObjGetInt(PyObject* val, bool strict, bool &ok) {
     } else if (val == Py_True) {
       d = 1;
     } else {
-      ok = false;
+      PyErr_Clear();
+      // PyInt_AsLong will try conversion to an int if the object is not an int:
+      d = PyInt_AsLong(val);
+      if (PyErr_Occurred()) {
+        ok = false;
+        PyErr_Clear();
+      }
     }
   } else {
     ok = false;
@@ -772,7 +799,13 @@ qint64 PythonQtConv::PyObjGetLongLong(PyObject* val, bool strict, bool &ok) {
     } else if (val == Py_True) {
       d = 1;
     } else {
-      ok = false;
+      PyErr_Clear();
+      // PyLong_AsLongLong will try conversion to an int if the object is not an int:
+      d = PyLong_AsLongLong(val);
+      if (PyErr_Occurred()) {
+        ok = false;
+        PyErr_Clear();
+      }
     }
   } else {
     ok = false;
@@ -798,7 +831,13 @@ quint64 PythonQtConv::PyObjGetULongLong(PyObject* val, bool strict, bool &ok) {
     } else if (val == Py_True) {
       d = 1;
     } else {
-      ok = false;
+      PyErr_Clear();
+      // PyLong_AsLongLong will try conversion to an int if the object is not an int:
+      d = PyLong_AsLongLong(val);
+      if (PyErr_Occurred()) {
+        PyErr_Clear();
+        ok = false;
+      }
     }
   } else {
     ok = false;
@@ -821,7 +860,13 @@ double PythonQtConv::PyObjGetDouble(PyObject* val, bool strict, bool &ok) {
     } else if (val == Py_True) {
       d = 1;
     } else {
-      ok = false;
+      PyErr_Clear();
+      // PyFloat_AsDouble will try conversion to a double if the object is not a float:
+      d = PyFloat_AsDouble(val);
+      if (PyErr_Occurred()) {
+        PyErr_Clear();
+        ok = false;
+      }
     }
   } else {
     ok = false;

src/PythonQtInstanceWrapper.cpp

@@ -64,7 +64,7 @@ static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self,
     // we own our qobject, so we delete it now:
     delete self->_obj;
     self->_obj = NULL;
-    if (force || self->classInfo()->hasOwnerMethodButNoOwner(self->_wrappedPtr) || self->_ownedByPythonQt) {
+    if (force || self->_ownedByPythonQt) {
       int type = self->classInfo()->metaTypeId();
       if (self->_useQMetaTypeDestroy && type>=0) {
         // use QMetaType to destroy the object

src/PythonQtMethodInfo.cpp

@@ -197,6 +197,31 @@ int PythonQtMethodInfo::nameToType(const char* name)
     _parameterTypeDict.insert("QString", QMetaType::QString);
     _parameterTypeDict.insert("", QMetaType::Void);
     _parameterTypeDict.insert("void", QMetaType::Void);
+
+    // GL types
+    _parameterTypeDict.insert("GLenum", QMetaType::UInt);
+    _parameterTypeDict.insert("GLboolean", QMetaType::UChar);
+    _parameterTypeDict.insert("GLbitfield", QMetaType::UInt);
+    _parameterTypeDict.insert("GLbyte", QMetaType::Char);
+    _parameterTypeDict.insert("GLubyte", QMetaType::UChar);
+    _parameterTypeDict.insert("GLshort", QMetaType::Short);
+    _parameterTypeDict.insert("GLushort", QMetaType::UShort);
+    _parameterTypeDict.insert("GLint", QMetaType::Int);
+    _parameterTypeDict.insert("GLuint", QMetaType::UInt);
+    _parameterTypeDict.insert("GLsizei", QMetaType::UInt);
+    _parameterTypeDict.insert("GLclampf", QMetaType::Float);
+    _parameterTypeDict.insert("GLfloat", QMetaType::Float);
+    _parameterTypeDict.insert("GLclampd", QMetaType::Double);
+    _parameterTypeDict.insert("GLdouble", QMetaType::Double);
+    _parameterTypeDict.insert("GLvoid", QMetaType::Void);
+    if (QT_POINTER_SIZE == 8) {
+      _parameterTypeDict.insert("qgl_GLintptr", QMetaType::LongLong);
+      _parameterTypeDict.insert("qgl_GLsizeiptr", QMetaType::LongLong);
+    } else {
+      _parameterTypeDict.insert("qgl_GLintptr", QMetaType::Int);
+      _parameterTypeDict.insert("qgl_GLsizeiptr", QMetaType::Int);
+    }
+
     // QVariant names
     _parameterTypeDict.insert("Q_LLONG", QMetaType::LongLong);
     _parameterTypeDict.insert("Q_ULLONG", QMetaType::ULongLong);