GIT_REPOSITORIES/LPP/PythonQt Commit - r62:b7a51b352089

SIGNAL/SLOT methods improved and supported in connect/disconnect...

florianlink -

r62:b7a51b352089

parent child

Context file:

r62:b7a51b352089

Collapse all files

src/PythonQt.cpp +2 -2

             /*
             *
             *  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);
               // according to Python docs, set the type late here, since it can not safely be stored in the struct when declaring it
               PythonQtClassWrapper_Type.tp_base = &PyType_Type;
               // add our own python object types for classes
               if (PyType_Ready(&PythonQtClassWrapper_Type) < 0) {
                 std::cerr << "could not initialize PythonQtClassWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtClassWrapper_Type);
               // add our own python object types for CPP instances
               if (PyType_Ready(&PythonQtInstanceWrapper_Type) < 0) {
                 PythonQt::handleError();
                 std::cerr << "could not initialize PythonQtInstanceWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtInstanceWrapper_Type);
               // add our own python object types for redirection of stdout
               if (PyType_Ready(&PythonQtStdOutRedirectType) < 0) {
                 std::cerr << "could not initialize PythonQtStdOutRedirectType" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtStdOutRedirectType);
               initPythonQtModule(flags & RedirectStdOut);
             }
             PythonQt::~PythonQt() {
               delete _p;
               _p = NULL;
             }
             PythonQtPrivate::~PythonQtPrivate() {
               delete _defaultImporter;
               _defaultImporter = NULL;
               {
                 QHashIterator<QByteArray, PythonQtClassInfo *> i(_knownClassInfos);
                 while (i.hasNext()) {
                   delete i.next().value();
                 }
               }
               PythonQtConv::global_valueStorage.clear();
               PythonQtConv::global_ptrStorage.clear();
               PythonQtConv::global_variantStorage.clear();
               PythonQtMethodInfo::cleanupCachedMethodInfos();
             }
             PythonQtImportFileInterface* PythonQt::importInterface()
             {
               return _self->_p->_importInterface?_self->_p->_importInterface:_self->_p->_defaultImporter;
             }
             void PythonQt::qObjectNoLongerWrappedCB(QObject* o)
             {
               if (_self->_p->_noLongerWrappedCB) {
                 (*_self->_p->_noLongerWrappedCB)(o);
               };
             }
             void PythonQt::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell)
             {
               _p->registerClass(metaobject, package, wrapperCreator, shell);
             }
             void PythonQtPrivate::registerClass(const QMetaObject* metaobject, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator, PythonQtShellSetInstanceWrapperCB* shell)
             {
               // we register all classes in the hierarchy
               const QMetaObject* m = metaobject;
               bool first = true;
               while (m) {
                 PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(m->className());
                 if (!info->pythonQtClassWrapper()) {
                   info->setupQObject(m);
                   createPythonQtClassWrapper(info, package);
                   if (m->superClass()) {
                     PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(m->superClass()->className());
                     info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo));
                   }
                 }
                 if (first) {
                   first = false;
                   if (wrapperCreator) {
                     info->setDecoratorProvider(wrapperCreator);
                   }
                   if (shell) {
                     info->setShellSetInstanceWrapperCB(shell);
                   }
                 }
                 m = m->superClass();
               }
             }
             void PythonQtPrivate::createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package)
             {
               PyObject* pack = packageByName(package);
               PyObject* pyobj = (PyObject*)createNewPythonQtClassWrapper(info, package);
               PyModule_AddObject(pack, info->className(), pyobj);
               if (package && strncmp(package,"Qt",2)==0) {
                 // since PyModule_AddObject steals the reference, we need a incref once more...
                 Py_INCREF(pyobj);
                 // put all qt objects into Qt as well
                 PyModule_AddObject(packageByName("Qt"), info->className(), pyobj);
               }
               info->setPythonQtClassWrapper(pyobj);
             }
             PyObject* PythonQtPrivate::wrapQObject(QObject* obj)
             {
               if (!obj) {
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(obj);
               if (!wrap) {
                 // smuggling it in...
                 PythonQtClassInfo* classInfo = _knownClassInfos.value(obj->metaObject()->className());
                 if (!classInfo || classInfo->pythonQtClassWrapper()==NULL) {
                   registerClass(obj->metaObject());
                   classInfo = _knownClassInfos.value(obj->metaObject()->className());
                 }
                 wrap = createNewPythonQtInstanceWrapper(obj, classInfo);
                 //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               } else {
                 Py_INCREF(wrap);
                 //    mlabDebugConst("MLABPython","qobject wrapper reused " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               }
               return (PyObject*)wrap;
             }
             PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name)
             {
               if (!ptr) {
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               PythonQtInstanceWrapper* wrap = findWrapperAndRemoveUnused(ptr);
               if (!wrap) {
                 PythonQtClassInfo* info = _knownClassInfos.value(name);
                 if (!info) {
                   // maybe it is a PyObject, which we can return directly
                   if (name == "PyObject") {
                     PyObject* p = (PyObject*)ptr;
                     Py_INCREF(p);
                     return p;
                   }
                   // we do not know the metaobject yet, but we might know it by it's name:
                   if (_knownQObjectClassNames.find(name)!=_knownQObjectClassNames.end()) {
                     // yes, we know it, so we can convert to QObject
                     QObject* qptr = (QObject*)ptr;
                     registerClass(qptr->metaObject());
                     info = _knownClassInfos.value(qptr->metaObject()->className());
                   }
                 }
                 if (info && info->isQObject()) {
                   QObject* qptr = (QObject*)ptr;
                   // if the object is a derived object, we want to switch the class info to the one of the derived class:
                   if (name!=(qptr->metaObject()->className())) {
                     registerClass(qptr->metaObject());
                     info = _knownClassInfos.value(qptr->metaObject()->className());
                   }
                   wrap = createNewPythonQtInstanceWrapper(qptr, info);
                   //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
                   return (PyObject*)wrap;
                 }
                 // not a known QObject, so try our wrapper factory:
                 QObject* wrapper = NULL;
                 for (int i=0; i<_cppWrapperFactories.size(); i++) {
                   wrapper = _cppWrapperFactories.at(i)->create(name, ptr);
                   if (wrapper) {
                     break;
                   }
                 }
                 if (info) {
                   // try to downcast in the class hierarchy, which will modify info and ptr if it is successfull
                   ptr  = info->castDownIfPossible(ptr, &info);
                 }
                 if (!info || info->pythonQtClassWrapper()==NULL) {
                   // still unknown, register as CPP class
                   registerCPPClass(name.constData());
                   info = _knownClassInfos.value(name);
                 }
                 if (wrapper && (info->metaObject() != wrapper->metaObject())) {
                   // if we a have a QObject wrapper and the metaobjects do not match, set the metaobject again!
                   info->setMetaObject(wrapper->metaObject());
                 }
                 wrap = createNewPythonQtInstanceWrapper(wrapper, info, ptr);
                 //          mlabDebugConst("MLABPython","new c++ wrapper added " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               } else {
                 Py_INCREF(wrap);
                 //mlabDebugConst("MLABPython","c++ wrapper reused " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->classInfo()->wrappedClassName().latin1());
               }
               return (PyObject*)wrap;
             }
             PyObject* PythonQtPrivate::dummyTuple() {
               static PyObject* dummyTuple = NULL;
               if (dummyTuple==NULL) {
                 dummyTuple = PyTuple_New(1);
                 PyTuple_SET_ITEM(dummyTuple, 0 , PyString_FromString("dummy"));
               }
               return dummyTuple;
             }
             PythonQtInstanceWrapper* PythonQtPrivate::createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr) {
               // call the associated class type to create a new instance...
               PythonQtInstanceWrapper* result = (PythonQtInstanceWrapper*)PyObject_Call(info->pythonQtClassWrapper(), dummyTuple(), NULL);
               result->setQObject(obj);
               result->_wrappedPtr = wrappedPtr;
               result->_ownedByPythonQt = false;
               result->_useQMetaTypeDestroy = false;
               if (wrappedPtr) {
                 _wrappedObjects.insert(wrappedPtr, result);
               } else {
                 _wrappedObjects.insert(obj, result);
                 if (obj->parent()== NULL && _wrappedCB) {
                   // tell someone who is interested that the qobject is wrapped the first time, if it has no parent
                   (*_wrappedCB)(obj);
                 }
               }
               return result;
             }
             PythonQtClassWrapper* PythonQtPrivate::createNewPythonQtClassWrapper(PythonQtClassInfo* info, const char* package) {
               PythonQtClassWrapper* result;
               PyObject* className = PyString_FromString(info->className());
               PyObject* baseClasses = PyTuple_New(1);
               PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PythonQtInstanceWrapper_Type);
               PyObject* typeDict = PyDict_New();
               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);
               return result;
             }
             PyObject*  PythonQtPrivate::createEnumValueInstance(PyObject* enumType, unsigned int enumValue)
             {
               PyObject* args = Py_BuildValue("(i)", enumValue);
               PyObject* result = PyObject_Call(enumType, args, NULL);
               Py_DECREF(args);
               return result;
             }
             PyObject* PythonQtPrivate::createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject) {
               PyObject* result;
               PyObject* className = PyString_FromString(enumName);
               PyObject* baseClasses = PyTuple_New(1);
               PyTuple_SET_ITEM(baseClasses, 0, (PyObject*)&PyInt_Type);
               PyObject* module = PyObject_GetAttrString(parentObject, "__module__");
               PyObject* typeDict = PyDict_New();
               PyDict_SetItemString(typeDict, "__module__", module);
               PyObject* args  = Py_BuildValue("OOO", className, baseClasses, typeDict);
               // create the new int derived type object by calling the core type
               result = PyObject_Call((PyObject *)&PyType_Type, args, NULL);
               Py_DECREF(baseClasses);
               Py_DECREF(typeDict);
               Py_DECREF(args);
               Py_DECREF(className);
               return result;
             }
             PythonQtSignalReceiver* PythonQt::getSignalReceiver(QObject* obj)
             {
               PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
               if (!r) {
                 r = new PythonQtSignalReceiver(obj);
                 _p->_signalReceivers.insert(obj, r);
               }
               return r;
             }
             bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
             {
               bool flag = false;
               PythonQtObjectPtr callable = lookupCallable(module, objectname);
               if (callable) {
                 PythonQtSignalReceiver* r = getSignalReceiver(obj);
                 flag = r->addSignalHandler(signal, callable);
                 if (!flag) {
                   // signal not found
                 }
               } else {
                 // callable not found
               }
               return flag;
             }
             bool PythonQt::addSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
             {
               bool flag = false;
               PythonQtSignalReceiver* r = getSignalReceiver(obj);
               if (r) {
                 flag = r->addSignalHandler(signal, receiver);
               }
               return flag;
             }
             bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname)
             {
               bool flag = false;
               PythonQtObjectPtr callable = lookupCallable(module, objectname);
               if (callable) {
                 PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
                 if (r) {
                   flag = r->removeSignalHandler(signal, callable);
                 }
               } else {
                 // callable not found
               }
               return flag;
             }
             bool PythonQt::removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver)
             {
               bool flag = false;
               PythonQtSignalReceiver* r = _p->_signalReceivers[obj];
               if (r) {
                 flag = r->removeSignalHandler(signal, receiver);
               }
               return flag;
             }
             PythonQtObjectPtr PythonQt::lookupCallable(PyObject* module, const QString& name)
             {
               PythonQtObjectPtr p = lookupObject(module, name);
               if (p) {
                 if (PyCallable_Check(p)) {
                   return p;
                 }
               }
               PyErr_Clear();
               return NULL;
             }
             PythonQtObjectPtr PythonQt::lookupObject(PyObject* module, const QString& name)
             {
               QStringList l = name.split('.');
               PythonQtObjectPtr p = module;
               PythonQtObjectPtr prev;
               QString s;
               QByteArray b;
               for (QStringList::ConstIterator i = l.begin(); i!=l.end() && p; ++i) {
                 prev = p;
                 b = (*i).toLatin1();
                 if (PyDict_Check(p)) {
                   p = PyDict_GetItemString(p, b.data());
                 } else {
                   p.setNewRef(PyObject_GetAttrString(p, b.data()));
                 }
               }
               PyErr_Clear();
               return p;
             }
             PythonQtObjectPtr PythonQt::getMainModule() {
               //both borrowed
               PythonQtObjectPtr dict = PyImport_GetModuleDict();
               return PyDict_GetItemString(dict, "__main__");
             }
             QVariant PythonQt::evalCode(PyObject* object, PyObject* pycode) {
               QVariant result;
               if (pycode) {
                 PyObject* dict = NULL;
                 if (PyModule_Check(object)) {
                   dict = PyModule_GetDict(object);
                 } else if (PyDict_Check(object)) {
                   dict = object;
                 }
                 PyObject* r = NULL;
                 if (dict) {
                   r = PyEval_EvalCode((PyCodeObject*)pycode, dict , dict);
                 }
                 if (r) {
                   result = PythonQtConv::PyObjToQVariant(r);
                   Py_DECREF(r);
                 } else {
                   handleError();
                 }
               } else {
                 handleError();
               }
               return result;
             }
             QVariant PythonQt::evalScript(PyObject* object, const QString& script, int start)
             {
               QVariant result;
               PythonQtObjectPtr p;
               PyObject* dict = NULL;
               if (PyModule_Check(object)) {
                 dict = PyModule_GetDict(object);
               } else if (PyDict_Check(object)) {
                 dict = object;
               }
               if (dict) {
                 p.setNewRef(PyRun_String(script.toLatin1().data(), start, dict, dict));
               }
               if (p) {
                 result = PythonQtConv::PyObjToQVariant(p);
               } else {
                 handleError();
               }
               return result;
             }
             void PythonQt::evalFile(PyObject* module, const QString& filename)
             {
               PythonQtObjectPtr code = parseFile(filename);
               if (code) {
                 evalCode(module, code);
               } else {
                 handleError();
               }
             }
             PythonQtObjectPtr PythonQt::parseFile(const QString& filename)
             {
               PythonQtObjectPtr p;
               p.setNewRef(PythonQtImport::getCodeFromPyc(filename));
               if (!p) {
                 handleError();
               }
               return p;
             }
             PythonQtObjectPtr PythonQt::createModuleFromFile(const QString& name, const QString& filename)
             {
               PythonQtObjectPtr code = parseFile(filename);
               PythonQtObjectPtr module = _p->createModule(name, code);
               return module;
             }
             PythonQtObjectPtr PythonQt::createModuleFromScript(const QString& name, const QString& script)
             {
               PyErr_Clear();
               QString scriptCode = script;
               if (scriptCode.isEmpty()) {
                 // we always need at least a linefeed
                 scriptCode = "\n";
               }
               PythonQtObjectPtr pycode;
               pycode.setNewRef(Py_CompileString((char*)scriptCode.toLatin1().data(), "",  Py_file_input));
               PythonQtObjectPtr module = _p->createModule(name, pycode);
               return module;
             }
             PythonQtObjectPtr PythonQt::createUniqueModule()
             {
               static QString pyQtStr("PythonQt_module");
               QString moduleName = pyQtStr+QString::number(_uniqueModuleCount++);
               return createModuleFromScript(moduleName);
             }
             void PythonQt::addObject(PyObject* object, const QString& name, QObject* qObject)
             {
               if (PyModule_Check(object)) {
                 PyModule_AddObject(object, name.toLatin1().data(), _p->wrapQObject(qObject));
               } else if (PyDict_Check(object)) {
                 PyDict_SetItemString(object, name.toLatin1().data(), _p->wrapQObject(qObject));
               } else {
                 PyObject_SetAttrString(object, name.toLatin1().data(), _p->wrapQObject(qObject));
               }
             }
             void PythonQt::addVariable(PyObject* object, const QString& name, const QVariant& v)
             {
               if (PyModule_Check(object)) {
                 PyModule_AddObject(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
               } else if (PyDict_Check(object)) {
                 PyDict_SetItemString(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
               } else {
                 PyObject_SetAttrString(object, name.toLatin1().data(), PythonQtConv::QVariantToPyObject(v));
               }
             }
             void PythonQt::removeVariable(PyObject* object, const QString& name)
             {
               if (PyDict_Check(object)) {
                 PyDict_DelItemString(object, name.toLatin1().data());
               } else {
                 PyObject_DelAttrString(object, name.toLatin1().data());
               }
             }
             QVariant PythonQt::getVariable(PyObject* object, const QString& objectname)
             {
               QVariant result;
               PythonQtObjectPtr obj = lookupObject(object, objectname);
               if (obj) {
                 result = PythonQtConv::PyObjToQVariant(obj);
               }
               return result;
             }
             QStringList PythonQt::introspection(PyObject* module, const QString& objectname, PythonQt::ObjectType type)
             {
               QStringList results;
               PythonQtObjectPtr object;
               if (objectname.isEmpty()) {
                 object = module;
               } else {
                 object = lookupObject(module, objectname);
                 if (!object && type == CallOverloads) {
                   PyObject* dict = lookupObject(module, "__builtins__");
                   if (dict) {
                     object = PyDict_GetItemString(dict, objectname.toLatin1().constData());
                   }
                 }
               }
               if (object) {
                 if (type == CallOverloads) {
                   if (PythonQtSlotFunction_Check(object)) {
                     PythonQtSlotFunctionObject* o = (PythonQtSlotFunctionObject*)object.object();
                     PythonQtSlotInfo* info = o->m_ml;
                     while (info) {
                       results << info->fullSignature();
                       info = info->nextInfo();
                     }
                   } else if (object->ob_type == &PythonQtClassWrapper_Type) {
                     PythonQtClassWrapper* o = (PythonQtClassWrapper*)object.object();
                     PythonQtSlotInfo* info = o->classInfo()->constructors();
                     while (info) {
                       results << info->fullSignature();
                       info = info->nextInfo();
                     }
                   } else {
                     //TODO: use pydoc!
                     PyObject* doc = PyObject_GetAttrString(object, "__doc__");
                     if (doc) {
                       results << PyString_AsString(doc);
                       Py_DECREF(doc);
                     }
                   }
                 } else {
                   PyObject* keys = NULL;
                   bool isDict = false;
                   if (PyDict_Check(object)) {
                     keys = PyDict_Keys(object);
                     isDict = true;
                   } else {
                     keys = PyObject_Dir(object);
                   }
                   if (keys) {
                     int count = PyList_Size(keys);
                     PyObject* key;
                     PyObject* value;
                     QString keystr;
                     for (int i = 0;i<count;i++) {
                       key = PyList_GetItem(keys,i);
                       if (isDict) {
                         value = PyDict_GetItem(object, key);
                         Py_INCREF(value);
                       } else {
                         value = PyObject_GetAttr(object, key);
                       }
                       if (!value) continue;
                       keystr = PyString_AsString(key);
                       static const QString underscoreStr("__tmp");
                       if (!keystr.startsWith(underscoreStr)) {
                         switch (type) {
                         case Anything:
                           results << keystr;
                           break;
                         case Class:
                           if (value->ob_type == &PyClass_Type) {
                             results << keystr;
                           }
                           break;
                         case Variable:
                           if (value->ob_type != &PyClass_Type
                             && value->ob_type != &PyCFunction_Type
                             && value->ob_type != &PyFunction_Type
                             && value->ob_type != &PyModule_Type
                             ) {
                             results << keystr;
                           }
                           break;
                         case Function:
                           if (value->ob_type == &PyFunction_Type ||
                             value->ob_type == &PyMethod_Type
                             ) {
                             results << keystr;
                           }
                           break;
                         case Module:
                           if (value->ob_type == &PyModule_Type) {
                             results << keystr;
                           }
                           break;
                         default:
                           std::cerr << "PythonQt: introspection: unknown case" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
                         }
                       }
                       Py_DECREF(value);
                     }
                     Py_DECREF(keys);
                   }
                 }
               }
               return results;
             }
             QVariant PythonQt::call(PyObject* object, const QString& name, const QVariantList& args)
             {
               PythonQtObjectPtr callable = lookupCallable(object, name);
               if (callable) {
                 return call(callable, args);
               } else {
                 return QVariant();
               }
             }
             QVariant PythonQt::call(PyObject* callable, const QVariantList& args)
             {
               QVariant r;
               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);
             }
             //---------------------------------------------------------------------------------------------------
             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) {
                   if (qstrncmp(m.signature(), "new_", 4)==0) {
                     if ((decoTypes & ConstructorDecorator) == 0) continue;
                     const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                     if (info->parameters().at(0).isPointer) {
                       QByteArray signature = m.signature();
                       QByteArray nameOfClass = signature.mid(4, signature.indexOf('(')-4);
                       PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
                       PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                       classInfo->addConstructor(newSlot);
                     }
                   } else if (qstrncmp(m.signature(), "delete_", 7)==0) {
                     if ((decoTypes & DestructorDecorator) == 0) continue;
                     QByteArray signature = m.signature();
                     QByteArray nameOfClass = signature.mid(7, signature.indexOf('(')-7);
                     PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
                     PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                     classInfo->setDestructor(newSlot);
                   } else if (qstrncmp(m.signature(), "static_", 7)==0) {
                     if ((decoTypes & StaticDecorator) == 0) continue;
                     QByteArray signature = m.signature();
                     QByteArray nameOfClass = signature.mid(signature.indexOf('_')+1);
                     nameOfClass = nameOfClass.mid(0, nameOfClass.indexOf('_'));
                     PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(nameOfClass);
                     PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::ClassDecorator);
                     classInfo->addDecoratorSlot(newSlot);
                   } else {
                     if ((decoTypes & InstanceDecorator) == 0) continue;
                     const PythonQtMethodInfo* info = PythonQtMethodInfo::getCachedMethodInfo(m, NULL);
                     if (info->parameters().count()>1) {
                       PythonQtMethodInfo::ParameterInfo p = info->parameters().at(1);
                       if (p.isPointer) {
                         PythonQtClassInfo* classInfo = lookupClassInfoAndCreateIfNotPresent(p.name);
                         PythonQtSlotInfo* newSlot = new PythonQtSlotInfo(NULL, m, i, o, PythonQtSlotInfo::InstanceDecorator);
                         classInfo->addDecoratorSlot(newSlot);
                       }
                     }
                   }
                 }
               }
             }
             void PythonQtPrivate::registerQObjectClassNames(const QStringList& names)
             {
               foreach(QString name, names) {
                 _knownQObjectClassNames.insert(name.toLatin1(), true);
               }
             }
             void PythonQtPrivate::removeSignalEmitter(QObject* obj)
             {
               _signalReceivers.remove(obj);
             }
             bool PythonQt::handleError()
             {
               bool flag = false;
               if (PyErr_Occurred()) {
                 // currently we just print the error and the stderr handler parses the errors
                 PyErr_Print();
                 /*
                 // EXTRA: the format of the ptype and ptraceback is not really documented, so I use PyErr_Print() above
                 PyObject *ptype;
                 PyObject *pvalue;
                 PyObject *ptraceback;
                 PyErr_Fetch( &ptype, &pvalue, &ptraceback);
                   Py_XDECREF(ptype);
                   Py_XDECREF(pvalue);
                   Py_XDECREF(ptraceback);
                 */
                 PyErr_Clear();
                 flag = true;
               }
               return flag;
             }
             void PythonQt::addSysPath(const QString& path)
             {
               PythonQtObjectPtr sys;
               sys.setNewRef(PyImport_ImportModule("sys"));
               PythonQtObjectPtr obj = lookupObject(sys, "path");
               PyList_Insert(obj, 0, PythonQtConv::QStringToPyObject(path));
             }
             void PythonQt::overwriteSysPath(const QStringList& paths)
             {
               PythonQtObjectPtr sys;
               sys.setNewRef(PyImport_ImportModule("sys"));
               PyModule_AddObject(sys, "path", PythonQtConv::QStringListToPyList(paths));
             }
             void PythonQt::setModuleImportPath(PyObject* module, const QStringList& paths)
             {
               PyModule_AddObject(module, "__path__", PythonQtConv::QStringListToPyList(paths));
             }
             void PythonQt::stdOutRedirectCB(const QString& str)
             {
               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 = 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,  PythonQtShellSetInstanceWrapperCB* shell)
             {
               _p->registerCPPClass(typeName, parentTypeName, package, wrapperCreator, shell);
             }
             PythonQtClassInfo* PythonQtPrivate::lookupClassInfoAndCreateIfNotPresent(const char* typeName)
             {
               PythonQtClassInfo* info = _knownClassInfos.value(typeName);
               if (!info) {
                 info = new PythonQtClassInfo();
                 info->setupCPPObject(typeName);
                 _knownClassInfos.insert(typeName, info);
               }
               return info;
             }
             void PythonQt::addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb)
             {
               _p->addPolymorphicHandler(typeName, cb);
             }
             void PythonQtPrivate::addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb)
             {
               PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(typeName);
               info->addPolymorphicHandler(cb);
             }
             bool PythonQt::addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset)
             {
               return _p->addParentClass(typeName, parentTypeName, upcastingOffset);
             }
             bool PythonQtPrivate::addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset)
             {
               PythonQtClassInfo* info = _knownClassInfos.value(typeName);
               if (info) {
                 PythonQtClassInfo* parentInfo = lookupClassInfoAndCreateIfNotPresent(parentTypeName);
                 info->addParentClass(PythonQtClassInfo::ParentClassInfo(parentInfo, upcastingOffset));
                 return true;
               } else {
                 return false;
               }
             }
             void PythonQtPrivate::registerCPPClass(const char* typeName, const char* parentTypeName, const char* package, PythonQtQObjectCreatorFunctionCB* wrapperCreator,  PythonQtShellSetInstanceWrapperCB* shell)
             {
               PythonQtClassInfo* info = lookupClassInfoAndCreateIfNotPresent(typeName);
               if (!info->pythonQtClassWrapper()) {
                 info->setupCPPObject(typeName);
                 createPythonQtClassWrapper(info, package);
               }
               if (parentTypeName && strcmp(parentTypeName,"")!=0) {
                 addParentClass(typeName, parentTypeName, 0);
               }
               if (wrapperCreator) {
                 info->setDecoratorProvider(wrapperCreator);
               }
               if (shell) {
                 info->setShellSetInstanceWrapperCB(shell);
               }
             }
             static PyObject *PythonQt_SIGNAL(PyObject * /*type*/, PyObject *args)
             {
               const char* value;
               if (!PyArg_ParseTuple(args, "s", &value)) {
                 return NULL;
               }
               // we do not prepend 0,1 or 2, why should we?
-              return PyString_FromString(value);
+              return PyString_FromString(QByteArray("2") + value);
             }
             static PyObject *PythonQt_SLOT(PyObject * /*type*/, PyObject *args)
             {
               const char* value;
               if (!PyArg_ParseTuple(args, "s", &value)) {
                 return NULL;
               }
               // we do not prepend 0,1 or 2, why should we?
-              return PyString_FromString(value);
+              return PyString_FromString(QByteArray("1") + value);
             }
             static PyMethodDef PythonQt_Qt_methods[] = {
             {"SIGNAL", (PyCFunction)PythonQt_SIGNAL, METH_VARARGS,
             "Returns a signal string"
             },
             {"SLOT", (PyCFunction)PythonQt_SLOT, METH_VARARGS,
             "Returns a slot string"
             }
             };
             PyObject* PythonQtPrivate::packageByName(const char* name)
             {
               if (name==NULL || name[0]==0) {
                 return _pythonQtModule;
               }
               PyObject* v = _packages.value(name);
               if (!v) {
                 v = PyImport_AddModule((QByteArray("PythonQt.") + name).constData());
                 if (strcmp(name,"Qt")==0 || strcmp(name,"QtCore")==0) {
                   // add SIGNAL and SLOT functions
                   PyModule_AddObject(v, "SIGNAL", PyCFunction_New(PythonQt_Qt_methods, v));
                   PyModule_AddObject(v, "SLOT", PyCFunction_New(PythonQt_Qt_methods+1, v));
                 }
                 _packages.insert(name, v);
                 // AddObject steals the reference, so increment it!
                 Py_INCREF(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/PythonQtDoc.h 0 -1

             #ifndef _PYTHONQTDOC_H
             #define _PYTHONQTDOC_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    PythonQtDoc.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-10
             */
             //----------------------------------------------------------------------------------
             /*!
               \if USE_GLOBAL_DOXYGEN_DOC
               \page PythonQtPage PythonQt Overview
               \else
               \mainpage PythonQt Overview
               \endif
              \section Introduction
              \b PythonQt is a dynamic Python (http://www.python.org) binding for Qt (http://www.qtsoftware.com).
              It offers an easy way to embed the Python scripting language into
              your Qt applications. It makes heavy use of the QMetaObject system and thus requires Qt4.x.
              The focus of PythonQt is on embedding Python into an existing C++ application, not on writing the whole
              application completely in Python. If you want to write your whole application in Python,
              you should use <a href="http://www.riverbankcomputing.co.uk/pyqt/">PyQt</a> instead.
              If you are looking for a simple way to embed Python objects into your C++/Qt Application
              and to script parts of your application via Python, PythonQt is the way to go!
              PythonQt is a stable library that was developed to make the
              Image Processing and Visualization platform MeVisLab (http://www.mevislab.de)
              scriptable from Python.
              \section Download
              PythonQt is hosted on SourceForge at http://sourceforge.net/projects/pythonqt , you can access it via SVN
              or download a tarball.
              \section Licensing
              PythonQt is distributed under the LGPL license, so it pairs well with the LGPL of the Qt 4.5 release and allows
              to be used in commercial applications when following the LGPL 2.1 obligations.
              \section LicensingWrapper Licensing of Wrapper Generator
              The build system of PythonQt makes use of a modified version of the GPL'ed QtScript generator,
              located in the "generator" directory.
              See http://labs.trolltech.com/page/Projects/QtScript/Generator for details on the original project.
              Thanks a lot to the QtJambi guys and the QtScript Generator project for the C++ parser and
              Qt typesystem files!
              The PythonQt wrappers generated by the generator located in the "generated_cpp" directory are distributed under the LGPL,
              they are not restriced by the GPL.
              The generated wrappers are pre-generated and checked-in for Qt 4.4.3, so you only need to build and run the
              generator when you want to build additional wrappers or you want to upgrade/downgrade to an newer Qt version.
              You may use the generator to generate C++ bindings for your own C++ classes (e.g. to make them deriveable in Python),
              , but this is currently not documented and involves creating your own typesystem files.
              \section Features
              The following are the built-in features of the PythonQt library:
              - Access all \b slots, \b properties, children and registered enums of any QObject derived class from Python
              - Connecting Qt Signals to Python functions (both from within Python and from C++)
              - Easy wrapping of Python objects from C++ with smart, reference-counting PythonQtObjectPtr.
              - Convenient conversions to/from QVariant for PythonQtObjectPtr.
              - Wrapping of C++ objects (which are not derived from QObject) via PythonQtCppWrapperFactory
              - Extending C++ and QObject derived classes with additional slots, static methods and constructors (see Decorators)
              - StdOut/Err redirection to Qt signals instead of cout
              - Interface for creating your own \c import replacement, so that Python scripts can be e.g. signed/verified before they are executed (PythonQtImportFileInterface)
              - Mapping of plain-old-datatypes and ALL QVariant types to and from Python
              - Support for wrapping of user QVariant types which are registerd via QMetaType
              - Support for Qt namespace (with all enumerators)
              - All PythonQt wrapped objects support the dir() statement, so that you can see easily which attributes a QObject, CPP object or QVariant has
              - No preprocessing/wrapping tool needs to be started, PythonQt can script any QObject without prior knowledge about it (except for the MetaObject information from the \b moc)
              - Multiple inheritance for C++ objects (e.g. a QWidget is derived from QObject and QPaintDevice, PythonQt will automatically cast a QWidget to a QPaintDevice when needed)
              - Polymorphic downcasting (if e.g. PythonQt sees a QEvent, it can downcast it depending on the type(), so the Python e.g. sees a QPaintEvent instead of a plain QEvent)
              - Deriving C++ objects from Python and overwriting virtual method with a Python implementation (requires usage of wrapper generator or manual work!)
              - Extensible handler for Python/C++ conversion of complex types, e.g. mapping of QVector<SomeObject> to/from a Python array
              \section FeaturesQtAll Features (with PythonQt_QtAll linked in)
              Thanks to the new wrapper generator, PythonQt now offers the additional PythonQt_QtAll library which wraps the complete Qt API, including all C++ classes and all non-slots on QObject derived classes.
              This offers the following features:
              - Complete Qt API wrapped and accessible
              - The following modules are available as submodule of the PythonQt module:
               - QtCore
               - QtGui
               - QtNetwork
               - QtOpenGL
               - QtSql
               - QtSvg
               - QtUiTools
               - QtWebKit
               - QtXml
               - QtXmlPatterns
               - (phonon, QtHelp, assistant, designer are currently not supported, this would require some additional effort on the code generator)
              - For convenience, all classes are also available in the PythonQt.Qt module, for people who do not care in which module a class is located
              - Any Qt class that has virtual methods can be easily derived from Python and the virtual methods can be reimplemented in Python
              - Polymorphic downcasting on QEvent, QGraphicsItem, QStyleOption, ...
              - Multiple inheritance support (e.g. QGraphicsTextItem is a QObject AND a QGraphicsItem, PythonQt will handle this well)
              \section Comparision Comparision with PyQt
              - PythonQt is not as Pythonic as PyQt in many details (e.g. operator mapping, pickling, translation support, ...) and it is mainly thought for embedding and intercommunication between Qt/Cpp and Python
              - PythonQt allows to communicate in both directions, e.g. calling a Python object from C++ AND calling a C++ method from Python, while PyQt only handles the Python->C++ direction
              - PythonQt offers properties as Python attributes, while PyQt offers them as setter/getter methods (e.g. QWidget.width is a property in PythonQt and a method in PyQt)
-             - PythonQt offer QtCore.SIGNAL() and QtCore.SLOT() methods for compability, but no 0/1/3 is prepended
              - PythonQt does not support instanceof checks for Qt classes, except for the exact match and derived Python classes
              - QObject.emit to emit Qt signals from Python is not yet implemented
              - PythonQt does not offer to add new signals to Python/C++ objects
              - Ownership of objects is a bit different in PythonQt, currently Python classes derived from a C++ class need to be manually references in PythonQt to not get deleted too early (this will be fixed)
              - Probably there are lots of details that differ, I do not know PyQt that well to list them all.
              \section Interface
              The main interface to PythonQt is the PythonQt singleton.
              PythonQt needs to be initialized via PythonQt::init() once.
              Afterwards you communicate with the singleton via PythonQt::self().
              PythonQt offers a complete Qt binding, which
              needs to be enabled via PythonQt_QtAll::init().
              \section Datatype Datatype Mapping
               The following table shows the mapping between Python and Qt objects:
               <table>
               <tr><th>Qt/C++</th><th>Python</th></tr>
               <tr><td>bool</td><td>bool</td></tr>
               <tr><td>double</td><td>float</td></tr>
               <tr><td>float</td><td>float</td></tr>
               <tr><td>char/uchar,int/uint,short,ushort,QChar</td><td>integer</td></tr>
               <tr><td>long</td><td>integer</td></tr>
               <tr><td>ulong,longlong,ulonglong</td><td>long</td></tr>
               <tr><td>QString</td><td>unicode string</td></tr>
               <tr><td>QByteArray</td><td>str</td></tr>
               <tr><td>char*</td><td>str</td></tr>
               <tr><td>QStringList</td><td>tuple of unicode strings</td></tr>
               <tr><td>QVariantList</td><td>tuple of objects</td></tr>
               <tr><td>QVariantMap</td><td>dict of objects</td></tr>
               <tr><td>QVariant</td><td>depends on type, see below</td></tr>
               <tr><td>QSize, QRect and all other standard Qt QVariants</td><td>variant wrapper that supports complete API of the respective Qt classes</td></tr>
               <tr><td>OwnRegisteredMetaType</td><td>C++ wrapper, optionally with additional information/wrapping provided by registerCPPClass()</td></tr>
               <tr><td>QList<AnyObject*></td><td>converts to a list of CPP wrappers</td></tr>
               <tr><td>EnumType</td><td>integer (all enums that are known via the moc and the Qt namespace are supported)</td></tr>
               <tr><td>QObject (and derived classes)</td><td>QObject wrapper</td></tr>
               <tr><td>C++ object</td><td>CPP wrapper, either wrapped via PythonQtCppWrapperFactory or just decorated with decorators</td></tr>
               <tr><td>PyObject</td><td>PyObject</td></tr>
               </table>
               PyObject is passed as simple pointer, which allows to pass/return any Python Object directly to/from
               a Qt slot.
               QVariants are mapped recursively as given above, e.g. a dictionary can
               contain lists of dictionaries of doubles.
               For example a QVariant of type "String" is mapped to a python unicode string.
               All Qt QVariant types are implemented, PythonQt supports the complete Qt API for these object.
              \section QObject QObject Wrapping
              All classes derived from QObject are automatically wrapped with a python wrapper class
              when they become visible to the Python interpreter. This can happen via
              - the PythonQt::addObject() method
              - when a Qt \b slot returns a QObject derived object to python
              - when a Qt \b signal contains a QObject and is connected to a python function
              It is important that you call PythonQt::registerClass() for any QObject derived class
              that may become visible to Python, except when you add it via PythonQt::addObject().
              This will register the complete parent hierachy of the registered class, so that
              when you register e.g. a QPushButton, QWidget will be registered as well (and all intermediate
              parents).
              From Python, you can talk to the returned QObjects in a natural way by calling
              their slots and receiving the return values. You can also read/write all
              properties of the objects as if they where normal python properties.
              In addition to this, the wrapped objects support
              - className() - returns a string that reprents the classname of the QObject
              - help() - shows all properties, slots, enums, decorator slots and constructors of the object, in a printable form
              - delete() - deletes the object (use with care, especially if you passed the ownership to C++)
              - connect(signal, function) - connect the signal of the given object to a python function
              - connect(signal, qobject, slot) - connect the signal of the given object to a slot of another QObject
              - disconnect(signal, function) - disconnect the signal of the given object from a python function
              - disconnect(signal, qobject, slot) - disconnect the signal of the given object from a slot of another QObject
              - children() - returns the children of the object
              - setParent(QObject) - set the parent
              - QObject* parent() - get the parent
              The below example shows how to connect signals in Python:
              \code
              # define a signal handler function
              def someFunction(flag):
                print flag
              # button1 is a QPushButton that has been added to Python via addObject()
              # connect the clicked signal to a python function:
              button1.connect("clicked(bool)", someFunction)
              \endcode
             \section CPP CPP Wrapping
             You can create dedicated wrapper QObjects for any C++ class. This is done by deriving from PythonQtCppWrapperFactory
             and adding your factory via addWrapperFactory().
             Whenever PythonQt encounters a CPP pointer (e.g. on a slot or signal)
             and it does not known it as a QObject derived class, it will create a generic CPP wrapper. So even unknown C++ objects
             can be passed through Python. If the wrapper factory supports the CPP class, a QObject wrapper will be created for each
             instance that enters Python. An alternative to a complete wrapper via the wrapper factory are decorators, see \ref Decorators
             \section MetaObject Meta Object/Class access
             For each known C++ class, PythonQt provides a Python class. These classes are visible
             inside of the "PythonQt" python module or in subpackages if a package is given when the class is registered.
             A Meta class supports:
             - access to all declared enum values
             - constructors
             - static methods
             - unbound non-static methods
             - help() and className()
             From within Python, you can import the module "PythonQt" to access these classes and the Qt namespace.
             \code
             from PythonQt import QtCore
             # namespace access:
             print QtCore.Qt.AlignLeft
             # constructors
             a = QtCore.QSize(12,13)
             b = QtCore.QFont()
             # static method
             QtCore.QDate.currentDate()
             # enum value
             QtCore.QFont.UltraCondensed
             \endcode
             \section Decorators Decorator slots
             PythonQt introduces a new generic approach to extend any wrapped QObject or CPP object with
             - constructors
             - destructors (for CPP objects)
             - additional slots
             - static slots (callable on both the Meta object and the instances)
             The idea behind decorators is that we wanted to make it as easy as possible to extend
             wrapped objects. Since we already have an implementation for invoking any Qt Slot from
             Python, it looked promising to use this approach for the extension of wrapped objects as well.
             This avoids that the PythonQt user needs to care about how Python arguments are mapped from/to
             Qt when he wants to create static methods, constructors and additional member functions.
             The basic idea about decorators is to create a QObject derived class that implements slots
             which take one of the above roles (e.g. constructor, destructor etc.) via a naming convention.
             These slots are then assigned to other classes via the naming convention.
             - SomeClassName* new_SomeClassName(...) - defines a constructor for "SomeClassName" that returns a new object of type SomeClassName (where SomeClassName can be any CPP class, not just QObject classes)
             - void delete_SomeClassName(SomeClassName* o) - defines a destructor, which should delete the passed in object o
             - anything static_SomeClassName_someMethodName(...) - defines a static method that is callable on instances and the meta class
             - anything someMethodName(SomeClassName* o, ...) - defines a slot that will be available on SomeClassName instances (and derived instances). When such a slot is called the first argument is the pointer to the instance and the rest of the arguments can be used to make a call on the instance.
             The below example shows all kinds of decorators in action:
             \code
             // an example CPP object
             class YourCPPObject {
             public:
               YourCPPObject(int arg1, float arg2) { a = arg1; b = arg2; }
               float doSomething(int arg1) { return arg1*a*b; };
               private:
               int a;
               float b;
             };
             // an example decorator
             class ExampleDecorator : public QObject
             {
               Q_OBJECT
             public slots:
               // add a constructor to QSize that takes a QPoint
               QSize* new_QSize(const QPoint& p) { return new QSize(p.x(), p.y()); }
               // add a constructor for QPushButton that takes a text and a parent widget
               QPushButton* new_QPushButton(const QString& text, QWidget* parent=NULL) { return new QPushButton(text, parent); }
               // add a constructor for a CPP object
               YourCPPObject* new_YourCPPObject(int arg1, float arg2) { return new YourCPPObject(arg1, arg2); }
               // add a destructor for a CPP object
               void delete_YourCPPObject(YourCPPObject* obj) { delete obj; }
               // add a static method to QWidget
               QWidget* static_QWidget_mouseGrabber() { return QWidget::mouseGrabber(); }
               // add an additional slot to QWidget (make move() callable, which is not declared as a slot in QWidget)
               void move(QWidget* w, const QPoint& p) { w->move(p); }
               // add an additional slot to QWidget, overloading the above move method
               void move(QWidget* w, int x, int y) { w->move(x,y); }
               // add a method to your own CPP object
               int doSomething(YourCPPObject* obj, int arg1) { return obj->doSomething(arg1); }
             };
             ...
             PythonQt::self()->addDecorators(new ExampleDecorator());
             PythonQt::self()->registerCPPClass("YourCPPObject");
             \endcode
             After you have registered an instance of the above ExampleDecorator, you can do the following from Python
             (all these calls are mapped to the above decorator slots):
             \code
             from PythonQt import QtCore, QtGui, YourCPPObject
             # call our new constructor of QSize
             size = QtCore.QSize(QPoint(1,2));
             # call our new QPushButton constructor
             button = QtGui.QPushButton("sometext");
             # call the move slot (overload1)
             button.move(QPoint(0,0))
             # call the move slot (overload2)
             button.move(0,0)
             # call the static method
             grabber = QtGui.QWidget.mouseWrapper();
             # create a CPP object via constructor
             yourCpp = YourCPPObject(1,11.5)
             # call the wrapped method on CPP object
             print yourCpp.doSomething(1);
             # destructor will be called:
             yourCpp = None
             \endcode
              \section Building
              PythonQt requires at least Qt 4.2.2 (or higher) and Python 2.3, 2.4, 2.5 or 2.6 on Windows, Linux and MacOS X. It has not yet been tested with Python 3.x, but it should only require minor changes.
              To compile PythonQt, you will need a python developer installation which includes Python's header files and
             the python2x.[lib | dll | so | dynlib].
              The build scripts a currently set to use Python 2.5.
              You may need to tweak the \b build/python.prf file to set the correct Python includes and libs on your system.
              \subsection Windows
              On Windows, the (non-source) Python Windows installer can be used.
              Make sure that you use the same compiler, the current Python distribution is built
              with Visual Studio 2003. If you want to use another compiler, you will need to build
              Python yourself, using your compiler.
              To build PythonQt, you need to set the environment variable \b PYTHON_PATH to point to the root
              dir of the python installation and \b PYTHON_LIB to point to
              the directory where the python lib file is located.
              When using the prebuild Python installer, this will be:
              \code
              > set PYTHON_PATH = c:\Python25
              > set PYTHON_LIB  = c:\Python25\libs
              \endcode
              When using the python sources, this will be something like:
              \code
               > set PYTHON_PATH = c:\yourDir\Python-2.5.1\
               > set PYTHON_LIB  = c:\yourDir\Python-2.5.1\PCbuild8\Win32
              \endcode
              To build all, do the following (after setting the above variables):
              \code
              > cd PythonQtRoot
              > vcvars32
              > qmake
              > nmake
              \endcode
              This should build everything. If Python can not be linked or include files can not be found,
              you probably need to tweak \b build/python.prf
              The tests and examples are located in PythonQt/lib.
              \subsection Linux
              On Linux, you need to install a Python-dev package.
              If Python can not be linked or include files can not be found,
              you probably need to tweak \b build/python.prf
              To build PythonQt, just do a:
              \code
              > cd PythonQtRoot
              > qmake
              > make all
              \endcode
              The tests and examples are located in PythonQt/lib.
              You should add PythonQt/lib to your LD_LIBRARY_PATH so that the runtime
              linker can find the *.so files.
              \subsection MacOsX
              On Mac, Python is installed as a Framework, so you should not need to install it.
              To build PythonQt, just do a:
              \code
              > cd PythonQtRoot
              > qmake
              > make all
              \endcode
              \section Tests
              There is a unit test that tests most features of PythonQt, see the \b tests subdirectory for details.
              \section Examples
              Examples are available in the \b examples directory. The PyScriptingConsole implements a simple
              interactive scripting console that shows how to script a simple application.
              The following shows how to integrate PythonQt into you Qt application:
              \code
              #include "PythonQt.h"
              #include <QApplication>
              ...
              int main( int argc, char **argv )
              {
               QApplication qapp(argc, argv);
               // init PythonQt and Python itself
               PythonQt::init(PythonQt::IgnoreSiteModule | PythonQt::RedirectStdOut);
               // get a smart pointer to the __main__ module of the Python interpreter
               PythonQtObjectPtr mainContext = PythonQt::self()->getMainModule();
               // add a QObject as variable of name "example" to the namespace of the __main__ module
               PyExampleObject example;
               PythonQt::self()->addObject(mainContext, "example", &example);
               // do something
               PythonQt::self()->runScript(mainContext, "print example\n");
               PythonQt::self()->runScript(mainContext, "def multiply(a,b):\n  return a*b;\n");
               QVariantList args;
               args << 42 << 47;
               QVariant result = PythonQt::self()->call(mainContext,"multiply", args);
               ...
              \endcode
             */

src/PythonQtStdDecorators.cpp +46 -16

             /*
             *
             *  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    PythonQtStdDecorators.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2007-04
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtStdDecorators.h"
             #include "PythonQt.h"
             #include "PythonQtClassInfo.h"
             bool PythonQtStdDecorators::connect(QObject* sender, const QByteArray& signal, PyObject* callable)
             {
-              QByteArray signalTmp("2");
+              QByteArray signalTmp;
-              signalTmp += signal;
+              char first = signal.at(0);
+              if (first>='0' && first<='9') {
+                signalTmp = signal;
+              } else {
+                signalTmp = "2" + signal;
+              }
               if (sender) {
                 return PythonQt::self()->addSignalHandler(sender, signalTmp, callable);
               } else {
                 return false;
               }
             }
             bool PythonQtStdDecorators::connect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot)
             {
               bool r = false;
               if (sender && receiver) {
-                QByteArray signalTmp("2");
+                QByteArray signalTmp;
-                signalTmp += signal;
+                char first = signal.at(0);
-                QByteArray slotTmp("1");
+                if (first>='0' && first<='9') {
-                slotTmp += slot;
+                  signalTmp = signal;
-                if (receiver) {
+                } else {
-                  r = QObject::connect(sender, signalTmp, receiver, slotTmp);
+                  signalTmp = "2" + signal;
                 }
+                QByteArray slotTmp;
+                first = slot.at(0);
+                if (first>='0' && first<='9') {
+                  slotTmp = slot;
+                } else {
+                  slotTmp = "1" + slot;
+                }
+                r = QObject::connect(sender, signalTmp, receiver, slotTmp);
               }
               return r;
             }
             bool PythonQtStdDecorators::disconnect(QObject* sender, const QByteArray& signal, PyObject* callable)
             {
-              QByteArray signalTmp("2");
+              QByteArray signalTmp;
-              signalTmp += signal;
+              char first = signal.at(0);
+              if (first>='0' && first<='9') {
+                signalTmp = signal;
+              } else {
+                signalTmp = "2" + signal;
+              }
               if (sender) {
                 return PythonQt::self()->removeSignalHandler(sender, signalTmp, callable);
               } else {
                 return false;
               }
             }
             bool PythonQtStdDecorators::disconnect(QObject* sender, const QByteArray& signal, QObject* receiver, const QByteArray& slot)
             {
               bool r = false;
               if (sender && receiver) {
-                QByteArray signalTmp("2");
+                QByteArray signalTmp;
-                signalTmp += signal;
+                char first = signal.at(0);
-                QByteArray slotTmp("1");
+                if (first>='0' && first<='9') {
-                slotTmp += slot;
+                  signalTmp = signal;
-                if (receiver) {
+                } else {
-                  r = QObject::disconnect(sender, signalTmp, receiver, slotTmp);
+                  signalTmp = "2" + signal;
                 }
+                QByteArray slotTmp;
+                first = slot.at(0);
+                if (first>='0' && first<='9') {
+                  slotTmp = slot;
+                } else {
+                  slotTmp = "1" + slot;
+                }
+                r = QObject::disconnect(sender, signalTmp, receiver, slotTmp);
               }
               return r;
             }
             #undef emit
             void PythonQtStdDecorators::emit(QObject* sender, const QByteArray& signal, PyObject* arg1 ,PyObject* arg2 ,
                       PyObject* arg3 ,PyObject* arg4 ,PyObject* arg5 ,PyObject* arg6 ,PyObject* arg7 )
             {
               // TODO xxx
               // use normal PythonQtSlot calling code, add "allowSignal" to member lookup?!
             }
             #define emit
             QObject* PythonQtStdDecorators::parent(QObject* o) {
               return o->parent();
             }
             void PythonQtStdDecorators::setParent(QObject* o, QObject* parent)
             {
               o->setParent(parent);
             }
             QVariantList PythonQtStdDecorators::children(QObject* o)
             {
               QVariantList v;
               QListIterator<QObject*> it(o->children());
               while (it.hasNext()) {
                 v << qVariantFromValue(it.next());
               }
               return v;
             }

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