From 1e29ab65924166688e352eaaa099ad571a980c4f Mon Sep 17 00:00:00 2001
From: Renato Filho <renato.filho@openbossa.org>
Date: Mon, 3 Oct 2011 18:49:42 -0300
Subject: Initia QtCore port to python3.

---
 PySide/QtCore/qbytearray_conversions.h    |  20 +++--
 PySide/QtCore/qchar_conversions.h         |   6 +-
 PySide/QtCore/qdate_conversions.h         |   8 +-
 PySide/QtCore/qdatetime_conversions.h     |   4 +
 PySide/QtCore/qstring_conversions.h       |  10 +--
 PySide/QtCore/qvariant_conversions.h      |   3 +
 PySide/QtCore/qvariant_type_conversions.h |   8 +-
 PySide/QtCore/typesystem_core.xml         | 121 +++++++++++++++++-------------
 8 files changed, 108 insertions(+), 72 deletions(-)

(limited to 'PySide/QtCore')

diff --git a/PySide/QtCore/qbytearray_conversions.h b/PySide/QtCore/qbytearray_conversions.h
index daa16099f..d776d82c4 100644
--- a/PySide/QtCore/qbytearray_conversions.h
+++ b/PySide/QtCore/qbytearray_conversions.h
@@ -11,19 +11,29 @@ inline bool Converter<QByteArray>::isConvertible(PyObject* pyObj)
         return true;
     SbkObjectType* shiboType = reinterpret_cast<SbkObjectType*>(SbkType< ::QByteArray >());
     return Shiboken::Converter<const char *>::checkType(pyObj)
+        || PyBytes_Check(pyObj)
         || (ObjectType::isExternalConvertible(shiboType, pyObj));
 }
 
 inline QByteArray Converter<QByteArray>::toCpp(PyObject* pyObj)
 {
-    if (pyObj == Py_None)
+    if (pyObj == Py_None) {
         return 0;
-    else if (PyObject_TypeCheck(pyObj, SbkType<QByteArray>()))
+    } else if (PyObject_TypeCheck(pyObj, SbkType<QByteArray>())) {
         return *Converter<QByteArray*>::toCpp(pyObj);
-    else if (PyString_Check(pyObj))
-        return QByteArray(PyString_AS_STRING(pyObj), PyString_GET_SIZE(pyObj));
-    else
+    } else if (PyBytes_Check(pyObj)) {
+        return QByteArray(PyBytes_AS_STRING(pyObj), PyBytes_GET_SIZE(pyObj));
+    } else if (PyUnicode_Check(pyObj)) {
+         Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(pyObj));
+         if (!data.isNull())
+             return QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object()));
+         else
+             return QByteArray();
+    } else if (Shiboken::String::check(pyObj)) {
+         return QByteArray(Shiboken::String::toCString(pyObj));
+    } else {
         return ValueTypeConverter<QByteArray>::toCpp(pyObj);
+    }
 }
 
 inline PyObject* Converter<QByteArray>::toPython(const ::QByteArray& cppObj)
diff --git a/PySide/QtCore/qchar_conversions.h b/PySide/QtCore/qchar_conversions.h
index 1ebcb646b..f79bac3c7 100644
--- a/PySide/QtCore/qchar_conversions.h
+++ b/PySide/QtCore/qchar_conversions.h
@@ -5,19 +5,19 @@ struct Converter<QChar>
 {
     static bool checkType(PyObject* pyObj)
     {
-        return PyString_Check(pyObj) && (PyString_Size(pyObj) == 1);
+        return Shiboken::String::check(pyObj) && (Shiboken::String::len(pyObj) == 1);
     }
 
     static bool isConvertible(PyObject* pyObj)
     {
-        return (PyString_Check(pyObj) && (PyString_Size(pyObj) == 1))
+        return (Shiboken::String::check(pyObj) && (Shiboken::String::len(pyObj) == 1))
                || pyObj == Py_None
                || PyInt_Check(pyObj);
     }
 
     static QChar toCpp(PyObject* pyObj)
     {
-        if (PyString_Check(pyObj) && PyString_Size(pyObj) == 1)
+        if (Shiboken::String::check(pyObj) && (Shiboken::String::len(pyObj) == 1))
             return QChar(Shiboken::Converter<char >::toCpp(pyObj));
         else if (PyInt_Check(pyObj))
             return QChar(Shiboken::Converter<int >::toCpp(pyObj));
diff --git a/PySide/QtCore/qdate_conversions.h b/PySide/QtCore/qdate_conversions.h
index 586fc3ce4..0d97a057a 100644
--- a/PySide/QtCore/qdate_conversions.h
+++ b/PySide/QtCore/qdate_conversions.h
@@ -1,6 +1,10 @@
+#ifdef IS_PY3K
+#define PySideDateTime_IMPORT PyDateTime_IMPORT
+#else
 #define PySideDateTime_IMPORT \
-    PyDateTimeAPI = (PyDateTime_CAPI*) PyCObject_Import((char*)"datetime", \
-                                                        (char*)"datetime_CAPI")
+        PyDateTimeAPI = (PyDateTime_CAPI*) PyCObject_Import((char*)"datetime", \
+                                                            (char*)"datetime_CAPI")
+#endif
 
 namespace Shiboken {
 
diff --git a/PySide/QtCore/qdatetime_conversions.h b/PySide/QtCore/qdatetime_conversions.h
index 44cf92c3c..bcf9ad3fe 100644
--- a/PySide/QtCore/qdatetime_conversions.h
+++ b/PySide/QtCore/qdatetime_conversions.h
@@ -1,6 +1,10 @@
+#ifdef IS_PY3K
+#define PySideDateTime_IMPORT PyDateTime_IMPORT
+#else
 #define PySideDateTime_IMPORT \
         PyDateTimeAPI = (PyDateTime_CAPI*) PyCObject_Import((char*)"datetime", \
                                                             (char*)"datetime_CAPI")
+#endif
 namespace Shiboken {
 
 inline bool Converter<QDateTime>::checkType(PyObject* pyObj)
diff --git a/PySide/QtCore/qstring_conversions.h b/PySide/QtCore/qstring_conversions.h
index bfb06f206..221a0acbf 100644
--- a/PySide/QtCore/qstring_conversions.h
+++ b/PySide/QtCore/qstring_conversions.h
@@ -11,14 +11,12 @@ struct Converter<QString>
 {
     static bool checkType(PyObject* pyObj)
     {
-        return PyString_Check(pyObj) || PyUnicode_Check(pyObj);
+        return Shiboken::String::check(pyObj);
     }
 
     static bool isConvertible(PyObject* pyObj)
     {
-        return PyString_Check(pyObj)
-                || PyUnicode_Check(pyObj)
-                || pyObj == Py_None;
+        return Shiboken::String::convertible(pyObj);
     }
 
     static QString toCpp(PyObject* pyObj)
@@ -31,8 +29,8 @@ struct Converter<QString>
     #else
             return QString::fromUtf16(unicode, PyUnicode_GET_SIZE(pyObj));
     #endif
-        } else if (PyString_Check(pyObj)) {
-            return QString(Converter<const char * >::toCpp(pyObj));
+        } else if (Shiboken::String::check(pyObj)) {
+            return QString(Shiboken::String::toCString(pyObj));
         }
         return QString();
     }
diff --git a/PySide/QtCore/qvariant_conversions.h b/PySide/QtCore/qvariant_conversions.h
index 354955b76..8465c2847 100644
--- a/PySide/QtCore/qvariant_conversions.h
+++ b/PySide/QtCore/qvariant_conversions.h
@@ -82,6 +82,9 @@ struct Converter<QVariant>
         } else if (Shiboken::isShibokenEnum(pyObj)) {
             // QVariant(enum)
             return QVariant(Converter<int>::toCpp(pyObj));
+        } else if (PyNumber_Check(pyObj)) {
+            Shiboken::AutoDecRef pyValue(PyNumber_Long(pyObj));
+            return QVariant((int)PyLong_AsLong(pyValue.object()));
         } else if (Shiboken::Object::checkType(pyObj)) {
             // a class supported by QVariant?
                 int typeCode;
diff --git a/PySide/QtCore/qvariant_type_conversions.h b/PySide/QtCore/qvariant_type_conversions.h
index bacf6c070..0381e78d8 100644
--- a/PySide/QtCore/qvariant_type_conversions.h
+++ b/PySide/QtCore/qvariant_type_conversions.h
@@ -19,7 +19,7 @@ struct Converter<QVariant::Type>
         if (pyObj == Py_None)
             return QVariant::Invalid;
 
-        if (pyObj == reinterpret_cast<PyObject*>(&PyString_Type) || pyObj == reinterpret_cast<PyObject*>(&PyUnicode_Type))
+        if (Shiboken::String::checkType(reinterpret_cast<PyTypeObject*>(pyObj)))
             typeName = "QString";
         else if (pyObj == reinterpret_cast<PyObject*>(&PyFloat_Type))
             typeName = "double"; // float is a UserType in QVariant.
@@ -31,10 +31,8 @@ struct Converter<QVariant::Type>
             else
                 typeName = reinterpret_cast<PyTypeObject*>(pyObj)->tp_name;
         }
-        else if (PyString_Check(pyObj))
-            typeName = PyString_AS_STRING(pyObj);
-        else if (PyUnicode_Check(pyObj))
-            typeName = PyString_AsString(pyObj);
+        else if (Shiboken::String::check(pyObj))
+            typeName = Shiboken::String::toCString(pyObj);
         else if (PyDict_Check(pyObj) && checkAllStringKeys(pyObj))
             typeName = "QVariantMap";
         else if (PySequence_Check(pyObj))
diff --git a/PySide/QtCore/typesystem_core.xml b/PySide/QtCore/typesystem_core.xml
index 67969cdad..d47ad8a84 100644
--- a/PySide/QtCore/typesystem_core.xml
+++ b/PySide/QtCore/typesystem_core.xml
@@ -1438,7 +1438,7 @@
             if (QCoreApplication::instance()) {
                 PyObject *klass = PyObject_GetAttrString(%PYSELF, "__class__");
                 PyObject *cname = PyObject_GetAttrString(klass, "__name__");
-                result = QString(QCoreApplication::instance()->translate(PyString_AsString(cname), %1, %2, QCoreApplication::CodecForTr, %3));
+                result = QString(QCoreApplication::instance()->translate(Shiboken::String::toCString(cname), %1, %2, QCoreApplication::CodecForTr, %3));
 
                 Py_DECREF(klass);
                 Py_DECREF(cname);
@@ -1454,7 +1454,7 @@
         Shiboken::AutoDecRef klass(PyObject_GetAttrString(%PYSELF, "__class__"));
         Shiboken::AutoDecRef cname(PyObject_GetAttrString(klass, "__name__"));
         $DEFINE_SECOND_VAR
-        QString result = QCoreApplication::instance()->translate(PyString_AS_STRING(cname.object()), $SECOND_VAR, %2, QCoreApplication::UnicodeUTF8, %3);
+        QString result = QCoreApplication::instance()->translate(Shiboken::String::toCString(cname.object()), $SECOND_VAR, %2, QCoreApplication::UnicodeUTF8, %3);
         %PYARG_0 = %CONVERTTOPYTHON[QString](result);
     } else {
         Py_INCREF(%PYARG_1);
@@ -1485,7 +1485,7 @@
         <inject-code class="target" position="beginning">
             <insert-template name="translate_utf8">
                 <replace from="$DEFINE_SECOND_VAR" to="Shiboken::AutoDecRef str(PyUnicode_AsUTF8String(%1));" />
-                <replace from="$SECOND_VAR" to="PyString_AS_STRING(str.object())" />
+                <replace from="$SECOND_VAR" to="Shiboken::String::toCString(str.object())" />
             </insert-template>
         </inject-code>
     </add-function>
@@ -1696,7 +1696,7 @@
         <inject-code>
             Shiboken::AutoDecRef str(PyUnicode_AsASCIIString(%PYARG_1));
             if (!str.isNull()) {
-                QByteArray b(PyString_AS_STRING(str.object()), PyString_GET_SIZE(str.object()));
+                QByteArray b(PyBytes_AS_STRING(str.object()), PyBytes_GET_SIZE (str.object()));
                 b.prepend(*%CPPSELF);
                 %PYARG_0 = %CONVERTTOPYTHON[QByteArray](b);
             }
@@ -1706,15 +1706,15 @@
         <inject-code>
             Shiboken::AutoDecRef str(PyUnicode_AsASCIIString(%PYARG_1));
             if (!str.isNull()) {
-                QByteArray b(PyString_AS_STRING(str.object()), PyString_GET_SIZE(str.object()));
+                QByteArray b(PyBytes_AS_STRING(str.object()), PyBytes_GET_SIZE(str.object()));
                 b.append(*%CPPSELF);
                 %PYARG_0 = %CONVERTTOPYTHON[QByteArray](b);
             }
         </inject-code>
     </add-function>
-    <add-function signature="operator+(PyString, QByteArray)">
+    <add-function signature="operator+(PyBytes, QByteArray)">
         <inject-code>
-        QByteArray ba = QByteArray(PyString_AS_STRING(%PYARG_1), PyString_GET_SIZE(%PYARG_1)) + *%CPPSELF;
+        QByteArray ba = QByteArray(PyBytes_AS_STRING(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1)) + *%CPPSELF;
         %PYARG_0 = %CONVERTTOPYTHON[QByteArray](ba);
         </inject-code>
     </add-function>
@@ -1723,11 +1723,16 @@
     <add-function signature="__repr__" return-type="PyObject*">
         <inject-code class="target" position="beginning">
             QByteArray b(((PyObject*)%PYSELF)->ob_type->tp_name);
-            b += '(';
-            Shiboken::AutoDecRef contents(PyObject_Repr(PyString_FromStringAndSize(%CPPSELF.constData(), %CPPSELF.size())));
-            b += PyString_AS_STRING(contents.object());
-            b += ")";
-            %PYARG_0 = PyString_FromStringAndSize(b.constData(), b.size());
+            PyObject* aux = Shiboken::String::fromStringAndSize(%CPPSELF.constData(), %CPPSELF.size());
+            if (PyUnicode_CheckExact(aux)) {
+                PyObject* tmp = PyUnicode_AsASCIIString(aux);
+                Py_DECREF(aux);
+                aux = tmp;
+            }
+            b += "('";
+            b += QByteArray(PyBytes_AS_STRING(aux), PyBytes_GET_SIZE(aux));
+            b += "')";
+            %PYARG_0 = Shiboken::String::fromStringAndSize(b.constData(), b.size());
         </inject-code>
     </add-function>
 
@@ -1735,15 +1740,21 @@
         <inject-code class="target" position="beginning">
             <insert-template name="reduce_code">
                 <replace from="%REDUCE_FORMAT" to="N" />
-                <replace from="%REDUCE_ARGS" to="PyString_FromStringAndSize(%CPPSELF.constData(), %CPPSELF.size())" />
+                <replace from="%REDUCE_ARGS" to="PyBytes_FromStringAndSize(%CPPSELF.constData(), %CPPSELF.size())" />
             </insert-template>
         </inject-code>
     </add-function>
     <modify-function signature="QByteArray(const char *)">
         <!-- Keep \x00 bytes passed in python strings -->
         <inject-code class="target" position="beginning">
-            int size = PyString_GET_SIZE(%PYARG_1);
-            %0 = new QByteArray(%1, size);
+            if (PyBytes_Check(%PYARG_1)) {
+                %0 = new QByteArray(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1));
+            } if (PyUnicode_CheckExact(%PYARG_1)) {
+                Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1));
+                %0 = new QByteArray(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object()));
+            } else if (Shiboken::String::check(%PYARG_1)) {
+                %0 = new QByteArray(Shiboken::String::toCString(%PYARG_1), Shiboken::String::len(%PYARG_1));
+            }
         </inject-code>
     </modify-function>
     <!-- buffer protocol -->
@@ -1757,7 +1768,7 @@
 
    <modify-function signature="data()">
        <inject-code class="target" position="beginning">
-           %PYARG_0 = PyString_FromStringAndSize(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.size());
+           %PYARG_0 = PyBytes_FromStringAndSize(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.size());
        </inject-code>
    </modify-function>
 
@@ -1872,11 +1883,14 @@
     <!-- QByteArray(const char *) do the job of this constructor -->
     <modify-function signature="QByteArray(const char*,int)" remove="all"/>
     <modify-function signature="fromRawData(const char*,int)">
+        <modify-argument index="1">
+            <replace-type modified-type="PyBytes"/>
+        </modify-argument>
         <modify-argument index="2">
             <remove-argument />
         </modify-argument>
         <inject-code class="target">
-        %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(PyString_AS_STRING(%PYARG_1), PyString_GET_SIZE(%PYARG_1));
+        %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1));
         %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
         </inject-code>
     </modify-function>
@@ -1898,7 +1912,7 @@
     </modify-function>
     <add-function signature="__str__" return-type="PyObject*">
         <inject-code class="target" position="beginning">
-            %PYARG_0 = PyString_FromStringAndSize(%CPPSELF.constData(), %CPPSELF.size());
+            %PYARG_0 = Shiboken::String::fromStringAndSize(%CPPSELF.constData(), %CPPSELF.size());
         </inject-code>
     </add-function>
     <add-function signature="__len__">
@@ -1915,7 +1929,7 @@
                     char res[2];
                     res[0] = %CPPSELF.at(_i);
                     res[1] = 0;
-                    return PyString_FromStringAndSize(res, 1);
+                    return PyBytes_FromStringAndSize(res, 1);
                 }
         </inject-code>
     </add-function>
@@ -2012,7 +2026,7 @@
     <modify-function signature="write(const char *,qint64)" remove="all"/>
     <modify-function signature="write(const char *)">
         <inject-code>
-        %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, PyString_GET_SIZE(%PYARG_1));
+        %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, Shiboken::String::len(%PYARG_1));
         %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
         </inject-code>
     </modify-function>
@@ -2039,11 +2053,12 @@
             <replace-type modified-type="PyObject"/>
             <conversion-rule class="native">
                 %RETURN_TYPE %out;
-                if (!PyString_Check(%PYARG_0)) {
-                    %out = -1;
-                } else {
-                    %out = PyString_GET_SIZE((PyObject*)%PYARG_0);
-                    memcpy(%1, PyString_AS_STRING((PyObject*)%PYARG_0), %out);
+                if (PyBytes_Check(%PYARG_0)) {
+                    %out = PyBytes_GET_SIZE((PyObject*)%PYARG_0);
+                    memcpy(%1, PyBytes_AS_STRING((PyObject*)%PYARG_0), %out);
+                } else if (Shiboken::String::check(%PYARG_0)) {
+                    %out = Shiboken::String::len((PyObject*)%PYARG_0);
+                    memcpy(%1, Shiboken::String::toCString((PyObject*)%PYARG_0), %out);
                 }
             </conversion-rule>
         </modify-argument>
@@ -2062,11 +2077,11 @@
             <replace-type modified-type="PyObject"/>
             <conversion-rule class="native">
                 %RETURN_TYPE %out;
-                if (!PyString_Check(%PYARG_0)) {
+                if (!PyBytes_Check(%PYARG_0)) {
                     %out = -1;
                 } else {
-                    %out = PyString_GET_SIZE((PyObject*)%PYARG_0);
-                    memcpy(%1, PyString_AS_STRING((PyObject*)%PYARG_0), %out);
+                    %out = PyBytes_GET_SIZE((PyObject*)%PYARG_0);
+                    memcpy(%1, PyBytes_AS_STRING((PyObject*)%PYARG_0), %out);
                 }
             </conversion-rule>
         </modify-argument>
@@ -2078,8 +2093,8 @@
         <modify-argument index="2">
             <remove-argument />
         </modify-argument>
-        <inject-code>
-            %CPPSELF.%FUNCTION_NAME(PyString_AS_STRING(%PYARG_1), PyString_GET_SIZE(%PYARG_1));
+        <inject-code>            
+            %CPPSELF.%FUNCTION_NAME(Shiboken::String::toCString(%PYARG_1), Shiboken::String::len(%PYARG_1));
         </inject-code>
     </modify-function>
   </object-type>
@@ -2263,7 +2278,7 @@
 
         if (PyObject_TypeCheck(%2, &amp;PySideSignalInstanceType)) {
             PySideSignalInstance* signalInstance = reinterpret_cast&lt;PySideSignalInstance*&gt;(%2);
-            Shiboken::AutoDecRef signalSignature(PyString_FromFormat("2%s", PySide::Signal::getSignature(signalInstance)));
+            Shiboken::AutoDecRef signalSignature(Shiboken::String::fromFormat("2%s", PySide::Signal::getSignature(signalInstance)));
             Shiboken::AutoDecRef result(
                 PyObject_CallMethod(pyTimer,
                                     const_cast&lt;char*>("connect"),
@@ -2350,7 +2365,7 @@
             QByteArray ba;
             ba.resize(%2);
             %CPPSELF.%FUNCTION_NAME(ba.data(), ba.size());
-            %PYARG_0 = PyString_FromStringAndSize(ba.constData(), ba.size());
+            %PYARG_0 = PyBytes_FromStringAndSize(ba.constData(), ba.size());
         </inject-code>
         <modify-argument index="1">
             <remove-argument />
@@ -2359,11 +2374,11 @@
             <replace-type modified-type="PyObject"/>
             <conversion-rule class="native">
                 %RETURN_TYPE %out;
-                if (!PyString_Check(%PYARG_0)) {
+                if (!Shiboken::String::check(%PYARG_0)) {
                     %out = -1;
                 } else {
-                    %out = PyString_GET_SIZE((PyObject*)%PYARG_0);
-                    memcpy(%1, PyString_AS_STRING((PyObject*)%PYARG_0), %out);
+                    %out = PyBytes_GET_SIZE((PyObject*)%PYARG_0);
+                    memcpy(%1, PyBytes_AS_STRING((PyObject*)%PYARG_0), %out);
                 }
             </conversion-rule>
         </modify-argument>
@@ -2373,7 +2388,7 @@
             QByteArray ba;
             ba.resize(%2);
             %CPPSELF.%FUNCTION_NAME(ba.data(), ba.size());
-            %PYARG_0 = PyString_FromStringAndSize(ba.constData(), ba.size());
+            %PYARG_0 = PyBytes_FromStringAndSize(ba.constData(), ba.size());
         </inject-code>
         <modify-argument index="1">
             <remove-argument />
@@ -2382,11 +2397,11 @@
             <replace-type modified-type="PyObject"/>
             <conversion-rule class="native">
                 %RETURN_TYPE %out;
-                if (!PyString_Check(%PYARG_0)) {
+                if (!Shiboken::String::check(%PYARG_0)) {
                     %out = -1;
                 } else {
-                    %out = PyString_GET_SIZE((PyObject*)%PYARG_0);
-                    memcpy(%1, PyString_AS_STRING((PyObject*)%PYARG_0), %out);
+                    %out = PyBytes_GET_SIZE((PyObject*)%PYARG_0);
+                    memcpy(%1, PyBytes_AS_STRING((PyObject*)%PYARG_0), %out);
                 }
             </conversion-rule>
         </modify-argument>
@@ -2679,7 +2694,7 @@
                 Py_INCREF(Py_None);
                 %PYARG_0 = Py_None;
             } else {
-                %PYARG_0 = PyString_FromStringAndSize(data.data(), result);
+                %PYARG_0 = PyBytes_FromStringAndSize(data.data(), result);
             }
         </inject-code>
     </modify-function>
@@ -2688,7 +2703,7 @@
             <remove-argument />
         </modify-argument>
         <inject-code class="target">
-            int r = %CPPSELF.%FUNCTION_NAME(%1, PyString_GET_SIZE(%PYARG_1));
+            int r = %CPPSELF.%FUNCTION_NAME(%1, Shiboken::String::len(%PYARG_1));
             %PYARG_0 = %CONVERTTOPYTHON[int](r);
         </inject-code>
     </modify-function>
@@ -3274,15 +3289,15 @@ s1.addTransition(button.clicked, s1h)&lt;/code>
 
   <!-- From Qt4.6 ^^^ -->
 
-  <add-function signature="SIGNAL(const char*)" return-type="PyString*">
+  <add-function signature="SIGNAL(const char*)" return-type="str">
     <inject-code class="target" position="beginning">
-      %PYARG_0 = PyString_FromFormat("2%s", QMetaObject::normalizedSignature(%1).constData());
+      %PYARG_0 = Shiboken::String::fromFormat("2%s", QMetaObject::normalizedSignature(%1).constData());
     </inject-code>
   </add-function>
 
-  <add-function signature="SLOT(const char*)" return-type="PyString*">
+  <add-function signature="SLOT(const char*)" return-type="str">
     <inject-code class="target" position="beginning">
-      %PYARG_0 = PyString_FromFormat("1%s", QMetaObject::normalizedSignature(%1).constData());
+      %PYARG_0 = Shiboken::String::fromFormat("1%s", QMetaObject::normalizedSignature(%1).constData());
     </inject-code>
   </add-function>
 
@@ -3325,16 +3340,20 @@ s1.addTransition(button.clicked, s1h)&lt;/code>
                             const unsigned char *,
                             const unsigned char *);
   </inject-code>
-  <add-function signature="qRegisterResourceData(int, const char *, const char *, const char *)" return-type="bool">
+  <add-function signature="qRegisterResourceData(int, PyBytes, PyBytes, PyBytes)" return-type="bool">
     <inject-code class="target" position="beginning">
-    %RETURN_TYPE %0 = %FUNCTION_NAME(%1, (uchar*)%2, (uchar*)%3, (uchar*)%4);
-    %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
+        %RETURN_TYPE %0 = %FUNCTION_NAME(%1, (uchar*)PyBytes_AS_STRING(%PYARG_2),
+                                             (uchar*)PyBytes_AS_STRING(%PYARG_3),
+                                             (uchar*)PyBytes_AS_STRING(%PYARG_4));
+        %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
     </inject-code>
   </add-function>
-  <add-function signature="qUnregisterResourceData(int, const char *, const char *, const char *)" return-type="bool">
+  <add-function signature="qUnregisterResourceData(int, PyBytes, PyBytes, PyBytes)" return-type="bool">
     <inject-code class="target" position="beginning">
-    %RETURN_TYPE %0 = %FUNCTION_NAME(%1, (uchar*)%2, (uchar*)%3, (uchar*)%4);
-    %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
+        %RETURN_TYPE %0 = %FUNCTION_NAME(%1, (uchar*)PyBytes_AS_STRING(%PYARG_2),
+                                             (uchar*)PyBytes_AS_STRING(%PYARG_3),
+                                             (uchar*)PyBytes_AS_STRING(%PYARG_4));
+        %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);
     </inject-code>
   </add-function>
 
-- 
cgit v1.2.3