GIT_REPOSITORIES/LPP/PythonQt Commit - r206:316b4928f53f

Start Python 3.x Port...

Orochimarufan -

r206:316b4928f53f

parent child

Context file:

r206:316b4928f53f

Collapse all files

CMakeLists.txt +5 -6

             #-----------------------------------------------------------------------------
             # Generator
-            #if(PythonQt_Qt5)
+            if(PythonQt_Qt5)
-            #	add_subdirectory(generator_50 EXCLUDE_FROM_ALL)
+            	add_subdirectory(generator_50 EXCLUDE_FROM_ALL)
-            #	add_custom_target(generator)
+            	add_custom_target(generator)
-            #	add_dependencies(generator pythonqt_generator)
+            	add_dependencies(generator pythonqt_generator)
-            #endif()
+            endif()
             # TODO
             option(PythonQt_Python3 "Use Python 3.x (3.3+)" OFF)
             if(PythonQt_Python3)
             	set(PythonQt_PythonMin 3.3)
-            	add_definitions(PYTHON3K)
             else(PythonQt_Python3)
             	set(PythonQt_PythonMin 2.6)
             endif()

generated_cpp_50/com_trolltech_qt_core_builtin/com_trolltech_qt_core_builtin0.h +4 0

               PyObject* data(QByteArray* b) {
                 if (b->data()) {
+            #ifdef PY3K
+                  return PyUnicode_FromStringAndSize(b->data(), b->size());
+            #else
                   return PyString_FromStringAndSize(b->data(), b->size());
+            #endif
                 } else {
                   Py_INCREF(Py_None);
                   return Py_None;

generator_50/typesystem_core.xml 0 -8

                     </conversion-rule>
                   </modify-argument>
                 </modify-function>
-                <modify-function signature="createNativeFile(QFile&amp;)">
-                  <modify-argument index="1">
-                    <replace-type modified-type="QFile*"/>
-                    <conversion-rule class="native">
-                    QFile &amp; %out% = *qscriptvalue_cast&lt;QFile*&gt;(%in%);
-                    </conversion-rule>
-                  </modify-argument>
-                </modify-function>
               </object-type>
               <object-type name="QMimeData">
                 <extra-includes>

generator_50/typesystem_gui.xml +11 -8

                   </modify-argument>
                 </modify-function>
-            <inject-code class="pywrap-h">
-            QImage* new_QImage( const uchar * data, int width, int height, QImage::Format format )
-              QImage* image = new QImage(width, height, format);
-              memcpy(image-&gt;bits(), data, image-&gt;byteCount());
-              return image;
-            </inject-code>
               </value-type>
               <value-type name="QColormap" delete-in-main-thread="yes">
                     <access modifier="private"/>
                 </modify-function>
+                <modify-function signature="addAction(QString,const QObject*,const char*,QKeySequence)">
+                    <remove/>
+                </modify-function>
+                <modify-function signature="addAction(QIcon,QString,const QObject*,const char*,QKeySequence)">
+                    <remove/>
+                </modify-function>
               <inject-code class="pywrap-h">
               QAction* addAction (QMenu* menu, const QString &amp; text, PyObject* callable, const QKeySequence &amp; shortcut = 0) {
                 QAction* a = menu-&gt;addAction(text);
                         <reference-count action="ignore"/>
                     </modify-argument>
                 </modify-function>
               <inject-code class="pywrap-h">
               QAction* addAction (QMenuBar* menu, const QString &amp; text, PyObject* callable)
               {
                         <reference-count action="ignore"/>
                     </modify-argument>
                 </modify-function>
               <inject-code class="pywrap-h">
               QAction* addAction (QToolBar* menu, const QString &amp; text, PyObject* callable)
               {
               <suppress-warning text="WARNING(JavaGenerator) :: either add or remove specified for reference count variable '__rcMenus' in 'com.trolltech.qt.gui.QMenuBar' but not both"/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QPixmap::pixmapData', unmatched return type 'QPixmapData*'"/>
+              <suppress-warning text="WARNING(MetaJavaBuilder) :: object type 'QAccessible' extended by interface type 'QAbstractAccessibleFactory'. The resulting API will be less expressive than the original."/>
               <suppress-warning text="WARNING(MetaJavaBuilder) :: Rejected enum has no alternative...: QPalette::NColorRoles"/>

generator_50/typesystem_opengl.xml 0 -7

               <enum-type name="QGLContext::BindOption" flags="QGLContext::BindOptions"/>
               <enum-type name="QGLShader::ShaderTypeBit" flags="QGLShader::ShaderType"/>
-              <enum-type name="QGLBuffer::Access"/>
-              <enum-type name="QGLBuffer::Type"/>
-              <enum-type name="QGLBuffer::UsagePattern"/>
-              <enum-type name="QGLFunctions::OpenGLFeature"/>
-              <enum-type name="QGLFormat::OpenGLContextProfile"/>
               <namespace-type name="QGL">
                  <include file-name="qgl.h" location="global"/>
               </value-type>
               <value-type name="QGLFramebufferObjectFormat"/>
-              <object-type name="QGLFunctions"/>
-              <object-type name="QGLBuffer"/>
               <object-type name="QGLShader"/>
               <object-type name="QGLShaderProgram">
                 <!-- Should be disambiguated later by fixing the native pointer API -->

src/CMakeLists.txt +2 -2

             include_directories(${CMAKE_CURRENT_SOURCE_DIR})
-            add_definitions(-DQT_NO_KEYWORDS) # recent python versions use them :(
+            #add_definitions(-DQT_NO_KEYWORDS) # recent python versions use them :(
-            add_library(PythonQt SHARED ${SOURCES} ${GEN_MOC} ${GEN_QRC})
+            add_library(PythonQt SHARED ${SOURCES} ${GEN_MOC} ${GEN_QRC} ${HEADERS})
             if(PythonQt_Qt5)
             	qt_use_modules(PythonQt Core Gui Widgets)
             else()

src/PythonQt.cpp +167 -14

               _p->_PythonQtObjectPtr_metaId = qRegisterMetaType<PythonQtObjectPtr>("PythonQtObjectPtr");
               if ((flags & PythonAlreadyInitialized) == 0) {
+            #ifdef PY3K
+                Py_SetProgramName(const_cast<wchar_t*>(L"PythonQt"));
+            #else
                 Py_SetProgramName(const_cast<char*>("PythonQt"));
+            #endif
                 if (flags & IgnoreSiteModule) {
                   // this prevents the automatic importing of Python site files
                   Py_NoSiteFlag = 1;
               static PyObject* dummyTuple = NULL;
               if (dummyTuple==NULL) {
                 dummyTuple = PyTuple_New(1);
+            #ifdef PY3K
+                PyTuple_SET_ITEM(dummyTuple, 0, PyUnicode_FromString("dummy"));
+            #else
                 PyTuple_SET_ITEM(dummyTuple, 0 , PyString_FromString("dummy"));
+            #endif
               }
               return dummyTuple;
             }
             PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* parentModule) {
               PythonQtClassWrapper* result;
+            #ifdef PY3K
+              PyObject* className = PyUnicode_FromString(info->className());
+            #else
               PyObject* className = PyString_FromString(info->className());
+            #endif
               PyObject* baseClasses = PyTuple_New(1);
               PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PythonQtInstanceWrapper_Type);
             PyObject* PythonQtPrivate::createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject) {
               PyObject* result;
+            #ifdef PY3K
+              PyObject* className = PyUnicode_FromString(enumName);
+            #else
               PyObject* className = PyString_FromString(enumName);
+            #endif
               PyObject* baseClasses = PyTuple_New(1);
+            #ifdef PY3K
+              PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PyLong_Type);
+            #else
               PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PyInt_Type);
+            #endif
               PyObject* module = PyObject_GetAttrString(parentObject, "__module__");
               PyObject* typeDict = PyDict_New();
                   globals = dict;
                 } else {
                   dict = PyObject_GetAttrString(object, "__dict__");
-                  globals = PyObject_GetAttrString(PyImport_ImportModule(PyString_AS_STRING(PyObject_GetAttrString(object, "__module__"))),"__dict__");
+                  globals = PyObject_GetAttrString(PyImport_ImportModule(
+            #ifdef PY3K
+                                                     PyUnicode_AsUTF8(
+            #else
+                                                     PyString_AS_STRING(
+            #endif
+                                                       PyObject_GetAttrString(object, "__module__"))),"__dict__");
                 }
                 PyObject* r = NULL;
                 if (dict) {
+            #ifdef PY3K
+                  r = PyEval_EvalCode(pycode, globals, dict);
+            #else
                   r = PyEval_EvalCode((PyCodeObject*)pycode, globals , dict);
+            #endif
                 }
                 if (r) {
                   result = PythonQtConv::PyObjToQVariant(r);
                   } else {
                     PyObject* doc = PyObject_GetAttrString(object, "__doc__");
                     if (doc) {
+            #ifdef PY3K
+                      results << PyUnicode_AsUTF8(doc);
+            #else
                       results << PyString_AsString(doc);
+            #endif
                       Py_DECREF(doc);
                     }
                   }
                       value = PyObject_GetAttr(object, key);
                     }
                     if (!value) continue;
+            #ifdef PY3K
+                    keystr = PyUnicode_AsUTF8(key);
+            #else
                     keystr = PyString_AsString(key);
+            #endif
                     static const QString underscoreStr("__tmp");
                     if (!keystr.startsWith(underscoreStr)) {
                       switch (type) {
                         results << keystr;
                         break;
                       case Class:
+            #ifdef PY3K
+                        if(PyType_Check(value)) {
+            #else
                         if (value->ob_type == &PyClass_Type || value->ob_type == &PyType_Type) {
+            #endif
                           results << keystr;
                         }
                         break;
                       case Variable:
-                        if (value->ob_type != &PyClass_Type
+                        if (
-                          && value->ob_type != &PyCFunction_Type
+            #ifndef PY3K
-                          && value->ob_type != &PyFunction_Type
+                           value->ob_type != &PyClass_Type &&
-                          && value->ob_type != &PyMethod_Type
+            #endif
-                          && value->ob_type != &PyModule_Type
+                           value->ob_type != &PyCFunction_Type &&
-                          && value->ob_type != &PyType_Type
+                           value->ob_type != &PyFunction_Type &&
-                          && value->ob_type != &PythonQtSlotFunction_Type
+                           value->ob_type != &PyMethod_Type &&
+                           value->ob_type != &PyModule_Type &&
+                           value->ob_type != &PyType_Type &&
+                           value->ob_type != &PythonQtSlotFunction_Type
                           ) {
                           results << keystr;
                         }
             //    return exitcode;
               PyErr_Fetch(&exception, &value, &tb);
+            #ifdef PY3K
+              std::cout << std::endl;
+            #else
               if (Py_FlushLine())
                 PyErr_Clear();
+            #endif
               fflush(stdout);
               if (value == NULL || value == Py_None)
                 goto done;
                 /* If we failed to dig out the 'code' attribute,
                    just let the else clause below print the error. */
               }
+            #ifdef PY3K
+              if (PyLong_Check(value))
+                exitcode = (int)PyLong_AsLong(value);
+            #else
               if (PyInt_Check(value))
                 exitcode = (int)PyInt_AsLong(value);
+            #endif
               else {
                 PyObject *sys_stderr = PySys_GetObject(const_cast<char*>("stderr"));
                 if (sys_stderr != NULL && sys_stderr != Py_None) {
               {NULL, NULL, 0, NULL}
             };
+            #ifdef PY3K
+            static PyModuleDef PythonQtModule = {
+              PyModuleDef_HEAD_INIT,
+              "",
+              NULL,
+              -1,
+              PythonQtMethods,
+              NULL,
+              NULL,
+              NULL,
+              NULL
+            };
+            #endif
             void PythonQt::initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName)
             {
               QByteArray name = "PythonQt";
               if (!pythonQtModuleName.isEmpty()) {
                 name = pythonQtModuleName;
               }
+            #ifdef PY3K
+              PythonQtModule.m_name = name.constData();
+              _p->_pythonQtModule = PyModule_Create(&PythonQtModule);
+            #else
               _p->_pythonQtModule = Py_InitModule(name.constData(), PythonQtMethods);
+            #endif
               _p->_pythonQtModuleName = name;
               if (redirectStdOut) {
               PyObject *module_names = PyTuple_New(old_size+1);
               for(Py_ssize_t i = 0; i < old_size; i++)
                   PyTuple_SetItem(module_names, i, PyTuple_GetItem(old_module_names, i));
+            #ifdef PY3K
+              PyTuple_SetItem(module_names, old_size, PyUnicode_FromString(name.constData()));
+            #else
               PyTuple_SetItem(module_names, old_size, PyString_FromString(name.constData()));
+            #endif
               PyModule_AddObject(sys.object(),"builtin_module_names",module_names);
               Py_DecRef(old_module_names);
             }
               QString type;
+            #ifdef PY3K
+              if (PyType_Check(methodObject)) {
+            #else
               if (methodObject->ob_type == &PyClass_Type || methodObject->ob_type == &PyType_Type) {
+            #endif
                 // the methodObject is not a method, but the name of a type/class. This means
                 // a constructor is called. Return the context.
                 type = context;
                 } else {
                   PyObject* classNameObject = PyObject_GetAttrString(variableObject, "__name__");
                   if (classNameObject) {
+            #ifdef PY3K
+                    Q_ASSERT(PyUnicode_Check(classNameObject));
+                    className = PyUnicode_AsUTF8(classNameObject);
+            #else
                     Q_ASSERT(PyString_Check(classNameObject));
                     className = PyString_AsString(classNameObject);
+            #endif
                     Py_DECREF(classNameObject);
                   }
                 }
                           PythonQtClassInfo* typeInfo = _p->_knownClassInfos.value(type.toLatin1().constData());
                           if (typeInfo && typeInfo->pythonQtClassWrapper()) {
                             PyObject* s = PyObject_GetAttrString(typeInfo->pythonQtClassWrapper(), "__module__");
+            #ifdef PY3K
+                            Q_ASSERT(PyUnicode_Check(s));
+                            type = QString(PyUnicode_AsUTF8(s));
+            #else
                             Q_ASSERT(PyString_Check(s));
                             type = QString(PyString_AsString(s)) + "." + type;
+            #endif
                             Py_DECREF(s);
                             s = PyObject_GetAttrString(typeInfo->pythonQtClassWrapper(), "__name__");
+            #ifdef PY3K
+                            Q_ASSERT(PyUnicode_Check(s));
+            #else
                             Q_ASSERT(PyString_Check(s));
+            #endif
                             Py_DECREF(s);
                           }
                         }
                 Q_EMIT pythonHelpRequest(QByteArray(info->className()));
                 return Py_BuildValue("");
               } else {
+            #ifdef PY3K
+                return PyUnicode_FromString(info->help().toLatin1().data());
+            #else
                 return PyString_FromString(info->help().toLatin1().data());
+            #endif
               }
             }
               if (PyObject_HasAttrString(object, "__get__") &&
                   !PyObject_HasAttrString(object, "__set__") &&
                   !PyMethod_Check(object) &&
-                  !PyFunction_Check(object) &&
+                  !PyFunction_Check(object)
-                  !PyClass_Check(object)) {
+            #ifndef PY3K
+                  && !PyClass_Check(object)
+            #endif
+                  ) {
                 return true;
               }
               return false;
                 bool decrefMethod = false;
+            #ifdef PY3K
+                if (PyType_Check(object)) {
+            #else
                 if (object->ob_type == &PyClass_Type || object->ob_type == &PyType_Type) {
+            #endif
                   method = (PyMethodObject*)PyObject_GetAttrString(object, "__init__");
                   decrefMethod = true;
                 } else if (object->ob_type == &PyFunction_Type) {
                     QString docstr;
                     PyObject* doc = PyObject_GetAttrString(object, "__doc__");
                     if (doc) {
+            #ifdef PY3K
+                      docstr = PyUnicode_AsUTF8(doc);
+            #else
                       docstr = PyString_AsString(doc);
+            #endif
                       Py_DECREF(doc);
                     }
                     PyObject* s = PyObject_GetAttrString(object, "__name__");
                     if (s) {
+            #ifdef PY3K
+                      Q_ASSERT(PyUnicode_Check(s));
+                      signature = PyUnicode_AsUTF8(s);
+            #else
                       Q_ASSERT(PyString_Check(s));
                       signature = PyString_AsString(s);
+            #endif
                       if (docstr.startsWith(signature + "(")) {
                         signature = docstr;
                       } else {
                   QString funcName;
                   PyObject* s = PyObject_GetAttrString((PyObject*)func, "__name__");
                   if (s) {
+            #ifdef PY3K
+                    Q_ASSERT(PyUnicode_Check(s));
+                    funcName = PyUnicode_AsUTF8(s);
+            #else
                     Q_ASSERT(PyString_Check(s));
                     funcName = PyString_AsString(s);
+            #endif
                     Py_DECREF(s);
                   }
                   if (method && funcName == "__init__") {
                     PyObject* s = PyObject_GetAttrString(object, "__name__");
                     if (s) {
+            #ifdef PY3K
+                      Q_ASSERT(PyUnicode_Check(s));
+                      funcName = PyUnicode_AsUTF8(s);
+            #else
                       Q_ASSERT(PyString_Check(s));
                       funcName = PyString_AsString(s);
+            #endif
                       Py_DECREF(s);
                     }
                   }
                     Q_ASSERT(PyTuple_Check(code->co_varnames));
                     for (int i=0; i<nargs; i++) {
                       PyObject* name = PyTuple_GetItem(code->co_varnames, i);
+            #ifdef PY3K
+                      Q_ASSERT(PyUnicode_Check(name));
+                      arguments << PyUnicode_AsUTF8(name);
+            #else
                       Q_ASSERT(PyString_Check(name));
                       arguments << PyString_AsString(name);
+            #endif
                     }
                     if (code->co_flags & CO_VARARGS) {
                       PyObject* s = PyTuple_GetItem(code->co_varnames, nargs);
+            #ifdef PY3K
+                      Q_ASSERT(PyUnicode_Check(s));
+                      varargs = PyUnicode_AsUTF8(s);
+            #else
                       Q_ASSERT(PyString_Check(s));
                       varargs = PyString_AsString(s);
+            #endif
                       nargs += 1;
                     }
                     if (code->co_flags & CO_VARKEYWORDS) {
                       PyObject* s = PyTuple_GetItem(code->co_varnames, nargs);
+            #ifdef PY3K
+                      Q_ASSERT(PyUnicode_Check(s));
+                      varkeywords = PyUnicode_AsUTF8(s);
+            #else
                       Q_ASSERT(PyString_Check(s));
                       varkeywords = PyString_AsString(s);
+            #endif
                     }
                   }
                     for (Py_ssize_t i=0; i<PyTuple_Size(defaultsTuple); i++) {
                       PyObject* d = PyTuple_GetItem(defaultsTuple, i);
                       PyObject* s = PyObject_Repr(d);
+            #ifdef PY3K
+                      Q_ASSERT(PyUnicode_Check(s));
+                      defaults << PyUnicode_AsUTF8(s);
+            #else
                       Q_ASSERT(PyString_Check(s));
                       defaults << PyString_AsString(s);
+            #endif
                       Py_DECREF(s);
                     }
                   }
             PyObject* PythonQtPrivate::wrapMemoryAsBuffer( const void* data, Py_ssize_t size )
             {
-              // P3K port needed later on!
+              // P3K port needed later on! -- not anymore :D
-              return PyBuffer_FromMemory((void*)data, size);
+            #ifdef PY3K
+              return PyMemoryView_FromMemory((char*)data, size, PyBUF_READ);
+            #else
+              return PyBuffer_FromMemory((char*)data, size);
+            #endif
             }
             PyObject* PythonQtPrivate::wrapMemoryAsBuffer( void* data, Py_ssize_t size )
             {
-              // P3K port needed later on!
+              // P3K port needed later on! -- not anymore :D
-              return PyBuffer_FromReadWriteMemory(data, size);
+            #ifdef PY3K
+              return PyMemoryView_FromMemory((char*)data, size, PyBUF_READ | PyBUF_WRITE);
+            #else
+              return PyBuffer_FromReadWriteMemory((char*)data, size);
+            #endif
             }

src/PythonQtClassWrapper.cpp +27 -4

                   wrap->_base.as_number.nb_multiply = (binaryfunc)PythonQtInstanceWrapper_mul;
                 }
                 if (typeSlots & PythonQt::Type_Divide) {
+            #ifndef PY3K
                   wrap->_base.as_number.nb_divide = (binaryfunc)PythonQtInstanceWrapper_div;
+            #endif
                   wrap->_base.as_number.nb_true_divide = (binaryfunc)PythonQtInstanceWrapper_div;
                 }
                 if (typeSlots & PythonQt::Type_And) {
                   wrap->_base.as_number.nb_multiply = (binaryfunc)PythonQtInstanceWrapper_imul;
                 }
                 if (typeSlots & PythonQt::Type_InplaceDivide) {
+            #ifndef PY3K
                   wrap->_base.as_number.nb_inplace_divide = (binaryfunc)PythonQtInstanceWrapper_idiv;
+            #endif
                   wrap->_base.as_number.nb_inplace_true_divide = (binaryfunc)PythonQtInstanceWrapper_idiv;
                 }
                 if (typeSlots & PythonQt::Type_InplaceAnd) {
                   wrap->_base.as_number.nb_invert = (unaryfunc)PythonQtInstanceWrapper_invert;
                 }
                 if (typeSlots & PythonQt::Type_NonZero) {
+            #ifdef PY3K
+                  wrap->_base.as_number.nb_bool = (inquiry)PythonQtInstanceWrapper_nonzero;
+            #else
                   wrap->_base.as_number.nb_nonzero = (inquiry)PythonQtInstanceWrapper_nonzero;
+            #endif
                 }
               }
             }
                 //  ...
                 // class MyWidget(MyWidgetBase):
                 //  ...
-                while( superType && superType->ob_type != &PythonQtClassWrapper_Type )
+                while( superType && Py_TYPE(superType) != &PythonQtClassWrapper_Type )
                     superType = superType->tp_base;
-                if (!superType || (superType->ob_type != &PythonQtClassWrapper_Type)) {
+                if (!superType || (Py_TYPE(superType) != &PythonQtClassWrapper_Type)) {
                   PyErr_Format(PyExc_TypeError, "type %s is not derived from PythonQtClassWrapper", ((PyTypeObject*)self)->tp_name);
                   return -1;
                 }
             static PyObject *PythonQtClassWrapper_classname(PythonQtClassWrapper* type)
             {
+            #ifdef PY3K
+              return PyUnicode_FromString((QString("Class_") + type->classInfo()->className()).toLatin1().data());
+            #else
               return PyString_FromString((QString("Class_") + type->classInfo()->className()).toLatin1().data());
+            #endif
             }
             static PyObject *PythonQtClassWrapper_help(PythonQtClassWrapper* type)
               const char *attributeName;
               PythonQtClassWrapper *wrapper = (PythonQtClassWrapper *)obj;
+            #ifdef PY3K
+              if ((attributeName = PyUnicode_AsUTF8(name)) == NULL) {
+            #else
               if ((attributeName = PyString_AsString(name)) == NULL) {
+            #endif
                 return NULL;
               }
               if (obj == (PyObject*)&PythonQtInstanceWrapper_Type) {
                   }
                 }
                 if (wrapper->classInfo()->constructors()) {
+            #ifdef PY3K
+                  PyObject* initName = PyUnicode_FromString("__init__");
+            #else
                   PyObject* initName = PyString_FromString("__init__");
+            #endif
                   PyObject* func = PyType_Type.tp_getattro(obj, initName);
                   Py_DECREF(initName);
                   PyDict_SetItemString(dict, "__init__", func);
               }
               // look in Python to support derived Python classes
+            #ifdef PY3K
+              return PyObject_GenericGetAttr(obj, name);
+            #else
               PyObject* superAttr = PyType_Type.tp_getattro(obj, name);
               if (superAttr) {
                 return superAttr;
               QString error = QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'";
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return NULL;
+            #endif
             }
             static int PythonQtClassWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
             */
             PyTypeObject PythonQtClassWrapper_Type = {
-                PyObject_HEAD_INIT(NULL)
+                PyVarObject_HEAD_INIT(NULL, 0)
-,                         /*ob_size*/
                 "PythonQt.PythonQtClassWrapper",             /*tp_name*/
                 sizeof(PythonQtClassWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/

src/PythonQtConversion.cpp +115 -32

             #include <QTime>
             #include <QDate>
+            #if PY_MAJOR_VERSION >= 3
+            #define PY3K
+            #endif
             PythonQtValueStorage<qint64, 128>  PythonQtConv::global_valueStorage;
             PythonQtValueStorage<void*, 128>   PythonQtConv::global_ptrStorage;
             PythonQtValueStorageWithCleanup<QVariant, 128> PythonQtConv::global_variantStorage;
                 // a char ptr will probably be a null terminated string, so we support that:
                 char* charPtr = *((char**)data);
                 if (charPtr) {
+            #ifdef PY3K
+                  return PyUnicode_FromString(charPtr);
+            #else
                   return PyString_FromString(charPtr);
+            #endif
                 } else {
                   Py_INCREF(Py_None);
                   return Py_None;
                 Py_INCREF(Py_None);
                 return Py_None;
               case QMetaType::Char:
-                return PyInt_FromLong(*((char*)data));
+                return PyLong_FromLong(*((char*)data));
               case QMetaType::UChar:
-                return PyInt_FromLong(*((unsigned char*)data));
+                return PyLong_FromLong(*((unsigned char*)data));
               case QMetaType::Short:
-                return PyInt_FromLong(*((short*)data));
+                return PyLong_FromLong(*((short*)data));
               case QMetaType::UShort:
-                return PyInt_FromLong(*((unsigned short*)data));
+                return PyLong_FromLong(*((unsigned short*)data));
               case QMetaType::Long:
-                return PyInt_FromLong(*((long*)data));
+                return PyLong_FromLong(*((long*)data));
               case QMetaType::ULong:
                 // does not fit into simple int of python
                 return PyLong_FromUnsignedLong(*((unsigned long*)data));
               case QMetaType::Bool:
                 return PythonQtConv::GetPyBool(*((bool*)data));
               case QMetaType::Int:
-                return PyInt_FromLong(*((int*)data));
+                return PyLong_FromLong(*((int*)data));
               case QMetaType::UInt:
                 // does not fit into simple int of python
                 return PyLong_FromUnsignedLong(*((unsigned int*)data));
               case QMetaType::QChar:
-                return PyInt_FromLong(*((short*)data));
+                return PyLong_FromLong(*((short*)data));
               case QMetaType::Float:
                 return PyFloat_FromDouble(*((float*)data));
               case QMetaType::Double:
               if (typeId == cursorId) {
                 static PyObject* qtCursorShapeEnum = PythonQtClassInfo::findEnumWrapper("Qt::CursorShape", NULL);
                 if ((PyObject*)obj->ob_type == qtCursorShapeEnum) {
-                  Qt::CursorShape val = (Qt::CursorShape)PyInt_AS_LONG(obj);
+                  Qt::CursorShape val = (Qt::CursorShape)PyLong_AsLong(obj);
                   if (!ptr) {
                     PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QCursor(), ptr);
                     ptr = (void*)((QVariant*)ptr)->constData();
                 // brushes can be created from QColor and from Qt::GlobalColor (and from brushes, but that's the default)
                 static PyObject* qtColorClass = PythonQt::priv()->getClassInfo("QColor")->pythonQtClassWrapper();
                 if ((PyObject*)obj->ob_type == qtGlobalColorEnum) {
-                  Qt::GlobalColor val = (Qt::GlobalColor)PyInt_AS_LONG(obj);
+                  Qt::GlobalColor val = (Qt::GlobalColor)PyLong_AsLong(obj);
                   if (!ptr) {
                     PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QPen(), ptr);
                     ptr = (void*)((QVariant*)ptr)->constData();
                 // brushes can be created from QColor and from Qt::GlobalColor (and from brushes, but that's the default)
                 static PyObject* qtColorClass = PythonQt::priv()->getClassInfo("QColor")->pythonQtClassWrapper();
                 if ((PyObject*)obj->ob_type == qtGlobalColorEnum) {
-                  Qt::GlobalColor val = (Qt::GlobalColor)PyInt_AS_LONG(obj);
+                  Qt::GlobalColor val = (Qt::GlobalColor)PyLong_AsLong(obj);
                   if (!ptr) {
                     PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QBrush(), ptr);
                     ptr = (void*)((QVariant*)ptr)->constData();
               } else if (typeId == colorId) {
                 // colors can be created from Qt::GlobalColor (and from colors, but that's the default)
                 if ((PyObject*)obj->ob_type == qtGlobalColorEnum) {
-                  Qt::GlobalColor val = (Qt::GlobalColor)PyInt_AS_LONG(obj);
+                  Qt::GlobalColor val = (Qt::GlobalColor)PyLong_AsLong(obj);
                   if (!ptr) {
                     PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QColor(), ptr);
                     ptr = (void*)((QVariant*)ptr)->constData();
                  // a pointer
                  if (info.typeId == QMetaType::Char || info.typeId == QMetaType::UChar)
                  {
+            #ifdef PY3K
+                   if (PyUnicode_Check(obj)) {
+                     QByteArray bytes(PyUnicode_AsUTF8(obj));
+                     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 (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);
+            #endif
                    } else {
                      // convert to string
                      QString str = PyObjGetString(obj, strict, ok);
                        ok = false;
                        if ((PyObject*)obj->ob_type == info.enumWrapper) {
                          // we have a exact enum type match:
-                         val = PyInt_AS_LONG(obj);
+                         val = PyLong_AsLong(obj);
                          ok = true;
                        } else if (!strict) {
                          // we try to get any integer, when not being strict. If we are strict, integers are not wanted because
               ok = false;
               // if we are strict, we do not want to convert a string to a stringlist
               // (strings in python are detected to be sequences)
-              if (strict &&
+              if (strict && (
-                (val->ob_type == &PyString_Type ||
+            #ifndef PY3K
+                val->ob_type == &PyString_Type ||
+            #endif
                 PyUnicode_Check(val))) {
                 ok = false;
                 return v;
               QString r;
               PyObject* str =  PyObject_Repr(val);
               if (str) {
+            #ifdef PY3K
+                Py_UCS4 *x = PyUnicode_AsUCS4Copy(str);
+                r = QString::fromUcs4(x, PyUnicode_GetLength(str));
+                PyMem_Free(x);
+            #else
                 r = QString(PyString_AS_STRING(str));
+            #endif
                 Py_DECREF(str);
               }
               return r;
             QString PythonQtConv::PyObjGetString(PyObject* val, bool strict, bool& ok) {
               QString r;
               ok = true;
-              if (val->ob_type == &PyString_Type) {
+            #ifndef PY3K
+              if (Py_TYPE(val) == &PyString_Type) {
                 r = QString(PyString_AS_STRING(val));
-              } else if (PyUnicode_Check(val)) {
+              } else
+            #endif
+              if (PyUnicode_Check(val)) {
+            #ifdef PY3K
+                Py_UCS4 *x = PyUnicode_AsUCS4Copy(val);
+                r = QString::fromUcs4(x, PyUnicode_GetLength(val));
+                PyMem_Free(x);
+            #else
                 PyObject *ptmp = PyUnicode_AsUTF8String(val);
                 if(ptmp) {
                   r = QString::fromUtf8(PyString_AS_STRING(ptmp));
                   Py_DECREF(ptmp);
                 }
+            #endif
               } else if (!strict) {
                 // EXTRA: could also use _Unicode, but why should we?
                 PyObject* str =  PyObject_Str(val);
                 if (str) {
+            #ifdef PY3K
+                  Py_UCS4 *x = PyUnicode_AsUCS4Copy(str);
+                  r = QString::fromUcs4(x, PyUnicode_GetLength(str));
+                  PyMem_Free(x);
+            #else
                   r = QString(PyString_AS_STRING(str));
+            #endif
                   Py_DECREF(str);
                 } else {
                   ok = false;
               // TODO: support buffer objects in general
               QByteArray r;
               ok = true;
-              if (val->ob_type == &PyString_Type) {
+            #ifdef PY3K
+              if (PyBytes_Check(val)) {
+                r = QByteArray(PyBytes_AS_STRING(val), PyBytes_GET_SIZE(val));
+            #else
+              if (Py_TYPE(val) == &PyString_Type) {
                 long size = PyString_GET_SIZE(val);
                 r = QByteArray(PyString_AS_STRING(val), size);
+            #endif
               } else {
                 ok = false;
               }
             int PythonQtConv::PyObjGetInt(PyObject* val, bool strict, bool &ok) {
               int d = 0;
               ok = true;
+            #ifndef PY3K
               if (val->ob_type == &PyInt_Type) {
                 d = PyInt_AS_LONG(val);
+              } else
+            #endif
+              if (Py_TYPE(val) == &PyLong_Type) {
+                // handle error on overflow!
+                d = PyLong_AsLong(val);
               } else if (!strict) {
+            #ifndef PY3K
                 if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   // support for derived int classes, e.g. for our enums
                   d = PyInt_AS_LONG(val);
-                } else if (val->ob_type == &PyFloat_Type) {
+                } else
-                  d = floor(PyFloat_AS_DOUBLE(val));
+            #endif
-                } else if (val->ob_type == &PyLong_Type) {
+                if (PyObject_TypeCheck(val, &PyLong_Type)) {
-                  // handle error on overflow!
                   d = PyLong_AsLong(val);
+                } else if (Py_TYPE(val) == &PyFloat_Type) {
+                  d = floor(PyFloat_AS_DOUBLE(val));
                 } else if (val == Py_False) {
                   d = 0;
                 } else if (val == Py_True) {
                 } else {
                   PyErr_Clear();
                   // PyInt_AsLong will try conversion to an int if the object is not an int:
-                  d = PyInt_AsLong(val);
+                  d = PyLong_AsLong(val);
                   if (PyErr_Occurred()) {
                     ok = false;
                     PyErr_Clear();
             qint64 PythonQtConv::PyObjGetLongLong(PyObject* val, bool strict, bool &ok) {
               qint64 d = 0;
               ok = true;
+            #ifndef PY3K
               if (val->ob_type == &PyInt_Type) {
                 d = PyInt_AS_LONG(val);
-              } else if (val->ob_type == &PyLong_Type) {
+              } else
+            #endif
+              if (Py_TYPE(val) == &PyLong_Type) {
                 d = PyLong_AsLongLong(val);
               } else if (!strict) {
+            #ifndef PY3K
                 if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   // support for derived int classes, e.g. for our enums
                   d = PyInt_AS_LONG(val);
-                } else if (val->ob_type == &PyFloat_Type) {
+                } else
+            #endif
+                if (PyObject_TypeCheck(val, &PyLong_Type)) {
+                  d = PyLong_AsLong(val);
+                } else if (Py_TYPE(val) == &PyFloat_Type) {
                   d = floor(PyFloat_AS_DOUBLE(val));
                 } else if (val == Py_False) {
                   d = 0;
             quint64 PythonQtConv::PyObjGetULongLong(PyObject* val, bool strict, bool &ok) {
               quint64 d = 0;
               ok = true;
-              if (PyObject_TypeCheck(val, &PyInt_Type)) {
+            #ifndef PY3K
+              if (Py_TYPE(val) == &PyInt_Type) {
                 d = PyInt_AS_LONG(val);
-              } else if (val->ob_type == &PyLong_Type) {
+              } else
+            #endif
+              if (Py_TYPE(val) == &PyLong_Type) {
                 d = PyLong_AsLongLong(val);
               } else if (!strict) {
+            #ifndef PY3K
                 if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   // support for derived int classes, e.g. for our enums
                   d = PyInt_AS_LONG(val);
-                } else if (val->ob_type == &PyFloat_Type) {
+                } else
+            #endif
+                if (PyObject_TypeCheck(val, &PyLong_Type)) {
+                  d = PyLong_AsLong(val);
+                } else if (Py_TYPE(val) == &PyFloat_Type) {
                   d = floor(PyFloat_AS_DOUBLE(val));
                 } else if (val == Py_False) {
                   d = 0;
               if (val->ob_type == &PyFloat_Type) {
                 d = PyFloat_AS_DOUBLE(val);
               } else if (!strict) {
+            #ifndef PY3K
                 if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   d = PyInt_AS_LONG(val);
-                } else if (val->ob_type == &PyLong_Type) {
+                } else
+            #endif
+                if (PyLong_Check(val)) {
                   d = PyLong_AsLong(val);
                 } else if (val == Py_False) {
                   d = 0;
               if (type==-1) {
                 // no special type requested
+            #ifdef PY3K
+                if (PyBytes_Check(val)) {
+                  type = QVariant::ByteArray;
+                } else if (PyUnicode_Check(val)) {
+            #else
                 if (val->ob_type==&PyString_Type || val->ob_type==&PyUnicode_Type) {
+            #endif
                   type = QVariant::String;
                 } else if (val == Py_False || val == Py_True) {
                   type = QVariant::Bool;
+            #ifndef PY3K
                 } else if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   type = QVariant::Int;
-                } else if (val->ob_type==&PyLong_Type) {
+            #endif
+                } else if (PyLong_Check(val)) {
                   type = QVariant::LongLong;
-                } else if (val->ob_type==&PyFloat_Type) {
+                } else if (PyFloat_Check(val)) {
                   type = QVariant::Double;
                 } else if (PyObject_TypeCheck(val, &PythonQtInstanceWrapper_Type)) {
                   PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)val;
                     v = qVariantFromValue(myObject);
                   }
                   return v;
-                } else if (val->ob_type==&PyDict_Type) {
+                } else if (PyDict_Check(val)) {
                   type = QVariant::Map;
-                } else if (val->ob_type==&PyList_Type || val->ob_type==&PyTuple_Type || PySequence_Check(val)) {
+                } else if (PyList_Check(val) || PyTuple_Check(val) || PySequence_Check(val)) {
                   type = QVariant::List;
                 } else if (val == Py_None) {
                   // none is invalid
             PyObject* PythonQtConv::QStringToPyObject(const QString& str)
             {
               if (str.isNull()) {
+            #ifdef PY3K
+                return PyUnicode_New(0, 0);
+            #else
                 return PyString_FromString("");
+            #endif
               } else {
                 return PyUnicode_DecodeUTF16((const char*)str.utf16(), str.length()*2, NULL, NULL);
               }

src/PythonQtImporter.cpp +28 -3

             #include <QFile>
             #include <QFileInfo>
+            #if PY_MAJOR_VERSION >= 3
+            #define PY3K
+            #endif
             #define IS_SOURCE   0x0
             #define IS_BYTECODE 0x1
             #define IS_PACKAGE  0x2
               // free the stored path
               if (self->_path) delete self->_path;
               // free ourself
-              self->ob_type->tp_free((PyObject *)self);
+              Py_TYPE(self)->tp_free((PyObject *)self);
             }
                   QString subname = info.moduleName;
                   int err;
+            #ifdef PY3K
+                  fullpath = PyUnicode_FromFormat("%s%c%s",
+            #else
                   fullpath = PyString_FromFormat("%s%c%s",
+            #endif
                     self->_path->toLatin1().constData(),
                     SEP,
                     subname.toLatin1().constData());
             #define DEFERRED_ADDRESS(ADDR) 0
             PyTypeObject PythonQtImporter_Type = {
-              PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type))
+              PyVarObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type), 0)
-,
               "PythonQtImport.PythonQtImporter",
               sizeof(PythonQtImporter),
 ,          /* tp_itemsize */
             PyDoc_STRVAR(mlabimport_doc,
             "Imports python files into PythonQt, completely replaces internal python import");
+            #ifdef PY3K
+            static struct PyModuleDef PythonQtImport_def = {
+                PyModuleDef_HEAD_INIT,
+                "PythonQtImport",   /* m_name */
+                mlabimport_doc,     /* m_doc */
+                -1,                 /* m_size */
+                NULL,               /* m_methods */
+                NULL,               /* m_reload */
+                NULL,               /* m_traverse */
+                NULL,               /* m_clear */
+                NULL                /* m_free */
+            };
+            #endif
             void PythonQtImport::init()
             {
               static bool first = true;
                 mlab_searchorder[4] = tmp;
               }
+            #ifdef PY3K
+              mod = PyModule_Create(&PythonQtImport_def);
+            #else
               mod = Py_InitModule4("PythonQtImport", NULL, mlabimport_doc,
                        NULL, PYTHON_API_VERSION);
+            #endif
               PythonQtImportError = PyErr_NewException(const_cast<char*>("PythonQtImport.PythonQtImportError"),
                           PyExc_ImportError, NULL);

src/PythonQtInstanceWrapper.cpp +83 -9

             #include "PythonQtConversion.h"
             #include "PythonQtClassWrapper.h"
+            #if PY_MAJOR_VERSION >= 3
+            #define PY3K
+            #endif
             PythonQtClassInfo* PythonQtInstanceWrapperStruct::classInfo()
             {
               // take the class info from our type object
-              return ((PythonQtClassWrapper*)ob_type)->_classInfo;
+              return ((PythonQtClassWrapper*)Py_TYPE(this))->_classInfo;
             }
             static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self, bool force = false) {
             {
               PythonQtInstanceWrapper_deleteObject(self);
               self->_obj.~QPointer<QObject>();
-              self->ob_type->tp_free((PyObject*)self);
+              Py_TYPE(self)->tp_free((PyObject*)self);
             }
             static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
             static PyObject *PythonQtInstanceWrapper_classname(PythonQtInstanceWrapper* obj)
             {
-              return PyString_FromString(obj->ob_type->tp_name);
+            #ifdef PY3K
+              return PyUnicode_FromString(Py_TYPE(obj)->tp_name);
+            #else
+              return PyString_FromString(Py_TYPE(obj)->tp_name);
+            #endif
             }
             PyObject *PythonQtInstanceWrapper_inherits(PythonQtInstanceWrapper* obj, PyObject *args)
               const char *attributeName;
               PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
+            #ifdef PY3K
+              if ((attributeName = PyUnicode_AsUTF8(name)) == NULL) {
+            #else
               if ((attributeName = PyString_AsString(name)) == NULL) {
+            #endif
                 return NULL;
               }
               }
               // look for the internal methods (className(), help())
+            #ifdef PY3K
+              PyObject* internalMethod = PyObject_GenericGetAttr(obj, name);
+            #else
               PyObject* internalMethod = Py_FindMethod( PythonQtInstanceWrapper_methods, obj, (char*)attributeName);
+            #endif
               if (internalMethod) {
                 return internalMethod;
               }
               const char *attributeName;
               PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
+            #ifdef PY3K
+              if ((attributeName = PyUnicode_AsUTF8(name)) == NULL)
+            #else
               if ((attributeName = PyString_AsString(name)) == NULL)
+            #endif
                 return -1;
               PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
               if (wrapper->classInfo()->metaTypeId()==QVariant::ByteArray) {
                 QByteArray* b = (QByteArray*) wrapper->_wrappedPtr;
                 if (b->data()) {
+            #ifdef PY3K
+                  return PyUnicode_FromStringAndSize(b->data(), b->size());
+            #else
                   return PyString_FromStringAndSize(b->data(), b->size());
+            #endif
                 } else {
+            #ifdef PY3K
+                  return PyUnicode_New(0, 0);
+            #else
                   return PyString_FromString("");
+            #endif
                 }
               }
               QObject *qobj = wrapper->_obj;
               QString str = getStringFromObject(wrapper);
               if (!str.isEmpty()) {
+            #ifdef PY3K
+                return PyUnicode_FromFormat("%s", str.toLatin1().constData());
+            #else
                 return PyString_FromFormat("%s", str.toLatin1().constData());
+            #endif
               }
               if (wrapper->_wrappedPtr) {
                 if (wrapper->_obj) {
-                  return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
+            #ifdef PY3K
+                  return PyUnicode_FromFormat("%s (C++ Object %p wrapped by %s %p)", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
+            #else
+                  return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p)", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
+            #endif
                 } else {
+            #ifdef PY3K
+                  return PyUnicode_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
+            #else
                   return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
+            #endif
                 }
               } else {
+            #ifdef PY3K
+                return PyUnicode_FromFormat("%s (QObject %p)", typeName, qobj);
+            #else
                 return PyString_FromFormat("%s (QObject %p)", typeName, qobj);
+            #endif
               }
             }
               QString str = getStringFromObject(wrapper);
               if (!str.isEmpty()) {
                 if (str.startsWith(typeName)) {
+            #ifdef PY3K
+                  return PyUnicode_FromFormat("%s", str.toLatin1().constData());
+            #else
                   return PyString_FromFormat("%s", str.toLatin1().constData());
+            #endif
                 } else {
+            #ifdef PY3K
+                  return PyUnicode_FromFormat("%s (%s, at: %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr ? wrapper->_wrappedPtr : qobj);
+            #else
                   return PyString_FromFormat("%s (%s, at: %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr ? wrapper->_wrappedPtr : qobj);
+            #endif
                 }
               }
               if (wrapper->_wrappedPtr) {
                 if (wrapper->_obj) {
+            #ifdef PY3K
+                  return PyUnicode_FromFormat("%s (C++ object at: %p wrapped by %s at: %p)", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
+            #else
                   return PyString_FromFormat("%s (C++ object at: %p wrapped by %s at: %p)", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
+            #endif
                 } else {
+            #ifdef PY3K
+                  return PyUnicode_FromFormat("%s (C++ object at: %p)", typeName, wrapper->_wrappedPtr);
+            #else
                   return PyString_FromFormat("%s (C++ object at: %p)", typeName, wrapper->_wrappedPtr);
+            #endif
                 }
               } else {
+            #ifdef PY3K
+                return PyUnicode_FromFormat("%s (%s at: %p)", typeName, wrapper->classInfo()->className(), qobj);
+            #else
                 return PyString_FromFormat("%s (%s at: %p)", typeName, wrapper->classInfo()->className(), qobj);
+            #endif
               }
             }
 ,      /* nb_add */
 ,      /* nb_subtract */
 ,      /* nb_multiply */
+            #ifndef PY3K
 ,      /* nb_divide */
+            #endif
 ,      /* nb_remainder */
 ,      /* nb_divmod */
 ,      /* nb_power */
 ,      /* nb_negative */
 ,      /* nb_positive */
 ,      /* nb_absolute */
-                PythonQtInstanceWrapper_builtin_nonzero,      /* nb_nonzero */
+                PythonQtInstanceWrapper_builtin_nonzero,      /* nb_nonzero / nb_bool in Py3K */
 ,      /* nb_invert */
 ,      /* nb_lshift */
 ,      /* nb_rshift */
 ,    /* nb_and */
 ,    /* nb_xor */
 ,    /* nb_or */
+            #ifndef PY3K
 ,      /* nb_coerce */
+            #endif
 ,      /* nb_int */
-,      /* nb_long */
+,      /* nb_long  / nb_reserved in Py3K */
 ,      /* nb_float */
+            #ifndef PY3K
 ,      /* nb_oct */
 ,      /* nb_hex */
+            #endif
 ,      /* nb_inplace_add */
 ,      /* nb_inplace_subtract */
 ,      /* nb_inplace_multiply */
+            #ifndef PY3K
 ,      /* nb_inplace_divide */
+            #endif
 ,      /* nb_inplace_remainder */
 ,      /* nb_inplace_power */
 ,      /* nb_inplace_lshift */
 ,      /* nb_true_divide */
 ,      /* nb_inplace_floor_divide */
 ,      /* nb_inplace_true_divide */
+            #ifdef PY3K
+,      /* nb_index in Py3K */
+            #endif
             };
             PyTypeObject PythonQtInstanceWrapper_Type = {
-                PyObject_HEAD_INIT(&PythonQtClassWrapper_Type)
+                PyVarObject_HEAD_INIT(&PythonQtClassWrapper_Type, 0)
-,                         /*ob_size*/
                 "PythonQt.PythonQtInstanceWrapper",             /*tp_name*/
                 sizeof(PythonQtInstanceWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
                 PythonQtInstanceWrapper_getattro,                         /*tp_getattro*/
                 PythonQtInstanceWrapper_setattro,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
-                Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_CHECKTYPES, /*tp_flags*/
+                Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE /*| Py_TPFLAGS_CHECKTYPES FIXME Py_TPFLAGS_CHECKTYPES removal */, /*tp_flags*/
                 "PythonQtInstanceWrapper object",           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */

src/PythonQtPythonInclude.h +16 0

@@ -38,6 +38,12
38	#undef _POSIX_THREADS	38	#undef _POSIX_THREADS
39	#undef _XOPEN_SOURCE	39	#undef _XOPEN_SOURCE
40		40
		41	// Undefine Qt keywords that conflict with Python headers
		42	#ifdef slots
		43	#undef slots
		44	#define PYTHONQT_RESTORE_KEYWORDS
		45	#endif
		46
41	// If PYTHONQT_USE_RELEASE_PYTHON_FALLBACK is enabled, try to link	47	// If PYTHONQT_USE_RELEASE_PYTHON_FALLBACK is enabled, try to link
42	// release Python DLL if it is available by undefining _DEBUG while	48	// release Python DLL if it is available by undefining _DEBUG while
43	// including Python.h	49	// including Python.h
@@ -53,4 +59,14
53	#include <Python.h>	59	#include <Python.h>
54	#endif	60	#endif
55		61
		62	// get Qt keywords back
		63	#ifdef PYTHONQT_RESTORE_KEYWORDS
		64	#define slots Q_SLOTS
		65	#undef PYTHONQT_RESTORE_KEYWORDS
		66	#endif
		67
		68	#if PY_MAJOR_VERSION >= 3
		69	#define PY3K
		70	#endif
		71
56	#endif	72	#endif

src/PythonQtSignal.cpp +47 -3

             meth_get__name__(PythonQtSignalFunctionObject *m, void * /*closure*/)
             {
             #if( QT_VERSION >= QT_VERSION_CHECK(5,0,0) )
+            #ifdef PY3K
+              return PyUnicode_FromString(m->m_ml->metaMethod()->methodSignature());
+            #else
               return PyString_FromString(m->m_ml->metaMethod()->methodSignature());
+            #endif
+            #else
+            #ifdef PY3K
+              return PyUnicode_FromString(m->m_ml->metaMethod()->signature());
             #else
               return PyString_FromString(m->m_ml->metaMethod()->signature());
             #endif
+            #endif
             }
             static int
             meth_get__self__(PythonQtSignalFunctionObject *m, void * /*closure*/)
             {
               PyObject *self;
+            #ifndef PY3K
               if (PyEval_GetRestricted()) {
                 PyErr_SetString(PyExc_RuntimeError,
                   "method.__self__ not accessible in restricted mode");
                 return NULL;
               }
+            #endif
               self = m->m_self;
               if (self == NULL)
                 self = Py_None;
             {
               if (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
                 PythonQtClassWrapper* self = (PythonQtClassWrapper*) f->m_self;
+            #ifdef PY3K
+                return PyUnicode_FromFormat("<unbound qt signal %s of %s type>",
+            #else
                 return PyString_FromFormat("<unbound qt signal %s of %s type>",
+            #endif
                   f->m_ml->slotName().data(),
                   self->classInfo()->className());
               } else {
+            #ifdef PY3K
+                return PyUnicode_FromFormat("<qt signal %s of %s instance at %p>",
+            #else
                 return PyString_FromFormat("<qt signal %s of %s instance at %p>",
+            #endif
                   f->m_ml->slotName().data(),
                   f->m_self->ob_type->tp_name,
                   f->m_self);
               return x;
             }
+            // for python 3.x
+            static PyObject*
+            meth_richcompare(PythonQtSignalFunctionObject *a, PythonQtSignalFunctionObject *b, int op)
+            {
+              int x = meth_compare(a, b);
+              bool r;
+              if (op == Py_LT)
+                r = x < 0;
+              else if (op == Py_LE)
+                r = x < 1;
+              else if (op == Py_EQ)
+                r = x == 0;
+              else if (op == Py_NE)
+                r = x != 0;
+              else if (op == Py_GE)
+                r = x > -1;
+              else if (op == Py_GT)
+                r = x > 0;
+              if (r)
+                Py_RETURN_TRUE;
+              else
+                Py_RETURN_FALSE;
+            }
             PyTypeObject PythonQtSignalFunction_Type = {
-              PyObject_HEAD_INIT(&PyType_Type)
+              PyVarObject_HEAD_INIT(&PyType_Type, 0)
-,
                 "builtin_qt_signal",
                 sizeof(PythonQtSignalFunctionObject),
 ,
 ,          /* tp_print */
 ,          /* tp_getattr */
 ,          /* tp_setattr */
+            #ifdef PY3K
+,
+            #else
                 (cmpfunc)meth_compare,      /* tp_compare */
+            #endif
                 (reprfunc)meth_repr,      /* tp_repr */
 ,          /* tp_as_number */
 ,          /* tp_as_sequence */
 ,          /* tp_doc */
                 (traverseproc)meth_traverse,    /* tp_traverse */
 ,          /* tp_clear */
-,          /* tp_richcompare */
+                (richcmpfunc)meth_richcompare,          /* tp_richcompare */
 ,          /* tp_weaklistoffset */
 ,          /* tp_iter */
 ,          /* tp_iternext */

src/PythonQtSignalReceiver.cpp +4 0

             bool PythonQtSignalTarget::isSame( int signalId, PyObject* callable ) const
             {
+            #ifdef PY3K
+              return PyObject_RichCompareBool(callable, _callable, Py_EQ) && signalId == _signalId;
+            #else
               return PyObject_Compare(callable, _callable) == 0 && signalId==_signalId;
+            #endif
             }
             //------------------------------------------------------------------------------

src/PythonQtSlot.cpp +68 -3

             #include <QByteArray>
+            #if PY_MAJOR_VERSION >= 3
+            #define PY3K
+            #endif
             #define PYTHONQT_MAX_ARGS 32
                     hadException = true;
                     QByteArray what("std::exception: ");
                     what += e.what();
+            #ifdef PY3K
+                    PyErr_SetString(PyExc_RuntimeError, what.constData());
+            #else
                     PyErr_SetString(PyExc_StandardError, what.constData());
+            #endif
                   }
                 }
             meth_get__name__(PythonQtSlotFunctionObject *m, void * /*closure*/)
             {
             #if( QT_VERSION >= QT_VERSION_CHECK(5,0,0) )
+            #ifdef PY3K
+              return PyUnicode_FromString(m->m_ml->metaMethod()->methodSignature());
+            #else
               return PyString_FromString(m->m_ml->metaMethod()->methodSignature());
+            #endif
+            #else
+            #ifdef PY3K
+              return PyUnicode_FromString(m->m_ml->metaMethod()->signature());
             #else
               return PyString_FromString(m->m_ml->metaMethod()->signature());
             #endif
+            #endif
             }
             static int
             meth_get__self__(PythonQtSlotFunctionObject *m, void * /*closure*/)
             {
               PyObject *self;
+            #ifndef PY3K
               if (PyEval_GetRestricted()) {
                 PyErr_SetString(PyExc_RuntimeError,
                   "method.__self__ not accessible in restricted mode");
                 return NULL;
               }
+            #endif
               self = m->m_self;
               if (self == NULL)
                 self = Py_None;
                 QList<QByteArray> types = info->metaMethod()->parameterTypes();
                 PyObject* tuple = PyTuple_New(types.count());
                 for (int i = 0; i<types.count();i++) {
+            #ifdef PY3K
+                  PyTuple_SET_ITEM(tuple, i, PyUnicode_FromString(types.at(i).constData()));
+            #else
                   PyTuple_SET_ITEM(tuple, i, PyString_FromString(types.at(i).constData()));
+            #endif
                 }
                 info = info->nextInfo();
                 PyTuple_SET_ITEM(result, j, tuple);
                 QList<QByteArray> names = info->metaMethod()->parameterNames();
                 PyObject* tuple = PyTuple_New(names.count());
                 for (int i = 0; i<names.count();i++) {
+            #ifdef PY3K
+                  PyTuple_SET_ITEM(tuple, i, PyUnicode_FromString(names.at(i).constData()));
+            #else
                   PyTuple_SET_ITEM(tuple, i, PyString_FromString(names.at(i).constData()));
+            #endif
                 }
                 info = info->nextInfo();
                 PyTuple_SET_ITEM(result, j, tuple);
               PyObject* result = PyTuple_New(count);
               for (int j = 0;j<count;j++) {
                 QByteArray name = info->metaMethod()->typeName();
+            #ifdef PY3K
+                PyTuple_SET_ITEM(result, j, PyUnicode_FromString(name.constData()));
+            #else
                 PyTuple_SET_ITEM(result, j, PyString_FromString(name.constData()));
+            #endif
                 info = info->nextInfo();
               }
               return result;
             {
               if (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
                 PythonQtClassWrapper* self = (PythonQtClassWrapper*) f->m_self;
+            #ifdef PY3K
+                return PyUnicode_FromFormat("<unbound qt slot %s of %s type>",
+            #else
                 return PyString_FromFormat("<unbound qt slot %s of %s type>",
+            #endif
                   f->m_ml->slotName().data(),
                   self->classInfo()->className());
               } else {
+            #ifdef PY3K
+                return PyUnicode_FromFormat("<qt slot %s of %s instance at %p",
+            #else
                 return PyString_FromFormat("<qt slot %s of %s instance at %p>",
+            #endif
                   f->m_ml->slotName().data(),
                   f->m_self->ob_type->tp_name,
                   f->m_self);
               return x;
             }
+            // for python 3.x
+            static PyObject*
+            meth_richcompare(PythonQtSlotFunctionObject *a, PythonQtSlotFunctionObject *b, int op)
+            {
+              int x = meth_compare(a, b);
+              bool r;
+              if (op == Py_LT)
+                r = x < 0;
+              else if (op == Py_LE)
+                r = x < 1;
+              else if (op == Py_EQ)
+                r = x == 0;
+              else if (op == Py_NE)
+                r = x != 0;
+              else if (op == Py_GE)
+                r = x > -1;
+              else if (op == Py_GT)
+                r = x > 0;
+              if (r)
+                Py_RETURN_TRUE;
+              else
+                Py_RETURN_FALSE;
+            }
             PyTypeObject PythonQtSlotFunction_Type = {
-              PyObject_HEAD_INIT(&PyType_Type)
+              PyVarObject_HEAD_INIT(&PyType_Type, 0)
-,
                 "builtin_qt_slot",
                 sizeof(PythonQtSlotFunctionObject),
 ,
 ,          /* tp_print */
 ,          /* tp_getattr */
 ,          /* tp_setattr */
+            #ifdef PY3K
+,
+            #else
                 (cmpfunc)meth_compare,      /* tp_compare */
+            #endif
                 (reprfunc)meth_repr,      /* tp_repr */
 ,          /* tp_as_number */
 ,          /* tp_as_sequence */
 ,          /* tp_doc */
                 (traverseproc)meth_traverse,    /* tp_traverse */
 ,          /* tp_clear */
-,          /* tp_richcompare */
+                (richcmpfunc)meth_richcompare,          /* tp_richcompare */
 ,          /* tp_weaklistoffset */
 ,          /* tp_iter */
 ,          /* tp_iternext */

src/PythonQtStdDecorators.cpp +15 0

                 meta = ((PythonQtClassWrapper*)type)->classInfo()->metaObject();
               } else if (PyObject_TypeCheck(type, &PythonQtInstanceWrapper_Type)) {
                 meta = ((PythonQtInstanceWrapper*)type)->classInfo()->metaObject();
+            #ifdef PY3K
+              } else if (PyUnicode_Check(type)) {
+                typeName = PyUnicode_AsUTF8(type);
+            #else
               } else if (PyString_Check(type)) {
                 typeName = PyString_AsString(type);
+            #endif
               }
               if (!typeName && !meta)
                 meta = ((PythonQtClassWrapper*)type)->classInfo()->metaObject();
               } else if (PyObject_TypeCheck(type, &PythonQtInstanceWrapper_Type)) {
                 meta = ((PythonQtInstanceWrapper*)type)->classInfo()->metaObject();
+            #ifdef PY3K
+              } else if (PyUnicode_Check(type)) {
+                typeName = PyUnicode_AsUTF8(type);
+            #else
               } else if (PyString_Check(type)) {
                 typeName = PyString_AsString(type);
+            #endif
               }
               QList<QObject*> list;
                 meta = ((PythonQtClassWrapper*)type)->classInfo()->metaObject();
               } else if (PyObject_TypeCheck(type, &PythonQtInstanceWrapper_Type)) {
                 meta = ((PythonQtInstanceWrapper*)type)->classInfo()->metaObject();
+            #ifdef PY3K
+              } else if (PyUnicode_Check(type)) {
+                typeName = PyUnicode_AsUTF8(type);
+            #else
               } else if (PyString_Check(type)) {
                 typeName = PyString_AsString(type);
+            #endif
               }
               QList<QObject*> list;

src/PythonQtStdIn.cpp +1 -2

             };
             PyTypeObject PythonQtStdInRedirectType = {
-                PyObject_HEAD_INIT(NULL)
+                PyVarObject_HEAD_INIT(NULL, 0)
-,                         /*ob_size*/
                 "PythonQtStdInRedirect",             /*tp_name*/
                 sizeof(PythonQtStdInRedirect),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/

src/PythonQtStdOut.cpp +7 -2

                 if (PyTuple_GET_SIZE(args)>=1) {
                   PyObject* obj = PyTuple_GET_ITEM(args,0);
                   if (PyUnicode_Check(obj)) {
+            #ifdef PY3K
+                    Py_UCS4 *x = PyUnicode_AsUCS4Copy(obj);
+                    output = QString::fromUcs4(x, PyUnicode_GetLength(obj));
+                    PyMem_Free(x);
+            #else
                     PyObject *tmp = PyUnicode_AsUTF8String(obj);
                     if(tmp) {
                       output = QString::fromUtf8(PyString_AS_STRING(tmp));
                     } else {
                       return NULL;
                     }
+            #endif
                   } else {
                     char *string;
                     if (!PyArg_ParseTuple(args, "s", &string)) {
             };
             PyTypeObject PythonQtStdOutRedirectType = {
-                PyObject_HEAD_INIT(NULL)
+                PyVarObject_HEAD_INIT(NULL, 0)
-,                         /*ob_size*/
                 "PythonQtStdOutRedirect",             /*tp_name*/
                 sizeof(PythonQtStdOutRedirect),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/

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