GIT_REPOSITORIES/LPP/PythonQt Commit - r180:a63222bd6a1b

merged various changes from MeVisLab repository...

florianlink -

r180:a63222bd6a1b

parent child

Context file:

r180:a63222bd6a1b

Collapse all files

src/PythonQt.cpp +32 -3

             /*
             *
             *  Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved.
             *
             *  This library is free software; you can redistribute it and/or
             *  modify it under the terms of the GNU Lesser General Public
             *  License as published by the Free Software Foundation; either
             *  version 2.1 of the License, or (at your option) any later version.
             *
             *  This library is distributed in the hope that it will be useful,
             *  but WITHOUT ANY WARRANTY; without even the implied warranty of
             *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
             *  Lesser General Public License for more details.
             *
             *  Further, this software is distributed without any warranty that it is
             *  free of the rightful claim of any third person regarding infringement
             *  or the like.  Any license provided herein, whether implied or
             *  otherwise, applies only to this software file.  Patent licenses, if
             *  any, provided herein do not apply to combinations of this program with
             *  other software, or any other product whatsoever.
             *
             *  You should have received a copy of the GNU Lesser General Public
             *  License along with this library; if not, write to the Free Software
             *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             *
             *  Contact information: MeVis Medical Solutions AG, Universitaetsallee 29,
             *  28359 Bremen, Germany or:
             *
             *  http://www.mevis.de
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQt.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQt.h"
             #include "PythonQtImporter.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtMethodInfo.h"
             #include "PythonQtSignal.h"
             #include "PythonQtSignalReceiver.h"
             #include "PythonQtConversion.h"
             #include "PythonQtStdIn.h"
             #include "PythonQtStdOut.h"
             #include "PythonQtCppWrapperFactory.h"
             #include "PythonQtVariants.h"
             #include "PythonQtStdDecorators.h"
             #include "PythonQtQFileImporter.h"
             #include <pydebug.h>
             #include <vector>
             PythonQt* PythonQt::_self = NULL;
             int       PythonQt::_uniqueModuleCount = 0;
             void PythonQt_init_QtGuiBuiltin(PyObject*);
             void PythonQt_init_QtCoreBuiltin(PyObject*);
             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);
+                PythonQt::self()->addDecorators(new PythonQtStdDecorators());
+                PythonQt::self()->registerCPPClass("QMetaObject",0, "QtCore", PythonQtCreateObject<PythonQtWrapper_QMetaObject>);
                 PythonQtRegisterToolClassesTemplateConverter(QByteArray);
                 PythonQtRegisterToolClassesTemplateConverter(QDate);
                 PythonQtRegisterToolClassesTemplateConverter(QTime);
                 PythonQtRegisterToolClassesTemplateConverter(QDateTime);
                 PythonQtRegisterToolClassesTemplateConverter(QUrl);
                 PythonQtRegisterToolClassesTemplateConverter(QLocale);
                 PythonQtRegisterToolClassesTemplateConverter(QRect);
                 PythonQtRegisterToolClassesTemplateConverter(QRectF);
                 PythonQtRegisterToolClassesTemplateConverter(QSize);
                 PythonQtRegisterToolClassesTemplateConverter(QSizeF);
                 PythonQtRegisterToolClassesTemplateConverter(QLine);
                 PythonQtRegisterToolClassesTemplateConverter(QLineF);
                 PythonQtRegisterToolClassesTemplateConverter(QPoint);
                 PythonQtRegisterToolClassesTemplateConverter(QPointF);
                 PythonQtRegisterToolClassesTemplateConverter(QRegExp);
                 PythonQtRegisterToolClassesTemplateConverter(QFont);
                 PythonQtRegisterToolClassesTemplateConverter(QPixmap);
                 PythonQtRegisterToolClassesTemplateConverter(QBrush);
                 PythonQtRegisterToolClassesTemplateConverter(QColor);
                 PythonQtRegisterToolClassesTemplateConverter(QPalette);
                 PythonQtRegisterToolClassesTemplateConverter(QIcon);
                 PythonQtRegisterToolClassesTemplateConverter(QImage);
                 PythonQtRegisterToolClassesTemplateConverter(QPolygon);
                 PythonQtRegisterToolClassesTemplateConverter(QRegion);
                 PythonQtRegisterToolClassesTemplateConverter(QBitmap);
                 PythonQtRegisterToolClassesTemplateConverter(QCursor);
                 PythonQtRegisterToolClassesTemplateConverter(QSizePolicy);
                 PythonQtRegisterToolClassesTemplateConverter(QKeySequence);
                 PythonQtRegisterToolClassesTemplateConverter(QPen);
                 PythonQtRegisterToolClassesTemplateConverter(QTextLength);
                 PythonQtRegisterToolClassesTemplateConverter(QTextFormat);
                 PythonQtRegisterToolClassesTemplateConverter(QMatrix);
                 PyObject* pack = PythonQt::priv()->packageByName("QtCore");
                 PyObject* pack2 = PythonQt::priv()->packageByName("Qt");
                 PyObject* qtNamespace = PythonQt::priv()->getClassInfo("Qt")->pythonQtClassWrapper();
                 const char* names[16] = {"SIGNAL", "SLOT", "qAbs", "qBound","qDebug","qWarning","qCritical","qFatal"
                                     ,"qFuzzyCompare", "qMax","qMin","qRound","qRound64","qVersion","qrand","qsrand"};
                 for (unsigned int i = 0;i<16; i++) {
                   PyObject* obj = PyObject_GetAttrString(qtNamespace, names[i]);
                   if (obj) {
                     PyModule_AddObject(pack, names[i], obj);
                     Py_INCREF(obj);
                     PyModule_AddObject(pack2, names[i], obj);
                   } else {
                     std::cerr << "method not found " << names[i];
                   }
                 }
               }
             }
             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(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);
               if (PyType_Ready(&PythonQtSignalFunction_Type) < 0) {
                 std::cerr << "could not initialize PythonQtSignalFunction_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtSignalFunction_Type);
               // according to Python docs, set the type late here, since it can not safely be stored in the struct when declaring it
               PythonQtClassWrapper_Type.tp_base = &PyType_Type;
               // add our own python object types for classes
               if (PyType_Ready(&PythonQtClassWrapper_Type) < 0) {
                 std::cerr << "could not initialize PythonQtClassWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtClassWrapper_Type);
               // add our own python object types for CPP instances
               if (PyType_Ready(&PythonQtInstanceWrapper_Type) < 0) {
                 PythonQt::handleError();
                 std::cerr << "could not initialize PythonQtInstanceWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtInstanceWrapper_Type);
               // add our own python object types for redirection of stdout
               if (PyType_Ready(&PythonQtStdOutRedirectType) < 0) {
                 std::cerr << "could not initialize PythonQtStdOutRedirectType" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtStdOutRedirectType);
               // add our own python object types for redirection of stdin
               if (PyType_Ready(&PythonQtStdInRedirectType) < 0) {
                 std::cerr << "could not initialize PythonQtStdInRedirectType" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtStdInRedirectType);
               initPythonQtModule(flags & RedirectStdOut, pythonQtModuleName);
               _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, try to wrap via foreign wrapper factories
                 PyObject* foreignWrapper = NULL;
                 for (int i=0; i<_foreignWrapperFactories.size(); i++) {
                   foreignWrapper = _foreignWrapperFactories.at(i)->wrap(name, ptr);
                   if (foreignWrapper) {
                     return foreignWrapper;
                   }
                 }
                 // not a known QObject, so try our wrapper factory:
                 QObject* wrapper = NULL;
                 for (int i=0; i<_cppWrapperFactories.size(); i++) {
                   wrapper = _cppWrapperFactories.at(i)->create(name, ptr);
                   if (wrapper) {
                     break;
                   }
                 }
                 if (info) {
                   // try to downcast in the class hierarchy, which will modify info and ptr if it is successfull
                   ptr  = info->castDownIfPossible(ptr, &info);
                   // if downcasting found out that the object is a QObject,
                   // handle it like one:
                   if (info && info->isQObject()) {
                     QObject* qptr = (QObject*)ptr;
                     // if the object is a derived object, we want to switch the class info to the one of the derived class:
                     if (name!=(qptr->metaObject()->className())) {
                       registerClass(qptr->metaObject());
                       info = _knownClassInfos.value(qptr->metaObject()->className());
                     }
                     wrap = createNewPythonQtInstanceWrapper(qptr, info);
                     //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
                     return (PyObject*)wrap;
                   }
                 }
                 if (!info || info->pythonQtClassWrapper()==NULL) {
                   // still unknown, register as CPP class
                   registerCPPClass(name.constData());
                   info = _knownClassInfos.value(name);
                 }
                 if (wrapper && (info->metaObject() != wrapper->metaObject())) {
                   // if we a have a QObject wrapper and the metaobjects do not match, set the metaobject again!
                   info->setMetaObject(wrapper->metaObject());
                 }
                 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;
               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) {
                 results = introspectObject(object, type);
               }
               return results;
             }
             QStringList PythonQt::introspectObject(PyObject* object, ObjectType type)
             {
               QStringList results;
               if (type == CallOverloads) {
                 if (PythonQtSlotFunction_Check(object)) {
                   PythonQtSlotFunctionObject* o = (PythonQtSlotFunctionObject*)object;
                   PythonQtSlotInfo* info = o->m_ml;
                   while (info) {
                     results << info->fullSignature();
                     info = info->nextInfo();
                   }
                 } else if (PythonQtSignalFunction_Check(object)) {
                   PythonQtSignalFunctionObject* o = (PythonQtSignalFunctionObject*)object;
                   PythonQtSlotInfo* info = o->m_ml;
                   while (info) {
                     results << info->fullSignature();
                     info = info->nextInfo();
                   }
                 } else if (object->ob_type == &PythonQtClassWrapper_Type) {
                   PythonQtClassWrapper* o = (PythonQtClassWrapper*)object;
                   PythonQtSlotInfo* info = o->classInfo()->constructors();
                   while (info) {
                     results << info->fullSignature();
                     info = info->nextInfo();
                   }
                 } else {
                   QString signature = _p->getSignature(object);
                   if (!signature.isEmpty()) {
                     results << signature;
                   } else {
                     PyObject* doc = PyObject_GetAttrString(object, "__doc__");
                     if (doc) {
                       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 || value->ob_type == &PyType_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 != &PyMethod_Type
                           && value->ob_type != &PyModule_Type
                           && value->ob_type != &PyType_Type
                           && value->ob_type != &PythonQtSlotFunction_Type
                           ) {
                           results << keystr;
                         }
                         break;
                       case Function:
                         if (value->ob_type == &PyCFunction_Type ||
                             value->ob_type == &PyFunction_Type ||
                             value->ob_type == &PyMethod_Type ||
                             value->ob_type == &PythonQtSlotFunction_Type
                           ) {
                           results << keystr;
                         }
                         break;
                       case Module:
                         if (value->ob_type == &PyModule_Type) {
                           results << keystr;
                         }
                         break;
                       default:
                         std::cerr << "PythonQt: introspection: unknown case" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
                       }
                     }
                     Py_DECREF(value);
                   }
                   Py_DECREF(keys);
                 }
+                if ((type == Anything) || (type == Variable)) {
+                  if (object->ob_type == &PythonQtClassWrapper_Type) {
+                    PythonQtClassWrapper* o = (PythonQtClassWrapper*)object;
+                    PythonQtClassInfo* info = o->classInfo();
+                    results += info->propertyList();
+                  }
+                }
               }
               return results;
             }
             PyObject* PythonQt::getObjectByType(const QString& typeName)
             {
               PythonQtObjectPtr sys;
               sys.setNewRef(PyImport_ImportModule("sys"));
               PythonQtObjectPtr modules = lookupObject(sys, "modules");
               Q_ASSERT(PyDict_Check(modules));
               QStringList tmp = typeName.split(".");
               QString simpleTypeName = tmp.takeLast();
               QString moduleName = tmp.join(".");
               PyObject* object = NULL;
               PyObject* moduleObject = PyDict_GetItemString(modules, moduleName.toLatin1().constData());
               if (moduleObject) {
                 object = PyObject_GetAttrString(moduleObject, simpleTypeName.toLatin1().constData());
               }
               if (!object) {
                 moduleObject = PyDict_GetItemString(modules, "__builtin__");
                 if (moduleObject) {
                   object = PyObject_GetAttrString(moduleObject, simpleTypeName.toLatin1().constData());
                 }
               }
               return object;
             }
             QStringList PythonQt::introspectType(const QString& typeName, ObjectType type)
             {
               QStringList results;
               PyObject* object = getObjectByType(typeName);
               if (!object) {
                 // the last item may be a member, split it away and try again
                 QStringList tmp = typeName.split(".");
                 QString memberName = tmp.takeLast();
-                QString typeName = tmp.takeLast();
+                QString typeName;
+                if (tmp.isEmpty()) {
+                  typeName = memberName;
+                  memberName.clear();
+                } else {
+                  typeName = tmp.takeLast();
+                }
                 PyObject* typeObject = getObjectByType(typeName);
                 if (typeObject) {
                   object = PyObject_GetAttrString(typeObject, memberName.toLatin1().constData());
                 }
               }
               if (object) {
                 results = introspectObject(object, type);
                 Py_DECREF(object);
               }
               return results;
             }
             QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args)
             {
               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);
             }
             void PythonQt::addWrapperFactory( PythonQtForeignWrapperFactory* factory )
             {
               _p->_foreignWrapperFactories.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);
               }
             }
             QString PythonQt::getReturnTypeOfWrappedMethod(PyObject* module, const QString& name)
             {
               QStringList tmp = name.split(".");
               QString methodName = tmp.takeLast();
               QString variableName = tmp.join(".");
               // TODO: the variableName may be a type name, this needs to be handled differently,
               // because it is not necessarily known in the module context
               PythonQtObjectPtr variableObject = lookupObject(module, variableName);
               if (variableObject.isNull()) {
                 return "";
               }
               return getReturnTypeOfWrappedMethodHelper(variableObject, methodName, name);
             }
             QString PythonQt::getReturnTypeOfWrappedMethod(const QString& typeName, const QString& methodName)
             {
               PythonQtObjectPtr typeObject = getObjectByType(typeName);
               if (typeObject.isNull()) {
                 return "";
               }
               return getReturnTypeOfWrappedMethodHelper(typeObject, methodName, typeName + "." + methodName);
             }
             QString PythonQt::getReturnTypeOfWrappedMethodHelper(const PythonQtObjectPtr& variableObject, const QString& methodName, const QString& context)
             {
               PythonQtObjectPtr methodObject;
               if (PyDict_Check(variableObject)) {
                 methodObject = PyDict_GetItemString(variableObject, methodName.toLatin1().constData());
               } else {
                 methodObject.setNewRef(PyObject_GetAttrString(variableObject, methodName.toLatin1().constData()));
               }
               if (methodObject.isNull()) {
                 return "";
               }
               QString type;
               if (methodObject->ob_type == &PyClass_Type || methodObject->ob_type == &PyType_Type) {
                 // the methodObject is not a method, but the name of a type/class. This means
                 // a constructor is called. Return the context.
                 type = context;
               } else if (methodObject->ob_type == &PythonQtSlotFunction_Type) {
                 QString className;
                 if (PyObject_TypeCheck(variableObject, &PythonQtInstanceWrapper_Type)) {
                   // the type name of wrapped instance is the class name
                   className = variableObject->ob_type->tp_name;
                 } else {
                   PyObject* classNameObject = PyObject_GetAttrString(variableObject, "__name__");
                   if (classNameObject) {
                     Q_ASSERT(PyString_Check(classNameObject));
                     className = PyString_AsString(classNameObject);
                     Py_DECREF(classNameObject);
                   }
                 }
                 if (!className.isEmpty()) {
                   PythonQtClassInfo* info = _p->_knownClassInfos.value(className.toLatin1().constData());
                   if (info) {
                     PythonQtSlotInfo* slotInfo = info->member(methodName.toLatin1().constData())._slot;
                     if (slotInfo) {
                       if (slotInfo->metaMethod()) {
                         type = slotInfo->metaMethod()->typeName();
                         if (!type.isEmpty()) {
                           QChar c = type.at(type.length()-1);
                           while (c == '*' || c == '&') {
                             type.truncate(type.length()-1);
                             if (!type.isEmpty()) {
                               c = type.at(type.length()-1);
                             } else {
                               break;
                             }
                           }
                           // split away template arguments
                           type = type.split("<").first();
                           // split away const
                           type = type.split(" ").last().trimmed();
                           // if the type is a known class info, then create the full type name, i.e. include the
                           // module name. For example, the slot may return a QDate, then this looks up the
                           // name _PythonQt.QtCore.QDate.
                           PythonQtClassInfo* typeInfo = _p->_knownClassInfos.value(type.toLatin1().constData());
                           if (typeInfo && typeInfo->pythonQtClassWrapper()) {
                             PyObject* s = PyObject_GetAttrString(typeInfo->pythonQtClassWrapper(), "__module__");
                             Q_ASSERT(PyString_Check(s));
                             type = QString(PyString_AsString(s)) + "." + type;
                             Py_DECREF(s);
                             s = PyObject_GetAttrString(typeInfo->pythonQtClassWrapper(), "__name__");
                             Q_ASSERT(PyString_Check(s));
                             Py_DECREF(s);
                           }
                         }
                       }
                     }
                   }
                 }
               }
               return type;
             }
             void PythonQt::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator,  PythonQtShellSetInstanceWrapperCB* shell)
             {
               _p->registerCPPClass(typeName, parentTypeName, package, wrapperCreator, shell);
             }
             PythonQtClassInfo* PythonQtPrivate::lookupClassInfoAndCreateIfNotPresent(const char* typeName)
             {
               PythonQtClassInfo* info = _knownClassInfos.value(typeName);
               if (!info) {
                 info = new PythonQtClassInfo();
                 info->setupCPPObject(typeName);
                 _knownClassInfos.insert(typeName, info);
               }
               return info;
             }
             void PythonQt::addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb)
             {
               _p->addPolymorphicHandler(typeName, cb);
             }
             void PythonQtPrivate::addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb)
             {
               PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(typeName);
               info->addPolymorphicHandler(cb);
             }
             bool PythonQt::addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset)
             {
               return _p->addParentClass(typeName, parentTypeName, upcastingOffset);
             }
             bool PythonQtPrivate::addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset)
             {
               PythonQtClassInfo* info = _knownClassInfos.value(typeName);
               if (info) {
                 PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(parentTypeName);
                 info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo, upcastingOffset));
                 return true;
               } else {
                 return false;
               }
             }
             void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator,  PythonQtShellSetInstanceWrapperCB* shell, PyObject* module, int typeSlots)
             {
               PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(typeName);
               if (!info->pythonQtClassWrapper()) {
                 info->setTypeSlots(typeSlots);
                 info->setupCPPObject(typeName);
                 createPythonQtClassWrapper(info, package, module);
               }
               if (parentTypeName && strcmp(parentTypeName,"")!=0) {
                 addParentClass(typeName, parentTypeName, 0);
               }
               if (wrapperCreator) {
                 info->setDecoratorProvider(wrapperCreator);
               }
               if (shell) {
                 info->setShellSetInstanceWrapperCB(shell);
               }
             }
             PyObject* PythonQtPrivate::packageByName(const char* name)
             {
               if (name==NULL || name[0]==0) {
                 name = "private";
               }
               PyObject* v = _packages.value(name);
               if (!v) {
                 v = PyImport_AddModule((_pythonQtModuleName + "." + name).constData());
                 _packages.insert(name, v);
                 // AddObject steals the reference, so increment it!
                 Py_INCREF(v);
                 PyModule_AddObject(_pythonQtModule, name, v);
               }
               return v;
             }
             void PythonQtPrivate::handleVirtualOverloadReturnError(const char* signature, const PythonQtMethodInfo* methodInfo, PyObject* result)
             {
               QString error = "Return value '" + PythonQtConv::PyObjGetString(result) + "' can not be converted to expected C++ type '" + methodInfo->parameters().at(0).name + "' as return value of virtual method " + signature;
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               PythonQt::self()->handleError();
             }
             PyObject* PythonQt::helpCalled(PythonQtClassInfo* info)
             {
               if (_p->_initFlags & ExternalHelp) {
                 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 PythonQt::removeWrapperFactory( PythonQtCppWrapperFactory* factory )
             {
               _p->_cppWrapperFactories.removeAll(factory);
             }
             void PythonQt::removeWrapperFactory( PythonQtForeignWrapperFactory* factory )
             {
               _p->_foreignWrapperFactories.removeAll(factory);
             }
             void PythonQtPrivate::removeWrapperPointer(void* obj)
             {
               _wrappedObjects.remove(obj);
             }
             void PythonQtPrivate::addWrapperPointer(void* obj, PythonQtInstanceWrapper* wrapper)
             {
               _wrappedObjects.insert(obj, wrapper);
             }
             PythonQtInstanceWrapper* PythonQtPrivate::findWrapperAndRemoveUnused(void* obj)
             {
               PythonQtInstanceWrapper* wrap = _wrappedObjects.value(obj);
               if (wrap && !wrap->_wrappedPtr && wrap->_obj == NULL) {
                 // this is a wrapper whose QObject was already removed due to destruction
                 // so the obj pointer has to be a new QObject with the same address...
                 // we remove the old one and set the copy to NULL
                 wrap->_objPointerCopy = NULL;
                 removeWrapperPointer(obj);
                 wrap = NULL;
               }
               return wrap;
             }
             PythonQtObjectPtr PythonQtPrivate::createModule(const QString& name, PyObject* pycode)
             {
               PythonQtObjectPtr result;
               if (pycode) {
                 result.setNewRef(PyImport_ExecCodeModule((char*)name.toLatin1().data(), pycode));
               } else {
                 PythonQt::self()->handleError();
               }
               return result;
             }
             void* PythonQtPrivate::unwrapForeignWrapper( const QByteArray& classname, PyObject* obj )
             {
               void* foreignObject = NULL;
               for (int i=0; i<_foreignWrapperFactories.size(); i++) {
                 foreignObject = _foreignWrapperFactories.at(i)->unwrap(classname, obj);
                 if (foreignObject) {
                   return foreignObject;
                 }
               }
               return NULL;
             }
             bool PythonQtPrivate::isMethodDescriptor(PyObject* object) const
             {
               // This implementation is the same as in inspect.ismethoddescriptor(), inspect.py.
               if (PyObject_HasAttrString(object, "__get__") &&
                   !PyObject_HasAttrString(object, "__set__") &&
                   !PyMethod_Check(object) &&
                   !PyFunction_Check(object) &&
                   !PyClass_Check(object)) {
                 return true;
               }
               return false;
             }
             QString PythonQtPrivate::getSignature(PyObject* object)
             {
               QString signature;
               if (object) {
                 PyMethodObject* method = NULL;
                 PyFunctionObject* func = NULL;
                 bool decrefMethod = false;
                 if (object->ob_type == &PyClass_Type || object->ob_type == &PyType_Type) {
                   method = (PyMethodObject*)PyObject_GetAttrString(object, "__init__");
                   decrefMethod = true;
                 } else if (object->ob_type == &PyFunction_Type) {
                   func = (PyFunctionObject*)object;
                 } else if (object->ob_type == &PyMethod_Type) {
                   method = (PyMethodObject*)object;
                 }
                 if (method)  {
                   if (PyFunction_Check(method->im_func)) {
                     func = (PyFunctionObject*)method->im_func;
                   } else if (isMethodDescriptor((PyObject*)method)) {
                     QString docstr;
                     PyObject* doc = PyObject_GetAttrString(object, "__doc__");
                     if (doc) {
                       docstr = PyString_AsString(doc);
                       Py_DECREF(doc);
                     }
                     PyObject* s = PyObject_GetAttrString(object, "__name__");
                     if (s) {
                       Q_ASSERT(PyString_Check(s));
                       signature = PyString_AsString(s);
                       if (docstr.startsWith(signature + "(")) {
                         signature = docstr;
                       } else {
                         signature += "(...)";
                         if (!docstr.isEmpty()) {
                           signature += "\n\n" + docstr;
                         }
                       }
                       Py_DECREF(s);
                     }
                   }
                 }
                 if (func) {
                   QString funcName;
                   PyObject* s = PyObject_GetAttrString((PyObject*)func, "__name__");
                   if (s) {
                     Q_ASSERT(PyString_Check(s));
                     funcName = PyString_AsString(s);
                     Py_DECREF(s);
                   }
                   if (method && funcName == "__init__") {
                     PyObject* s = PyObject_GetAttrString(object, "__name__");
                     if (s) {
                       Q_ASSERT(PyString_Check(s));
                       funcName = PyString_AsString(s);
                       Py_DECREF(s);
                     }
                   }
                   QStringList arguments;
                   QStringList defaults;
                   QString varargs;
                   QString varkeywords;
                   // NOTE: This implementation is based on function getargs() in inspect.py.
                   //       inspect.getargs() can handle anonymous (tuple) arguments, while this code does not.
                   //       It can be implemented, but it may be rarely needed and not necessary.
                   PyCodeObject* code = (PyCodeObject*)func->func_code;
                   if (code->co_varnames) {
                     int nargs = code->co_argcount;
                     Q_ASSERT(PyTuple_Check(code->co_varnames));
                     for (int i=0; i<nargs; i++) {
                       PyObject* name = PyTuple_GetItem(code->co_varnames, i);
                       Q_ASSERT(PyString_Check(name));
                       arguments << PyString_AsString(name);
                     }
                     if (code->co_flags & CO_VARARGS) {
                       PyObject* s = PyTuple_GetItem(code->co_varnames, nargs);
                       Q_ASSERT(PyString_Check(s));
                       varargs = PyString_AsString(s);
                       nargs += 1;
                     }
                     if (code->co_flags & CO_VARKEYWORDS) {
                       PyObject* s = PyTuple_GetItem(code->co_varnames, nargs);
                       Q_ASSERT(PyString_Check(s));
                       varkeywords = PyString_AsString(s);
                     }
                   }
                   PyObject* defaultsTuple = func->func_defaults;
                   if (defaultsTuple) {
                     Q_ASSERT(PyTuple_Check(defaultsTuple));
                     for (Py_ssize_t i=0; i<PyTuple_Size(defaultsTuple); i++) {
                       PyObject* d = PyTuple_GetItem(defaultsTuple, i);
                       PyObject* s = PyObject_Repr(d);
                       Q_ASSERT(PyString_Check(s));
                       defaults << PyString_AsString(s);
                       Py_DECREF(s);
                     }
                   }
                   int firstdefault = arguments.size() - defaults.size();
                   for (int i=0; i<arguments.size(); i++) {
                     if (!signature.isEmpty()) { signature += ", "; }
                     if (!method || i>0 || arguments[i] != "self") {
                       signature += arguments[i];
                       if (i >= firstdefault) {
                         signature += "=" + defaults[i-firstdefault];
                       }
                     }
                   }
                   if (!varargs.isEmpty()) {
                     if (!signature.isEmpty()) { signature += ", "; }
                     signature += "*" + varargs;
                   }
                   if (!varkeywords.isEmpty()) {
                     if (!signature.isEmpty()) { signature += ", "; }
                     signature += "**" + varkeywords;
                   }
                   signature = funcName + "(" + signature + ")";
                 }
                 if (method && decrefMethod) {
                   Py_DECREF(method);
                 }
               }
               return signature;
             }
+            void PythonQtPrivate::shellClassDeleted( void* shellClass )
+            {
+              PythonQtInstanceWrapper* wrap = _wrappedObjects.value(shellClass);
+              if (wrap && wrap->_wrappedPtr) {
+                // this is a pure C++ wrapper and the shell has gone, so we need
+                // to set the _wrappedPtr to NULL on the wrapper
+                wrap->_wrappedPtr = NULL;
+                // and then we remove the wrapper, since the wrapped class is gone
+                _wrappedObjects.remove(shellClass);
+              }
+              // if the wrapper is a QObject, we do not handle this here,
+              // it will be handled by the QPointer<> to the QObject, which becomes NULL
+              // via the QObject destructor.
+            }
  No newline at end of file

src/PythonQt.h +3 0

             #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 PythonQtForeignWrapperFactory;
             class PythonQtQFileImporter;
             typedef void  PythonQtQObjectWrappedCB(QObject* object);
             typedef void  PythonQtQObjectNoLongerWrappedCB(QObject* object);
             typedef void* PythonQtPolymorphicHandlerCB(const void *ptr, const char **class_name);
             typedef void PythonQtShellSetInstanceWrapperCB(void* object, PythonQtInstanceWrapper* 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 ((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();
               //@}
               //! 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);
               //! read vars etc. in scope of the given \c object
               QStringList introspectObject(PyObject* object, ObjectType type);
               //! read vars etc. in scope of the type object called \c typename. First the typename
               //! of the form module.type is split into module and type. Then the module is looked up
               //! in sys.modules. If the module or type is not found there, then the type is looked up in
               //! the __builtin__ module.
               QStringList introspectType(const QString& typeName, ObjectType type);
               //! returns the found callable object or NULL
               //! @return new reference
               PythonQtObjectPtr lookupCallable(PyObject* object, const QString& name);
               //! returns the return type of the method of a wrapped c++ object referenced by \c objectname
               QString getReturnTypeOfWrappedMethod(PyObject* module, const QString& objectname);
               //! returns the return type of the method \c methodName of a wrapped c++ type referenced by \c typeName
               QString getReturnTypeOfWrappedMethod(const QString& typeName, const QString& methodName);
               //@}
               //---------------------------------------------------------------------------
               //! \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);
               //! add the given factory to PythonQt (ownership stays with caller)
               void addWrapperFactory(PythonQtForeignWrapperFactory* factory);
               //! remove the wrapper factory
               void removeWrapperFactory(PythonQtCppWrapperFactory* factory);
               //! remove the wrapper factory
               void removeWrapperFactory(PythonQtForeignWrapperFactory* 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);
               QString getReturnTypeOfWrappedMethodHelper(const PythonQtObjectPtr& variableObject, const QString& methodName, const QString& context);
               PyObject* getObjectByType(const QString& typeName);
               //! 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);
+              //! called by destructor of shells to allow invalidation of the Python wrapper
+              void shellClassDeleted(void* shellClass);
               //! try to unwrap the given object to a C++ pointer using the foreign wrapper factories
               void* unwrapForeignWrapper(const QByteArray& classname, PyObject* 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; }
               //! determines the signature of the given callable object (similar as pydoc)
               QString getSignature(PyObject* object);
               //! returns true if the object is a method descriptor (same as inspect.ismethoddescriptor() in inspect.py)
               bool isMethodDescriptor(PyObject* object) const;
             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;
               QList<PythonQtForeignWrapperFactory*> _foreignWrapperFactories;
               QHash<QByteArray, PyObject*> _packages;
               PythonQtClassInfo* _currentClassInfoForClassWrapperCreation;
               PythonQt::ProfilingCB* _profilingCB;
               int _initFlags;
               int _PythonQtObjectPtr_metaId;
               friend class PythonQt;
             };
             #endif

src/PythonQtClassInfo.cpp +17 -26

             /*
             *
             *  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 "PythonQtClassInfo.h"
             #include "PythonQtMethodInfo.h"
             #include "PythonQt.h"
             #include <QMetaMethod>
             #include <QMetaObject>
             #include <QMetaEnum>
             QHash<QByteArray, int> PythonQtMethodInfo::_parameterTypeDict;
             PythonQtClassInfo::PythonQtClassInfo() {
               _meta = NULL;
               _constructors = NULL;
               _destructor = NULL;
               _decoratorProvider = NULL;
               _decoratorProviderCB = NULL;
               _pythonQtClassWrapper = NULL;
               _shellSetInstanceWrapperCB = NULL;
               _metaTypeId = -1;
               _typeSlots = 0;
               _isQObject = false;
               _enumsCreated = false;
             }
             PythonQtClassInfo::~PythonQtClassInfo()
             {
               clearCachedMembers();
               if (_constructors) {
                 _constructors->deleteOverloadsAndThis();
               }
               if (_destructor) {
                 _destructor->deleteOverloadsAndThis();
               }
               foreach(PythonQtSlotInfo* info, _decoratorSlots) {
                 info->deleteOverloadsAndThis();
               }
             }
             void PythonQtClassInfo::setupQObject(const QMetaObject* meta)
             {
               // _wrappedClassName is already set earlier in the class setup
               _isQObject = true;
               _meta = meta;
             }
             void PythonQtClassInfo::setupCPPObject(const QByteArray& classname)
             {
               _isQObject = false;
               _wrappedClassName = classname;
               _metaTypeId = QMetaType::type(classname);
             }
             void PythonQtClassInfo::clearCachedMembers()
             {
               QHashIterator<QByteArray, PythonQtMemberInfo> i(_cachedMembers);
               while (i.hasNext()) {
                 PythonQtMemberInfo member = i.next().value();
                 if (member._type== PythonQtMemberInfo::Slot || member._type== PythonQtMemberInfo::Signal) {
                   PythonQtSlotInfo* info = member._slot;
                   while (info) {
                     PythonQtSlotInfo* next = info->nextInfo();
                     delete info;
                     info = next;
                   }
                 }
               }
             }
             int PythonQtClassInfo::findCharOffset(const char* sigStart, char someChar)
             {
               const char* sigEnd = sigStart;
               char c;
               do {
                 c = *sigEnd++;
               } while (c!=someChar && c!=0);
               return sigEnd-sigStart-1;
             }
             bool PythonQtClassInfo::lookForPropertyAndCache(const char* memberName)
             {
               if (!_meta) return false;
               bool found = false;
               bool nameMapped = false;
               const char* attributeName = memberName;
               // look for properties
               int i = _meta->indexOfProperty(attributeName);
               if (i==-1) {
                 // try to map name to objectName
                 if (qstrcmp(attributeName, "name")==0) {
                   attributeName = "objectName";
                   nameMapped = true;
                   i = _meta->indexOfProperty(attributeName);
                 }
               }
               if (i!=-1) {
                 PythonQtMemberInfo newInfo(_meta->property(i));
                 _cachedMembers.insert(attributeName, newInfo);
                 if (nameMapped) {
                   _cachedMembers.insert(memberName, newInfo);
                 }
               #ifdef PYTHONQT_DEBUG
                 std::cout << "caching property " << memberName << " on " << _meta->className() << std::endl;
               #endif
                 found = true;
               }
               return found;
             }
             PythonQtSlotInfo* PythonQtClassInfo::recursiveFindDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset)
             {
               inputInfo = findDecoratorSlotsFromDecoratorProvider(memberName, inputInfo, found, memberCache, upcastingOffset);
               foreach(const ParentClassInfo& info, _parentClasses) {
                 inputInfo = info._parent->recursiveFindDecoratorSlotsFromDecoratorProvider(memberName, inputInfo, found, memberCache, upcastingOffset+info._upcastingOffset);
               }
               return inputInfo;
             }
             PythonQtSlotInfo* PythonQtClassInfo::findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset) {
               QObject* decoratorProvider = decorator();
               int memberNameLen = static_cast<int>(strlen(memberName));
               if (decoratorProvider) {
                 //qDebug()<< "looking " << decoratorProvider->metaObject()->className() << " " << memberName << " " << upcastingOffset;
                 const QMetaObject* meta = decoratorProvider->metaObject();
                 int numMethods = meta->methodCount();
                 int startFrom = QObject::staticMetaObject.methodCount();
                 for (int i = startFrom; i < numMethods; i++) {
                   QMetaMethod m = meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                        m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     const char* sigStart = m.signature();
                     bool isClassDeco = false;
                     if (qstrncmp(sigStart, "static_", 7)==0) {
                       // skip the static_classname_ part of the string
                       sigStart += 7 + 1 + strlen(className());
                       isClassDeco = true;
                     } else if (qstrncmp(sigStart, "new_", 4)==0) {
                       isClassDeco = true;
                     } else if (qstrncmp(sigStart, "delete_", 7)==0) {
                       isClassDeco = true;
                     }
                     // find the first '('
                     int offset = findCharOffset(sigStart, '(');
                     // XXX no checking is currently done if the slots have correct first argument or not...
                     // check if same length and same name
                     if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
                       found = true;
                       PythonQtSlotInfo* info = new PythonQtSlotInfo(this, m, i, decoratorProvider, isClassDeco?PythonQtSlotInfo::ClassDecorator:PythonQtSlotInfo::InstanceDecorator);
                       info->setUpcastingOffset(upcastingOffset);
                       //qDebug()<< "adding " << decoratorProvider->metaObject()->className() << " " << memberName << " " << upcastingOffset;
                       if (tail) {
                         tail->setNextInfo(info);
                       } else {
                         PythonQtMemberInfo newInfo(info);
                         memberCache.insert(memberName, newInfo);
                       }
                       tail = info;
                     }
                   }
                 }
               }
               tail = findDecoratorSlots(memberName, memberNameLen, tail, found, memberCache, upcastingOffset);
-              return tail;
+              // now look for slots/signals/methods on this level of the meta object
-            bool PythonQtClassInfo::lookForMethodAndCache(const char* memberName)
-              bool found = false;
-              int memberNameLen =  static_cast<int>(strlen(memberName));
-              PythonQtSlotInfo* tail = NULL;
               if (_meta) {
                 int numMethods = _meta->methodCount();
-                for (int i = 0; i < numMethods; i++) {
+                // start from methodOffset, to only add slots which are located in this class,
+                // and not in the parent class, which is traversed recursively later on.
+                // (if the class in not a QObject, we are working with a script wrapper QObject
+                //  and need to read all slots/signals starting from 0).
+                int methodOffset = _isQObject?_meta->methodOffset():0;
+                for (int i = methodOffset; i < numMethods; i++) {
                   QMetaMethod m = _meta->method(i);
                   if (((m.methodType() == QMetaMethod::Method ||
                     m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public)
                     || m.methodType()==QMetaMethod::Signal) {
                       const char* sigStart = m.signature();
                       // find the first '('
                       int offset = findCharOffset(sigStart, '(');
                       // check if same length and same name
                       if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
                         found = true;
                         PythonQtSlotInfo* info = new PythonQtSlotInfo(this, m, i);
                         if (tail) {
                           tail->setNextInfo(info);
                         } else {
                           PythonQtMemberInfo newInfo(info);
-                        _cachedMembers.insert(memberName, newInfo);
+                          memberCache.insert(memberName, newInfo);
                         }
                         tail = info;
                       }
                   }
                 }
               }
+              return tail;
+            }
+            bool PythonQtClassInfo::lookForMethodAndCache(const char* memberName)
+            {
+              bool found = false;
+              PythonQtSlotInfo* tail = NULL;
               // look for dynamic decorators in this class and in derived classes
+              // (do this first to allow overloading of existing slots with generated wrappers,
+              //  e.g. QDialog::accept is overloaded with PythonQtWrapper_QDialog::accept decorator)
               tail = recursiveFindDecoratorSlotsFromDecoratorProvider(memberName, tail, found, _cachedMembers, 0);
               return found;
             }
             bool PythonQtClassInfo::lookForEnumAndCache(const QMetaObject* meta, const char* memberName)
             {
               bool found = false;
               // look for enum values
               int enumCount = meta->enumeratorCount();
               for (int i=0;i<enumCount; i++) {
                 QMetaEnum e = meta->enumerator(i);
                 // we do not want flags, they will cause our values to appear two times
                 if (e.isFlag()) continue;
                 for (int j=0; j < e.keyCount(); j++) {
                   if (qstrcmp(e.key(j), memberName)==0) {
                     PyObject* enumType = findEnumWrapper(e.name());
                     if (enumType) {
                       PythonQtObjectPtr enumValuePtr;
                       enumValuePtr.setNewRef(PythonQtPrivate::createEnumValueInstance(enumType, e.value(j)));
                       PythonQtMemberInfo newInfo(enumValuePtr);
                       _cachedMembers.insert(memberName, newInfo);
               #ifdef PYTHONQT_DEBUG
                       std::cout << "caching enum " << memberName << " on " << meta->className() << std::endl;
               #endif
                       found = true;
                       break;
                     } else {
                       std::cout << "enum " << e.name() << " not found on " << className() << std::endl;
                     }
                   }
                 }
               }
               return found;
             }
             PythonQtMemberInfo PythonQtClassInfo::member(const char* memberName)
             {
               PythonQtMemberInfo info = _cachedMembers.value(memberName);
               if (info._type != PythonQtMemberInfo::Invalid) {
                 return info;
               } else {
                 bool found = false;
                 found = lookForPropertyAndCache(memberName);
                 if (!found) {
                   found = lookForMethodAndCache(memberName);
                 }
                 if (!found) {
                   if (_meta) {
                     // check enums in our meta object directly
                     found = lookForEnumAndCache(_meta, memberName);
                   }
                   if (!found) {
                     // check enums in the class hierachy of CPP classes
                     // look for dynamic decorators in this class and in derived classes
                     QList<QObject*> decoObjects;
                     recursiveCollectDecoratorObjects(decoObjects);
                     foreach(QObject* deco, decoObjects) {
                       // call on ourself for caching, but with different metaObject():
                       found = lookForEnumAndCache(deco->metaObject(), memberName);
                       if (found) {
                         break;
                       }
                     }
                   }
                 }
                 if (!found) {
                   // maybe it is an enum wrapper?
                   PyObject* p = findEnumWrapper(memberName);
                   if (p) {
                     info._type = PythonQtMemberInfo::EnumWrapper;
                     info._enumWrapper = p;
                     _cachedMembers.insert(memberName, info);
                     found = true;
                   }
                 }
                 if (!found) {
                   // since python keywords can not be looked up, we check if the name contains a single trailing _
                   // and remove that and look again, so that we e.g. find exec on an exec_ lookup
                   QByteArray mbrName(memberName);
                   if ((mbrName.length()>2) &&
                       (mbrName.at(mbrName.length()-1) == '_') &&
                       (mbrName.at(mbrName.length()-2) != '_')) {
                     mbrName = mbrName.mid(0,mbrName.length()-1);
                     found = lookForMethodAndCache(mbrName.constData());
                     if (found) {
                       return _cachedMembers.value(mbrName);
                     }
                   }
                 }
                 if (!found) {
                   // we store a NotFound member, so that we get a quick result for non existing members (e.g. operator_equal lookup)
                   info._type = PythonQtMemberInfo::NotFound;
                   _cachedMembers.insert(memberName, info);
                 }
               }
               return _cachedMembers.value(memberName);
             }
             void PythonQtClassInfo::recursiveCollectDecoratorObjects(QList<QObject*>& decoratorObjects) {
               QObject* deco = decorator();
               if (deco) {
                 decoratorObjects.append(deco);
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 info._parent->recursiveCollectDecoratorObjects(decoratorObjects);
               }
             }
             void PythonQtClassInfo::recursiveCollectClassInfos(QList<PythonQtClassInfo*>& classInfoObjects) {
               classInfoObjects.append(this);
               foreach(const ParentClassInfo& info, _parentClasses) {
                 info._parent->recursiveCollectClassInfos(classInfoObjects);
               }
             }
             PythonQtSlotInfo* PythonQtClassInfo::findDecoratorSlots(const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset)
             {
               QListIterator<PythonQtSlotInfo*> it(_decoratorSlots);
               while (it.hasNext()) {
                 PythonQtSlotInfo* infoOrig = it.next();
                 const char* sigStart = infoOrig->metaMethod()->signature();
                 if (qstrncmp("static_", sigStart, 7)==0) {
                   sigStart += 7;
                   sigStart += findCharOffset(sigStart, '_')+1;
                 }
                 int offset = findCharOffset(sigStart, '(');
                 if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
                   //make a copy, otherwise we will have trouble on overloads!
                   PythonQtSlotInfo* info = new PythonQtSlotInfo(*infoOrig);
                   info->setUpcastingOffset(upcastingOffset);
                   found = true;
                   if (tail) {
                     tail->setNextInfo(info);
                   } else {
                     PythonQtMemberInfo newInfo(info);
                     memberCache.insert(memberName, newInfo);
                   }
                   tail = info;
                 }
               }
               return tail;
             }
             void PythonQtClassInfo::listDecoratorSlotsFromDecoratorProvider(QStringList& list, bool metaOnly) {
               QObject* decoratorProvider = decorator();
               if (decoratorProvider) {
                 const QMetaObject* meta = decoratorProvider->metaObject();
                 int numMethods = meta->methodCount();
                 int startFrom = QObject::staticMetaObject.methodCount();
                 for (int i = startFrom; i < numMethods; i++) {
                   QMetaMethod m = meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                        m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     const char* sigStart = m.signature();
                     bool isClassDeco = false;
                     if (qstrncmp(sigStart, "static_", 7)==0) {
                       // skip the static_classname_ part of the string
                       sigStart += 7 + 1 + strlen(className());
                       isClassDeco = true;
                     } else if (qstrncmp(sigStart, "new_", 4)==0) {
                       continue;
                     } else if (qstrncmp(sigStart, "delete_", 7)==0) {
                       continue;
                     } else if (qstrncmp(sigStart, "py_", 3)==0) {
                       // hide everything that starts with py_
                       continue;
                     }
                     // find the first '('
                     int offset = findCharOffset(sigStart, '(');
                     // XXX no checking is currently done if the slots have correct first argument or not...
                     if (!metaOnly || isClassDeco) {
                       list << QString::fromLatin1(sigStart, offset);
                     }
                   }
                 }
               }
               // look for global decorator slots
               QListIterator<PythonQtSlotInfo*> it(_decoratorSlots);
               while (it.hasNext()) {
                 PythonQtSlotInfo* slot = it.next();
                 if (metaOnly) {
                   if (slot->isClassDecorator()) {
                     QByteArray first = slot->slotName();
                     if (first.startsWith("static_")) {
                       int idx = first.indexOf('_');
                       idx = first.indexOf('_', idx+1);
                       first = first.mid(idx+1);
                     }
                     list << first;
                   }
                 } else {
                   list << slot->slotName();
                 }
               }
             }
             QStringList PythonQtClassInfo::propertyList()
             {
               QStringList l;
               if (_isQObject && _meta) {
                 int i;
                 int numProperties = _meta->propertyCount();
                 for (i = 0; i < numProperties; i++) {
                   QMetaProperty p = _meta->property(i);
                   l << QString(p.name());
                 }
               }
               return l;
             }
             QStringList PythonQtClassInfo::memberList()
             {
               decorator();
               QStringList l;
               QString h;
               // normal slots of QObject (or wrapper QObject)
               if (_meta) {
                 int numMethods = _meta->methodCount();
                 bool skipQObj = !_isQObject;
                 for (int i = skipQObj?QObject::staticMetaObject.methodCount():0; i < numMethods; i++) {
                   QMetaMethod m = _meta->method(i);
                   if (((m.methodType() == QMetaMethod::Method ||
                     m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public)
                       || m.methodType()==QMetaMethod::Signal) {
                     QByteArray signa(m.signature());
                     signa = signa.left(signa.indexOf('('));
                     l << signa;
                   }
                 }
               }
               {
                 // look for dynamic decorators in this class and in derived classes
                 QList<PythonQtClassInfo*> infos;
                 recursiveCollectClassInfos(infos);
                 foreach(PythonQtClassInfo* info, infos) {
                   info->listDecoratorSlotsFromDecoratorProvider(l, false);
                 }
               }
               // List enumerator keys...
               QList<const QMetaObject*> enumMetaObjects;
               if (_meta) {
                 enumMetaObjects << _meta;
               }
               // check enums in the class hierachy of CPP classes
               QList<QObject*> decoObjects;
               recursiveCollectDecoratorObjects(decoObjects);
               foreach(QObject* deco, decoObjects) {
                 enumMetaObjects << deco->metaObject();
               }
               foreach(const QMetaObject* meta, enumMetaObjects) {
                 for (int i = 0; i<meta->enumeratorCount(); i++) {
                   QMetaEnum e = meta->enumerator(i);
                   l << e.name();
                   // we do not want flags, they will cause our values to appear two times
                   if (e.isFlag()) continue;
                   for (int j=0; j < e.keyCount(); j++) {
                     l << QString(e.key(j));
                   }
                 }
               }
               return QSet<QString>::fromList(l).toList();
             }
             const char* PythonQtClassInfo::className()
             {
               return _wrappedClassName.constData();
             }
             void* PythonQtClassInfo::castTo(void* ptr, const char* classname)
             {
               if (ptr==NULL) {
                 return NULL;
               }
               if (_wrappedClassName == classname) {
                 return ptr;
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 void* result = info._parent->castTo((char*)ptr + info._upcastingOffset, classname);
                 if (result) {
                   return result;
                 }
               }
               return NULL;
             }
             bool PythonQtClassInfo::inherits(const char* name)
             {
               if (_wrappedClassName == name) {
                 return true;
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 if (info._parent->inherits(name)) {
                   return true;
                 }
               }
               return false;
             }
             bool PythonQtClassInfo::inherits(PythonQtClassInfo* classInfo)
             {
               if (classInfo == this) {
                 return true;
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 if (info._parent->inherits(classInfo)) {
                   return true;
                 }
               }
               return false;
             }
             QString PythonQtClassInfo::help()
             {
               decorator();
               QString h;
               h += QString("--- ") + QString(className()) + QString(" ---\n");
               if (_isQObject) {
                 h += "Properties:\n";
                 int i;
                 int numProperties = _meta->propertyCount();
                 for (i = 0; i < numProperties; i++) {
                   QMetaProperty p = _meta->property(i);
                   h += QString(p.name()) + " (" + QString(p.typeName()) + " )\n";
                 }
               }
               if (constructors()) {
                 h += "Constructors:\n";
                 PythonQtSlotInfo* constr = constructors();
                 while (constr) {
                   h += constr->fullSignature() + "\n";
                   constr = constr->nextInfo();
                 }
               }
               h += "Slots:\n";
               h += "QString help()\n";
               h += "QString className()\n";
               if (_meta) {
                 int numMethods = _meta->methodCount();
                 for (int i = 0; i < numMethods; i++) {
                   QMetaMethod m = _meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                     m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     PythonQtSlotInfo slot(this, m, i);
                     h += slot.fullSignature()+ "\n";
                   }
                 }
               }
               // TODO xxx : decorators and enums from decorator() are missing...
               // maybe we can reuse memberlist()?
               if (_meta && _meta->enumeratorCount()) {
                 h += "Enums:\n";
                 for (int i = 0; i<_meta->enumeratorCount(); i++) {
                   QMetaEnum e = _meta->enumerator(i);
                   h += QString(e.name()) + " {";
                   for (int j=0; j < e.keyCount(); j++) {
                     if (j) { h+= ", "; }
                     h += e.key(j);
                   }
                   h += " }\n";
                 }
               }
               if (_isQObject && _meta) {
                 int numMethods = _meta->methodCount();
                 if (numMethods>0) {
                   h += "Signals:\n";
                   for (int i = 0; i < numMethods; i++) {
                     QMetaMethod m = _meta->method(i);
                     if (m.methodType() == QMetaMethod::Signal) {
                       h += QString(m.signature()) + "\n";
                     }
                   }
                 }
               }
               return h;
             }
             PythonQtSlotInfo* PythonQtClassInfo::constructors()
             {
               if (!_constructors) {
                 // force creation of lazy decorator, which will register the decorators
                 decorator();
               }
               return _constructors;
             }
             PythonQtSlotInfo* PythonQtClassInfo::destructor()
             {
               if (!_destructor) {
                 // force creation of lazy decorator, which will register the decorators
                 decorator();
               }
               return _destructor;
             }
             void PythonQtClassInfo::addConstructor(PythonQtSlotInfo* info)
             {
               PythonQtSlotInfo* prev = constructors();
               if (prev) {
                 info->setNextInfo(prev->nextInfo());
                 prev->setNextInfo(info);
               } else {
                 _constructors = info;
               }
             }
             void PythonQtClassInfo::addDecoratorSlot(PythonQtSlotInfo* info)
             {
               _decoratorSlots.append(info);
             }
             void PythonQtClassInfo::setDestructor(PythonQtSlotInfo* info)
             {
               if (_destructor) {
                 _destructor->deleteOverloadsAndThis();
               }
               _destructor = info;
             }
             void PythonQtClassInfo::setMetaObject(const QMetaObject* meta)
             {
               _meta = meta;
               clearCachedMembers();
             }
             QObject* PythonQtClassInfo::decorator()
             {
               if (!_decoratorProvider && _decoratorProviderCB) {
                 _decoratorProvider = (*_decoratorProviderCB)();
                 if (_decoratorProvider) {
                   _decoratorProvider->setParent(PythonQt::priv());
                   // setup enums early, since they might be needed by the constructor decorators:
                   if (!_enumsCreated) {
                     createEnumWrappers();
                   }
                   PythonQt::priv()->addDecorators(_decoratorProvider, PythonQtPrivate::ConstructorDecorator | PythonQtPrivate::DestructorDecorator);
                 }
               }
               // check if enums need to be created and create them if they are not yet created
               if (!_enumsCreated) {
                 createEnumWrappers();
               }
               return _decoratorProvider;
             }
-            bool PythonQtClassInfo::hasOwnerMethodButNoOwner(void* object)
-              PythonQtMemberInfo info = member("py_hasOwner");
-              if (info._type == PythonQtMemberInfo::Slot) {
-                void* obj = object;
-                bool result = false;
-                void* args[2];
-                args[0] = &result;
-                args[1] = &obj;
-                info._slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
-                return !result;
-              } else {
-                return false;
             void* PythonQtClassInfo::recursiveCastDownIfPossible(void* ptr, const char** resultClassName)
             {
               if (!_polymorphicHandlers.isEmpty()) {
                 foreach(PythonQtPolymorphicHandlerCB* cb, _polymorphicHandlers) {
                   void* resultPtr = (*cb)(ptr, resultClassName);
                   if (resultPtr) {
                     return resultPtr;
                   }
                 }
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 if (!info._parent->isQObject()) {
                   void* resultPtr = info._parent->recursiveCastDownIfPossible((char*)ptr + info._upcastingOffset, resultClassName);
                   if (resultPtr) {
                     return resultPtr;
                   }
                 }
               }
               return NULL;
             }
             void* PythonQtClassInfo::castDownIfPossible(void* ptr, PythonQtClassInfo** resultClassInfo)
             {
               const char* className;
               // this would do downcasting recursively...
               // void* resultPtr = recursiveCastDownIfPossible(ptr, &className);
               // we only do downcasting on the base object, not on the whole inheritance tree...
               void* resultPtr = NULL;
               if (!_polymorphicHandlers.isEmpty()) {
                 foreach(PythonQtPolymorphicHandlerCB* cb, _polymorphicHandlers) {
                   resultPtr = (*cb)(ptr, &className);
                   if (resultPtr) {
                     break;
                   }
                 }
               }
               if (resultPtr) {
                 *resultClassInfo = PythonQt::priv()->getClassInfo(className);
               } else {
                 *resultClassInfo = this;
                 resultPtr = ptr;
               }
               return resultPtr;
             }
             PyObject* PythonQtClassInfo::findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool* isLocalEnum)
             {
               if (isLocalEnum) {
                 *isLocalEnum = true;
               }
               int scopePos = name.lastIndexOf("::");
               if (scopePos != -1) {
                 if (isLocalEnum) {
                   *isLocalEnum = false;
                 }
                 // split into scope and enum name
                 QByteArray enumScope = name.mid(0,scopePos);
                 QByteArray enumName = name.mid(scopePos+2);
                 PythonQtClassInfo* info = PythonQt::priv()->getClassInfo(enumScope);
                 if (info) {
                   return info->findEnumWrapper(enumName);
                 } else{
                   return NULL;
                 }
               }
               if (localScope) {
                 return localScope->findEnumWrapper(name);
               } else {
                 return NULL;
               }
             }
             void PythonQtClassInfo::createEnumWrappers(const QMetaObject* meta)
             {
               for (int i = meta->enumeratorOffset();i<meta->enumeratorCount();i++) {
                 QMetaEnum e = meta->enumerator(i);
                 PythonQtObjectPtr p;
                 p.setNewRef(PythonQtPrivate::createNewPythonQtEnumWrapper(e.name(), _pythonQtClassWrapper));
                 _enumWrappers.append(p);
               }
             }
             void PythonQtClassInfo::createEnumWrappers()
             {
               if (!_enumsCreated) {
                 _enumsCreated = true;
                 if (_meta) {
                   createEnumWrappers(_meta);
                 }
                 if (decorator()) {
                   createEnumWrappers(decorator()->metaObject());
                 }
                 foreach(const ParentClassInfo& info, _parentClasses) {
                   info._parent->createEnumWrappers();
                 }
               }
             }
             PyObject* PythonQtClassInfo::findEnumWrapper(const char* name) {
               // force enum creation
               if (!_enumsCreated) {
                 createEnumWrappers();
               }
               foreach(const PythonQtObjectPtr& p, _enumWrappers) {
                 const char* className = ((PyTypeObject*)p.object())->tp_name;
                 if (qstrcmp(className, name)==0) {
                   return p.object();
                 }
               }
               foreach(const ParentClassInfo& info, _parentClasses) {
                 PyObject* p = info._parent->findEnumWrapper(name);
                 if (p) return p;
               }
               return NULL;
             }
             void PythonQtClassInfo::setDecoratorProvider( PythonQtQObjectCreatorFunctionCB* cb )
             {
               _decoratorProviderCB = cb;
               _decoratorProvider = NULL;
               _enumsCreated = false;
             }
             void PythonQtClassInfo::clearNotFoundCachedMembers()
             {
               // remove all not found entries, since a new decorator means new slots,
               // which might have been cached as "NotFound" already.
               QMutableHashIterator<QByteArray, PythonQtMemberInfo> it(_cachedMembers);
               while (it.hasNext()) {
                 it.next();
                 if (it.value()._type == PythonQtMemberInfo::NotFound) {
                   it.remove();
                 }
               }
             }
             //-------------------------------------------------------------------------
             PythonQtMemberInfo::PythonQtMemberInfo( PythonQtSlotInfo* info )
             {
               if (info->metaMethod()->methodType() == QMetaMethod::Signal) {
                 _type = Signal;
               } else {
                 _type = Slot;
               }
               _slot = info;
               _enumValue = NULL;
             }
             PythonQtMemberInfo::PythonQtMemberInfo( const PythonQtObjectPtr& enumValue )
             {
               _type = EnumValue;
               _slot = NULL;
               _enumValue = enumValue;
               _enumWrapper = NULL;
             }
             PythonQtMemberInfo::PythonQtMemberInfo( const QMetaProperty& prop )
             {
               _type = Property;
               _slot = NULL;
               _enumValue = NULL;
               _property = prop;
               _enumWrapper = NULL;
             }

src/PythonQtClassInfo.h 0 -3

             #ifndef _PYTHONQTCLASSINFO_H
             #define _PYTHONQTCLASSINFO_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
              *
              */
             #include <QMetaObject>
             #include <QMetaMethod>
             #include <QHash>
             #include <QByteArray>
             #include <QList>
             #include "PythonQt.h"
             class PythonQtSlotInfo;
             struct PythonQtMemberInfo {
               enum Type {
                 Invalid, Slot, Signal, EnumValue, EnumWrapper, Property, NotFound
               };
               PythonQtMemberInfo():_type(Invalid),_slot(NULL),_enumWrapper(NULL),_enumValue(0) { }
               PythonQtMemberInfo(PythonQtSlotInfo* info);
               PythonQtMemberInfo(const PythonQtObjectPtr& enumValue);
               PythonQtMemberInfo(const QMetaProperty& prop);
               Type              _type;
               // TODO: this could be a union...
               PythonQtSlotInfo* _slot;
               PyObject*         _enumWrapper;
               PythonQtObjectPtr _enumValue;
               QMetaProperty     _property;
             };
             //! a class that stores all required information about a Qt object (and an optional associated C++ class name)
             /*! for fast lookup of slots when calling the object from Python
             */
             class PYTHONQT_EXPORT PythonQtClassInfo {
             public:
               PythonQtClassInfo();
               ~PythonQtClassInfo();
               //! store information about parent classes
               struct ParentClassInfo {
                 ParentClassInfo(PythonQtClassInfo* parent, int upcastingOffset=0):_parent(parent),_upcastingOffset(upcastingOffset)
                 {};
                 PythonQtClassInfo* _parent;
                 int                _upcastingOffset;
               };
               //! setup as a QObject, taking the meta object as meta information about the QObject
               void setupQObject(const QMetaObject* meta);
               //! setup as a CPP (non-QObject), taking the classname
               void setupCPPObject(const QByteArray& classname);
               //! set the type capabilities
               void setTypeSlots(int typeSlots) { _typeSlots = typeSlots; }
               //! get the type capabilities
               int typeSlots() const { return _typeSlots; }
               //! get the Python method definition for a given slot name (without return type and signature)
               PythonQtMemberInfo member(const char* member);
               //! get access to the constructor slot (which may be overloaded if there are multiple constructors)
               PythonQtSlotInfo* constructors();
               //! get access to the destructor slot
               PythonQtSlotInfo* destructor();
               //! add a constructor, ownership is passed to classinfo
               void addConstructor(PythonQtSlotInfo* info);
               //! set a destructor, ownership is passed to classinfo
               void setDestructor(PythonQtSlotInfo* info);
               //! add a decorator slot, ownership is passed to classinfo
               void addDecoratorSlot(PythonQtSlotInfo* info);
               //! get the classname (either of the QObject or of the wrapped CPP object)
               const char* className();
               //! returns if the QObject
               bool isQObject() { return _isQObject; }
               //! returns if the class is a CPP wrapper
               bool isCPPWrapper() { return !_isQObject; }
               //! get the meta object
               const QMetaObject* metaObject() { return _meta; }
               //! set the meta object, this will reset the caching
               void setMetaObject(const QMetaObject* meta);
               //! returns if this class inherits from the given classname
               bool inherits(const char* classname);
               //! returns if this class inherits from the given classinfo
               bool inherits(PythonQtClassInfo* info);
               //! casts the given \c ptr to an object of type \c classname, returns the new pointer
               //! which might be different to \c ptr due to C++ multiple inheritance
               //! (if the cast is not possible or if ptr is NULL, NULL is returned)
               void* castTo(void* ptr, const char* classname);
               //! get help string for the metaobject
               QString help();
               //! get list of all properties (on QObjects only, otherwise the list is empty)
               QStringList propertyList();
               //! get list of all members (excluding properties, which can be listed with propertyList())
               QStringList memberList();
               //! get the meta type id of this class (only valid for isCPPWrapper() == true)
               int metaTypeId() { return _metaTypeId; }
               //! set an additional decorator provider that offers additional decorator slots for this class
               void setDecoratorProvider(PythonQtQObjectCreatorFunctionCB* cb);
               //! get the decorator qobject instance
               QObject* decorator();
               //! add the parent class info of a CPP object
               void addParentClass(const ParentClassInfo& info) { _parentClasses.append(info); }
-              //! check if the special method "py_hasOwner" is implemented and if it returns false, which means that the object may be destroyed
-              bool hasOwnerMethodButNoOwner(void* object);
               //! set the associated PythonQtClassWrapper (which handles instance creation of this type)
               void setPythonQtClassWrapper(PyObject* obj) { _pythonQtClassWrapper = obj; }
               //! get the associated PythonQtClassWrapper (which handles instance creation of this type)
               PyObject* pythonQtClassWrapper() { return _pythonQtClassWrapper; }
               //! set the shell set instance wrapper cb
               void setShellSetInstanceWrapperCB(PythonQtShellSetInstanceWrapperCB* cb) {
                 _shellSetInstanceWrapperCB = cb;
               }
               //! get the shell set instance wrapper cb
               PythonQtShellSetInstanceWrapperCB* shellSetInstanceWrapperCB() {
                 return _shellSetInstanceWrapperCB;
               }
               //! add a handler for polymorphic downcasting
               void addPolymorphicHandler(PythonQtPolymorphicHandlerCB* cb) { _polymorphicHandlers.append(cb); }
               //! cast the pointer down in the class hierarchy if a polymorphic handler allows to do that
               void* castDownIfPossible(void* ptr, PythonQtClassInfo** resultClassInfo);
               //! returns if the localScope has an enum of that type name or if the enum contains a :: scope, if that class contails the enum
               static PyObject* findEnumWrapper(const QByteArray& name, PythonQtClassInfo* localScope, bool* isLocalEnum = NULL);
               //! clear all members that where cached as "NotFound"
               void clearNotFoundCachedMembers();
             private:
               void createEnumWrappers();
               void createEnumWrappers(const QMetaObject* meta);
               PyObject* findEnumWrapper(const char* name);
               //! clear all cached members
               void clearCachedMembers();
               void* recursiveCastDownIfPossible(void* ptr, const char** resultClassName);
               PythonQtSlotInfo* findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
               void listDecoratorSlotsFromDecoratorProvider(QStringList& list, bool metaOnly);
               PythonQtSlotInfo* recursiveFindDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
               void recursiveCollectClassInfos(QList<PythonQtClassInfo*>& classInfoObjects);
               void recursiveCollectDecoratorObjects(QList<QObject*>& decoratorObjects);
               bool lookForPropertyAndCache(const char* memberName);
               bool lookForMethodAndCache(const char* memberName);
               bool lookForEnumAndCache(const QMetaObject* m, const char* memberName);
               PythonQtSlotInfo* findDecoratorSlots(const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache, int upcastingOffset);
               int findCharOffset(const char* sigStart, char someChar);
               QHash<QByteArray, PythonQtMemberInfo> _cachedMembers;
               PythonQtSlotInfo*                    _constructors;
               PythonQtSlotInfo*                    _destructor;
               QList<PythonQtSlotInfo*>             _decoratorSlots;
               QList<PythonQtObjectPtr>             _enumWrappers;
               const QMetaObject*                   _meta;
               QByteArray                           _wrappedClassName;
               QList<ParentClassInfo>               _parentClasses;
               QList<PythonQtPolymorphicHandlerCB*> _polymorphicHandlers;
               QObject*                             _decoratorProvider;
               PythonQtQObjectCreatorFunctionCB*    _decoratorProviderCB;
               PyObject*                            _pythonQtClassWrapper;
               PythonQtShellSetInstanceWrapperCB*   _shellSetInstanceWrapperCB;
               int                                  _metaTypeId;
               int                                  _typeSlots;
               bool                                 _isQObject;
               bool                                 _enumsCreated;
             };
             //---------------------------------------------------------------
             #endif

src/PythonQtConversion.cpp +46 -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    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)
                  {
+                   if (obj->ob_type == &PyString_Type) {
+                     // take direct reference to string data
+                     const char* data = PyString_AS_STRING(obj);
+                     PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, (void*)data, ptr);
+                   } else {
+                     // convert to string
                      QString str = PyObjGetString(obj, strict, ok);
                      if (ok) {
+                       QByteArray bytes;
+                       bytes = str.toUtf8();
+                       if (ok) {
                          void* ptr2 = NULL;
-                     PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(str.toUtf8()), ptr2);
+                         PythonQtValueStorage_ADD_VALUE_IF_NEEDED(NULL,global_variantStorage, QVariant, QVariant(bytes), ptr2);
                          PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, (((QByteArray*)((QVariant*)ptr2)->constData())->data()), ptr);
                        }
+                     }
+                   }
+                 } else if (info.typeId == QMetaType::QString) {
+                   // TODO: this is a special case for bad Qt APIs which take a QString*, like QtGui.QFileDialog.getSaveFileName
+                   // In general we would need to decide to either support * args for all basic types (ignoring the fact that the
+                   // result value is not useable in Python), or if all these APIs need to be wrapped manually/differently, like PyQt/PySide do.
+                   QString str = PyObjGetString(obj, strict, ok);
+                   if (ok) {
+                     void* ptr2 = NULL;
+                     PythonQtValueStorage_ADD_VALUE_IF_NEEDED(NULL,global_variantStorage, QVariant, QVariant(str), ptr2);
+                     PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, (void*)((QVariant*)ptr2)->constData(), ptr);
+                   }
                  } else if (info.name == "PyObject") {
                    // handle low level PyObject directly
                    PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, obj, ptr);
                  } else if (obj == Py_None) {
                    // None is treated as a NULL ptr
                    PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, NULL, ptr);
                  } else {
                    void* foreignWrapper = PythonQt::priv()->unwrapForeignWrapper(info.name, obj);
                    if (foreignWrapper) {
                      PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, foreignWrapper, ptr);
                    } else {
                      // if we are not strict, we try if we are passed a 0 integer
                      if (!strict) {
                        bool ok;
                        int value = PyObjGetInt(obj, true, ok);
                        if (ok && value==0) {
                          // TODOXXX is this wise? or should it be expected from the programmer to use None?
                          PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_ptrStorage, void*, NULL, ptr);
                        }
                      }
                    }
                  }
                } else if (info.pointerCount == 0) {
                  // not a pointer
                  switch (info.typeId) {
                  case QMetaType::Char:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, char, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::UChar:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned char, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Short:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, short, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::UShort:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned short, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Long:
                    {
                      long val = (long)PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, long, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::ULong:
                    {
                      unsigned long val = (unsigned long)PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned long, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Bool:
                    {
                      bool val = PyObjGetBool(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, bool, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Int:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, int, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::UInt:
                    {
                      unsigned int val = (unsigned int)PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, unsigned int, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::QChar:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, short, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Float:
                    {
                      float val = (float)PyObjGetDouble(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, float, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Double:
                    {
                      double val = (double)PyObjGetDouble(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, double, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::LongLong:
                    {
                      qint64 val = PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, qint64, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::ULongLong:
                    {
                      quint64 val = PyObjGetULongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_valueStorage, quint64, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::QByteArray:
                    {
                      QByteArray bytes = PyObjGetBytes(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(bytes), ptr);
                        ptr = (void*)((QVariant*)ptr)->constData();
                      }
                    }
                    break;
                  case QMetaType::QString:
                    {
                      QString str = PyObjGetString(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(str), ptr);
                        ptr = (void*)((QVariant*)ptr)->constData();
                      }
                    }
                    break;
                  case QMetaType::QStringList:
                    {
                      QStringList l = PyObjToStringList(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, QVariant(l), ptr);
                        ptr = (void*)((QVariant*)ptr)->constData();
                      }
                    }
                    break;
                  case PythonQtMethodInfo::Variant:
                    {
                      QVariant v = PyObjToQVariant(obj);
                      // the only case where conversion can fail it None and we want to pass that to, e.g. setProperty(),
                      // so we do not check v.isValid() here
                      PythonQtValueStorage_ADD_VALUE_IF_NEEDED(alreadyAllocatedCPPObject,global_variantStorage, QVariant, v, ptr);
                    }
                    break;
                    default:
                    {
                      // check for enum case
                      if (info.enumWrapper) {
                        unsigned int val;
                        ok = false;
                        if ((PyObject*)obj->ob_type == info.enumWrapper) {
                          // we have a exact enum type match:
                          val = 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)) {
                 PyObject *ptmp = PyUnicode_AsUTF8String(val);
                 if(ptmp) {
                   r = QString::fromUtf8(PyString_AS_STRING(ptmp));
                   Py_DECREF(ptmp);
                 }
               } 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 {
+                  PyErr_Clear();
+                  // PyInt_AsLong will try conversion to an int if the object is not an int:
+                  d = PyInt_AsLong(val);
+                  if (PyErr_Occurred()) {
                     ok = false;
+                    PyErr_Clear();
+                  }
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             qint64 PythonQtConv::PyObjGetLongLong(PyObject* val, bool strict, bool &ok) {
               qint64 d = 0;
               ok = true;
               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 {
+                  PyErr_Clear();
+                  // PyLong_AsLongLong will try conversion to an int if the object is not an int:
+                  d = PyLong_AsLongLong(val);
+                  if (PyErr_Occurred()) {
                     ok = false;
+                    PyErr_Clear();
+                  }
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             quint64 PythonQtConv::PyObjGetULongLong(PyObject* val, bool strict, bool &ok) {
               quint64 d = 0;
               ok = true;
               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 {
+                  PyErr_Clear();
+                  // PyLong_AsLongLong will try conversion to an int if the object is not an int:
+                  d = PyLong_AsLongLong(val);
+                  if (PyErr_Occurred()) {
+                    PyErr_Clear();
                     ok = false;
                   }
+                }
               } else {
                 ok = false;
               }
               return d;
             }
             double PythonQtConv::PyObjGetDouble(PyObject* val, bool strict, bool &ok) {
               double d = 0;
               ok = true;
               if (val->ob_type == &PyFloat_Type) {
                 d = PyFloat_AS_DOUBLE(val);
               } else if (!strict) {
                 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 {
+                  PyErr_Clear();
+                  // PyFloat_AsDouble will try conversion to a double if the object is not a float:
+                  d = PyFloat_AsDouble(val);
+                  if (PyErr_Occurred()) {
+                    PyErr_Clear();
                     ok = false;
                   }
+                }
               } else {
                 ok = false;
               }
               return d;
             }
             QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
             {
               QVariant v;
               bool ok = true;
               if (type==-1) {
                 // no special type requested
                 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 {
                 return PyUnicode_DecodeUTF16((const char*)str.utf16(), str.length()*2, NULL, NULL);
               }
             }
             PyObject* PythonQtConv::QStringListToPyObject(const QStringList& list)
             {
               PyObject* result = PyTuple_New(list.count());
               int i = 0;
               QString str;
               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/PythonQtInstanceWrapper.cpp +1 -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    PythonQtInstanceWrapper.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtInstanceWrapper.h"
             #include <QObject>
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtSignal.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtConversion.h"
             #include "PythonQtClassWrapper.h"
             PythonQtClassInfo* PythonQtInstanceWrapperStruct::classInfo()
             {
               // take the class info from our type object
               return ((PythonQtClassWrapper*)ob_type)->_classInfo;
             }
             static void PythonQtInstanceWrapper_deleteObject(PythonQtInstanceWrapper* self, bool force = false) {
               // is this a C++ wrapper?
               if (self->_wrappedPtr) {
                 //mlabDebugConst("Python","c++ wrapper removed " << self->_wrappedPtr << " " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1());
                 PythonQt::priv()->removeWrapperPointer(self->_wrappedPtr);
                 // we own our qobject, so we delete it now:
                 delete self->_obj;
                 self->_obj = NULL;
-                if (force || self->classInfo()->hasOwnerMethodButNoOwner(self->_wrappedPtr) || self->_ownedByPythonQt) {
+                if (force || self->_ownedByPythonQt) {
                   int type = self->classInfo()->metaTypeId();
                   if (self->_useQMetaTypeDestroy && type>=0) {
                     // use QMetaType to destroy the object
                     QMetaType::destroy(type, self->_wrappedPtr);
                   } else {
                     PythonQtSlotInfo* slot = self->classInfo()->destructor();
                     if (slot) {
                       void* args[2];
                       args[0] = NULL;
                       args[1] = &self->_wrappedPtr;
                       slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, slot->slotIndex(), args);
                       self->_wrappedPtr = NULL;
                     } else {
                       if (type>=0) {
                         // use QMetaType to destroy the object
                         QMetaType::destroy(type, self->_wrappedPtr);
                       } else {
                         // TODO: warn about not being able to destroy the object?
                       }
                     }
                   }
                 }
               } else {
                 //mlabDebugConst("Python","qobject wrapper removed " << self->_obj->className() << " " << self->classInfo()->wrappedClassName().latin1());
                 if (self->_objPointerCopy) {
                   PythonQt::priv()->removeWrapperPointer(self->_objPointerCopy);
                 }
                 if (self->_obj) {
                   if (force || self->_ownedByPythonQt) {
                     if (force || !self->_obj->parent()) {
                       delete self->_obj;
                     }
                   } else {
                     if (self->_obj->parent()==NULL) {
                       // tell someone who is interested that the qobject is no longer wrapped, if it has no parent
                       PythonQt::qObjectNoLongerWrappedCB(self->_obj);
                     }
                   }
                 }
               }
               self->_obj = NULL;
             }
             static void PythonQtInstanceWrapper_dealloc(PythonQtInstanceWrapper* self)
             {
               PythonQtInstanceWrapper_deleteObject(self);
               self->_obj.~QPointer<QObject>();
               self->ob_type->tp_free((PyObject*)self);
             }
             static PyObject* PythonQtInstanceWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               //PythonQtClassWrapper    *classType = (PythonQtClassWrapper*)type;
               PythonQtInstanceWrapper *self;
               static PyObject* emptyTuple = NULL;
               if (emptyTuple==NULL) {
                 emptyTuple = PyTuple_New(0);
               }
               self = (PythonQtInstanceWrapper*)PyBaseObject_Type.tp_new(type, emptyTuple, NULL);
               if (self != NULL) {
                 new (&self->_obj) QPointer<QObject>();
                 self->_wrappedPtr = NULL;
                 self->_ownedByPythonQt = false;
                 self->_useQMetaTypeDestroy = false;
                 self->_isShellInstance = false;
               }
               return (PyObject *)self;
             }
             int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds)
             {
               if (args == PythonQtPrivate::dummyTuple()) {
                 // we are called from the internal PythonQt API, so our data will be filled later on...
                 return 0;
               }
               // we are called from python, try to construct our object
               if (self->classInfo()->constructors()) {
                 void* directCPPPointer = NULL;
                 PythonQtSlotFunction_CallImpl(self->classInfo(), NULL, self->classInfo()->constructors(), args, kwds, NULL, &directCPPPointer);
                 if (PyErr_Occurred()) {
                   return -1;
                 }
                 if (directCPPPointer) {
                   // change ownershipflag to be owned by PythonQt
                   self->_ownedByPythonQt = true;
                   self->_useQMetaTypeDestroy = false;
                   if (self->classInfo()->isCPPWrapper()) {
                     self->_wrappedPtr = directCPPPointer;
                     // TODO xxx: if there is a wrapper factory, we might want to generate a wrapper for our class?!
                   } else {
                     self->setQObject((QObject*)directCPPPointer);
                   }
                   // register with PythonQt
                   PythonQt::priv()->addWrapperPointer(directCPPPointer, self);
                   PythonQtShellSetInstanceWrapperCB* cb = self->classInfo()->shellSetInstanceWrapperCB();
                   if (cb) {
                     // if we are a derived python class, we set the wrapper
                     // to activate the shell class, otherwise we just ignore that it is a shell...
                     // we detect it be checking if the type does not have PythonQtInstanceWrapper_Type as direct base class,
                     // which is the case for all non-python derived types
                     if (((PyObject*)self)->ob_type->tp_base != &PythonQtInstanceWrapper_Type) {
                       // set the wrapper and remember that we have a shell instance!
                       (*cb)(directCPPPointer, self);
                       self->_isShellInstance = true;
                     }
                   }
                 }
               } else {
                 QString error = QString("No constructors available for ") + self->classInfo()->className();
                 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                 return -1;
               }
               return 0;
             }
             static PyObject *PythonQtInstanceWrapper_richcompare(PythonQtInstanceWrapper* wrapper, PyObject* other, int code)
             {
               bool validPtrs = false;
               bool areSamePtrs = false;
               if (PyObject_TypeCheck((PyObject*)wrapper, &PythonQtInstanceWrapper_Type)) {
                 if (PyObject_TypeCheck(other, &PythonQtInstanceWrapper_Type)) {
                   validPtrs = true;
                   PythonQtInstanceWrapper* w1 = wrapper;
                   PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)other;
                   // check pointers directly
                   if (w1->_wrappedPtr != NULL) {
                     if (w1->_wrappedPtr == w2->_wrappedPtr) {
                       areSamePtrs = true;
                     }
                   } else if (w1->_obj == w2->_obj) {
                     areSamePtrs = true;
                   }
                 } else if (other == Py_None) {
                   validPtrs = true;
                   if (wrapper->_obj || wrapper->_wrappedPtr) {
                     areSamePtrs = false;
                   } else {
                     areSamePtrs = true;
                   }
                 }
               }
               if ((wrapper->classInfo()->typeSlots() & PythonQt::Type_RichCompare) == 0) {
                 // shortcut if richcompare is not supported:
                 if (validPtrs && code == Py_EQ) {
                   return PythonQtConv::GetPyBool(areSamePtrs);
                 } else if (validPtrs && code == Py_NE) {
                   return PythonQtConv::GetPyBool(!areSamePtrs);
                 }
                 Py_INCREF(Py_NotImplemented);
                 return Py_NotImplemented;
               }
               QByteArray memberName;
               switch (code) {
               case Py_LT:
                 {
                   static QByteArray name = "__lt__";
                   memberName = name;
                 }
                 break;
               case Py_LE:
                 {
                   static QByteArray name = "__le__";
                   memberName = name;
                 }
                 break;
               case Py_EQ:
                 {
                   static QByteArray name = "__eq__";
                   memberName = name;
                 }
                 break;
               case Py_NE:
                 {
                   static QByteArray name = "__ne__";
                   memberName = name;
                 }
                 break;
               case Py_GT:
                 {
                   static QByteArray name = "__gt__";
                   memberName = name;
                 }
                 break;
               case Py_GE:
                 {
                   static QByteArray name = "__ge__";
                   memberName = name;
                 }
                 break;
               }
               PythonQtMemberInfo opSlot = wrapper->classInfo()->member(memberName);
               if (opSlot._type == PythonQtMemberInfo::Slot) {
                 // TODO get rid of tuple
                 PyObject* args = PyTuple_New(1);
                 Py_INCREF(other);
                 PyTuple_SET_ITEM(args, 0, other);
                 PyObject* result = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, opSlot._slot, args, NULL, wrapper->_wrappedPtr);
                 Py_DECREF(args);
                 return result;
               } else {
                 // not implemented, let python try something else!
                 Py_INCREF(Py_NotImplemented);
                 return Py_NotImplemented;
               }
             }
             static PyObject *PythonQtInstanceWrapper_classname(PythonQtInstanceWrapper* obj)
             {
               return PyString_FromString(obj->ob_type->tp_name);
             }
             PyObject *PythonQtInstanceWrapper_inherits(PythonQtInstanceWrapper* obj, PyObject *args)
             {
               char *name = NULL;
               if (!PyArg_ParseTuple(args, "s:PythonQtInstanceWrapper.inherits",&name)) {
                 return NULL;
               }
               return PythonQtConv::GetPyBool(obj->classInfo()->inherits(name));
             }
             static PyObject *PythonQtInstanceWrapper_help(PythonQtInstanceWrapper* obj)
             {
               return PythonQt::self()->helpCalled(obj->classInfo());
             }
             PyObject *PythonQtInstanceWrapper_delete(PythonQtInstanceWrapper * self)
             {
               PythonQtInstanceWrapper_deleteObject(self, true);
               Py_INCREF(Py_None);
               return Py_None;
             }
             static PyMethodDef PythonQtInstanceWrapper_methods[] = {
                 {"className", (PyCFunction)PythonQtInstanceWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
                 {"inherits", (PyCFunction)PythonQtInstanceWrapper_inherits, METH_VARARGS,
                 "Returns if the class inherits or is of given type name"
                 },
                 {"help", (PyCFunction)PythonQtInstanceWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
                 {"delete", (PyCFunction)PythonQtInstanceWrapper_delete, METH_NOARGS,
                 "Deletes the C++ object (at your own risk, my friend!)"
                 },
             {NULL, NULL, 0, NULL}  /* Sentinel */
             };
             static PyObject *PythonQtInstanceWrapper_getattro(PyObject *obj,PyObject *name)
             {
               const char *attributeName;
               PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL) {
                 return NULL;
               }
               if (qstrcmp(attributeName, "__dict__")==0) {
                 PyObject* dict = PyBaseObject_Type.tp_getattro(obj, name);
                 dict = PyDict_Copy(dict);
                 if (wrapper->_obj) {
                   // only the properties are missing, the rest is already available from
                   // PythonQtClassWrapper...
                   QStringList l = wrapper->classInfo()->propertyList();
                   foreach (QString name, l) {
                     PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
                     if (o) {
                       PyDict_SetItemString(dict, name.toLatin1().data(), o);
                       Py_DECREF(o);
                     } else {
                       std::cerr << "PythonQtInstanceWrapper: something is wrong, could not get attribute " << name.toLatin1().data();
                     }
                   }
                   QList<QByteArray> dynamicProps = wrapper->_obj->dynamicPropertyNames();
                   foreach (QByteArray name, dynamicProps) {
                     PyObject* o = PyObject_GetAttrString(obj, name.data());
                     if (o) {
                       PyDict_SetItemString(dict, name.data(), o);
                       Py_DECREF(o);
                     } else {
                       std::cerr << "PythonQtInstanceWrapper: dynamic property could not be read " << name.data();
                     }
                   }
                 }
                 // Note: we do not put children into the dict, is would look confusing?!
                 return dict;
               }
               // first look in super, to return derived methods from base object first
               PyObject* superAttr = PyBaseObject_Type.tp_getattro(obj, name);
               if (superAttr) {
                 return superAttr;
               }
               PyErr_Clear();
               //  mlabDebugConst("Python","get " << attributeName);
               PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
               switch (member._type) {
               case PythonQtMemberInfo::Property:
                 if (wrapper->_obj) {
                   if (member._property.userType() != QVariant::Invalid) {
                     PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB();
                     if (profilingCB) {
                       QString methodName = "getProperty(";
                       methodName += attributeName;
                       methodName += ")";
                       profilingCB(PythonQt::Enter, wrapper->_obj->metaObject()->className(), methodName.toLatin1());
                     }
                     PyObject* value = PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj));
                     if (profilingCB) {
                       profilingCB(PythonQt::Leave, NULL, NULL);
                     }
                     return value;
                   } else {
                     Py_INCREF(Py_None);
                     return Py_None;
                   }
                 } else {
                   QString error = QString("Trying to read property '") + attributeName + "' from a destroyed " + wrapper->classInfo()->className() + " object";
                   PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                   return NULL;
                 }
                 break;
               case PythonQtMemberInfo::Slot:
                 return PythonQtSlotFunction_New(member._slot, obj, NULL);
                 break;
               case PythonQtMemberInfo::Signal:
                 return PythonQtSignalFunction_New(member._slot, obj, NULL);
                 break;
               case PythonQtMemberInfo::EnumValue:
                 {
                   PyObject* enumValue = member._enumValue;
                   Py_INCREF(enumValue);
                   return enumValue;
                 }
                 break;
               case PythonQtMemberInfo::EnumWrapper:
                 {
                   PyObject* enumWrapper = member._enumWrapper;
                   Py_INCREF(enumWrapper);
                   return enumWrapper;
                 }
                 break;
               case PythonQtMemberInfo::NotFound:
                 {
                   static const QByteArray getterString("py_get_");
                   // check for a getter slot
                   PythonQtMemberInfo member = wrapper->classInfo()->member(getterString + attributeName);
                   if (member._type == PythonQtMemberInfo::Slot) {
                     return PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, member._slot, NULL, NULL, wrapper->_wrappedPtr);
                   }
                   // handle dynamic properties
                   if (wrapper->_obj) {
                     QVariant v = wrapper->_obj->property(attributeName);
                     if (v.isValid()) {
                       return PythonQtConv::QVariantToPyObject(v);
                     }
                   }
                 }
                 break;
               default:
                 // is an invalid type, go on
                 break;
               }
               // look for the internal methods (className(), help())
               PyObject* internalMethod = Py_FindMethod( PythonQtInstanceWrapper_methods, obj, (char*)attributeName);
               if (internalMethod) {
                 return internalMethod;
               }
               PyErr_Clear();
               if (wrapper->_obj) {
                 // look for a child
                 QObjectList children = wrapper->_obj->children();
                 for (int i = 0; i < children.count(); i++) {
                   QObject *child = children.at(i);
                   if (child->objectName() == attributeName) {
                     return PythonQt::priv()->wrapQObject(child);
                   }
                 }
               }
               QString error = QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'";
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return NULL;
             }
             static int PythonQtInstanceWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
             {
               QString error;
               const char *attributeName;
               PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL)
                 return -1;
               PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
               if (member._type == PythonQtMemberInfo::Property) {
                 if (!wrapper->_obj) {
                   error = QString("Trying to set property '") + attributeName + "' on a destroyed " + wrapper->classInfo()->className() + " object";
                   PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
                   return -1;
                 }
                 QMetaProperty prop = member._property;
                 if (prop.isWritable()) {
                   QVariant v;
                   if (prop.isEnumType()) {
                     // this will give us either a string or an int, everything else will probably be an error
                     v = PythonQtConv::PyObjToQVariant(value);
                   } else {
                     int t = prop.userType();
                     v = PythonQtConv::PyObjToQVariant(value, t);
                   }
                   bool success = false;
                   if (v.isValid()) {
                     PythonQt::ProfilingCB* profilingCB = PythonQt::priv()->profilingCB();
                     if (profilingCB) {
                       QString methodName = "setProperty(";
                       methodName += attributeName;
                       methodName += ")";
                       profilingCB(PythonQt::Enter, wrapper->_obj->metaObject()->className(), methodName.toLatin1());
                     }
                     success = prop.write(wrapper->_obj, v);
                     if (profilingCB) {
                       profilingCB(PythonQt::Leave, NULL, NULL);
                     }
                   }
                   if (success) {
                     return 0;
                   } else {
                     error = QString("Property '") + attributeName + "' of type '" +
                       prop.typeName() + "' does not accept an object of type "
                       + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")";
                   }
                 } else {
                   error = QString("Property '") + attributeName + "' of " + obj->ob_type->tp_name + " object is not writable";
                 }
               } else if (member._type == PythonQtMemberInfo::Slot) {
                 error = QString("Slot '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
               } else if (member._type == PythonQtMemberInfo::Signal) {
                 error = QString("Signal '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
               } else if (member._type == PythonQtMemberInfo::EnumValue) {
                 error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
               } else if (member._type == PythonQtMemberInfo::EnumWrapper) {
                 error = QString("Enum '") + attributeName + "' can not be overwritten on " + obj->ob_type->tp_name + " object";
               } else if (member._type == PythonQtMemberInfo::NotFound) {
                 // check for a setter slot
                 static const QByteArray setterString("py_set_");
                 PythonQtMemberInfo setter = wrapper->classInfo()->member(setterString + attributeName);
                 if (setter._type == PythonQtMemberInfo::Slot) {
                   // call the setter and ignore the result value
                   void* result;
                   PyObject* args = PyTuple_New(1);
                   Py_INCREF(value);
                   PyTuple_SET_ITEM(args, 0, value);
                   PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, setter._slot, args, NULL, wrapper->_wrappedPtr, &result);
                   Py_DECREF(args);
                   return 0;
                 }
                 // handle dynamic properties
                 if (wrapper->_obj) {
                   QVariant prop = wrapper->_obj->property(attributeName);
                   if (prop.isValid()) {
                     QVariant v = PythonQtConv::PyObjToQVariant(value);
                     if (v.isValid()) {
                       wrapper->_obj->setProperty(attributeName, v);
                       return 0;
                     } else {
                       error = QString("Dynamic property '") + attributeName + "' does not accept an object of type "
                       + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")";
                       PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
                       return -1;
                     }
                   }
                 }
                 // if we are a derived python class, we allow setting attributes.
                 // if we are a direct CPP wrapper, we do NOT allow it, since
                 // it would be confusing to allow it because a wrapper will go away when it is not seen by python anymore
                 // and when it is recreated from a CPP pointer the attributes are gone...
                 if (obj->ob_type->tp_base != &PythonQtInstanceWrapper_Type) {
                   return PyBaseObject_Type.tp_setattro(obj,name,value);
                 } else {
                   error = QString("'") + attributeName + "' does not exist on " + obj->ob_type->tp_name + " and creating new attributes on C++ objects is not allowed";
                 }
               }
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return -1;
             }
             static QString getStringFromObject(PythonQtInstanceWrapper* wrapper) {
               QString result;
               if (wrapper->_wrappedPtr) {
                 // first try some manually string conversions for some variants
                 int metaid = wrapper->classInfo()->metaTypeId();
                 result = PythonQtConv::CPPObjectToString(metaid, wrapper->_wrappedPtr);
                 if (!result.isEmpty()) {
                   return result;
                 }
               }
               if (wrapper->_wrappedPtr || wrapper->_obj) {
                 // next, try to call py_toString
                 PythonQtMemberInfo info = wrapper->classInfo()->member("py_toString");
                 if (info._type == PythonQtMemberInfo::Slot) {
                   PyObject* resultObj = PythonQtSlotFunction_CallImpl(wrapper->classInfo(), wrapper->_obj, info._slot, NULL, NULL, wrapper->_wrappedPtr);
                   if (resultObj) {
                     // TODO this is one conversion too much, would be nicer to call the slot directly...
                     result = PythonQtConv::PyObjGetString(resultObj);
                     Py_DECREF(resultObj);
                   }
                 }
               }
               return result;
             }
             static PyObject * PythonQtInstanceWrapper_str(PyObject * obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               // QByteArray should be directly returned as a str
               if (wrapper->classInfo()->metaTypeId()==QVariant::ByteArray) {
                 QByteArray* b = (QByteArray*) wrapper->_wrappedPtr;
                 if (b->data()) {
                   return PyString_FromStringAndSize(b->data(), b->size());
                 } else {
                   return PyString_FromString("");
                 }
               }
               const char* typeName = obj->ob_type->tp_name;
               QObject *qobj = wrapper->_obj;
               QString str = getStringFromObject(wrapper);
               if (!str.isEmpty()) {
                 return PyString_FromFormat("%s", str.toLatin1().constData());
               }
               if (wrapper->_wrappedPtr) {
                 if (wrapper->_obj) {
                   return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
                 } else {
                   return PyString_FromFormat("%s (C++ Object %p)", typeName, wrapper->_wrappedPtr);
                 }
               } else {
                 return PyString_FromFormat("%s (QObject %p)", typeName, qobj);
               }
             }
             static PyObject * PythonQtInstanceWrapper_repr(PyObject * obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               const char* typeName = obj->ob_type->tp_name;
               QObject *qobj = wrapper->_obj;
               QString str = getStringFromObject(wrapper);
               if (!str.isEmpty()) {
                 if (str.startsWith(typeName)) {
                   return PyString_FromFormat("%s", str.toLatin1().constData());
                 } else {
                   return PyString_FromFormat("%s (%s, at: %p)", typeName, str.toLatin1().constData(), wrapper->_wrappedPtr ? wrapper->_wrappedPtr : qobj);
                 }
               }
               if (wrapper->_wrappedPtr) {
                 if (wrapper->_obj) {
                   return PyString_FromFormat("%s (C++ object at: %p wrapped by %s at: %p)", typeName, wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
                 } else {
                   return PyString_FromFormat("%s (C++ object at: %p)", typeName, wrapper->_wrappedPtr);
                 }
               } else {
                 return PyString_FromFormat("%s (%s at: %p)", typeName, wrapper->classInfo()->className(), qobj);
               }
             }
             static int PythonQtInstanceWrapper_builtin_nonzero(PyObject *obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               return (wrapper->_wrappedPtr == NULL && wrapper->_obj == NULL)?0:1;
             }
             static long PythonQtInstanceWrapper_hash(PythonQtInstanceWrapper *obj)
             {
               if (obj->_wrappedPtr != NULL) {
                 return reinterpret_cast<long>(obj->_wrappedPtr);
               } else {
                 QObject* qobj = obj->_obj; // get pointer from QPointer wrapper
                 return reinterpret_cast<long>(qobj);
               }
             }
             // we override nb_nonzero, so that one can do 'if' expressions to test for a NULL ptr
             static PyNumberMethods PythonQtInstanceWrapper_as_number = {
 ,      /* nb_add */
 ,      /* nb_subtract */
 ,      /* nb_multiply */
 ,      /* nb_divide */
 ,      /* nb_remainder */
 ,      /* nb_divmod */
 ,      /* nb_power */
 ,      /* nb_negative */
 ,      /* nb_positive */
 ,      /* nb_absolute */
                 PythonQtInstanceWrapper_builtin_nonzero,      /* nb_nonzero */
 ,      /* nb_invert */
 ,      /* nb_lshift */
 ,      /* nb_rshift */
 ,    /* nb_and */
 ,    /* nb_xor */
 ,    /* nb_or */
 ,      /* nb_coerce */
 ,      /* nb_int */
 ,      /* nb_long */
 ,      /* nb_float */
 ,      /* nb_oct */
 ,      /* nb_hex */
 ,      /* nb_inplace_add */
 ,      /* nb_inplace_subtract */
 ,      /* nb_inplace_multiply */
 ,      /* nb_inplace_divide */
 ,      /* nb_inplace_remainder */
 ,      /* nb_inplace_power */
 ,      /* nb_inplace_lshift */
 ,      /* nb_inplace_rshift */
 ,      /* nb_inplace_and */
 ,      /* nb_inplace_xor */
 ,      /* nb_inplace_or */
 ,      /* nb_floor_divide */
 ,      /* nb_true_divide */
 ,      /* nb_inplace_floor_divide */
 ,      /* nb_inplace_true_divide */
             };
             PyTypeObject PythonQtInstanceWrapper_Type = {
                 PyObject_HEAD_INIT(&PythonQtClassWrapper_Type)
 ,                         /*ob_size*/
                 "PythonQt.PythonQtInstanceWrapper",             /*tp_name*/
                 sizeof(PythonQtInstanceWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
                 (destructor)PythonQtInstanceWrapper_dealloc, /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
 ,                         /*tp_compare*/
                 PythonQtInstanceWrapper_repr,            /*tp_repr*/
                 &PythonQtInstanceWrapper_as_number,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
                 (hashfunc)PythonQtInstanceWrapper_hash,                         /*tp_hash */
 ,                         /*tp_call*/
                 PythonQtInstanceWrapper_str,      /*tp_str*/
                 PythonQtInstanceWrapper_getattro,                         /*tp_getattro*/
                 PythonQtInstanceWrapper_setattro,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_CHECKTYPES, /*tp_flags*/
                 "PythonQtInstanceWrapper object",           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
                 (richcmpfunc)PythonQtInstanceWrapper_richcompare,                   /* tp_richcompare */
 ,                   /* tp_weaklistoffset */
 ,                   /* tp_iter */
 ,                   /* tp_iternext */
 ,             /* tp_methods */
 ,             /* tp_members */
 ,                         /* tp_getset */
 ,                         /* tp_base */
 ,                         /* tp_dict */
 ,                         /* tp_descr_get */
 ,                         /* tp_descr_set */
 ,                         /* tp_dictoffset */
                 (initproc)PythonQtInstanceWrapper_init,      /* tp_init */
 ,                         /* tp_alloc */
                 PythonQtInstanceWrapper_new,                 /* tp_new */
             };
             //-------------------------------------------------------

src/PythonQtMethodInfo.cpp +25 0

             /*
              *
              *  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    PythonQtMethodInfo.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtMethodInfo.h"
             #include "PythonQtClassInfo.h"
             #include <iostream>
             QHash<QByteArray, PythonQtMethodInfo*> PythonQtMethodInfo::_cachedSignatures;
             QHash<QByteArray, QByteArray> PythonQtMethodInfo::_parameterNameAliases;
             PythonQtMethodInfo::PythonQtMethodInfo(const QMetaMethod& meta, PythonQtClassInfo* classInfo)
             {
             #ifdef PYTHONQT_DEBUG
               QByteArray sig(meta.signature());
               sig = sig.mid(sig.indexOf('('));
               QByteArray fullSig = QByteArray(meta.typeName()) + " " + sig;
               std::cout << "caching " << fullSig.data() << std::endl;
             #endif
               ParameterInfo type;
               fillParameterInfo(type, QByteArray(meta.typeName()), classInfo);
               _parameters.append(type);
               QList<QByteArray> names = meta.parameterTypes();
               foreach (const QByteArray& name, names) {
                 fillParameterInfo(type, name, classInfo);
                 _parameters.append(type);
               }
             }
             PythonQtMethodInfo::PythonQtMethodInfo(const QByteArray& typeName, const QList<QByteArray>& args)
             {
               ParameterInfo type;
               fillParameterInfo(type, typeName, NULL);
               _parameters.append(type);
               foreach (const QByteArray& name, args) {
                 fillParameterInfo(type, name, NULL);
                 _parameters.append(type);
               }
             }
             const PythonQtMethodInfo* PythonQtMethodInfo::getCachedMethodInfo(const QMetaMethod& signal, PythonQtClassInfo* classInfo)
             {
               QByteArray sig(signal.signature());
               sig = sig.mid(sig.indexOf('('));
               QByteArray fullSig = QByteArray(signal.typeName()) + " " + sig;
               PythonQtMethodInfo* result = _cachedSignatures.value(fullSig);
               if (!result) {
                 result = new PythonQtMethodInfo(signal, classInfo);
                 _cachedSignatures.insert(fullSig, result);
               }
               return result;
             }
             const PythonQtMethodInfo* PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(int numArgs, const char** args)
             {
               QByteArray typeName = args[0];
               QList<QByteArray> arguments;
               QByteArray fullSig = typeName;
               fullSig += "(";
               for (int i =1;i<numArgs; i++) {
                 if (i>1) {
                   fullSig += ",";
                 }
                 QByteArray arg(args[i]);
                 fullSig += arg;
                 arguments << arg;
               }
               fullSig += ")";
               PythonQtMethodInfo* result = _cachedSignatures.value(fullSig);
               if (!result) {
                 result = new PythonQtMethodInfo(typeName, arguments);
                 _cachedSignatures.insert(fullSig, result);
               }
               return result;
             }
             void PythonQtMethodInfo::fillParameterInfo(ParameterInfo& type, const QByteArray& orgName, PythonQtClassInfo* classInfo)
             {
               QByteArray name = orgName;
               type.enumWrapper = NULL;
               int len = name.length();
               if (len>0) {
                 if (strncmp(name.constData(), "const ", 6)==0) {
                   name = name.mid(6);
                   len -= 6;
                   type.isConst = true;
                 } else {
                   type.isConst = false;
                 }
                 char pointerCount = 0;
                 bool hadReference = false;
                 // remove * and & from the end of the string, handle & and * the same way
                 while (name.at(len-1) == '*') {
                   len--;
                   pointerCount++;
                 }
                 while (name.at(len-1) == '&') {
                   len--;
                   hadReference = true;
                 }
                 if (len!=name.length()) {
                   name = name.left(len);
                 }
                 type.pointerCount = pointerCount;
                 QByteArray alias = _parameterNameAliases.value(name);
                 if (!alias.isEmpty()) {
                   name = alias;
                 }
                 type.typeId = nameToType(name);
                 if ((type.pointerCount == 0) && type.typeId == Unknown) {
                   type.typeId = QMetaType::type(name.constData());
                   if (type.typeId == QMetaType::Void) {
                     type.typeId = Unknown;
                   }
                 }
                 type.name = name;
                 if (type.typeId == PythonQtMethodInfo::Unknown || type.typeId >= QMetaType::User) {
                   bool isLocalEnum;
                   // TODOXXX: make use of this flag!
                   type.enumWrapper = PythonQtClassInfo::findEnumWrapper(type.name, classInfo, &isLocalEnum);
                 }
               } else {
                 type.typeId = QMetaType::Void;
                 type.pointerCount = 0;
                 type.isConst = false;
               }
             }
             int PythonQtMethodInfo::nameToType(const char* name)
             {
               if (_parameterTypeDict.isEmpty()) {
                 // we could also use QMetaType::nameToType, but that does a string compare search
                 // and does not support QVariant
                 // QMetaType names
                 _parameterTypeDict.insert("long", QMetaType::Long);
                 _parameterTypeDict.insert("int", QMetaType::Int);
                 _parameterTypeDict.insert("short", QMetaType::Short);
                 _parameterTypeDict.insert("char", QMetaType::Char);
                 _parameterTypeDict.insert("ulong", QMetaType::ULong);
                 _parameterTypeDict.insert("unsigned long", QMetaType::ULong);
                 _parameterTypeDict.insert("uint", QMetaType::UInt);
                 _parameterTypeDict.insert("unsigned int", QMetaType::UInt);
                 _parameterTypeDict.insert("ushort", QMetaType::UShort);
                 _parameterTypeDict.insert("unsigned short", QMetaType::UShort);
                 _parameterTypeDict.insert("uchar", QMetaType::UChar);
                 _parameterTypeDict.insert("unsigned char", QMetaType::UChar);
                 _parameterTypeDict.insert("bool", QMetaType::Bool);
                 _parameterTypeDict.insert("float", QMetaType::Float);
                 _parameterTypeDict.insert("double", QMetaType::Double);
                 _parameterTypeDict.insert("qreal", QMetaType::Double);
                 _parameterTypeDict.insert("QChar", QMetaType::QChar);
                 _parameterTypeDict.insert("QByteArray", QMetaType::QByteArray);
                 _parameterTypeDict.insert("QString", QMetaType::QString);
                 _parameterTypeDict.insert("", QMetaType::Void);
                 _parameterTypeDict.insert("void", QMetaType::Void);
+                // GL types
+                _parameterTypeDict.insert("GLenum", QMetaType::UInt);
+                _parameterTypeDict.insert("GLboolean", QMetaType::UChar);
+                _parameterTypeDict.insert("GLbitfield", QMetaType::UInt);
+                _parameterTypeDict.insert("GLbyte", QMetaType::Char);
+                _parameterTypeDict.insert("GLubyte", QMetaType::UChar);
+                _parameterTypeDict.insert("GLshort", QMetaType::Short);
+                _parameterTypeDict.insert("GLushort", QMetaType::UShort);
+                _parameterTypeDict.insert("GLint", QMetaType::Int);
+                _parameterTypeDict.insert("GLuint", QMetaType::UInt);
+                _parameterTypeDict.insert("GLsizei", QMetaType::UInt);
+                _parameterTypeDict.insert("GLclampf", QMetaType::Float);
+                _parameterTypeDict.insert("GLfloat", QMetaType::Float);
+                _parameterTypeDict.insert("GLclampd", QMetaType::Double);
+                _parameterTypeDict.insert("GLdouble", QMetaType::Double);
+                _parameterTypeDict.insert("GLvoid", QMetaType::Void);
+                if (QT_POINTER_SIZE == 8) {
+                  _parameterTypeDict.insert("qgl_GLintptr", QMetaType::LongLong);
+                  _parameterTypeDict.insert("qgl_GLsizeiptr", QMetaType::LongLong);
+                } else {
+                  _parameterTypeDict.insert("qgl_GLintptr", QMetaType::Int);
+                  _parameterTypeDict.insert("qgl_GLsizeiptr", QMetaType::Int);
+                }
                 // QVariant names
                 _parameterTypeDict.insert("Q_LLONG", QMetaType::LongLong);
                 _parameterTypeDict.insert("Q_ULLONG", QMetaType::ULongLong);
                 _parameterTypeDict.insert("qlonglong", QMetaType::LongLong);
                 _parameterTypeDict.insert("qulonglong", QMetaType::ULongLong);
                 _parameterTypeDict.insert("qint64", QMetaType::LongLong);
                 _parameterTypeDict.insert("quint64", QMetaType::ULongLong);
                 _parameterTypeDict.insert("QVariantMap", QMetaType::QVariantMap);
                 _parameterTypeDict.insert("QVariantList", QMetaType::QVariantList);
                 _parameterTypeDict.insert("QMap<QString,QVariant>", QMetaType::QVariantMap);
                 _parameterTypeDict.insert("QList<QVariant>", QMetaType::QVariantList);
                 _parameterTypeDict.insert("QStringList", QMetaType::QStringList);
                 _parameterTypeDict.insert("QBitArray", QMetaType::QBitArray);
                 _parameterTypeDict.insert("QDate", QMetaType::QDate);
                 _parameterTypeDict.insert("QTime", QMetaType::QTime);
                 _parameterTypeDict.insert("QDateTime", QMetaType::QDateTime);
                 _parameterTypeDict.insert("QUrl", QMetaType::QUrl);
                 _parameterTypeDict.insert("QLocale", QMetaType::QLocale);
                 _parameterTypeDict.insert("QRect", QMetaType::QRect);
                 _parameterTypeDict.insert("QRectF", QMetaType::QRectF);
                 _parameterTypeDict.insert("QSize", QMetaType::QSize);
                 _parameterTypeDict.insert("QSizeF", QMetaType::QSizeF);
                 _parameterTypeDict.insert("QLine", QMetaType::QLine);
                 _parameterTypeDict.insert("QLineF", QMetaType::QLineF);
                 _parameterTypeDict.insert("QPoint", QMetaType::QPoint);
                 _parameterTypeDict.insert("QPointF", QMetaType::QPointF);
                 _parameterTypeDict.insert("QRegExp", QMetaType::QRegExp);
                 _parameterTypeDict.insert("QFont", QMetaType::QFont);
                 _parameterTypeDict.insert("QPixmap", QMetaType::QPixmap);
                 _parameterTypeDict.insert("QBrush", QMetaType::QBrush);
                 _parameterTypeDict.insert("QColor", QMetaType::QColor);
                 _parameterTypeDict.insert("QCursor", QMetaType::QCursor);
                 _parameterTypeDict.insert("QPalette", QMetaType::QPalette);
                 _parameterTypeDict.insert("QIcon", QMetaType::QIcon);
                 _parameterTypeDict.insert("QImage", QMetaType::QImage);
                 _parameterTypeDict.insert("QRegion", QMetaType::QRegion);
                 _parameterTypeDict.insert("QBitmap", QMetaType::QBitmap);
                 _parameterTypeDict.insert("QSizePolicy", QMetaType::QSizePolicy);
                 _parameterTypeDict.insert("QKeySequence", QMetaType::QKeySequence);
                 _parameterTypeDict.insert("QPen", QMetaType::QPen);
                 _parameterTypeDict.insert("QTextLength", QMetaType::QTextLength);
                 _parameterTypeDict.insert("QTextFormat", QMetaType::QTextFormat);
                 _parameterTypeDict.insert("QMatrix", QMetaType::QMatrix);
                 _parameterTypeDict.insert("QVariant", PythonQtMethodInfo::Variant);
                 // own special types... (none so far, could be e.g. ObjectList
               }
               QHash<QByteArray, int>::const_iterator it = _parameterTypeDict.find(name);
               if (it!=_parameterTypeDict.end()) {
                 return it.value();
               } else {
                 return PythonQtMethodInfo::Unknown;
               }
             }
             void PythonQtMethodInfo::cleanupCachedMethodInfos()
             {
               QHashIterator<QByteArray, PythonQtMethodInfo *> i(_cachedSignatures);
               while (i.hasNext()) {
                 delete i.next().value();
               }
             }
             void PythonQtMethodInfo::addParameterTypeAlias(const QByteArray& alias, const QByteArray& name)
             {
               _parameterNameAliases.insert(alias, name);
             }
             //-------------------------------------------------------------------------------------------------
             void PythonQtSlotInfo::deleteOverloadsAndThis()
             {
               PythonQtSlotInfo* cur = this;
               while(cur->nextInfo()) {
                 PythonQtSlotInfo* next = cur->nextInfo();
                 delete cur;
                 cur = next;
               }
             }
             QString PythonQtSlotInfo::fullSignature()
             {
               bool skipFirstArg = isInstanceDecorator();
               QString result = _meta.typeName();
               QByteArray sig = slotName();
               QList<QByteArray> names = _meta.parameterNames();
               bool isStatic = false;
               bool isConstructor = false;
               bool isDestructor = false;
               if (_type == ClassDecorator) {
                 if (sig.startsWith("new_")) {
                   sig = sig.mid(4);
                   isConstructor = true;
                 } else if (sig.startsWith("delete_")) {
                   sig = sig.mid(7);
                   isDestructor = true;
                 } else if(sig.startsWith("static_")) {
                   isStatic = true;
                   sig = sig.mid(7);
                   int idx = sig.indexOf("_");
                   if (idx>=0) {
                     sig = sig.mid(idx+1);
                   }
                 }
               }
               result += QByteArray(" ") + sig;
               result += "(";
               int lastEntry = _parameters.count()-1;
               for (int i = skipFirstArg?2:1; i<_parameters.count(); i++) {
                 if (_parameters.at(i).isConst) {
                   result += "const ";
                 }
                 result += _parameters.at(i).name;
                 if (_parameters.at(i).pointerCount) {
                   QByteArray stars;
                   stars.fill('*', _parameters.at(i).pointerCount);
                   result += stars;
                 }
                 if (!names.at(i-1).isEmpty()) {
                   result += " ";
                   result += names.at(i-1);
                 }
                 if (i!=lastEntry) {
                   result += ", ";
                 }
               }
               result += ")";
               if (isStatic) {
                 result = QString("static ") + result;
               }
               if (isConstructor) {
             //    result = QString("constructor ") + result;
               }
               if (isDestructor) {
                 result = QString("~") + result;
               }
               return result;
             }
             QByteArray PythonQtSlotInfo::slotName()
             {
               QByteArray sig(_meta.signature());
               int idx = sig.indexOf('(');
               sig = sig.left(idx);
               return sig;
             }

src/PythonQtSignalReceiver.cpp +41 -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    PythonQtSignalReceiver.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtSignalReceiver.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtMethodInfo.h"
             #include "PythonQtConversion.h"
             #include <QMetaObject>
             #include <QMetaMethod>
             #include "funcobject.h"
+            // use -2 to signal that the variable is uninitialized
+            int PythonQtSignalReceiver::_destroyedSignal1Id = -2;
+            int PythonQtSignalReceiver::_destroyedSignal2Id = -2;
             void PythonQtSignalTarget::call(void **arguments) const {
               PyObject* result = call(_callable, methodInfo(), arguments);
               if (result) {
                 Py_DECREF(result);
               }
             }
             PyObject* PythonQtSignalTarget::call(PyObject* callable, const PythonQtMethodInfo* methodInfos, void **arguments, bool skipFirstArgumentOfMethodInfo)
             {
               Q_UNUSED(skipFirstArgumentOfMethodInfo)
               // Note: we check if the callable is a PyFunctionObject and has a fixed number of arguments
               // if that is the case, we only pass these arguments to python and skip the additional arguments from the signal
               int numPythonArgs = -1;
               if (PyFunction_Check(callable)) {
                 PyObject* o = callable;
                 PyFunctionObject* func = (PyFunctionObject*)o;
                 PyCodeObject* code = (PyCodeObject*)func->func_code;
                 if (!(code->co_flags & CO_VARARGS)) {
                   numPythonArgs = code->co_argcount;
                 } else {
                   // variable numbers of arguments allowed
                 }
               } else if (PyMethod_Check(callable)) {
                 PyObject* o = callable;
                 PyMethodObject* method = (PyMethodObject*)o;
                 if (PyFunction_Check(method->im_func)) {
                   PyFunctionObject* func = (PyFunctionObject*)method->im_func;
                   PyCodeObject* code = (PyCodeObject*)func->func_code;
                   if (!(code->co_flags & CO_VARARGS)) {
                     numPythonArgs = code->co_argcount - 1; // we subtract one because the first is "self"
                   } else {
                     // variable numbers of arguments allowed
                   }
                 }
               }
               const PythonQtMethodInfo* m = methodInfos;
               // parameterCount includes return value:
               int count = m->parameterCount();
               if (numPythonArgs!=-1) {
                 if (count>numPythonArgs+1) {
                   // take less arguments
                   count = numPythonArgs+1;
                 }
               }
               PyObject* pargs = NULL;
               if (count>1) {
                 pargs = PyTuple_New(count-1);
               }
               bool err = false;
               // transform Qt values to Python
               const QList<PythonQtMethodInfo::ParameterInfo>& params = m->parameters();
               for (int i = 1; i < count; i++) {
                 const PythonQtMethodInfo::ParameterInfo& param = params.at(i);
                 PyObject* arg = PythonQtConv::ConvertQtValueToPython(param, arguments[i]);
                 if (arg) {
                   // steals reference, no unref
                   PyTuple_SetItem(pargs, i-1,arg);
                 } else {
                   err = true;
                   break;
                 }
               }
               PyObject* result = NULL;
               if (!err) {
                 PyErr_Clear();
                 result = PyObject_CallObject(callable, pargs);
                 if (result) {
                   // ok
                 } else {
                   PythonQt::self()->handleError();
                 }
               }
               if (pargs) {
                 // free the arguments again
                 Py_DECREF(pargs);
               }
               return result;
             }
             bool PythonQtSignalTarget::isSame( int signalId, PyObject* callable ) const
             {
               return PyObject_Compare(callable, _callable) == 0 && signalId==_signalId;
             }
             //------------------------------------------------------------------------------
             PythonQtSignalReceiver::PythonQtSignalReceiver(QObject* obj):PythonQtSignalReceiverBase(obj)
             {
+              if (_destroyedSignal1Id == -2) {
+                // initialize these once
+                _destroyedSignal1Id = QObject::staticMetaObject.indexOfSignal("destroyed()");
+                _destroyedSignal2Id = QObject::staticMetaObject.indexOfSignal("destroyed(QObject*)");
+                if (_destroyedSignal1Id == -1 || _destroyedSignal2Id == -1) {
+                  std::cerr << "PythonQt: could not find destroyed signal index, should never happen!" << std::endl;
+                }
+              }
+              _destroyedSignalCount = 0;
               _obj = obj;
               // fetch the class info for object, since we will need to for correct enum resolution in
               // signals
               _objClassInfo = PythonQt::priv()->getClassInfo(obj->metaObject());
               if (!_objClassInfo || !_objClassInfo->isQObject()) {
                 PythonQt::self()->registerClass(obj->metaObject());
                 _objClassInfo = PythonQt::priv()->getClassInfo(obj->metaObject());
               }
               // force decorator/enum creation
               _objClassInfo->decorator();
               _slotCount = staticMetaObject.methodOffset();
             }
             PythonQtSignalReceiver::~PythonQtSignalReceiver()
             {
               PythonQt::priv()->removeSignalEmitter(_obj);
             }
             bool PythonQtSignalReceiver::addSignalHandler(const char* signal, PyObject* callable)
             {
               bool flag = false;
               int sigId = getSignalIndex(signal);
               if (sigId>=0) {
                 // create PythonQtMethodInfo from signal
                 QMetaMethod meta = _obj->metaObject()->method(sigId);
                 const PythonQtMethodInfo* signalInfo = PythonQtMethodInfo::getCachedMethodInfo(meta, _objClassInfo);
                 PythonQtSignalTarget t(sigId, signalInfo, _slotCount, callable);
                 _targets.append(t);
                 // now connect to ourselves with the new slot id
                 QMetaObject::connect(_obj, sigId, this, _slotCount, Qt::AutoConnection, 0);
                 _slotCount++;
                 flag = true;
+                if (sigId == _destroyedSignal1Id || sigId == _destroyedSignal2Id) {
+                  _destroyedSignalCount++;
+                  if (_destroyedSignalCount==1) {
+                    // make ourself parent of PythonQt, to not get deleted as a child of the QObject we are
+                    // listening to, since we do that manually when we receive the destroyed signal
+                    this->setParent(PythonQt::priv());
+                  }
+                }
               }
               return flag;
             }
             bool PythonQtSignalReceiver::removeSignalHandler(const char* signal, PyObject* callable)
             {
-              bool found = false;
+              int foundCount = 0;
               int sigId = getSignalIndex(signal);
               if (sigId>=0) {
                 QMutableListIterator<PythonQtSignalTarget> i(_targets);
                 if (callable) {
                   while (i.hasNext()) {
                     if (i.next().isSame(sigId, callable)) {
                       i.remove();
-                      found = true;
+                      foundCount++;
                       break;
                     }
                   }
                 } else {
                   while (i.hasNext()) {
                     if (i.next().signalId() == sigId) {
                       i.remove();
-                      found = true;
+                      foundCount++;
                     }
                   }
                 }
               }
-              return found;
+              if ((foundCount>0) && (sigId == _destroyedSignal1Id) || (sigId == _destroyedSignal2Id)) {
+                _destroyedSignalCount -= foundCount;
+                if (_destroyedSignalCount==0) {
+                  // make ourself child of QObject again, to get deleted when the object gets deleted
+                  this->setParent(_obj);
                 }
+              }
-            void PythonQtSignalReceiver::removeSignalHandlers()
+              return foundCount>0;
-              _targets.clear();
             }
             int PythonQtSignalReceiver::getSignalIndex(const char* signal)
             {
               int sigId = _obj->metaObject()->indexOfSignal(signal+1);
               if (sigId<0) {
                 QByteArray tmpSig = QMetaObject::normalizedSignature(signal+1);
                 sigId = _obj->metaObject()->indexOfSignal(tmpSig);
               }
               return sigId;
             }
             int PythonQtSignalReceiver::qt_metacall(QMetaObject::Call c, int id, void **arguments)
             {
             //  mlabDebugConst("PythonQt", "PythonQtSignalReceiver invoke " << _obj->className() << " " << _obj->name() << " " << id);
               if (c != QMetaObject::InvokeMetaMethod) {
                 QObject::qt_metacall(c, id, arguments);
               }
-              bool found = false;
               foreach(const PythonQtSignalTarget& t, _targets) {
                 if (t.slotId() == id) {
-                  found = true;
                   t.call(arguments);
+                  // if the signal is the last destroyed signal, we delete ourselves
+                  int sigId = t.signalId();
+                  if ((sigId == _destroyedSignal1Id) || (sigId == _destroyedSignal2Id)) {
+                    _destroyedSignalCount--;
+                    if (_destroyedSignalCount == 0) {
+                      delete this;
+                    }
+                  }
                   break;
                 }
               }
               return 0;
             }

src/PythonQtSignalReceiver.h +4 -3

             #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 "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 for given callable (or all callables on that signal if callable is NULL)
               bool removeSignalHandler(const char* signal, PyObject* callable = NULL);
-              //! 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;
+              int _destroyedSignalCount;
               // linear list may get slow on multiple targets, but I think typically we have many objects and just a few signals
               QList<PythonQtSignalTarget> _targets;
+              static int _destroyedSignal1Id;
+              static int _destroyedSignal2Id;
             };
             #endif

src/PythonQtStdDecorators.cpp +7 -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    PythonQtStdDecorators.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2007-04
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtStdDecorators.h"
             #include "PythonQt.h"
             #include "PythonQtClassInfo.h"
             #include <QCoreApplication>
             bool PythonQtStdDecorators::connect(QObject* sender, const QByteArray& signal, PyObject* callable)
             {
               bool result = false;
               QByteArray signalTmp;
               char first = signal.at(0);
               if (first>='0' && first<='9') {
                 signalTmp = signal;
               } else {
                 signalTmp = "2" + signal;
               }
               if (sender) {
                 result = PythonQt::self()->addSignalHandler(sender, signalTmp, callable);
                 if (!result) {
                   if (sender->metaObject()->indexOfSignal(QMetaObject::normalizedSignature(signalTmp.constData()+1)) == -1) {
                     qWarning("PythonQt: QObject::connect() signal '%s' does not exist on %s", signal.constData(), sender->metaObject()->className());
                   }
                 }
               }
               return result;
             }
-            bool PythonQtStdDecorators::connect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot)
+            bool PythonQtStdDecorators::connect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot, Qt::ConnectionType type)
             {
               bool r = false;
               if (sender && receiver) {
                 QByteArray signalTmp;
                 char first = signal.at(0);
                 if (first>='0' && first<='9') {
                   signalTmp = signal;
                 } else {
                   signalTmp = "2" + signal;
                 }
                 QByteArray slotTmp;
                 first = slot.at(0);
                 if (first>='0' && first<='9') {
                   slotTmp = slot;
                 } else {
                   slotTmp = "1" + slot;
                 }
-                r = QObject::connect(sender, signalTmp, receiver, slotTmp);
+                r = QObject::connect(sender, signalTmp, receiver, slotTmp, type);
               }
               return r;
             }
             bool PythonQtStdDecorators::disconnect(QObject* sender, const QByteArray& signal, PyObject* callable)
             {
               bool result = false;
               QByteArray signalTmp;
               char first = signal.at(0);
               if (first>='0' && first<='9') {
                 signalTmp = signal;
               } else {
                 signalTmp = "2" + signal;
               }
               if (sender) {
                 result = PythonQt::self()->removeSignalHandler(sender, signalTmp, callable);
                 if (callable == NULL) {
                   result |= QObject::disconnect(sender, signalTmp, NULL, NULL);
                 }
                 if (!result) {
                   if (sender->metaObject()->indexOfSignal(QMetaObject::normalizedSignature(signalTmp.constData()+1)) == -1) {
                     qWarning("PythonQt: QObject::disconnect() signal '%s' does not exist on %s", signal.constData(), sender->metaObject()->className());
                   }
                 }
               }
               return result;
             }
             bool PythonQtStdDecorators::disconnect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot)
             {
               bool r = false;
               if (sender && receiver) {
                 QByteArray signalTmp;
                 char first = signal.at(0);
                 if (first>='0' && first<='9') {
                   signalTmp = signal;
                 } else {
                   signalTmp = "2" + signal;
                 }
                 QByteArray slotTmp;
                 first = slot.at(0);
                 if (first>='0' && first<='9') {
                   slotTmp = slot;
                 } else {
                   slotTmp = "1" + slot;
                 }
                 r = QObject::disconnect(sender, signalTmp, receiver, slotTmp);
               }
               return r;
             }
             QObject* PythonQtStdDecorators::parent(QObject* o) {
               return o->parent();
             }
             void PythonQtStdDecorators::setParent(QObject* o, QObject* parent)
             {
               o->setParent(parent);
             }
             const QObjectList* PythonQtStdDecorators::children(QObject* o)
             {
               return &o->children();
             }
             bool PythonQtStdDecorators::setProperty(QObject* o, const char* name, const QVariant& value)
             {
               return o->setProperty(name, value);
             }
             QVariant PythonQtStdDecorators::property(QObject* o, const char* name)
             {
               return o->property(name);
             }
             QString PythonQtStdDecorators::tr(QObject* obj, const QByteArray& text, const QByteArray& ambig, int n)
             {
               return QCoreApplication::translate(obj->metaObject()->className(), text.constData(), ambig.constData(), QCoreApplication::CodecForTr, n);
             }
             QObject* PythonQtStdDecorators::findChild(QObject* parent, PyObject* type, const QString& name)
             {
               const QMetaObject* meta = NULL;
               const char* typeName = NULL;
               if (PyObject_TypeCheck(type, &PythonQtClassWrapper_Type)) {
                 meta = ((PythonQtClassWrapper*)type)->classInfo()->metaObject();
               } else if (PyObject_TypeCheck(type, &PythonQtInstanceWrapper_Type)) {
                 meta = ((PythonQtInstanceWrapper*)type)->classInfo()->metaObject();
               } else if (PyString_Check(type)) {
                 typeName = PyString_AsString(type);
               }
               if (!typeName && !meta)
                 return NULL;
               return findChild(parent, typeName, meta, name);
             }
             QList<QObject*> PythonQtStdDecorators::findChildren(QObject* parent, PyObject* type, const QString& name)
             {
               const QMetaObject* meta = NULL;
               const char* typeName = NULL;
               if (PyObject_TypeCheck(type, &PythonQtClassWrapper_Type)) {
                 meta = ((PythonQtClassWrapper*)type)->classInfo()->metaObject();
               } else if (PyObject_TypeCheck(type, &PythonQtInstanceWrapper_Type)) {
                 meta = ((PythonQtInstanceWrapper*)type)->classInfo()->metaObject();
               } else if (PyString_Check(type)) {
                 typeName = PyString_AsString(type);
               }
               QList<QObject*> list;
               if (!typeName && !meta)
                 return list;
               findChildren(parent, typeName, meta, name, list);
               return list;
             }
             QList<QObject*> PythonQtStdDecorators::findChildren(QObject* parent, PyObject* type, const QRegExp& regExp)
             {
               const QMetaObject* meta = NULL;
               const char* typeName = NULL;
               if (PyObject_TypeCheck(type, &PythonQtClassWrapper_Type)) {
                 meta = ((PythonQtClassWrapper*)type)->classInfo()->metaObject();
               } else if (PyObject_TypeCheck(type, &PythonQtInstanceWrapper_Type)) {
                 meta = ((PythonQtInstanceWrapper*)type)->classInfo()->metaObject();
               } else if (PyString_Check(type)) {
                 typeName = PyString_AsString(type);
               }
               QList<QObject*> list;
               if (!typeName && !meta)
                 return list;
               findChildren(parent, typeName, meta, regExp, list);
               return list;
             }
             QObject* PythonQtStdDecorators::findChild(QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name)
             {
               const QObjectList &children = parent->children();
               int i;
               for (i = 0; i < children.size(); ++i) {
                 QObject* obj = children.at(i);
                 if (!obj)
                   return NULL;
                 // Skip if the name doesn't match.
                 if (!name.isNull() && obj->objectName() != name)
                   continue;
                 if ((typeName && obj->inherits(typeName)) ||
                   (meta && meta->cast(obj)))
                   return obj;
               }
               for (i = 0; i < children.size(); ++i) {
                 QObject* obj = findChild(children.at(i), typeName, meta, name);
                 if (obj != NULL)
                   return obj;
               }
               return NULL;
             }
             int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QString& name, QList<QObject*>& list)
             {
               const QObjectList& children = parent->children();
               int i;
               for (i = 0; i < children.size(); ++i) {
                 QObject* obj = children.at(i);
                 if (!obj)
                   return -1;
                 // Skip if the name doesn't match.
                 if (!name.isNull() && obj->objectName() != name)
                   continue;
                 if ((typeName && obj->inherits(typeName)) ||
                   (meta && meta->cast(obj))) {
                     list += obj;
                 }
                 if (findChildren(obj, typeName, meta, name, list) < 0)
                   return -1;
               }
               return 0;
             }
             int PythonQtStdDecorators::findChildren(QObject* parent, const char* typeName, const QMetaObject* meta, const QRegExp& regExp, QList<QObject*>& list)
             {
               const QObjectList& children = parent->children();
               int i;
               for (i = 0; i < children.size(); ++i) {
                 QObject* obj = children.at(i);
                 if (!obj)
                   return -1;
                 // Skip if the name doesn't match.
                 if (regExp.indexIn(obj->objectName()) == -1)
                   continue;
                 if ((typeName && obj->inherits(typeName)) ||
                   (meta && meta->cast(obj))) {
                     list += obj;
                 }
                 if (findChildren(obj, typeName, meta, regExp, list) < 0)
                   return -1;
               }
               return 0;
             }
+            const QMetaObject* PythonQtStdDecorators::metaObject( QObject* obj )
+            {
+              return obj->metaObject();
+            }
  No newline at end of file

src/PythonQtStdDecorators.h +51 -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 <QObject>
             #include <QVariantList>
             #include <QTextDocument>
             #include <QColor>
             #include <QDateTime>
             #include <QDate>
             #include <QTime>
+            #include <QImage>
+            #include <QMetaMethod>
+            #include <QMetaEnum>
+            #include <QMetaProperty>
             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 connect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot,  Qt::ConnectionType type = Qt::AutoConnection);
+              bool connect(QObject* receiver, QObject* sender, const QByteArray& signal, const QByteArray& slot,  Qt::ConnectionType type = Qt::AutoConnection) { return connect(sender, signal, receiver, slot, type); }
+              bool static_QObject_connect(QObject* sender, const QByteArray& signal, PyObject* callable) { return connect(sender, signal, callable); }
+              bool static_QObject_connect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot,  Qt::ConnectionType type = Qt::AutoConnection)  { return connect(sender, signal, receiver, slot, type); }
               bool disconnect(QObject* sender, const QByteArray& signal, PyObject* callable = NULL);
               bool disconnect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot);
+              bool static_QObject_disconnect(QObject* sender, const QByteArray& signal, PyObject* callable = NULL) { return disconnect(sender, signal, callable); }
+              bool static_QObject_disconnect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot) { return connect(sender, signal, receiver, slot); }
+              const QMetaObject* metaObject( QObject* obj );
               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);
             };
+            class PythonQtWrapper_QMetaObject : public QObject
+            {
+              Q_OBJECT
+            public slots:
+              const char *className(QMetaObject* obj) const { return obj->className(); }
+              const QMetaObject *superClass(QMetaObject* obj) const { return obj->superClass(); }
+              int methodOffset(QMetaObject* obj) const { return obj->methodOffset(); }
+              int enumeratorOffset(QMetaObject* obj) const { return obj->enumeratorOffset(); }
+              int propertyOffset(QMetaObject* obj) const { return obj->propertyOffset(); }
+              int classInfoOffset(QMetaObject* obj) const { return obj->classInfoOffset(); }
+              int constructorCount(QMetaObject* obj) const { return obj->constructorCount(); }
+              int methodCount(QMetaObject* obj) const { return obj->methodCount(); }
+              int enumeratorCount(QMetaObject* obj) const { return obj->enumeratorCount(); }
+              int propertyCount(QMetaObject* obj) const { return obj->propertyCount(); }
+              int classInfoCount(QMetaObject* obj) const { return obj->classInfoCount(); }
+              int indexOfConstructor(QMetaObject* obj, const char *constructor) const { return obj->indexOfConstructor(constructor); }
+              int indexOfMethod(QMetaObject* obj, const char *method) const { return obj->indexOfMethod(method); }
+              int indexOfSignal(QMetaObject* obj, const char *signal) const { return obj->indexOfSignal(signal); }
+              int indexOfSlot(QMetaObject* obj, const char *slot) const { return obj->indexOfSlot(slot); }
+              int indexOfEnumerator(QMetaObject* obj, const char *name) const { return obj->indexOfEnumerator(name); }
+              int indexOfProperty(QMetaObject* obj, const char *name) const { return obj->indexOfProperty(name); }
+              int indexOfClassInfo(QMetaObject* obj, const char *name) const { return obj->indexOfClassInfo(name); }
+              QMetaMethod constructor(QMetaObject* obj, int index) const { return obj->constructor(index); }
+              QMetaMethod method(QMetaObject* obj, int index) const { return obj->method(index); }
+              QMetaEnum enumerator(QMetaObject* obj, int index) const { return obj->enumerator(index); }
+              QMetaProperty property(QMetaObject* obj, int index) const { return obj->property(index); }
+              QMetaClassInfo classInfo(QMetaObject* obj, int index) const { return obj->classInfo(index); }
+              QMetaProperty userProperty(QMetaObject* obj) const { return obj->userProperty(); }
+              bool static_QMetaObject_checkConnectArgs(const char *signal, const char *method) { return QMetaObject::checkConnectArgs(signal, method); }
+              QByteArray static_QMetaObject_normalizedSignature(const char *method) { return QMetaObject::normalizedSignature(method); }
+              QByteArray static_QMetaObject_normalizedType(const char *type) { return QMetaObject::normalizedType(type); }
+            };
             #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