GIT_REPOSITORIES/LPP/PythonQt Commit - r18:44e5ff2700cb

- wrapped instances are now wrapped by class specific subtypes to facilitate future deriving from python...

florianlink -

r18:44e5ff2700cb

parent child

Context file:

r18:44e5ff2700cb

Collapse all files

src/PythonQt.cpp +91 -56

             /*
             *
             *  Copyright (C) 2006 MeVis Research GmbH 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 Research GmbH, Universitaetsallee 29,
             *  28359 Bremen, Germany or:
             *
             *  http://www.mevis.de
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQt.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQt.h"
             #include "PythonQtImporter.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtMethodInfo.h"
             #include "PythonQtSignalReceiver.h"
             #include "PythonQtConversion.h"
             #include "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(int flags)
             {
               if (!_self) {
                 _self = new PythonQt(flags);
               }
               PythonQtMethodInfo::addParameterTypeAlias("QObjectList", "QList<QObject*>");
               qRegisterMetaType<QList<QObject*> >("QList<void*>");
               PythonQtRegisterToolClassesTemplateConverter(int);
               PythonQtRegisterToolClassesTemplateConverter(float);
               PythonQtRegisterToolClassesTemplateConverter(double);
               // TODO: which other POD types should be available for QList etc.
               PythonQt::self()->addDecorators(new PythonQtStdDecorators());
               PythonQt::self()->registerCPPClass("Qt", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_Qt>);
               PythonQt::self()->registerCPPClass("QBitArray", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QBitArray>);
               PythonQt::self()->registerCPPClass("QDate", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QDate>);
               PythonQt::self()->registerCPPClass("QTime", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QTime>);
               PythonQt::self()->registerCPPClass("QDateTime", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QDateTime>);
               PythonQt::self()->registerCPPClass("QUrl", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QUrl>);
               PythonQt::self()->registerCPPClass("QLocale", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QLocale>);
               PythonQt::self()->registerCPPClass("QRect", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QRect>);
               PythonQt::self()->registerCPPClass("QRectF", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QRectF>);
               PythonQt::self()->registerCPPClass("QSize", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QSize>);
               PythonQt::self()->registerCPPClass("QSizeF", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QSizeF>);
               PythonQt::self()->registerCPPClass("QLine", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QLine>);
               PythonQt::self()->registerCPPClass("QLineF", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QLineF>);
               PythonQt::self()->registerCPPClass("QPoint", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QPoint>);
               PythonQt::self()->registerCPPClass("QPointF", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QPointF>);
               PythonQt::self()->registerCPPClass("QRegExp", "", "QtCore", PythonQtCreateObject<PythonQtWrapper_QRegExp>);
               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);
               PythonQt::self()->registerCPPClass("QFont", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QFont>);
               PythonQt::self()->registerCPPClass("QPixmap", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QPixmap>);
               PythonQt::self()->registerCPPClass("QBrush", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QBrush>);
               PythonQt::self()->registerCPPClass("QColor", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QColor>);
               PythonQt::self()->registerCPPClass("QPalette", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QPalette>);
               PythonQt::self()->registerCPPClass("QIcon", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QIcon>);
               PythonQt::self()->registerCPPClass("QImage", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QImage>);
               PythonQt::self()->registerCPPClass("QPolygon", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QPolygon>);
               PythonQt::self()->registerCPPClass("QRegion", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QRegion>);
               PythonQt::self()->registerCPPClass("QBitmap", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QBitmap>);
               PythonQt::self()->registerCPPClass("QCursor", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QCursor>);
               PythonQt::self()->registerCPPClass("QSizePolicy", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QSizePolicy>);
               PythonQt::self()->registerCPPClass("QKeySequence", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QKeySequence>);
               PythonQt::self()->registerCPPClass("QPen", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QPen>);
               PythonQt::self()->registerCPPClass("QTextLength", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QTextLength>);
               PythonQt::self()->registerCPPClass("QTextFormat", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QTextFormat>);
               PythonQt::self()->registerCPPClass("QMatrix", "", "QtGui", PythonQtCreateObject<PythonQtWrapper_QMatrix>);
               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);
             }
             void PythonQt::cleanup()
             {
               if (_self) {
                 delete _self;
                 _self = NULL;
               }
             }
             PythonQt::PythonQt(int flags)
             {
               _p = new PythonQtPrivate;
               _p->_initFlags = flags;
               _p->_PythonQtObjectPtr_metaId = qRegisterMetaType<PythonQtObjectPtr>("PythonQtObjectPtr");
               Py_SetProgramName("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);
-              // add our own python object types for qt objects
+              // according to Python docs, set the type late here, since it can not safely be stored in the struct when declaring it
-              if (PyType_Ready(&PythonQtInstanceWrapper_Type) < 0) {
+              PythonQtClassWrapper_Type.tp_base = &PyType_Type;
-                std::cerr << "could not initialize PythonQtInstanceWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
+              // add our own python object types for classes
-              Py_INCREF(&PythonQtInstanceWrapper_Type);
-              // add our own python object types for qt objects
               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);
               initPythonQtModule(flags & RedirectStdOut);
             }
             PythonQt::~PythonQt() {
               delete _p;
               _p = NULL;
             }
             PythonQtPrivate::~PythonQtPrivate() {
               delete _defaultImporter;
               _defaultImporter = NULL;
               {
                 QHashIterator<QByteArray, PythonQtSlotInfo *> i(_knownQtDecoratorSlots);
                 while (i.hasNext()) {
                   delete i.next().value();
                 }
               }
               {
                 QHashIterator<QByteArray, PythonQtClassInfo *> i(_knownQtClasses);
                 while (i.hasNext()) {
                   delete i.next().value();
                 }
               }
               {
                 QHashIterator<QByteArray, PythonQtClassInfo *> i(_knownQtWrapperClasses);
                 while (i.hasNext()) {
                   delete i.next().value();
                 }
               }
               {
                 QHashIterator<QByteArray, PythonQtSlotInfo *> i(_constructorSlots);
                 while (i.hasNext()) {
                   PythonQtSlotInfo* cur = i.next().value();
                   while(cur->nextInfo()) {
                     PythonQtSlotInfo* next = cur->nextInfo();
                     delete cur;
                     cur = next;
                   }
                   delete cur;
                 }
               }
               {
                 QHashIterator<QByteArray, PythonQtSlotInfo *> i(_destructorSlots);
                 while (i.hasNext()) {
                   PythonQtSlotInfo* cur = i.next().value();
                   while(cur->nextInfo()) {
                     PythonQtSlotInfo* next = cur->nextInfo();
                     delete cur;
                     cur = next;
                   }
                   delete cur;
                 }
               }
               PythonQtConv::global_valueStorage.clear();
               PythonQtConv::global_ptrStorage.clear();
               PythonQtConv::global_variantStorage.clear();
               PythonQtMethodInfo::cleanupCachedMethodInfos();
             }
             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)
             {
               _p->registerClass(metaobject, package, wrapperCreator);
             }
             void PythonQtPrivate::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator)
             {
               // we register all classes in the hierarchy
               const QMetaObject* m = metaobject;
               bool first = true;
               while (m) {
                 PythonQtClassInfo* info = _knownQtClasses.value(m->className());
                 if (!info) {
-                  info = new PythonQtClassInfo(m);
+                  info = createPythonQtClassInfo(m, NULL, package);
                   _knownQtClasses.insert(m->className(), info);
-                  PythonQtObjectPtr pack = packageByName(package);
-                  PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info);
-                  PyModule_AddObject(pack, m->className(), pyobj);
-                  if (package && strncmp(package,"Qt",2)==0) {
-                    // put all qt objects into Qt as well
-                    PythonQtObjectPtr pack = packageByName("Qt");
-                    PyModule_AddObject(pack, m->className(), pyobj);
                 }
                 if (first) {
                   first = false;
                   if (wrapperCreator) {
                     info->setDecoratorProvider(wrapperCreator);
                   }
                 }
                 m = m->superClass();
               }
             }
+            PythonQtClassInfo* PythonQtPrivate::createPythonQtClassInfo(const QMetaObject* meta, const char* cppClassName, const char* package)
+            {
+              PythonQtClassInfo* info = new PythonQtClassInfo(meta, cppClassName);
+              PythonQtObjectPtr pack = packageByName(package);
+              PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info, package);
+              PyModule_AddObject(pack, meta?meta->className():cppClassName, pyobj);
+              if (package && strncmp(package,"Qt",2)==0) {
+                // put all qt objects into Qt as well
+                PythonQtObjectPtr pack = packageByName("Qt");
+                PyModule_AddObject(pack, meta?meta->className():cppClassName, pyobj);
+              }
+              info->setPythonQtClassWrapper(pyobj);
+              return info;
+            }
             bool PythonQtPrivate::isEnumType(const QMetaObject* meta, const QByteArray& name) {
               int i = meta?meta->indexOfEnumerator(name.constData()):-1;
               if (i!=-1) {
                 return true;
               } else {
                 // look for scope
                 int scopePos = name.indexOf("::");
                 if (scopePos != -1) {
                   // slit into scope and enum name
                   QByteArray enumScope = name.mid(0,scopePos);
                   QByteArray enumName = name.mid(scopePos+2);
                   if (enumScope == "Qt") {
                     // special qt namespace case
                     return isEnumType(&staticQtMetaObject, enumName);
                   } else {
                     // look for known classes as scope
                     // TODO: Q_GADGETS are not yet handled
                     PythonQtClassInfo* info = _knownQtClasses.value(enumScope);
                     if (info) {
                       return isEnumType(info->metaObject(), enumName);
                     }
                   }
                 }
               }
               return false;
             }
             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 = _knownQtClasses.value(obj->metaObject()->className());
                 if (!classInfo) {
                   registerClass(obj->metaObject());
                   classInfo = _knownQtClasses.value(obj->metaObject()->className());
                 }
                 wrap = createNewPythonQtInstanceWrapper(obj, classInfo);
-                //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
+                //    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->_info->wrappedClassName().latin1());
+                //    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 = _knownQtClasses.value(name);
                 if (!info) {
                   // 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 = _knownQtClasses.value(qptr->metaObject()->className());
                   }
                 }
                 if (info) {
                   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 = _knownQtClasses.value(qptr->metaObject()->className());
                   }
                   wrap = createNewPythonQtInstanceWrapper(qptr, info);
-                  //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
+                  //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
                 } else {
                   // maybe it is a PyObject, which we can return directly
                   if (name == "PyObject") {
                     PyObject* p = (PyObject*)ptr;
                     Py_INCREF(p);
                     return p;
                   }
                     // 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;
                     }
                   }
                   PythonQtClassInfo* info = _knownQtWrapperClasses.value(name);
                   if (!info) {
-                    info = new PythonQtClassInfo(wrapper?wrapper->metaObject():NULL, name);
+                    registerCPPClass(name.constData());
-                    _knownQtWrapperClasses.insert(name, info);
+                    info = _knownQtWrapperClasses.value(name);
-                    PyModule_AddObject(_pythonQtModule, name, (PyObject*)createNewPythonQtClassWrapper(info));
-                  } else {
+                  if (wrapper && (info->metaObject() != wrapper->metaObject())) {
-                    if (wrapper && (info->metaObject() != wrapper->metaObject())) {
+                    info->setMetaObject(wrapper->metaObject());
-                      info->setMetaObject(wrapper->metaObject());
                   }
                   wrap = createNewPythonQtInstanceWrapper(wrapper, info, ptr);
-                  //          mlabDebugConst("MLABPython","new c++ wrapper added " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
+                  //          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->_info->wrappedClassName().latin1());
+                //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) {
-              PythonQtInstanceWrapper* result;
+              // call the associated class type to create a new instance...
-              result = (PythonQtInstanceWrapper *)PythonQtInstanceWrapper_Type.tp_new(&PythonQtInstanceWrapper_Type,
+              PythonQtInstanceWrapper* result = (PythonQtInstanceWrapper*)PyObject_Call(info->pythonQtClassWrapper(), dummyTuple(), NULL);
-                NULL, NULL);
               result->setQObject(obj);
-              result->_info = info;
               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) {
+            PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtClassInfo* info, const char* package) {
               PythonQtClassWrapper* result;
-              result = (PythonQtClassWrapper *)PythonQtClassWrapper_Type.tp_new(&PythonQtClassWrapper_Type,
-                NULL, NULL);
+              PyObject* className = PyString_FromString(info->className());
-              result->_info = info;
+              PyObject* baseClasses = PyTuple_New(1);
+              PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PythonQtInstanceWrapper_Type);
+              PyObject* typeDict = PyDict_New();
+              QByteArray moduleName("PythonQt");
+              if (package && strcmp(package, "")!=0) {
+                moduleName += ".";
+                moduleName += package;
+              }
+              PyDict_SetItemString(typeDict, "__module__", PyString_FromString(moduleName.constData()));
+              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);
+              //TODO XXX why is this incref needed? It looks like the types get garbage collected somehow?!
+              Py_INCREF((PyObject*)result);
               return result;
             }
             PythonQtSignalReceiver* PythonQt::getSignalReceiver(QObject* obj)
             {
               PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
               if (!r) {
                 r = new PythonQtSignalReceiver(obj);
                 _p->_signalReceivers.insert(obj, r);
               }
               return r;
             }
             bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
             {
               bool flag = false;
               PythonQtObjectPtr callable = lookupCallable(module, objectname);
               if (callable) {
                 PythonQtSignalReceiver* r = getSignalReceiver(obj);
                 flag = r->addSignalHandler(signal, callable);
                 if (!flag) {
                   // signal not found
                 }
               } else {
                 // callable not found
               }
               return flag;
             }
             bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
             {
               bool flag = false;
               PythonQtSignalReceiver* r = getSignalReceiver(obj);
               if (r) {
                 flag = r->addSignalHandler(signal, receiver);
               }
               return flag;
             }
             bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
             {
               bool flag = false;
               PythonQtObjectPtr callable = lookupCallable(module, objectname);
               if (callable) {
                 PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
                 if (r) {
                   flag = r->removeSignalHandler(signal, callable);
                 }
               } else {
                 // callable not found
               }
               return flag;
             }
             bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
             {
               bool flag = false;
               PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
               if (r) {
                 flag = r->removeSignalHandler(signal, receiver);
               }
               return flag;
             }
             PythonQtObjectPtr PythonQt::lookupCallable(PyObject* module, const QString& name)
             {
               PythonQtObjectPtr p = lookupObject(module, name);
               if (p) {
                 if (PyCallable_Check(p)) {
                   return p;
                 }
               }
               PyErr_Clear();
               return NULL;
             }
             PythonQtObjectPtr PythonQt::lookupObject(PyObject* module, const QString& name)
             {
               QStringList l = name.split('.');
               PythonQtObjectPtr p = module;
               PythonQtObjectPtr prev;
               QString s;
               QByteArray b;
               for (QStringList::ConstIterator i = l.begin(); i!=l.end() && p; ++i) {
                 prev = p;
                 b = (*i).toLatin1();
                 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__");
             }
             QVariant PythonQt::evalCode(PyObject* module, PyObject* pycode) {
               QVariant result;
               if (pycode) {
                 PyObject* r = PyEval_EvalCode((PyCodeObject*)pycode, PyModule_GetDict((PyObject*)module) , PyModule_GetDict((PyObject*)module));
                 if (r) {
                   result = PythonQtConv::PyObjToQVariant(r);
                   Py_DECREF(r);
                 } else {
                   handleError();
                 }
               } else {
                 handleError();
               }
               return result;
             }
             QVariant PythonQt::evalScript(PyObject* module, const QString& script, int start)
             {
               QVariant result;
               PythonQtObjectPtr p;
               p.setNewRef(PyRun_String(script.toLatin1().data(), start, PyModule_GetDict(module), PyModule_GetDict(module)));
               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* module, const QString& name, QObject* object)
             {
               PyModule_AddObject(module, name.toLatin1().data(), _p->wrapQObject(object));
             }
             void PythonQt::addVariable(PyObject* module, const QString& name, const QVariant& v)
             {
               PyModule_AddObject(module, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
             }
             void PythonQt::removeVariable(PyObject* module, const QString& name)
             {
               PyObject_DelAttrString(module, name.toLatin1().data());
             }
             QVariant PythonQt::getVariable(PyObject* module, const QString& objectname)
             {
               QVariant result;
               PythonQtObjectPtr obj = lookupObject(module, objectname);
               if (obj) {
                 result = PythonQtConv::PyObjToQVariant(obj);
               }
               return result;
             }
             QStringList PythonQt::introspection(PyObject* module, const QString& objectname, PythonQt::ObjectType type)
             {
               QStringList results;
               PythonQtObjectPtr object;
               if (objectname.isEmpty()) {
                 object = module;
               } else {
                 object = lookupObject(module, objectname);
                 if (!object && type == CallOverloads) {
                   PyObject* dict = lookupObject(module, "__builtins__");
                   if (dict) {
                     object = PyDict_GetItemString(dict, objectname.toLatin1().constData());
                   }
                 }
               }
               if (object) {
                 if (type == CallOverloads) {
                   if (PythonQtSlotFunction_Check(object)) {
                     PythonQtSlotFunctionObject* o = (PythonQtSlotFunctionObject*)object.object();
                     PythonQtSlotInfo* info = o->m_ml;
                     while (info) {
                       results << info->fullSignature(info->isInstanceDecorator());
                       info = info->nextInfo();
                     }
                   } else if (object->ob_type == &PythonQtClassWrapper_Type) {
                     PythonQtClassWrapper* o = (PythonQtClassWrapper*)object.object();
-                    PythonQtSlotInfo* info = o->_info->constructors();
+                    PythonQtSlotInfo* info = o->classInfo()->constructors();
                     while (info) {
                       results << info->fullSignature(false);
                       info = info->nextInfo();
                     }
                   } else {
                     //TODO: use pydoc!
                     PyObject* doc = PyObject_GetAttrString(object, "__doc__");
                     if (doc) {
                       results << PyString_AsString(doc);
                       Py_DECREF(doc);
                     }
                   }
                 } else {
                   PyObject* keys = 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);
                       value = PyObject_GetAttr(object, key);
                       if (!value) continue;
                       keystr = PyString_AsString(key);
                       static const QString underscoreStr("__tmp");
                       if (!keystr.startsWith(underscoreStr)) {
                         switch (type) {
                         case Anything:
                           results << keystr;
                           break;
                         case Class:
                           if (value->ob_type == &PyClass_Type) {
                             results << keystr;
                           }
                           break;
                         case Variable:
                           if (value->ob_type != &PyClass_Type
                             && value->ob_type != &PyCFunction_Type
                             && value->ob_type != &PyFunction_Type
                             && value->ob_type != &PyModule_Type
                             ) {
                             results << keystr;
                           }
                           break;
                         case Function:
                           if (value->ob_type == &PyFunction_Type ||
                             value->ob_type == &PyMethod_Type
                             ) {
                             results << keystr;
                           }
                           break;
                         case Module:
                           if (value->ob_type == &PyModule_Type) {
                             results << keystr;
                           }
                           break;
                         default:
                           std::cerr << "PythonQt: introspection: unknown case" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
                         }
                       }
                       Py_DECREF(value);
                     }
                     Py_DECREF(keys);
                   }
                 }
               }
               return results;
             }
             QVariant PythonQt::call(PyObject* module, const QString& name, const QVariantList& args)
             {
               QVariant r;
               PythonQtObjectPtr callable = lookupCallable(module, name);
               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();
                   PythonQtObjectPtr result;
                   result.setNewRef(PyObject_CallObject(callable, pargs));
                   if (result) {
                     // ok
                     r = PythonQtConv::PyObjToQVariant(result);
                   } else {
                     PythonQt::self()->handleError();
                   }
                 }
               }
               return r;
             }
             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)
             {
               PythonQtImport::init();
               _p->_importInterface = importInterface;
             }
             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::addConstructorHandler(PythonQtConstructorHandler* factory)
-              _p->_constructorHandlers.append(factory);
-            const QList<PythonQtConstructorHandler*>& PythonQt::constructorHandlers()
-              return _p->_constructorHandlers;
-            };
             //---------------------------------------------------------------------------------------------------
             PythonQtPrivate::PythonQtPrivate()
             {
               _importInterface = NULL;
               _defaultImporter = new PythonQtQFileImporter;
               _noLongerWrappedCB = NULL;
               _wrappedCB = NULL;
+              _currentClassInfoForClassWrapperCreation = NULL;
+            }
+            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) {
                  const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m);
                   if (qstrncmp(m.signature(), "new_", 4)==0) {
                     if ((decoTypes & ConstructorDecorator) == 0) continue;
                     // either it returns a * or a QVariant and the name starts with "new_"
                     bool isVariantReturn = info->parameters().at(0).typeId == PythonQtMethodInfo::Variant;
                     if ((info->parameters().at(0).isPointer || isVariantReturn)) {
                       QByteArray signature = m.signature();
                       QByteArray nameOfClass = signature.mid(4, signature.indexOf('(')-4);
                       PythonQtSlotInfo* prev = _constructorSlots.value(nameOfClass);
                       PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(m, i, o, PythonQtSlotInfo::ClassDecorator);
                       if (prev) {
                         newSlot->setNextInfo(prev->nextInfo());
                         prev->setNextInfo(newSlot);
                       } else {
                         _constructorSlots.insert(nameOfClass, 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);
                     PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(m, i, o, PythonQtSlotInfo::ClassDecorator);
                     _destructorSlots.insert(nameOfClass, 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('_'));
                     PythonQtSlotInfo* slotCopy = new PythonQtSlotInfo(m, i, o, PythonQtSlotInfo::ClassDecorator);
                     _knownQtDecoratorSlots.insert(nameOfClass, slotCopy);
                   } else {
                     if ((decoTypes & InstanceDecorator) == 0) continue;
                     if (info->parameters().count()>1) {
                       PythonQtMethodInfo::ParameterInfo p = info->parameters().at(1);
                       if (p.isPointer) {
                         PythonQtSlotInfo* slotCopy = new PythonQtSlotInfo(m, i, o, PythonQtSlotInfo::InstanceDecorator);
                         _knownQtDecoratorSlots.insert(p.name, slotCopy);
                       }
                     }
                   }
                 }
               }
             }
             void PythonQtPrivate::registerQObjectClassNames(const QStringList& names)
             {
               foreach(QString name, names) {
                 _knownQObjectClassNames.insert(name.toLatin1(), true);
               }
             }
             QList<PythonQtSlotInfo*> PythonQtPrivate::getDecoratorSlots(const QByteArray& className)
             {
               return _knownQtDecoratorSlots.values(className);
             }
             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)
             {
               emit PythonQt::self()->pythonStdOut(str);
             }
             void PythonQt::stdErrRedirectCB(const QString& str)
             {
               emit PythonQt::self()->pythonStdErr(str);
             }
             void PythonQt::setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb)
             {
               _p->_wrappedCB = cb;
             }
             void PythonQt::setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb)
             {
               _p->_noLongerWrappedCB = cb;
             }
             static PyMethodDef PythonQtMethods[] = {
               {NULL, NULL, 0, NULL}
             };
             void PythonQt::initPythonQtModule(bool redirectStdOut)
             {
               _p->_pythonQtModule.setNewRef(Py_InitModule("PythonQt", PythonQtMethods));
               if (redirectStdOut) {
                 PythonQtObjectPtr sys;
                 PythonQtObjectPtr out;
                 PythonQtObjectPtr err;
                 sys.setNewRef(PyImport_ImportModule("sys"));
                 // create a redirection object for stdout and stderr
                 out = PythonQtStdOutRedirectType.tp_new(&PythonQtStdOutRedirectType,NULL, NULL);
                 ((PythonQtStdOutRedirect*)out.object())->_cb = stdOutRedirectCB;
                 err = PythonQtStdOutRedirectType.tp_new(&PythonQtStdOutRedirectType,NULL, NULL);
                 ((PythonQtStdOutRedirect*)err.object())->_cb = stdErrRedirectCB;
                 // replace the built in file objects with our own objects
                 PyModule_AddObject(sys, "stdout", out);
                 PyModule_AddObject(sys, "stderr", err);
               }
             }
             void PythonQt::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator)
             {
               _p->registerCPPClass(typeName, parentTypeName, package, wrapperCreator);
             }
             void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator)
             {
               PythonQtClassInfo* info = _knownQtWrapperClasses.value(typeName);
               if (!info) {
-                info = new PythonQtClassInfo(NULL, typeName);
+                info = createPythonQtClassInfo(NULL, typeName, package);
                 _knownQtWrapperClasses.insert(typeName, info);
-                PythonQtObjectPtr pack = packageByName(package);
-                PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info);
-                PyModule_AddObject(pack, typeName, pyobj);
-                if (package && strncmp(package,"Qt",2)==0) {
-                  // put all qt objects into Qt as well
-                  PythonQtObjectPtr pack = packageByName("Qt");
-                  PyModule_AddObject(pack, typeName, pyobj);
               }
               if (parentTypeName) {
                 info->setWrappedParentClassName(parentTypeName);
               }
               if (wrapperCreator) {
                 info->setDecoratorProvider(wrapperCreator);
               }
             }
             PythonQtObjectPtr PythonQtPrivate::packageByName(const char* name)
             {
               if (name==NULL || name[0]==0) {
                 return _pythonQtModule;
               }
               PythonQtObjectPtr v = _packages.value(name);
               if (!v) {
                 v.setNewRef(PyImport_AddModule((QByteArray("PythonQt.") + name).constData()));
                 _packages.insert(name, v);
                 PyModule_AddObject(_pythonQtModule, name, v);
               }
               return v;
             }
             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 PythonQtPrivate::removeWrapperPointer(void* obj)
             {
               _wrappedObjects.remove(obj);
             }
+            void PythonQtPrivate::addWrapperPointer(void* obj, PythonQtInstanceWrapper* wrapper)
+            {
+              _wrappedObjects.insert(obj, wrapper);
+            }
             PythonQtInstanceWrapper* PythonQtPrivate::findWrapperAndRemoveUnused(void* obj)
             {
               PythonQtInstanceWrapper* wrap = _wrappedObjects.value(obj);
               if (wrap && !wrap->_wrappedPtr && wrap->_obj == NULL) {
                 // this is a wrapper whose QObject was already removed due to destruction
                 // so the obj pointer has to be a new QObject with the same address...
                 // we remove the old one and set the copy to NULL
                 wrap->_objPointerCopy = NULL;
                 removeWrapperPointer(obj);
                 wrap = NULL;
               }
               return wrap;
             }
             PythonQtObjectPtr PythonQtPrivate::createModule(const QString& name, PyObject* pycode)
             {
               PythonQtObjectPtr result;
               if (pycode) {
                 result.setNewRef(PyImport_ExecCodeModule((char*)name.toLatin1().data(), pycode));
               } else {
                 PythonQt::self()->handleError();
               }
               return result;
             }

src/PythonQt.h +15 -11

             #ifndef _PYTHONQT_H
             #define _PYTHONQT_H
             /*
              *
              *  Copyright (C) 2006 MeVis Research GmbH 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 Research GmbH, 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 <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 PythonQtConstructorHandler;
             class PythonQtQFileImporter;
             typedef void PythonQtQObjectWrappedCB(QObject* object);
             typedef void PythonQtQObjectNoLongerWrappedCB(QObject* object);
             //! callback to create a QObject lazyly
             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
             class PYTHONQT_EXPORT PythonQt : public QObject {
               Q_OBJECT
             public:
               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
               };
               //! initialize the python qt binding (flags are a or combination of InitFlags)
               static void init(int flags = IgnoreSiteModule | RedirectStdOut);
               //! cleanup
               static void cleanup();
               //! get the singleton instance
               static PythonQt* self() { return _self; }
               //-----------------------------------------------------------------------------
               // Public API:
               //! defines the object types for introspection
               enum ObjectType {
                 Class,
                 Function,
                 Variable,
                 Module,
                 Anything,
                 CallOverloads
               };
               //! 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);
               //! get the __main__ module of python
               PythonQtObjectPtr getMainModule();
               //! 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);
               //! 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);
               //! 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);
               //! 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* module, PyObject* pycode);
               //! evaluates the given script code and returns the result value
               QVariant evalScript(PyObject* module, const QString& script, int start = Py_file_input);
               //! evaluates the given script code from file
               void evalFile(PyObject* module, const QString& filename);
               //! 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();
               //@{ 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);
               //@}
               //@{ Variable access
               //! add the given \c object to the \c module as a variable with \c name (it can be removed via clearVariable)
               void addObject(PyObject* module, const QString& name, QObject* object);
               //! add the given variable to the module
               void addVariable(PyObject* module, 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 module, returns an invalid QVariant on error
               QVariant getVariable(PyObject* module, const QString& name);
               //! read vars etc. in scope of a module, optional looking inside of an object \c objectname
               QStringList introspection(PyObject* module, const QString& objectname, ObjectType type);
               //! returns the found callable object or NULL
               //! @return new reference
               PythonQtObjectPtr lookupCallable(PyObject* module, const QString& name);
               //@}
               //@{ Calling of python callables
               //! call the given python method, returns the result converted to a QVariant
               QVariant call(PyObject* module, const QString& callable, const QVariantList& args = QVariantList());
               //@}
               //@{ 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 constructor handler to PythonQt (ownership stays with caller)
-              void addConstructorHandler(PythonQtConstructorHandler* handler);
-              //! get list of constructor handlers
-              const QList<PythonQtConstructorHandler*>& constructorHandlers();
               //@}
               //@{ Custom importer (to replace internal import implementation of python)
               //! 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 internal data (should not be used on the public API, but is used by some C functions)
               static PythonQtPrivate* priv() { return _self->_p; }
               //! get access to the file importer (if set)
               static PythonQtImportFileInterface* importInterface();
               //! 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();
               //! 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);
             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);
             public:
               //! 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);
             private:
               void initPythonQtModule(bool redirectStdOut);
               //! 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);
               ~PythonQt();
               static PythonQt* _self;
               static int _uniqueModuleCount;
               PythonQtPrivate* _p;
             };
             //! internal PythonQt details
             class PythonQtPrivate : public QObject {
               Q_OBJECT
             public:
               PythonQtPrivate();
               ~PythonQtPrivate();
               enum DecoratorTypes {
                 StaticDecorator = 1,
                 ConstructorDecorator = 2,
                 DestructorDecorator = 4,
                 InstanceDecorator = 8,
                 AllDecorators = 0xffff
               };
               //! 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 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);
               //! 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);
               //! 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);
               //! get list of all slots that are available as decorator slots
               QList<PythonQtSlotInfo*> getDecoratorSlots(const QByteArray& className);
               //! check if the enum is either part of the \c meta class or contains a scope and is
               //! an enum of another known metaobject (and as last resort, of the Qt namespace)
               bool isEnumType(const QMetaObject* meta, const QByteArray& name);
               //! helper method that creates a PythonQtClassWrapper object
-              PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info);
+              PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info, const char* package = NULL);
               //! 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 _knownQtClasses.value(meta->className()); }
               //! get the class info for a meta object (if available)
               PythonQtClassInfo* getClassInfo(const QByteArray& className) { return _knownQtClasses.value(className); }
               //! get the constructor slot for the given classname
               PythonQtSlotInfo* getConstructorSlot(const QByteArray& className) { return _constructorSlots.value(className); }
               //! get the destructor slot for the given classname
               PythonQtSlotInfo* getDestructorSlot(const QByteArray& className) { return _destructorSlots.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();
             private:
+              //! create a new class info and python wrapper type
+              PythonQtClassInfo* createPythonQtClassInfo(const QMetaObject* meta, const char* cppClassName, const char* package);
               //! get/create new package module
               PythonQtObjectPtr 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 *> _knownQtClasses;
               //! stores the meta info of known Qt classes
               QHash<QByteArray, PythonQtClassInfo *> _knownQtWrapperClasses;
               //! stores the meta info of known Qt C++ wrapper classes
               QMultiHash<QByteArray, PythonQtSlotInfo *> _knownQtDecoratorSlots;
               //! 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 importer interface (if set)
               PythonQtImportFileInterface* _importInterface;
               //! the default importer
               PythonQtQFileImporter* _defaultImporter;
               PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
               PythonQtQObjectWrappedCB* _wrappedCB;
               QStringList _importIgnorePaths;
               //! the cpp object wrapper factories
               QList<PythonQtCppWrapperFactory*> _cppWrapperFactories;
-              //! the cpp object wrapper factories
-              QList<PythonQtConstructorHandler*> _constructorHandlers;
               QHash<QByteArray , PythonQtSlotInfo *> _constructorSlots;
               QHash<QByteArray , PythonQtSlotInfo *> _destructorSlots;
               QHash<QByteArray, PythonQtObjectPtr> _packages;
+              PythonQtClassInfo* _currentClassInfoForClassWrapperCreation;
               int _initFlags;
               int _PythonQtObjectPtr_metaId;
               friend class PythonQt;
             };
             #endif

src/PythonQtClassInfo.cpp +1 0

             /*
             *
             *  Copyright (C) 2006 MeVis Research GmbH 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 Research GmbH, 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>
             QHash<QByteArray, int> PythonQtMethodInfo::_parameterTypeDict;
             PythonQtClassInfo::PythonQtClassInfo(const QMetaObject* meta, const QByteArray& wrappedClassName) {
               _meta = meta;
               _wrappedClassName = wrappedClassName;
               _constructors = NULL;
               _parentClassInfo = NULL;
               _parentClassInfoResolved = false;
               _decoratorProvider = NULL;
               _decoratorProviderCB = NULL;
+              _pythonQtClassWrapper = NULL;
               if (wrappedClassName.isEmpty()) {
                 _metaTypeId = -1;
               } else {
                 _metaTypeId = QMetaType::type(wrappedClassName);
               }
             }
             PythonQtClassInfo::~PythonQtClassInfo()
             {
               clearCachedMembers();
             }
             void PythonQtClassInfo::clearCachedMembers()
             {
               QHashIterator<QByteArray, PythonQtMemberInfo> i(_cachedMembers);
               while (i.hasNext()) {
                 PythonQtMemberInfo member = i.next().value();
                 if (member._type== PythonQtMemberInfo::Slot) {
                   PythonQtSlotInfo* info = member._slot;
                   while (info) {
                     PythonQtSlotInfo* next = info->nextInfo();
                     delete info;
                     info = next;
                   }
                 }
               }
             }
             void PythonQtClassInfo::resolveParentClassInfo()
             {
               if (!_parentClassInfoResolved) {
                 _parentClassInfoResolved = true;
                 if (isCPPWrapper()) {
                   if (!_wrappedClassName.isEmpty()) {
                     _parentClassInfo = PythonQt::priv()->getClassInfo(_wrappedParentClassName);
                   }
                 } else {
                   if (_meta->superClass()) {
                     _parentClassInfo = PythonQt::priv()->getClassInfo(_meta->superClass());
                   }
                 }
               }
             }
             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)
             {
               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::findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache) {
               QObject* decoratorProvider = decorator();
               if (decoratorProvider) {
                 const QMetaObject* meta = decoratorProvider->metaObject();
                 int memberNameLen = strlen(memberName);
                 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(m, i, decoratorProvider, isClassDeco?PythonQtSlotInfo::ClassDecorator:PythonQtSlotInfo::InstanceDecorator);
                       if (tail) {
                         tail->setNextInfo(info);
                       } else {
                         PythonQtMemberInfo newInfo(info);
                         memberCache.insert(memberName, newInfo);
                       }
                       tail = info;
                     }
                   }
                 }
               }
               return tail;
             }
             bool PythonQtClassInfo::lookForMethodAndCache(const char* memberName)
             {
               bool found = false;
               int memberNameLen = strlen(memberName);
               PythonQtSlotInfo* tail = NULL;
               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) {
                     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(m, i);
                       if (tail) {
                         tail->setNextInfo(info);
                       } else {
                         PythonQtMemberInfo newInfo(info);
                         _cachedMembers.insert(memberName, newInfo);
                       }
                       tail = info;
                     }
                   }
                 }
               }
               // look for dynamic decorators in this class and in derived classes
               PythonQtClassInfo* info = this;
               while (info) {
                 tail = info->findDecoratorSlotsFromDecoratorProvider(memberName, tail, found, _cachedMembers);
                 if (!info->_parentClassInfoResolved) {
                   info->resolveParentClassInfo();
                 }
                 info = info->_parentClassInfo;
               }
               // look for decorators
               if (!_wrappedClassName.isEmpty()) {
                 tail = findDecoratorSlots(_wrappedClassName.constData(), memberName, memberNameLen, tail, found);
               }
               const QMetaObject* meta = _meta;
               while (meta) {
                 tail = findDecoratorSlots(meta->className(), memberName, memberNameLen, tail, found);
                 meta = meta->superClass();
               }
               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);
                 for (int j=0; j < e.keyCount(); j++) {
                   if (qstrcmp(e.key(j), memberName)==0) {
                     PythonQtMemberInfo newInfo(e.value(j));
                     _cachedMembers.insert(memberName, newInfo);
               #ifdef PYTHONQT_DEBUG
                     std::cout << "caching enum " << memberName << " on " << meta->className() << std::endl;
               #endif
                     found = true;
                   }
                 }
               }
               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
                     PythonQtClassInfo* info = this;
                     while (info && !found) {
                       QObject* deco = info->decorator();
                       if (deco) {
                         // call on ourself for caching, but with different metaObject():
                         found = lookForEnumAndCache(deco->metaObject(), memberName);
                       }
                       if (!info->_parentClassInfoResolved) {
                         info->resolveParentClassInfo();
                       }
                       info = info->_parentClassInfo;
                     }
                   }
                 }
                 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);
             }
             PythonQtSlotInfo* PythonQtClassInfo::findDecoratorSlots(const char* classname, const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool& found)
             {
               QListIterator<PythonQtSlotInfo*> it(PythonQt::priv()->getDecoratorSlots(classname));
               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);
                   found = true;
                   if (tail) {
                     tail->setNextInfo(info);
                   } else {
                     PythonQtMemberInfo newInfo(info);
                     _cachedMembers.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;
                     }
                     // 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);
                     }
                   }
                 }
               }
             }
             QStringList PythonQtClassInfo::memberList(bool metaOnly)
             {
               resolveParentClassInfo();
               decorator();
               QStringList l;
               QString h;
               if (_wrappedClassName.isEmpty() && _meta && !metaOnly) {
                 int i;
                 int numProperties = _meta->propertyCount();
                 for (i = 0; i < numProperties; i++) {
                   QMetaProperty p = _meta->property(i);
                   l << QString(p.name());
                 }
               }
               // normal slots of QObject (or wrapper QObject)
               if (!metaOnly && _meta) {
                 int numMethods = _meta->methodCount();
                 bool skipQObj = !_wrappedClassName.isEmpty();
                 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) {
                     QByteArray signa(m.signature());
                     if (signa.startsWith("new_")) continue;
                     if (signa.startsWith("delete_")) continue;
                     if (signa.startsWith("static_")) continue;
                     PythonQtSlotInfo slot(m, i);
                     l << slot.slotName();
                   }
                 }
               }
               {
                 // look for dynamic decorators in this class and in derived classes
                 PythonQtClassInfo* info = this;
                 while (info) {
                   info->listDecoratorSlotsFromDecoratorProvider(l, metaOnly);
                   if (!info->_parentClassInfoResolved) {
                     info->resolveParentClassInfo();
                   }
                   info = info->_parentClassInfo;
                 }
               }
               // look for decorators
               QList<const char*> names;
               if (!_wrappedClassName.isEmpty()) {
                 // CPP wrapper case:
                 names << _wrappedClassName.constData();
                 // for CPP classes which are wrapped, we do not want to look for decorators of the wrapping qobjects, since they
                 // would require a different pointer on the decorator slot call
               } else {
                 // QObject case:
                 const QMetaObject* meta = _meta;
                 while (meta) {
                   if (meta==&QObject::staticMetaObject && !_wrappedClassName.isEmpty()) break;
                   names << meta->className();
                   meta = meta->superClass();
                 }
               }
               QListIterator<const char*> nameIt(names);
               while (nameIt.hasNext()) {
                 QListIterator<PythonQtSlotInfo*> it(PythonQt::priv()->getDecoratorSlots(nameIt.next()));
                 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);
                       }
                       l << first;
                     }
                   } else {
                     l << slot->slotName();
                   }
                 }
               }
               // List enumerator keys...
               QList<const QMetaObject*> enumMetaObjects;
               if (_meta) {
                 enumMetaObjects << _meta;
               }
               // check enums in the class hierachy of CPP classes
               PythonQtClassInfo* info = this;
               while (info) {
                 QObject* deco = info->decorator();
                 if (deco) {
                   enumMetaObjects << deco->metaObject();
                 }
                 if (!info->_parentClassInfoResolved) {
                   info->resolveParentClassInfo();
                 }
                 info = info->_parentClassInfo;
               }
               foreach(const QMetaObject* meta, enumMetaObjects) {
                 for (int i = 0; i<meta->enumeratorCount(); i++) {
                   QMetaEnum e = meta->enumerator(i);
                   for (int j=0; j < e.keyCount(); j++) {
                     l << QString(e.key(j));
                   }
                 }
               }
               return l;
             }
             const char* PythonQtClassInfo::className()
             {
               if (!_wrappedClassName.isEmpty()) {
                 return _wrappedClassName.constData();
               } else {
                 return _meta->className();
               }
             }
             bool PythonQtClassInfo::inherits(const char* name)
             {
               resolveParentClassInfo();
               if (isCPPWrapper()) {
                 PythonQtClassInfo* info = this;
                 while (info) {
                   if (_wrappedClassName == name) {
                     return true;
                   }
                   if (!info->_parentClassInfoResolved) {
                     info->resolveParentClassInfo();
                   }
                   info = info->_parentClassInfo;
                 }
               } else {
                 const QMetaObject* m = _meta;
                 while (m) {
                   if (strcmp(name, m->className())==0) {
                     return true;
                   }
                   m = m->superClass();
                 }
               }
               return false;
             }
             QString PythonQtClassInfo::help()
             {
               resolveParentClassInfo();
               decorator();
               QString h;
               h += QString("--- ") + QString(className()) + QString(" ---\n");
               if (_wrappedClassName.isEmpty()) {
                 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(false) + "\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) {
                     QByteArray signa(m.signature());
                     if (signa.startsWith("new_")) continue;
                     if (signa.startsWith("delete_")) continue;
                     if (signa.startsWith("static_")) continue;
                     PythonQtSlotInfo slot(m, i);
                     h += slot.fullSignature(false)+ "\n";
                   }
                 }
               }
               // TODO xxx : decorators and enums from decorator() are missing...
               // maybe we can reuse memberlist()?
               // look for decorators
               QList<const char*> names;
               if (!_wrappedClassName.isEmpty()) {
                 names << _wrappedClassName.constData();
               }
               const QMetaObject* meta = _meta;
               while (meta) {
                 names << meta->className();
                 meta = meta->superClass();
               }
               QListIterator<const char*> nameIt(names);
               while (nameIt.hasNext()) {
                 QListIterator<PythonQtSlotInfo*> it(PythonQt::priv()->getDecoratorSlots(nameIt.next()));
                 while (it.hasNext()) {
                   PythonQtSlotInfo* slot = it.next();
                   h += slot->fullSignature(slot->isInstanceDecorator()) + "\n";
                 }
               }
               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 (_wrappedClassName.isEmpty() && _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();
                 _constructors = PythonQt::priv()->getConstructorSlot(!_wrappedClassName.isEmpty()?_wrappedClassName:QByteArray(_meta->className()));
               }
               return _constructors;
             }
             void PythonQtClassInfo::setMetaObject(const QMetaObject* meta)
             {
               _meta = meta;
               clearCachedMembers();
             }
             QObject* PythonQtClassInfo::decorator()
             {
               if (!_decoratorProvider && _decoratorProviderCB) {
                 _decoratorProvider = (*_decoratorProviderCB)();
                 if (_decoratorProvider) {
                   _decoratorProvider->setParent(PythonQt::priv());
                   PythonQt::priv()->addDecorators(_decoratorProvider, PythonQtPrivate::ConstructorDecorator | PythonQtPrivate::DestructorDecorator);
                 }
               }
               return _decoratorProvider;
             }
             bool PythonQtClassInfo::hasOwnerMethodButNoOwner(void* object)
             {
               PythonQtMemberInfo info = member("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;
               }
             }

src/PythonQtClassInfo.h +8 0

             #ifndef _PYTHONQTCLASSINFO_H
             #define _PYTHONQTCLASSINFO_H
             /*
              *
              *  Copyright (C) 2006 MeVis Research GmbH 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 Research GmbH, 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, EnumValue, Property, NotFound
               };
               PythonQtMemberInfo():_slot(NULL),_enumValue(0),_type(Invalid) { }
               PythonQtMemberInfo(PythonQtSlotInfo* info) {
                 _type = Slot;
                 _slot = info;
                 _enumValue = 0;
               }
               PythonQtMemberInfo(unsigned int enumValue) {
                 _type = EnumValue;
                 _slot = NULL;
                 _enumValue = enumValue;
               }
               PythonQtMemberInfo(const QMetaProperty& prop) {
                 _type = Property;
                 _slot = NULL;
                 _enumValue = 0;
                 _property = prop;
               }
               PythonQtSlotInfo* _slot;
               unsigned int      _enumValue;
               QMetaProperty     _property;
               Type              _type;
             };
             //! 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 PythonQtClassInfo {
             public:
               PythonQtClassInfo(const QMetaObject* meta, const QByteArray& wrappedClassName = QByteArray());
               ~PythonQtClassInfo();
               //! get the Python method definition for a given slot name (without return type and signature)
               PythonQtMemberInfo member(const char* member);
               PythonQtSlotInfo* constructors();
               //! get the classname (either of the QObject or of the wrapped CPP object)
               const char* className();
               //! returns if the object is a CPP wrapper
               bool isCPPWrapper() { return !_wrappedClassName.isEmpty(); }
               //! 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 the meta object inherits the given classname
               bool inherits(const char* name);
               //! get help string for the metaobject
               QString help();
               //! get list of all members
               QStringList memberList(bool metaOnly = false);
               //! 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) { _decoratorProviderCB = cb; _decoratorProvider = NULL; }
               //! get the decorator qobject instance
               QObject* decorator();
               //! set the parent class name of a wrapped CPP pointer
               void setWrappedParentClassName(const QByteArray& name) { _wrappedParentClassName = name; _parentClassInfo = NULL; _parentClassInfoResolved = false; }
               //! check if the special method "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; }
             private:
               //! resolve the parent class from either meta object or cpp parent class name
               void resolveParentClassInfo();
               //! clear all cached members
               void clearCachedMembers();
               PythonQtSlotInfo* findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache);
               void listDecoratorSlotsFromDecoratorProvider(QStringList& list, bool metaOnly);
               bool lookForPropertyAndCache(const char* memberName);
               bool lookForMethodAndCache(const char* memberName);
               bool lookForEnumAndCache(const QMetaObject* m, const char* memberName);
               PythonQtSlotInfo* findDecoratorSlots(const char* classname, const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool &found);
               int findCharOffset(const char* sigStart, char someChar);
               QHash<QByteArray, PythonQtMemberInfo> _cachedMembers;
               PythonQtSlotInfo*                    _constructors;
               const QMetaObject*                   _meta;
               QByteArray                           _wrappedClassName;
               QByteArray                           _wrappedParentClassName;
               QObject*                             _decoratorProvider;
               PythonQtQObjectCreatorFunctionCB*    _decoratorProviderCB;
               PythonQtClassInfo*                   _parentClassInfo;
+              PyObject*                            _pythonQtClassWrapper;
               bool                                 _parentClassInfoResolved;
               int                                  _metaTypeId;
             };
             //---------------------------------------------------------------
             #endif

src/PythonQtClassWrapper.cpp +62 -89

             /*
              *
              *  Copyright (C) 2006 MeVis Research GmbH 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 Research GmbH, Universitaetsallee 29,
              *  28359 Bremen, Germany or:
              *
              *  http://www.mevis.de
              *
              */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtClassWrapper.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtClassWrapper.h"
             #include <QObject>
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtConversion.h"
-            static void PythonQtClassWrapper_dealloc(PythonQtClassWrapper* self)
+            static PyObject* PythonQtClassWrapper_alloc(PyTypeObject *self, Py_ssize_t nitems)
             {
-              self->ob_type->tp_free((PyObject*)self);
+              // call the default type alloc
+              PyObject* obj = PyType_Type.tp_alloc(self, nitems);
-            static PyObject* PythonQtClassWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
+              // take current class type, if we are called via newPythonQtClassWrapper()
+              PythonQtClassWrapper* wrap = (PythonQtClassWrapper*)obj;
-              PythonQtClassWrapper *self;
+              wrap->_classInfo = PythonQt::priv()->currentClassInfoForClassWrapperCreation();
-              self = (PythonQtClassWrapper *)type->tp_alloc(type, 0);
+              return obj;
-              if (self != NULL) {
-                self->_info = NULL;
-              return (PyObject *)self;
             }
-            static int PythonQtClassWrapper_init(PythonQtClassWrapper * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
-              return 0;
-            PyObject *PythonQtClassWrapper_call(PyObject *func, PyObject *args, PyObject *kw) {
+            static int PythonQtClassWrapper_init(PythonQtClassWrapper* self, PyObject* args, PyObject* kwds)
-              PythonQtClassWrapper* wrapper = (PythonQtClassWrapper*)func;
-              PyObject* result = NULL;
+              // call the default type init
-              QString error;
+              if (PyType_Type.tp_init((PyObject *)self, args, kwds) < 0) {
-              PyObject* err = NULL;
+                return -1;
-              if (wrapper->_info->constructors()) {
-                result = PythonQtSlotFunction_CallImpl(NULL, wrapper->_info->constructors(), args, kw);
-                err = PyErr_Occurred();
-              if (!result) {
-                QObject* v = NULL;
-                QListIterator<PythonQtConstructorHandler*> it(PythonQt::self()->constructorHandlers());
-                while (!v && it.hasNext()) {
-                  v = it.next()->create(wrapper->_info->metaObject(), args, kw, error);
-                if (v) {
-                  result = PythonQt::priv()->wrapQObject(v);
               }
-              if (result) {
-                // change ownershipflag to be owned by PythonQt
+              // if we have no CPP class information, try our base class
-                if (result->ob_type == &PythonQtInstanceWrapper_Type) {
+              if (!self->classInfo()) {
-                  ((PythonQtInstanceWrapper*)result)->_ownedByPythonQt = true;
+                PyTypeObject*  superType = ((PyTypeObject *)self)->tp_base;
-              } else {
+                if (!superType || (superType->ob_type != &PythonQtClassWrapper_Type)) {
-                if (!wrapper->_info->constructors()) {
+                  PyErr_Format(PyExc_TypeError, "type %s is not derived from PythonQtClassWrapper", ((PyTypeObject*)self)->tp_name);
-                  if (!err) {
+                  return -1;
-                    if (error.isEmpty()) {
-                      error = QString("No constructors available for ") + wrapper->_info->className();
-                    PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                 }
+                // take the class info from the superType
+                self->_classInfo = ((PythonQtClassWrapper*)superType)->classInfo();
               }
-              return result;
+              return 0;
             }
             static PyObject *PythonQtClassWrapper_classname(PythonQtClassWrapper* type)
             {
-              return PyString_FromString((QString("Meta_") + type->_info->className()).toLatin1().data());
+              return PyString_FromString((QString("Class_") + type->classInfo()->className()).toLatin1().data());
             }
             static PyObject *PythonQtClassWrapper_help(PythonQtClassWrapper* type)
             {
-              return PythonQt::self()->helpCalled(type->_info);
+              return PythonQt::self()->helpCalled(type->classInfo());
             }
             static PyMethodDef PythonQtClassWrapper_methods[] = {
                 {"className", (PyCFunction)PythonQtClassWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
                 {"help", (PyCFunction)PythonQtClassWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
                 {NULL, NULL, 0 , NULL}  /* Sentinel */
             };
-            static PyObject *PythonQtClassWrapper_getattro(PyObject *obj,PyObject *name)
+            static PyObject *PythonQtClassWrapper_getattro(PyObject *obj, PyObject *name)
             {
               const char *attributeName;
               PythonQtClassWrapper *wrapper = (PythonQtClassWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL) {
                 return NULL;
               }
-              PythonQtMemberInfo member = wrapper->_info->member(attributeName);
+              PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
               if (member._type == PythonQtMemberInfo::EnumValue) {
                 return PyInt_FromLong(member._enumValue);
               }
               if (member._type == PythonQtMemberInfo::Slot && member._slot->isClassDecorator()) {
                 return PythonQtSlotFunction_New(member._slot, obj, NULL);
               }
               // look for the interal methods (className(), help())
               PyObject* internalMethod = Py_FindMethod( PythonQtClassWrapper_methods, obj, (char*)attributeName);
               if (internalMethod) {
                 return internalMethod;
               }
               PyErr_Clear();
               if (qstrcmp(attributeName, "__dict__")==0) {
-                QStringList l = wrapper->_info->memberList(true);
+                QStringList l = wrapper->classInfo()->memberList(true);
                 PyObject* dict = PyDict_New();
                 foreach (QString name, l) {
                   //PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
                   PyDict_SetItemString(dict, name.toLatin1().data(), Py_None);
                   //Py_DECREF(o);
                 }
                 return dict;
               }
-              QString error = QString(wrapper->_info->className()) + " has no attribute named '" + QString(attributeName) + "'";
+              QString error = QString(wrapper->classInfo()->className()) + " has no attribute named '" + QString(attributeName) + "'";
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return NULL;
             }
+            static int PythonQtClassWrapper_setattro(PyObject *obj,PyObject *name,PyObject * /*value*/)
+            {
+              QString error;
+              char *attributeName;
+              if ((attributeName = PyString_AsString(name)) == NULL) {
+                return -1;
+              }
+              PythonQtClassWrapper *wrapper = (PythonQtClassWrapper *)obj;
+              // TODO
+              return -1;
+            }
+            /*
             static PyObject * PythonQtClassWrapper_repr(PyObject * obj)
             {
               PythonQtClassWrapper* wrapper = (PythonQtClassWrapper*)obj;
-              if (wrapper->_info->isCPPWrapper()) {
+              if (wrapper->classInfo()->isCPPWrapper()) {
-                const QMetaObject* meta = wrapper->_info->metaObject();
+                const QMetaObject* meta = wrapper->classInfo()->metaObject();
                 if (!meta) {
-                  QObject* decorator = wrapper->_info->decorator();
+                  QObject* decorator = wrapper->classInfo()->decorator();
                   if (decorator) {
                     meta = decorator->metaObject();
                   }
                 }
                 if (meta) {
-                  return PyString_FromFormat("%s Class (C++ wrapped by %s)", wrapper->_info->className(), meta->className());
+                  return PyString_FromFormat("%s Class (C++ wrapped by %s)", wrapper->classInfo()->className(), meta->className());
-                } else {
-                  return PyString_FromFormat("%s Class (C++ unwrapped)", wrapper->_info->className());
-              } else {
-                return PyString_FromFormat("%s Class", wrapper->_info->className());
-            static int PythonQtClassWrapper_compare(PyObject * obj1, PyObject * obj2)
-              if (obj1->ob_type == &PythonQtClassWrapper_Type &&
-                obj2->ob_type == &PythonQtClassWrapper_Type) {
-                PythonQtClassWrapper* w1 = (PythonQtClassWrapper*)obj1;
-                PythonQtClassWrapper* w2 = (PythonQtClassWrapper*)obj2;
-                if (w1->_info == w2->_info) {
-                  return 0;
                 } else {
-                  return -1;
+                  return PyString_FromFormat("%s Class (C++ unwrapped)", wrapper->classInfo()->className());
                 }
               } else {
-                return -1;
+                return PyString_FromFormat("%s Class", wrapper->classInfo()->className());
               }
             }
-            static long PythonQtClassWrapper_hash(PythonQtClassWrapper *obj)
+            */
-              return reinterpret_cast<long>(obj->_info);
             PyTypeObject PythonQtClassWrapper_Type = {
                 PyObject_HEAD_INIT(NULL)
 ,                         /*ob_size*/
                 "PythonQt.PythonQtClassWrapper",             /*tp_name*/
                 sizeof(PythonQtClassWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
-                (destructor)PythonQtClassWrapper_dealloc, /*tp_dealloc*/
+,                         /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
-                PythonQtClassWrapper_compare,         /*tp_compare*/
+,                         /*tp_compare*/
-                PythonQtClassWrapper_repr,            /*tp_repr*/
+, //PythonQtClassWrapper_repr,            /*tp_repr*/
 ,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
-                (hashfunc)PythonQtClassWrapper_hash,                         /*tp_hash */
+,                         /*tp_hash */
-                PythonQtClassWrapper_call,                         /*tp_call*/
+,                         /*tp_call*/
 ,                         /*tp_str*/
                 PythonQtClassWrapper_getattro,                         /*tp_getattro*/
-,                         /*tp_setattro*/
+                PythonQtClassWrapper_setattro,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
-                "PythonQtClassWrapper object",           /* tp_doc */
+,           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
 ,                   /* 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)PythonQtClassWrapper_init,      /* tp_init */
-,                         /* tp_alloc */
+                PythonQtClassWrapper_alloc,                         /* tp_alloc */
-                PythonQtClassWrapper_new,                 /* tp_new */
+,                         /* tp_new */
+,                         /* tp_free */
             };
             //-------------------------------------------------------

src/PythonQtClassWrapper.h +11 -15

             #ifndef _PYTHONQTCLASSWRAPPER_H
             #define _PYTHONQTCLASSWRAPPER_H
             /*
              *
              *  Copyright (C) 2006 MeVis Research GmbH 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 Research GmbH, Universitaetsallee 29,
              *  28359 Bremen, Germany or:
              *
              *  http://www.mevis.de
              *
              */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtClassWrapper.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include <Python.h>
             #include "structmember.h"
             #include "methodobject.h"
             #include "compile.h"
             #include "eval.h"
             #include <QString>
             class PythonQtClassInfo;
-            class QObject;
-            struct QMetaObject;
+            //! the type of the PythonQt class wrapper objects
             extern PyTypeObject PythonQtClassWrapper_Type;
             //---------------------------------------------------------------
-            //! a Python wrapper object for Qt meta objects
+            //! a Python wrapper object for PythonQt wrapped classes
+            //! which inherits from the Python type object to allow
+            //! deriving of wrapped CPP classes from Python.
             typedef struct {
-              PyObject_HEAD
+              PyHeapTypeObject _base;
-              //! the class information (which contains the meta object as well)
+              //! the additional class information that PythonQt stores for the CPP class
-              PythonQtClassInfo* _info;
+              PythonQtClassInfo* _classInfo;
+              //! get the class info
+              PythonQtClassInfo* classInfo() { return _classInfo; }
             } PythonQtClassWrapper;
             //---------------------------------------------------------------
-            // an abstact class for handling construction of objects
-            class PythonQtConstructorHandler {
-            public:
-              //! get rid of warnings
-              virtual ~PythonQtConstructorHandler() {}
-              virtual QObject* create(const QMetaObject* meta, PyObject *args, PyObject *kw, QString& error) = 0;
-            };
-            #endif
  No newline at end of file
+            #endif

src/PythonQtConversion.cpp +12 -12

             /*
             *
             *  Copyright (C) 2006 MeVis Research GmbH 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 Research GmbH, 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;
             PythonQtValueStorage<QVariant, 32> 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) {
               if (info.typeId == QMetaType::Void) {
                 Py_INCREF(Py_None);
                 return Py_None;
               } else if (info.isPointer && (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:
                 // (TODO: check what happens if this is a pointer type?!)
                 QByteArray innerType = info.name.mid(6,info.name.length()-7);
                 if (innerType.endsWith("*")) {
                   innerType.truncate(innerType.length()-1);
                   return ConvertQListOfPointerTypeToPythonList((QList<void*>*)data, innerType);
                 }
               }
               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.isPointer) {
                 // 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 {
                 // handle values that are not yet handled and not pointers
                 return ConvertQtValueToPythonInternal(info.typeId, data);
               }
             }
             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:
                 return PyInt_FromLong(*((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));
               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.isPointer) {
                  PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, NULL, 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, long, 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) {
                      // everything else is stored in a QVariant...
                      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::ConvertPythonToQt(const PythonQtMethodInfo::ParameterInfo& info, PyObject* obj, bool strict, const QMetaObject* meta)
              {
                bool ok;
                void* ptr = NULL;
-               if (obj->ob_type == &PythonQtInstanceWrapper_Type && info.typeId != PythonQtMethodInfo::Variant) {
+               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;
-                 if (wrap->_info->inherits(info.name)) {
+                 if (wrap->classInfo()->inherits(info.name)) {
                    void* object;
-                   if (wrap->_info->isCPPWrapper()) {
+                   if (wrap->classInfo()->isCPPWrapper()) {
                      object = wrap->_wrappedPtr;
                    } else {
                      QObject* tmp = wrap->_obj;
                      object = tmp;
                    }
                    if (info.isPointer) {
                      // store the wrapped pointer in an extra pointer and let ptr point to the extra pointer
                      PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, object, ptr);
                    } else {
                      // store the wrapped pointer directly, since we are a reference
                      ptr = object;
                    }
                  } else {
                   // not matching
                  }
                } else if (info.isPointer) {
                  // a pointer
                  if (info.typeId == QMetaType::Char || info.typeId == QMetaType::UChar)
                  {
                    QString str = PyObjGetString(obj, strict, ok);
                    if (ok) {
                      void* ptr2 = NULL;
                      PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QVariant(str.toUtf8()), ptr2);
                      PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, (((QByteArray*)((QVariant*)ptr2)->constData())->data()), ptr);
                    }
                  } else if (info.name == "PyObject") {
                    // handle low level PyObject directly
                    PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, obj, ptr);
                  } else if (obj == Py_None) {
                    // None is treated as a NULL ptr
                    PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, NULL, ptr);
                  } else {
                    // if we are not strict, we try if we are passed a 0 integer
                    if (!strict) {
                      bool ok;
                      int value = PyObjGetInt(obj, true, ok);
                      if (ok && value==0) {
                        PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, NULL, ptr);
                      }
                    }
                  }
                } else {
                  // not a pointer
                  switch (info.typeId) {
                  case QMetaType::Char:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, char, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::UChar:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, unsigned char, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Short:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, short, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::UShort:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, unsigned short, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Long:
                    {
                      long val = (long)PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, long, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::ULong:
                    {
                      unsigned long val = (unsigned long)PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, unsigned long, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Bool:
                    {
                      bool val = PyObjGetBool(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, bool, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Int:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, int, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::UInt:
                    {
                      unsigned int val = (unsigned int)PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, unsigned int, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::QChar:
                    {
                      int val = PyObjGetInt(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, short, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Float:
                    {
                      float val = (float)PyObjGetDouble(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, float, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::Double:
                    {
                      double val = (double)PyObjGetDouble(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, double, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::LongLong:
                    {
                      qint64 val = PyObjGetLongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, qint64, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::ULongLong:
                    {
                      quint64 val = PyObjGetULongLong(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(global_valueStorage, quint64, val, ptr);
                      }
                    }
                    break;
                  case QMetaType::QByteArray:
                    {
                      QByteArray bytes = PyObjGetBytes(obj, strict, ok);
                      if (ok) {
                        PythonQtValueStorage_ADD_VALUE(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(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(global_variantStorage, QVariant, QVariant(l), ptr);
                        ptr = (void*)((QVariant*)ptr)->constData();
                      }
                    }
                    break;
                  case PythonQtMethodInfo::Variant:
                    {
                      QVariant v = PyObjToQVariant(obj);
                      if (v.isValid()) {
                        PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, v, ptr);
                      }
                    }
                    break;
                    default:
                    {
                      if (info.typeId == PythonQtMethodInfo::Unknown) {
                        // check for enum case
                        if (PythonQt::priv()->isEnumType(meta, info.name)) {
                          unsigned int val = (unsigned int)PyObjGetLongLong(obj, strict, ok);
                          if (ok) {
                            PythonQtValueStorage_ADD_VALUE(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*>");
                            PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QVariant::Type(id), ptr);
                            ptr = (void*)((QVariant*)ptr)->constData();
                            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) {
                          // create a new empty variant of concrete type:
                          PythonQtValueStorage_ADD_VALUE(global_variantStorage, QVariant, QVariant::Type(info.typeId), ptr);
                          ptr = (void*)((QVariant*)ptr)->constData();
                          // 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;
                          }
                        }
                      }
                      // 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(global_variantStorage, QVariant, v, ptr);
                        ptr = (void*)((QVariant*)ptr)->constData();
                      }
                    }
                 }
               }
               return ptr;
             }
             QStringList PythonQtConv::PyObjToStringList(PyObject* val, bool strict, bool& ok) {
               QStringList v;
               ok = false;
               // if we are strict, we do not want to convert a string to a stringlist
               // (strings in python are detected to be sequences)
               if (strict &&
                 (val->ob_type == &PyString_Type ||
                 PyUnicode_Check(val))) {
                 ok = false;
                 return v;
               }
               if (PySequence_Check(val)) {
                 int count = PySequence_Size(val);
                 for (int i = 0;i<count;i++) {
                   PyObject* value = PySequence_GetItem(val,i);
                   v.append(PyObjGetString(value,false,ok));
                 }
                 ok = true;
               }
               return v;
             }
             QString PythonQtConv::PyObjGetRepresentation(PyObject* val)
             {
               QString r;
               PyObject* str =  PyObject_Repr(val);
               if (str) {
                 r = QString(PyString_AS_STRING(str));
                 Py_DECREF(str);
               }
               return r;
             }
             QString PythonQtConv::PyObjGetString(PyObject* val, bool strict, bool& ok) {
               QString r;
               ok = true;
               if (val->ob_type == &PyString_Type) {
                 r = QString(PyString_AS_STRING(val));
               } else if (PyUnicode_Check(val)) {
             #ifdef WIN32
                 r = QString::fromUtf16(PyUnicode_AS_UNICODE(val));
             #else
                 PyObject *ptmp = PyUnicode_AsUTF8String(val);
                 if(ptmp) {
                   r = QString::fromUtf8(PyString_AS_STRING(ptmp));
                   Py_DECREF(ptmp);
                 }
             #endif
               } else if (!strict) {
                 // EXTRA: could also use _Unicode, but why should we?
                 PyObject* str =  PyObject_Str(val);
                 if (str) {
                   r = QString(PyString_AS_STRING(str));
                   Py_DECREF(str);
                 } else {
                   ok = false;
                 }
               } else {
                 ok = false;
               }
               return r;
             }
             QByteArray PythonQtConv::PyObjGetBytes(PyObject* val, bool /*strict*/, bool& ok) {
               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 (val->ob_type == &PyFloat_Type) {
                   d = floor(PyFloat_AS_DOUBLE(val));
                 } else if (val->ob_type == &PyLong_Type) {
                   // handle error on overflow!
                   d = PyLong_AsLong(val);
                 } else if (val == Py_False) {
                   d = 0;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   ok = false;
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             qint64 PythonQtConv::PyObjGetLongLong(PyObject* val, bool strict, bool &ok) {
               qint64 d = 0;
               ok = true;
               if (val->ob_type == &PyInt_Type) {
                 d = PyInt_AS_LONG(val);
               } else if (val->ob_type == &PyLong_Type) {
                 d = PyLong_AsLongLong(val);
               } else if (!strict) {
                 if (val->ob_type == &PyFloat_Type) {
                   d = floor(PyFloat_AS_DOUBLE(val));
                 } else if (val == Py_False) {
                   d = 0;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   ok = false;
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             quint64 PythonQtConv::PyObjGetULongLong(PyObject* val, bool strict, bool &ok) {
               quint64 d = 0;
               ok = true;
               if (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 (val->ob_type == &PyFloat_Type) {
                   d = floor(PyFloat_AS_DOUBLE(val));
                 } else if (val == Py_False) {
                   d = 0;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   ok = false;
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             double PythonQtConv::PyObjGetDouble(PyObject* val, bool strict, bool &ok) {
               double d = 0;
               ok = true;
               if (val->ob_type == &PyFloat_Type) {
                 d = PyFloat_AS_DOUBLE(val);
               } else if (!strict) {
                 if (val->ob_type == &PyInt_Type) {
                   d = PyInt_AS_LONG(val);
                 } else if (val->ob_type == &PyLong_Type) {
                   d = PyLong_AsLong(val);
                 } else if (val == Py_False) {
                   d = 0;
                 } else if (val == Py_True) {
                   d = 1;
                 } else {
                   ok = false;
                 }
               } else {
                 ok = false;
               }
               return d;
             }
             QVariant PythonQtConv::PyObjToQVariant(PyObject* val, int type)
             {
               QVariant v;
               bool ok = true;
               if (type==-1) {
                 // no special type requested
                 if (val->ob_type==&PyString_Type || val->ob_type==&PyUnicode_Type) {
                   type = QVariant::String;
                 } else if (val->ob_type==&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 (val->ob_type == &PythonQtInstanceWrapper_Type) {
+                } 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->_info->isCPPWrapper()) {
+                  if (wrap->classInfo()->isCPPWrapper()) {
-                    if (wrap->_info->metaTypeId()>0) {
+                    if (wrap->classInfo()->metaTypeId()>0) {
                       // construct a new variant from the C++ object if it has a meta type
-                      v = QVariant(wrap->_info->metaTypeId(), wrap->_wrappedPtr);
+                      v = QVariant(wrap->classInfo()->metaTypeId(), wrap->_wrappedPtr);
                     } else {
                       // 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::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 (val->ob_type == &PythonQtInstanceWrapper_Type) {
+                if (PyObject_TypeCheck(val, &PythonQtInstanceWrapper_Type)) {
                   PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)val;
-                  if (wrap->_info->isCPPWrapper() && wrap->_info->metaTypeId() == type) {
+                  if (wrap->classInfo()->isCPPWrapper() && wrap->classInfo()->metaTypeId() == type) {
                     // construct a new variant from the C++ object if it has the same meta type
                     v = QVariant(type, wrap->_wrappedPtr);
                   } else {
                     v = QVariant();
                   }
                 } else {
                   v = QVariant();
                 }
               }
               return v;
             }
             PyObject* PythonQtConv::QStringToPyObject(const QString& str)
             {
               if (str.isNull()) {
                 return PyString_FromString("");
               } else {
             #ifdef WIN32
                 //    return PyString_FromString(str.toLatin1().data());
                 return PyUnicode_FromUnicode(str.utf16(), str.length());
             #else
                 return PyUnicode_DecodeUTF16((const char*)str.utf16(), str.length()*2, NULL, NULL);
             #endif
               }
             }
             PyObject* PythonQtConv::QStringListToPyObject(const QStringList& list)
             {
               PyObject* result = PyTuple_New(list.count());
               int i = 0;
               QString str;
               foreach (str, list) {
                 PyTuple_SET_ITEM(result, i, PythonQtConv::QStringToPyObject(str));
                 i++;
               }
               // why is the error state bad after this?
               PyErr_Clear();
               return result;
             }
             PyObject* PythonQtConv::QStringListToPyList(const QStringList& list)
             {
               PyObject* result = PyList_New(list.count());
               int i = 0;
               for (QStringList::ConstIterator it = list.begin(); it!=list.end(); ++it) {
                 PyList_SET_ITEM(result, i, PythonQtConv::QStringToPyObject(*it));
                 i++;
               }
               return result;
             }
             PyObject* PythonQtConv::QVariantToPyObject(const QVariant& v)
             {
               return ConvertQtValueToPythonInternal(v.userType(), (void*)v.constData());
             }
             PyObject* PythonQtConv::QVariantMapToPyObject(const QVariantMap& m) {
               PyObject* result = PyDict_New();
               QVariantMap::const_iterator t = m.constBegin();
               PyObject* key;
               PyObject* val;
               for (;t!=m.end();t++) {
                 key = QStringToPyObject(t.key());
                 val = QVariantToPyObject(t.value());
                 PyDict_SetItem(result, key, val);
                 Py_DECREF(key);
                 Py_DECREF(val);
               }
               return result;
             }
             PyObject* PythonQtConv::QVariantListToPyObject(const QVariantList& l) {
               PyObject* result = PyTuple_New(l.count());
               int i = 0;
               QVariant v;
               foreach (v, l) {
                 PyTuple_SET_ITEM(result, i, PythonQtConv::QVariantToPyObject(v));
                 i++;
               }
               // why is the error state bad after this?
               PyErr_Clear();
               return result;
             }
             PyObject* PythonQtConv::ConvertQListOfPointerTypeToPythonList(QList<void*>* list, const QByteArray& typeName)
             {
               PyObject* result = PyTuple_New(list->count());
               int i = 0;
               foreach (void* value, *list) {
                 PyTuple_SET_ITEM(result, i, PythonQt::priv()->wrapPtr(value, typeName));
                 i++;
               }
               return result;
             }
             bool PythonQtConv::ConvertPythonListToQListOfPointerType(PyObject* obj, QList<void*>* list, const QByteArray& type, bool /*strict*/)
             {
               bool result = false;
               if (PySequence_Check(obj)) {
                 result = true;
                 int count = PySequence_Size(obj);
                 PyObject* value;
                 for (int i = 0;i<count;i++) {
                   value = PySequence_GetItem(obj,i);
-                  if (value->ob_type == &PythonQtInstanceWrapper_Type) {
+                  if (PyObject_TypeCheck(value, &PythonQtInstanceWrapper_Type)) {
                     PythonQtInstanceWrapper* wrap = (PythonQtInstanceWrapper*)value;
                     // both QObjects and CPP wrappers support inherits, so we use that to check of we match
-                    if (wrap->_info->inherits(type)) {
+                    if (wrap->classInfo()->inherits(type)) {
-                      if (wrap->_info->isCPPWrapper()) {
+                      if (wrap->classInfo()->isCPPWrapper()) {
                         list->append(wrap->_wrappedPtr);
                       } else {
                         QObject* myObject = wrap->_obj;
                         list->append((void*)myObject);
                       }
                     } 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::qVariantToString(const QVariant& v) {
               return CPPObjectToString(v.userType(), v.constData());
             }
             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 +79 -35

             /*
             *
             *  Copyright (C) 2006 MeVis Research GmbH 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 Research GmbH, 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 "PythonQtClassInfo.h"
             #include "PythonQtConversion.h"
+            #include "PythonQtClassWrapper.h"
+            PythonQtClassInfo* PythonQtInstanceWrapper::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->_info->wrappedClassName().latin1());
+                //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->_info->hasOwnerMethodButNoOwner(self->_wrappedPtr) || self->_ownedByPythonQt) {
+                if (force || self->classInfo()->hasOwnerMethodButNoOwner(self->_wrappedPtr) || self->_ownedByPythonQt) {
-                  int type = self->_info->metaTypeId();
+                  int type = self->classInfo()->metaTypeId();
                   if (self->_useQMetaTypeDestroy && type>=0) {
                     // use QMetaType to destroy the object
                     QMetaType::destroy(type, self->_wrappedPtr);
                   } else {
-                    PythonQtSlotInfo* slot = PythonQt::priv()->getDestructorSlot(self->_info->className());
+                    PythonQtSlotInfo* slot = PythonQt::priv()->getDestructorSlot(self->classInfo()->className());
                     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->_info->wrappedClassName().latin1());
+                //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*/)
+            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);
-              self = (PythonQtInstanceWrapper *)type->tp_alloc(type, 0);
               if (self != NULL) {
-                self->_info = NULL;
                 new (&self->_obj) QPointer<QObject>();
                 self->_wrappedPtr = NULL;
                 self->_ownedByPythonQt = false;
                 self->_useQMetaTypeDestroy = false;
               }
               return (PyObject *)self;
             }
-            static int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
+            static int PythonQtInstanceWrapper_init(PythonQtInstanceWrapper * self, PyObject * args, PyObject * kwds)
             {
+              PyObject* result = NULL;
+              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(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);
+                }
+              } 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_classname(PythonQtInstanceWrapper* type)
             {
-              return PyString_FromString(type->_info->className());
+              return PyString_FromString(type->classInfo()->className());
             }
             static PyObject *PythonQtInstanceWrapper_help(PythonQtInstanceWrapper* type)
             {
-              return PythonQt::self()->helpCalled(type->_info);
+              return PythonQt::self()->helpCalled(type->classInfo());
             }
             static 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"
                 },
                 {"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 (!wrapper->_obj && !wrapper->_wrappedPtr) {
-                QString error = QString("Trying to read attribute '") + attributeName + "' from a destroyed " + wrapper->_info->className() + " object";
+                QString error = QString("Trying to read attribute '") + attributeName + "' from a destroyed " + wrapper->classInfo()->className() + " object";
                 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                 return NULL;
               }
               //  mlabDebugConst("Python","get " << attributeName);
               // TODO: dynamic properties are missing
-              PythonQtMemberInfo member = wrapper->_info->member(attributeName);
+              PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
               switch (member._type) {
               case PythonQtMemberInfo::Property:
                 if (wrapper->_obj) {
                   return PythonQtConv::QVariantToPyObject(member._property.read(wrapper->_obj));
                 }
                 break;
               case PythonQtMemberInfo::Slot:
                 return PythonQtSlotFunction_New(member._slot, obj, NULL);
                 break;
               case PythonQtMemberInfo::EnumValue:
                 return PyInt_FromLong(member._enumValue);
                 break;
                 default:
                   // is an invalid type, go on
                 break;
               }
               // look for the interal 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::self()->priv()->wrapQObject(child);
                   }
                 }
               }
               if (qstrcmp(attributeName, "__dict__")==0) {
-                QStringList l = wrapper->_info->memberList(false);
+                QStringList l = wrapper->classInfo()->memberList(false);
                 PyObject* dict = PyDict_New();
                 foreach (QString name, l) {
                   //PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
                   PyDict_SetItemString(dict, name.toLatin1().data(), Py_None);
                   //Py_DECREF(o);
                 }
                 // Note: we do not put children into the dict, is would look confusing?!
                 return dict;
               }
-              QString error = QString(wrapper->_info->className()) + " has no attribute named '" + QString(attributeName) + "'";
+              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;
               char *attributeName;
               PythonQtInstanceWrapper *wrapper = (PythonQtInstanceWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL)
                 return -1;
               if (!wrapper->_obj) {
-                error = QString("Trying to set attribute '") + attributeName + "' on a destroyed " + wrapper->_info->className() + " object";
+                error = QString("Trying to set attribute '") + attributeName + "' on a destroyed " + wrapper->classInfo()->className() + " object";
                 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
                 return -1;
               }
-              PythonQtMemberInfo member = wrapper->_info->member(attributeName);
+              PythonQtMemberInfo member = wrapper->classInfo()->member(attributeName);
               if (member._type == PythonQtMemberInfo::Property) {
                 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()) {
                     success = prop.write(wrapper->_obj, v);
                   }
                   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 " + wrapper->_info->className() + " object is not writable";
+                  error = QString("Property '") + attributeName + "' of " + wrapper->classInfo()->className() + " object is not writable";
                 }
               } else {
                 if (member._type == PythonQtMemberInfo::Slot) {
-                  error = QString("Slot '") + attributeName + "' can not be overwritten on " + wrapper->_info->className() + " object";
+                  error = QString("Slot '") + attributeName + "' can not be overwritten on " + wrapper->classInfo()->className() + " object";
                 } else if (member._type == PythonQtMemberInfo::EnumValue) {
-                  error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + wrapper->_info->className() + " object";
+                  error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + wrapper->classInfo()->className() + " object";
                 }
               }
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return -1;
             }
             static PyObject * PythonQtInstanceWrapper_str(PyObject * obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               QObject *qobj = wrapper->_obj;
               if (wrapper->_wrappedPtr) {
-                QString str = PythonQtConv::CPPObjectToString(wrapper->_info->metaTypeId(), wrapper->_wrappedPtr);
+                QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr);
                 if (!str.isEmpty()) {
                   return PyString_FromFormat("%s", str.toLatin1().constData());
                 } else
                 if (wrapper->_obj) {
-                  return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wrapper->_info->className(), wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
+                  return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wrapper->classInfo()->className(), wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
                 } else {
-                  return PyString_FromFormat("%s (C++ Object %p)", wrapper->_info->className(), wrapper->_wrappedPtr);
+                  return PyString_FromFormat("%s (C++ Object %p)", wrapper->classInfo()->className(), wrapper->_wrappedPtr);
                 }
               } else {
-                return PyString_FromFormat("%s (QObject %p)", wrapper->_info->className(), qobj);
+                return PyString_FromFormat("%s (QObject %p)", wrapper->classInfo()->className(), qobj);
               }
             }
             static PyObject * PythonQtInstanceWrapper_repr(PyObject * obj)
             {
               PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)obj;
               QObject *qobj = wrapper->_obj;
               if (wrapper->_wrappedPtr) {
-                QString str = PythonQtConv::CPPObjectToString(wrapper->_info->metaTypeId(), wrapper->_wrappedPtr);
+                QString str = PythonQtConv::CPPObjectToString(wrapper->classInfo()->metaTypeId(), wrapper->_wrappedPtr);
                 if (!str.isEmpty()) {
-                  return PyString_FromFormat("%s(%s, %p)", QMetaType::typeName(wrapper->_info->metaTypeId()), str.toLatin1().constData(), wrapper->_wrappedPtr);
+                  return PyString_FromFormat("%s(%s, %p)", QMetaType::typeName(wrapper->classInfo()->metaTypeId()), str.toLatin1().constData(), wrapper->_wrappedPtr);
                 } else
                 if (wrapper->_obj) {
-                  return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wrapper->_info->className(), wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
+                  return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wrapper->classInfo()->className(), wrapper->_wrappedPtr, wrapper->_obj->metaObject()->className(), qobj);
                 } else {
-                  return PyString_FromFormat("%s (C++ Object %p)", wrapper->_info->className(), wrapper->_wrappedPtr);
+                  return PyString_FromFormat("%s (C++ Object %p)", wrapper->classInfo()->className(), wrapper->_wrappedPtr);
                 }
               } else {
-                return PyString_FromFormat("%s (QObject %p)", wrapper->_info->className(), qobj);
+                return PyString_FromFormat("%s (QObject %p)", wrapper->classInfo()->className(), qobj);
               }
             }
             static int PythonQtInstanceWrapper_compare(PyObject * obj1, PyObject * obj2)
             {
-              if (obj1->ob_type == &PythonQtInstanceWrapper_Type &&
+              if (PyObject_TypeCheck(obj1, &PythonQtInstanceWrapper_Type) &&
-                obj2->ob_type == &PythonQtInstanceWrapper_Type) {
+                PyObject_TypeCheck(obj2, &PythonQtInstanceWrapper_Type)) {
                 PythonQtInstanceWrapper* w1 = (PythonQtInstanceWrapper*)obj1;
                 PythonQtInstanceWrapper* w2 = (PythonQtInstanceWrapper*)obj2;
                 // check pointers directly first:
                 if (w1->_wrappedPtr != NULL) {
                   if (w1->_wrappedPtr == w2->_wrappedPtr) {
                     return 0;
                   }
                 } else if (w1->_obj == w2->_obj) {
                   return 0;
                 }
-                const char* class1 = w1->_info->className();
+                const char* class1 = w1->classInfo()->className();
-                const char* class2 = w2->_info->className();
+                const char* class2 = w2->classInfo()->className();
                 if (strcmp(class1, class2) == 0) {
                   // same class names, so we can try the operator_equal
-                  PythonQtMemberInfo info = w1->_info->member("operator_equal");
+                  PythonQtMemberInfo info = w1->classInfo()->member("operator_equal");
                   if (info._type == PythonQtMemberInfo::Slot) {
                     bool result = false;
                     void* obj1 = w1->_wrappedPtr;
                     if (!obj1) {
                       obj1 = w1->_obj;
                     }
                     if (!obj1) { return -1; }
                     void* obj2 = w2->_wrappedPtr;
                     if (!obj2) {
                       obj2 = w2->_obj;
                     }
                     if (!obj2) { return -1; }
                     if (info._slot->isInstanceDecorator()) {
                       // call on decorator QObject
                       void* args[3];
                       args[0] = &result;
                       args[1] = &obj1; // this is a pointer, so it needs a pointer to a pointer
                       args[2] = obj2;  // this is a reference, so it needs the direct pointer
                       info._slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
                       return result?0:-1;
                     } else {
                       // call directly on QObject
                       if (w1->_obj && w2->_obj) {
                         void* args[2];
                         args[0] = &result;
                         args[2] = obj2;  // this is a reference, so it needs the direct pointer
                         w1->_obj->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
                       }
                     }
                   }
                 }
               }
               return -1;
             }
             static int PythonQtInstanceWrapper_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_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(NULL)
+                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*/
                 PythonQtInstanceWrapper_compare,         /*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, /*tp_flags*/
                 "PythonQtInstanceWrapper object",           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
 ,                   /* 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/PythonQtInstanceWrapper.h +3 -3

             #ifndef _PYTHONQTINSTANCEWRAPPER_H
             #define _PYTHONQTINSTANCEWRAPPER_H
             /*
              *
              *  Copyright (C) 2006 MeVis Research GmbH 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 Research GmbH, Universitaetsallee 29,
              *  28359 Bremen, Germany or:
              *
              *  http://www.mevis.de
              *
              */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtInstanceWrapper.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include <Python.h>
             #include "PythonQtSystem.h"
             #include <QPointer>
             #include "structmember.h"
             #include "methodobject.h"
             #include "compile.h"
             #include "eval.h"
             class PythonQtClassInfo;
             class QObject;
             extern PYTHONQT_EXPORT PyTypeObject PythonQtInstanceWrapper_Type;
             //---------------------------------------------------------------
             //! a Python wrapper object for Qt objects and C++ objects (that are themselves wrapped by wrapper QObjects)
             typedef struct {
               PyObject_HEAD
+              //! the class information, this is set even if the _obj or _wrappedPtr is NULL to support typed NULL pointers
+              PythonQtClassInfo* classInfo();
               //! set the QObject pointer
               void setQObject(QObject* object) {
                 _obj = object;
                 _objPointerCopy = object;
               }
               //! pointer to the wrapped Qt object or if _wrappedPtr is set, the Qt object that wraps the C++ Ptr
               QPointer<QObject> _obj;
               //! a copy of the _obj pointer, which is required because the wrapper needs to
               //! deregister itself via the _obj pointer, even when the QPointer<QObject> object was destroyed
               void* _objPointerCopy;
               //! optional C++ object Ptr that is wrapped by the above _obj
               void*    _wrappedPtr;
-              //! the class information, this is set even if the _obj or _wrappedPtr is NULL to support typed NULL pointers
-              PythonQtClassInfo* _info;
               //! flag that stores if the object is owned by pythonQt
               bool _ownedByPythonQt;
               //! stores that the owned object should be destroyed using QMetaType::destroy()
               bool _useQMetaTypeDestroy;
             } PythonQtInstanceWrapper;
             #endif

src/PythonQtSlot.cpp +39 -26

             /*
             *
             *  Copyright (C) 2006 MeVis Research GmbH 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 Research GmbH, Universitaetsallee 29,
             *  28359 Bremen, Germany or:
             *
             *  http://www.mevis.de
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtSlot.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtInstanceWrapper.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtMisc.h"
             #include "PythonQtConversion.h"
             #include <iostream>
             #define PYTHONQT_MAX_ARGS 32
-            PyObject* PythonQtCallSlot(QObject* objectToCall, PyObject* args, bool strict, PythonQtSlotInfo* info, void* firstArgument)
+            bool PythonQtCallSlot(QObject* objectToCall, PyObject* args, bool strict, PythonQtSlotInfo* info, void* firstArgument, PyObject** pythonReturnValue, void** directReturnValuePointer)
             {
               static unsigned int recursiveEntry = 0;
+              if (directReturnValuePointer) {
+                *directReturnValuePointer = NULL;
+              }
               // store the current storage position, so that we can get back to this state after a slot is called
               // (do this locally, so that we have all positions on the stack
               PythonQtValueStoragePosition globalValueStoragePos;
               PythonQtValueStoragePosition globalPtrStoragePos;
               PythonQtValueStoragePosition globalVariantStoragePos;
               PythonQtConv::global_valueStorage.getPos(globalValueStoragePos);
               PythonQtConv::global_ptrStorage.getPos(globalPtrStoragePos);
               PythonQtConv::global_variantStorage.getPos(globalVariantStoragePos);
               recursiveEntry++;
               // the arguments that are passed to qt_metacall
               void* argList[PYTHONQT_MAX_ARGS];
               PyObject* result = NULL;
               int argc = info->parameterCount();
               const QList<PythonQtSlotInfo::ParameterInfo>& params = info->parameters();
               bool returnValueIsEnum = false;
               const PythonQtSlotInfo::ParameterInfo& returnValueParam = params.at(0);
               // set return argument to NULL
               argList[0] = NULL;
               if (returnValueParam.typeId != QMetaType::Void) {
                 // extra handling of enum return value
                 if (!returnValueParam.isPointer && returnValueParam.typeId == PythonQtMethodInfo::Unknown) {
                   returnValueIsEnum = PythonQt::priv()->isEnumType(objectToCall->metaObject(), returnValueParam.name);
                   if (returnValueIsEnum) {
                     // create enum return value
                     PythonQtValueStorage_ADD_VALUE(PythonQtConv::global_valueStorage, long, 0, argList[0]);
                   }
                 }
                 if (argList[0]==NULL) {
                   // create empty default value for the return value
-                  argList[0] = PythonQtConv::CreateQtReturnValue(returnValueParam);
+                  if (!directReturnValuePointer) {
+                    // create empty default value for the return value
+                    argList[0] = PythonQtConv::CreateQtReturnValue(returnValueParam);
+                  } else {
+                    // we can use our pointer directly!
+                    argList[0] = directReturnValuePointer;
+                  }
                 }
               }
               const QMetaObject* meta = objectToCall?objectToCall->metaObject():NULL;
               bool ok = true;
               bool skipFirst = false;
               if (info->isInstanceDecorator()) {
                 skipFirst = true;
                 if (!firstArgument) {
                   argList[1] = &objectToCall;
                 } else {
                   // for the variant call we take the ptr to the variant data, for decorators on CPP objects, we take the cpp ptr
                   argList[1] = &firstArgument;
                 }
                 if (ok) {
                   for (int i = 2; i<argc && ok; i++) {
                     const PythonQtSlotInfo::ParameterInfo& param = params.at(i);
                     //std::cout << param.name.data() << " " << param.typeId << (param.isPointer?"*":"") << (param.isConst?" const":"") << std::endl;
                     argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-2), strict, meta);
                     if (argList[i]==NULL) {
                       ok = false;
                       break;
                     }
                   }
                 }
               } else {
                 for (int i = 1; i<argc && ok; i++) {
                   const PythonQtSlotInfo::ParameterInfo& param = params.at(i);
                   //std::cout << param.name.data() << " " << param.typeId << (param.isPointer?"*":"") << (param.isConst?" const":"") << std::endl;
                   argList[i] = PythonQtConv::ConvertPythonToQt(param, PyTuple_GET_ITEM(args, i-1), strict, meta);
                   if (argList[i]==NULL) {
                     ok = false;
                     break;
                   }
                 }
               }
               if (ok) {
                 (info->decorator()?info->decorator():objectToCall)->qt_metacall(QMetaObject::InvokeMetaMethod, info->slotIndex(), argList);
                 if (argList[0] || returnValueParam.typeId == QMetaType::Void) {
-                  if (!returnValueIsEnum) {
+                  if (directReturnValuePointer) {
-                    result = PythonQtConv::ConvertQtValueToPython(returnValueParam, argList[0]);
+                    result = NULL;
                   } else {
-                    result = PyInt_FromLong(*((unsigned int*)argList[0]));
+                    if (!returnValueIsEnum) {
+                      result = PythonQtConv::ConvertQtValueToPython(returnValueParam, argList[0]);
+                    } else {
+                      result = PyInt_FromLong(*((unsigned int*)argList[0]));
+                    }
                   }
                 } else {
                   QString e = QString("Called ") + info->fullSignature(skipFirst) + ", return type is ignored because it is unknown to PythonQt.";
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                   result = NULL;
                 }
               }
               recursiveEntry--;
               // reset the parameter storage position to the stored pos to "pop" the parameter stack
               PythonQtConv::global_valueStorage.setPos(globalValueStoragePos);
               PythonQtConv::global_ptrStorage.setPos(globalPtrStoragePos);
               PythonQtConv::global_variantStorage.setPos(globalVariantStoragePos);
+              *pythonReturnValue = result;
               // NOTE: it is important to only return here, otherwise the stack will not be popped!!!
-              return result;
+              return result || (directReturnValuePointer && *directReturnValuePointer);
             }
             //-----------------------------------------------------------------------------------
             static PythonQtSlotFunctionObject *pythonqtslot_free_list = NULL;
             PyObject *PythonQtSlotFunction_Call(PyObject *func, PyObject *args, PyObject *kw)
             {
               PythonQtSlotFunctionObject* f = (PythonQtSlotFunctionObject*)func;
               PythonQtSlotInfo*    info = f->m_ml;
-              if (f->m_self->ob_type == &PythonQtInstanceWrapper_Type) {
+              if (PyObject_TypeCheck(f->m_self, &PythonQtInstanceWrapper_Type)) {
                 PythonQtInstanceWrapper* self = (PythonQtInstanceWrapper*) f->m_self;
                 return PythonQtSlotFunction_CallImpl(self->_obj, info, args, kw, self->_wrappedPtr);
               } else if (f->m_self->ob_type == &PythonQtClassWrapper_Type) {
                 return PythonQtSlotFunction_CallImpl(NULL, info, args, kw);
               } else {
                 return NULL;
               }
             }
-            PyObject *PythonQtSlotFunction_CallImpl(QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject * /*kw*/, void* firstArg)
+            PyObject *PythonQtSlotFunction_CallImpl(QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject * /*kw*/, void* firstArg, void** directReturnValuePointer)
             {
               int argc = PyTuple_Size(args);
             #ifdef PYTHONQT_DEBUG
               std::cout << "called " << info->metaMethod()->typeName() << " " << info->metaMethod()->signature() << std::endl;
             #endif
               PyObject* r = NULL;
+              bool ok = false;
+              if (directReturnValuePointer) {
+                *directReturnValuePointer = NULL;
+              }
               if (info->nextInfo()) {
                 // overloaded slot call, try on all slots with strict conversion first
+                bool strict = true;
                 PythonQtSlotInfo* i = info;
-                while (i && r==NULL) {
+                while (i) {
                   bool skipFirst = i->isInstanceDecorator();
                   if (i->parameterCount()-1-(skipFirst?1:0) == argc) {
                     PyErr_Clear();
-                    r = PythonQtCallSlot(objectToCall, args, true, i, firstArg);
+                    ok = PythonQtCallSlot(objectToCall, args, strict, i, firstArg, &r, directReturnValuePointer);
-                    if (PyErr_Occurred()) break;
+                    if (PyErr_Occurred() || ok) break;
                   }
                   i = i->nextInfo();
+                  if (!i) {
-                if (!r) {
+                    if (strict) {
-                  // try on all slots with non-strict conversion
+                      // one more run without being strict
-                  i = info;
+                      strict = false;
-                  while (i && r==NULL) {
+                      i = info;
-                    bool skipFirst = i->isInstanceDecorator();
-                    if (i->parameterCount()-1-(skipFirst?1:0) == argc) {
-                      PyErr_Clear();
-                      r = PythonQtCallSlot(objectToCall, args, false, i, firstArg);
-                      if (PyErr_Occurred()) break;
                     }
-                    i = i->nextInfo();
                   }
                 }
-                if (r==NULL && !PyErr_Occurred()) {
+                if (!ok && !PyErr_Occurred()) {
                   QString e = QString("Could not find matching overload for given arguments:\n" + PythonQtConv::PyObjGetString(args) + "\n The following slots are available:\n");
                   PythonQtSlotInfo* i = info;
                   while (i) {
                     bool skipFirst = i->isInstanceDecorator();
                     e += QString(i->fullSignature(skipFirst)) + "\n";
                     i = i->nextInfo();
                   }
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                 }
               } else {
                 // simple (non-overloaded) slot call
                 bool skipFirst = info->isInstanceDecorator();
                 if (info->parameterCount()-1-(skipFirst?1:0) == argc) {
                   PyErr_Clear();
-                  r = PythonQtCallSlot(objectToCall, args, false, info, firstArg);
+                  ok = PythonQtCallSlot(objectToCall, args, false, info, firstArg, &r, directReturnValuePointer);
-                  if (r==NULL && !PyErr_Occurred()) {
+                  if (!ok && !PyErr_Occurred()) {
                     QString e = QString("Called ") + info->fullSignature(skipFirst) + " with wrong arguments: " + PythonQtConv::PyObjGetString(args);
                     PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                   }
                 } else {
                   QString e = QString("Called ") + info->fullSignature(skipFirst) + " with wrong number of arguments: " + PythonQtConv::PyObjGetString(args);
                   PyErr_SetString(PyExc_ValueError, e.toLatin1().data());
                 }
               }
               return r;
             }
             PyObject *
             PythonQtSlotFunction_New(PythonQtSlotInfo *ml, PyObject *self, PyObject *module)
             {
               PythonQtSlotFunctionObject *op;
               op = pythonqtslot_free_list;
               if (op != NULL) {
                 pythonqtslot_free_list = (PythonQtSlotFunctionObject *)(op->m_self);
                 PyObject_INIT(op, &PythonQtSlotFunction_Type);
               }
               else {
                 op = PyObject_GC_New(PythonQtSlotFunctionObject, &PythonQtSlotFunction_Type);
                 if (op == NULL)
                   return NULL;
               }
               op->m_ml = ml;
               Py_XINCREF(self);
               op->m_self = self;
               Py_XINCREF(module);
               op->m_module = module;
               PyObject_GC_Track(op);
               return (PyObject *)op;
             }
             PythonQtSlotInfo*
             PythonQtSlotFunction_GetSlotInfo(PyObject *op)
             {
               if (!PythonQtSlotFunction_Check(op)) {
                 PyErr_BadInternalCall();
                 return NULL;
               }
               return ((PythonQtSlotFunctionObject *)op) -> m_ml;
             }
             PyObject *
             PythonQtSlotFunction_GetSelf(PyObject *op)
             {
               if (!PythonQtSlotFunction_Check(op)) {
                 PyErr_BadInternalCall();
                 return NULL;
               }
               return ((PythonQtSlotFunctionObject *)op) -> m_self;
             }
             /* Methods (the standard built-in methods, that is) */
             static void
             meth_dealloc(PythonQtSlotFunctionObject *m)
             {
               PyObject_GC_UnTrack(m);
               Py_XDECREF(m->m_self);
               Py_XDECREF(m->m_module);
               m->m_self = (PyObject *)pythonqtslot_free_list;
               pythonqtslot_free_list = m;
             }
             static PyObject *
             meth_get__doc__(PythonQtSlotFunctionObject * /*m*/, void * /*closure*/)
             {
               Py_INCREF(Py_None);
               return Py_None;
             }
             static PyObject *
             meth_get__name__(PythonQtSlotFunctionObject *m, void * /*closure*/)
             {
               return PyString_FromString(m->m_ml->metaMethod()->signature());
             }
             static int
             meth_traverse(PythonQtSlotFunctionObject *m, visitproc visit, void *arg)
             {
               int err;
               if (m->m_self != NULL) {
                 err = visit(m->m_self, arg);
                 if (err)
                   return err;
               }
               if (m->m_module != NULL) {
                 err = visit(m->m_module, arg);
                 if (err)
                   return err;
               }
               return 0;
             }
             static PyObject *
             meth_get__self__(PythonQtSlotFunctionObject *m, void * /*closure*/)
             {
               PyObject *self;
               if (PyEval_GetRestricted()) {
                 PyErr_SetString(PyExc_RuntimeError,
                   "method.__self__ not accessible in restricted mode");
                 return NULL;
               }
               self = m->m_self;
               if (self == NULL)
                 self = Py_None;
               Py_INCREF(self);
               return self;
             }
             static PyGetSetDef meth_getsets [] = {
               {"__doc__",  (getter)meth_get__doc__,  NULL, NULL},
               {"__name__", (getter)meth_get__name__, NULL, NULL},
               {"__self__", (getter)meth_get__self__, NULL, NULL},
               {NULL, NULL, NULL,NULL},
             };
             #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 6
             #define PY_WRITE_RESTRICTED WRITE_RESTRICTED
             #endif
             #define OFF(x) offsetof(PythonQtSlotFunctionObject, x)
             static PyMemberDef meth_members[] = {
               {"__module__",    T_OBJECT,     OFF(m_module), PY_WRITE_RESTRICTED},
               {NULL}
             };
             static PyObject *
             meth_repr(PythonQtSlotFunctionObject *m)
             {
               return PyString_FromFormat("<built-in qt slot %s of %s object at %p>",
                 m->m_ml->metaMethod()->signature(),
                 m->m_self->ob_type->tp_name,
                 m->m_self);
             }
             static int
             meth_compare(PythonQtSlotFunctionObject *a, PythonQtSlotFunctionObject *b)
             {
               if (a->m_self != b->m_self)
                 return (a->m_self < b->m_self) ? -1 : 1;
               if (a->m_ml == b->m_ml)
                 return 0;
               if (strcmp(a->m_ml->metaMethod()->signature(), b->m_ml->metaMethod()->signature()) < 0)
                 return -1;
               else
                 return 1;
             }
             static long
             meth_hash(PythonQtSlotFunctionObject *a)
             {
               long x,y;
               if (a->m_self == NULL)
                 x = 0;
               else {
                 x = PyObject_Hash(a->m_self);
                 if (x == -1)
                   return -1;
               }
               y = _Py_HashPointer((void*)(a->m_ml));
               if (y == -1)
                 return -1;
               x ^= y;
               if (x == -1)
                 x = -2;
               return x;
             }
             PyTypeObject PythonQtSlotFunction_Type = {
               PyObject_HEAD_INIT(&PyType_Type)
 ,
                 "builtin_qt_slot",
                 sizeof(PythonQtSlotFunctionObject),
 ,
                 (destructor)meth_dealloc,     /* tp_dealloc */
 ,          /* tp_print */
 ,          /* tp_getattr */
 ,          /* tp_setattr */
                 (cmpfunc)meth_compare,      /* tp_compare */
                 (reprfunc)meth_repr,      /* tp_repr */
 ,          /* tp_as_number */
 ,          /* tp_as_sequence */
 ,          /* tp_as_mapping */
                 (hashfunc)meth_hash,      /* tp_hash */
                 PythonQtSlotFunction_Call,      /* tp_call */
 ,          /* tp_str */
                 PyObject_GenericGetAttr,    /* tp_getattro */
 ,          /* tp_setattro */
 ,          /* tp_as_buffer */
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
 ,          /* tp_doc */
                 (traverseproc)meth_traverse,    /* tp_traverse */
 ,          /* tp_clear */
 ,          /* tp_richcompare */
 ,          /* tp_weaklistoffset */
 ,          /* tp_iter */
 ,          /* tp_iternext */
 ,          /* tp_methods */
                 meth_members,       /* tp_members */
                 meth_getsets,       /* tp_getset */
 ,          /* tp_base */
 ,          /* tp_dict */
             };
             /* Clear out the free list */
             void
             PythonQtSlotFunction_Fini(void)
             {
               while (pythonqtslot_free_list) {
                 PythonQtSlotFunctionObject *v = pythonqtslot_free_list;
                 pythonqtslot_free_list = (PythonQtSlotFunctionObject *)(v->m_self);
                 PyObject_GC_Del(v);
               }
             }

src/PythonQtSlot.h +1 -1

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

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