Qt6 compatibility fixes for core PythonQt library

richard42 · mrbean-bremen · commit 10a3e499b488 · 2023-11-02T20:39:00.000+01:00
diff --git a/src/PythonQt.cpp b/src/PythonQt.cpp
@@ -122,8 +122,6 @@ void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
     } else {
       qRegisterMetaType<quint32>("size_t");
     }
-    int stringRefId = qRegisterMetaType<QStringRef>("QStringRef");
-    PythonQtConv::registerMetaTypeToPythonConverter(stringRefId, PythonQtConv::convertFromStringRef);
 
     int objectPtrListId = qRegisterMetaType<QList<PythonQtObjectPtr> >("QList<PythonQtObjectPtr>");
     PythonQtConv::registerMetaTypeToPythonConverter(objectPtrListId, PythonQtConv::convertFromQListOfPythonQtObjectPtr);
@@ -239,7 +237,7 @@ void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
     PythonQtRegisterToolClassesTemplateConverterForKnownClass(QLineF);
     PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPoint);
     PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPointF);
-    PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRegExp);
+    PythonQtRegisterToolClassesTemplateConverterForKnownClass(QRegularExpression);
 
     PythonQtRegisterToolClassesTemplateConverterForKnownClass(QFont);
     PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPixmap);
@@ -257,7 +255,6 @@ void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
     PythonQtRegisterToolClassesTemplateConverterForKnownClass(QPen);
     PythonQtRegisterToolClassesTemplateConverterForKnownClass(QTextLength);
     PythonQtRegisterToolClassesTemplateConverterForKnownClass(QTextFormat);
-    PythonQtRegisterToolClassesTemplateConverterForKnownClass(QMatrix);
 
     PyObject* pack = PythonQt::priv()->packageByName("QtCore");
     PyObject* pack2 = PythonQt::priv()->packageByName("Qt");
diff --git a/src/PythonQtClassInfo.cpp b/src/PythonQtClassInfo.cpp
@@ -554,7 +554,8 @@ QStringList PythonQtClassInfo::memberList()
     }
   }
 
-  return QSet<QString>::fromList(l).toList();
+  QSet<QString> set(l.begin(), l.end());
+  return set.values();
 }
 
 const QByteArray& PythonQtClassInfo::className() const
diff --git a/src/PythonQtClassWrapper.cpp b/src/PythonQtClassWrapper.cpp
@@ -463,8 +463,8 @@ static PyObject *PythonQtClassWrapper_getattro(PyObject *obj, PyObject *name)
     }
     PyObject* dict = PyDict_New();
       
-    QSet<QString> completeSet = QSet<QString>::fromList(wrapper->classInfo()->memberList());
-    completeSet.unite(QSet<QString>::fromList(wrapper->classInfo()->propertyList()));
+    QSet<QString> completeSet(wrapper->classInfo()->memberList().begin(), wrapper->classInfo()->memberList().end());
+    completeSet.unite(QSet<QString>(wrapper->classInfo()->propertyList().begin(), wrapper->classInfo()->propertyList().end()));
 
     Q_FOREACH (QString name, completeSet) {
       if (name.startsWith("py_")) {
diff --git a/src/PythonQtConversion.cpp b/src/PythonQtConversion.cpp
@@ -1015,17 +1015,17 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
       if (wrap->classInfo()->isCPPWrapper()) {
         if (wrap->classInfo()->metaTypeId()>0) {
           // construct a new variant from the C++ object if it has a meta type (this will COPY the object!)
-          v = QVariant(wrap->classInfo()->metaTypeId(), wrap->_wrappedPtr);
+          v = QVariant(QMetaType(wrap->classInfo()->metaTypeId()), wrap->_wrappedPtr);
         } else {
           // TODOXXX we could as well check if there is a registered meta type for "classname*", so that we may pass
           // the pointer here...
           // is this worth anything? we loose the knowledge of the cpp object type
-          v = qVariantFromValue(wrap->_wrappedPtr);
+          v = QVariant::fromValue(wrap->_wrappedPtr);
         }
       } else {
         // this gives us a QObject pointer
         QObject* myObject = wrap->_obj;
-        v = qVariantFromValue(myObject);
+        v = QVariant::fromValue(myObject);
       }
       return v;
     } else if (val == Py_None) {
@@ -1073,55 +1073,55 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
   case QMetaType::Float:
     {
       float d = (float) PyObjGetDouble(val,false,ok);
-      if (ok) v =  qVariantFromValue(d);
+      if (ok) v =  QVariant::fromValue(d);
     }
     break;
   case QMetaType::Long:
     {
       long d = (long) PyObjGetLongLong(val,false,ok);
-      if (ok) v =  qVariantFromValue(d);
+      if (ok) v =  QVariant::fromValue(d);
     }
     break;
   case QMetaType::ULong:
     {
       unsigned long d = (unsigned long) PyObjGetLongLong(val,false,ok);
-      if (ok) v =  qVariantFromValue(d);
+      if (ok) v =  QVariant::fromValue(d);
     }
     break;
   case QMetaType::LongLong:
     {
       qint64 d = PyObjGetLongLong(val, false, ok);
-      if (ok) v =  qVariantFromValue(d);
+      if (ok) v =  QVariant::fromValue(d);
     }
     break;
   case QMetaType::ULongLong:
     {
       quint64 d = PyObjGetULongLong(val, false, ok);
-      if (ok) v =  qVariantFromValue(d);
+      if (ok) v =  QVariant::fromValue(d);
     }
     break;
   case QMetaType::Short:
     {
       short d = (short) PyObjGetInt(val,false,ok);
-      if (ok) v =  qVariantFromValue(d);
+      if (ok) v =  QVariant::fromValue(d);
     }
     break;
   case QMetaType::UShort:
     {
       unsigned short d = (unsigned short) PyObjGetInt(val,false,ok);
-      if (ok) v =  qVariantFromValue(d);
+      if (ok) v =  QVariant::fromValue(d);
     }
     break;
   case QMetaType::Char:
     {
       char d = (char) PyObjGetInt(val,false,ok);
-      if (ok) v =  qVariantFromValue(d);
+      if (ok) v =  QVariant::fromValue(d);
     }
     break;
   case QMetaType::UChar:
     {
       unsigned char d = (unsigned char) PyObjGetInt(val,false,ok);
-      if (ok) v =  qVariantFromValue(d);
+      if (ok) v =  QVariant::fromValue(d);
     }
     break;
 
@@ -1189,7 +1189,7 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
       PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)val;
       if (wrap->classInfo()->isCPPWrapper() && wrap->classInfo()->metaTypeId() == type) {
         // construct a new variant from the C++ object if it has the same meta type
-        v = QVariant(type, wrap->_wrappedPtr);
+        v = QVariant(QMetaType(type), wrap->_wrappedPtr);
       } else {
         // Try to convert the object to a QVariant based on the typeName
         bool ok;
@@ -1202,10 +1202,10 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
         void* object = castWrapperTo(wrap, typeName, ok);
         if (ok) {
           if (isPtr) {
-            v = QVariant(type, &object);
+            v = QVariant(QMetaType(type), &object);
           }
           else {
-            v = QVariant(type, object);
+            v = QVariant(QMetaType(type), object);
           }
         }
       }
@@ -1215,7 +1215,7 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
       PythonQtConvertPythonToMetaTypeCB* converter = _pythonToMetaTypeConverters.value(type);
       if (converter) {
         // allocate a default object of the needed type:
-        v = QVariant(type, (const void*)nullptr);
+        v = QVariant(QMetaType(type), (const void*)nullptr);
         // now call the converter, passing the internal object of the variant
         ok = (*converter)(val, (void*)v.constData(), type, true);
         if (!ok) {
@@ -1226,7 +1226,7 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
         const PythonQtMethodInfo::ParameterInfo& info = PythonQtMethodInfo::getParameterInfoForMetaType(type);
         if (info.isQList && (info.innerNamePointerCount == 1)) {
           // allocate a default object of the needed type:
-          v = QVariant(type, (const void*)nullptr);
+          v = QVariant(QMetaType(type), (const void*)nullptr);
           ok = ConvertPythonListToQListOfPointerType(val, (QList<void*>*)v.constData(), info, true);
           if (!ok) {
             v = QVariant();
@@ -1461,7 +1461,7 @@ QString PythonQtConv::CPPObjectToString(int type, const void* data) {
       // this creates a copy, but that should not be expensive for typical simple variants
       // (but we do not want to do this for our won user types!
       if (type>0 && type < (int)QVariant::UserType) {
-        QVariant v(type, data);
+        QVariant v(QMetaType(type), data);
         r = v.toString();
       }
   }
@@ -1483,11 +1483,6 @@ PyObject* PythonQtConv::createCopyFromMetaType( int type, const void* data )
   return (PyObject*)wrap;
 }
 
-PyObject* PythonQtConv::convertFromStringRef(const void* inObject, int /*metaTypeId*/)
-{
-  return PythonQtConv::QStringToPyObject(((QStringRef*)inObject)->toString());
-}
-
 QByteArray PythonQtConv::getCPPTypeName(PyObject* type)
 {
   QByteArray result;
diff --git a/src/PythonQtConversion.h b/src/PythonQtConversion.h
@@ -185,7 +185,6 @@ class PYTHONQT_EXPORT PythonQtConv {
   static PyObject* convertFromPythonQtSafeObjectPtr(const void* /* PythonQtObjectPtr* */ inObject, int /*metaTypeId*/);
   static bool      convertToQListOfPythonQtObjectPtr(PyObject* obj, void* /* QList<PythonQtObjectPtr>* */ outList, int /*metaTypeId*/, bool /*strict*/);
   static PyObject* convertFromQListOfPythonQtObjectPtr(const void* /* QList<PythonQtObjectPtr>* */ inObject, int /*metaTypeId*/);
-  static PyObject* convertFromStringRef(const void* inObject, int /*metaTypeId*/);
 
   //! Returns the name of the equivalent CPP type (for signals and slots)
   static QByteArray getCPPTypeName(PyObject* type);
diff --git a/src/PythonQtImporter.cpp b/src/PythonQtImporter.cpp
@@ -222,7 +222,7 @@ PythonQtImporter_load_module(PyObject *obj, PyObject *args)
 {
   PythonQtImporter *self = (PythonQtImporter *)obj;
   PyObject *code = nullptr, *mod = nullptr, *dict = nullptr;
-  char *fullname;
+  char *fullname = NULL;
 
   if (!PyArg_ParseTuple(args, "s:PythonQtImporter.load_module",
             &fullname))
@@ -338,7 +338,7 @@ PythonQtImporter_load_module(PyObject *obj, PyObject *args)
       QVariantList list = result.toList();
       if (list.count()==3) {
         // We prepend the full module name (including package prefix)
-        list.prepend(fullname);
+        list.prepend(QString(fullname));
 #ifdef __linux
   #ifdef _DEBUG
         // imp_find_module() does not respect the debug suffix '_d' on Linux,
@@ -740,7 +740,7 @@ PythonQtImport::getCodeFromData(const QString& path, int isbytecode,int /*ispack
       QDateTime time;
       time = PythonQt::importInterface()->lastModifiedDate(path);
       QString cacheFilename =  getCacheFilename(path, /*isOptimizedFilename=*/false);
-      writeCompiledModule((PyCodeObject*)code, cacheFilename, time.toTime_t(), /*sourceSize=*/qdata.length());
+      writeCompiledModule((PyCodeObject*)code, cacheFilename, time.toSecsSinceEpoch(), /*sourceSize=*/qdata.length());
     }
   }
   return code;
@@ -754,7 +754,7 @@ PythonQtImport::getMTimeOfSource(const QString& path)
   if (PythonQt::importInterface()->exists(path2)) {
     QDateTime t = PythonQt::importInterface()->lastModifiedDate(path2);
     if (t.isValid()) {
-      mtime = t.toTime_t();
+      mtime = t.toSecsSinceEpoch();
     }
   }
 
diff --git a/src/PythonQtMethodInfo.cpp b/src/PythonQtMethodInfo.cpp
@@ -372,7 +372,7 @@ int PythonQtMethodInfo::nameToType(const char* name)
     _parameterTypeDict.insert("QLineF", QMetaType::QLineF);
     _parameterTypeDict.insert("QPoint", QMetaType::QPoint);
     _parameterTypeDict.insert("QPointF", QMetaType::QPointF);
-    _parameterTypeDict.insert("QRegExp", QMetaType::QRegExp);
+    _parameterTypeDict.insert("QRegularExpression", QMetaType::QRegularExpression);
     _parameterTypeDict.insert("QFont", QMetaType::QFont);
     _parameterTypeDict.insert("QPixmap", QMetaType::QPixmap);
     _parameterTypeDict.insert("QBrush", QMetaType::QBrush);
@@ -388,7 +388,6 @@ int PythonQtMethodInfo::nameToType(const char* name)
     _parameterTypeDict.insert("QPen", QMetaType::QPen);
     _parameterTypeDict.insert("QTextLength", QMetaType::QTextLength);
     _parameterTypeDict.insert("QTextFormat", QMetaType::QTextFormat);
-    _parameterTypeDict.insert("QMatrix", QMetaType::QMatrix);
     _parameterTypeDict.insert("QVariant", PythonQtMethodInfo::Variant);
     // own special types... (none so far, could be e.g. ObjectList
   }
diff --git a/src/PythonQtSlot.cpp b/src/PythonQtSlot.cpp
@@ -540,7 +540,7 @@ meth_get__doc__(PythonQtSlotFunctionObject * m, void * /*closure*/)
     if (!names.at(i - 1).isEmpty()) {
       doc += names.at(i - 1);
     } else {
-      doc += QString('a' + i - firstArgOffset).toLatin1();
+      doc += QString(QChar((char) ('a' + i - firstArgOffset))).toLatin1();
     }
   }
   doc += ")";
diff --git a/src/PythonQtStdDecorators.cpp b/src/PythonQtStdDecorators.cpp
@@ -45,6 +45,7 @@
 #include "PythonQtConversion.h"
 
 #include <QCoreApplication>
+#include <QRegularExpression>
 
 bool PythonQtStdDecorators::connect(QObject* sender, const QByteArray& signal, PyObject* callable)
 {
@@ -240,7 +241,7 @@ QList<QObject*> PythonQtStdDecorators::findChildren(QObject* parent, PyObject* t
   return list;
 }
 
-QList<QObject*> PythonQtStdDecorators::findChildren(QObject* parent, PyObject* type, const QRegExp& regExp)
+QList<QObject*> PythonQtStdDecorators::findChildren(QObject* parent, PyObject* type, const QRegularExpression& regExp)
 {
   const QMetaObject* meta = nullptr;
   QByteArray typeName;
@@ -322,7 +323,7 @@ int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, c
   return 0;
 }
 
-int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QRegExp& regExp, QList<QObject*>& list)
+int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QRegularExpression& regExp, QList<QObject*>& list)
 {
   const QObjectList& children = parent->children();
   int i;
@@ -334,7 +335,8 @@ int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, c
       return -1;
 
     // Skip if the name doesn't match.
-    if (regExp.indexIn(obj->objectName()) == -1)
+    QRegularExpressionMatch match = regExp.match(obj->objectName());
+    if (match.hasMatch() == false)
       continue;
 
     if ((typeName && obj->inherits(typeName)) ||
diff --git a/src/PythonQtStdDecorators.h b/src/PythonQtStdDecorators.h
@@ -58,6 +58,7 @@
 #include <QMetaMethod>
 #include <QMetaEnum>
 #include <QMetaProperty>
+#include <QRandomGenerator>
 
 class PYTHONQT_EXPORT PythonQtStdDecorators : public QObject
 {
@@ -82,7 +83,7 @@ public Q_SLOTS:
   const QObjectList* children(QObject* o);
   QObject* findChild(QObject* parent, PyObject* type, const QString& name = QString());
   QList<QObject*> findChildren(QObject* parent, PyObject* type, const QString& name= QString());
-  QList<QObject*> findChildren(QObject* parent, PyObject* type, const QRegExp& regExp);
+  QList<QObject*> findChildren(QObject* parent, PyObject* type, const QRegularExpression& regExp);
 
   bool setProperty(QObject* o, const char* name, const QVariant& value);
   QVariant property(QObject* o, const char* name);
@@ -103,8 +104,8 @@ public Q_SLOTS:
   int static_Qt_qRound(double a) { return qRound(a); }
   qint64 static_Qt_qRound64(double a) { return qRound64(a); }
   const char* static_Qt_qVersion() { return qVersion(); }
-  int static_Qt_qrand() { return qrand(); }
-  void static_Qt_qsrand(uint a) { qsrand(a); }
+  int static_Qt_qrand() { return QRandomGenerator::global()->generate(); }
+  void static_Qt_qsrand(uint a) { QRandomGenerator::global()->seed(a); }
 
   QString tr(QObject* obj, const QString& text, const QString& ambig = QString(), int n = -1);
 
@@ -116,7 +117,7 @@ public Q_SLOTS:
 private:
   QObject* findChild(QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name);
   int findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name, QList<QObject*>& list);
-  int findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QRegExp& regExp, QList<QObject*>& list);
+  int findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QRegularExpression& regExp, QList<QObject*>& list);
 };
 
 class PythonQtSingleShotTimer : public QTimer
diff --git a/src/PythonQtVariants.h b/src/PythonQtVariants.h
@@ -54,7 +54,7 @@
 #include <QLineF>
 #include <QPoint>
 #include <QPointF>
-#include <QRegExp>
+#include <QRegularExpression>
 
 #include <QFont>
 #include <QBitmap>
@@ -72,7 +72,6 @@
 #include <QPen>
 #include <QTextLength>
 #include <QTextFormat>
-#include <QMatrix>
 
 #endif
 
diff --git a/src/gui/PythonQtScriptingConsole.h b/src/gui/PythonQtScriptingConsole.h
@@ -55,7 +55,7 @@ class PYTHONQT_EXPORT PythonQtScriptingConsole : public QTextEdit
   Q_OBJECT
 
 public:
-  PythonQtScriptingConsole(QWidget* parent, const PythonQtObjectPtr& context, Qt::WindowFlags i = 0);
+  PythonQtScriptingConsole(QWidget* parent, const PythonQtObjectPtr& context, Qt::WindowFlags i = Qt::WindowFlags());
 
   ~PythonQtScriptingConsole() override;
 
diff --git a/src/src.pro b/src/src.pro
@@ -4,7 +4,7 @@
 # $Source$
 # --------------------------------------------------
 
-TARGET   = PythonQt-Qt5-PythonXY
+TARGET   = PythonQt-Qt6-PythonXY
 TEMPLATE = lib
 
 DESTDIR    = ../lib
@@ -25,12 +25,16 @@ isEmpty(PYTHONQT_STATIC) {
 
 DEFINES += PYTHONQT_CATCH_ALL_EXCEPTIONS
 
-contains(QT_MAJOR_VERSION, 5) {
+contains(QT_MAJOR_VERSION, 6) {
   QT += widgets core-private
 }
  
 INCLUDEPATH += $$PWD
 
+macx {
+    QMAKE_APPLE_DEVICE_ARCHS = x86_64 arm64
+}
+
 include ( ../build/common.prf )  
 include ( ../build/python.prf )
 TARGET = $$replace(TARGET, PythonXY, Python$${PYTHON_VERSION})

Original file line number	Diff line number	Diff line change
`@@ -554,7 +554,8 @@ QStringList PythonQtClassInfo::memberList()`
`554`	`554`	`}`
`555`	`555`	`}`
`556`	`556`
`557`		`- return QSet<QString>::fromList(l).toList();`
	`557`	`+ QSet<QString> set(l.begin(), l.end());`
	`558`	`+ return set.values();`
`558`	`559`	`}`
`559`	`560`
`560`	`561`	`const QByteArray& PythonQtClassInfo::className() const`
Original file line number	Diff line number	Diff line change
`@@ -463,8 +463,8 @@ static PyObject PythonQtClassWrapper_getattro(PyObject obj, PyObject *name)`
`463`	`463`	`}`
`464`	`464`	`PyObject* dict = PyDict_New();`
`465`	`465`
`466`		`- QSet<QString> completeSet = QSet<QString>::fromList(wrapper->classInfo()->memberList());`
`467`		`- completeSet.unite(QSet<QString>::fromList(wrapper->classInfo()->propertyList()));`
	`466`	`+ QSet<QString> completeSet(wrapper->classInfo()->memberList().begin(), wrapper->classInfo()->memberList().end());`
	`467`	`+ completeSet.unite(QSet<QString>(wrapper->classInfo()->propertyList().begin(), wrapper->classInfo()->propertyList().end()));`
`468`	`468`
`469`	`469`	`Q_FOREACH (QString name, completeSet) {`
`470`	`470`	`if (name.startsWith("py_")) {`
Original file line number	Diff line number	Diff line change
`@@ -1015,17 +1015,17 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)`
`1015`	`1015`	`if (wrap->classInfo()->isCPPWrapper()) {`
`1016`	`1016`	`if (wrap->classInfo()->metaTypeId()>0) {`
`1017`	`1017`	`// construct a new variant from the C++ object if it has a meta type (this will COPY the object!)`
`1018`		`- v = QVariant(wrap->classInfo()->metaTypeId(), wrap->_wrappedPtr);`
	`1018`	`+ v = QVariant(QMetaType(wrap->classInfo()->metaTypeId()), wrap->_wrappedPtr);`
`1019`	`1019`	`} else {`
`1020`	`1020`	`// TODOXXX we could as well check if there is a registered meta type for "classname*", so that we may pass`
`1021`	`1021`	`// the pointer here...`
`1022`	`1022`	`// is this worth anything? we loose the knowledge of the cpp object type`
`1023`		`- v = qVariantFromValue(wrap->_wrappedPtr);`
	`1023`	`+ v = QVariant::fromValue(wrap->_wrappedPtr);`
`1024`	`1024`	`}`
`1025`	`1025`	`} else {`
`1026`	`1026`	`// this gives us a QObject pointer`
`1027`	`1027`	`QObject* myObject = wrap->_obj;`
`1028`		`- v = qVariantFromValue(myObject);`
	`1028`	`+ v = QVariant::fromValue(myObject);`
`1029`	`1029`	`}`
`1030`	`1030`	`return v;`
`1031`	`1031`	`} else if (val == Py_None) {`
`@@ -1073,55 +1073,55 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)`
`1073`	`1073`	`case QMetaType::Float:`
`1074`	`1074`	`{`
`1075`	`1075`	`float d = (float) PyObjGetDouble(val,false,ok);`
`1076`		`- if (ok) v = qVariantFromValue(d);`
	`1076`	`+ if (ok) v = QVariant::fromValue(d);`
`1077`	`1077`	`}`
`1078`	`1078`	`break;`
`1079`	`1079`	`case QMetaType::Long:`
`1080`	`1080`	`{`
`1081`	`1081`	`long d = (long) PyObjGetLongLong(val,false,ok);`
`1082`		`- if (ok) v = qVariantFromValue(d);`
	`1082`	`+ if (ok) v = QVariant::fromValue(d);`
`1083`	`1083`	`}`
`1084`	`1084`	`break;`
`1085`	`1085`	`case QMetaType::ULong:`
`1086`	`1086`	`{`
`1087`	`1087`	`unsigned long d = (unsigned long) PyObjGetLongLong(val,false,ok);`
`1088`		`- if (ok) v = qVariantFromValue(d);`
	`1088`	`+ if (ok) v = QVariant::fromValue(d);`
`1089`	`1089`	`}`
`1090`	`1090`	`break;`
`1091`	`1091`	`case QMetaType::LongLong:`
`1092`	`1092`	`{`
`1093`	`1093`	`qint64 d = PyObjGetLongLong(val, false, ok);`
`1094`		`- if (ok) v = qVariantFromValue(d);`
	`1094`	`+ if (ok) v = QVariant::fromValue(d);`
`1095`	`1095`	`}`
`1096`	`1096`	`break;`
`1097`	`1097`	`case QMetaType::ULongLong:`
`1098`	`1098`	`{`
`1099`	`1099`	`quint64 d = PyObjGetULongLong(val, false, ok);`
`1100`		`- if (ok) v = qVariantFromValue(d);`
	`1100`	`+ if (ok) v = QVariant::fromValue(d);`
`1101`	`1101`	`}`
`1102`	`1102`	`break;`
`1103`	`1103`	`case QMetaType::Short:`
`1104`	`1104`	`{`
`1105`	`1105`	`short d = (short) PyObjGetInt(val,false,ok);`
`1106`		`- if (ok) v = qVariantFromValue(d);`
	`1106`	`+ if (ok) v = QVariant::fromValue(d);`
`1107`	`1107`	`}`
`1108`	`1108`	`break;`
`1109`	`1109`	`case QMetaType::UShort:`
`1110`	`1110`	`{`
`1111`	`1111`	`unsigned short d = (unsigned short) PyObjGetInt(val,false,ok);`
`1112`		`- if (ok) v = qVariantFromValue(d);`
	`1112`	`+ if (ok) v = QVariant::fromValue(d);`
`1113`	`1113`	`}`
`1114`	`1114`	`break;`
`1115`	`1115`	`case QMetaType::Char:`
`1116`	`1116`	`{`
`1117`	`1117`	`char d = (char) PyObjGetInt(val,false,ok);`
`1118`		`- if (ok) v = qVariantFromValue(d);`
	`1118`	`+ if (ok) v = QVariant::fromValue(d);`
`1119`	`1119`	`}`
`1120`	`1120`	`break;`
`1121`	`1121`	`case QMetaType::UChar:`
`1122`	`1122`	`{`
`1123`	`1123`	`unsigned char d = (unsigned char) PyObjGetInt(val,false,ok);`
`1124`		`- if (ok) v = qVariantFromValue(d);`
	`1124`	`+ if (ok) v = QVariant::fromValue(d);`
`1125`	`1125`	`}`
`1126`	`1126`	`break;`
`1127`	`1127`
`@@ -1189,7 +1189,7 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)`
`1189`	`1189`	`PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)val;`
`1190`	`1190`	`if (wrap->classInfo()->isCPPWrapper() && wrap->classInfo()->metaTypeId() == type) {`
`1191`	`1191`	`// construct a new variant from the C++ object if it has the same meta type`
`1192`		`- v = QVariant(type, wrap->_wrappedPtr);`
	`1192`	`+ v = QVariant(QMetaType(type), wrap->_wrappedPtr);`
`1193`	`1193`	`} else {`
`1194`	`1194`	`// Try to convert the object to a QVariant based on the typeName`
`1195`	`1195`	`bool ok;`
`@@ -1202,10 +1202,10 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)`
`1202`	`1202`	`void* object = castWrapperTo(wrap, typeName, ok);`
`1203`	`1203`	`if (ok) {`
`1204`	`1204`	`if (isPtr) {`
`1205`		`- v = QVariant(type, &object);`
	`1205`	`+ v = QVariant(QMetaType(type), &object);`
`1206`	`1206`	`}`
`1207`	`1207`	`else {`
`1208`		`- v = QVariant(type, object);`
	`1208`	`+ v = QVariant(QMetaType(type), object);`
`1209`	`1209`	`}`
`1210`	`1210`	`}`
`1211`	`1211`	`}`
`@@ -1215,7 +1215,7 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)`
`1215`	`1215`	`PythonQtConvertPythonToMetaTypeCB* converter = _pythonToMetaTypeConverters.value(type);`
`1216`	`1216`	`if (converter) {`
`1217`	`1217`	`// allocate a default object of the needed type:`
`1218`		`- v = QVariant(type, (const void*)nullptr);`
	`1218`	`+ v = QVariant(QMetaType(type), (const void*)nullptr);`
`1219`	`1219`	`// now call the converter, passing the internal object of the variant`
`1220`	`1220`	`ok = (converter)(val, (void)v.constData(), type, true);`
`1221`	`1221`	`if (!ok) {`
`@@ -1226,7 +1226,7 @@ QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)`
`1226`	`1226`	`const PythonQtMethodInfo::ParameterInfo& info = PythonQtMethodInfo::getParameterInfoForMetaType(type);`
`1227`	`1227`	`if (info.isQList && (info.innerNamePointerCount == 1)) {`
`1228`	`1228`	`// allocate a default object of the needed type:`
`1229`		`- v = QVariant(type, (const void*)nullptr);`
	`1229`	`+ v = QVariant(QMetaType(type), (const void*)nullptr);`
`1230`	`1230`	`ok = ConvertPythonListToQListOfPointerType(val, (QList<void>)v.constData(), info, true);`
`1231`	`1231`	`if (!ok) {`
`1232`	`1232`	`v = QVariant();`
`@@ -1461,7 +1461,7 @@ QString PythonQtConv::CPPObjectToString(int type, const void* data) {`
`1461`	`1461`	`// this creates a copy, but that should not be expensive for typical simple variants`
`1462`	`1462`	`// (but we do not want to do this for our won user types!`
`1463`	`1463`	`if (type>0 && type < (int)QVariant::UserType) {`
`1464`		`- QVariant v(type, data);`
	`1464`	`+ QVariant v(QMetaType(type), data);`
`1465`	`1465`	`r = v.toString();`
`1466`	`1466`	`}`
`1467`	`1467`	`}`
`@@ -1483,11 +1483,6 @@ PyObject* PythonQtConv::createCopyFromMetaType( int type, const void* data )`
`1483`	`1483`	`return (PyObject*)wrap;`
`1484`	`1484`	`}`
`1485`	`1485`
`1486`		`-PyObject* PythonQtConv::convertFromStringRef(const void* inObject, int /metaTypeId/)`
`1487`		`-{`
`1488`		`- return PythonQtConv::QStringToPyObject(((QStringRef*)inObject)->toString());`
`1489`		`-}`
`1490`		`-`
`1491`	`1486`	`QByteArray PythonQtConv::getCPPTypeName(PyObject* type)`
`1492`	`1487`	`{`
`1493`	`1488`	`QByteArray result;`
Original file line number	Diff line number	Diff line change
`@@ -540,7 +540,7 @@ meth_get__doc__(PythonQtSlotFunctionObject * m, void * /closure/)`
`540`	`540`	`if (!names.at(i - 1).isEmpty()) {`
`541`	`541`	`doc += names.at(i - 1);`
`542`	`542`	`} else {`
`543`		`- doc += QString('a' + i - firstArgOffset).toLatin1();`
	`543`	`+ doc += QString(QChar((char) ('a' + i - firstArgOffset))).toLatin1();`
`544`	`544`	`}`
`545`	`545`	`}`
`546`	`546`	`doc += ")";`
Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,7 @@`
`45`	`45`	`#include "PythonQtConversion.h"`
`46`	`46`
`47`	`47`	`#include <QCoreApplication>`
	`48`	`+#include <QRegularExpression>`
`48`	`49`
`49`	`50`	`bool PythonQtStdDecorators::connect(QObject* sender, const QByteArray& signal, PyObject* callable)`
`50`	`51`	`{`
`@@ -240,7 +241,7 @@ QList<QObject> PythonQtStdDecorators::findChildren(QObject parent, PyObject* t`
`240`	`241`	`return list;`
`241`	`242`	`}`
`242`	`243`
`243`		`-QList<QObject> PythonQtStdDecorators::findChildren(QObject parent, PyObject* type, const QRegExp& regExp)`
	`244`	`+QList<QObject> PythonQtStdDecorators::findChildren(QObject parent, PyObject* type, const QRegularExpression& regExp)`
`244`	`245`	`{`
`245`	`246`	`const QMetaObject* meta = nullptr;`
`246`	`247`	`QByteArray typeName;`
`@@ -322,7 +323,7 @@ int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, c`
`322`	`323`	`return 0;`
`323`	`324`	`}`
`324`	`325`
`325`		`-int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QRegExp& regExp, QList<QObject*>& list)`
	`326`	`+int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QRegularExpression& regExp, QList<QObject*>& list)`
`326`	`327`	`{`
`327`	`328`	`const QObjectList& children = parent->children();`
`328`	`329`	`int i;`
`@@ -334,7 +335,8 @@ int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, c`
`334`	`335`	`return -1;`
`335`	`336`
`336`	`337`	`// Skip if the name doesn't match.`
`337`		`- if (regExp.indexIn(obj->objectName()) == -1)`
	`338`	`+ QRegularExpressionMatch match = regExp.match(obj->objectName());`
	`339`	`+ if (match.hasMatch() == false)`
`338`	`340`	`continue;`
`339`	`341`
`340`	`342`	`if ((typeName && obj->inherits(typeName)) \|\|`