GIT_REPOSITORIES/LPP/PythonQt Commit - r207:99eb8a233276

Fix __getattr__ problems.

Orochimarufan -

r207:99eb8a233276

parent child

Context file:

r207:99eb8a233276

Collapse all files

CMakeLists.txt +9 -5

             project(PythonQt)
             cmake_minimum_required(VERSION 2.8.10)
             include(CTestUseLaunchers OPTIONAL)
             set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
             #-----------------------------------------------------------------------------
             # Debug
             option(PythonQt_DEBUG "Enable/Disable PythonQt debug output" OFF)
             if(PythonQt_DEBUG)
             	add_definitions(-DPYTHONQT_DEBUG)
             else()
             	remove_definitions(-DPYTHONQT_DEBUG)
             endif()
             #-----------------------------------------------------------------------------
             # Qt
             option(PythonQt_Qt5 "Use Qt 5.x (5.1+)" OFF)
             if(PythonQt_Qt5)
             	include(PythonQt_Qt_5x)
             else(PythonQt_Qt5)
             	include(PythonQt_Qt_4x)
             endif(PythonQt_Qt5)
             #-----------------------------------------------------------------------------
             # The variable "generated_cpp_suffix" allows to conditionnally compile the generated wrappers
             # associated with the Qt version being used.
             if(PythonQt_Qt5)
             	set(generated_cpp_suffix "_${Qt5Core_VERSION_MAJOR}${Qt5Core_VERSION_MINOR}")
             else()
             	set(generated_cpp_suffix "_${QT_VERSION_MAJOR}${QT_VERSION_MINOR}")
             endif()
             if("${generated_cpp_suffix}" STREQUAL "_48")
             	set(generated_cpp_suffix "")
             endif()
             if("${generated_cpp_suffix}" STREQUAL "_46")
             	set(generated_cpp_suffix "_47") # Also use 4.7 wrappers for 4.6.x version
             endif()
             if("${generated_cpp_suffix}" STREQUAL "_51")
             	set(generated_cpp_suffix "_50")
             endif()
             #-----------------------------------------------------------------------------
             # Generator
             if(PythonQt_Qt5)
             	add_subdirectory(generator_50 EXCLUDE_FROM_ALL)
             	add_custom_target(generator)
             	add_dependencies(generator pythonqt_generator)
             endif()
             # TODO
             #-----------------------------------------------------------------------------
             # Build options
             #option(PythonQt_Wrap_QtAll "Make all Qt components available in python" OFF)
             #
             #set(qtlibs core gui network opengl sql svg uitools webkit xml xmlpatterns)
             #foreach(qtlib ${qtlibs})
             #	OPTION(PythonQt_Wrap_Qt${qtlib} "Make all of Qt${qtlib} available in python" OFF)
             #endforeach()
             # Force option if it applies
             #if(PythonQt_Wrap_QtAll)
             #	list(REMOVE_ITEM qtlibs xmlpatterns) # xmlpatterns wrapper does *NOT* build at all :(
             #	foreach(qtlib ${qtlibs})
             #		if(NOT ${PythonQt_Wrap_Qt${qtlib}})
             #			set(PythonQt_Wrap_Qt${qtlib} ON CACHE BOOL "Make all of Qt${qtlib} available in python" FORCE)
             #			message(STATUS "Enabling [PythonQt_Wrap_Qt${qtlib}] because of [PythonQt_Wrap_QtAll] evaluates to True")
             #		endif()
             #	endforeach()
             #endif()
             #-----------------------------------------------------------------------------
             # Add extra sources
             #foreach(qtlib core gui network opengl sql svg uitools webkit xml xmlpatterns)
             #
             #	if (${PythonQt_Wrap_Qt${qtlib}})
             #
             #		ADD_DEFINITIONS(-DPYTHONQT_WRAP_Qt${qtlib})
             #
             #		set(file_prefix generated_cpp${generated_cpp_suffix}/com_trolltech_qt_${qtlib}/com_trolltech_qt_${qtlib})
             #
             #		foreach(index RANGE 0 11)
             #
             #			# Source files
             #			if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${file_prefix}${index}.cpp)
             #				list(APPEND sources ${file_prefix}${index}.cpp)
             #			endif()
             #
             #			# Headers that should run through moc
             #			if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${file_prefix}${index}.h)
             #				list(APPEND moc_sources ${file_prefix}${index}.h)
             #			endif()
             #
             #		endforeach()
             #
             #		list(APPEND sources ${file_prefix}_init.cpp)
             #
             #	endif()
             #endforeach()
             #-----------------------------------------------------------------------------
             # Find Python
             option(PythonQt_Python3 "Use Python 3.x (3.3+)" OFF)
-            if(PythonQt_Python3)
+            option(PythonQt_Python "Use specific Python Version" OFF)
-            	set(PythonQt_PythonMin 3.3)
+            if(PythonQt_Python)
-            else(PythonQt_Python3)
+            	find_package(Python ${PythonQt_Python} REQUIRED EXACT)
-            	set(PythonQt_PythonMin 2.6)
+            elseif(PythonQt_Python3)
+            	find_package(Python 3.3 REQUIRED)
+            else()
+            	find_package(Python 2.6 REQUIRED)
             endif()
-            find_package(Python ${PythonQt_PythonMin} REQUIRED)
             include_directories(${PYTHON_INCLUDE_DIRS})
             add_definitions(-DPYTHONQT_USE_RELEASE_PYTHON_FALLBACK)
+            #-----------------------------------------------------------------------------
+            # Core
             add_subdirectory(src)
             #-----------------------------------------------------------------------------
             # Tests
             add_subdirectory(tests EXCLUDE_FROM_ALL)
             # test alias
             add_custom_target(test COMMAND tests/PythonQtTest WORKING_DIRECTORY ${CURRENT_BINARY_DIR})
             add_dependencies(test PythonQtTest)
             #-----------------------------------------------------------------------------
             # Extenseions (QtAll)
             add_subdirectory(extensions EXCLUDE_FROM_ALL)
             # QtAll alias
             add_custom_target(QtAll)
             add_dependencies(QtAll PythonQt_QtAll)
             #-----------------------------------------------------------------------------
             # Examples
             include_directories(src)
             include_directories(extensions/PythonQt_QtAll)
             add_subdirectory(examples EXCLUDE_FROM_ALL)

src/PythonQt.cpp +11 -8

             /*
             *
             *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
             *
             *  This library is free software; you can redistribute it and/or
             *  modify it under the terms of the GNU Lesser General Public
             *  License as published by the Free Software Foundation; either
             *  version 2.1 of the License, or (at your option) any later version.
             *
             *  This library is distributed in the hope that it will be useful,
             *  but WITHOUT ANY WARRANTY; without even the implied warranty of
             *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
             *  Lesser General Public License for more details.
             *
             *  Further, this software is distributed without any warranty that it is
             *  free of the rightful claim of any third person regarding infringement
             *  or the like.  Any license provided herein, whether implied or
             *  otherwise, applies only to this software file.  Patent licenses, if
             *  any, provided herein do not apply to combinations of this program with
             *  other software, or any other product whatsoever.
             *
             *  You should have received a copy of the GNU Lesser General Public
             *  License along with this library; if not, write to the Free Software
             *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             *
             *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
             *  28359 Bremen, Germany or:
             *
             *  http://www.mevis.de
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQt.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQt.h"
             #include "PythonQtImporter.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtMethodInfo.h"
             #include "PythonQtSignal.h"
             #include "PythonQtSignalReceiver.h"
             #include "PythonQtConversion.h"
             #include "PythonQtStdIn.h"
             #include "PythonQtStdOut.h"
             #include "PythonQtCppWrapperFactory.h"
             #include "PythonQtVariants.h"
             #include "PythonQtStdDecorators.h"
             #include "PythonQtQFileImporter.h"
             #include <pydebug.h>
             #include <vector>
             PythonQt* PythonQt::_self = NULL;
             int       PythonQt::_uniqueModuleCount = 0;
             void PythonQt_init_QtGuiBuiltin(PyObject*);
             void PythonQt_init_QtCoreBuiltin(PyObject*);
             PyObject* PythonQtConvertFromStringRef(const void* inObject, int /*metaTypeId*/)
             {
               return PythonQtConv::QStringToPyObject(((QStringRef*)inObject)->toString());
             }
             void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
             {
               if (!_self) {
                 _self = new PythonQt(flags, pythonQtModuleName);
                 PythonQt::priv()->setupSharedLibrarySuffixes();
                 PythonQtMethodInfo::addParameterTypeAlias("QObjectList", "QList<QObject*>");
                 qRegisterMetaType<QList<QObject*> >("QList<void*>");
                 int stringRefId = qRegisterMetaType<QStringRef>("QStringRef");
                 PythonQtConv::registerMetaTypeToPythonConverter(stringRefId, PythonQtConvertFromStringRef);
                 PythonQtRegisterToolClassesTemplateConverter(int);
                 PythonQtRegisterToolClassesTemplateConverter(float);
                 PythonQtRegisterToolClassesTemplateConverter(double);
                 PythonQtRegisterToolClassesTemplateConverter(qint32);
                 PythonQtRegisterToolClassesTemplateConverter(quint32);
                 PythonQtRegisterToolClassesTemplateConverter(qint64);
                 PythonQtRegisterToolClassesTemplateConverter(quint64);
                 // TODO: which other POD types should be available for QList etc.
                 PythonQt_init_QtCoreBuiltin(NULL);
                 PythonQt_init_QtGuiBuiltin(NULL);
                 PythonQt::self()->addDecorators(new PythonQtStdDecorators());
                 PythonQt::self()->registerCPPClass("QMetaObject",0, "QtCore", PythonQtCreateObject<PythonQtWrapper_QMetaObject>);
                 PythonQtRegisterToolClassesTemplateConverter(QByteArray);
                 PythonQtRegisterToolClassesTemplateConverter(QDate);
                 PythonQtRegisterToolClassesTemplateConverter(QTime);
                 PythonQtRegisterToolClassesTemplateConverter(QDateTime);
                 PythonQtRegisterToolClassesTemplateConverter(QUrl);
                 PythonQtRegisterToolClassesTemplateConverter(QLocale);
                 PythonQtRegisterToolClassesTemplateConverter(QRect);
                 PythonQtRegisterToolClassesTemplateConverter(QRectF);
                 PythonQtRegisterToolClassesTemplateConverter(QSize);
                 PythonQtRegisterToolClassesTemplateConverter(QSizeF);
                 PythonQtRegisterToolClassesTemplateConverter(QLine);
                 PythonQtRegisterToolClassesTemplateConverter(QLineF);
                 PythonQtRegisterToolClassesTemplateConverter(QPoint);
                 PythonQtRegisterToolClassesTemplateConverter(QPointF);
                 PythonQtRegisterToolClassesTemplateConverter(QRegExp);
                 PythonQtRegisterToolClassesTemplateConverter(QFont);
                 PythonQtRegisterToolClassesTemplateConverter(QPixmap);
                 PythonQtRegisterToolClassesTemplateConverter(QBrush);
                 PythonQtRegisterToolClassesTemplateConverter(QColor);
                 PythonQtRegisterToolClassesTemplateConverter(QPalette);
                 PythonQtRegisterToolClassesTemplateConverter(QIcon);
                 PythonQtRegisterToolClassesTemplateConverter(QImage);
                 PythonQtRegisterToolClassesTemplateConverter(QPolygon);
                 PythonQtRegisterToolClassesTemplateConverter(QRegion);
                 PythonQtRegisterToolClassesTemplateConverter(QBitmap);
                 PythonQtRegisterToolClassesTemplateConverter(QCursor);
                 PythonQtRegisterToolClassesTemplateConverter(QSizePolicy);
                 PythonQtRegisterToolClassesTemplateConverter(QKeySequence);
                 PythonQtRegisterToolClassesTemplateConverter(QPen);
                 PythonQtRegisterToolClassesTemplateConverter(QTextLength);
                 PythonQtRegisterToolClassesTemplateConverter(QTextFormat);
                 PythonQtRegisterToolClassesTemplateConverter(QMatrix);
                 PyObject* pack = PythonQt::priv()->packageByName("QtCore");
                 PyObject* pack2 = PythonQt::priv()->packageByName("Qt");
                 PyObject* qtNamespace = PythonQt::priv()->getClassInfo("Qt")->pythonQtClassWrapper();
                 const char* names[16] = {"SIGNAL", "SLOT", "qAbs", "qBound","qDebug","qWarning","qCritical","qFatal"
                                     ,"qFuzzyCompare", "qMax","qMin","qRound","qRound64","qVersion","qrand","qsrand"};
                 for (unsigned int i = 0;i<16; i++) {
                   PyObject* obj = PyObject_GetAttrString(qtNamespace, names[i]);
                   if (obj) {
                     PyModule_AddObject(pack, names[i], obj);
                     Py_INCREF(obj);
                     PyModule_AddObject(pack2, names[i], obj);
                   } else {
-                    std::cerr << "method not found " << names[i];
+                    std::cerr << "method not found " << names[i] << std::endl;
                   }
                 }
               }
             }
             void PythonQt::cleanup()
             {
               if (_self) {
                 delete _self;
                 _self = NULL;
               }
             }
             PythonQt* PythonQt::self() { return _self; }
             PythonQt::PythonQt(int flags, const QByteArray& pythonQtModuleName)
             {
               _p = new PythonQtPrivate;
               _p->_initFlags = flags;
               _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;
                 }
                 Py_Initialize();
               }
               // add our own python object types for qt object slots
               if (PyType_Ready(&PythonQtSlotFunction_Type) < 0) {
                 std::cerr << "could not initialize PythonQtSlotFunction_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtSlotFunction_Type);
               if (PyType_Ready(&PythonQtSignalFunction_Type) < 0) {
                 std::cerr << "could not initialize PythonQtSignalFunction_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtSignalFunction_Type);
               // according to Python docs, set the type late here, since it can not safely be stored in the struct when declaring it
               PythonQtClassWrapper_Type.tp_base = &PyType_Type;
               // add our own python object types for classes
               if (PyType_Ready(&PythonQtClassWrapper_Type) < 0) {
                 std::cerr << "could not initialize PythonQtClassWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtClassWrapper_Type);
               // add our own python object types for CPP instances
               if (PyType_Ready(&PythonQtInstanceWrapper_Type) < 0) {
                 PythonQt::handleError();
                 std::cerr << "could not initialize PythonQtInstanceWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtInstanceWrapper_Type);
               // add our own python object types for redirection of stdout
               if (PyType_Ready(&PythonQtStdOutRedirectType) < 0) {
                 std::cerr << "could not initialize PythonQtStdOutRedirectType" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtStdOutRedirectType);
               // add our own python object types for redirection of stdin
               if (PyType_Ready(&PythonQtStdInRedirectType) < 0) {
                 std::cerr << "could not initialize PythonQtStdInRedirectType" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtStdInRedirectType);
               initPythonQtModule(flags & RedirectStdOut, pythonQtModuleName);
             }
             PythonQt::~PythonQt() {
               delete _p;
               _p = NULL;
             }
             PythonQtPrivate::~PythonQtPrivate() {
               delete _defaultImporter;
               _defaultImporter = NULL;
               {
                 QHashIterator<QByteArray, PythonQtClassInfo *> i(_knownClassInfos);
                 while (i.hasNext()) {
                   delete i.next().value();
                 }
               }
               PythonQtConv::global_valueStorage.clear();
               PythonQtConv::global_ptrStorage.clear();
               PythonQtConv::global_variantStorage.clear();
               PythonQtMethodInfo::cleanupCachedMethodInfos();
             }
             void PythonQt::setRedirectStdInCallback(PythonQtInputChangedCB* callback, void * callbackData)
             {
               if (!callback)
                 {
                 std::cerr << "PythonQt::setRedirectStdInCallback - callback parameter is NULL !" << std::endl;
                 return;
                 }
               PythonQtObjectPtr sys;
               PythonQtObjectPtr in;
               sys.setNewRef(PyImport_ImportModule("sys"));
               // Backup original 'sys.stdin' if not yet done
               if( !PyObject_HasAttrString(sys.object(), "pythonqt_original_stdin") )
                   PyObject_SetAttrString(sys.object(), "pythonqt_original_stdin", PyObject_GetAttrString(sys.object(), "stdin"));
               in = PythonQtStdInRedirectType.tp_new(&PythonQtStdInRedirectType, NULL, NULL);
               ((PythonQtStdInRedirect*)in.object())->_cb = callback;
               ((PythonQtStdInRedirect*)in.object())->_callData = callbackData;
               // replace the built in file objects with our own objects
               PyModule_AddObject(sys.object(), "stdin", in);
               // Backup custom 'stdin' into 'pythonqt_stdin'
               Py_IncRef(in);
               PyModule_AddObject(sys.object(), "pythonqt_stdin", in);
             }
             void PythonQt::setRedirectStdInCallbackEnabled(bool enabled)
             {
               PythonQtObjectPtr sys;
               sys.setNewRef(PyImport_ImportModule("sys"));
               if (enabled)
                 {
                   if( !PyObject_HasAttrString(sys.object(), "pythonqt_stdin") )
                       PyObject_SetAttrString(sys.object(), "stdin", PyObject_GetAttrString(sys.object(), "pythonqt_stdin"));
                 }
               else
                 {
                   if( !PyObject_HasAttrString(sys.object(), "pythonqt_original_stdin") )
                       PyObject_SetAttrString(sys.object(), "stdin", PyObject_GetAttrString(sys.object(), "pythonqt_original_stdin"));
                 }
             }
             PythonQtImportFileInterface* PythonQt::importInterface()
             {
               return _self->_p->_importInterface?_self->_p->_importInterface:_self->_p->_defaultImporter;
             }
             void PythonQt::qObjectNoLongerWrappedCB(QObject* o)
             {
               if (_self->_p->_noLongerWrappedCB) {
                 (*_self->_p->_noLongerWrappedCB)(o);
               };
             }
             void PythonQt::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell)
             {
               _p->registerClass(metaobject, package, wrapperCreator, shell);
             }
             void PythonQtPrivate::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell, PyObject* module, int typeSlots)
             {
               // we register all classes in the hierarchy
               const QMetaObject* m = metaobject;
               bool first = true;
               while (m) {
                 PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(m->className());
                 if (!info->pythonQtClassWrapper()) {
                   info->setTypeSlots(typeSlots);
                   info->setupQObject(m);
                   createPythonQtClassWrapper(info, package, module);
                   if (m->superClass()) {
                     PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(m->superClass()->className());
                     info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo));
                   }
                 } else if (first && module) {
                   // There is a wrapper already, but if we got a module, we want to place the wrapper into that module as well,
                   // since it might have been placed into "private" earlier on.
                   // If the wrapper was already added to module before, it is just readded, which does no harm.
                   PyObject* classWrapper = info->pythonQtClassWrapper();
                   // AddObject steals a reference, so we need to INCREF
                   Py_INCREF(classWrapper);
                   PyModule_AddObject(module, info->className(), classWrapper);
                 }
                 if (first) {
                   first = false;
                   if (wrapperCreator) {
                     info->setDecoratorProvider(wrapperCreator);
                   }
                   if (shell) {
                     info->setShellSetInstanceWrapperCB(shell);
                   }
                 }
                 m = m->superClass();
               }
             }
             void PythonQtPrivate::createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module)
             {
               PyObject* pack = module?module:packageByName(package);
               PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info, pack);
               PyModule_AddObject(pack, info->className(), pyobj);
               if (!module && package && strncmp(package,"Qt",2)==0) {
                 // since PyModule_AddObject steals the reference, we need a incref once more...
                 Py_INCREF(pyobj);
                 // put all qt objects into Qt as well
                 PyModule_AddObject(packageByName("Qt"), info->className(), pyobj);
               }
               info->setPythonQtClassWrapper(pyobj);
             }
             PyObject* PythonQtPrivate::wrapQObject(QObject* obj)
             {
               if (!obj) {
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(obj);
               if (wrap && wrap->_wrappedPtr) {
                 // uh oh, we want to wrap a QObject, but have a C++ wrapper at that
                 // address, so probably that C++ wrapper has been deleted earlier and
                 // now we see a QObject with the same address.
                 // Do not use the old wrapper anymore.
                 wrap = NULL;
               }
               if (!wrap) {
                 // smuggling it in...
                 PythonQtClassInfo* classInfo = _knownClassInfos.value(obj->metaObject()->className());
                 if (!classInfo || classInfo->pythonQtClassWrapper()==NULL) {
                   registerClass(obj->metaObject());
                   classInfo = _knownClassInfos.value(obj->metaObject()->className());
                 }
                 wrap = createNewPythonQtInstanceWrapper(obj, classInfo);
                 //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               } else {
                 Py_INCREF(wrap);
                 //    mlabDebugConst("MLABPython","qobject wrapper reused " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               }
               return (PyObject*)wrap;
             }
             PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name)
             {
               if (!ptr) {
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(ptr);
               PythonQtInstanceWrapper* possibleStillAliveWrapper = NULL;
               if (wrap && wrap->_wrappedPtr) {
                 // we have a previous C++ wrapper... if the wrapper is for a C++ object,
                 // we are not sure if it may have been deleted earlier and we just see the same C++
                 // pointer once again. To make sure that we do not reuse a wrapper of the wrong type,
                 // we compare the classInfo() pointer and only reuse the wrapper if it has the same
                 // info. This is only needed for non-QObjects, since we know it when a QObject gets deleted.
                 possibleStillAliveWrapper = wrap;
                 wrap = NULL;
               }
               if (!wrap) {
                 PythonQtClassInfo* info = _knownClassInfos.value(name);
                 if (!info) {
                   // maybe it is a PyObject, which we can return directly
                   if (name == "PyObject") {
                     PyObject* p = (PyObject*)ptr;
                     Py_INCREF(p);
                     return p;
                   }
                   // we do not know the metaobject yet, but we might know it by its name:
                   if (_knownQObjectClassNames.find(name)!=_knownQObjectClassNames.end()) {
                     // yes, we know it, so we can convert to QObject
                     QObject* qptr = (QObject*)ptr;
                     registerClass(qptr->metaObject());
                     info = _knownClassInfos.value(qptr->metaObject()->className());
                   }
                 }
                 if (info && info->isQObject()) {
                   QObject* qptr = (QObject*)ptr;
                   // if the object is a derived object, we want to switch the class info to the one of the derived class:
                   if (name!=(qptr->metaObject()->className())) {
                     info = _knownClassInfos.value(qptr->metaObject()->className());
                     if (!info) {
                       registerClass(qptr->metaObject());
                       info = _knownClassInfos.value(qptr->metaObject()->className());
                     }
                   }
                   wrap = createNewPythonQtInstanceWrapper(qptr, info);
                   //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
                   return (PyObject*)wrap;
                 }
                 // not a known QObject, try to wrap via foreign wrapper factories
                 PyObject* foreignWrapper = NULL;
                 for (int i=0; i<_foreignWrapperFactories.size(); i++) {
                   foreignWrapper = _foreignWrapperFactories.at(i)->wrap(name, ptr);
                   if (foreignWrapper) {
                     return foreignWrapper;
                   }
                 }
                 // not a known QObject, so try our wrapper factory:
                 QObject* wrapper = NULL;
                 for (int i=0; i<_cppWrapperFactories.size(); i++) {
                   wrapper = _cppWrapperFactories.at(i)->create(name, ptr);
                   if (wrapper) {
                     break;
                   }
                 }
                 if (info) {
                   // try to downcast in the class hierarchy, which will modify info and ptr if it is successfull
                   ptr  = info->castDownIfPossible(ptr, &info);
                   // if downcasting found out that the object is a QObject,
                   // handle it like one:
                   if (info && info->isQObject()) {
                     QObject* qptr = (QObject*)ptr;
                     // if the object is a derived object, we want to switch the class info to the one of the derived class:
                     if (name!=(qptr->metaObject()->className())) {
                       registerClass(qptr->metaObject());
                       info = _knownClassInfos.value(qptr->metaObject()->className());
                     }
                     wrap = createNewPythonQtInstanceWrapper(qptr, info);
                     //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
                     return (PyObject*)wrap;
                   }
                 }
                 if (!info || info->pythonQtClassWrapper()==NULL) {
                   // still unknown, register as CPP class
                   registerCPPClass(name.constData());
                   info = _knownClassInfos.value(name);
                 }
                 if (wrapper && (info->metaObject() != wrapper->metaObject())) {
                   // if we a have a QObject wrapper and the metaobjects do not match, set the metaobject again!
                   info->setMetaObject(wrapper->metaObject());
                 }
                 if (possibleStillAliveWrapper && possibleStillAliveWrapper->classInfo() == info) {
                   wrap = possibleStillAliveWrapper;
                   Py_INCREF(wrap);
                 } else {
                   wrap = createNewPythonQtInstanceWrapper(wrapper, info, ptr);
                 }
                 //          mlabDebugConst("MLABPython","new c++ wrapper added " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               } else {
                 Py_INCREF(wrap);
                 //mlabDebugConst("MLABPython","c++ wrapper reused " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               }
               return (PyObject*)wrap;
             }
             PyObject* PythonQtPrivate::dummyTuple() {
               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;
             }
             PythonQtInstanceWrapper* PythonQtPrivate::createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr) {
               // call the associated class type to create a new instance...
               PythonQtInstanceWrapper* result = (PythonQtInstanceWrapper*)PyObject_Call(info->pythonQtClassWrapper(), dummyTuple(), NULL);
               result->setQObject(obj);
               result->_wrappedPtr = wrappedPtr;
               result->_ownedByPythonQt = false;
               result->_useQMetaTypeDestroy = false;
               if (wrappedPtr) {
                 _wrappedObjects.insert(wrappedPtr, result);
               } else {
                 _wrappedObjects.insert(obj, result);
                 if (obj->parent()== NULL && _wrappedCB) {
                   // tell someone who is interested that the qobject is wrapped the first time, if it has no parent
                   (*_wrappedCB)(obj);
                 }
               }
               return result;
             }
             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* typeDict = PyDict_New();
               PyObject* moduleName = PyObject_GetAttrString(parentModule, "__name__");
               PyDict_SetItemString(typeDict, "__module__", moduleName);
               PyObject* args  = Py_BuildValue("OOO", className, baseClasses, typeDict);
               // set the class info so that PythonQtClassWrapper_new can read it
               _currentClassInfoForClassWrapperCreation = info;
               // create the new type object by calling the type
               result = (PythonQtClassWrapper *)PyObject_Call((PyObject *)&PythonQtClassWrapper_Type, args, NULL);
               Py_DECREF(baseClasses);
               Py_DECREF(typeDict);
               Py_DECREF(args);
               Py_DECREF(className);
               return result;
             }
             PyObject*  PythonQtPrivate::createEnumValueInstance(PyObject* enumType, unsigned int enumValue)
             {
               PyObject* args = Py_BuildValue("(i)", enumValue);
               PyObject* result = PyObject_Call(enumType, args, NULL);
               Py_DECREF(args);
               return result;
             }
             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();
               PyDict_SetItemString(typeDict, "__module__", module);
               PyObject* args  = Py_BuildValue("OOO", className, baseClasses, typeDict);
               // create the new int derived type object by calling the core type
               result = PyObject_Call((PyObject *)&PyType_Type, args, NULL);
               Py_DECREF(baseClasses);
               Py_DECREF(typeDict);
               Py_DECREF(args);
               Py_DECREF(className);
               return result;
             }
             PythonQtSignalReceiver* PythonQt::getSignalReceiver(QObject* obj)
             {
               PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
               if (!r) {
                 r = new PythonQtSignalReceiver(obj);
                 _p->_signalReceivers.insert(obj, r);
               }
               return r;
             }
             bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
             {
               bool flag = false;
               PythonQtObjectPtr callable = lookupCallable(module, objectname);
               if (callable) {
                 PythonQtSignalReceiver* r = getSignalReceiver(obj);
                 flag = r->addSignalHandler(signal, callable);
                 if (!flag) {
                   // signal not found
                 }
               } else {
                 // callable not found
               }
               return flag;
             }
             bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
             {
               bool flag = false;
               PythonQtSignalReceiver* r = getSignalReceiver(obj);
               if (r) {
                 flag = r->addSignalHandler(signal, receiver);
               }
               return flag;
             }
             bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
             {
               bool flag = false;
               PythonQtObjectPtr callable = lookupCallable(module, objectname);
               if (callable) {
                 PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
                 if (r) {
                   flag = r->removeSignalHandler(signal, callable);
                 }
               } else {
                 // callable not found
               }
               return flag;
             }
             bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
             {
               bool flag = false;
               PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
               if (r) {
                 flag = r->removeSignalHandler(signal, receiver);
               }
               return flag;
             }
             PythonQtObjectPtr PythonQt::lookupCallable(PyObject* module, const QString& name)
             {
               PythonQtObjectPtr p = lookupObject(module, name);
               if (p) {
                 if (PyCallable_Check(p)) {
                   return p;
                 }
               }
               PyErr_Clear();
               return NULL;
             }
             PythonQtObjectPtr PythonQt::lookupObject(PyObject* module, const QString& name)
             {
               QStringList l = name.split('.');
               PythonQtObjectPtr p = module;
               PythonQtObjectPtr prev;
               QByteArray b;
               for (QStringList::ConstIterator i = l.begin(); i!=l.end() && p; ++i) {
                 prev = p;
                 b = (*i).toLatin1();
                 if (PyDict_Check(p)) {
                   p = PyDict_GetItemString(p, b.data());
                 } else {
                   p.setNewRef(PyObject_GetAttrString(p, b.data()));
                 }
               }
               PyErr_Clear();
               return p;
             }
             PythonQtObjectPtr PythonQt::getMainModule() {
               //both borrowed
               PythonQtObjectPtr dict = PyImport_GetModuleDict();
               return PyDict_GetItemString(dict, "__main__");
             }
             PythonQtObjectPtr PythonQt::importModule(const QString& name)
             {
               PythonQtObjectPtr mod;
               mod.setNewRef(PyImport_ImportModule(name.toLatin1().constData()));
               return mod;
             }
             QVariant PythonQt::evalCode(PyObject* object, PyObject* pycode) {
               QVariant result;
               clearError();
               if (pycode) {
                 PyObject* dict = NULL;
                 PyObject* globals = NULL;
                 if (PyModule_Check(object)) {
                   dict = PyModule_GetDict(object);
                   globals = dict;
                 } else if (PyDict_Check(object)) {
                   dict = object;
                   globals = dict;
                 } else {
                   dict = PyObject_GetAttrString(object, "__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);
                   Py_DECREF(r);
                 } else {
                   handleError();
                 }
               } else {
                 handleError();
               }
               return result;
             }
             QVariant PythonQt::evalScript(PyObject* object, const QString& script, int start)
             {
               QVariant result;
               PythonQtObjectPtr p;
               PyObject* dict = NULL;
               clearError();
               if (PyModule_Check(object)) {
                 dict = PyModule_GetDict(object);
               } else if (PyDict_Check(object)) {
                 dict = object;
               }
               if (dict) {
                 p.setNewRef(PyRun_String(script.toLatin1().data(), start, dict, dict));
               }
               if (p) {
                 result = PythonQtConv::PyObjToQVariant(p);
               } else {
                 handleError();
               }
               return result;
             }
             void PythonQt::evalFile(PyObject* module, const QString& filename)
             {
               PythonQtObjectPtr code = parseFile(filename);
               clearError();
               if (code) {
                 evalCode(module, code);
               } else {
                 handleError();
               }
             }
             PythonQtObjectPtr PythonQt::parseFile(const QString& filename)
             {
               PythonQtObjectPtr p;
               p.setNewRef(PythonQtImport::getCodeFromPyc(filename));
               clearError();
               if (!p) {
                 handleError();
               }
               return p;
             }
             PythonQtObjectPtr PythonQt::createModuleFromFile(const QString& name, const QString& filename)
             {
               PythonQtObjectPtr code = parseFile(filename);
               PythonQtObjectPtr module = _p->createModule(name, code);
               return module;
             }
             PythonQtObjectPtr PythonQt::createModuleFromScript(const QString& name, const QString& script)
             {
               PyErr_Clear();
               QString scriptCode = script;
               if (scriptCode.isEmpty()) {
                 // we always need at least a linefeed
                 scriptCode = "\n";
               }
               PythonQtObjectPtr pycode;
               pycode.setNewRef(Py_CompileString((char*)scriptCode.toLatin1().data(), "",  Py_file_input));
               PythonQtObjectPtr module = _p->createModule(name, pycode);
               return module;
             }
             PythonQtObjectPtr PythonQt::createUniqueModule()
             {
               static QString pyQtStr("PythonQt_module");
               QString moduleName = pyQtStr+QString::number(_uniqueModuleCount++);
               return createModuleFromScript(moduleName);
             }
             void PythonQt::addObject(PyObject* object, const QString& name, QObject* qObject)
             {
               if (PyModule_Check(object)) {
                 PyModule_AddObject(object, name.toLatin1().data(), _p->wrapQObject(qObject));
               } else if (PyDict_Check(object)) {
                 PyDict_SetItemString(object, name.toLatin1().data(), _p->wrapQObject(qObject));
               } else {
                 PyObject_SetAttrString(object, name.toLatin1().data(), _p->wrapQObject(qObject));
               }
             }
             void PythonQt::addVariable(PyObject* object, const QString& name, const QVariant& v)
             {
               if (PyModule_Check(object)) {
                 PyModule_AddObject(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
               } else if (PyDict_Check(object)) {
                 PyDict_SetItemString(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
               } else {
                 PyObject_SetAttrString(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
               }
             }
             void PythonQt::removeVariable(PyObject* object, const QString& name)
             {
               if (PyDict_Check(object)) {
                 PyDict_DelItemString(object, name.toLatin1().data());
               } else {
                 PyObject_DelAttrString(object, name.toLatin1().data());
               }
             }
             QVariant PythonQt::getVariable(PyObject* object, const QString& objectname)
             {
               QVariant result;
               PythonQtObjectPtr obj = lookupObject(object, objectname);
               if (obj) {
                 result = PythonQtConv::PyObjToQVariant(obj);
               }
               return result;
             }
             QStringList PythonQt::introspection(PyObject* module, const QString& objectname, PythonQt::ObjectType type)
             {
               QStringList results;
               PythonQtObjectPtr object;
               if (objectname.isEmpty()) {
                 object = module;
               } else {
                 object = lookupObject(module, objectname);
                 if (!object && type == CallOverloads) {
                   PyObject* dict = lookupObject(module, "__builtins__");
                   if (dict) {
                     object = PyDict_GetItemString(dict, objectname.toLatin1().constData());
                   }
                 }
               }
               if (object) {
                 results = introspectObject(object, type);
               }
               return results;
             }
             QStringList PythonQt::introspectObject(PyObject* object, ObjectType type)
             {
               QStringList results;
               if (type == CallOverloads) {
                 if (PythonQtSlotFunction_Check(object)) {
                   PythonQtSlotFunctionObject* o = (PythonQtSlotFunctionObject*)object;
                   PythonQtSlotInfo* info = o->m_ml;
                   while (info) {
                     results << info->fullSignature();
                     info = info->nextInfo();
                   }
                 } else if (PythonQtSignalFunction_Check(object)) {
                   PythonQtSignalFunctionObject* o = (PythonQtSignalFunctionObject*)object;
                   PythonQtSlotInfo* info = o->m_ml;
                   while (info) {
                     results << info->fullSignature();
                     info = info->nextInfo();
                   }
                 } else if (object->ob_type == &PythonQtClassWrapper_Type) {
                   PythonQtClassWrapper* o = (PythonQtClassWrapper*)object;
                   PythonQtSlotInfo* info = o->classInfo()->constructors();
                   while (info) {
                     results << info->fullSignature();
                     info = info->nextInfo();
                   }
                 } else {
                   QString signature = _p->getSignature(object);
                   if (!signature.isEmpty()) {
                     results << signature;
                   } else {
                     PyObject* doc = PyObject_GetAttrString(object, "__doc__");
                     if (doc) {
             #ifdef PY3K
                       results << PyUnicode_AsUTF8(doc);
             #else
                       results << PyString_AsString(doc);
             #endif
                       Py_DECREF(doc);
                     }
                   }
                 }
               } else {
                 PyObject* keys = NULL;
                 bool isDict = false;
                 if (PyDict_Check(object)) {
                   keys = PyDict_Keys(object);
                   isDict = true;
                 } else {
                   keys = PyObject_Dir(object);
                 }
                 if (keys) {
                   int count = PyList_Size(keys);
                   PyObject* key;
                   PyObject* value;
                   QString keystr;
                   for (int i = 0;i<count;i++) {
                     key = PyList_GetItem(keys,i);
                     if (isDict) {
                       value = PyDict_GetItem(object, key);
                       Py_INCREF(value);
                     } else {
                       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) {
                       case Anything:
                         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 (
             #ifndef PY3K
                            value->ob_type != &PyClass_Type &&
             #endif
                            value->ob_type != &PyCFunction_Type &&
                            value->ob_type != &PyFunction_Type &&
                            value->ob_type != &PyMethod_Type &&
                            value->ob_type != &PyModule_Type &&
                            value->ob_type != &PyType_Type &&
                            value->ob_type != &PythonQtSlotFunction_Type
                           ) {
                           results << keystr;
                         }
                         break;
                       case Function:
                         if (value->ob_type == &PyCFunction_Type ||
                             value->ob_type == &PyFunction_Type ||
                             value->ob_type == &PyMethod_Type ||
                             value->ob_type == &PythonQtSlotFunction_Type
                           ) {
                           results << keystr;
                         }
                         break;
                       case Module:
                         if (value->ob_type == &PyModule_Type) {
                           results << keystr;
                         }
                         break;
                       default:
                         std::cerr << "PythonQt: introspection: unknown case" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
                       }
                     }
                     Py_DECREF(value);
                   }
                   Py_DECREF(keys);
                 }
                 if ((type == Anything) || (type == Variable)) {
                   if (object->ob_type == &PythonQtClassWrapper_Type) {
                     PythonQtClassWrapper* o = (PythonQtClassWrapper*)object;
                     PythonQtClassInfo* info = o->classInfo();
                     results += info->propertyList();
                   }
                 }
               }
               return results;
             }
             PyObject* PythonQt::getObjectByType(const QString& typeName)
             {
               PythonQtObjectPtr sys;
               sys.setNewRef(PyImport_ImportModule("sys"));
               PythonQtObjectPtr modules = lookupObject(sys, "modules");
               Q_ASSERT(PyDict_Check(modules));
               QStringList tmp = typeName.split(".");
               QString simpleTypeName = tmp.takeLast();
               QString moduleName = tmp.join(".");
               PyObject* object = NULL;
               PyObject* moduleObject = PyDict_GetItemString(modules, moduleName.toLatin1().constData());
               if (moduleObject) {
                 object = PyObject_GetAttrString(moduleObject, simpleTypeName.toLatin1().constData());
               }
               if (!object) {
                 moduleObject = PyDict_GetItemString(modules, "__builtin__");
                 if (moduleObject) {
                   object = PyObject_GetAttrString(moduleObject, simpleTypeName.toLatin1().constData());
                 }
               }
               return object;
             }
             QStringList PythonQt::introspectType(const QString& typeName, ObjectType type)
             {
               QStringList results;
               PyObject* object = getObjectByType(typeName);
               if (!object) {
                 // the last item may be a member, split it away and try again
                 QStringList tmp = typeName.split(".");
                 QString memberName = tmp.takeLast();
                 QString typeName;
                 if (tmp.isEmpty()) {
                   typeName = memberName;
                   memberName.clear();
                 } else {
                   typeName = tmp.takeLast();
                 }
                 PyObject* typeObject = getObjectByType(typeName);
                 if (typeObject) {
                   object = PyObject_GetAttrString(typeObject, memberName.toLatin1().constData());
                 }
               }
               if (object) {
                 results = introspectObject(object, type);
                 Py_DECREF(object);
               }
               return results;
             }
             QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args, const QVariantMap& kwargs)
             {
               PythonQtObjectPtr callable = lookupCallable(object, name);
               if (callable) {
                 return call(callable, args, kwargs);
               } else {
                 return QVariant();
               }
             }
             QVariant PythonQt::call(PyObject* callable, const QVariantList& args, const QVariantMap& kwargs)
             {
               QVariant r;
               PythonQtObjectPtr result;
               result.setNewRef(callAndReturnPyObject(callable, args, kwargs));
               clearError();
               if (result) {
                 r = PythonQtConv::PyObjToQVariant(result);
               } else {
                 PythonQt::self()->handleError();
               }
               return r;
             }
             PyObject* PythonQt::callAndReturnPyObject(PyObject* callable, const QVariantList& args, const QVariantMap& kwargs)
             {
               PyObject* result = NULL;
               if (callable) {
                 bool err = false;
                 PythonQtObjectPtr pargs;
                 int count = args.size();
                 if ((count > 0) || (kwargs.count() > 0)) { // create empty tuple if kwargs are given
                   pargs.setNewRef(PyTuple_New(count));
                   // transform QVariant arguments to Python
                   for (int i = 0; i < count; i++) {
                     PyObject* arg = PythonQtConv::QVariantToPyObject(args.at(i));
                     if (arg) {
                       // steals reference, no unref
                       PyTuple_SetItem(pargs, i,arg);
                     } else {
                       err = true;
                       break;
                     }
                   }
                 }
                 if (!err) {
                   if (kwargs.isEmpty()) {
                     // do a direct call if we have no keyword arguments
                     PyErr_Clear();
                     result = PyObject_CallObject(callable, pargs);
                   } else {
                     // convert keyword arguments to Python
                     PythonQtObjectPtr pkwargs;
                     pkwargs.setNewRef(PyDict_New());
                     QMapIterator<QString, QVariant> it(kwargs);
                     while (it.hasNext()) {
                       it.next();
                       PyObject* arg = PythonQtConv::QVariantToPyObject(it.value());
                       if (arg) {
                         PyDict_SetItemString(pkwargs, it.key().toLatin1().constData(), arg);
                       } else {
                         err = true;
                         break;
                       }
                     }
                     if (!err) {
                       // call with arguments and keyword arguments
                       PyErr_Clear();
                       result = PyObject_Call(callable, pargs, pkwargs);
                     }
                   }
                 }
               }
               return result;
             }
             void PythonQt::addInstanceDecorators(QObject* o)
             {
               _p->addDecorators(o, PythonQtPrivate::InstanceDecorator);
             }
             void PythonQt::addClassDecorators(QObject* o)
             {
               _p->addDecorators(o, PythonQtPrivate::StaticDecorator | PythonQtPrivate::ConstructorDecorator | PythonQtPrivate::DestructorDecorator);
             }
             void PythonQt::addDecorators(QObject* o)
             {
               _p->addDecorators(o, PythonQtPrivate::AllDecorators);
             }
             void PythonQt::registerQObjectClassNames(const QStringList& names)
             {
               _p->registerQObjectClassNames(names);
             }
             void PythonQt::setImporter(PythonQtImportFileInterface* importInterface)
             {
               _p->_importInterface = importInterface;
               PythonQtImport::init();
             }
             void PythonQt::setImporterIgnorePaths(const QStringList& paths)
             {
               _p->_importIgnorePaths = paths;
             }
             const QStringList& PythonQt::getImporterIgnorePaths()
             {
               return _p->_importIgnorePaths;
             }
             void PythonQt::addWrapperFactory(PythonQtCppWrapperFactory* factory)
             {
               _p->_cppWrapperFactories.append(factory);
             }
             void PythonQt::addWrapperFactory( PythonQtForeignWrapperFactory* factory )
             {
               _p->_foreignWrapperFactories.append(factory);
             }
             //---------------------------------------------------------------------------------------------------
             PythonQtPrivate::PythonQtPrivate()
             {
               _importInterface = NULL;
               _defaultImporter = new PythonQtQFileImporter;
               _noLongerWrappedCB = NULL;
               _wrappedCB = NULL;
               _currentClassInfoForClassWrapperCreation = NULL;
               _profilingCB = NULL;
               _hadError = false;
               _systemExitExceptionHandlerEnabled = false;
             }
             void PythonQtPrivate::setupSharedLibrarySuffixes()
             {
               _sharedLibrarySuffixes.clear();
               PythonQtObjectPtr imp;
               imp.setNewRef(PyImport_ImportModule("imp"));
               int cExtensionCode = imp.getVariable("C_EXTENSION").toInt();
               QVariant result = imp.call("get_suffixes");
             #ifdef __linux
               #ifdef _DEBUG
               // First look for shared libraries with the '_d' suffix in debug mode on Linux.
               // This is a workaround, because python does not append the '_d' suffix on Linux
               // and would always load the release library otherwise.
               _sharedLibrarySuffixes << "_d.so";
               #endif
             #endif
               Q_FOREACH (QVariant entry, result.toList()) {
                 QVariantList suffixEntry = entry.toList();
                 if (suffixEntry.count()==3) {
                   int code = suffixEntry.at(2).toInt();
                   if (code == cExtensionCode) {
                     _sharedLibrarySuffixes << suffixEntry.at(0).toString();
                   }
                 }
               }
             }
             PythonQtClassInfo* PythonQtPrivate::currentClassInfoForClassWrapperCreation()
             {
               PythonQtClassInfo* info = _currentClassInfoForClassWrapperCreation;
               _currentClassInfoForClassWrapperCreation = NULL;
               return info;
             }
             void PythonQtPrivate::addDecorators(QObject* o, int decoTypes)
             {
               o->setParent(this);
               int numMethods = o->metaObject()->methodCount();
               for (int i = 0; i < numMethods; i++) {
                 QMetaMethod m = o->metaObject()->method(i);
                 if ((m.methodType() == QMetaMethod::Method ||
                   m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
             // QMetaMethod::signature changed to QMetaMethod::methodSignature in QT5
             #if( QT_VERSION >= QT_VERSION_CHECK(5,0,0) )
                     QByteArray signature = m.methodSignature();
             #else
                     QByteArray signature = m.signature();
             #endif
                   if (signature.startsWith("new_")) {
                     if ((decoTypes & ConstructorDecorator) == 0) continue;
                     const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                     if (info->parameters().at(0).pointerCount == 1) {
                       QByteArray nameOfClass = signature.mid(4, signature.indexOf('(')-4);
                       PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
                       PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                       classInfo->addConstructor(newSlot);
                     }
                   } else if (signature.startsWith("delete_")) {
                     if ((decoTypes & DestructorDecorator) == 0) continue;
                     QByteArray nameOfClass = signature.mid(7, signature.indexOf('(')-7);
                     PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
                     PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                     classInfo->setDestructor(newSlot);
                   } else if (signature.startsWith("static_")) {
                     if ((decoTypes & StaticDecorator) == 0) continue;
                     QByteArray nameOfClass = signature.mid(7);
                     nameOfClass = nameOfClass.mid(0, nameOfClass.indexOf('_'));
                     PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
                     PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                     classInfo->addDecoratorSlot(newSlot);
                   } else {
                     if ((decoTypes & InstanceDecorator) == 0) continue;
                     const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                     if (info->parameters().count()>1) {
                       PythonQtMethodInfo::ParameterInfo p = info->parameters().at(1);
                       if (p.pointerCount==1) {
                         PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(p.name);
                         PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::InstanceDecorator);
                         classInfo->addDecoratorSlot(newSlot);
                       }
                     }
                   }
                 }
               }
             }
             void PythonQtPrivate::registerQObjectClassNames(const QStringList& names)
             {
               Q_FOREACH(QString name, names) {
                 _knownQObjectClassNames.insert(name.toLatin1(), true);
               }
             }
             void PythonQtPrivate::removeSignalEmitter(QObject* obj)
             {
               _signalReceivers.remove(obj);
             }
             namespace
             {
             //! adapted from python source file "pythonrun.c", function "handle_system_exit"
             //! return the exitcode instead of calling "Py_Exit".
             //! it gives the application an opportunity to properly terminate.
             int custom_system_exit_exception_handler()
             {
               PyObject *exception, *value, *tb;
               int exitcode = 0;
             //  if (Py_InspectFlag)
             //    /* Don't exit if -i flag was given. This flag is set to 0
             //     * when entering interactive mode for inspecting. */
             //    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 (PyExceptionInstance_Check(value)) {
                 /* The error code should be in the `code' attribute. */
                 PyObject *code = PyObject_GetAttrString(value, "code");
                 if (code) {
                   Py_DECREF(value);
                   value = code;
                   if (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) {
                   PyFile_WriteObject(value, sys_stderr, Py_PRINT_RAW);
                 } else {
                   PyObject_Print(value, stderr, Py_PRINT_RAW);
                   fflush(stderr);
                 }
                 PySys_WriteStderr("\n");
                 exitcode = 1;
               }
               done:
                 /* Restore and clear the exception info, in order to properly decref
                  * the exception, value, and traceback.      If we just exit instead,
                  * these leak, which confuses PYTHONDUMPREFS output, and may prevent
                  * some finalizers from running.
                  */
                 PyErr_Restore(exception, value, tb);
                 PyErr_Clear();
                 return exitcode;
                 //Py_Exit(exitcode);
             }
             }
             bool PythonQt::handleError()
             {
               bool flag = false;
               if (PyErr_Occurred()) {
                 if (_p->_systemExitExceptionHandlerEnabled &&
                     PyErr_ExceptionMatches(PyExc_SystemExit)) {
                   int exitcode = custom_system_exit_exception_handler();
                   Q_EMIT PythonQt::self()->systemExitExceptionRaised(exitcode);
                   }
                 else
                   {
                   // currently we just print the error and the stderr handler parses the errors
                   PyErr_Print();
                   /*
                   // EXTRA: the format of the ptype and ptraceback is not really documented, so I use PyErr_Print() above
                   PyObject *ptype;
                   PyObject *pvalue;
                   PyObject *ptraceback;
                   PyErr_Fetch( &ptype, &pvalue, &ptraceback);
                     Py_XDECREF(ptype);
                     Py_XDECREF(pvalue);
                     Py_XDECREF(ptraceback);
                   */
                   PyErr_Clear();
                   }
                 flag = true;
               }
               _p->_hadError = flag;
               return flag;
             }
             bool PythonQt::hadError()const
             {
               return _p->_hadError;
             }
             void PythonQt::clearError()
             {
               _p->_hadError = false;
             }
             void PythonQt::setSystemExitExceptionHandlerEnabled(bool value)
             {
               _p->_systemExitExceptionHandlerEnabled = value;
             }
             bool PythonQt::systemExitExceptionHandlerEnabled() const
             {
               return _p->_systemExitExceptionHandlerEnabled;
             }
             void PythonQt::addSysPath(const QString& path)
             {
               PythonQtObjectPtr sys;
               sys.setNewRef(PyImport_ImportModule("sys"));
               PythonQtObjectPtr obj = lookupObject(sys, "path");
               PyList_Insert(obj, 0, PythonQtConv::QStringToPyObject(path));
             }
             void PythonQt::overwriteSysPath(const QStringList& paths)
             {
               PythonQtObjectPtr sys;
               sys.setNewRef(PyImport_ImportModule("sys"));
               PyModule_AddObject(sys, "path", PythonQtConv::QStringListToPyList(paths));
             }
             void PythonQt::setModuleImportPath(PyObject* module, const QStringList& paths)
             {
               PyModule_AddObject(module, "__path__", PythonQtConv::QStringListToPyList(paths));
             }
             void PythonQt::stdOutRedirectCB(const QString& str)
             {
               if (!PythonQt::self()) {
                 std::cout << str.toLatin1().data() << std::endl;
                 return;
               }
               Q_EMIT PythonQt::self()->pythonStdOut(str);
             }
             void PythonQt::stdErrRedirectCB(const QString& str)
             {
               if (!PythonQt::self()) {
                 std::cerr << str.toLatin1().data() << std::endl;
                 return;
               }
               Q_EMIT PythonQt::self()->pythonStdErr(str);
             }
             void PythonQt::setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb)
             {
               _p->_wrappedCB = cb;
             }
             void PythonQt::setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb)
             {
               _p->_noLongerWrappedCB = cb;
             }
             void PythonQt::setProfilingCallback(ProfilingCB* cb)
             {
               _p->_profilingCB = cb;
             }
             static PyMethodDef PythonQtMethods[] = {
               {NULL, NULL, 0, NULL}
             };
             #ifdef PY3K
-            static PyModuleDef PythonQtModule = {
+            static PyModuleDef PythonQtModuleDef = {
               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();
+              PythonQtModuleDef.m_name = name.constData();
-              _p->_pythonQtModule = PyModule_Create(&PythonQtModule);
+              _p->_pythonQtModule = PyModule_Create(&PythonQtModuleDef);
             #else
               _p->_pythonQtModule = Py_InitModule(name.constData(), PythonQtMethods);
             #endif
               _p->_pythonQtModuleName = name;
-              if (redirectStdOut) {
               PythonQtObjectPtr sys;
+              sys.setNewRef(PyImport_ImportModule("sys"));
+              if (redirectStdOut) {
                 PythonQtObjectPtr out;
                 PythonQtObjectPtr err;
-                sys.setNewRef(PyImport_ImportModule("sys"));
                 // create a redirection object for stdout and stderr
                 out = PythonQtStdOutRedirectType.tp_new(&PythonQtStdOutRedirectType,NULL, NULL);
                 ((PythonQtStdOutRedirect*)out.object())->_cb = stdOutRedirectCB;
                 err = PythonQtStdOutRedirectType.tp_new(&PythonQtStdOutRedirectType,NULL, NULL);
                 ((PythonQtStdOutRedirect*)err.object())->_cb = stdErrRedirectCB;
                 // replace the built in file objects with our own objects
                 PyModule_AddObject(sys, "stdout", out);
                 PyModule_AddObject(sys, "stderr", err);
               }
               // add PythonQt to the list of builtin module names
-              PythonQtObjectPtr sys;
-              sys.setNewRef(PyImport_ImportModule("sys"));
               PyObject *old_module_names = PyObject_GetAttrString(sys.object(),"builtin_module_names");
               Py_ssize_t old_size = PyTuple_Size(old_module_names);
               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);
+            #ifdef PY3K
+              PyDict_SetItem(PyObject_GetAttrString(sys.object(), "modules"), PyUnicode_FromString(name.constData()), _p->_pythonQtModule.object());
+            #endif
             }
             QString PythonQt::getReturnTypeOfWrappedMethod(PyObject* module, const QString& name)
             {
               QStringList tmp = name.split(".");
               QString methodName = tmp.takeLast();
               QString variableName = tmp.join(".");
               // TODO: the variableName may be a type name, this needs to be handled differently,
               // because it is not necessarily known in the module context
               PythonQtObjectPtr variableObject = lookupObject(module, variableName);
               if (variableObject.isNull()) {
                 return "";
               }
               return getReturnTypeOfWrappedMethodHelper(variableObject, methodName, name);
             }
             QString PythonQt::getReturnTypeOfWrappedMethod(const QString& typeName, const QString& methodName)
             {
               PythonQtObjectPtr typeObject = getObjectByType(typeName);
               if (typeObject.isNull()) {
                 return "";
               }
               return getReturnTypeOfWrappedMethodHelper(typeObject, methodName, typeName + "." + methodName);
             }
             QString PythonQt::getReturnTypeOfWrappedMethodHelper(const PythonQtObjectPtr& variableObject, const QString& methodName, const QString& context)
             {
               PythonQtObjectPtr methodObject;
               if (PyDict_Check(variableObject)) {
                 methodObject = PyDict_GetItemString(variableObject, methodName.toLatin1().constData());
               } else {
                 methodObject.setNewRef(PyObject_GetAttrString(variableObject, methodName.toLatin1().constData()));
               }
               if (methodObject.isNull()) {
                 return "";
               }
               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 if (methodObject->ob_type == &PythonQtSlotFunction_Type) {
                 QString className;
                 if (PyObject_TypeCheck(variableObject, &PythonQtInstanceWrapper_Type)) {
                   // the type name of wrapped instance is the class name
                   className = variableObject->ob_type->tp_name;
                 } 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);
                   }
                 }
                 if (!className.isEmpty()) {
                   PythonQtClassInfo* info = _p->_knownClassInfos.value(className.toLatin1().constData());
                   if (info) {
                     PythonQtSlotInfo* slotInfo = info->member(methodName.toLatin1().constData())._slot;
                     if (slotInfo) {
                       if (slotInfo->metaMethod()) {
                         type = slotInfo->metaMethod()->typeName();
                         if (!type.isEmpty()) {
                           QChar c = type.at(type.length()-1);
                           while (c == '*' || c == '&') {
                             type.truncate(type.length()-1);
                             if (!type.isEmpty()) {
                               c = type.at(type.length()-1);
                             } else {
                               break;
                             }
                           }
                           // split away template arguments
                           type = type.split("<").first();
                           // split away const
                           type = type.split(" ").last().trimmed();
                           // if the type is a known class info, then create the full type name, i.e. include the
                           // module name. For example, the slot may return a QDate, then this looks up the
                           // name _PythonQt.QtCore.QDate.
                           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);
                           }
                         }
                       }
                     }
                   }
                 }
               }
               return type;
             }
             void PythonQt::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator,  PythonQtShellSetInstanceWrapperCB* shell)
             {
               _p->registerCPPClass(typeName, parentTypeName, package, wrapperCreator, shell);
             }
             PythonQtClassInfo* PythonQtPrivate::lookupClassInfoAndCreateIfNotPresent(const char* typeName)
             {
               PythonQtClassInfo* info = _knownClassInfos.value(typeName);
               if (!info) {
                 info = new PythonQtClassInfo();
                 info->setupCPPObject(typeName);
                 _knownClassInfos.insert(typeName, info);
               }
               return info;
             }
             void PythonQt::addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb)
             {
               _p->addPolymorphicHandler(typeName, cb);
             }
             void PythonQtPrivate::addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb)
             {
               PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(typeName);
               info->addPolymorphicHandler(cb);
             }
             bool PythonQt::addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset)
             {
               return _p->addParentClass(typeName, parentTypeName, upcastingOffset);
             }
             bool PythonQtPrivate::addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset)
             {
               PythonQtClassInfo* info = _knownClassInfos.value(typeName);
               if (info) {
                 PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(parentTypeName);
                 info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo, upcastingOffset));
                 return true;
               } else {
                 return false;
               }
             }
             void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator,  PythonQtShellSetInstanceWrapperCB* shell, PyObject* module, int typeSlots)
             {
               PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(typeName);
               if (!info->pythonQtClassWrapper()) {
                 info->setTypeSlots(typeSlots);
                 info->setupCPPObject(typeName);
                 createPythonQtClassWrapper(info, package, module);
               }
               if (parentTypeName && strcmp(parentTypeName,"")!=0) {
                 addParentClass(typeName, parentTypeName, 0);
               }
               if (wrapperCreator) {
                 info->setDecoratorProvider(wrapperCreator);
               }
               if (shell) {
                 info->setShellSetInstanceWrapperCB(shell);
               }
             }
             PyObject* PythonQtPrivate::packageByName(const char* name)
             {
               if (name==NULL || name[0]==0) {
                 name = "private";
               }
               PyObject* v = _packages.value(name);
               if (!v) {
                 v = PyImport_AddModule((_pythonQtModuleName + "." + name).constData());
                 _packages.insert(name, v);
                 // AddObject steals the reference, so increment it!
                 Py_INCREF(v);
                 PyModule_AddObject(_pythonQtModule, name, v);
               }
               return v;
             }
             void PythonQtPrivate::handleVirtualOverloadReturnError(const char* signature, const PythonQtMethodInfo* methodInfo, PyObject* result)
             {
               QString error = "Return value '" + PythonQtConv::PyObjGetString(result) + "' can not be converted to expected C++ type '" + methodInfo->parameters().at(0).name + "' as return value of virtual method " + signature;
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               PythonQt::self()->handleError();
             }
             PyObject* PythonQt::helpCalled(PythonQtClassInfo* info)
             {
               if (_p->_initFlags & ExternalHelp) {
                 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
               }
             }
             void PythonQt::clearNotFoundCachedMembers()
             {
               Q_FOREACH(PythonQtClassInfo* info, _p->_knownClassInfos) {
                 info->clearNotFoundCachedMembers();
               }
             }
             void PythonQt::removeWrapperFactory( PythonQtCppWrapperFactory* factory )
             {
               _p->_cppWrapperFactories.removeAll(factory);
             }
             void PythonQt::removeWrapperFactory( PythonQtForeignWrapperFactory* factory )
             {
               _p->_foreignWrapperFactories.removeAll(factory);
             }
             void PythonQtPrivate::removeWrapperPointer(void* obj)
             {
               _wrappedObjects.remove(obj);
             }
             void PythonQtPrivate::addWrapperPointer(void* obj, PythonQtInstanceWrapper* wrapper)
             {
               _wrappedObjects.insert(obj, wrapper);
             }
             PythonQtInstanceWrapper* PythonQtPrivate::findWrapperAndRemoveUnused(void* obj)
             {
               PythonQtInstanceWrapper* wrap = _wrappedObjects.value(obj);
               if (wrap && !wrap->_wrappedPtr && wrap->_obj == NULL) {
                 // this is a wrapper whose QObject was already removed due to destruction
                 // so the obj pointer has to be a new QObject with the same address...
                 // we remove the old one and set the copy to NULL
                 wrap->_objPointerCopy = NULL;
                 removeWrapperPointer(obj);
                 wrap = NULL;
               }
               return wrap;
             }
             PythonQtObjectPtr PythonQtPrivate::createModule(const QString& name, PyObject* pycode)
             {
               PythonQtObjectPtr result;
               PythonQt::self()->clearError();
               if (pycode) {
                 result.setNewRef(PyImport_ExecCodeModule((char*)name.toLatin1().data(), pycode));
               } else {
                 PythonQt::self()->handleError();
               }
               return result;
             }
             void* PythonQtPrivate::unwrapForeignWrapper( const QByteArray& classname, PyObject* obj )
             {
               void* foreignObject = NULL;
               for (int i=0; i<_foreignWrapperFactories.size(); i++) {
                 foreignObject = _foreignWrapperFactories.at(i)->unwrap(classname, obj);
                 if (foreignObject) {
                   return foreignObject;
                 }
               }
               return NULL;
             }
             bool PythonQtPrivate::isMethodDescriptor(PyObject* object) const
             {
               // This implementation is the same as in inspect.ismethoddescriptor(), inspect.py.
               if (PyObject_HasAttrString(object, "__get__") &&
                   !PyObject_HasAttrString(object, "__set__") &&
                   !PyMethod_Check(object) &&
                   !PyFunction_Check(object)
             #ifndef PY3K
                   && !PyClass_Check(object)
             #endif
                   ) {
                 return true;
               }
               return false;
             }
             QString PythonQtPrivate::getSignature(PyObject* object)
             {
               QString signature;
               if (object) {
                 PyMethodObject* method = NULL;
                 PyFunctionObject* func = NULL;
                 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) {
                   func = (PyFunctionObject*)object;
                 } else if (object->ob_type == &PyMethod_Type) {
                   method = (PyMethodObject*)object;
                 }
                 if (method)  {
                   if (PyFunction_Check(method->im_func)) {
                     func = (PyFunctionObject*)method->im_func;
                   } else if (isMethodDescriptor((PyObject*)method)) {
                     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 {
                         signature += "(...)";
                         if (!docstr.isEmpty()) {
                           signature += "\n\n" + docstr;
                         }
                       }
                       Py_DECREF(s);
                     }
                   }
                 }
                 if (func) {
                   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);
                     }
                   }
                   QStringList arguments;
                   QStringList defaults;
                   QString varargs;
                   QString varkeywords;
                   // NOTE: This implementation is based on function getargs() in inspect.py.
                   //       inspect.getargs() can handle anonymous (tuple) arguments, while this code does not.
                   //       It can be implemented, but it may be rarely needed and not necessary.
                   PyCodeObject* code = (PyCodeObject*)func->func_code;
                   if (code->co_varnames) {
                     int nargs = code->co_argcount;
                     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
                     }
                   }
                   PyObject* defaultsTuple = func->func_defaults;
                   if (defaultsTuple) {
                     Q_ASSERT(PyTuple_Check(defaultsTuple));
                     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);
                     }
                   }
                   int firstdefault = arguments.size() - defaults.size();
                   for (int i=0; i<arguments.size(); i++) {
                     if (!signature.isEmpty()) { signature += ", "; }
                     if (!method || i>0 || arguments[i] != "self") {
                       signature += arguments[i];
                       if (i >= firstdefault) {
                         signature += "=" + defaults[i-firstdefault];
                       }
                     }
                   }
                   if (!varargs.isEmpty()) {
                     if (!signature.isEmpty()) { signature += ", "; }
                     signature += "*" + varargs;
                   }
                   if (!varkeywords.isEmpty()) {
                     if (!signature.isEmpty()) { signature += ", "; }
                     signature += "**" + varkeywords;
                   }
                   signature = funcName + "(" + signature + ")";
                 }
                 if (method && decrefMethod) {
                   Py_DECREF(method);
                 }
               }
               return signature;
             }
             void PythonQtPrivate::shellClassDeleted( void* shellClass )
             {
               PythonQtInstanceWrapper* wrap = _wrappedObjects.value(shellClass);
               if (wrap && wrap->_wrappedPtr) {
                 // this is a pure C++ wrapper and the shell has gone, so we need
                 // to set the _wrappedPtr to NULL on the wrapper
                 wrap->_wrappedPtr = NULL;
                 // and then we remove the wrapper, since the wrapped class is gone
                 _wrappedObjects.remove(shellClass);
               }
               // if the wrapper is a QObject, we do not handle this here,
               // it will be handled by the QPointer<> to the QObject, which becomes NULL
               // via the QObject destructor.
             }
             PyObject* PythonQtPrivate::wrapMemoryAsBuffer( const void* data, Py_ssize_t size )
             {
               // P3K port needed later on! -- not anymore :D
             #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! -- not anymore :D
             #ifdef PY3K
               return PyMemoryView_FromMemory((char*)data, size, PyBUF_READ | PyBUF_WRITE);
             #else
               return PyBuffer_FromReadWriteMemory((char*)data, size);
             #endif
             }

src/PythonQtClassWrapper.cpp +5 -5

             /*
              *
              *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
              *
              *  This library is free software; you can redistribute it and/or
              *  modify it under the terms of the GNU Lesser General Public
              *  License as published by the Free Software Foundation; either
              *  version 2.1 of the License, or (at your option) any later version.
              *
              *  This library is distributed in the hope that it will be useful,
              *  but WITHOUT ANY WARRANTY; without even the implied warranty of
              *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
              *  Lesser General Public License for more details.
              *
              *  Further, this software is distributed without any warranty that it is
              *  free of the rightful claim of any third person regarding infringement
              *  or the like.  Any license provided herein, whether implied or
              *  otherwise, applies only to this software file.  Patent licenses, if
              *  any, provided herein do not apply to combinations of this program with
              *  other software, or any other product whatsoever.
              *
              *  You should have received a copy of the GNU Lesser General Public
              *  License along with this library; if not, write to the Free Software
              *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              *
              *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
              *  28359 Bremen, Germany or:
              *
              *  http://www.mevis.de
              *
              */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtClassWrapper.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtClassWrapper.h"
             #include <QObject>
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtSignal.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtConversion.h"
             #include "PythonQtInstanceWrapper.h"
             static PyObject* PythonQtInstanceWrapper_invert(PythonQtInstanceWrapper* wrapper)
             {
               PyObject* result = NULL;
               static QByteArray memberName = "__invert__";
               PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);
               if (opSlot._type == PythonQtMemberInfo::Slot) {
                 result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, NULL, NULL, wrapper->_wrappedPtr);
               }
               return result;
             }
             static int PythonQtInstanceWrapper_nonzero(PythonQtInstanceWrapper* wrapper)
             {
               int result = (wrapper->_wrappedPtr == NULL && wrapper->_obj == NULL)?0:1;
               if (result) {
                 static QByteArray memberName = "__nonzero__";
                 PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);
                 if (opSlot._type == PythonQtMemberInfo::Slot) {
                   PyObject* resultObj = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, NULL, NULL, wrapper->_wrappedPtr);
                   if (resultObj == Py_False) {
                     result = 0;
                   }
                   Py_XDECREF(resultObj);
                 }
               }
               return result;
             }
             static PyObject* PythonQtInstanceWrapper_binaryfunc(PyObject* self, PyObject* other, const QByteArray& opName, const QByteArray& fallbackOpName = QByteArray())
             {
               // since we disabled type checking, we can receive any object as self, but we currently only support
               // different objects on the right. Otherwise we would need to generate __radd__ etc. methods.
               if (!PyObject_TypeCheck(self, &PythonQtInstanceWrapper_Type)) {
                 QString error = "Unsupported operation " + opName + "(" + self->ob_type->tp_name + ", " +  other->ob_type->tp_name + ")";
                 PyErr_SetString(PyExc_ArithmeticError, error.toLatin1().data());
                 return NULL;
               }
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)self;
               PyObject* result = NULL;
               PythonQtMemberInfo opSlot = wrapper->classInfo()->member(opName);
               if (opSlot._type == PythonQtMemberInfo::Slot) {
                 // TODO get rid of tuple
                 PyObject* args = PyTuple_New(1);
                 Py_INCREF(other);
                 PyTuple_SET_ITEM(args, 0, other);
                 result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, args, NULL, wrapper->_wrappedPtr);
                 Py_DECREF(args);
                 if (!result && !fallbackOpName.isEmpty()) {
                   // try fallback if we did not get a result
                   result = PythonQtInstanceWrapper_binaryfunc(self, other, fallbackOpName);
                 }
               }
               return result;
             }
             #define BINARY_OP(NAME) \
             static PyObject* PythonQtInstanceWrapper_ ## NAME(PyObject* self, PyObject* other) \
             { \
               static const QByteArray opName("__" #NAME "__"); \
               return PythonQtInstanceWrapper_binaryfunc(self, other, opName); \
             }
             #define BINARY_OP_INPLACE(NAME) \
               static PyObject* PythonQtInstanceWrapper_i ## NAME(PyObject* self, PyObject* other) \
             { \
               static const QByteArray opName("__i" #NAME "__"); \
               static const QByteArray fallbackName("__" #NAME "__"); \
               return PythonQtInstanceWrapper_binaryfunc(self, other, opName, fallbackName); \
             }
             BINARY_OP(add)
             BINARY_OP(sub)
             BINARY_OP(mul)
             BINARY_OP(div)
             BINARY_OP(and)
             BINARY_OP(or)
             BINARY_OP(xor)
             BINARY_OP(mod)
             BINARY_OP(lshift)
             BINARY_OP(rshift)
             BINARY_OP_INPLACE(add)
             BINARY_OP_INPLACE(sub)
             BINARY_OP_INPLACE(mul)
             BINARY_OP_INPLACE(div)
             BINARY_OP_INPLACE(and)
             BINARY_OP_INPLACE(or)
             BINARY_OP_INPLACE(xor)
             BINARY_OP_INPLACE(mod)
             BINARY_OP_INPLACE(lshift)
             BINARY_OP_INPLACE(rshift)
             static void initializeSlots(PythonQtClassWrapper* wrap)
             {
               int typeSlots = wrap->classInfo()->typeSlots();
               if (typeSlots) {
                 if (typeSlots & PythonQt::Type_Add) {
                   wrap->_base.as_number.nb_add = (binaryfunc)PythonQtInstanceWrapper_add;
                 }
                 if (typeSlots & PythonQt::Type_Subtract) {
                   wrap->_base.as_number.nb_subtract = (binaryfunc)PythonQtInstanceWrapper_sub;
                 }
                 if (typeSlots & PythonQt::Type_Multiply) {
                   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_and = (binaryfunc)PythonQtInstanceWrapper_and;
                 }
                 if (typeSlots & PythonQt::Type_Or) {
                   wrap->_base.as_number.nb_or = (binaryfunc)PythonQtInstanceWrapper_or;
                 }
                 if (typeSlots & PythonQt::Type_Xor) {
                   wrap->_base.as_number.nb_xor = (binaryfunc)PythonQtInstanceWrapper_xor;
                 }
                 if (typeSlots & PythonQt::Type_Mod) {
                   wrap->_base.as_number.nb_remainder = (binaryfunc)PythonQtInstanceWrapper_mod;
                 }
                 if (typeSlots & PythonQt::Type_LShift) {
                   wrap->_base.as_number.nb_lshift = (binaryfunc)PythonQtInstanceWrapper_lshift;
                 }
                 if (typeSlots & PythonQt::Type_RShift) {
                   wrap->_base.as_number.nb_rshift = (binaryfunc)PythonQtInstanceWrapper_rshift;
                 }
                 if (typeSlots & PythonQt::Type_InplaceAdd) {
                   wrap->_base.as_number.nb_add = (binaryfunc)PythonQtInstanceWrapper_iadd;
                 }
                 if (typeSlots & PythonQt::Type_InplaceSubtract) {
                   wrap->_base.as_number.nb_subtract = (binaryfunc)PythonQtInstanceWrapper_isub;
                 }
                 if (typeSlots & PythonQt::Type_InplaceMultiply) {
                   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_inplace_and = (binaryfunc)PythonQtInstanceWrapper_iand;
                 }
                 if (typeSlots & PythonQt::Type_InplaceOr) {
                   wrap->_base.as_number.nb_inplace_or = (binaryfunc)PythonQtInstanceWrapper_ior;
                 }
                 if (typeSlots & PythonQt::Type_InplaceXor) {
                   wrap->_base.as_number.nb_inplace_xor = (binaryfunc)PythonQtInstanceWrapper_ixor;
                 }
                 if (typeSlots & PythonQt::Type_InplaceMod) {
                   wrap->_base.as_number.nb_inplace_remainder = (binaryfunc)PythonQtInstanceWrapper_imod;
                 }
                 if (typeSlots & PythonQt::Type_InplaceLShift) {
                   wrap->_base.as_number.nb_inplace_lshift = (binaryfunc)PythonQtInstanceWrapper_ilshift;
                 }
                 if (typeSlots & PythonQt::Type_InplaceRShift) {
                   wrap->_base.as_number.nb_inplace_rshift = (binaryfunc)PythonQtInstanceWrapper_irshift;
                 }
                 if (typeSlots & PythonQt::Type_Invert) {
                   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
                 }
               }
             }
             static PyObject* PythonQtClassWrapper_alloc(PyTypeObject *self, Py_ssize_t nitems)
             {
               // call the default type alloc
               PyObject* obj = PyType_Type.tp_alloc(self, nitems);
               // take current class type, if we are called via newPythonQtClassWrapper()
               PythonQtClassWrapper* wrap = (PythonQtClassWrapper*)obj;
               wrap->_classInfo = PythonQt::priv()->currentClassInfoForClassWrapperCreation();
               if (wrap->_classInfo) {
                 initializeSlots(wrap);
               }
               return obj;
             }
             static int PythonQtClassWrapper_init(PythonQtClassWrapper* self, PyObject* args, PyObject* kwds)
             {
               // call the default type init
               if (PyType_Type.tp_init((PyObject *)self, args, kwds) < 0) {
                 return -1;
               }
               // if we have no CPP class information, try our base class
               if (!self->classInfo()) {
                 PyTypeObject*  superType = ((PyTypeObject *)self)->tp_base;
                 // recursively search for PythonQtClassWrapper superclass,
                 // this is needed for multiple levels of inheritance in python,
                 // e.g.
                 // class MyWidgetBase(QWidget):
                 //  ...
                 // class MyWidget(MyWidgetBase):
                 //  ...
                 while( superType && Py_TYPE(superType) != &PythonQtClassWrapper_Type )
                     superType = superType->tp_base;
                 if (!superType || (Py_TYPE(superType) != &PythonQtClassWrapper_Type)) {
                   PyErr_Format(PyExc_TypeError, "type %s is not derived from PythonQtClassWrapper", ((PyTypeObject*)self)->tp_name);
                   return -1;
                 }
                 // take the class info from the superType
                 self->_classInfo = ((PythonQtClassWrapper*)superType)->classInfo();
               }
               return 0;
             }
             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)
             {
               return PythonQt::self()->helpCalled(type->classInfo());
             }
             PyObject *PythonQtClassWrapper_delete(PythonQtClassWrapper *type, PyObject *args)
             {
               Q_UNUSED(type);
               Py_ssize_t argc = PyTuple_Size(args);
               if (argc>0) {
                 PyObject* self = PyTuple_GET_ITEM(args, 0);
                 if (PyObject_TypeCheck(self, &PythonQtInstanceWrapper_Type)) {
                   return PythonQtInstanceWrapper_delete((PythonQtInstanceWrapper*)self);
                 }
               }
               return NULL;
             }
             PyObject *PythonQtClassWrapper_inherits(PythonQtClassWrapper *type, PyObject *args)
             {
               Q_UNUSED(type);
               PythonQtInstanceWrapper* wrapper = NULL;
               char *name = NULL;
               if (!PyArg_ParseTuple(args, "O!s:PythonQtClassWrapper.inherits",&PythonQtInstanceWrapper_Type, &wrapper, &name)) {
                 return NULL;
               }
               return PythonQtConv::GetPyBool(wrapper->classInfo()->inherits(name));
             }
             static PyMethodDef PythonQtClassWrapper_methods[] = {
                 {"className", (PyCFunction)PythonQtClassWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
                 {"inherits", (PyCFunction)PythonQtClassWrapper_inherits, METH_VARARGS,
                 "Returns if the class inherits or is of given type name"
                 },
                 {"help", (PyCFunction)PythonQtClassWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
                 {"delete", (PyCFunction)PythonQtClassWrapper_delete, METH_VARARGS,
                 "Deletes the given C++ object"
                 },
                 {NULL, NULL, 0 , NULL}  /* Sentinel */
             };
             static PyObject *PythonQtClassWrapper_getattro(PyObject *obj, PyObject *name)
             {
               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) {
                 return NULL;
               }
               if (qstrcmp(attributeName, "__dict__")==0) {
                 PyObject* objectDict  = ((PyTypeObject *)wrapper)->tp_dict;
                 if (!wrapper->classInfo()) {
                   Py_INCREF(objectDict);
                   return objectDict;
                 }
                 PyObject* dict = PyDict_New();
                 QStringList l = wrapper->classInfo()->memberList();
                 Q_FOREACH (QString name, l) {
                   PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
                   if (o) {
                     PyDict_SetItemString(dict, name.toLatin1().data(), o);
                     Py_DECREF(o);
                   } else {
                     // it must have been a property or child, which we do not know as a class object...
                     PyErr_Clear();
                   }
                 }
                 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);
                   Py_DECREF(func);
                 }
                 for (int i = 0; PythonQtClassWrapper_methods[i].ml_name != NULL; i++) {
                   PyObject* func = PyCFunction_New(&PythonQtClassWrapper_methods[i], obj);
                   PyDict_SetItemString(dict, PythonQtClassWrapper_methods[i].ml_name, func);
                   Py_DECREF(func);
                 }
                 PyDict_Update(dict, objectDict);
                 return dict;
               }
               // 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;
               }
               PyErr_Clear();
               if (wrapper->classInfo()) {
                 PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
                 if (member._type == PythonQtMemberInfo::EnumValue) {
                   PyObject* enumValue = member._enumValue;
                   Py_INCREF(enumValue);
                   return enumValue;
                 } else if (member._type == PythonQtMemberInfo::EnumWrapper) {
                   PyObject* enumWrapper = member._enumWrapper;
                   Py_INCREF(enumWrapper);
                   return enumWrapper;
                 } else if (member._type == PythonQtMemberInfo::Slot) {
                   // we return all slots, even the instance slots, since they are callable as unbound slots with self argument
                   return PythonQtSlotFunction_New(member._slot, obj, NULL);
                 } else if (member._type == PythonQtMemberInfo::Signal) {
                   // we return all signals, even the instance signals, since they are callable as unbound signals with self argument
                   return PythonQtSignalFunction_New(member._slot, obj, NULL);
                 }
               }
               // look for the internal methods (className(), help())
+            #ifdef PY3K
+              PyObject* internalMethod = PyObject_GenericGetAttr(obj, name);
+            #else
               PyObject* internalMethod = Py_FindMethod( PythonQtClassWrapper_methods, obj, (char*)attributeName);
+            #endif
               if (internalMethod) {
                 return internalMethod;
               }
               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)
             {
               return PyType_Type.tp_setattro(obj,name,value);
             }
             /*
             static PyObject * PythonQtClassWrapper_repr(PyObject * obj)
             {
               PythonQtClassWrapper* wrapper = (PythonQtClassWrapper*)obj;
               if (wrapper->classInfo()->isCPPWrapper()) {
                 const QMetaObject* meta = wrapper->classInfo()->metaObject();
                 if (!meta) {
                   QObject* decorator = wrapper->classInfo()->decorator();
                   if (decorator) {
                     meta = decorator->metaObject();
                   }
                 }
                 if (meta) {
                   return PyString_FromFormat("%s Class (C++ wrapped by %s)", wrapper->classInfo()->className(), meta->className());
                 } else {
                   return PyString_FromFormat("%s Class (C++ unwrapped)", wrapper->classInfo()->className());
                 }
               } else {
                 return PyString_FromFormat("%s Class", wrapper->classInfo()->className());
               }
             }
             */
             PyTypeObject PythonQtClassWrapper_Type = {
                 PyVarObject_HEAD_INIT(NULL, 0)
                 "PythonQt.PythonQtClassWrapper",             /*tp_name*/
                 sizeof(PythonQtClassWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
 ,                         /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
 ,                         /*tp_compare*/
 , //PythonQtClassWrapper_repr,            /*tp_repr*/
 ,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
 ,                         /*tp_hash */
 ,                         /*tp_call*/
 ,                         /*tp_str*/
                 PythonQtClassWrapper_getattro,                         /*tp_getattro*/
                 PythonQtClassWrapper_setattro,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
 ,           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
 ,                   /* tp_richcompare */
 ,                   /* tp_weaklistoffset */
 ,                   /* tp_iter */
 ,                   /* tp_iternext */
-,                   /* tp_methods */
+                PythonQtClassWrapper_methods,                   /* tp_methods */
 ,                   /* tp_members */
 ,                         /* tp_getset */
 ,                         /* tp_base */
 ,                         /* tp_dict */
 ,                         /* tp_descr_get */
 ,                         /* tp_descr_set */
 ,                         /* tp_dictoffset */
                 (initproc)PythonQtClassWrapper_init,      /* tp_init */
                 PythonQtClassWrapper_alloc,                         /* tp_alloc */
 ,                         /* tp_new */
 ,                         /* tp_free */
             };
             //-------------------------------------------------------

src/PythonQtConversion.cpp 0 -4

             /*
             *
             *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
             *
             *  This library is free software; you can redistribute it and/or
             *  modify it under the terms of the GNU Lesser General Public
             *  License as published by the Free Software Foundation; either
             *  version 2.1 of the License, or (at your option) any later version.
             *
             *  This library is distributed in the hope that it will be useful,
             *  but WITHOUT ANY WARRANTY; without even the implied warranty of
             *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
             *  Lesser General Public License for more details.
             *
             *  Further, this software is distributed without any warranty that it is
             *  free of the rightful claim of any third person regarding infringement
             *  or the like.  Any license provided herein, whether implied or
             *  otherwise, applies only to this software file.  Patent licenses, if
             *  any, provided herein do not apply to combinations of this program with
             *  other software, or any other product whatsoever.
             *
             *  You should have received a copy of the GNU Lesser General Public
             *  License along with this library; if not, write to the Free Software
             *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             *
             *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
             *  28359 Bremen, Germany or:
             *
             *  http://www.mevis.de
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtConversion.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtConversion.h"
             #include "PythonQtVariants.h"
             #include <QDateTime>
             #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;
             QHash<int, PythonQtConvertMetaTypeToPythonCB*> PythonQtConv::_metaTypeToPythonConverters;
             QHash<int, PythonQtConvertPythonToMetaTypeCB*> PythonQtConv::_pythonToMetaTypeConverters;
             PyObject* PythonQtConv::GetPyBool(bool val)
             {
               PyObject* r = val?Py_True:Py_False;
               Py_INCREF(r);
               return r;
             }
             PyObject* PythonQtConv::ConvertQtValueToPython(const PythonQtMethodInfo::ParameterInfo& info, const void* data) {
               // is it an enum value?
               if (info.enumWrapper) {
                 if (info.pointerCount==0) {
                   return PythonQtPrivate::createEnumValueInstance(info.enumWrapper, *((unsigned int*)data));
                 } else {
                   // we do not support pointers to enums (who needs them?)
                   Py_INCREF(Py_None);
                   return Py_None;
                 }
               }
               if (info.typeId == QMetaType::Void) {
                 Py_INCREF(Py_None);
                 return Py_None;
               } else if ((info.pointerCount == 1) && (info.typeId == QMetaType::Char)) {
                 // 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;
                 }
               } else if ((info.typeId == PythonQtMethodInfo::Unknown || info.typeId >= QMetaType::User) &&
                          info.name.startsWith("QList<")) {
                 // it is a QList template:
                 QByteArray innerType = info.name.mid(6,info.name.length()-7);
                 if (innerType.endsWith("*")) {
                   innerType.truncate(innerType.length()-1);
                   QList<void*>* listPtr = NULL;
                   if (info.pointerCount == 1) {
                     listPtr = *((QList<void*>**)data);
                   } else if (info.pointerCount == 0) {
                     listPtr = (QList<void*>*)data;
                   }
                   if (listPtr) {
                     return ConvertQListOfPointerTypeToPythonList(listPtr, innerType);
                   } else {
                     return NULL;
                   }
                 }
               }
               if (info.typeId >= QMetaType::User) {
                 // if a converter is registered, we use is:
                 PythonQtConvertMetaTypeToPythonCB* converter = _metaTypeToPythonConverters.value(info.typeId);
                 if (converter) {
                   return (*converter)(data, info.typeId);
                 }
               }
               // special handling did not match, so we convert the usual way (either pointer or value version):
               if (info.pointerCount == 1) {
                 // convert the pointer to a Python Object (we can handle ANY C++ object, in the worst case we just know the type and the pointer)
                 return PythonQt::priv()->wrapPtr(*((void**)data), info.name);
               } else if (info.pointerCount == 0) {
                 // handle values that are not yet handled and not pointers
                 return ConvertQtValueToPythonInternal(info.typeId, data);
               } else {
                 return NULL;
               }
             }
             PyObject* PythonQtConv::ConvertQtValueToPythonInternal(int type, const void* data) {
               switch (type) {
               case QMetaType::Void:
                 Py_INCREF(Py_None);
                 return Py_None;
               case QMetaType::Char:
                 return PyLong_FromLong(*((char*)data));
               case QMetaType::UChar:
                 return PyLong_FromLong(*((unsigned char*)data));
               case QMetaType::Short:
                 return PyLong_FromLong(*((short*)data));
               case QMetaType::UShort:
                 return PyLong_FromLong(*((unsigned short*)data));
               case QMetaType::Long:
                 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 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 PyLong_FromLong(*((short*)data));
               case QMetaType::Float:
                 return PyFloat_FromDouble(*((float*)data));
               case QMetaType::Double:
                 return PyFloat_FromDouble(*((double*)data));
               case QMetaType::LongLong:
                 return PyLong_FromLongLong(*((qint64*)data));
               case QMetaType::ULongLong:
                 return PyLong_FromUnsignedLongLong(*((quint64*)data));
                   // implicit conversion from QByteArray to str has been removed:
               //case QMetaType::QByteArray: {
               //  QByteArray* v = (QByteArray*) data;
               //  return PyString_FromStringAndSize(*v, v->size());
               //                            }
               case QMetaType::QVariantMap:
                 return PythonQtConv::QVariantMapToPyObject(*((QVariantMap*)data));
               case QMetaType::QVariantList:
                 return PythonQtConv::QVariantListToPyObject(*((QVariantList*)data));
               case QMetaType::QString:
                 return PythonQtConv::QStringToPyObject(*((QString*)data));
               case QMetaType::QStringList:
                 return PythonQtConv::QStringListToPyObject(*((QStringList*)data));
               case PythonQtMethodInfo::Variant:
                 return PythonQtConv::QVariantToPyObject(*((QVariant*)data));
               case QMetaType::QObjectStar:
             #if( QT_VERSION < QT_VERSION_CHECK(5,0,0) )
               case QMetaType::QWidgetStar:
             #endif
                 return PythonQt::priv()->wrapQObject(*((QObject**)data));
               default:
                 if (PythonQt::priv()->isPythonQtObjectPtrMetaId(type)) {
                   // special case, it is a PythonQtObjectPtr which contains a PyObject, take it directly:
                   PyObject* o = ((PythonQtObjectPtr*)data)->object();
                   Py_INCREF(o);
                   return o;
                 } else {
                   if (type > 0) {
                     // if the type is known, we can construct it via QMetaType::construct
             #if( QT_VERSION >= QT_VERSION_CHECK(5,0,0) )
                     void* newCPPObject = QMetaType::create(type, data);
             #else
                     void* newCPPObject = QMetaType::construct(type, data);
             #endif
                     // XXX this could be optimized by using metatypeid directly
                     PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)PythonQt::priv()->wrapPtr(newCPPObject, QMetaType::typeName(type));
                     wrap->_ownedByPythonQt = true;
                     wrap->_useQMetaTypeDestroy = true;
                     return (PyObject*)wrap;
                   }
                   std::cerr << "Unknown type that can not be converted to Python: " << type << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
                 }
             }
             Py_INCREF(Py_None);
             return Py_None;
              }
              void* PythonQtConv::CreateQtReturnValue(const PythonQtMethodInfo::ParameterInfo& info) {
                void* ptr = NULL;
                if (info.pointerCount>1) {
                  return NULL;
                } else if (info.pointerCount==1) {
                  PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, NULL, ptr);
                } else if (info.enumWrapper) {
                  // create enum return value
                  PythonQtValueStorage_ADD_VALUE(PythonQtConv::global_valueStorage, long, 0, ptr);
                } else {
                  switch (info.typeId) {
                  case QMetaType::Char:
                  case QMetaType::UChar:
                  case QMetaType::Short:
                  case QMetaType::UShort:
                  case QMetaType::Long:
                  case QMetaType::ULong:
                  case QMetaType::Bool:
                  case QMetaType::Int:
                  case QMetaType::UInt:
                  case QMetaType::QChar:
                  case QMetaType::Float:
                  case QMetaType::Double:
                    PythonQtValueStorage_ADD_VALUE(global_valueStorage, qint64, 0, ptr);
                    break;
                  case PythonQtMethodInfo::Variant:
                    PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, 0, ptr);
                    // return the ptr to the variant
                    break;
                  default:
                    if (info.typeId == PythonQtMethodInfo::Unknown) {
                      // check if we have a QList of pointers, which we can circumvent with a QList<void*>
                      if (info.name.startsWith("QList<")) {
                        QByteArray innerType = info.name.mid(6,info.name.length()-7);
                        if (innerType.endsWith("*")) {
                          static int id = QMetaType::type("QList<void*>");
                          PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QVariant::Type(id), ptr);
                          // return the constData pointer that will be filled with the result value later on
                          ptr = (void*)((QVariant*)ptr)->constData();
                        }
                      }
                    }
                   if (!ptr && info.typeId!=PythonQtMethodInfo::Unknown) {
                      // everything else is stored in a QVariant, if we know the meta type...
                      PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QVariant::Type(info.typeId), ptr);
                      // return the constData pointer that will be filled with the result value later on
                      ptr = (void*)((QVariant*)ptr)->constData();
                    }
                  }
                }
                return ptr;
              }
              void* PythonQtConv::castWrapperTo(PythonQtInstanceWrapper* wrapper, const QByteArray& className, bool& ok)
              {
                void* object;
                if (wrapper->classInfo()->isCPPWrapper()) {
                  object = wrapper->_wrappedPtr;
                } else {
                  QObject* tmp = wrapper->_obj;
                  object = tmp;
                }
                if (object) {
                  // if we can be upcasted to the given name, we pass the casted pointer in:
                  object = wrapper->classInfo()->castTo(object, className);
                  ok = object!=NULL;
                } else {
                  // if it is a NULL ptr, we need to check if it inherits, so that we might pass the NULL ptr
                  ok = wrapper->classInfo()->inherits(className);
                }
                return object;
              }
             void* PythonQtConv::handlePythonToQtAutoConversion(int typeId, PyObject* obj, void* alreadyAllocatedCPPObject)
             {
               void* ptr = alreadyAllocatedCPPObject;
               static int penId = QMetaType::type("QPen");
               static int brushId = QMetaType::type("QBrush");
               static int cursorId = QMetaType::type("QCursor");
               static int colorId = QMetaType::type("QColor");
               static PyObject* qtGlobalColorEnum = PythonQtClassInfo::findEnumWrapper("Qt::GlobalColor", NULL);
               if (typeId == cursorId) {
                 static PyObject* qtCursorShapeEnum = PythonQtClassInfo::findEnumWrapper("Qt::CursorShape", NULL);
                 if ((PyObject*)obj->ob_type == qtCursorShapeEnum) {
                   Qt::CursorShape val = (Qt::CursorShape)PyLong_AsLong(obj);
                   if (!ptr) {
                     PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QCursor(), ptr);
                     ptr = (void*)((QVariant*)ptr)->constData();
                   }
                   *((QCursor*)ptr) = QCursor(val);
                   return ptr;
                 }
               } else if (typeId == penId) {
                 // 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)PyLong_AsLong(obj);
                   if (!ptr) {
                     PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QPen(), ptr);
                     ptr = (void*)((QVariant*)ptr)->constData();
                   }
                   *((QPen*)ptr) = QPen(QColor(val));
                   return ptr;
                 } else if ((PyObject*)obj->ob_type == qtColorClass) {
                   if (!ptr) {
                     PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QPen(), ptr);
                     ptr = (void*)((QVariant*)ptr)->constData();
                   }
                   *((QPen*)ptr) = QPen(*((QColor*)((PythonQtInstanceWrapper*)obj)->_wrappedPtr));
                   return ptr;
                 }
               } else if (typeId == brushId) {
                 // 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)PyLong_AsLong(obj);
                   if (!ptr) {
                     PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QBrush(), ptr);
                     ptr = (void*)((QVariant*)ptr)->constData();
                   }
                   *((QBrush*)ptr) = QBrush(QColor(val));
                   return ptr;
                 } else if ((PyObject*)obj->ob_type == qtColorClass) {
                   if (!ptr) {
                     PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QBrush(), ptr);
                     ptr = (void*)((QVariant*)ptr)->constData();
                   }
                   *((QBrush*)ptr) = QBrush(*((QColor*)((PythonQtInstanceWrapper*)obj)->_wrappedPtr));
                   return ptr;
                 }
               } 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)PyLong_AsLong(obj);
                   if (!ptr) {
                     PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QColor(), ptr);
                     ptr = (void*)((QVariant*)ptr)->constData();
                   }
                   *((QColor*)ptr) = QColor(val);
                   return ptr;
                 }
               }
               return NULL;
             }
             void* PythonQtConv::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, PythonQtClassInfo* /*classInfo*/, void* alreadyAllocatedCPPObject)
              {
                bool ok = false;
                void* ptr = NULL;
                // autoconversion of QPen/QBrush/QCursor/QColor from different type
                if (info.pointerCount==0 && !strict) {
                  ptr = handlePythonToQtAutoConversion(info.typeId, obj, alreadyAllocatedCPPObject);
                  if (ptr) {
                    return ptr;
                  }
                }
                if (PyObject_TypeCheck(obj, &PythonQtInstanceWrapper_Type) && info.typeId != PythonQtMethodInfo::Variant) {
                  // if we have a Qt wrapper object and if we do not need a QVariant, we do the following:
                  // (the Variant case is handled below in a switch)
                  // a C++ wrapper (can be passed as pointer or reference)
                  PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)obj;
                  void* object = castWrapperTo(wrap, info.name, ok);
                  if (ok) {
                    if (info.pointerCount==1) {
                      // store the wrapped pointer in an extra pointer and let ptr point to the extra pointer
                      PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, object, ptr);
                    } else if (info.pointerCount==0) {
                      // store the wrapped pointer directly, since we are a reference
                      ptr = object;
                    }
                  } else {
                    // not matching, maybe a PyObject*?
                    if (info.name == "PyObject" && info.pointerCount==1) {
                      // handle low level PyObject directly
                      PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, obj, ptr);
                    }
                  }
                } else if (info.pointerCount == 1) {
                  // 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);
                      if (ok) {
                        QByteArray bytes;
                        bytes = str.toUtf8();
                        if (ok) {
                          void* ptr2 = NULL;
                          PythonQtValueStorage_ADD_VALUE_IF_NEEDED(NULL,global_variantStorage, QVariant, QVariant(bytes), ptr2);
                          PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, (((QByteArray*)((QVariant*)ptr2)->constData())->data()), ptr);
                        }
                      }
                    }
                  } else if (info.typeId == QMetaType::QString) {
                    // TODO: this is a special case for bad Qt APIs which take a QString*, like QtGui.QFileDialog.getSaveFileName
                    // In general we would need to decide to either support * args for all basic types (ignoring the fact that the
                    // result value is not useable in Python), or if all these APIs need to be wrapped manually/differently, like PyQt/PySide do.
                    QString str = PyObjGetString(obj, strict, ok);
                    if (ok) {
                      void* ptr2 = NULL;
                      PythonQtValueStorage_ADD_VALUE_IF_NEEDED(NULL,global_variantStorage, QVariant, QVariant(str), ptr2);
                      PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, (void*)((QVariant*)ptr2)->constData(), ptr);
                    }
                  } else if (info.name == "PyObject") {
                    // handle low level PyObject directly
                    PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, obj, ptr);
                  } else if (obj == Py_None) {
                    // None is treated as a NULL ptr
                    PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, NULL, ptr);
                  } else {
                    void* foreignWrapper = PythonQt::priv()->unwrapForeignWrapper(info.name, obj);
                    if (foreignWrapper) {
                      PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, foreignWrapper, ptr);
                    } else {
                      // if we are not strict, we try if we are passed a 0 integer
                      if (!strict) {
                        bool ok;
                        int value = PyObjGetInt(obj, true, ok);
                        if (ok && value==0) {
                          // TODOXXX is this wise? or should it be expected from the programmer to use None?
                          PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, NULL, ptr);
                        }
                      }
                    }
                  }
                } else if (info.pointerCount == 0) {
                  // not a pointer
                  switch (info.typeId) {
                  case QMetaType::Char:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, char, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::UChar:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned char, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Short:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, short, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::UShort:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned short, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Long:
                    {
                      long val = (long)PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, long, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::ULong:
                    {
                      unsigned long val = (unsigned long)PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned long, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Bool:
                    {
                      bool val = PyObjGetBool(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, bool, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Int:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, int, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::UInt:
                    {
                      unsigned int val = (unsigned int)PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned int, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::QChar:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, short, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Float:
                    {
                      float val = (float)PyObjGetDouble(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, float, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Double:
                    {
                      double val = (double)PyObjGetDouble(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, double, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::LongLong:
                    {
                      qint64 val = PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, qint64, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::ULongLong:
                    {
                      quint64 val = PyObjGetULongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, quint64, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::QByteArray:
                    {
                      QByteArray bytes = PyObjGetBytes(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(bytes), ptr);
                        ptr = (void*)((QVariant*)ptr)->constData();
                      }
                    }
                    break;
                  case QMetaType::QString:
                    {
                      QString str = PyObjGetString(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(str), ptr);
                        ptr = (void*)((QVariant*)ptr)->constData();
                      }
                    }
                    break;
                  case QMetaType::QStringList:
                    {
                      QStringList l = PyObjToStringList(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(l), ptr);
                        ptr = (void*)((QVariant*)ptr)->constData();
                      }
                    }
                    break;
                  case PythonQtMethodInfo::Variant:
                    {
                      QVariant v = PyObjToQVariant(obj);
                      // the only case where conversion can fail it None and we want to pass that to, e.g. setProperty(),
                      // so we do not check v.isValid() here
                      PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, v, ptr);
                    }
                    break;
                    default:
                    {
                      // check for enum case
                      if (info.enumWrapper) {
                        unsigned int val;
                        ok = false;
                        if ((PyObject*)obj->ob_type == info.enumWrapper) {
                          // we have a exact enum type match:
                          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
                          // we want an integer overload to be taken first!
                          val = (unsigned int)PyObjGetLongLong(obj, false, ok);
                        }
                        if (ok) {
                          PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned int, val, ptr);
                          return ptr;
                        } else {
                          return NULL;
                        }
                      }
                      if (info.typeId == PythonQtMethodInfo::Unknown || info.typeId >= QMetaType::User) {
                        // check for QList<AnyPtr*> case, where we will use a QList<void*> QVariant
                        if (info.name.startsWith("QList<")) {
                          QByteArray innerType = info.name.mid(6,info.name.length()-7);
                          if (innerType.endsWith("*")) {
                            innerType.truncate(innerType.length()-1);
                            static int id = QMetaType::type("QList<void*>");
                            if (!alreadyAllocatedCPPObject) {
                              PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant::Type(id), ptr);
                              ptr = (void*)((QVariant*)ptr)->constData();
                            } else {
                              ptr = alreadyAllocatedCPPObject;
                            }
                            ok = ConvertPythonListToQListOfPointerType(obj, (QList<void*>*)ptr, innerType, strict);
                            if (ok) {
                              return ptr;
                            } else {
                              return NULL;
                            }
                          }
                        }
                      }
                      // We only do this for registered type > QMetaType::User for performance reasons.
                      if (info.typeId >= QMetaType::User) {
                        // Maybe we have a special converter that is registered for that type:
                        PythonQtConvertPythonToMetaTypeCB* converter = _pythonToMetaTypeConverters.value(info.typeId);
                        if (converter) {
                          if (!alreadyAllocatedCPPObject) {
                            // create a new empty variant of concrete type:
                            PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant::Type(info.typeId), ptr);
                            ptr = (void*)((QVariant*)ptr)->constData();
                          } else {
                            ptr = alreadyAllocatedCPPObject;
                          }
                          // now call the converter, passing the internal object of the variant
                          ok = (*converter)(obj, ptr, info.typeId, strict);
                          if (ok) {
                            return ptr;
                          } else {
                            return NULL;
                          }
                        }
                      }
                      // if no type id is available, conversion to a QVariant makes no sense/is not possible
                      if (info.typeId != PythonQtMethodInfo::Unknown) {
                        // for all other types, we use the same qvariant conversion and pass out the constData of the variant:
                        QVariant v = PyObjToQVariant(obj, info.typeId);
                        if (v.isValid()) {
                          PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, v, ptr);
                          ptr = (void*)((QVariant*)ptr)->constData();
                        }
                      }
                    }
                 }
               }
               return ptr;
             }
             QStringList PythonQtConv::PyObjToStringList(PyObject* val, bool strict, bool& ok) {
               QStringList v;
               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 && (
             #ifndef PY3K
                 val->ob_type == &PyString_Type ||
             #endif
                 PyUnicode_Check(val))) {
                 ok = false;
                 return v;
               }
               if (PySequence_Check(val)) {
                 int count = PySequence_Size(val);
                 for (int i = 0;i<count;i++) {
                   PyObject* value = PySequence_GetItem(val,i);
                   v.append(PyObjGetString(value,false,ok));
                 }
                 ok = true;
               }
               return v;
             }
             QString PythonQtConv::PyObjGetRepresentation(PyObject* val)
             {
               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;
             #ifndef PY3K
               if (Py_TYPE(val) == &PyString_Type) {
                 r = QString(PyString_AS_STRING(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;
                 }
               } else {
                 ok = false;
               }
               return r;
             }
             QByteArray PythonQtConv::PyObjGetBytes(PyObject* val, bool /*strict*/, bool& ok) {
               // TODO: support buffer objects in general
               QByteArray r;
               ok = true;
             #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;
               }
               return r;
             }
             bool PythonQtConv::PyObjGetBool(PyObject* val, bool strict, bool &ok) {
               bool d = false;
               ok = false;
               if (val == Py_False) {
                 d = false;
                 ok = true;
               } else if (val == Py_True) {
                 d = true;
                 ok = true;
               } else if (!strict) {
                 int result = PyObject_IsTrue(val);
                 d = (result == 1);
                 // the result is -1 if an error occurred, handle this:
                 ok = (result != -1);
               }
               return d;
             }
             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
             #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;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   PyErr_Clear();
                   // PyInt_AsLong will try conversion to an int if the object is not an int:
                   d = PyLong_AsLong(val);
                   if (PyErr_Occurred()) {
                     ok = false;
                     PyErr_Clear();
                   }
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             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
             #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
             #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;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   PyErr_Clear();
                   // PyLong_AsLongLong will try conversion to an int if the object is not an int:
                   d = PyLong_AsLongLong(val);
                   if (PyErr_Occurred()) {
                     ok = false;
                     PyErr_Clear();
                   }
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             quint64 PythonQtConv::PyObjGetULongLong(PyObject* val, bool strict, bool &ok) {
               quint64 d = 0;
               ok = true;
             #ifndef PY3K
               if (Py_TYPE(val) == &PyInt_Type) {
                 d = PyInt_AS_LONG(val);
               } 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
             #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;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   PyErr_Clear();
                   // PyLong_AsLongLong will try conversion to an int if the object is not an int:
                   d = PyLong_AsLongLong(val);
                   if (PyErr_Occurred()) {
                     PyErr_Clear();
                     ok = false;
                   }
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             double PythonQtConv::PyObjGetDouble(PyObject* val, bool strict, bool &ok) {
               double d = 0;
               ok = true;
               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
             #endif
                 if (PyLong_Check(val)) {
                   d = PyLong_AsLong(val);
                 } else if (val == Py_False) {
                   d = 0;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   PyErr_Clear();
                   // PyFloat_AsDouble will try conversion to a double if the object is not a float:
                   d = PyFloat_AsDouble(val);
                   if (PyErr_Occurred()) {
                     PyErr_Clear();
                     ok = false;
                   }
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
             {
               QVariant v;
               bool ok = true;
               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;
             #endif
                 } else if (PyLong_Check(val)) {
                   type = QVariant::LongLong;
                 } else if (PyFloat_Check(val)) {
                   type = QVariant::Double;
                 } else if (PyObject_TypeCheck(val, &PythonQtInstanceWrapper_Type)) {
                   PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)val;
                   // c++ wrapper, check if the class names of the c++ objects match
                   if (wrap->classInfo()->isCPPWrapper()) {
                     if (wrap->classInfo()->metaTypeId()>0) {
                       // construct a new variant from the C++ object if it has a meta type (this will COPY the object!)
                       v = QVariant(wrap->classInfo()->metaTypeId(), wrap->_wrappedPtr);
                     } else {
                       // TODOXXX we could as well check if there is a registered meta type for "classname*", so that we may pass
                       // the pointer here...
                       // is this worth anything? we loose the knowledge of the cpp object type
                       v = qVariantFromValue(wrap->_wrappedPtr);
                     }
                   } else {
                     // this gives us a QObject pointer
                     QObject* myObject = wrap->_obj;
                     v = qVariantFromValue(myObject);
                   }
                   return v;
                 } else if (PyDict_Check(val)) {
                   type = QVariant::Map;
                 } else if (PyList_Check(val) || PyTuple_Check(val) || PySequence_Check(val)) {
                   type = QVariant::List;
                 } else if (val == Py_None) {
                   // none is invalid
                   type = QVariant::Invalid;
                 } else {
                   // this used to be:
                   // type = QVariant::String;
                   // but now we want to transport the Python Objects directly:
                   PythonQtObjectPtr o(val);
                   v = qVariantFromValue(o);
                   return v;
                 }
               }
               // special type request:
               switch (type) {
               case QVariant::Invalid:
                 return v;
                 break;
               case QVariant::Int:
                 {
                   int d = PyObjGetInt(val, false, ok);
                   if (ok) return QVariant(d);
                 }
                 break;
               case QVariant::UInt:
                 {
                   int d = PyObjGetInt(val, false,ok);
                   if (ok) v = QVariant((unsigned int)d);
                 }
                 break;
               case QVariant::Bool:
                 {
                   int d = PyObjGetBool(val,false,ok);
                   if (ok) v =  QVariant((bool)(d!=0));
                 }
                 break;
               case QVariant::Double:
                 {
                   double d = PyObjGetDouble(val,false,ok);
                   if (ok) v =  QVariant(d);
                   break;
                 }
               case QMetaType::Float:
                 {
                   float d = (float) PyObjGetDouble(val,false,ok);
                   if (ok) v =  qVariantFromValue(d);
                   break;
                 }
               case QMetaType::Long:
                 {
                   long d = (long) PyObjGetLongLong(val,false,ok);
                   if (ok) v =  qVariantFromValue(d);
                   break;
                 }
               case QMetaType::ULong:
                 {
                   unsigned long d = (unsigned long) PyObjGetLongLong(val,false,ok);
                   if (ok) v =  qVariantFromValue(d);
                   break;
                 }
               case QMetaType::LongLong:
                 {
                   qint64 d = PyObjGetLongLong(val, false, ok);
                   if (ok) v =  qVariantFromValue(d);
                 }
                 break;
               case QMetaType::ULongLong:
                 {
                   quint64 d = PyObjGetULongLong(val, false, ok);
                   if (ok) v =  qVariantFromValue(d);
                 }
                 break;
               case QMetaType::Short:
                 {
                   short d = (short) PyObjGetInt(val,false,ok);
                   if (ok) v =  qVariantFromValue(d);
                   break;
                 }
               case QMetaType::UShort:
                 {
                   unsigned short d = (unsigned short) PyObjGetInt(val,false,ok);
                   if (ok) v =  qVariantFromValue(d);
                   break;
                 }
               case QMetaType::Char:
                 {
                   char d = (char) PyObjGetInt(val,false,ok);
                   if (ok) v =  qVariantFromValue(d);
                   break;
                 }
               case QMetaType::UChar:
                 {
                   unsigned char d = (unsigned char) PyObjGetInt(val,false,ok);
                   if (ok) v =  qVariantFromValue(d);
                   break;
                 }
               case QVariant::ByteArray:
               case QVariant::String:
                 {
                   bool ok;
                   v = QVariant(PyObjGetString(val, false, ok));
                 }
                 break;
                 // these are important for MeVisLab
               case QVariant::Map:
                 {
                   if (PyMapping_Check(val)) {
                     QMap<QString,QVariant> map;
                     PyObject* items = PyMapping_Items(val);
                     if (items) {
                       int count = PyList_Size(items);
                       PyObject* value;
                       PyObject* key;
                       PyObject* tuple;
                       for (int i = 0;i<count;i++) {
                         tuple = PyList_GetItem(items,i);
                         key = PyTuple_GetItem(tuple, 0);
                         value = PyTuple_GetItem(tuple, 1);
                         map.insert(PyObjGetString(key), PyObjToQVariant(value,-1));
                       }
                       Py_DECREF(items);
                       v = map;
                     }
                   }
                 }
                 break;
               case QVariant::List:
                 if (PySequence_Check(val)) {
                   QVariantList list;
                   int count = PySequence_Size(val);
                   PyObject* value;
                   for (int i = 0;i<count;i++) {
                     value = PySequence_GetItem(val,i);
                     list.append(PyObjToQVariant(value, -1));
                   }
                   v = list;
                 }
                 break;
               case QVariant::StringList:
                 {
                   bool ok;
                   QStringList l = PyObjToStringList(val, false, ok);
                   if (ok) {
                     v = l;
                   }
                 }
                 break;
               default:
                 if (PyObject_TypeCheck(val, &PythonQtInstanceWrapper_Type)) {
                   PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)val;
                   if (wrap->classInfo()->isCPPWrapper() && wrap->classInfo()->metaTypeId() == type) {
                     // construct a new variant from the C++ object if it has the same meta type
                     v = QVariant(type, wrap->_wrappedPtr);
                   } else {
                     v = QVariant();
                   }
                 } else {
                   v = QVariant();
                 }
               }
               return v;
             }
             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);
               }
             }
             PyObject* PythonQtConv::QStringListToPyObject(const QStringList& list)
             {
               PyObject* result = PyTuple_New(list.count());
               int i = 0;
               QString str;
               Q_FOREACH (str, list) {
                 PyTuple_SET_ITEM(result, i, PythonQtConv::QStringToPyObject(str));
                 i++;
               }
               // why is the error state bad after this?
               PyErr_Clear();
               return result;
             }
             PyObject* PythonQtConv::QStringListToPyList(const QStringList& list)
             {
               PyObject* result = PyList_New(list.count());
               int i = 0;
               for (QStringList::ConstIterator it = list.begin(); it!=list.end(); ++it) {
                 PyList_SET_ITEM(result, i, PythonQtConv::QStringToPyObject(*it));
                 i++;
               }
               return result;
             }
             PyObject* PythonQtConv::QVariantToPyObject(const QVariant& v)
             {
               return ConvertQtValueToPythonInternal(v.userType(), (void*)v.constData());
             }
             PyObject* PythonQtConv::QVariantMapToPyObject(const QVariantMap& m) {
               PyObject* result = PyDict_New();
               QVariantMap::const_iterator t = m.constBegin();
               PyObject* key;
               PyObject* val;
               for (;t!=m.end();t++) {
                 key = QStringToPyObject(t.key());
                 val = QVariantToPyObject(t.value());
                 PyDict_SetItem(result, key, val);
                 Py_DECREF(key);
                 Py_DECREF(val);
               }
               return result;
             }
             PyObject* PythonQtConv::QVariantListToPyObject(const QVariantList& l) {
               PyObject* result = PyTuple_New(l.count());
               int i = 0;
               QVariant v;
               Q_FOREACH (v, l) {
                 PyTuple_SET_ITEM(result, i, PythonQtConv::QVariantToPyObject(v));
                 i++;
               }
               // why is the error state bad after this?
               PyErr_Clear();
               return result;
             }
             PyObject* PythonQtConv::ConvertQListOfPointerTypeToPythonList(QList<void*>* list, const QByteArray& typeName)
             {
               PyObject* result = PyTuple_New(list->count());
               int i = 0;
               Q_FOREACH (void* value, *list) {
                 PyTuple_SET_ITEM(result, i, PythonQt::priv()->wrapPtr(value, typeName));
                 i++;
               }
               return result;
             }
             bool PythonQtConv::ConvertPythonListToQListOfPointerType(PyObject* obj, QList<void*>* list, const QByteArray& type, bool /*strict*/)
             {
               bool result = false;
               if (PySequence_Check(obj)) {
                 result = true;
                 int count = PySequence_Size(obj);
                 PyObject* value;
                 for (int i = 0;i<count;i++) {
                   value = PySequence_GetItem(obj,i);
                   if (PyObject_TypeCheck(value, &PythonQtInstanceWrapper_Type)) {
                     PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)value;
                     bool ok;
                     void* object = castWrapperTo(wrap, type, ok);
                     if (ok) {
                       list->append(object);
                     } else {
                       result = false;
                       break;
                     }
                   }
                 }
               }
               return result;
             }
             int PythonQtConv::getInnerTemplateMetaType(const QByteArray& typeName)
             {
               int idx = typeName.indexOf("<");
               if (idx>0) {
                 int idx2 = typeName.indexOf(">");
                 if (idx2>0) {
                   QByteArray innerType = typeName.mid(idx+1,idx2-idx-1);
                   return QMetaType::type(innerType.constData());
                 }
               }
               return QMetaType::Void;
             }
             QString PythonQtConv::CPPObjectToString(int type, const void* data) {
               QString r;
               switch (type) {
                 case QVariant::Size: {
                   const QSize* s = static_cast<const QSize*>(data);
                   r = QString::number(s->width()) + ", " + QString::number(s->height());
                   }
                   break;
                 case QVariant::SizeF: {
                   const QSizeF* s = static_cast<const QSizeF*>(data);
                   r = QString::number(s->width()) + ", " + QString::number(s->height());
                   }
                   break;
                 case QVariant::Point: {
                   const QPoint* s = static_cast<const QPoint*>(data);
                   r = QString::number(s->x()) + ", " + QString::number(s->y());
                   }
                   break;
                 case QVariant::PointF: {
                   const QPointF* s = static_cast<const QPointF*>(data);
                   r = QString::number(s->x()) + ", " + QString::number(s->y());
                   }
                   break;
                 case QVariant::Rect: {
                   const QRect* s = static_cast<const QRect*>(data);
                   r = QString::number(s->x()) + ", " + QString::number(s->y());
                   r += ", " + QString::number(s->width()) + ", " + QString::number(s->height());
                   }
                   break;
                 case QVariant::RectF: {
                   const QRectF* s = static_cast<const QRectF*>(data);
                   r = QString::number(s->x()) + ", " + QString::number(s->y());
                   r += ", " + QString::number(s->width()) + ", " + QString::number(s->height());
                   }
                   break;
                 case QVariant::Date: {
                   const QDate* s = static_cast<const QDate*>(data);
                   r = s->toString(Qt::ISODate);
                   }
                   break;
                 case QVariant::DateTime: {
                   const QDateTime* s = static_cast<const QDateTime*>(data);
                   r = s->toString(Qt::ISODate);
                   }
                   break;
                 case QVariant::Time: {
                   const QTime* s = static_cast<const QTime*>(data);
                   r = s->toString(Qt::ISODate);
                 }
                   break;
                 case QVariant::Pixmap:
                 {
                   const QPixmap* s = static_cast<const QPixmap*>(data);
                   r = QString("Pixmap ") + QString::number(s->width()) + ", " + QString::number(s->height());
                 }
                   break;
                 case QVariant::Image:
                 {
                   const QImage* s = static_cast<const QImage*>(data);
                   r = QString("Image ") + QString::number(s->width()) + ", " + QString::number(s->height());
                 }
                   break;
                 case QVariant::Url:
                   {
                     const QUrl* s = static_cast<const QUrl*>(data);
                     r = s->toString();
                   }
                   break;
                   //TODO: add more printing for other variant types
                 default:
                   // this creates a copy, but that should not be expensive for typical simple variants
                   // (but we do not want to do this for our won user types!
                   if (type>0 && type < (int)QVariant::UserType) {
                     QVariant v(type, data);
                     r = v.toString();
                   }
               }
               return r;
             }

src/PythonQtImporter.cpp 0 -4

             /*
              *
              *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
              *
              *  This library is free software; you can redistribute it and/or
              *  modify it under the terms of the GNU Lesser General Public
              *  License as published by the Free Software Foundation; either
              *  version 2.1 of the License, or (at your option) any later version.
              *
              *  This library is distributed in the hope that it will be useful,
              *  but WITHOUT ANY WARRANTY; without even the implied warranty of
              *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
              *  Lesser General Public License for more details.
              *
              *  Further, this software is distributed without any warranty that it is
              *  free of the rightful claim of any third person regarding infringement
              *  or the like.  Any license provided herein, whether implied or
              *  otherwise, applies only to this software file.  Patent licenses, if
              *  any, provided herein do not apply to combinations of this program with
              *  other software, or any other product whatsoever.
              *
              *  You should have received a copy of the GNU Lesser General Public
              *  License along with this library; if not, write to the Free Software
              *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              *
              *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
              *  28359 Bremen, Germany or:
              *
              *  http://www.mevis.de
              *
              */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtImporter.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             // This module was inspired by the zipimport.c module of the original
             // Python distribution. Most of the functions are identical or slightly
             // modified to do all the loading of Python files via an external file interface.
             // In contrast to zipimport.c, this module also writes *.pyc files
             // automatically if it has write access/is not inside of a zip file.
             //----------------------------------------------------------------------------------
             #include "PythonQtImporter.h"
             #include "PythonQtImportFileInterface.h"
             #include "PythonQt.h"
             #include "PythonQtConversion.h"
             #include <QFile>
             #include <QFileInfo>
-            #if PY_MAJOR_VERSION >= 3
-            #define PY3K
-            #endif
             #define IS_SOURCE   0x0
             #define IS_BYTECODE 0x1
             #define IS_PACKAGE  0x2
             struct st_mlab_searchorder {
               char suffix[14];
               int type;
             };
             /* mlab_searchorder defines how we search for a module in the Zip
                archive: we first search for a package __init__, then for
                non-package .pyc, .pyo and .py entries. The .pyc and .pyo entries
                are swapped by initmlabimport() if we run in optimized mode. Also,
                '/' is replaced by SEP there. */
              struct st_mlab_searchorder mlab_searchorder[] = {
               {"/__init__.pyc", IS_PACKAGE | IS_BYTECODE},
               {"/__init__.pyo", IS_PACKAGE | IS_BYTECODE},
               {"/__init__.py", IS_PACKAGE | IS_SOURCE},
               {".pyc", IS_BYTECODE},
               {".pyo", IS_BYTECODE},
               {".py", IS_SOURCE},
               {"", 0}
             };
             extern PyTypeObject PythonQtImporter_Type;
             PyObject *PythonQtImportError;
             QString PythonQtImport::getSubName(const QString& str)
             {
               int idx = str.lastIndexOf('.');
               if (idx!=-1) {
                 return str.mid(idx+1);
               } else {
                 return str;
               }
             }
             PythonQtImport::ModuleInfo PythonQtImport::getModuleInfo(PythonQtImporter* self, const QString& fullname)
             {
               ModuleInfo info;
               QString subname;
               struct st_mlab_searchorder *zso;
               subname = getSubName(fullname);
               QString path = *self->_path + "/" + subname;
               QString test;
               for (zso = mlab_searchorder; *zso->suffix; zso++) {
                 test = path + zso->suffix;
                 if (PythonQt::importInterface()->exists(test)) {
                   info.fullPath = test;
                   info.moduleName = subname;
                   info.type = (zso->type & IS_PACKAGE)?MI_PACKAGE:MI_MODULE;
                   return info;
                 }
               }
               // test if it is a shared library
               Q_FOREACH(const QString& suffix, PythonQt::priv()->sharedLibrarySuffixes()) {
                 test = path+suffix;
                 if (PythonQt::importInterface()->exists(test)) {
                   info.fullPath = test;
                   info.moduleName = subname;
                   info.type = MI_SHAREDLIBRARY;
                   return info;
                 }
               }
               return info;
             }
             /* PythonQtImporter.__init__
               Just store the path argument (or reject if it is in the ignorePaths list
             */
             int PythonQtImporter_init(PythonQtImporter *self, PyObject *args, PyObject * /*kwds*/)
             {
               self->_path = NULL;
               const char* cpath;
               if (!PyArg_ParseTuple(args, "s",
                 &cpath))
                 return -1;
               QString path(cpath);
               if (PythonQt::importInterface()->exists(path)) {
                 const QStringList& ignorePaths = PythonQt::self()->getImporterIgnorePaths();
                 Q_FOREACH(QString ignorePath, ignorePaths) {
                   if (path.startsWith(ignorePath)) {
                     PyErr_SetString(PythonQtImportError,
                       "path ignored");
                     return -1;
                   }
                 }
                 self->_path = new QString(path);
                 return 0;
               } else {
                 PyErr_SetString(PythonQtImportError,
                     "path does not exist error");
                 return -1;
               }
             }
             void
             PythonQtImporter_dealloc(PythonQtImporter *self)
             {
               // free the stored path
               if (self->_path) delete self->_path;
               // free ourself
               Py_TYPE(self)->tp_free((PyObject *)self);
             }
             /* Check whether we can satisfy the import of the module named by
                'fullname'. Return self if we can, None if we can't. */
             PyObject *
             PythonQtImporter_find_module(PyObject *obj, PyObject *args)
             {
               PythonQtImporter *self = (PythonQtImporter *)obj;
               PyObject *path = NULL;
               char *fullname;
               if (!PyArg_ParseTuple(args, "s|O:PythonQtImporter.find_module",
                         &fullname, &path))
                 return NULL;
               //qDebug() << "looking for " << fullname << " at " << *self->_path;
               PythonQtImport::ModuleInfo info = PythonQtImport::getModuleInfo(self, fullname);
               if (info.type != PythonQtImport::MI_NOT_FOUND) {
                 Py_INCREF(self);
                 return (PyObject *)self;
               } else {
                 Py_INCREF(Py_None);
                 return Py_None;
               }
             }
             /* Load and return the module named by 'fullname'. */
             PyObject *
             PythonQtImporter_load_module(PyObject *obj, PyObject *args)
             {
               PythonQtImporter *self = (PythonQtImporter *)obj;
               PyObject *code = NULL, *mod = NULL, *dict = NULL;
               char *fullname;
               if (!PyArg_ParseTuple(args, "s:PythonQtImporter.load_module",
                         &fullname))
                 return NULL;
               PythonQtImport::ModuleInfo info = PythonQtImport::getModuleInfo(self, fullname);
               if (info.type == PythonQtImport::MI_NOT_FOUND) {
                 return NULL;
               }
               if (info.type == PythonQtImport::MI_PACKAGE || info.type == PythonQtImport::MI_MODULE) {
                 QString fullPath;
                 code = PythonQtImport::getModuleCode(self, fullname, fullPath);
                 if (code == NULL) {
                   return NULL;
                 }
                 mod = PyImport_AddModule(fullname);
                 if (mod == NULL) {
                   Py_DECREF(code);
                   return NULL;
                 }
                 dict = PyModule_GetDict(mod);
                 if (PyDict_SetItemString(dict, "__loader__", (PyObject *)self) != 0) {
                   Py_DECREF(code);
                   Py_DECREF(mod);
                   return NULL;
                 }
                 if (info.type == PythonQtImport::MI_PACKAGE) {
                   PyObject *pkgpath, *fullpath;
                   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());
                   if (fullpath == NULL) {
                     Py_DECREF(code);
                     Py_DECREF(mod);
                     return NULL;
                   }
                   pkgpath = Py_BuildValue("[O]", fullpath);
                   Py_DECREF(fullpath);
                   if (pkgpath == NULL) {
                     Py_DECREF(code);
                     Py_DECREF(mod);
                     return NULL;
                   }
                   err = PyDict_SetItemString(dict, "__path__", pkgpath);
                   Py_DECREF(pkgpath);
                   if (err != 0) {
                     Py_DECREF(code);
                     Py_DECREF(mod);
                     return NULL;
                   }
                 }
                 mod = PyImport_ExecCodeModuleEx(fullname, code, fullPath.toLatin1().data());
                 if (PythonQt::importInterface()) {
                   PythonQt::importInterface()->importedModule(fullname);
                 }
                 Py_DECREF(code);
                 if (Py_VerboseFlag) {
                   PySys_WriteStderr("import %s # loaded from %s\n",
                     fullname, fullPath.toLatin1().constData());
                 }
               } else {
                 PythonQtObjectPtr imp;
                 imp.setNewRef(PyImport_ImportModule("imp"));
                 // Create a PyList with the current path as its single element,
                 // which is required for find_module (it won't accept a tuple...)
                 PythonQtObjectPtr pathList;
                 pathList.setNewRef(PythonQtConv::QStringListToPyList(QStringList() << *self->_path));
                 QVariantList args;
                 // Pass the module name without the package prefix
                 args.append(info.moduleName);
                 // And the path where we know that the shared library is
                 args.append(QVariant::fromValue(pathList));
                 QVariant result = imp.call("find_module", args);
                 if (result.isValid()) {
                   // This will return a tuple with (file, pathname, description=(suffix,mode,type))
                   QVariantList list = result.toList();
                   if (list.count()==3) {
                     // We prepend the full module name (including package prefix)
                     list.prepend(fullname);
             #ifdef __linux
               #ifdef _DEBUG
                     // imp_find_module() does not respect the debug suffix '_d' on Linux,
                     // so it does not return the correct file path and we correct it now
                     // find_module opened a file to the release library, but that file handle is
                     // ignored on Linux and Windows, maybe on MacOS also.
                     list[2] = info.fullPath;
               #endif
             #endif
                     // And call "load_module" with (fullname, file, pathname, description=(suffix,mode,type))
                     PythonQtObjectPtr module = imp.call("load_module", list);
                     mod = module.object();
                     if (mod) {
                       Py_INCREF(mod);
                     }
                     // Finally, we need to close the file again, which find_module opened for us
                     PythonQtObjectPtr file = list.at(1);
                     file.call("close");
                   }
                 }
               }
               return mod;
             }
             PyObject *
             PythonQtImporter_get_data(PyObject* /*obj*/, PyObject* /*args*/)
             {
               // EXTRA, NOT YET IMPLEMENTED
               return NULL;
             }
             PyObject *
             PythonQtImporter_get_code(PyObject *obj, PyObject *args)
             {
               PythonQtImporter *self = (PythonQtImporter *)obj;
               char *fullname;
               if (!PyArg_ParseTuple(args, "s:PythonQtImporter.get_code", &fullname))
                 return NULL;
               QString notused;
               return PythonQtImport::getModuleCode(self, fullname, notused);
             }
             PyObject *
             PythonQtImporter_get_source(PyObject * /*obj*/, PyObject * /*args*/)
             {
               // EXTRA, NOT YET IMPLEMENTED
               return NULL;
             }
             PyDoc_STRVAR(doc_find_module,
             "find_module(fullname, path=None) -> self or None.\n\
             \n\
             Search for a module specified by 'fullname'. 'fullname' must be the\n\
             fully qualified (dotted) module name. It returns the PythonQtImporter\n\
             instance itself if the module was found, or None if it wasn't.\n\
             The optional 'path' argument is ignored -- it's there for compatibility\n\
             with the importer protocol.");
             PyDoc_STRVAR(doc_load_module,
             "load_module(fullname) -> module.\n\
             \n\
             Load the module specified by 'fullname'. 'fullname' must be the\n\
             fully qualified (dotted) module name. It returns the imported\n\
             module, or raises PythonQtImportError if it wasn't found.");
             PyDoc_STRVAR(doc_get_data,
             "get_data(pathname) -> string with file data.\n\
             \n\
             Return the data associated with 'pathname'. Raise IOError if\n\
             the file wasn't found.");
             PyDoc_STRVAR(doc_get_code,
             "get_code(fullname) -> code object.\n\
             \n\
             Return the code object for the specified module. Raise PythonQtImportError\n\
             is the module couldn't be found.");
             PyDoc_STRVAR(doc_get_source,
             "get_source(fullname) -> source string.\n\
             \n\
             Return the source code for the specified module. Raise PythonQtImportError\n\
             is the module couldn't be found, return None if the archive does\n\
             contain the module, but has no source for it.");
             PyMethodDef PythonQtImporter_methods[] = {
               {"find_module", PythonQtImporter_find_module, METH_VARARGS,
                doc_find_module},
               {"load_module", PythonQtImporter_load_module, METH_VARARGS,
                doc_load_module},
               {"get_data", PythonQtImporter_get_data, METH_VARARGS,
                doc_get_data},
               {"get_code", PythonQtImporter_get_code, METH_VARARGS,
                doc_get_code},
               {"get_source", PythonQtImporter_get_source, METH_VARARGS,
                doc_get_source},
               {NULL,    NULL, 0 , NULL} /* sentinel */
             };
             PyDoc_STRVAR(PythonQtImporter_doc,
             "PythonQtImporter(path) -> PythonQtImporter object\n\
             \n\
             Create a new PythonQtImporter instance. 'path' must be a valid path on disk/or inside of a zip file known to MeVisLab\n\
             . Every path is accepted.");
             #define DEFERRED_ADDRESS(ADDR) 0
             PyTypeObject PythonQtImporter_Type = {
               PyVarObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type), 0)
               "PythonQtImport.PythonQtImporter",
               sizeof(PythonQtImporter),
 ,          /* tp_itemsize */
               (destructor)PythonQtImporter_dealloc, /* tp_dealloc */
 ,          /* tp_print */
 ,          /* tp_getattr */
 ,          /* tp_setattr */
 ,          /* tp_compare */
 ,    /* tp_repr */
 ,          /* tp_as_number */
 ,          /* tp_as_sequence */
 ,          /* tp_as_mapping */
 ,          /* tp_hash */
 ,          /* tp_call */
 ,          /* tp_str */
               PyObject_GenericGetAttr,    /* tp_getattro */
 ,          /* tp_setattro */
 ,          /* tp_as_buffer */
               Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE ,    /* tp_flags */
               PythonQtImporter_doc,     /* tp_doc */
 ,      /* tp_traverse */
 ,          /* tp_clear */
 ,          /* tp_richcompare */
 ,          /* tp_weaklistoffset */
 ,          /* tp_iter */
 ,          /* tp_iternext */
               PythonQtImporter_methods,     /* tp_methods */
 ,          /* tp_members */
 ,          /* tp_getset */
 ,          /* tp_base */
 ,          /* tp_dict */
 ,          /* tp_descr_get */
 ,          /* tp_descr_set */
 ,          /* tp_dictoffset */
               (initproc)PythonQtImporter_init,    /* tp_init */
               PyType_GenericAlloc,      /* tp_alloc */
               PyType_GenericNew,      /* tp_new */
               PyObject_Del,     /* tp_free */
             };
             /* Given a buffer, return the long that is represented by the first
 bytes, encoded as little endian. This partially reimplements
                marshal.c:r_long() */
             long
             PythonQtImport::getLong(unsigned char *buf)
             {
               long x;
               x =  buf[0];
               x |= (long)buf[1] <<  8;
               x |= (long)buf[2] << 16;
               x |= (long)buf[3] << 24;
             #if SIZEOF_LONG > 4
               /* Sign extension for 64-bit machines */
               x |= -(x & 0x80000000L);
             #endif
               return x;
             }
             FILE *
             open_exclusive(const QString& filename)
             {
             #if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
               /* Use O_EXCL to avoid a race condition when another process tries to
                  write the same file.  When that happens, our open() call fails,
                  which is just fine (since it's only a cache).
                  XXX If the file exists and is writable but the directory is not
                  writable, the file will never be written.  Oh well.
               */
               QFile::remove(filename);
               int fd;
               int flags = O_EXCL|O_CREAT|O_WRONLY|O_TRUNC;
             #ifdef O_BINARY
                 flags |= O_BINARY;   /* necessary for Windows */
             #endif
             #ifdef WIN32
               fd = _wopen(filename.ucs2(), flags, 0666);
             #else
               fd = open(filename.local8Bit(), flags, 0666);
             #endif
               if (fd < 0)
                 return NULL;
               return fdopen(fd, "wb");
             #else
               /* Best we can do -- on Windows this can't happen anyway */
               return fopen(filename.toLocal8Bit().constData(), "wb");
             #endif
             }
             void PythonQtImport::writeCompiledModule(PyCodeObject *co, const QString& filename, long mtime)
             {
               FILE *fp;
               // we do not want to write Qt resources to disk, do we?
               if (filename.startsWith(":")) {
                 return;
               }
               fp = open_exclusive(filename);
               if (fp == NULL) {
                 if (Py_VerboseFlag)
                   PySys_WriteStderr(
                   "# can't create %s\n", filename.toLatin1().constData());
                 return;
               }
             #if PY_VERSION_HEX < 0x02040000
               PyMarshal_WriteLongToFile(PyImport_GetMagicNumber(), fp);
             #else
               PyMarshal_WriteLongToFile(PyImport_GetMagicNumber(), fp, Py_MARSHAL_VERSION);
             #endif
               /* First write a 0 for mtime */
             #if PY_VERSION_HEX < 0x02040000
               PyMarshal_WriteLongToFile(0L, fp);
             #else
               PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
             #endif
             #if PY_VERSION_HEX < 0x02040000
               PyMarshal_WriteObjectToFile((PyObject *)co, fp);
             #else
               PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
             #endif
               if (ferror(fp)) {
                 if (Py_VerboseFlag)
                   PySys_WriteStderr("# can't write %s\n", filename.toLatin1().constData());
                 /* Don't keep partial file */
                 fclose(fp);
                 QFile::remove(filename);
                 return;
               }
               /* Now write the true mtime */
               fseek(fp, 4L, 0);
             #if PY_VERSION_HEX < 0x02040000
               PyMarshal_WriteLongToFile(mtime, fp);
             #else
               PyMarshal_WriteLongToFile(mtime, fp, Py_MARSHAL_VERSION);
             #endif
               fflush(fp);
               fclose(fp);
               if (Py_VerboseFlag)
                 PySys_WriteStderr("# wrote %s\n", filename.toLatin1().constData());
             //#ifdef macintosh
             //  PyMac_setfiletype(cpathname, 'Pyth', 'PYC ');
             //#endif
             }
             /* Given the contents of a .py[co] file in a buffer, unmarshal the data
                and return the code object. Return None if it the magic word doesn't
                match (we do this instead of raising an exception as we fall back
                to .py if available and we don't want to mask other errors).
                Returns a new reference. */
             PyObject *
             PythonQtImport::unmarshalCode(const QString& path, const QByteArray& data, time_t mtime)
             {
               PyObject *code;
               // ugly cast, but Python API is not const safe
               char *buf = (char*) data.constData();
               int size = data.size();
               if (size <= 9) {
                 PySys_WriteStderr("# %s has bad pyc data\n",
                         path.toLatin1().constData());
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               if (getLong((unsigned char *)buf) != PyImport_GetMagicNumber()) {
                 if (Py_VerboseFlag)
                   PySys_WriteStderr("# %s has bad magic\n",
                         path.toLatin1().constData());
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               if (mtime != 0) {
                 time_t timeDiff = getLong((unsigned char *)buf + 4) - mtime;
                 if (timeDiff<0) { timeDiff = -timeDiff; }
                 if (timeDiff > 1) {
                   if (Py_VerboseFlag)
                     PySys_WriteStderr("# %s has bad mtime\n",
                     path.toLatin1().constData());
                   Py_INCREF(Py_None);
                   return Py_None;
                 }
               }
               code = PyMarshal_ReadObjectFromString(buf + 8, size - 8);
               if (code == NULL)
                 return NULL;
               if (!PyCode_Check(code)) {
                 Py_DECREF(code);
                 PyErr_Format(PyExc_TypeError,
                      "compiled module %.200s is not a code object",
                      path.toLatin1().constData());
                 return NULL;
               }
               return code;
             }
             /* Given a string buffer containing Python source code, compile it
                return and return a code object as a new reference. */
             PyObject *
             PythonQtImport::compileSource(const QString& path, const QByteArray& data)
             {
               PyObject *code;
               QByteArray data1 = data;
             // in qt4, data is null terminated
             //  data1.resize(data.size()+1);
             //  data1.data()[data.size()-1] = 0;
               code = Py_CompileString(data.data(), path.toLatin1().constData(),
                     Py_file_input);
               return code;
             }
             /* Return the code object for the module named by 'fullname' from the
                Zip archive as a new reference. */
             PyObject *
             PythonQtImport::getCodeFromData(const QString& path, int isbytecode,int /*ispackage*/, time_t mtime)
             {
               PyObject *code;
               QByteArray qdata;
                 if (!isbytecode) {
                   //    mlabDebugConst("MLABPython", "reading source " << path);
                   bool ok;
                   qdata = PythonQt::importInterface()->readSourceFile(path, ok);
                   if (!ok) {
                     //    mlabErrorConst("PythonQtImporter","File could not be verified" << path);
                     return NULL;
                   }
                   if (qdata == " ") {
                     qdata.clear();
                   }
                 } else {
                   qdata = PythonQt::importInterface()->readFileAsBytes(path);
                 }
               if (isbytecode) {
             //    mlabDebugConst("MLABPython", "reading bytecode " << path);
                 code = unmarshalCode(path, qdata, mtime);
               }
               else {
               //  mlabDebugConst("MLABPython", "compiling source " << path);
                 code = compileSource(path, qdata);
                 if (code) {
                   // save a pyc file if possible
                   QDateTime time;
                   time = PythonQt::importInterface()->lastModifiedDate(path);
                   writeCompiledModule((PyCodeObject*)code, path+"c", time.toTime_t());
                 }
               }
               return code;
             }
             time_t
             PythonQtImport::getMTimeOfSource(const QString& path)
             {
               time_t mtime = 0;
               QString path2 = path;
               path2.truncate(path.length()-1);
               if (PythonQt::importInterface()->exists(path2)) {
                 QDateTime t = PythonQt::importInterface()->lastModifiedDate(path2);
                 if (t.isValid()) {
                   mtime = t.toTime_t();
                 }
               }
               return mtime;
             }
             /* Get the code object associated with the module specified by
                'fullname'. */
             PyObject *
             PythonQtImport::getModuleCode(PythonQtImporter *self, const char* fullname, QString& modpath)
             {
               QString subname;
               struct st_mlab_searchorder *zso;
               subname = getSubName(fullname);
               QString path = *self->_path + "/" + subname;
               QString test;
               for (zso = mlab_searchorder; *zso->suffix; zso++) {
                 PyObject *code = NULL;
                 test = path + zso->suffix;
                 if (Py_VerboseFlag > 1)
                   PySys_WriteStderr("# trying %s\n",
                         test.toLatin1().constData());
                 if (PythonQt::importInterface()->exists(test)) {
                   time_t mtime = 0;
                   int ispackage = zso->type & IS_PACKAGE;
                   int isbytecode = zso->type & IS_BYTECODE;
                   // if ignoreUpdatedPythonSourceFiles() returns true, then mtime stays 0
                   // and unmarshalCode() in getCodeFromData() will always read an existing *.pyc file,
                   // even if a newer *.py file exists. This is a release optimization where
                   // typically only *.pyc files are delivered without *.py files and reading file
                   // modification time is slow.
                   if (isbytecode && !PythonQt::importInterface()->ignoreUpdatedPythonSourceFiles()) {
                     mtime = getMTimeOfSource(test);
                   }
                   code = getCodeFromData(test, isbytecode, ispackage, mtime);
                   if (code == Py_None) {
                     Py_DECREF(code);
                     continue;
                   }
                   if (code != NULL) {
                     modpath = test;
                   }
                   return code;
                 }
               }
               PyErr_Format(PythonQtImportError, "can't find module '%.200s'", fullname);
               return NULL;
             }
             QString PythonQtImport::replaceExtension(const QString& str, const QString& ext)
             {
              QString r;
              int i = str.lastIndexOf('.');
              if (i!=-1) {
                r = str.mid(0,i) + "." + ext;
              } else {
                r = str + "." + ext;
              }
              return r;
             }
             PyObject* PythonQtImport::getCodeFromPyc(const QString& file)
             {
               PyObject* code;
               const static QString pycStr("pyc");
               QString pyc = replaceExtension(file, pycStr);
               if (PythonQt::importInterface()->exists(pyc)) {
                 time_t mtime = 0;
                 // if ignoreUpdatedPythonSourceFiles() returns true, then mtime stays 0
                 // and unmarshalCode() in getCodeFromData() will always read an existing *.pyc file,
                 // even if a newer *.py file exists. This is a release optimization where
                 // typically only *.pyc files are delivered without *.py files and reading file
                 // modification time is slow.
                 if (!PythonQt::importInterface()->ignoreUpdatedPythonSourceFiles()) {
                   mtime = getMTimeOfSource(pyc);
                 }
                 code = getCodeFromData(pyc, true, false, mtime);
                 if (code != Py_None && code != NULL) {
                   return code;
                 }
                 if (code) {
                   Py_DECREF(code);
                 }
               }
               code = getCodeFromData(file,false,false,0);
               return code;
             }
             /* Module init */
             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;
               if (!first) {
                 return;
               }
               first = false;
               PyObject *mod;
               if (PyType_Ready(&PythonQtImporter_Type) < 0)
                 return;
               /* Correct directory separator */
               mlab_searchorder[0].suffix[0] = SEP;
               mlab_searchorder[1].suffix[0] = SEP;
               mlab_searchorder[2].suffix[0] = SEP;
               if (Py_OptimizeFlag) {
                 /* Reverse *.pyc and *.pyo */
                 struct st_mlab_searchorder tmp;
                 tmp = mlab_searchorder[0];
                 mlab_searchorder[0] = mlab_searchorder[1];
                 mlab_searchorder[1] = tmp;
                 tmp = mlab_searchorder[3];
                 mlab_searchorder[3] = mlab_searchorder[4];
                 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);
               if (PythonQtImportError == NULL)
                 return;
               Py_INCREF(PythonQtImportError);
               if (PyModule_AddObject(mod, "PythonQtImportError",
                          PythonQtImportError) < 0)
                 return;
               Py_INCREF(&PythonQtImporter_Type);
               if (PyModule_AddObject(mod, "PythonQtImporter",
                          (PyObject *)&PythonQtImporter_Type) < 0)
                 return;
               // set our importer into the path_hooks to handle all path on sys.path
               PyObject* classobj = PyDict_GetItemString(PyModule_GetDict(mod), "PythonQtImporter");
               PyObject* path_hooks = PySys_GetObject(const_cast<char*>("path_hooks"));
               PyList_Append(path_hooks, classobj);
             #ifndef WIN32
               // reload the encodings module, because it might fail to custom import requirements (e.g. encryption).
               PyObject* modules         = PyImport_GetModuleDict();
               PyObject* encodingsModule = PyDict_GetItemString(modules, "encodings");
               if (encodingsModule != NULL) {
                 PyImport_ReloadModule(encodingsModule);
               }
             #endif
             }

src/PythonQtInstanceWrapper.cpp +1 -5

             /*
             *
             *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
             *
             *  This library is free software; you can redistribute it and/or
             *  modify it under the terms of the GNU Lesser General Public
             *  License as published by the Free Software Foundation; either
             *  version 2.1 of the License, or (at your option) any later version.
             *
             *  This library is distributed in the hope that it will be useful,
             *  but WITHOUT ANY WARRANTY; without even the implied warranty of
             *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
             *  Lesser General Public License for more details.
             *
             *  Further, this software is distributed without any warranty that it is
             *  free of the rightful claim of any third person regarding infringement
             *  or the like.  Any license provided herein, whether implied or
             *  otherwise, applies only to this software file.  Patent licenses, if
             *  any, provided herein do not apply to combinations of this program with
             *  other software, or any other product whatsoever.
             *
             *  You should have received a copy of the GNU Lesser General Public
             *  License along with this library; if not, write to the Free Software
             *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             *
             *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
             *  28359 Bremen, Germany or:
             *
             *  http://www.mevis.de
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtInstanceWrapper.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtInstanceWrapper.h"
             #include <QObject>
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtSignal.h"
             #include "PythonQtClassInfo.h"
             #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*)Py_TYPE(this))->_classInfo;
             }
             static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self, bool force = false) {
               // is this a C++ wrapper?
               if (self->_wrappedPtr) {
                 //mlabDebugConst("Python","c++ wrapper removed " << self->_wrappedPtr << " " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1());
                 PythonQt::priv()->removeWrapperPointer(self->_wrappedPtr);
                 // we own our qobject, so we delete it now:
                 delete self->_obj;
                 self->_obj = NULL;
                 if (force || self->_ownedByPythonQt) {
                   int type = self->classInfo()->metaTypeId();
                   if (self->_useQMetaTypeDestroy && type>=0) {
                     // use QMetaType to destroy the object
                     QMetaType::destroy(type, self->_wrappedPtr);
                   } else {
                     PythonQtSlotInfo* slot = self->classInfo()->destructor();
                     if (slot) {
                       void* args[2];
                       args[0] = NULL;
                       args[1] = &self->_wrappedPtr;
                       slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, slot->slotIndex(), args);
                       self->_wrappedPtr = NULL;
                     } else {
                       if (type>=0) {
                         // use QMetaType to destroy the object
                         QMetaType::destroy(type, self->_wrappedPtr);
                       } else {
                         // TODO: warn about not being able to destroy the object?
                       }
                     }
                   }
                 }
               } else {
                 //mlabDebugConst("Python","qobject wrapper removed " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1());
                 if (self->_objPointerCopy) {
                   PythonQt::priv()->removeWrapperPointer(self->_objPointerCopy);
                 }
                 if (self->_obj) {
                   if (force || self->_ownedByPythonQt) {
                     if (force || !self->_obj->parent()) {
                       delete self->_obj;
                     }
                   } else {
                     if (self->_obj->parent()==NULL) {
                       // tell someone who is interested that the qobject is no longer wrapped, if it has no parent
                       PythonQt::qObjectNoLongerWrappedCB(self->_obj);
                     }
                   }
                 }
               }
               self->_obj = NULL;
             }
             static void PythonQtInstanceWrapper_dealloc(PythonQtInstanceWrapper* self)
             {
               PythonQtInstanceWrapper_deleteObject(self);
               self->_obj.~QPointer<QObject>();
               Py_TYPE(self)->tp_free((PyObject*)self);
             }
             static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               //PythonQtClassWrapper    *classType = (PythonQtClassWrapper*)type;
               PythonQtInstanceWrapper *self;
               static PyObject* emptyTuple = NULL;
               if (emptyTuple==NULL) {
                 emptyTuple = PyTuple_New(0);
               }
               self = (PythonQtInstanceWrapper*)PyBaseObject_Type.tp_new(type, emptyTuple, NULL);
               if (self != NULL) {
                 new (&self->_obj) QPointer<QObject>();
                 self->_wrappedPtr = NULL;
                 self->_ownedByPythonQt = false;
                 self->_useQMetaTypeDestroy = false;
                 self->_isShellInstance = false;
               }
               return (PyObject *)self;
             }
             int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds)
             {
               if (args == PythonQtPrivate::dummyTuple()) {
                 // we are called from the internal PythonQt API, so our data will be filled later on...
                 return 0;
               }
               // we are called from python, try to construct our object
               if (self->classInfo()->constructors()) {
                 void* directCPPPointer = NULL;
                 PythonQtSlotFunction_CallImpl(self->classInfo(), NULL, self->classInfo()->constructors(), args, kwds, NULL, &directCPPPointer);
                 if (PyErr_Occurred()) {
                   return -1;
                 }
                 if (directCPPPointer) {
                   // change ownershipflag to be owned by PythonQt
                   self->_ownedByPythonQt = true;
                   self->_useQMetaTypeDestroy = false;
                   if (self->classInfo()->isCPPWrapper()) {
                     self->_wrappedPtr = directCPPPointer;
                     // TODO xxx: if there is a wrapper factory, we might want to generate a wrapper for our class?!
                   } else {
                     self->setQObject((QObject*)directCPPPointer);
                   }
                   // register with PythonQt
                   PythonQt::priv()->addWrapperPointer(directCPPPointer, self);
                   PythonQtShellSetInstanceWrapperCB* cb = self->classInfo()->shellSetInstanceWrapperCB();
                   if (cb) {
                     // if we are a derived python class, we set the wrapper
                     // to activate the shell class, otherwise we just ignore that it is a shell...
                     // we detect it be checking if the type does not have PythonQtInstanceWrapper_Type as direct base class,
                     // which is the case for all non-python derived types
                     if (((PyObject*)self)->ob_type->tp_base != &PythonQtInstanceWrapper_Type) {
                       // set the wrapper and remember that we have a shell instance!
                       (*cb)(directCPPPointer, self);
                       self->_isShellInstance = true;
                     }
                   }
                 }
               } else {
                 QString error = QString("No constructors available for ") + self->classInfo()->className();
                 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                 return -1;
               }
               return 0;
             }
             static PyObject *PythonQtInstanceWrapper_richcompare(PythonQtInstanceWrapper* wrapper, PyObject* other, int code)
             {
               bool validPtrs = false;
               bool areSamePtrs = false;
               if (PyObject_TypeCheck((PyObject*)wrapper, &PythonQtInstanceWrapper_Type)) {
                 if (PyObject_TypeCheck(other, &PythonQtInstanceWrapper_Type)) {
                   validPtrs = true;
                   PythonQtInstanceWrapper* w1 = wrapper;
                   PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)other;
                   // check pointers directly
                   if (w1->_wrappedPtr != NULL) {
                     if (w1->_wrappedPtr == w2->_wrappedPtr) {
                       areSamePtrs = true;
                     }
                   } else if (w1->_obj == w2->_obj) {
                     areSamePtrs = true;
                   }
                 } else if (other == Py_None) {
                   validPtrs = true;
                   if (wrapper->_obj || wrapper->_wrappedPtr) {
                     areSamePtrs = false;
                   } else {
                     areSamePtrs = true;
                   }
                 }
               }
               if ((wrapper->classInfo()->typeSlots() & PythonQt::Type_RichCompare) == 0) {
                 // shortcut if richcompare is not supported:
                 if (validPtrs && code == Py_EQ) {
                   return PythonQtConv::GetPyBool(areSamePtrs);
                 } else if (validPtrs && code == Py_NE) {
                   return PythonQtConv::GetPyBool(!areSamePtrs);
                 }
                 Py_INCREF(Py_NotImplemented);
                 return Py_NotImplemented;
               }
               QByteArray memberName;
               switch (code) {
               case Py_LT:
                 {
                   static QByteArray name = "__lt__";
                   memberName = name;
                 }
                 break;
               case Py_LE:
                 {
                   static QByteArray name = "__le__";
                   memberName = name;
                 }
                 break;
               case Py_EQ:
                 {
                   static QByteArray name = "__eq__";
                   memberName = name;
                 }
                 break;
               case Py_NE:
                 {
                   static QByteArray name = "__ne__";
                   memberName = name;
                 }
                 break;
               case Py_GT:
                 {
                   static QByteArray name = "__gt__";
                   memberName = name;
                 }
                 break;
               case Py_GE:
                 {
                   static QByteArray name = "__ge__";
                   memberName = name;
                 }
                 break;
               }
               PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);
               if (opSlot._type == PythonQtMemberInfo::Slot) {
                 // TODO get rid of tuple
                 PyObject* args = PyTuple_New(1);
                 Py_INCREF(other);
                 PyTuple_SET_ITEM(args, 0, other);
                 PyObject* result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, args, NULL, wrapper->_wrappedPtr);
                 Py_DECREF(args);
                 return result;
               } else {
                 // not implemented, let python try something else!
                 Py_INCREF(Py_NotImplemented);
                 return Py_NotImplemented;
               }
             }
             static PyObject *PythonQtInstanceWrapper_classname(PythonQtInstanceWrapper* obj)
             {
             #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)
             {
               char *name = NULL;
               if (!PyArg_ParseTuple(args, "s:PythonQtInstanceWrapper.inherits",&name)) {
                 return NULL;
               }
               return PythonQtConv::GetPyBool(obj->classInfo()->inherits(name));
             }
             static PyObject *PythonQtInstanceWrapper_help(PythonQtInstanceWrapper* obj)
             {
               return PythonQt::self()->helpCalled(obj->classInfo());
             }
             PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self)
             {
               PythonQtInstanceWrapper_deleteObject(self, true);
               Py_INCREF(Py_None);
               return Py_None;
             }
             static PyMethodDef PythonQtInstanceWrapper_methods[] = {
                 {"className", (PyCFunction)PythonQtInstanceWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
                 {"inherits", (PyCFunction)PythonQtInstanceWrapper_inherits, METH_VARARGS,
                 "Returns if the class inherits or is of given type name"
                 },
                 {"help", (PyCFunction)PythonQtInstanceWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
                 {"delete", (PyCFunction)PythonQtInstanceWrapper_delete, METH_NOARGS,
                 "Deletes the C++ object (at your own risk, my friend!)"
                 },
             {NULL, NULL, 0, NULL}  /* Sentinel */
             };
             static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name)
             {
               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;
               }
               if (qstrcmp(attributeName, "__dict__")==0) {
                 PyObject* dict = PyBaseObject_Type.tp_getattro(obj, name);
                 dict = PyDict_Copy(dict);
                 if (wrapper->_obj) {
                   // only the properties are missing, the rest is already available from
                   // PythonQtClassWrapper...
                   QStringList l = wrapper->classInfo()->propertyList();
                   Q_FOREACH (QString name, l) {
                     PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
                     if (o) {
                       PyDict_SetItemString(dict, name.toLatin1().data(), o);
                       Py_DECREF(o);
                     } else {
                       std::cerr << "PythonQtInstanceWrapper: something is wrong, could not get attribute " << name.toLatin1().data();
                     }
                   }
                   QList<QByteArray> dynamicProps = wrapper->_obj->dynamicPropertyNames();
                   Q_FOREACH (QByteArray name, dynamicProps) {
                     PyObject* o = PyObject_GetAttrString(obj, name.data());
                     if (o) {
                       PyDict_SetItemString(dict, name.data(), o);
                       Py_DECREF(o);
                     } else {
                       std::cerr << "PythonQtInstanceWrapper: dynamic property could not be read " << name.data();
                     }
                   }
                 }
                 // Note: we do not put children into the dict, is would look confusing?!
                 return dict;
               }
               // first look in super, to return derived methods from base object first
               PyObject* superAttr = PyBaseObject_Type.tp_getattro(obj, name);
               if (superAttr) {
                 return superAttr;
               }
               PyErr_Clear();
               //  mlabDebugConst("Python","get " << attributeName);
               PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
               switch (member._type) {
               case PythonQtMemberInfo::Property:
                 if (wrapper->_obj) {
                   if (member._property.userType() != QVariant::Invalid) {
                     PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB();
                     if (profilingCB) {
                       QString methodName = "getProperty(";
                       methodName += attributeName;
                       methodName += ")";
                       profilingCB(PythonQt::Enter, wrapper->_obj->metaObject()->className(), methodName.toLatin1());
                     }
                     PyObject* value = PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj));
                     if (profilingCB) {
                       profilingCB(PythonQt::Leave, NULL, NULL);
                     }
                     return value;
                   } else {
                     Py_INCREF(Py_None);
                     return Py_None;
                   }
                 } else {
                   QString error = QString("Trying to read property '") + attributeName + "' from a destroyed " + wrapper->classInfo()->className() + " object";
                   PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                   return NULL;
                 }
                 break;
               case PythonQtMemberInfo::Slot:
                 return PythonQtSlotFunction_New(member._slot, obj, NULL);
                 break;
               case PythonQtMemberInfo::Signal:
                 return PythonQtSignalFunction_New(member._slot, obj, NULL);
                 break;
               case PythonQtMemberInfo::EnumValue:
                 {
                   PyObject* enumValue = member._enumValue;
                   Py_INCREF(enumValue);
                   return enumValue;
                 }
                 break;
               case PythonQtMemberInfo::EnumWrapper:
                 {
                   PyObject* enumWrapper = member._enumWrapper;
                   Py_INCREF(enumWrapper);
                   return enumWrapper;
                 }
                 break;
               case PythonQtMemberInfo::NotFound:
                 {
                   static const QByteArray getterString("py_get_");
                   // check for a getter slot
                   PythonQtMemberInfo member = wrapper->classInfo()->member(getterString + attributeName);
                   if (member._type == PythonQtMemberInfo::Slot) {
                     return PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, member._slot, NULL, NULL, wrapper->_wrappedPtr);
                   }
                   // handle dynamic properties
                   if (wrapper->_obj) {
                     QVariant v = wrapper->_obj->property(attributeName);
                     if (v.isValid()) {
                       return PythonQtConv::QVariantToPyObject(v);
                     }
                   }
                 }
                 break;
               default:
                 // is an invalid type, go on
                 break;
               }
               // 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;
               }
               PyErr_Clear();
               if (wrapper->_obj) {
                 // look for a child
                 QObjectList children = wrapper->_obj->children();
                 for (int i = 0; i < children.count(); i++) {
                   QObject *child = children.at(i);
                   if (child->objectName() == attributeName) {
                     return PythonQt::priv()->wrapQObject(child);
                   }
                 }
               }
               QString error = QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'";
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return NULL;
             }
             static int PythonQtInstanceWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
             {
               QString error;
               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 (member._type == PythonQtMemberInfo::Property) {
                 if (!wrapper->_obj) {
                   error = QString("Trying to set property '") + attributeName + "' on a destroyed " + wrapper->classInfo()->className() + " object";
                   PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
                   return -1;
                 }
                 QMetaProperty prop = member._property;
                 if (prop.isWritable()) {
                   QVariant v;
                   if (prop.isEnumType()) {
                     // this will give us either a string or an int, everything else will probably be an error
                     v = PythonQtConv::PyObjToQVariant(value);
                   } else {
                     int t = prop.userType();
                     v = PythonQtConv::PyObjToQVariant(value, t);
                   }
                   bool success = false;
                   if (v.isValid()) {
                     PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB();
                     if (profilingCB) {
                       QString methodName = "setProperty(";
                       methodName += attributeName;
                       methodName += ")";
                       profilingCB(PythonQt::Enter, wrapper->_obj->metaObject()->className(), methodName.toLatin1());
                     }
                     success = prop.write(wrapper->_obj, v);
                     if (profilingCB) {
                       profilingCB(PythonQt::Leave, NULL, NULL);
                     }
                   }
                   if (success) {
                     return 0;
                   } else {
                     error = QString("Property '") + attributeName + "' of type '" +
                       prop.typeName() + "' does not accept an object of type "
                       + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")";
                   }
                 } else {
                   error = QString("Property '") + attributeName + "' of " + obj->ob_type->tp_name + " object is not writable";
                 }
               } else if (member._type == PythonQtMemberInfo::Slot) {
                 error = QString("Slot '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
               } else if (member._type == PythonQtMemberInfo::Signal) {
                 error = QString("Signal '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
               } else if (member._type == PythonQtMemberInfo::EnumValue) {
                 error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
               } else if (member._type == PythonQtMemberInfo::EnumWrapper) {
                 error = QString("Enum '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
               } else if (member._type == PythonQtMemberInfo::NotFound) {
                 // check for a setter slot
                 static const QByteArray setterString("py_set_");
                 PythonQtMemberInfo setter = wrapper->classInfo()->member(setterString + attributeName);
                 if (setter._type == PythonQtMemberInfo::Slot) {
                   // call the setter and ignore the result value
                   void* result;
                   PyObject* args = PyTuple_New(1);
                   Py_INCREF(value);
                   PyTuple_SET_ITEM(args, 0, value);
                   PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, setter._slot, args, NULL, wrapper->_wrappedPtr, &result);
                   Py_DECREF(args);
                   return 0;
                 }
                 // handle dynamic properties
                 if (wrapper->_obj) {
                   QVariant prop = wrapper->_obj->property(attributeName);
                   if (prop.isValid()) {
                     QVariant v = PythonQtConv::PyObjToQVariant(value);
                     if (v.isValid()) {
                       wrapper->_obj->setProperty(attributeName, v);
                       return 0;
                     } else {
                       error = QString("Dynamic property '") + attributeName + "' does not accept an object of type "
                       + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")";
                       PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
                       return -1;
                     }
                   }
                 }
                 // if we are a derived python class, we allow setting attributes.
                 // if we are a direct CPP wrapper, we do NOT allow it, since
                 // it would be confusing to allow it because a wrapper will go away when it is not seen by python anymore
                 // and when it is recreated from a CPP pointer the attributes are gone...
                 if (obj->ob_type->tp_base != &PythonQtInstanceWrapper_Type) {
                   return PyBaseObject_Type.tp_setattro(obj,name,value);
                 } else {
                   error = QString("'") + attributeName + "' does not exist on " + obj->ob_type->tp_name + " and creating new attributes on C++ objects is not allowed";
                 }
               }
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return -1;
             }
             static QString getStringFromObject(PythonQtInstanceWrapper* wrapper) {
               QString result;
               if (wrapper->_wrappedPtr) {
                 // first try some manually string conversions for some variants
                 int metaid = wrapper->classInfo()->metaTypeId();
                 result = PythonQtConv::CPPObjectToString(metaid, wrapper->_wrappedPtr);
                 if (!result.isEmpty()) {
                   return result;
                 }
               }
               if (wrapper->_wrappedPtr || wrapper->_obj) {
                 // next, try to call py_toString
                 PythonQtMemberInfo info = wrapper->classInfo()->member("py_toString");
                 if (info._type == PythonQtMemberInfo::Slot) {
                   PyObject* resultObj = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, info._slot, NULL, NULL, wrapper->_wrappedPtr);
                   if (resultObj) {
                     // TODO this is one conversion too much, would be nicer to call the slot directly...
                     result = PythonQtConv::PyObjGetString(resultObj);
                     Py_DECREF(resultObj);
                   }
                 }
               }
               return result;
             }
             static PyObject * PythonQtInstanceWrapper_str(PyObject * obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               // QByteArray should be directly returned as a str
               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
                 }
               }
               const char* typeName = obj->ob_type->tp_name;
               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) {
             #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
               }
             }
             static PyObject * PythonQtInstanceWrapper_repr(PyObject * obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               const char* typeName = obj->ob_type->tp_name;
               QObject *qobj = wrapper->_obj;
               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
               }
             }
             static int PythonQtInstanceWrapper_builtin_nonzero(PyObject *obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               return (wrapper->_wrappedPtr == NULL && wrapper->_obj == NULL)?0:1;
             }
             static long PythonQtInstanceWrapper_hash(PythonQtInstanceWrapper *obj)
             {
               if (obj->_wrappedPtr != NULL) {
                 return reinterpret_cast<long>(obj->_wrappedPtr);
               } else {
                 QObject* qobj = obj->_obj; // get pointer from QPointer wrapper
                 return reinterpret_cast<long>(qobj);
               }
             }
             // we override nb_nonzero, so that one can do 'if' expressions to test for a NULL ptr
             static PyNumberMethods PythonQtInstanceWrapper_as_number = {
 ,      /* 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 / 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_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_inplace_rshift */
 ,      /* nb_inplace_and */
 ,      /* nb_inplace_xor */
 ,      /* nb_inplace_or */
 ,      /* nb_floor_divide */
 ,      /* nb_true_divide */
 ,      /* nb_inplace_floor_divide */
 ,      /* nb_inplace_true_divide */
             #ifdef PY3K
 ,      /* nb_index in Py3K */
             #endif
             };
             PyTypeObject PythonQtInstanceWrapper_Type = {
                 PyVarObject_HEAD_INIT(&PythonQtClassWrapper_Type, 0)
                 "PythonQt.PythonQtInstanceWrapper",             /*tp_name*/
                 sizeof(PythonQtInstanceWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
                 (destructor)PythonQtInstanceWrapper_dealloc, /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
 ,                         /*tp_compare*/
                 PythonQtInstanceWrapper_repr,            /*tp_repr*/
                 &PythonQtInstanceWrapper_as_number,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
                 (hashfunc)PythonQtInstanceWrapper_hash,                         /*tp_hash */
 ,                         /*tp_call*/
                 PythonQtInstanceWrapper_str,      /*tp_str*/
                 PythonQtInstanceWrapper_getattro,                         /*tp_getattro*/
                 PythonQtInstanceWrapper_setattro,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE /*| Py_TPFLAGS_CHECKTYPES FIXME Py_TPFLAGS_CHECKTYPES removal */, /*tp_flags*/
                 "PythonQtInstanceWrapper object",           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
                 (richcmpfunc)PythonQtInstanceWrapper_richcompare,                   /* tp_richcompare */
 ,                   /* tp_weaklistoffset */
 ,                   /* tp_iter */
 ,                   /* tp_iternext */
-,             /* tp_methods */
+                PythonQtInstanceWrapper_methods,             /* tp_methods */
 ,             /* tp_members */
 ,                         /* tp_getset */
 ,                         /* tp_base */
 ,                         /* tp_dict */
 ,                         /* tp_descr_get */
 ,                         /* tp_descr_set */
 ,                         /* tp_dictoffset */
                 (initproc)PythonQtInstanceWrapper_init,      /* tp_init */
 ,                         /* tp_alloc */
                 PythonQtInstanceWrapper_new,                 /* tp_new */
             };
             //-------------------------------------------------------

src/PythonQtSlot.cpp 0 -4

             /*
             *
             *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
             *
             *  This library is free software; you can redistribute it and/or
             *  modify it under the terms of the GNU Lesser General Public
             *  License as published by the Free Software Foundation; either
             *  version 2.1 of the License, or (at your option) any later version.
             *
             *  This library is distributed in the hope that it will be useful,
             *  but WITHOUT ANY WARRANTY; without even the implied warranty of
             *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
             *  Lesser General Public License for more details.
             *
             *  Further, this software is distributed without any warranty that it is
             *  free of the rightful claim of any third person regarding infringement
             *  or the like.  Any license provided herein, whether implied or
             *  otherwise, applies only to this software file.  Patent licenses, if
             *  any, provided herein do not apply to combinations of this program with
             *  other software, or any other product whatsoever.
             *
             *  You should have received a copy of the GNU Lesser General Public
             *  License along with this library; if not, write to the Free Software
             *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             *
             *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
             *  28359 Bremen, Germany or:
             *
             *  http://www.mevis.de
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtSlot.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtInstanceWrapper.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtMisc.h"
             #include "PythonQtConversion.h"
             #include <iostream>
             #include <exception>
             #include <stdexcept>
             #include <QByteArray>
-            #if PY_MAJOR_VERSION >= 3
-            #define PY3K
-            #endif
             #define PYTHONQT_MAX_ARGS 32
             bool PythonQtCallSlot(PythonQtClassInfo* classInfo, QObject* objectToCall, PyObject* args, bool strict, PythonQtSlotInfo* info, void* firstArgument, PyObject** pythonReturnValue, void** directReturnValuePointer)
             {
               static unsigned int recursiveEntry = 0;
               if (directReturnValuePointer) {
                 *directReturnValuePointer = NULL;
               }
               // store the current storage position, so that we can get back to this state after a slot is called
               // (do this locally, so that we have all positions on the stack
               PythonQtValueStoragePosition globalValueStoragePos;
               PythonQtValueStoragePosition globalPtrStoragePos;
               PythonQtValueStoragePosition globalVariantStoragePos;
               PythonQtConv::global_valueStorage.getPos(globalValueStoragePos);
               PythonQtConv::global_ptrStorage.getPos(globalPtrStoragePos);
               PythonQtConv::global_variantStorage.getPos(globalVariantStoragePos);
               recursiveEntry++;
               // the arguments that are passed to qt_metacall
               void* argList[PYTHONQT_MAX_ARGS];
               PyObject* result = NULL;
               int argc = info->parameterCount();
               const QList<PythonQtSlotInfo::ParameterInfo>& params = info->parameters();
               const PythonQtSlotInfo::ParameterInfo& returnValueParam = params.at(0);
               // set return argument to NULL
               argList[0] = NULL;
               bool ok = true;
               bool skipFirst = false;
               if (info->isInstanceDecorator()) {
                 skipFirst = true;
                 // for decorators on CPP objects, we take the cpp ptr, for QObjects we take the QObject pointer
                 void* arg1 = firstArgument;
                 if (!arg1) {
                   arg1 = objectToCall;
                 }
                 if (arg1) {
                   // upcast to correct parent class
                   arg1 = ((char*)arg1)+info->upcastingOffset();
                 }
                 argList[1] = &arg1;
                 if (ok) {
                   for (int i = 2; i<argc && ok; i++) {
                     const PythonQtSlotInfo::ParameterInfo& param = params.at(i);
                     argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-2), strict, classInfo);
                     if (argList[i]==NULL) {
                       ok = false;
                       break;
                     }
                   }
                 }
               } else {
                 for (int i = 1; i<argc && ok; i++) {
                   const PythonQtSlotInfo::ParameterInfo& param = params.at(i);
                   argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-1), strict, classInfo);
                   if (argList[i]==NULL) {
                     ok = false;
                     break;
                   }
                 }
               }
               if (ok) {
                 // parameters are ok, now create the qt return value which is assigned to by metacall
                 if (returnValueParam.typeId != QMetaType::Void) {
                   // create empty default value for the return value
                   if (!directReturnValuePointer) {
                     // create empty default value for the return value
                     argList[0] = PythonQtConv::CreateQtReturnValue(returnValueParam);
                     if (argList[0]==NULL) {
                       // return value could not be created, maybe we have a registered class with a default constructor, so that we can construct the pythonqt wrapper object and
                       // pass its internal pointer
                       PythonQtClassInfo* info = PythonQt::priv()->getClassInfo(returnValueParam.name);
                       if (info && info->pythonQtClassWrapper()) {
                         PyObject* emptyTuple = PyTuple_New(0);
                         // 1) default construct an empty object as python object (owned by PythonQt), by calling the meta class with empty arguments
                         result = PyObject_Call((PyObject*)info->pythonQtClassWrapper(), emptyTuple, NULL);
                         if (result) {
                           argList[0] = ((PythonQtInstanceWrapper*)result)->_wrappedPtr;
                         }
                         Py_DECREF(emptyTuple);
                       }
                     }
                   } else {
                     // we can use our pointer directly!
                     argList[0] = directReturnValuePointer;
                   }
                 }
                 PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB();
                 if (profilingCB) {
                   const char* className = NULL;
                   if (info->decorator()) {
                     className = info->decorator()->metaObject()->className();
                   } else {
                     className = objectToCall->metaObject()->className();
                   }
             #if( QT_VERSION >= QT_VERSION_CHECK(5,0,0) )
                   profilingCB(PythonQt::Enter, className, info->metaMethod()->methodSignature());
             #else
                   profilingCB(PythonQt::Enter, className, info->metaMethod()->signature());
             #endif
                 }
                 // invoke the slot via metacall
                 bool hadException = false;
                 QObject* obj = info->decorator()?info->decorator():objectToCall;
                 if (!obj) {
                   hadException = true;
                   PyErr_SetString(PyExc_RuntimeError, "Trying to call a slot on a deleted QObject!");
                 } else {
                   try {
                     obj->qt_metacall(QMetaObject::InvokeMetaMethod, info->slotIndex(), argList);
                   } catch (std::bad_alloc & e) {
                     hadException = true;
                     QByteArray what("std::bad_alloc: ");
                     what += e.what();
                     PyErr_SetString(PyExc_MemoryError, what.constData());
                   } catch (std::runtime_error & e) {
                     hadException = true;
                     QByteArray what("std::runtime_error: ");
                     what += e.what();
                     PyErr_SetString(PyExc_RuntimeError, what.constData());
                   } catch (std::logic_error & e) {
                     hadException = true;
                     QByteArray what("std::logic_error: ");
                     what += e.what();
                     PyErr_SetString(PyExc_RuntimeError, what.constData());
                   } catch (std::exception& e) {
                     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
                   }
                 }
                 if (profilingCB) {
                   profilingCB(PythonQt::Leave, NULL, NULL);
                 }
                 // handle the return value (which in most cases still needs to be converted to a Python object)
                 if (!hadException) {
                   if (argList[0] || returnValueParam.typeId == QMetaType::Void) {
                     if (directReturnValuePointer) {
                       result = NULL;
                     } else {
                       // the resulting object maybe present already, because we created it above at 1)...
                       if (!result) {
                         result = PythonQtConv::ConvertQtValueToPython(returnValueParam, argList[0]);
                       }
                     }
                   } else {
                     QString e = QString("Called ") + info->fullSignature() + ", return type '" + returnValueParam.name + "' is ignored because it is unknown to PythonQt. Probably you should register it using qRegisterMetaType() or add a default constructor decorator to the class.";
                     PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                     result = NULL;
                   }
                 } else {
                   result = NULL;
                 }
               }
               recursiveEntry--;
               // reset the parameter storage position to the stored pos to "pop" the parameter stack
               PythonQtConv::global_valueStorage.setPos(globalValueStoragePos);
               PythonQtConv::global_ptrStorage.setPos(globalPtrStoragePos);
               PythonQtConv::global_variantStorage.setPos(globalVariantStoragePos);
               *pythonReturnValue = result;
               // NOTE: it is important to only return here, otherwise the stack will not be popped!!!
               return result || (directReturnValuePointer && *directReturnValuePointer);
             }
             //-----------------------------------------------------------------------------------
             static PythonQtSlotFunctionObject *pythonqtslot_free_list = NULL;
             PyObject *PythonQtSlotFunction_Call(PyObject *func, PyObject *args, PyObject *kw)
             {
               PythonQtSlotFunctionObject* f = (PythonQtSlotFunctionObject*)func;
               return PythonQtMemberFunction_Call(f->m_ml, f->m_self, args, kw);
             }
             PyObject *PythonQtMemberFunction_Call(PythonQtSlotInfo* info, PyObject* m_self, PyObject *args, PyObject *kw)
             {
               if (PyObject_TypeCheck(m_self, &PythonQtInstanceWrapper_Type)) {
                 PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*) m_self;
                 if (!info->isClassDecorator() && (self->_obj==NULL && self->_wrappedPtr==NULL)) {
                   QString error = QString("Trying to call '") + info->slotName() + "' on a destroyed " + self->classInfo()->className() + " object";
                   PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                   return NULL;
                 } else {
                   return PythonQtSlotFunction_CallImpl(self->classInfo(), self->_obj, info, args, kw, self->_wrappedPtr);
                 }
               } else if (m_self->ob_type == &PythonQtClassWrapper_Type) {
                 PythonQtClassWrapper* type = (PythonQtClassWrapper*) m_self;
                 if (info->isClassDecorator()) {
                   return PythonQtSlotFunction_CallImpl(type->classInfo(), NULL, info, args, kw);
                 } else {
                   // otherwise, it is an unbound call and we have an instanceDecorator or normal slot...
                   Py_ssize_t argc = PyTuple_Size(args);
                   if (argc>0) {
                     PyObject* firstArg = PyTuple_GET_ITEM(args, 0);
                     if (PyObject_TypeCheck(firstArg, (PyTypeObject*)&PythonQtInstanceWrapper_Type)
                       && ((PythonQtInstanceWrapper*)firstArg)->classInfo()->inherits(type->classInfo())) {
                       PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*)firstArg;
                       if (!info->isClassDecorator() && (self->_obj==NULL && self->_wrappedPtr==NULL)) {
                         QString error = QString("Trying to call '") + info->slotName() + "' on a destroyed " + self->classInfo()->className() + " object";
                         PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                         return NULL;
                       }
                       // strip the first argument...
                       PyObject* newargs = PyTuple_GetSlice(args, 1, argc);
                       PyObject* result = PythonQtSlotFunction_CallImpl(self->classInfo(), self->_obj, info, newargs, kw, self->_wrappedPtr);
                       Py_DECREF(newargs);
                       return result;
                     } else {
                       // first arg is not of correct type!
                       QString error = "slot " + info->fullSignature() + " requires " + type->classInfo()->className() + " instance as first argument, got " + firstArg->ob_type->tp_name;
                       PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                       return NULL;
                     }
                   } else {
                     // wrong number of args
                     QString error = "slot " + info->fullSignature() + " requires " + type->classInfo()->className() + " instance as first argument.";
                     PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                     return NULL;
                   }
                 }
               }
               return NULL;
             }
             PyObject *PythonQtSlotFunction_CallImpl(PythonQtClassInfo* classInfo, QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject * /*kw*/, void* firstArg, void** directReturnValuePointer)
             {
               int argc = args?PyTuple_Size(args):0;
             #ifdef PYTHONQT_DEBUG
               std::cout << "called " << info->metaMethod()->typeName() << " " << info->metaMethod()->signature() << std::endl;
             #endif
               PyObject* r = NULL;
               bool ok = false;
               if (directReturnValuePointer) {
                 *directReturnValuePointer = NULL;
               }
               if (info->nextInfo()) {
                 // overloaded slot call, try on all slots with strict conversion first
                 bool strict = true;
                 PythonQtSlotInfo* i = info;
                 while (i) {
                   bool skipFirst = i->isInstanceDecorator();
                   if (i->parameterCount()-1-(skipFirst?1:0) == argc) {
                     PyErr_Clear();
                     ok = PythonQtCallSlot(classInfo, objectToCall, args, strict, i, firstArg, &r, directReturnValuePointer);
                     if (PyErr_Occurred() || ok) break;
                   }
                   i = i->nextInfo();
                   if (!i) {
                     if (strict) {
                       // one more run without being strict
                       strict = false;
                       i = info;
                     }
                   }
                 }
                 if (!ok && !PyErr_Occurred()) {
                   QString e = QString("Could not find matching overload for given arguments:\n" + PythonQtConv::PyObjGetString(args) + "\n The following slots are available:\n");
                   PythonQtSlotInfo* i = info;
                   while (i) {
                     e += QString(i->fullSignature()) + "\n";
                     i = i->nextInfo();
                   }
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                 }
               } else {
                 // simple (non-overloaded) slot call
                 bool skipFirst = info->isInstanceDecorator();
                 if (info->parameterCount()-1-(skipFirst?1:0) == argc) {
                   PyErr_Clear();
                   ok = PythonQtCallSlot(classInfo, objectToCall, args, false, info, firstArg, &r, directReturnValuePointer);
                   if (!ok && !PyErr_Occurred()) {
                     QString e = QString("Called ") + info->fullSignature() + " with wrong arguments: " + PythonQtConv::PyObjGetString(args);
                     PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                   }
                 } else {
                   QString e = QString("Called ") + info->fullSignature() + " with wrong number of arguments: " + PythonQtConv::PyObjGetString(args);
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                 }
               }
               return r;
             }
             PyObject *
             PythonQtSlotFunction_New(PythonQtSlotInfo *ml, PyObject *self, PyObject *module)
             {
               PythonQtSlotFunctionObject *op;
               op = pythonqtslot_free_list;
               if (op != NULL) {
                 pythonqtslot_free_list = (PythonQtSlotFunctionObject *)(op->m_self);
                 PyObject_INIT(op, &PythonQtSlotFunction_Type);
               }
               else {
                 op = PyObject_GC_New(PythonQtSlotFunctionObject, &PythonQtSlotFunction_Type);
                 if (op == NULL)
                   return NULL;
               }
               op->m_ml = ml;
               Py_XINCREF(self);
               op->m_self = self;
               Py_XINCREF(module);
               op->m_module = module;
               PyObject_GC_Track(op);
               return (PyObject *)op;
             }
             PythonQtSlotInfo*
             PythonQtSlotFunction_GetSlotInfo(PyObject *op)
             {
               if (!PythonQtSlotFunction_Check(op)) {
                 PyErr_Format(PyExc_SystemError, "%s:%d: bad argument to internal function", __FILE__, __LINE__);
                 return NULL;
               }
               return ((PythonQtSlotFunctionObject *)op) -> m_ml;
             }
             PyObject *
             PythonQtSlotFunction_GetSelf(PyObject *op)
             {
               if (!PythonQtSlotFunction_Check(op)) {
                 PyErr_Format(PyExc_SystemError, "%s:%d: bad argument to internal function", __FILE__, __LINE__);
                 return NULL;
               }
               return ((PythonQtSlotFunctionObject *)op) -> m_self;
             }
             /* Methods (the standard built-in methods, that is) */
             static void
             meth_dealloc(PythonQtSlotFunctionObject *m)
             {
               PyObject_GC_UnTrack(m);
               Py_XDECREF(m->m_self);
               Py_XDECREF(m->m_module);
               m->m_self = (PyObject *)pythonqtslot_free_list;
               pythonqtslot_free_list = m;
             }
             static PyObject *
             meth_get__doc__(PythonQtSlotFunctionObject * /*m*/, void * /*closure*/)
             {
               Py_INCREF(Py_None);
               return Py_None;
             }
             static PyObject *
             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_traverse(PythonQtSlotFunctionObject *m, visitproc visit, void *arg)
             {
               int err;
               if (m->m_self != NULL) {
                 err = visit(m->m_self, arg);
                 if (err)
                   return err;
               }
               if (m->m_module != NULL) {
                 err = visit(m->m_module, arg);
                 if (err)
                   return err;
               }
               return 0;
             }
             static PyObject *
             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;
               Py_INCREF(self);
               return self;
             }
             static PyGetSetDef meth_getsets [] = {
               {const_cast<char*>("__doc__"),  (getter)meth_get__doc__,  NULL, NULL},
               {const_cast<char*>("__name__"), (getter)meth_get__name__, NULL, NULL},
               {const_cast<char*>("__self__"), (getter)meth_get__self__, NULL, NULL},
               {NULL, NULL, NULL,NULL},
             };
             #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 6
             #define PY_WRITE_RESTRICTED WRITE_RESTRICTED
             #endif
             #define OFF(x) offsetof(PythonQtSlotFunctionObject, x)
             static PyMemberDef meth_members[] = {
               {const_cast<char*>("__module__"),    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
               {NULL}
             };
             static PyObject *PythonQtSlotFunction_parameterTypes(PythonQtSlotFunctionObject* type)
             {
               return PythonQtMemberFunction_parameterTypes(type->m_ml);
             }
             static PyObject *PythonQtSlotFunction_parameterNames(PythonQtSlotFunctionObject* type)
             {
               return PythonQtMemberFunction_parameterNames(type->m_ml);
             }
             static PyObject *PythonQtSlotFunction_typeName(PythonQtSlotFunctionObject* type)
             {
               return PythonQtMemberFunction_typeName(type->m_ml);
             }
             PyObject *PythonQtMemberFunction_parameterTypes(PythonQtSlotInfo* theInfo)
             {
               PythonQtSlotInfo* info = theInfo;
               int count = 0;
               while (info) {
                 info = info->nextInfo();
                 count++;
               }
               info = theInfo;
               PyObject* result = PyTuple_New(count);
               for (int j = 0;j<count;j++) {
                 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);
               }
               return result;
             }
             PyObject *PythonQtMemberFunction_parameterNames(PythonQtSlotInfo* theInfo)
             {
               PythonQtSlotInfo* info = theInfo;
               int count = 0;
               while (info) {
                 info = info->nextInfo();
                 count++;
               }
               info = theInfo;
               PyObject* result = PyTuple_New(count);
               for (int j = 0;j<count;j++) {
                 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);
               }
               return result;
             }
             PyObject *PythonQtMemberFunction_typeName(PythonQtSlotInfo* theInfo)
             {
               PythonQtSlotInfo* info = theInfo;
               int count = 0;
               while (info) {
                 info = info->nextInfo();
                 count++;
               }
               info = theInfo;
               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;
             }
             static PyMethodDef meth_methods[] = {
               {"parameterTypes", (PyCFunction)PythonQtSlotFunction_parameterTypes, METH_NOARGS,
               "Returns a tuple of tuples of the C++ parameter types for all overloads of the slot"
               },
               {"parameterNames", (PyCFunction)PythonQtSlotFunction_parameterNames, METH_NOARGS,
               "Returns a tuple of tuples of the C++ parameter type names (if available), for all overloads of the slot"
               },
               {"typeName", (PyCFunction)PythonQtSlotFunction_typeName, METH_NOARGS,
               "Returns a tuple of the C++ return value types of each slot overload"
               },
               {NULL, NULL, 0 , NULL}  /* Sentinel */
             };
             static PyObject *
             meth_repr(PythonQtSlotFunctionObject *f)
             {
               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);
               }
             }
             static int
             meth_compare(PythonQtSlotFunctionObject *a, PythonQtSlotFunctionObject *b)
             {
               if (a->m_self != b->m_self)
                 return (a->m_self < b->m_self) ? -1 : 1;
               if (a->m_ml == b->m_ml)
                 return 0;
             #if( QT_VERSION >= QT_VERSION_CHECK(5,0,0) )
               if (strcmp(a->m_ml->metaMethod()->methodSignature(), b->m_ml->metaMethod()->methodSignature()) < 0)
             #else
               if (strcmp(a->m_ml->metaMethod()->signature(), b->m_ml->metaMethod()->signature()) < 0)
             #endif
                 return -1;
               else
                 return 1;
             }
             static long
             meth_hash(PythonQtSlotFunctionObject *a)
             {
               long x,y;
               if (a->m_self == NULL)
                 x = 0;
               else {
                 x = PyObject_Hash(a->m_self);
                 if (x == -1)
                   return -1;
               }
               y = _Py_HashPointer((void*)(a->m_ml));
               if (y == -1)
                 return -1;
               x ^= y;
               if (x == -1)
                 x = -2;
               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 = {
               PyVarObject_HEAD_INIT(&PyType_Type, 0)
                 "builtin_qt_slot",
                 sizeof(PythonQtSlotFunctionObject),
 ,
                 (destructor)meth_dealloc,     /* tp_dealloc */
 ,          /* 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_as_mapping */
                 (hashfunc)meth_hash,      /* tp_hash */
                 PythonQtSlotFunction_Call,      /* tp_call */
 ,          /* tp_str */
                 PyObject_GenericGetAttr,    /* tp_getattro */
 ,          /* tp_setattro */
 ,          /* tp_as_buffer */
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
 ,          /* tp_doc */
                 (traverseproc)meth_traverse,    /* tp_traverse */
 ,          /* tp_clear */
                 (richcmpfunc)meth_richcompare,          /* tp_richcompare */
 ,          /* tp_weaklistoffset */
 ,          /* tp_iter */
 ,          /* tp_iternext */
                 meth_methods,          /* tp_methods */
                 meth_members,       /* tp_members */
                 meth_getsets,       /* tp_getset */
 ,          /* tp_base */
 ,          /* tp_dict */
             };
             /* Clear out the free list */
             void
             PythonQtSlotFunction_Fini(void)
             {
               while (pythonqtslot_free_list) {
                 PythonQtSlotFunctionObject *v = pythonqtslot_free_list;
                 pythonqtslot_free_list = (PythonQtSlotFunctionObject *)(v->m_self);
                 PyObject_GC_Del(v);
               }
             }

tests/PythonQtTests.cpp +15 -7

             /*
              *
              *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
              *
              *  This library is free software; you can redistribute it and/or
              *  modify it under the terms of the GNU Lesser General Public
              *  License as published by the Free Software Foundation; either
              *  version 2.1 of the License, or (at your option) any later version.
              *
              *  This library is distributed in the hope that it will be useful,
              *  but WITHOUT ANY WARRANTY; without even the implied warranty of
              *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
              *  Lesser General Public License for more details.
              *
              *  Further, this software is distributed without any warranty that it is
              *  free of the rightful claim of any third person regarding infringement
              *  or the like.  Any license provided herein, whether implied or
              *  otherwise, applies only to this software file.  Patent licenses, if
              *  any, provided herein do not apply to combinations of this program with
              *  other software, or any other product whatsoever.
              *
              *  You should have received a copy of the GNU Lesser General Public
              *  License along with this library; if not, write to the Free Software
              *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              *
              *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
              *  28359 Bremen, Germany or:
              *
              *  http://www.mevis.de
              *
              */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtTests.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtTests.h"
             void PythonQtTestSlotCalling::initTestCase()
             {
               _helper = new PythonQtTestSlotCallingHelper(this);
               PythonQtObjectPtr main = PythonQt::self()->getMainModule();
               main.evalScript("import PythonQt");
               PythonQt::self()->addObject(main, "obj", _helper);
             }
             void PythonQtTestSlotCalling::init() {
             }
             void* polymorphic_ClassB_Handler(const void* ptr, const char** className) {
               ClassB* o = (ClassB*)ptr;
               if (o->type()==2) {
                 *className = "ClassB";
                 return (ClassB*)o;
               }
               if (o->type()==3) {
                 *className = "ClassC";
                 return (ClassC*)o;
               }
               if (o->type()==4) {
                 *className = "ClassD";
                 return (ClassD*)o;
               }
               return NULL;
             }
             void PythonQtTestSlotCalling::testInheritance() {
               PythonQt::self()->registerCPPClass("ClassA",NULL,NULL, PythonQtCreateObject<ClassAWrapper>);
               PythonQt::self()->registerCPPClass("ClassB",NULL,NULL, PythonQtCreateObject<ClassBWrapper>);
               PythonQt::self()->registerCPPClass("ClassC",NULL,NULL, PythonQtCreateObject<ClassCWrapper>);
               PythonQt::self()->addParentClass("ClassC", "ClassA", PythonQtUpcastingOffset<ClassC,ClassA>());
               PythonQt::self()->addParentClass("ClassC", "ClassB", PythonQtUpcastingOffset<ClassC,ClassB>());
               PythonQt::self()->registerClass(&ClassD::staticMetaObject, NULL, PythonQtCreateObject<ClassDWrapper>);
               PythonQt::self()->addParentClass("ClassD", "ClassA", PythonQtUpcastingOffset<ClassD,ClassA>());
               PythonQt::self()->addParentClass("ClassD", "ClassB", PythonQtUpcastingOffset<ClassD,ClassB>());
               PythonQtObjectPtr classA = PythonQt::self()->getMainModule().getVariable("PythonQt.private.ClassA");
               PythonQtObjectPtr classB = PythonQt::self()->getMainModule().getVariable("PythonQt.private.ClassB");
               PythonQtObjectPtr classC = PythonQt::self()->getMainModule().getVariable("PythonQt.private.ClassC");
               PythonQtObjectPtr classD = PythonQt::self()->getMainModule().getVariable("PythonQt.private.ClassD");
               QVERIFY(classA);
               QVERIFY(classB);
               QVERIFY(classC);
               QVERIFY(classD);
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassA();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
               QEXPECT_FAIL("", "ClassB can not be converted to ClassA", Continue);
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassB();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassC();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassD();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
               QEXPECT_FAIL("", "ClassA can not be converted to ClassB", Continue);
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassA();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassB();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassC();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassD();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
               QEXPECT_FAIL("", "ClassA can not be converted to ClassC", Continue);
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassA();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
               QEXPECT_FAIL("", "ClassB can not be converted to ClassC", Continue);
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassB();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassC();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
               QEXPECT_FAIL("", "ClassD can not be converted to ClassC", Continue);
               QVERIFY(_helper->runScript("a = PythonQt.private.ClassD();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if type(obj.createClassA())==PythonQt.private.ClassA: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if type(obj.createClassB())==PythonQt.private.ClassB: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if type(obj.createClassCAsA())==PythonQt.private.ClassA: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if type(obj.createClassCAsB())==PythonQt.private.ClassB: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if type(obj.createClassD())==PythonQt.private.ClassD: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if type(obj.createClassDAsA())==PythonQt.private.ClassA: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if type(obj.createClassDAsB())==PythonQt.private.ClassB: obj.setPassed();\n"));
               PythonQt::self()->addPolymorphicHandler("ClassB", polymorphic_ClassB_Handler);
               QVERIFY(_helper->runScript("if type(obj.getClassBPtr(obj.createClassB()))==PythonQt.private.ClassB: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if type(obj.createClassCAsB())==PythonQt.private.ClassC: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if type(obj.createClassDAsB())==PythonQt.private.ClassD: obj.setPassed();\n"));
             }
             void PythonQtTestSlotCalling::testAutoConversion() {
               QVERIFY(_helper->runScript("if obj.setAutoConvertColor(PythonQt.QtCore.Qt.red)==PythonQt.Qt.QColor(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.setAutoConvertBrush(PythonQt.QtCore.Qt.red)==PythonQt.Qt.QBrush(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.setAutoConvertPen(PythonQt.QtCore.Qt.red)==PythonQt.Qt.QPen(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.setAutoConvertBrush(PythonQt.Qt.QColor(PythonQt.QtCore.Qt.red))==PythonQt.Qt.QBrush(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.setAutoConvertPen(PythonQt.Qt.QColor(PythonQt.QtCore.Qt.red))==PythonQt.Qt.QPen(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.setAutoConvertCursor(PythonQt.Qt.QCursor(PythonQt.QtCore.Qt.UpArrowCursor)).shape()==PythonQt.Qt.QCursor(PythonQt.QtCore.Qt.UpArrowCursor).shape(): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.setAutoConvertCursor(PythonQt.QtCore.Qt.UpArrowCursor).shape()==PythonQt.Qt.QCursor(PythonQt.QtCore.Qt.UpArrowCursor).shape(): obj.setPassed();\n"));
             }
             void PythonQtTestSlotCalling::testNoArgSlotCall()
             {
               QVERIFY(_helper->runScript("obj.testNoArg(); obj.setPassed();\n"));
             }
             void PythonQtTestSlotCalling::testOverloadedCall()
             {
               QVERIFY(_helper->runScript("obj.overload(False); obj.setPassed();\n", 0));
               QVERIFY(_helper->runScript("obj.overload(True); obj.setPassed();\n", 0));
               QVERIFY(_helper->runScript("obj.overload(12.5); obj.setPassed();\n", 1));
               QVERIFY(_helper->runScript("obj.overload(12); obj.setPassed();\n", 2));
               QVERIFY(_helper->runScript("obj.overload('test'); obj.setPassed();\n", 3));
               QVERIFY(_helper->runScript("obj.overload(u'test'); obj.setPassed();\n", 3));
               QVERIFY(_helper->runScript("obj.overload(('test','test2')); obj.setPassed();\n", 4));
               QVERIFY(_helper->runScript("obj.overload(obj); obj.setPassed();\n", 5));
               QVERIFY(_helper->runScript("obj.overload(12,13); obj.setPassed();\n", 6));
             }
             void PythonQtTestSlotCalling::testPyObjectSlotCall()
             {
               QVERIFY(_helper->runScript("if obj.getPyObject(PythonQt)==PythonQt: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getPyObject('Hello')=='Hello': obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getPyObjectFromVariant(PythonQt)==PythonQt: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getPyObjectFromVariant2(PythonQt)==PythonQt: obj.setPassed();\n"));
             //  QVERIFY(_helper->runScript("if obj.getPyObjectFromPtr(PythonQt)==PythonQt: obj.setPassed();\n"));
             }
             void PythonQtTestSlotCalling::testCPPSlotCalls()
             {
               // test QColor compare operation
               QVERIFY(_helper->runScript("if PythonQt.QtGui.QColor(1,2,3)==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();obj.testNoArg()\n"));
               QVERIFY(_helper->runScript("if PythonQt.QtGui.QColor(1,2,3)!=PythonQt.QtGui.QColor(3,2,1): obj.setPassed();obj.testNoArg()\n"));
               // test passing/returning QColors
               QVERIFY(_helper->runScript("if obj.getQColor1(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQColor2(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQColor3(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQColor4(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQColor5()==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
             }
             void PythonQtTestSlotCalling::testPODSlotCalls()
             {
               QVERIFY(_helper->runScript("if obj.getBool(False)==False: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getBool(True)==True: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getInt(-42)==-42: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getUInt(42)==42: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getShort(-43)==-43: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getUShort(43)==43: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getChar(-12)==-12: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getUChar(12)==12: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getLong(-256*256*256)==-256*256*256: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getULong(256*256*256)==256*256*256: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getLongLong(-42)==-42: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getULongLong(42)==42: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQChar(4096)==4096: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getDouble(47.12)==47.12: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if abs(obj.getFloat(47.11)-47.11)<0.01: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQString('testStr')=='testStr': obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQString('')=='': obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQStringList(('test','test2'))==('test','test2'): obj.setPassed();\n"));
             }
             void PythonQtTestSlotCalling::testQVariantSlotCalls()
             {
               QVERIFY(_helper->runScript("if obj.getQVariant(-42)==-42: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQVariant('testStr')=='testStr': obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQVariant(('test','test2'))==('test','test2'): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQVariant(('test',12, 47.11))==('test',12, 47.11): obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQVariant({'test':'bla','test2':47.11})=={'test':'bla','test2':47.11}: obj.setPassed();\n"));
               QEXPECT_FAIL("", "Testing to pass a map and compare with a different map", Continue);
               QVERIFY(_helper->runScript("if obj.getQVariant({'test':'bla2','test2':47.11})=={'test':'bla','test2':47.11}: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getQVariant(obj)==obj: obj.setPassed();\n"));
             }
             void PythonQtTestSlotCalling::testObjectSlotCalls()
             {
               QVERIFY(_helper->runScript("if obj.getQObject(obj)==obj: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getTestObject(obj)==obj: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getNewObject().className()=='PythonQtTestSlotCallingHelper': obj.setPassed();\n"));
               QEXPECT_FAIL("", "Testing to pass a QObject when another object was expected", Continue);
               QVERIFY(_helper->runScript("if obj.getQWidget(obj)==obj: obj.setPassed();\n"));
             }
             void PythonQtTestSlotCalling::testCppFactory()
             {
               PythonQtTestCppFactory* f = new PythonQtTestCppFactory;
               PythonQt::self()->addInstanceDecorators(new PQCppObjectDecorator);
               // do not register, since we want to know if that works as well
               //qRegisterMetaType<PQCppObjectNoWrap>("PQCppObjectNoWrap");
               PythonQt::self()->addDecorators(new PQCppObjectNoWrapDecorator);
               PythonQt::self()->addWrapperFactory(f);
               QVERIFY(_helper->runScript("if obj.createPQCppObject(12).getHeight()==12: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.createPQCppObject(12).getH()==12: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("pq1 = obj.createPQCppObject(12);\n"
                 "pq2 = obj.createPQCppObject(13);\n"
                 "pq3 = obj.getPQCppObject(pq1);\n"
                 "pq4 = obj.getPQCppObject(pq2);\n"
                 "if pq3.getHeight()==12 and pq4.getHeight()==13: obj.setPassed();\n"
                 ));
               QVERIFY(_helper->runScript("if obj.createPQCppObjectNoWrap(12).getH()==12: obj.setPassed();\n"));
               QVERIFY(_helper->runScript("if obj.getPQCppObjectNoWrapAsValue().getH()==47: obj.setPassed();\n"));
               qRegisterMetaType<PQUnknownButRegisteredValueObject>("PQUnknownButRegisteredValueObject");
-              QVERIFY(_helper->runScript("a = obj.getUnknownButRegisteredValueObjectAsPtr();print a;\nif a!=None: obj.setPassed();\n"));
+              QVERIFY(_helper->runScript("a = obj.getUnknownButRegisteredValueObjectAsPtr();print (a);\nif a!=None: obj.setPassed();\n"));
-              QVERIFY(_helper->runScript("a = obj.getUnknownButRegisteredValueObjectAsValue();print a;\nif a!=None: obj.setPassed();\n"));
+              QVERIFY(_helper->runScript("a = obj.getUnknownButRegisteredValueObjectAsValue();print (a);\nif a!=None: obj.setPassed();\n"));
-              QVERIFY(_helper->runScript("a = obj.getUnknownValueObjectAsPtr();print a;\nif a!=None: obj.setPassed();\n"));
+              QVERIFY(_helper->runScript("a = obj.getUnknownValueObjectAsPtr();print (a);\nif a!=None: obj.setPassed();\n"));
               QEXPECT_FAIL("", "Testing by value return without the object being registered as QMetaType or having registered a default constructor decorator", Continue);
-              QVERIFY(_helper->runScript("a = obj.getUnknownValueObjectAsValue();print a;\nif a!=None: obj.setPassed();\n"));
+              QVERIFY(_helper->runScript("a = obj.getUnknownValueObjectAsValue();print (a);\nif a!=None: obj.setPassed();\n"));
               // expect to get strict call to double overload
               QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObjectNoWrap\na = PQCppObjectNoWrap(22.2)\nif a.getH()==2: obj.setPassed();\n"));
               // expect to get un-strict call to double overload
               QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObjectNoWrap\na = PQCppObjectNoWrap(22)\nif a.getH()==2: obj.setPassed();\n"));
               // expect to get strict call to copy constructor overload
-              QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObjectNoWrap\na = PQCppObjectNoWrap(PQCppObjectNoWrap())\nprint a.getH()\nif a.getH()==1: obj.setPassed();\n"));
+              QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObjectNoWrap\na = PQCppObjectNoWrap(PQCppObjectNoWrap())\nprint (a.getH())\nif a.getH()==1: obj.setPassed();\n"));
               // test decorated enums
               // already registered by signals test
               //PythonQt::self()->registerCPPClass("PQCppObject2",NULL,NULL, PythonQtCreateObject<PQCppObject2Decorator>);
               // local enum (decorated)
-              QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObject2\na = PQCppObject2()\nprint a.testEnumFlag1\nif a.testEnumFlag1(PQCppObject2.TestEnumValue2)==PQCppObject2.TestEnumValue2: obj.setPassed();\n"));
+              QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObject2\na = PQCppObject2()\nprint (a.testEnumFlag1)\nif a.testEnumFlag1(PQCppObject2.TestEnumValue2)==PQCppObject2.TestEnumValue2: obj.setPassed();\n"));
               // enum with namespace (decorated)
               QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObject2\na = PQCppObject2()\nif a.testEnumFlag2(PQCppObject2.TestEnumValue2)==PQCppObject2.TestEnumValue2: obj.setPassed();\n"));
               // with int overload to check overloading
               QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt.private import PQCppObject2\na = PQCppObject2()\nif a.testEnumFlag3(PQCppObject2.TestEnumValue2)==PQCppObject2.TestEnumValue2: obj.setPassed();\n"));
             }
             PQCppObject2Decorator::TestEnumFlag PQCppObject2Decorator::testEnumFlag1(PQCppObject2* obj, PQCppObject2Decorator::TestEnumFlag flag) {
               return flag;
             }
             PQCppObject2::TestEnumFlag PQCppObject2Decorator::testEnumFlag2(PQCppObject2* obj, PQCppObject2::TestEnumFlag flag) {
               return flag;
             }
             // with int overload
             PQCppObject2Decorator::TestEnumFlag PQCppObject2Decorator::testEnumFlag3(PQCppObject2* obj, int flag) {
               return (TestEnumFlag)-1;
             }
             PQCppObject2Decorator::TestEnumFlag PQCppObject2Decorator::testEnumFlag3(PQCppObject2* obj, PQCppObject2Decorator::TestEnumFlag flag) {
               return flag;
             }
             void PythonQtTestSlotCalling::testMultiArgsSlotCall()
             {
               QVERIFY(_helper->runScript("if obj.getMultiArgs(12,47.11,'test')==(12,47.11,'test'): obj.setPassed();\n"));
             }
             bool PythonQtTestSlotCallingHelper::runScript(const char* script, int expectedOverload)
             {
               _called = false;
               _passed = false;
               _calledOverload = -1;
               PyRun_SimpleString(script);
               return _called && _passed && _calledOverload==expectedOverload;
             }
             void PythonQtTestSignalHandler::initTestCase()
             {
               _helper = new PythonQtTestSignalHandlerHelper(this);
               PythonQtObjectPtr main = PythonQt::self()->getMainModule();
               PythonQt::self()->addObject(main, "obj", _helper);
             }
             void PythonQtTestSignalHandler::testSignalHandler()
             {
               PythonQtObjectPtr main = PythonQt::self()->getMainModule();
               PyRun_SimpleString("def testIntSignal(a):\n  if a==12: obj.setPassed();\n");
               QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(intSignal(int)), main, "testIntSignal"));
               QVERIFY(_helper->emitIntSignal(12));
               PyRun_SimpleString("def testFloatSignal(a):\n  if a==12: obj.setPassed();\n");
               QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(floatSignal(float)), main, "testFloatSignal"));
               QVERIFY(_helper->emitFloatSignal(12));
               // test decorated enums
               PythonQt::self()->registerCPPClass("PQCppObject2",NULL,NULL, PythonQtCreateObject<PQCppObject2Decorator>);
               PyRun_SimpleString("def testEnumSignal(a):\n  if a==1: obj.setPassed();\n");
               QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(enumSignal(PQCppObject2::TestEnumFlag)), main, "testEnumSignal"));
               QVERIFY(_helper->emitEnumSignal(PQCppObject2::TestEnumValue2));
               PyRun_SimpleString("def testVariantSignal(a):\n  if a==obj.expectedVariant(): obj.setPassed();\n");
               QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(variantSignal(QVariant)), main, "testVariantSignal"));
               _helper->setExpectedVariant(QString("Test"));
               QVERIFY(_helper->emitVariantSignal(QString("Test")));
               _helper->setExpectedVariant(12);
               QVERIFY(_helper->emitVariantSignal(12));
               _helper->setExpectedVariant(QStringList() << "test1" << "test2");
               QVERIFY(_helper->emitVariantSignal(QStringList() << "test1" << "test2"));
               _helper->setExpectedVariant(qVariantFromValue((QObject*)_helper));
               QVERIFY(_helper->emitVariantSignal(qVariantFromValue((QObject*)_helper)));
               PyRun_SimpleString("def testComplexSignal(a,b,l,o):\n  if a==12 and b==13 and l==('test1','test2') and o == obj: obj.setPassed();\n");
               // intentionally not normalized signal:
               QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(complexSignal( int, float , const QStringList  , QObject*)), main, "testComplexSignal"));
               QVERIFY(_helper->emitComplexSignal(12,13,QStringList() << "test1" << "test2", _helper));
               // try removing the handler
               QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(complexSignal( int, float , const QStringList  , QObject*)), main, "testComplexSignal"));
               // and emit the signal, which should fail because the handler was removed
               QVERIFY(!_helper->emitComplexSignal(12,13,QStringList() << "test1" << "test2", _helper));
               QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(intSignal(int)), main, "testIntSignal"));
               QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(floatSignal(float)), main, "testFloatSignal"));
               QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(variantSignal(QVariant)), main, "testVariantSignal"));
               QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(enumSignal(PQCppObject2::TestEnumFlag)), main, "testEnumSignal"));
             }
             void PythonQtTestSignalHandler::testRecursiveSignalHandler()
             {
               PythonQtObjectPtr main = PythonQt::self()->getMainModule();
               PyRun_SimpleString("def testSignal1(a):\n  obj.emitSignal2(a);\n");
               PyRun_SimpleString("def testSignal2(a):\n  obj.emitSignal3(float(a));\n");
               PyRun_SimpleString("def testSignal3(a):\n  if a==12: obj.setPassed();\n");
               QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(signal1(int)), main, "testSignal1"));
               QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(signal2(const QString&)), main, "testSignal2"));
               QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(signal3(float)), main, "testSignal3"));
               QVERIFY(_helper->emitSignal1(12));
             }
             void PythonQtTestApi::initTestCase()
             {
               _helper = new PythonQtTestApiHelper();
               _main = PythonQt::self()->getMainModule();
               _main.evalScript("import PythonQt");
               _main.addObject("obj", _helper);
             }
             void PythonQtTestApi::testProperties()
             {
               PythonQtObjectPtr main = PythonQt::self()->getMainModule();
               // check for name alias (for backward comp to Qt3)
               main.evalScript("obj.name = 'hello'");
               QVERIFY(QString("hello") == main.getVariable("obj.name").toString());
               main.evalScript("obj.objectName = 'hello2'");
               QVERIFY(QString("hello2") == main.getVariable("obj.objectName").toString());
             }
             void PythonQtTestApi::testDynamicProperties()
             {
               PythonQtObjectPtr main = PythonQt::self()->getMainModule();
               // this fails and should fail, but how could that be tested?
               // main.evalScript("obj.testProp = 1");
               // create a new dynamic property
               main.evalScript("obj.setProperty('testProp','testValue')");
               // read the property
               QVERIFY(QString("testValue") == main.getVariable("obj.testProp").toString());
               // modify and read again
               main.evalScript("obj.testProp = 12");
               QVERIFY(12 == main.getVariable("obj.testProp").toInt());
               // check if dynamic property is in dict
               QVERIFY(12 == main.evalScript("obj.__dict__['testProp']", Py_eval_input).toInt());
               // check if dynamic property is in introspection
               QStringList l = PythonQt::self()->introspection(PythonQt::self()->getMainModule(), "obj", PythonQt::Anything);
               QVERIFY(l.contains("testProp"));
               // check with None, previous value expected
               main.evalScript("obj.testProp = None");
               QVERIFY(12 == main.getVariable("obj.testProp").toInt());
               // remove the dynamic property
               main.evalScript("obj.setProperty('testProp', None)");
               // check if dynamic property is really gone
               QStringList l2 = PythonQt::self()->introspection(PythonQt::self()->getMainModule(), "obj", PythonQt::Anything);
               QVERIFY(!l2.contains("testProp"));
             }
             bool PythonQtTestApiHelper::call(const QString& function, const QVariantList& args, const QVariant& expectedResult) {
               _passed = false;
               QVariant r = PythonQt::self()->call(PythonQt::self()->getMainModule(), function, args);
               return _passed && expectedResult==r;
             }
             void PythonQtTestApi::testCall()
             {
               PythonQtObjectPtr main = PythonQt::self()->getMainModule();
               QVERIFY(qvariant_cast<QObject*>(PythonQt::self()->getVariable(main, "obj"))==_helper);
               PyRun_SimpleString("def testCallNoArgs():\n  obj.setPassed();\n");
               QVERIFY(_helper->call("testCallNoArgs", QVariantList(), QVariant()));
               PyRun_SimpleString("def testCall1(a):\n if a=='test': obj.setPassed();\n return 'test2';\n");
               QVERIFY(_helper->call("testCall1", QVariantList() << QVariant("test"), QVariant(QString("test2"))));
               PyRun_SimpleString("def testCall2(a, b):\n if a=='test' and b==obj: obj.setPassed();\n return obj;\n");
               QVariant r = PythonQt::self()->call(PythonQt::self()->getMainModule(), "testCall2", QVariantList() << QVariant("test") << qVariantFromValue((QObject*)_helper));
               QObject* p = qvariant_cast<QObject*>(r);
               QVERIFY(p==_helper);
             }
             void PythonQtTestApi::testVariables()
             {
               PythonQt::self()->addObject(PythonQt::self()->getMainModule(), "someObject", _helper);
               QVariant v = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someObject");
               QObject* p = qvariant_cast<QObject*>(v);
               QVERIFY(p==_helper);
               // test for unset variable
               QVariant v2 = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someObject2");
               QVERIFY(v2==QVariant());
               PythonQt::self()->addVariable(PythonQt::self()->getMainModule(), "someValue", QStringList() << "test1" << "test2");
               QVariant v3 = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someValue");
               QVERIFY(v3 == QVariant(QStringList() << "test1" << "test2"));
               QStringList l = PythonQt::self()->introspection(PythonQt::self()->getMainModule(), QString::null, PythonQt::Variable);
               QSet<QString> s;
               // check that at least these three variables are set
               s << "obj" << "someObject" << "someValue";
               foreach (QString value, s) {
                 QVERIFY(l.indexOf(value)!=-1);
               }
               // insert a second time!
               PythonQt::self()->addObject(PythonQt::self()->getMainModule(), "someObject", _helper);
               // and remove
               PythonQt::self()->removeVariable(PythonQt::self()->getMainModule(), "someObject");
               // we expect to find no variable
               QVariant v4 = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someObject");
               QVERIFY(v4==QVariant());
             }
             void PythonQtTestApi::testImporter()
             {
               PythonQt::self()->setImporter(_helper);
               PythonQt::self()->overwriteSysPath(QStringList() << "c:\\test");
               PyRun_SimpleString("import bla\n");
             }
             void PythonQtTestApi::testQtNamespace()
             {
               QVERIFY(_main.getVariable("PythonQt.QtCore.Qt.red").toInt()==Qt::red);
               QVERIFY(_main.getVariable("PythonQt.QtCore.Qt.FlatCap").toInt()==Qt::FlatCap);
             #if( QT_VERSION < QT_VERSION_CHECK(5,0,0) )
               QVERIFY(PythonQtObjectPtr(_main.getVariable("PythonQt.QtCore.Qt.escape")));
             #endif
               // check for an enum type wrapper
               QVERIFY(PythonQtObjectPtr(_main.getVariable("PythonQt.QtCore.Qt.AlignmentFlag")));
               // check for a flags type wrapper
               QVERIFY(PythonQtObjectPtr(_main.getVariable("PythonQt.QtCore.Qt.Alignment")));
             }
             void PythonQtTestApi::testConnects()
             {
             //  QVERIFY((qvariant_vast<QColor>(_main.evalScript("PythonQt.Qt.QColor(PythonQt.Qt.Qt.red)" ,Py_eval_input)) == QColor(Qt::red));
               //TODO: add signal/slot connect both with QObject.connect and connect
             }
             void PythonQtTestApi::testQColorDecorators()
             {
               PythonQtObjectPtr colorClass = _main.getVariable("PythonQt.QtGui.QColor");
               QVERIFY(colorClass);
               // verify that the class is in the correct module
               QVERIFY(colorClass.getVariable("__module__") == "PythonQt.QtGui");
               // test on Qt module as well:
               colorClass = _main.getVariable("PythonQt.Qt.QColor");
               QVERIFY(colorClass);
               // constructors
               QVERIFY(qvariant_cast<QColor>(colorClass.call(QVariantList() << 1 << 2 << 3)) == QColor(1,2,3));
               QVERIFY(qvariant_cast<QColor>(colorClass.call()) == QColor());
               QEXPECT_FAIL("", "Testing non-existing constructor", Continue);
               QVERIFY(colorClass.call(QVariantList() << 1 << 2) != QVariant());
               // check that enum overload is taken over int
               QVERIFY(qvariant_cast<QColor>(_main.evalScript("PythonQt.Qt.QColor(PythonQt.Qt.Qt.red)" ,Py_eval_input)) == QColor(Qt::red));
               // check that int overload is taken over enum
               QVERIFY(qvariant_cast<QColor>(_main.evalScript("PythonQt.Qt.QColor(0x112233)" ,Py_eval_input)) == QColor(0x112233));
               // check for decorated Cmyk enum value
               QVERIFY(colorClass.getVariable("Cmyk").toInt() == QColor::Cmyk);
               PythonQtObjectPtr staticMethod = colorClass.getVariable("fromRgb");
               QVERIFY(staticMethod);
               // direct call of static method via class
               QVERIFY(qvariant_cast<QColor>(colorClass.call("fromRgb", QVariantList() << 1 << 2 << 3)) == QColor(1,2,3));
               // direct call of static method
               QVERIFY(qvariant_cast<QColor>(staticMethod.call(QVariantList() << 1 << 2 << 3)) == QColor(1,2,3));
               PythonQtObjectPtr publicMethod = colorClass.getVariable("red");
               QVERIFY(publicMethod);
               // call with passing self in:
               QVERIFY(colorClass.call("red", QVariantList() << QColor(255,0,0)).toInt() == 255);
             }
             QByteArray PythonQtTestApiHelper::readFileAsBytes(const QString& filename)
             {
               QByteArray b;
               return b;
             }
             QByteArray PythonQtTestApiHelper::readSourceFile(const QString& filename, bool& ok)
             {
               QByteArray b;
               ok = true;
               return b;
             }
             bool PythonQtTestApiHelper::exists(const QString& filename)
             {
               return true;
             }
             QDateTime PythonQtTestApiHelper::lastModifiedDate(const QString& filename) {
               return QDateTime::currentDateTime();
             }
             void PythonQtTestApi::testRedirect()
             {
               connect(PythonQt::self(), SIGNAL(pythonStdOut(const QString&)), _helper, SLOT(stdOut(const QString&)));
               connect(PythonQt::self(), SIGNAL(pythonStdErr(const QString&)), _helper, SLOT(stdErr(const QString&)));
-              PyRun_SimpleString("print 'test'\n");
+              PyRun_SimpleString("print ('test')\n");
             }
             void PythonQtTestApiHelper::stdOut(const QString& s)
             {
+              outBuf.append(s);
+              QStringList x = outBuf.split("\n");
+              outBuf = x.takeLast();
+              foreach(QString s, x)
                 qDebug() << s;
             }
             void PythonQtTestApiHelper::stdErr(const QString& s)
             {
+              errBuf.append(s);
+              QStringList x = errBuf.split("\n");
+              errBuf = x.takeLast();
+              foreach(QString s, x)
                 qDebug() << s;
             }
             QObject* PythonQtTestCppFactory::create(const QByteArray& name, void *ptr)
             {
               if (name == "PQCppObject") {
                 return new PQCppObjectWrapper(ptr);
               }
               return NULL;
             }

tests/PythonQtTests.h +2 0

             #ifndef _PYTHONQTTESTS_H
             #define _PYTHONQTTESTS_H
             /*
              *
              *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
              *
              *  This library is free software; you can redistribute it and/or
              *  modify it under the terms of the GNU Lesser General Public
              *  License as published by the Free Software Foundation; either
              *  version 2.1 of the License, or (at your option) any later version.
              *
              *  This library is distributed in the hope that it will be useful,
              *  but WITHOUT ANY WARRANTY; without even the implied warranty of
              *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
              *  Lesser General Public License for more details.
              *
              *  Further, this software is distributed without any warranty that it is
              *  free of the rightful claim of any third person regarding infringement
              *  or the like.  Any license provided herein, whether implied or
              *  otherwise, applies only to this software file.  Patent licenses, if
              *  any, provided herein do not apply to combinations of this program with
              *  other software, or any other product whatsoever.
              *
              *  You should have received a copy of the GNU Lesser General Public
              *  License along with this library; if not, write to the Free Software
              *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              *
              *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
              *  28359 Bremen, Germany or:
              *
              *  http://www.mevis.de
              *
              */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtTests.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQt.h"
             #include <QtTest/QtTest>
             #include <QVariant>
             #include "PythonQtImportFileInterface.h"
             #include "PythonQtCppWrapperFactory.h"
             #include <QPen>
             #include <QColor>
             #include <QBrush>
             #include <QCursor>
             class PythonQtTestSlotCallingHelper;
             class PythonQtTestApiHelper;
             class QWidget;
             //! test the PythonQt api
             class PythonQtTestApi : public QObject
             {
               Q_OBJECT
             private slots:
               void initTestCase();
               void testCall();
               void testVariables();
               void testRedirect();
               void testImporter();
               void testQColorDecorators();
               void testQtNamespace();
               void testConnects();
               void testProperties();
               void testDynamicProperties();
             private:
               PythonQtTestApiHelper* _helper;
               PythonQtObjectPtr _main;
             };
             class ClassA {
             public:
               ClassA() { x = 1; }
               int x;
             };
             class ClassB {
             public:
               ClassB() { y = 2; }
               int y;
               virtual int type() { return 2; }
             };
             class ClassC : public ClassA, public ClassB {
             public:
               ClassC() { z = 3; }
               int z;
               virtual int type() { return 3; }
             };
             class ClassD : public QObject, public ClassA, public ClassB {
               Q_OBJECT
             public:
               ClassD() { d = 4; }
               public slots:
                 int getD() { return d; }
             private:
               int d;
               virtual int type() { return 4; }
             };
             class ClassAWrapper : public QObject {
               Q_OBJECT
             public slots:
               ClassA* new_ClassA() { return new ClassA; }
               int getX(ClassA* o) { return o->x; }
             };
             class ClassBWrapper : public QObject {
               Q_OBJECT
             public slots:
               ClassB* new_ClassB() { return new ClassB; }
               int getY(ClassB* o) { return o->y; }
             };
             class ClassCWrapper : public QObject {
               Q_OBJECT
             public slots:
               ClassC* new_ClassC() { return new ClassC; }
               int getZ(ClassC* o) { return o->z; }
             };
             class ClassDWrapper : public QObject {
               Q_OBJECT
                 public slots:
                   ClassD* new_ClassD() { return new ClassD; }
             };
             //! test the PythonQt api (helper)
             class PythonQtTestApiHelper : public QObject , public PythonQtImportFileInterface
             {
               Q_OBJECT
             public:
               PythonQtTestApiHelper() {
               };
               bool call(const QString& function, const QVariantList& args, const QVariant& expectedResult);
               virtual QByteArray readFileAsBytes(const QString& filename);
               virtual QByteArray readSourceFile(const QString& filename, bool& ok);
               virtual bool exists(const QString& filename);
               virtual QDateTime lastModifiedDate(const QString& filename);
             public slots:
               //! call to set that the test has passed (from Python!)
               void setPassed() { _passed = true; }
               void stdOut(const QString&);
               void stdErr(const QString&);
             private:
+              QString outBuf;
+              QString errBuf;
               bool _passed;
             };
             // test implementation of the wrapper factory
             class PythonQtTestCppFactory : public PythonQtCppWrapperFactory
             {
             public:
               virtual QObject* create(const QByteArray& name, void *ptr);
             };
             //! an cpp object to be wrapped
             class PQCppObject {
             public:
               PQCppObject(int h) { _height = h; }
               int getHeight() { return _height; }
               void setHeight(int h) { _height = h; }
             private:
               int _height;
             };
             //! an qobject that wraps the existing cpp object
             class PQCppObjectWrapper : public QObject {
               Q_OBJECT
             public:
               PQCppObjectWrapper(void* ptr) {
                 _ptr = (PQCppObject*)ptr;
               }
             public slots:
               int  getHeight() { return _ptr->getHeight(); }
               void setHeight(int h) { _ptr->setHeight(h); }
             private:
               PQCppObject* _ptr;
             };
             class PQCppObjectDecorator : public QObject {
               Q_OBJECT
             public slots:
               int  getH(PQCppObject* obj) { return obj->getHeight(); }
             };
             //! an cpp object to be wrapped by decorators only
             class PQCppObjectNoWrap {
             public:
               PQCppObjectNoWrap() { _height = 0; }
               PQCppObjectNoWrap(int h) { _height = h; }
               int getHeight() { return _height; }
               void setHeight(int h) { _height = h; }
             private:
               int _height;
             };
             class PQCppObjectNoWrapDecorator : public QObject {
               Q_OBJECT
             public slots:
               PQCppObjectNoWrap* new_PQCppObjectNoWrap() {
                 return new PQCppObjectNoWrap(0);
               }
               PQCppObjectNoWrap* new_PQCppObjectNoWrap(const PQCppObjectNoWrap& other) {
                 return new PQCppObjectNoWrap(1);
               }
               PQCppObjectNoWrap* new_PQCppObjectNoWrap(double value) {
                 return new PQCppObjectNoWrap(2);
               }
               int  getH(PQCppObjectNoWrap* obj) { return obj->getHeight(); }
             };
             //! an cpp object that is to be wrapped by decorators only
             class PQCppObject2 {
             public:
               enum TestEnumFlag {
                 TestEnumValue1 = 0,
                 TestEnumValue2 = 1
               };
               PQCppObject2() {}
             };
             class PQCppObject2Decorator : public QObject {
               Q_OBJECT
             public:
               Q_ENUMS(TestEnumFlag)
               Q_FLAGS(TestEnum)
               enum TestEnumFlag {
                 TestEnumValue1 = 0,
                 TestEnumValue2 = 1
               };
               Q_DECLARE_FLAGS(TestEnum, TestEnumFlag)
               public slots:
               PQCppObject2* new_PQCppObject2() {
                 return new PQCppObject2();
               }
               TestEnumFlag testEnumFlag1(PQCppObject2* obj, TestEnumFlag flag);
               PQCppObject2::TestEnumFlag testEnumFlag2(PQCppObject2* obj, PQCppObject2::TestEnumFlag flag);
               // with int overload
               TestEnumFlag testEnumFlag3(PQCppObject2* obj, int flag);
               TestEnumFlag testEnumFlag3(PQCppObject2* obj, TestEnumFlag flag);
             };
             class PQUnknownValueObject
             {
             public:
               PQUnknownValueObject() {};
             };
             class PQUnknownButRegisteredValueObject
             {
             public:
               PQUnknownButRegisteredValueObject() {};
             };
             //! test the calling of slots
             class PythonQtTestSlotCalling : public QObject
             {
               Q_OBJECT
             private slots:
               void initTestCase();
               void init();
               void testNoArgSlotCall();
               void testPODSlotCalls();
               void testCPPSlotCalls();
               void testQVariantSlotCalls();
               void testObjectSlotCalls();
               void testMultiArgsSlotCall();
               void testPyObjectSlotCall();
               void testOverloadedCall();
               void testCppFactory();
               void testInheritance();
               void testAutoConversion();
             private:
               PythonQtTestSlotCallingHelper* _helper;
             };
             //! helper class for slot calling test
             class PythonQtTestSlotCallingHelper : public QObject
             {
               Q_OBJECT
             public:
               PythonQtTestSlotCallingHelper(PythonQtTestSlotCalling* test) {
                 _test = test;
               };
               bool runScript(const char* script, int expectedOverload = -1);
             public slots:
               //! call to set that the test has passed (from Python!)
               void setPassed() { _passed = true; }
               //! no arguments, no return value:
               void testNoArg() { _called = true; }
               //! overload test!
               void overload(bool a) { _calledOverload = 0; _called = true; }
               void overload(float a) { _calledOverload = 1; _called = true;}
               void overload(int a) { _calledOverload = 2; _called = true;}
               void overload(const QString& str) { _calledOverload = 3; _called = true;}
               void overload(const QStringList& str) { _calledOverload = 4; _called = true;}
               void overload(QObject* str) { _calledOverload = 5; _called = true;}
               void overload(float a, int b) { _calledOverload = 6; _called = true;}
               //! POD values:
               int getInt(int a) {   _called = true; return a; }
               unsigned int getUInt(unsigned int a) { _called = true;  return a; }
               bool getBool(bool a) { _called = true;  return a; }
               char getChar(char a) { _called = true;  return a; }
               unsigned char getUChar(unsigned char a) { _called = true;  return a; }
               long getLong(long a) { _called = true;  return a; }
               unsigned long getULong(unsigned long a) { _called = true;  return a; }
               short getShort(short a) { _called = true;  return a; }
               unsigned short getUShort(unsigned short a) { _called = true;  return a; }
               QChar getQChar(QChar a) { _called = true;  return a; }
               qint64 getLongLong(qint64 a) { _called = true;  return a; }
               quint64 getULongLong(quint64 a) { _called = true;  return a; }
               double getDouble(double d) { _called = true;  return d; }
               float  getFloat(float d) { _called = true;  return d; }
               //! important qt types:
               QString getQString(const QString& s) { _called = true;  return s; }
               QStringList getQStringList(const QStringList& l) { _called = true;  return l; }
               QVariant getQVariant(const QVariant& var) { _called = true;  return var; }
               // QColor as representative for C++ value classes
               QColor  getQColor1(const QColor& var) { _called = true;  return var; }
               QColor  getQColor2(QColor& var) { _called = true;  return var; }
               QColor  getQColor3(QColor* col) { _called = true;  return *col; }
               QColor  getQColor4(const QVariant& color) { _called = true;  return color.value<QColor>(); }
               QColor* getQColor5() { _called = true; static QColor c(1,2,3); return &c; }
               PyObject* getPyObject(PyObject* obj) { _called = true; return obj; }
               PyObject* getPyObjectFromVariant(const QVariant& val) { _called = true; return PythonQtObjectPtr(val); }
               QVariant  getPyObjectFromVariant2(const QVariant& val) { _called = true; return val; }
               // this does not yet work but is not required to work:
               //PyObject* getPyObjectFromPtr(const PythonQtObjectPtr& val) { _called = true; return val; };
               //! testing pointer passing
               PythonQtTestSlotCallingHelper* getTestObject(PythonQtTestSlotCallingHelper* obj) {  _called = true; return obj; }
               //! testing inheritance checking
               QObject* getQObject(QObject* obj) { _called = true; return obj; }
               QWidget* getQWidget(QWidget* obj) { _called = true; return obj; }
               //! testing if an object that was not wrapped is wrapped earlier is wrapped correctly
               QObject* getNewObject() { _called = true; return new PythonQtTestSlotCallingHelper(NULL); }
               QVariantList getMultiArgs(int a, double b, const QString& str) { _called = true; return (QVariantList() << a << b << str); }
               //! cpp wrapper factory test
               PQCppObject* createPQCppObject(int h) { _called = true; return new PQCppObject(h); }
               //! cpp wrapper factory test
               PQCppObject* getPQCppObject(PQCppObject* p) { _called = true; return p; }
               //! cpp wrapper factory test
               PQCppObjectNoWrap* createPQCppObjectNoWrap(int h) { _called = true; return new PQCppObjectNoWrap(h); }
               //! cpp wrapper factory test
               PQCppObjectNoWrap* getPQCppObjectNoWrap(PQCppObjectNoWrap* p) { _called = true; return p; }
               //! get a return by value PQCppObjectNoWrap
               PQCppObjectNoWrap getPQCppObjectNoWrapAsValue() { _called = true; return PQCppObjectNoWrap(47); }
               PQUnknownButRegisteredValueObject getUnknownButRegisteredValueObjectAsValue() { _called = true; return PQUnknownButRegisteredValueObject(); }
               PQUnknownValueObject              getUnknownValueObjectAsValue() { _called = true; return PQUnknownValueObject(); }
               PQUnknownButRegisteredValueObject* getUnknownButRegisteredValueObjectAsPtr() { _called = true; return new PQUnknownButRegisteredValueObject(); }
               PQUnknownValueObject*              getUnknownValueObjectAsPtr() { _called = true; return new PQUnknownValueObject(); }
               ClassA* getClassAPtr(ClassA* o) { _called = true; return o; }
               ClassB* getClassBPtr(ClassB* o) { _called = true; return o; }
               ClassC* getClassCPtr(ClassC* o) { _called = true; return o; }
               ClassD* getClassDPtr(ClassD* o) { _called = true; return o; }
               ClassA* createClassA() { _called = true; return new ClassA; }
               ClassB* createClassB() { _called = true; return new ClassB; }
               ClassC* createClassC() { _called = true; return new ClassC; }
               ClassD* createClassD() { _called = true; return new ClassD; }
               ClassA* createClassCAsA() { _called = true; return new ClassC; }
               ClassB* createClassCAsB() { _called = true; return new ClassC; }
               ClassA* createClassDAsA() { _called = true; return new ClassD; }
               ClassB* createClassDAsB() { _called = true; return new ClassD; }
               QColor  setAutoConvertColor(const QColor& color) { _called = true; return color; };
               QBrush  setAutoConvertBrush(const QBrush& brush) { _called = true; return brush; };
               QPen    setAutoConvertPen(const QPen& pen) { _called = true; return pen; };
               QCursor setAutoConvertCursor(const QCursor& cursor) { _called = true; return cursor; };
             private:
               bool _passed;
               bool _called;
               int  _calledOverload;
               PythonQtTestSlotCalling* _test;
             };
             class PythonQtTestSignalHandlerHelper;
             //! test the connection of signals to python
             class PythonQtTestSignalHandler : public QObject
             {
               Q_OBJECT
             private slots:
               void initTestCase();
               void testSignalHandler();
               void testRecursiveSignalHandler();
             private:
               PythonQtTestSignalHandlerHelper* _helper;
             };
             //! helper class for signal testing
             class PythonQtTestSignalHandlerHelper : public QObject
             {
               Q_OBJECT
             public:
               PythonQtTestSignalHandlerHelper(PythonQtTestSignalHandler* test) {
                 _test = test;
               };
             public slots:
               void setPassed() { _passed = true; }
               bool emitIntSignal(int a) { _passed = false; emit intSignal(a); return _passed; };
               bool emitFloatSignal(float a) { _passed = false; emit floatSignal(a); return _passed; };
               bool emitEnumSignal(PQCppObject2::TestEnumFlag flag) { _passed = false; emit enumSignal(flag); return _passed; };
               bool emitVariantSignal(const QVariant& v) { _passed = false; emit variantSignal(v); return _passed; };
               QVariant expectedVariant() { return _v; }
               void setExpectedVariant(const QVariant& v) { _v = v; }
               bool emitComplexSignal(int a, float b, const QStringList& l, QObject* obj) { _passed = false; emit complexSignal(a,b,l,obj); return _passed; };
               bool emitSignal1(int a) { _passed = false; emit signal1(a); return _passed; };
               bool emitSignal2(const QString& s) { _passed = false; emit signal2(s); return _passed; };
               bool emitSignal3(float a) { _passed = false; emit signal3(a); return _passed; };
             signals:
               void intSignal(int);
               void floatSignal(float);
               void variantSignal(const QVariant& v);
               void complexSignal(int a, float b, const QStringList& l, QObject* obj);
               void enumSignal(PQCppObject2::TestEnumFlag flag);
               void signal1(int);
               void signal2(const QString&);
               void signal3(float);
             private:
               bool _passed;
               QVariant _v;
               PythonQtTestSignalHandler* _test;
             };
             #endif

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