GIT_REPOSITORIES/LPP/PythonQt Commit - r161:87322f2ddb44

merged contributions from https://github.com/commontk/PythonQt/compare/svn-mirror...patched...

florianlink -

r161:87322f2ddb44

parent child

Context file:

r161:87322f2ddb44

Collapse all files

src/PythonQt.cpp +61 -1

             /*
             *
             *  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 "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*);
             void PythonQt::init(int flags, const QByteArray& pythonQtModuleName)
             {
               if (!_self) {
                 _self = new PythonQt(flags, pythonQtModuleName);
                 PythonQtMethodInfo::addParameterTypeAlias("QObjectList", "QList<QObject*>");
                 qRegisterMetaType<QList<QObject*> >("QList<void*>");
                 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::self()->addDecorators(new PythonQtStdDecorators());
                 PythonQt_init_QtCoreBuiltin(NULL);
                 PythonQt_init_QtGuiBuiltin(NULL);
                 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];
                   }
                 }
               }
             }
             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) {
-                Py_SetProgramName("PythonQt");
+                Py_SetProgramName(const_cast<char*>("PythonQt"));
                 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);
               // 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);
               _p->setupSharedLibrarySuffixes();
             }
             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
+              PyRun_SimpleString("if not hasattr(sys, 'pythonqt_original_stdin'):"
+                                 "sys.pythonqt_original_stdin = sys.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, "stdin", in);
+              // Backup custom 'stdin' into 'pythonqt_stdin'
+              PyRun_SimpleString("sys.pythonqt_stdin = sys.stdin");
+            }
+            void PythonQt::setRedirectStdInCallbackEnabled(bool enabled)
+            {
+              if (enabled)
+                {
+                PyRun_SimpleString("if hasattr(sys, 'pythonqt_stdin'):"
+                                   "sys.stdin = sys.pythonqt_stdin");
+                }
+              else
+                {
+                PyRun_SimpleString("if hasattr(sys,'pythonqt_original_stdin'):"
+                                   "sys.stdin = sys.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) {
                 // 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);
               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 it's 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())) {
                     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, 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 (!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());
                 }
+                // TODO XXX: delegate wrapping via CB here (pass name and ptr)
                 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);
                 PyTuple_SET_ITEM(dummyTuple, 0 , PyString_FromString("dummy"));
               }
               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;
               PyObject* className = PyString_FromString(info->className());
               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;
               PyObject* className = PyString_FromString(enumName);
               PyObject* baseClasses = PyTuple_New(1);
               PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PyInt_Type);
               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;
               QString s;
               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;
               if (pycode) {
                 PyObject* dict = NULL;
                 if (PyModule_Check(object)) {
                   dict = PyModule_GetDict(object);
                 } else if (PyDict_Check(object)) {
                   dict = object;
                 }
                 PyObject* r = NULL;
                 if (dict) {
                   r = PyEval_EvalCode((PyCodeObject*)pycode, dict , dict);
                 }
                 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;
               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);
               if (code) {
                 evalCode(module, code);
               } else {
                 handleError();
               }
             }
             PythonQtObjectPtr PythonQt::parseFile(const QString& filename)
             {
               PythonQtObjectPtr p;
               p.setNewRef(PythonQtImport::getCodeFromPyc(filename));
               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) {
                 if (type == CallOverloads) {
                   if (PythonQtSlotFunction_Check(object)) {
                     PythonQtSlotFunctionObject* o = (PythonQtSlotFunctionObject*)object.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.object();
                     PythonQtSlotInfo* info = o->classInfo()->constructors();
                     while (info) {
                       results << info->fullSignature();
                       info = info->nextInfo();
                     }
                   } else {
                     //TODO: use pydoc!
                     PyObject* doc = PyObject_GetAttrString(object, "__doc__");
                     if (doc) {
                       results << PyString_AsString(doc);
                       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;
                       keystr = PyString_AsString(key);
                       static const QString underscoreStr("__tmp");
                       if (!keystr.startsWith(underscoreStr)) {
                         switch (type) {
                         case Anything:
                           results << keystr;
                           break;
                         case Class:
                           if (value->ob_type == &PyClass_Type) {
                             results << keystr;
                           }
                           break;
                         case Variable:
                           if (value->ob_type != &PyClass_Type
                             && value->ob_type != &PyCFunction_Type
                             && value->ob_type != &PyFunction_Type
                             && value->ob_type != &PyModule_Type
                             ) {
                             results << keystr;
                           }
                           break;
                         case Function:
                           if (value->ob_type == &PyFunction_Type ||
                             value->ob_type == &PyMethod_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);
                   }
                 }
               }
               return results;
             }
             QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args)
             {
               PythonQtObjectPtr callable = lookupCallable(object, name);
               if (callable) {
                 return call(callable, args);
               } else {
                 return QVariant();
               }
             }
             QVariant PythonQt::call(PyObject* callable, const QVariantList& args)
             {
               QVariant r;
               PythonQtObjectPtr result;
               result.setNewRef(callAndReturnPyObject(callable, args));
               if (result) {
                 r = PythonQtConv::PyObjToQVariant(result);
               } else {
                 PythonQt::self()->handleError();
               }
               return r;
             }
             PyObject* PythonQt::callAndReturnPyObject(PyObject* callable, const QVariantList& args)
             {
               PyObject* result = NULL;
               if (callable) {
                 PythonQtObjectPtr pargs;
                 int count = args.size();
                 if (count>0) {
                   pargs.setNewRef(PyTuple_New(count));
                 }
                 bool err = false;
                 // transform QVariants 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) {
                   PyErr_Clear();
                   result = PyObject_CallObject(callable, pargs);
                 }
               }
               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);
             }
             //---------------------------------------------------------------------------------------------------
             PythonQtPrivate::PythonQtPrivate()
             {
               _importInterface = NULL;
               _defaultImporter = new PythonQtQFileImporter;
               _noLongerWrappedCB = NULL;
               _wrappedCB = NULL;
               _currentClassInfoForClassWrapperCreation = NULL;
               _profilingCB = NULL;
             }
             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
               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) {
                   if (qstrncmp(m.signature(), "new_", 4)==0) {
                     if ((decoTypes & ConstructorDecorator) == 0) continue;
                     const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                     if (info->parameters().at(0).pointerCount == 1) {
                       QByteArray signature = m.signature();
                       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 (qstrncmp(m.signature(), "delete_", 7)==0) {
                     if ((decoTypes & DestructorDecorator) == 0) continue;
                     QByteArray signature = m.signature();
                     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 (qstrncmp(m.signature(), "static_", 7)==0) {
                     if ((decoTypes & StaticDecorator) == 0) continue;
                     QByteArray signature = m.signature();
                     QByteArray nameOfClass = signature.mid(signature.indexOf('_')+1);
                     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)
             {
               foreach(QString name, names) {
                 _knownQObjectClassNames.insert(name.toLatin1(), true);
               }
             }
             void PythonQtPrivate::removeSignalEmitter(QObject* obj)
             {
               _signalReceivers.remove(obj);
             }
             bool PythonQt::handleError()
             {
               bool flag = false;
               if (PyErr_Occurred()) {
                 // 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;
               }
               return flag;
             }
             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;
+              }
               emit PythonQt::self()->pythonStdOut(str);
             }
             void PythonQt::stdErrRedirectCB(const QString& str)
             {
+              if (!PythonQt::self()) {
+                std::cerr << str.toLatin1().data() << std::endl;
+                return;
+              }
               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}
             };
             void PythonQt::initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName)
             {
               QByteArray name = "PythonQt";
               if (!pythonQtModuleName.isEmpty()) {
                 name = pythonQtModuleName;
               }
               _p->_pythonQtModule = Py_InitModule(name.constData(), PythonQtMethods);
               _p->_pythonQtModuleName = name;
               if (redirectStdOut) {
                 PythonQtObjectPtr sys;
                 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);
               }
             }
             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) {
                 emit pythonHelpRequest(QByteArray(info->className()));
                 return Py_BuildValue("");
               } else {
                 return PyString_FromString(info->help().toLatin1().data());
               }
             }
             void PythonQt::clearNotFoundCachedMembers()
             {
               foreach(PythonQtClassInfo* info, _p->_knownClassInfos) {
                 info->clearNotFoundCachedMembers();
               }
             }
             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;
               if (pycode) {
                 result.setNewRef(PyImport_ExecCodeModule((char*)name.toLatin1().data(), pycode));
               } else {
                 PythonQt::self()->handleError();
               }
               return result;
             }

src/PythonQt.h +22 -3

             #ifndef _PYTHONQT_H
             #define _PYTHONQT_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    PythonQt.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtSystem.h"
             #include "PythonQtInstanceWrapper.h"
             #include "PythonQtClassWrapper.h"
             #include "PythonQtSlot.h"
             #include "PythonQtObjectPtr.h"
+            #include "PythonQtStdIn.h"
             #include <QObject>
             #include <QVariant>
             #include <QList>
             #include <QHash>
             #include <QByteArray>
             #include <QStringList>
             #include <QtDebug>
             #include <iostream>
             class PythonQtClassInfo;
             class PythonQtPrivate;
             class PythonQtMethodInfo;
             class PythonQtSignalReceiver;
             class PythonQtImportFileInterface;
             class PythonQtCppWrapperFactory;
             class PythonQtQFileImporter;
             typedef void  PythonQtQObjectWrappedCB(QObject* object);
             typedef void  PythonQtQObjectNoLongerWrappedCB(QObject* object);
             typedef void* PythonQtPolymorphicHandlerCB(const void *ptr, char **class_name);
             typedef void PythonQtShellSetInstanceWrapperCB(void* object, PythonQtInstanceWrapper* wrapper);
-            template<class T> void PythonQtSetInstanceWrapperOnShell(void* object, PythonQtInstanceWrapper* wrapper) { ((T*)object)->_wrapper = wrapper; };
+            template<class T> void PythonQtSetInstanceWrapperOnShell(void* object, PythonQtInstanceWrapper* wrapper) {
+              (reinterpret_cast<T*>(object))->_wrapper = wrapper;
+            }
             //! returns the offset that needs to be added to upcast an object of type T1 to T2
             template<class T1, class T2> int PythonQtUpcastingOffset() {
-              return (((char*)(static_cast<T2*>(reinterpret_cast<T1*>(0x100)))) - ((char*)reinterpret_cast<T1*>(0x100)));
+              return ((reinterpret_cast<char*>(static_cast<T2*>(reinterpret_cast<T1*>(0x100))))
+                      - (reinterpret_cast<char*>(reinterpret_cast<T1*>(0x100))));
             }
             //! callback to create a QObject lazily
             typedef QObject* PythonQtQObjectCreatorFunctionCB();
             //! helper template to create a derived QObject class
             template<class T> QObject* PythonQtCreateObject() { return new T(); };
             //! The main interface to the Python Qt binding, realized as a singleton
             /*!
              Use PythonQt::init() to initialize the singleton and PythonQt::self() to access it.
              While there can be only one PythonQt instance, you can have any number of Python context to do scripting in.
              One possibility is to use createModuleFromFile(), createModuleFromScript() or createUniqueModule() to get a context
              that is separated from the other contexts. Alternatively you can use Python dicts as contexts for script evaluation,
              but you will need to populate the dict with the __builtins__ instance to have all Pythons available when running
              code in the scope of a dict.
              */
             class PYTHONQT_EXPORT PythonQt : public QObject {
               Q_OBJECT
             public:
               //! flags that can be passed to PythonQt::init()
               enum InitFlags {
                 RedirectStdOut = 1,   //!<< sets if the std out/err is redirected to pythonStdOut() and pythonStdErr() signals
                 IgnoreSiteModule = 2, //!<< sets if Python should ignore the site module
                 ExternalHelp = 4,     //!<< sets if help() calls on PythonQt modules are forwarded to the pythonHelpRequest() signal
                 PythonAlreadyInitialized = 8 //!<< sets that PythonQt should not can PyInitialize, since it is already done
               };
               //! flags that tell PythonQt which operators to expect on the registered type
               enum TypeSlots {
                 Type_Add = 1,
                 Type_Subtract = 1 << 1,
                 Type_Multiply = 1 << 2,
                 Type_Divide = 1 << 3,
                 Type_Mod = 1 << 4,
                 Type_And = 1 << 5,
                 Type_Or = 1 << 6,
                 Type_Xor = 1 << 7,
                 Type_LShift = 1 << 8,
                 Type_RShift = 1 << 9,
                 Type_InplaceAdd = 1 << 10,
                 Type_InplaceSubtract = 1 << 11,
                 Type_InplaceMultiply = 1 << 12,
                 Type_InplaceDivide = 1 << 13,
                 Type_InplaceMod = 1 << 14,
                 Type_InplaceAnd = 1 << 15,
                 Type_InplaceOr = 1 << 16,
                 Type_InplaceXor = 1 << 17,
                 Type_InplaceLShift = 1 << 18,
                 Type_InplaceRShift = 1 << 19,
                 // Not yet needed/nicely mappable/generated...
                 //Type_Positive = 1 << 29,
                 //Type_Negative = 1 << 29,
                 //Type_Abs = 1 << 29,
                 //Type_Hash = 1 << 29,
                 Type_Invert = 1 << 29,
                 Type_RichCompare = 1 << 30,
                 Type_NonZero     = 1 << 31,
               };
               //! enum for profiling callback
               enum ProfilingCallbackState {
                 Enter = 1,
                 Leave = 2
               };
               //! callback for profiling. className and methodName are only passed when state == Enter, otherwise
               //! they are NULL.
               typedef void ProfilingCB(ProfilingCallbackState state, const char* className, const char* methodName);
               //---------------------------------------------------------------------------
               //! \name Singleton Initialization
               //@{
               //! initialize the python qt binding (flags are a or combination of PythonQt::InitFlags), if \c pythonQtModuleName is given
               //! it defines the name of the python module that PythonQt will add, otherwise "PythonQt" is used.
               //! This can be used to e.g. pass in PySide or PyQt4 to make it more compatible.
               static void init(int flags = IgnoreSiteModule | RedirectStdOut, const QByteArray& pythonQtModuleName = QByteArray());
               //! cleanup of the singleton
               static void cleanup();
               //! get the singleton instance
-              static PythonQt* self() { return _self; }
+              static PythonQt* self();
               //@}
               //! defines the object types for introspection
               enum ObjectType {
                 Class,
                 Function,
                 Variable,
                 Module,
                 Anything,
                 CallOverloads
               };
+              //---------------------------------------------------------------------------
+              //! \name Standard input handling
+              //@{
+              //! Overwrite default handling of stdin using a custom callback. It internally backup
+              //! the original 'sys.stdin' into 'sys.pythonqt_original_stdin'
+              void setRedirectStdInCallback(PythonQtInputChangedCB* callback, void * callbackData = 0);
+              //! Enable or disable stdin custom callback. It resets 'sys.stdin' using either 'sys.pythonqt_stdin'
+              //! or 'sys.pythonqt_original_stdin'
+              void setRedirectStdInCallbackEnabled(bool enabled);
+              //@}
               //---------------------------------------------------------------------------
               //! \name Modules
               //@{
               //! get the __main__ module of python
               PythonQtObjectPtr getMainModule();
               //! import the given module and return a reference to it (useful to import e.g. "sys" and call something on it)
               //! If a module is already imported, this returns the already imported module.
               PythonQtObjectPtr importModule(const QString& name);
               //! creates the new module \c name and evaluates the given file in the context of that module
               //! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code
               //! to a module later on.
               //! The user needs to make sure that the \c name is unique in the python module dictionary.
               PythonQtObjectPtr createModuleFromFile(const QString& name, const QString& filename);
               //! creates the new module \c name and evaluates the given script in the context of that module.
               //! If the \c script is empty, the module contains no initial code. You can use evalScript/evalCode to add code
               //! to a module later on.
               //! The user needs to make sure that the \c name is unique in the python module dictionary.
               PythonQtObjectPtr createModuleFromScript(const QString& name, const QString& script = QString());
               //! create a uniquely named module, you can use evalFile or evalScript to populate the module with
               //! script code
               PythonQtObjectPtr createUniqueModule();
               //@}
               //---------------------------------------------------------------------------
               //! \name Importing/Paths
               //@{
               //! overwrite the python sys path (call this directly after PythonQt::init() if you want to change the std python sys path)
               void overwriteSysPath(const QStringList& paths);
               //! prepend a path to sys.path to allow importing from it
               void addSysPath(const QString& path);
               //! sets the __path__ list of a module to the given list (important for local imports)
               void setModuleImportPath(PyObject* module, const QStringList& paths);
               //@}
               //---------------------------------------------------------------------------
               //! \name Registering Classes
               //@{
               //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
               /* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
                you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
               void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
               //! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
               //! (ownership of wrapper is passed to PythonQt)
               /*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!
                This will add a wrapper object that is used to make calls to the given classname \c typeName.
                All slots that take a pointer to typeName as the first argument will be callable from Python on
                a variant object that contains such a type.
                */
               void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);
               //! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
               //! and it will register the classes when it first sees a pointer to such a derived class
               void registerQObjectClassNames(const QStringList& names);
               //! add a parent class relation to the \c given typeName, the upcastingOffset is needed for multiple inheritance
               //! and can be calculated using PythonQtUpcastingOffset<type,parentType>(), which also verifies that
               //! type is really derived from parentType.
               //! Returns false if the typeName was not yet registered.
               bool addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset=0);
               //! add a handler for polymorphic downcasting
               void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);
               //@}
               //---------------------------------------------------------------------------
               //! \name Script Parsing and Evaluation
               //@{
               //! parses the given file and returns the python code object, this can then be used to call evalCode()
               PythonQtObjectPtr parseFile(const QString& filename);
               //! evaluates the given code and returns the result value (use Py_Compile etc. to create pycode from string)
               //! If pycode is NULL, a python error is printed.
               QVariant evalCode(PyObject* object, PyObject* pycode);
               //! evaluates the given script code and returns the result value
               QVariant evalScript(PyObject* object, const QString& script, int start = Py_file_input);
               //! evaluates the given script code from file
               void evalFile(PyObject* object, const QString& filename);
               //@}
               //---------------------------------------------------------------------------
               //! \name Signal Handlers
               //@{
               //! add a signal handler to the given \c signal of \c obj  and connect it to a callable \c objectname in module
               bool addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname);
               //! remove a signal handler from the given \c signal of \c obj
               bool removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname);
               //! add a signal handler to the given \c signal of \c obj  and connect it to a callable \c receiver
               bool addSignalHandler(QObject* obj, const char* signal, PyObject* receiver);
               //! remove a signal handler from the given \c signal of \c obj
               bool removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver);
               //@}
               //---------------------------------------------------------------------------
               //! \name Variable access
               //@{
               //! add the given \c qObject to the python \c object as a variable with \c name (it can be removed via clearVariable)
               void addObject(PyObject* object, const QString& name, QObject* qObject);
               //! add the given variable to the object
               void addVariable(PyObject* object, const QString& name, const QVariant& v);
               //! remove the given variable
               void removeVariable(PyObject* module, const QString& name);
               //! get the variable with the \c name of the \c object, returns an invalid QVariant on error
               QVariant getVariable(PyObject* object, const QString& name);
               //! read vars etc. in scope of an \c object, optional looking inside of an object \c objectname
               QStringList introspection(PyObject* object, const QString& objectname, ObjectType type);
               //! returns the found callable object or NULL
               //! @return new reference
               PythonQtObjectPtr lookupCallable(PyObject* object, const QString& name);
               //@}
               //---------------------------------------------------------------------------
               //! \name Calling Python Objects
               //@{
               //! call the given python \c callable in the scope of object, returns the result converted to a QVariant
               QVariant call(PyObject* object, const QString& callable, const QVariantList& args = QVariantList());
               //! call the given python object, returns the result converted to a QVariant
               QVariant call(PyObject* callable, const QVariantList& args = QVariantList());
               //! call the given python object, returns the result as new PyObject
               PyObject* callAndReturnPyObject(PyObject* callable, const QVariantList& args = QVariantList());
               //@}
               //---------------------------------------------------------------------------
               //! \name Decorations, Constructors, Wrappers...
               //@{
               //! add an object whose slots will be used as decorator slots for
               //! other QObjects or CPP classes. The slots need to follow the
               //! convention that the first argument is a pointer to the wrapped object.
               //! (ownership is passed to PythonQt)
               /*!
               Example:
               A slot with the signature
               \code
               bool doSomething(QWidget* w, int a)
               \endcode
               will extend QWidget instances (and derived classes) with a "bool doSomething(int a)" slot
               that will be called with the concrete instance as first argument.
               So in Python you can now e.g. call
               \code
               someWidget.doSomething(12)
               \endcode
               without QWidget really having this method. This allows to easily make normal methods
               of Qt classes callable by forwarding them with such decorator slots
               or to make CPP classes (which are not derived from QObject) callable from Python.
               */
               void addInstanceDecorators(QObject* o);
               //! add an object whose slots will be used as decorator slots for
               //! class objects (ownership is passed to PythonQt)
               /*!
               The slots need to follow the following convention:
               - SomeClass* new_SomeClass(...)
               - QVariant new_SomeClass(...)
               - void delete_SomeClass(SomeClass*)
               - ... static_SomeClass_someName(...)
               This will add:
               - a constructor
               - a constructor which generates a QVariant
               - a destructor (only useful for CPP objects)
               - a static decorator slot which will be available on the MetaObject (visible in PythonQt module)
               */
               void addClassDecorators(QObject* o);
               //! this will add the object both as class and instance decorator (ownership is passed to PythonQt)
               void addDecorators(QObject* o);
               //! add the given factory to PythonQt (ownership stays with caller)
               void addWrapperFactory(PythonQtCppWrapperFactory* factory);
               //@}
               //---------------------------------------------------------------------------
               //! \name Custom Importer
               //@{
               //! replace the internal import implementation and use the supplied interface to load files (both py and pyc files)
               //! (this method should be called directly after initialization of init() and before calling overwriteSysPath().
               //! On the first call to this method, it will install a generic PythonQt importer in Pythons "path_hooks".
               //! This is not reversible, so even setting setImporter(NULL) afterwards will
               //! keep the custom PythonQt importer with a QFile default import interface.
               //! Subsequent python import calls will make use of the passed importInterface
               //! which forwards all import calls to the given \c importInterface.
               //! Passing NULL will install a default QFile importer.
               //! (\c importInterface ownership stays with caller)
               void setImporter(PythonQtImportFileInterface* importInterface);
               //! this installs the default QFile importer (which effectively does a setImporter(NULL))
               //! (without calling setImporter or installDefaultImporter at least once, the default python import
               //! mechanism is in place)
               //! the default importer allows to import files from anywhere QFile can read from,
               //! including the Qt resource system using ":". Keep in mind that you need to extend
               //! "sys.path" with ":" to be able to import from the Qt resources.
               void installDefaultImporter() { setImporter(NULL); }
               //! set paths that the importer should ignore
               void setImporterIgnorePaths(const QStringList& paths);
               //! get paths that the importer should ignore
               const QStringList& getImporterIgnorePaths();
               //! get access to the file importer (if set)
               static PythonQtImportFileInterface* importInterface();
               //@}
               //---------------------------------------------------------------------------
               //! \name Other Stuff
               //@{
               //! get access to internal data (should not be used on the public API, but is used by some C functions)
               static PythonQtPrivate* priv() { return _self->_p; }
               //! handle a python error, call this when a python function fails. If no error occurred, it returns false.
               //! The error is currently just output to the python stderr, future version might implement better trace printing
               bool handleError();
               //! clear all NotFound entries on all class infos, to ensure that
               //! newly loaded wrappers can add methods even when the object was wrapped by PythonQt before the wrapper was loaded
               void clearNotFoundCachedMembers();
               //! set a callback that is called when a QObject with parent == NULL is wrapped by pythonqt
               void setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb);
               //! set a callback that is called when a QObject with parent == NULL is no longer wrapped by pythonqt
               void setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb);
               //! call the callback if it is set
               static void qObjectNoLongerWrappedCB(QObject* o);
               //! called by internal help methods
               PyObject* helpCalled(PythonQtClassInfo* info);
               //! returns the found object or NULL
               //! @return new reference
               PythonQtObjectPtr lookupObject(PyObject* module, const QString& name);
               //! sets a callback that is called before and after function calls for profiling
               void setProfilingCallback(ProfilingCB* cb);
               //@}
             signals:
               //! emitted when python outputs something to stdout (and redirection is turned on)
               void pythonStdOut(const QString& str);
               //! emitted when python outputs something to stderr (and redirection is turned on)
               void pythonStdErr(const QString& str);
               //! emitted when help() is called on a PythonQt object and \c ExternalHelp is enabled
               void pythonHelpRequest(const QByteArray& cppClassName);
             private:
               void initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName);
               //! callback for stdout redirection, emits pythonStdOut signal
               static void stdOutRedirectCB(const QString& str);
               //! callback for stderr redirection, emits pythonStdErr signal
               static void stdErrRedirectCB(const QString& str);
               //! get (and create if not available) the signal receiver of that QObject, signal receiver is made child of the passed \c obj
               PythonQtSignalReceiver* getSignalReceiver(QObject* obj);
               PythonQt(int flags, const QByteArray& pythonQtModuleName);
               ~PythonQt();
               static PythonQt* _self;
               static int _uniqueModuleCount;
               PythonQtPrivate* _p;
             };
             //! internal PythonQt details
             class PYTHONQT_EXPORT PythonQtPrivate : public QObject {
               Q_OBJECT
             public:
               PythonQtPrivate();
               ~PythonQtPrivate();
               enum DecoratorTypes {
                 StaticDecorator = 1,
                 ConstructorDecorator = 2,
                 DestructorDecorator = 4,
                 InstanceDecorator = 8,
                 AllDecorators = 0xffff
               };
               //! get the suffixes that are used for shared libraries
               const QStringList& sharedLibrarySuffixes() { return _sharedLibrarySuffixes; }
               //! returns if the id is the id for PythonQtObjectPtr
               bool isPythonQtObjectPtrMetaId(int id) { return _PythonQtObjectPtr_metaId == id; }
               //! add the wrapper pointer (for reuse if the same obj appears while wrapper still exists)
               void addWrapperPointer(void* obj, PythonQtInstanceWrapper* wrapper);
               //! remove the wrapper ptr again
               void removeWrapperPointer(void* obj);
               //! add parent class relation
               bool addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset);
               //! add a handler for polymorphic downcasting
               void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);
               //! lookup existing classinfo and return new if not yet present
               PythonQtClassInfo* lookupClassInfoAndCreateIfNotPresent(const char* typeName);
               //! called when a signal emitting QObject is destroyed to remove the signal handler from the hash map
               void removeSignalEmitter(QObject* obj);
               //! wrap the given QObject into a Python object (or return existing wrapper!)
               PyObject* wrapQObject(QObject* obj);
               //! wrap the given ptr into a Python object (or return existing wrapper!) if there is a known QObject of that name or a known wrapper in the factory
               PyObject* wrapPtr(void* ptr, const QByteArray& name);
               //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)
               /* Since Qt4 does not offer a way to detect if a given classname is derived from QObject and thus has a QMetaObject,
                  you MUST register all your QObject derived classes here when you want them to be detected in signal and slot calls */
               void registerClass(const QMetaObject* metaobject, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);
               //! add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants
               //! (ownership of wrapper is passed to PythonQt)
               /*! Make sure that you have done a qRegisterMetaType first, if typeName is a user type!
                This will add a wrapper object that is used to make calls to the given classname \c typeName.
                All slots that take a pointer to typeName as the first argument will be callable from Python on
                a variant object that contains such a type.
                */
               void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);
               //! as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes
               //! and it will register the classes when it first sees a pointer to such a derived class
               void registerQObjectClassNames(const QStringList& names);
               //! add a decorator object
               void addDecorators(QObject* o, int decoTypes);
               //! helper method that creates a PythonQtClassWrapper object  (returns a new reference)
               PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* module);
               //! create a new instance of the given enum type with given value (returns a new reference)
               static PyObject*  createEnumValueInstance(PyObject* enumType, unsigned int enumValue);
               //! helper that creates a new int derived class that represents the enum of the given name  (returns a new reference)
               static PyObject* createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject);
               //! helper method that creates a PythonQtInstanceWrapper object and registers it in the object map
               PythonQtInstanceWrapper* createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);
               //! get the class info for a meta object (if available)
               PythonQtClassInfo* getClassInfo(const QMetaObject* meta) { return _knownClassInfos.value(meta->className()); }
               //! get the class info for a meta object (if available)
               PythonQtClassInfo* getClassInfo(const QByteArray& className) { return _knownClassInfos.value(className); }
               //! creates the new module from the given pycode
               PythonQtObjectPtr createModule(const QString& name, PyObject* pycode);
               //! get the current class info (for the next PythonQtClassWrapper that is created) and reset it to NULL again
               PythonQtClassInfo* currentClassInfoForClassWrapperCreation();
               //! the dummy tuple (which is empty and may be used to detected that a wrapper is called from internal wrapper creation
               static PyObject* dummyTuple();
               //! called by virtual overloads when a python return value can not be converted to the required Qt type
               void handleVirtualOverloadReturnError(const char* signature, const PythonQtMethodInfo* methodInfo, PyObject* result);
               //! get access to the PythonQt module
               PythonQtObjectPtr pythonQtModule() const { return _pythonQtModule; }
               //! returns the profiling callback, which may be NULL
               PythonQt::ProfilingCB* profilingCB() const { return _profilingCB; }
             private:
               //! Setup the shared library suffixes by getting them from the "imp" module.
               void setupSharedLibrarySuffixes();
               //! create a new pythonqt class wrapper and place it in the pythonqt module
               void createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module = NULL);
               //! get/create new package module (the returned object is a borrowed reference)
               PyObject* packageByName(const char* name);
               //! get the wrapper for a given pointer (and remove a wrapper of an already destroyed qobject)
               PythonQtInstanceWrapper* findWrapperAndRemoveUnused(void* obj);
               //! stores pointer to PyObject mapping of wrapped QObjects AND C++ objects
               QHash<void* , PythonQtInstanceWrapper *> _wrappedObjects;
               //! stores the meta info of known Qt classes
               QHash<QByteArray, PythonQtClassInfo *>   _knownClassInfos;
               //! names of qobject derived classes that can be casted to qobject savely
               QHash<QByteArray, bool> _knownQObjectClassNames;
               //! stores signal receivers for QObjects
               QHash<QObject* , PythonQtSignalReceiver *> _signalReceivers;
               //! the PythonQt python module
               PythonQtObjectPtr _pythonQtModule;
               //! the name of the PythonQt python module
               QByteArray _pythonQtModuleName;
               //! the importer interface (if set)
               PythonQtImportFileInterface* _importInterface;
               //! the default importer
               PythonQtQFileImporter* _defaultImporter;
               PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
               PythonQtQObjectWrappedCB* _wrappedCB;
               QStringList _importIgnorePaths;
               QStringList _sharedLibrarySuffixes;
               //! the cpp object wrapper factories
               QList<PythonQtCppWrapperFactory*> _cppWrapperFactories;
               QHash<QByteArray, PyObject*> _packages;
               PythonQtClassInfo* _currentClassInfoForClassWrapperCreation;
               PythonQt::ProfilingCB* _profilingCB;
               int _initFlags;
               int _PythonQtObjectPtr_metaId;
               friend class PythonQt;
             };
             #endif

src/PythonQtClassWrapper.h +1 -1

             #ifndef _PYTHONQTCLASSWRAPPER_H
             #define _PYTHONQTCLASSWRAPPER_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    PythonQtClassWrapper.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
-            #include <Python.h>
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"
             #include "structmember.h"
             #include "methodobject.h"
             #include "compile.h"
             #include "eval.h"
             #include <QString>
             class PythonQtClassInfo;
             //! the type of the PythonQt class wrapper objects
             extern PYTHONQT_EXPORT PyTypeObject PythonQtClassWrapper_Type;
             //---------------------------------------------------------------
             //! a Python wrapper object for PythonQt wrapped classes
             //! which inherits from the Python type object to allow
             //! deriving of wrapped CPP classes from Python.
             typedef struct {
               PyHeapTypeObject _base;
               //! the additional class information that PythonQt stores for the CPP class
               PythonQtClassInfo* _classInfo;
               //! get the class info
               PythonQtClassInfo* classInfo() { return _classInfo; }
             } PythonQtClassWrapper;
             //---------------------------------------------------------------
             #endif

src/PythonQtConversion.cpp +3 -10

             /*
             *
             *  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>
             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:
                 return PyString_FromString(*((char**)data));
               } 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 PyInt_FromLong(*((char*)data));
               case QMetaType::UChar:
                 return PyInt_FromLong(*((unsigned char*)data));
               case QMetaType::Short:
                 return PyInt_FromLong(*((short*)data));
               case QMetaType::UShort:
                 return PyInt_FromLong(*((unsigned short*)data));
               case QMetaType::Long:
                 return PyInt_FromLong(*((long*)data));
               case QMetaType::ULong:
                 // does not fit into simple int of python
                 return PyLong_FromUnsignedLong(*((unsigned long*)data));
               case QMetaType::Bool:
                 return PythonQtConv::GetPyBool(*((bool*)data));
               case QMetaType::Int:
                 return PyInt_FromLong(*((int*)data));
               case QMetaType::UInt:
                 // does not fit into simple int of python
                 return PyLong_FromUnsignedLong(*((unsigned int*)data));
               case QMetaType::QChar:
                 return PyInt_FromLong(*((short*)data));
               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:
               case QMetaType::QWidgetStar:
                 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
                     void* newCPPObject = QMetaType::construct(type, data);
                     // 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)PyInt_AS_LONG(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)PyInt_AS_LONG(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)PyInt_AS_LONG(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)PyInt_AS_LONG(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
                  }
                } else if (info.pointerCount == 1) {
                  // a pointer
                  if (info.typeId == QMetaType::Char || info.typeId == QMetaType::UChar)
                  {
                    QString str = PyObjGetString(obj, strict, ok);
                    if (ok) {
                      void* ptr2 = NULL;
                      PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(str.toUtf8()), ptr2);
                      PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, (((QByteArray*)((QVariant*)ptr2)->constData())->data()), ptr);
                    }
                  } 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) {
+                 // TODO XXX: pass obj and name and add when it returns a pointer
+                 else if (obj == Py_None) {
                    // None is treated as a NULL ptr
                    PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, NULL, 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 = PyInt_AS_LONG(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 &&
                 (val->ob_type == &PyString_Type ||
                 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) {
                 r = QString(PyString_AS_STRING(str));
                 Py_DECREF(str);
               }
               return r;
             }
             QString PythonQtConv::PyObjGetString(PyObject* val, bool strict, bool& ok) {
               QString r;
               ok = true;
               if (val->ob_type == &PyString_Type) {
                 r = QString(PyString_AS_STRING(val));
               } else if (PyUnicode_Check(val)) {
-            #ifdef WIN32
-                r = QString::fromUtf16(PyUnicode_AS_UNICODE(val));
-            #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) {
                   r = QString(PyString_AS_STRING(str));
                   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;
               if (val->ob_type == &PyString_Type) {
                 long size = PyString_GET_SIZE(val);
                 r = QByteArray(PyString_AS_STRING(val), size);
               } 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) {
                 d = PyObjGetInt(val, false, ok)!=0;
                 ok = true;
               }
               return d;
             }
             int PythonQtConv::PyObjGetInt(PyObject* val, bool strict, bool &ok) {
               int d = 0;
               ok = true;
               if (val->ob_type == &PyInt_Type) {
                 d = PyInt_AS_LONG(val);
               } else if (!strict) {
                 if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   // support for derived int classes, e.g. for our enums
                   d = PyInt_AS_LONG(val);
                 } else if (val->ob_type == &PyFloat_Type) {
                   d = floor(PyFloat_AS_DOUBLE(val));
                 } else if (val->ob_type == &PyLong_Type) {
                   // handle error on overflow!
                   d = PyLong_AsLong(val);
                 } else if (val == Py_False) {
                   d = 0;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   ok = false;
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             qint64 PythonQtConv::PyObjGetLongLong(PyObject* val, bool strict, bool &ok) {
               qint64 d = 0;
               ok = true;
               if (val->ob_type == &PyInt_Type) {
                 d = PyInt_AS_LONG(val);
               } else if (val->ob_type == &PyLong_Type) {
                 d = PyLong_AsLongLong(val);
               } else if (!strict) {
                 if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   // support for derived int classes, e.g. for our enums
                   d = PyInt_AS_LONG(val);
                 } else if (val->ob_type == &PyFloat_Type) {
                   d = floor(PyFloat_AS_DOUBLE(val));
                 } else if (val == Py_False) {
                   d = 0;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   ok = false;
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             quint64 PythonQtConv::PyObjGetULongLong(PyObject* val, bool strict, bool &ok) {
               quint64 d = 0;
               ok = true;
               if (PyObject_TypeCheck(val, &PyInt_Type)) {
                 d = PyInt_AS_LONG(val);
               } else if (val->ob_type == &PyLong_Type) {
                 d = PyLong_AsLongLong(val);
               } else if (!strict) {
                 if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   // support for derived int classes, e.g. for our enums
                   d = PyInt_AS_LONG(val);
                 } else if (val->ob_type == &PyFloat_Type) {
                   d = floor(PyFloat_AS_DOUBLE(val));
                 } else if (val == Py_False) {
                   d = 0;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   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) {
                 if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   d = PyInt_AS_LONG(val);
                 } else if (val->ob_type == &PyLong_Type) {
                   d = PyLong_AsLong(val);
                 } else if (val == Py_False) {
                   d = 0;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   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
                 if (val->ob_type==&PyString_Type || val->ob_type==&PyUnicode_Type) {
                   type = QVariant::String;
                 } else if (PyObject_TypeCheck(val, &PyInt_Type)) {
                   type = QVariant::Int;
                 } else if (val->ob_type==&PyLong_Type) {
                   type = QVariant::LongLong;
                 } else if (val->ob_type==&PyFloat_Type) {
                   type = QVariant::Double;
                 } else if (val == Py_False || val == Py_True) {
                   type = QVariant::Bool;
                 } 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 (val->ob_type==&PyDict_Type) {
                   type = QVariant::Map;
                 } else if (val->ob_type==&PyList_Type || val->ob_type==&PyTuple_Type || 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()) {
                 return PyString_FromString("");
               } else {
-            #ifdef WIN32
-                //    return PyString_FromString(str.toLatin1().data());
-                return PyUnicode_FromUnicode(str.utf16(), str.length());
-            #else
                 return PyUnicode_DecodeUTF16((const char*)str.utf16(), str.length()*2, NULL, NULL);
-            #endif
               }
             }
             PyObject* PythonQtConv::QStringListToPyObject(const QStringList& list)
             {
               PyObject* result = PyTuple_New(list.count());
               int i = 0;
               QString str;
               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;
               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;
               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 +2 -2

             /*
              *
              *  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>
             #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
               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();
                 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
               self->ob_type->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;
                   fullpath = PyString_FromFormat("%s%c%s",
                     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());
                 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 = {
               PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type))
 ,
               "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");
             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;
               }
               mod = Py_InitModule4("PythonQtImport", NULL, mlabimport_doc,
                        NULL, PYTHON_API_VERSION);
-              PythonQtImportError = PyErr_NewException("PythonQtImport.PythonQtImportError",
+              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("path_hooks");
+              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/PythonQtImporter.h +2 -1

             #ifndef _PYTHONQTIMPORTER_
             #define _PYTHONQTIMPORTER_
             /*
              *
              *  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: stk $
             // \date    2004-06
             */
             //----------------------------------------------------------------------------------
-            #include "Python.h"
+            #include "PythonQtPythonInclude.h"
             #include "structmember.h"
             #include "osdefs.h"
             #include "marshal.h"
             #include "compile.h"
             #include <time.h>
             #include <qobject.h>
             #include <qstring.h>
             //! defines a python object that stores a Qt slot info
             typedef struct _PythonQtImporter {
               PyObject_HEAD
               QString* _path;
             } PythonQtImporter;
             //! implements importing of python files into PythonQt
             /*! also compiles/marshalls/unmarshalls py/pyc files and handles time stamps correctly
             */
             class PythonQtImport
             {
             public:
               enum ModuleType {
                 MI_NOT_FOUND,
                 MI_MODULE,
                 MI_PACKAGE,
                 MI_SHAREDLIBRARY
               };
               struct ModuleInfo {
                 ModuleInfo() {
                   type  = MI_NOT_FOUND;
                 }
                 QString    fullPath;   //!< the full path to the found file
                 QString    moduleName; //!< the module name without the package prefix
                 ModuleType type;
               };
               //! initialize
               static void init();
               //! writes the python code to disk, marshalling and writing the time stamp
               static void writeCompiledModule(PyCodeObject *co, const QString& filename, long mtime);
               /*! 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. */
               static PyObject *unmarshalCode(const QString& path, const QByteArray& data, time_t mtime);
               //! Given a string buffer containing Python source code, compile it
               //! return and return a code object as a new reference.
               static PyObject *compileSource(const QString& path, const QByteArray& data);
               //! Return the code object for the module named by 'fullname' from the
               //! Zip archive as a new reference.
               static PyObject *getCodeFromData(const QString& path, int isbytecode = 0, int ispackage = 0,
                                                   time_t mtime = 0);
               //! Get the code object associated with the module specified by
               //! 'fullname'.
               static PyObject * getModuleCode(PythonQtImporter *self,
                                               const char* fullname, QString& modpath);
               //! gets the compiled code for the given *.py file if there is a valid pyc file, otherwise compiles the file and writes the pyc
               static PyObject* getCodeFromPyc(const QString& file);
               //! Return if module exists and is a package or a module
               static ModuleInfo getModuleInfo(PythonQtImporter* self, const QString& fullname);
               //! get the last name of a dot chain (first.second.last)
               static QString getSubName(const QString& str);
               //! Given a buffer, return the long that is represented by the first
               //!   4 bytes, encoded as little endian. This partially reimplements
               //!   marshal.c:r_long()
               static long getLong(unsigned char *buf);
               //! get time stamp of file
               static time_t getMTimeOfSource(const QString& path);
               //! replace extension of file
               static QString replaceExtension(const QString& str, const QString& ext);
             };
             #endif

src/PythonQtInstanceWrapper.h +2 -1

             #ifndef _PYTHONQTINSTANCEWRAPPER_H
             #define _PYTHONQTINSTANCEWRAPPER_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    PythonQtInstanceWrapper.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
-            #include <Python.h>
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"
             #include <QPointer>
             #include "structmember.h"
             #include "methodobject.h"
             #include "compile.h"
             #include "eval.h"
             class PythonQtClassInfo;
             class QObject;
             extern PYTHONQT_EXPORT PyTypeObject PythonQtInstanceWrapper_Type;
             //---------------------------------------------------------------
             //! a Python wrapper object for Qt objects and C++ objects (that are themselves wrapped by wrapper QObjects)
             typedef struct PythonQtInstanceWrapperStruct {
               PyObject_HEAD
               //! the class information, this is set even if the _obj or _wrappedPtr is NULL to support typed NULL pointers
               PythonQtClassInfo* classInfo();
               //! set the QObject pointer
               void setQObject(QObject* object) {
                 _obj = object;
                 _objPointerCopy = object;
               }
               //! pointer to the wrapped Qt object or if _wrappedPtr is set, the Qt object that wraps the C++ Ptr
               QPointer<QObject> _obj;
               //! a copy of the _obj pointer, which is required because the wrapper needs to
               //! deregister itself via the _obj pointer, even when the QPointer<QObject> object was destroyed
               void* _objPointerCopy;
               //! optional C++ object Ptr that is wrapped by the above _obj
               void*    _wrappedPtr;
               // TODO xxx: put booleans into int that holds flags
               //! flag that stores if the object is owned by pythonQt
               bool _ownedByPythonQt;
               //! stores that the owned object should be destroyed using QMetaType::destroy()
               bool _useQMetaTypeDestroy;
               //! stores if the object is a shell instance
               bool _isShellInstance;
             } PythonQtInstanceWrapper;
             int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds);
             PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self);
             #endif

src/PythonQtObjectPtr.cpp +28 -1

             /*
              *
              *  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    PythonQtObjectPtr.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include <PythonQt.h>
+            PythonQtObjectPtr::PythonQtObjectPtr(PyObject* o)
+            {
+              _object = o;
+              if (o) Py_INCREF(_object);
+            }
+            PythonQtObjectPtr::~PythonQtObjectPtr()
+            {
+              if (_object) Py_DECREF(_object);
+            }
+            void PythonQtObjectPtr::setNewRef(PyObject* o)
+            {
+              if (o != _object) {
+                if (_object) Py_DECREF(_object);
+                _object = o;
+              }
+            }
             QVariant PythonQtObjectPtr::evalScript(const QString& script, int start)
             {
               return PythonQt::self()->evalScript(_object, script, start);
             }
             void PythonQtObjectPtr::evalFile(const QString& file)
             {
               PythonQt::self()->evalFile(_object, file);
             }
             QVariant PythonQtObjectPtr::evalCode(PyObject* pycode)
             {
               return PythonQt::self()->evalCode(_object, pycode);
             }
             void PythonQtObjectPtr::addObject(const QString& name, QObject* object)
             {
               PythonQt::self()->addObject(_object, name, object);
             }
             void PythonQtObjectPtr::addVariable(const QString& name, const QVariant& v)
             {
               PythonQt::self()->addVariable(_object, name, v);
             }
             void PythonQtObjectPtr::removeVariable(const QString& name)
             {
               PythonQt::self()->removeVariable(_object, name);
             }
             QVariant PythonQtObjectPtr::getVariable(const QString& name)
             {
               return PythonQt::self()->getVariable(_object, name);
             }
             QVariant PythonQtObjectPtr::call(const QString& callable, const QVariantList& args)
             {
               return PythonQt::self()->call(_object, callable, args);
             }
             QVariant PythonQtObjectPtr::call(const QVariantList& args)
             {
               return PythonQt::self()->call(_object, args);
             }
             bool PythonQtObjectPtr::fromVariant(const QVariant& variant)
             {
               if (!variant.isNull()) {
                   setObject(qVariantValue<PythonQtObjectPtr>(variant));
                   return true;
               }
               else {
                   setObject(0);
                   return false;
+              }
+            }
+            void PythonQtObjectPtr::setObject(PyObject* o)
+            {
+              if (o != _object) {
+                if (_object) Py_DECREF(_object);
+                _object = o;
+                if (_object) Py_INCREF(_object);
               }
             }

src/PythonQtObjectPtr.h +13 -24

             #ifndef _PYTHONQTOBJECTPTR_H
             #define _PYTHONQTOBJECTPTR_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    PythonQtObjectPtr.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
-            #include <Python.h>
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"
             #include <QVariant>
             #include <QVariantList>
             //! a smart pointer that stores a PyObject pointer and that handles reference counting automatically
             class PYTHONQT_EXPORT PythonQtObjectPtr
             {
             public:
               PythonQtObjectPtr():_object(NULL) {}
-              PythonQtObjectPtr(const PythonQtObjectPtr &p):_object(NULL) {
+              PythonQtObjectPtr(const PythonQtObjectPtr &p)
+              :_object(NULL) {
                 setObject(p.object());
               }
               //! If the given variant holds a PythonQtObjectPtr, extract the value from it and hold onto the reference. This results in an increment of the reference count.
               PythonQtObjectPtr(const QVariant& variant):_object(NULL) {
                   fromVariant(variant);
               }
-              PythonQtObjectPtr(PyObject* o) {
+              PythonQtObjectPtr(PyObject* o);
-                _object = o;
-                if (o) Py_INCREF(_object);
+              ~PythonQtObjectPtr();
-              ~PythonQtObjectPtr() { if (_object) { Py_DECREF(_object); } }
               //! If the given variant holds a PythonQtObjectPtr, extract the value from it and hold onto the reference. This results in an increment of the reference count.
               bool fromVariant(const QVariant& variant);
               PythonQtObjectPtr &operator=(const PythonQtObjectPtr &p) {
                 setObject(p.object());
                 return *this;
               }
               PythonQtObjectPtr &operator=(PyObject* o) {
                 setObject(o);
                 return *this;
               }
               PythonQtObjectPtr &operator=(const QVariant& variant) {
                   fromVariant(variant);
                   return *this;
               }
               bool operator==( const PythonQtObjectPtr &p ) const {
                 return object() == p.object();
               }
               bool operator!= ( const PythonQtObjectPtr& p ) const {
                 return !( *this == p );
               }
               bool operator==( PyObject* p ) const {
                 return object() == p;
               }
               bool operator!= ( PyObject* p ) const {
                 return object() != p;
               }
               bool isNull() const { return !object(); }
               PyObject* operator->() const { return object(); }
               PyObject& operator*() const { return *( object() ); }
               operator PyObject*() const { return object(); }
               //! sets the object and passes the ownership (stealing the reference, in Python slang)
-              void setNewRef(PyObject* o) {
+              void setNewRef(PyObject* o);
-                if (o != _object) {
-                  if (_object) { Py_DECREF(_object); }
-                  _object = o;
               PyObject* object() const {
                 return _object;
               }
               //! evaluates the given script code in the context of this object and returns the result value
               QVariant evalScript(const QString& script, int start = Py_file_input);
               //! evaluates the given code and returns the result value (use Py_Compile etc. to create pycode from string)
               //! If pycode is NULL, a python error is printed.
               QVariant evalCode(PyObject* pycode);
               //! evaluates the given code in the context
               void evalFile(const QString& filename);
               //! add the given \c object to the \c module as a variable with \c name (it can be removed via clearVariable)
               void addObject(const QString& name, QObject* object);
               //! add the given variable to the module
               void addVariable(const QString& name, const QVariant& v);
               //! remove the given variable
               void removeVariable(const QString& name);
               //! get the variable with the \c name of the \c module, returns an invalid QVariant on error
               QVariant getVariable(const QString& name);
               //! call the given python object (in the scope of the current object), returns the result converted to a QVariant
               QVariant call(const QString& callable, const QVariantList& args = QVariantList());
               //! call the contained python object directly, returns the result converted to a QVariant
               QVariant call(const QVariantList& args = QVariantList());
             protected:
-              void setObject(PyObject* o) {
+              void setObject(PyObject* o);
-                if (o != _object) {
-                  if (_object) { Py_DECREF(_object); }
-                  _object = o;
-                  if (_object) { Py_INCREF(_object); }
             private:
               PyObject* _object;
             };
             // register it to the meta type system
             Q_DECLARE_METATYPE(PythonQtObjectPtr)
             #endif

src/PythonQtSignalReceiver.h +2 -1

             #ifndef _PYTHONQTSIGNALRECEIVER_H
             #define _PYTHONQTSIGNALRECEIVER_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    PythonQtSignalReceiver.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
-            #include <Python.h>
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"
             #include "PythonQtObjectPtr.h"
             class PythonQtMethodInfo;
             class PythonQtClassInfo;
             //! stores information about a signal target
             /*! copy construction and assignment works fine with the C++ standard behavior and are thus not implemented
             */
             class PYTHONQT_EXPORT PythonQtSignalTarget {
             public:
               PythonQtSignalTarget() {
                 _signalId = -1;
                 _methodInfo = NULL;
                 _slotId = -1;
               }
               PythonQtSignalTarget(int signalId,const PythonQtMethodInfo* methodInfo, int slotId, PyObject* callable)
               {
                 _signalId = signalId;
                 _slotId = slotId;
                 _methodInfo = methodInfo;
                 _callable = callable;
               };
               ~PythonQtSignalTarget() {
               };
               //! get the id of the original signal
               int signalId() const { return _signalId; }
               //! get the id that was assigned to this simulated slot
               int slotId()  const { return _slotId; }
               //! get the signals parameter info
               const PythonQtMethodInfo* methodInfo()  const { return _methodInfo; }
               //! call the python callable with the given arguments (as defined in methodInfo)
               void call(void **arguments) const;
               //! check if it is the same signal target
               bool isSame(int signalId, PyObject* callable) const;
               //! call the given callable with arguments described by PythonQtMethodInfo, returns a new reference as result value (or NULL)
               static PyObject* call(PyObject* callable, const PythonQtMethodInfo* methodInfo, void **arguments, bool skipFirstArgumentOfMethodInfo = false);
             private:
               int       _signalId;
               int       _slotId;
               const PythonQtMethodInfo* _methodInfo;
               PythonQtObjectPtr _callable;
             };
             //! base class for signal receivers
             /*!
             */
             class PythonQtSignalReceiverBase : public QObject {
               Q_OBJECT
             public:
               PythonQtSignalReceiverBase(QObject* obj):QObject(obj) {};
             };
             //! receives all signals for one QObject
             /*! we derive from our base but do not declare the QObject macro because we want to reimplement qt_metacall only.
             */
             class PythonQtSignalReceiver : public PythonQtSignalReceiverBase {
             public:
               PythonQtSignalReceiver(QObject* obj);
               ~PythonQtSignalReceiver();
               //! add a signal handler
               bool addSignalHandler(const char* signal, PyObject* callable);
               //! remove a signal handler
               bool removeSignalHandler(const char* signal, PyObject* callable);
               //! remove all signal handlers
               void removeSignalHandlers();
               //! we implement this method to simulate a number of slots that match the ids in _targets
               virtual int qt_metacall(QMetaObject::Call c, int id, void **arguments);
             private:
               //! get the index of the signal
               int getSignalIndex(const char* signal);
               QObject* _obj;
               PythonQtClassInfo* _objClassInfo;
               int _slotCount;
               // linear list may get slow on multiple targets, but I think typically we have many objects and just a few signals
               QList<PythonQtSignalTarget> _targets;
             };
             #endif

src/PythonQtSlot.cpp +6 -6

             /*
             *
             *  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>
             #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();
                   }
                   profilingCB(PythonQt::Enter, className, info->metaMethod()->signature());
                 }
                 // invoke the slot via metacall
                 bool hadException = false;
                 try {
                   (info->decorator()?info->decorator():objectToCall)->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();
                   PyErr_SetString(PyExc_StandardError, what.constData());
                 }
                 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;
               PythonQtSlotInfo*    info = f->m_ml;
               if (PyObject_TypeCheck(f->m_self, &PythonQtInstanceWrapper_Type)) {
                 PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*) f->m_self;
                 if (!info->isClassDecorator() && (self->_obj==NULL && self->_wrappedPtr==NULL)) {
                   QString error = QString("Trying to call '") + f->m_ml->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 (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
                 PythonQtClassWrapper* type = (PythonQtClassWrapper*) f->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 '") + f->m_ml->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_BadInternalCall();
+                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_BadInternalCall();
+                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*/)
             {
               return PyString_FromString(m->m_ml->metaMethod()->signature());
             }
             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;
               if (PyEval_GetRestricted()) {
                 PyErr_SetString(PyExc_RuntimeError,
                   "method.__self__ not accessible in restricted mode");
                 return NULL;
               }
               self = m->m_self;
               if (self == NULL)
                 self = Py_None;
               Py_INCREF(self);
               return self;
             }
             static PyGetSetDef meth_getsets [] = {
-              {"__doc__",  (getter)meth_get__doc__,  NULL, NULL},
+              {const_cast<char*>("__doc__"),  (getter)meth_get__doc__,  NULL, NULL},
-              {"__name__", (getter)meth_get__name__, NULL, NULL},
+              {const_cast<char*>("__name__"), (getter)meth_get__name__, NULL, NULL},
-              {"__self__", (getter)meth_get__self__, 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[] = {
-              {"__module__",    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
+              {const_cast<char*>("__module__"),    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
               {NULL}
             };
             static PyObject *
             meth_repr(PythonQtSlotFunctionObject *f)
             {
               if (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
                 PythonQtClassWrapper* self = (PythonQtClassWrapper*) f->m_self;
                 return PyString_FromFormat("<unbound qt slot %s of %s type>",
                   f->m_ml->slotName().data(),
                   self->classInfo()->className());
               } else {
                 return PyString_FromFormat("<qt slot %s of %s instance at %p>",
                   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 (strcmp(a->m_ml->metaMethod()->signature(), b->m_ml->metaMethod()->signature()) < 0)
                 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;
             }
             PyTypeObject PythonQtSlotFunction_Type = {
               PyObject_HEAD_INIT(&PyType_Type)
 ,
                 "builtin_qt_slot",
                 sizeof(PythonQtSlotFunctionObject),
 ,
                 (destructor)meth_dealloc,     /* tp_dealloc */
 ,          /* tp_print */
 ,          /* tp_getattr */
 ,          /* tp_setattr */
                 (cmpfunc)meth_compare,      /* tp_compare */
                 (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 */
 ,          /* tp_richcompare */
 ,          /* tp_weaklistoffset */
 ,          /* tp_iter */
 ,          /* tp_iternext */
 ,          /* 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);
               }
             }

src/PythonQtSlot.h +2 -1

             #ifndef _PYTHONQTSLOT_H
             #define _PYTHONQTSLOT_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    PythonQtSlot.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
-            #include "Python.h"
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"
             #include "structmember.h"
             class PythonQtSlotInfo;
             extern PYTHONQT_EXPORT PyTypeObject PythonQtSlotFunction_Type;
             #define PythonQtSlotFunction_Check(op) ((op)->ob_type == &PythonQtSlotFunction_Type)
             PythonQtSlotInfo* PythonQtSlotFunction_GetSlotInfo(PyObject *);
             PyObject* PythonQtSlotFunction_GetSelf(PyObject *);
             /* Macros for direct access to these values. Type checks are *not*
                done, so use with care. */
             #define PythonQtSlotFunction_GET_SELF(func) \
               (((PythonQtSlotFunctionObject *)func) -> m_self)
             PyObject* PythonQtSlotFunction_Call(PyObject *, PyObject *, PyObject *);
             PyObject *PythonQtSlotFunction_CallImpl(PythonQtClassInfo* classInfo, QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject *kw, void* firstArg=NULL,  void** directReturnValuePointer=NULL);
             PyObject* PythonQtSlotFunction_New(PythonQtSlotInfo *, PyObject *,
                        PyObject *);
             //! defines a python object that stores a Qt slot info
             typedef struct {
                 PyObject_HEAD
                 PythonQtSlotInfo *m_ml; /* Description of the C function to call */
                 PyObject    *m_self; /* Passed as 'self' arg to the C func, can be NULL */
                 PyObject    *m_module; /* The __module__ attribute, can be anything */
             } PythonQtSlotFunctionObject;
             #endif

src/PythonQtStdDecorators.h +3 -1

             #ifndef _PYTHONQTSTDDECORATORS_H
             #define _PYTHONQTSTDDECORATORS_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    PythonQtStdDecorators.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2007-04
             */
             //----------------------------------------------------------------------------------
+            #include "PythonQtPythonInclude.h"
             #include "PythonQtSystem.h"
-            #include <Python.h>
             #include <QObject>
             #include <QVariantList>
             #include <QTextDocument>
             #include <QColor>
             #include <QDateTime>
             #include <QDate>
             #include <QTime>
             class PYTHONQT_EXPORT PythonQtStdDecorators : public QObject
             {
               Q_OBJECT
             public slots:
               bool connect(QObject* sender, const QByteArray& signal, PyObject* callable);
               bool connect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot);
               bool disconnect(QObject* sender, const QByteArray& signal, PyObject* callable);
               bool disconnect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot);
               QObject* parent(QObject* o);
               void setParent(QObject* o, QObject* parent);
               const QObjectList* children(QObject* o);
               QObject* findChild(QObject* parent, PyObject* type, const QString& name = QString());
               QList<QObject*> findChildren(QObject* parent, PyObject* type, const QString& name= QString());
               QList<QObject*> findChildren(QObject* parent, PyObject* type, const QRegExp& regExp);
               bool setProperty(QObject* o, const char* name, const QVariant& value);
               QVariant property(QObject* o, const char* name);
               double static_Qt_qAbs(double a) { return qAbs(a); }
               double static_Qt_qBound(double a,double b,double c) { return qBound(a,b,c); }
               void static_Qt_qDebug(const QByteArray& msg) { qDebug("%s", msg.constData()); }
               // TODO: multi arg qDebug...
               void static_Qt_qWarning(const QByteArray& msg) { qWarning("%s", msg.constData()); }
               // TODO: multi arg qWarning...
               void static_Qt_qCritical(const QByteArray& msg) { qCritical("%s", msg.constData()); }
               // TODO: multi arg qCritical...
               void static_Qt_qFatal(const QByteArray& msg) { qFatal("%s", msg.constData()); }
               // TODO: multi arg qFatal...
               bool static_Qt_qFuzzyCompare(double a, double b) { return qFuzzyCompare(a, b); }
               double static_Qt_qMax(double a, double b) { return qMax(a, b); }
               double static_Qt_qMin(double a, double b) { return qMin(a, b); }
               int static_Qt_qRound(double a) { return qRound(a); }
               qint64 static_Qt_qRound64(double a) { return qRound64(a); }
               const char* static_Qt_qVersion() { return qVersion(); }
               int static_Qt_qrand() { return qrand(); }
               void static_Qt_qsrand(uint a) { qsrand(a); }
               QString tr(QObject* obj, const QByteArray& text, const QByteArray& ambig = QByteArray(), int n = -1);
               QByteArray static_Qt_SIGNAL(const QByteArray& s) { return QByteArray("2") + s; }
               QByteArray static_Qt_SLOT(const QByteArray& s) { return QByteArray("1") + s; }
             private:
               QObject* findChild(QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name);
               int findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name, QList<QObject*>& list);
               int findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QRegExp& regExp, QList<QObject*>& list);
             };
             #endif

src/PythonQtStdOut.cpp +2 -2

             /*
              *
              *  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    PythonQtStdOut.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtStdOut.h"
             static PyObject *PythonQtStdOutRedirect_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               PythonQtStdOutRedirect *self;
               self = (PythonQtStdOutRedirect *)type->tp_alloc(type, 0);
               self->softspace = 0;
               self->_cb = NULL;
               return (PyObject *)self;
             }
             static PyObject *PythonQtStdOutRedirect_write(PyObject *self, PyObject *args)
             {
               PythonQtStdOutRedirect*  s = (PythonQtStdOutRedirect*)self;
               if (s->_cb) {
                 char *string;
                 if (!PyArg_ParseTuple(args, "s", &string))
                   return NULL;
                 if (s->softspace > 0) {
                   (*s->_cb)(QString(""));
                   s->softspace = 0;
                 }
                 (*s->_cb)(QString(string));
               }
               return Py_BuildValue("");
             }
             static PyObject *PythonQtStdOutRedirect_flush(PyObject * /*self*/, PyObject * /*args*/)
             {
               return Py_BuildValue("");
             }
             static PyMethodDef PythonQtStdOutRedirect_methods[] = {
               {"write", (PyCFunction)PythonQtStdOutRedirect_write, METH_VARARGS,
               "redirect the writing to a callback"},
               {"flush", (PyCFunction)PythonQtStdOutRedirect_flush, METH_VARARGS,
               "flush the output, currently not implemented but needed for logging framework"
               },
               {NULL,    NULL, 0 , NULL} /* sentinel */
             };
             static PyMemberDef PythonQtStdOutRedirect_members[] = {
-              {"softspace", T_INT, offsetof(PythonQtStdOutRedirect, softspace), 0,
+              {const_cast<char*>("softspace"), T_INT, offsetof(PythonQtStdOutRedirect, softspace), 0,
-                "soft space flag"
+                const_cast<char*>("soft space flag")
               },
               {NULL}  /* Sentinel */
             };
             PyTypeObject PythonQtStdOutRedirectType = {
                 PyObject_HEAD_INIT(NULL)
 ,                         /*ob_size*/
                 "PythonQtStdOutRedirect",             /*tp_name*/
                 sizeof(PythonQtStdOutRedirect),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
 , /*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*/
 ,                         /*tp_getattro*/
 ,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
                 "PythonQtStdOutRedirect",           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
 ,                   /* tp_richcompare */
 ,                   /* tp_weaklistoffset */
 ,                   /* tp_iter */
 ,                   /* tp_iternext */
                 PythonQtStdOutRedirect_methods,                   /* tp_methods */
                 PythonQtStdOutRedirect_members,                   /* tp_members */
 ,                   /* tp_getset */
 ,                         /* tp_base */
 ,                         /* tp_dict */
 ,                         /* tp_descr_get */
 ,                         /* tp_descr_set */
 ,                         /* tp_dictoffset */
 ,                         /* tp_init */
 ,                         /* tp_alloc */
                 PythonQtStdOutRedirect_new,                 /* tp_new */
             };

src/PythonQtStdOut.h +2 -1

             #ifndef _PYTHONQTSTDOUT_H
             #define _PYTHONQTSTDOUT_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    PythonQtStdOut.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
-            #include <Python.h>
+            #include "PythonQtPythonInclude.h"
             #include "structmember.h"
             #include <QString>
             //! declares the type of the stdout redirection class
             extern PyTypeObject PythonQtStdOutRedirectType;
             //! declares the callback that is called from the write() function
             typedef void PythonQtOutputChangedCB(const QString& str);
             //! declares the stdout redirection class
             typedef struct {
               PyObject_HEAD
               PythonQtOutputChangedCB* _cb;
               int softspace;
             } PythonQtStdOutRedirect;
             #endif

src/gui/PythonQtScriptingConsole.h +2 -1

             #ifndef _PythonQtScriptingConsole_H
             #define _PythonQtScriptingConsole_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    PythonQtScriptingConsole.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-10
             */
             //----------------------------------------------------------------------------------
             #include "PythonQt.h"
             #include <QVariant>
             #include <QTextEdit>
             class QCompleter;
             //-------------------------------------------------------------------------------
             //! A simple console for python scripting
             class PYTHONQT_EXPORT PythonQtScriptingConsole : public QTextEdit
             {
               Q_OBJECT
             public:
               PythonQtScriptingConsole(QWidget* parent, const PythonQtObjectPtr& context, Qt::WindowFlags i = 0);
               ~PythonQtScriptingConsole();
             public slots:
               //! execute current line
               void executeLine(bool storeOnly);
               //! derived key press event
               void keyPressEvent (QKeyEvent * e);
               //! output from console
               void consoleMessage(const QString & message);
               //! get history
               QStringList history() { return _history; }
               //! set history
               void setHistory(const QStringList& h) { _history = h; _historyPosition = 0; }
               //! clear the console
               void clear();
               //! overridden to control which characters a user may delete
               virtual void cut();
               //! output redirection
               void stdOut(const QString& s);
               //! output redirection
               void stdErr(const QString& s);
               void insertCompletion(const QString&);
               //! Appends a newline and command prompt at the end of the document.
               void appendCommandPrompt(bool storeOnly = false);
             public:
               //! returns true if python cerr had an error
               bool hadError() { return _hadError; }
               //! returns true if python cerr had an error
               void clearError() {
                 _hadError = false;
               }
             protected:
               //! handle the pressing of tab
               void handleTabCompletion();
               //! Returns the position of the command prompt
               int commandPromptPosition();
               //! Returns if deletion is allowed at the current cursor
               //! (with and without selected text)
               bool verifySelectionBeforeDeletion();
               //! Sets the current font
               void setCurrentFont(const QColor& color = QColor(0,0,0), bool bold = false);
               //! change the history according to _historyPos
               void changeHistory();
               //! flush output that was not yet printed
               void flushStdOut();
             private:
               void executeCode(const QString& code);
               PythonQtObjectPtr _context;
               QStringList _history;
               int         _historyPosition;
               QString _clickedAnchor;
               QString _storageKey;
               QString _commandPrompt;
               QString _currentMultiLineCode;
               QString _stdOut;
               QString _stdErr;
               QTextCharFormat _defaultTextCharacterFormat;
               QCompleter* _completer;
               bool _hadError;
             };
-            #endif
  No newline at end of file
+            #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