GIT_REPOSITORIES/LPP/PythonQt Commit - r8:f65f3e118cc5

- removed warnings...

florianlink -

r8:f65f3e118cc5

parent child

Context file:

r8:f65f3e118cc5

Collapse all files

src/PythonQtQFileImporter.cpp created 644 +80 0

@@ -0,0 +1,80
	1	/*
	2	*
	3	* Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
	4	*
	5	* This library is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Lesser General Public
	7	* License as published by the Free Software Foundation; either
	8	* version 2.1 of the License, or (at your option) any later version.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Lesser General Public License for more details.
	14	*
	15	* Further, this software is distributed without any warranty that it is
	16	* free of the rightful claim of any third person regarding infringement
	17	* or the like. Any license provided herein, whether implied or
	18	* otherwise, applies only to this software file. Patent licenses, if
	19	* any, provided herein do not apply to combinations of this program with
	20	* other software, or any other product whatsoever.
	21	*
	22	* You should have received a copy of the GNU Lesser General Public
	23	* License along with this library; if not, write to the Free Software
	24	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	25	*
	26	* Contact information: MeVis Research GmbH, Universitaetsallee 29,
	27	* 28359 Bremen, Germany or:
	28	*
	29	* http://www.mevis.de
	30	*
	31	*/
	32
	33	//----------------------------------------------------------------------------------
	34	/*!
	35	// \file PythonQtQFileImporter.h
	36	// \author Florian Link
	37	// \author Last changed by $Author: florian $
	38	// \date 2009-03
	39	*/
	40	//----------------------------------------------------------------------------------
	41
	42	#include <QFile>
	43	#include <QFileInfo>
	44
	45	#include "PythonQtQFileImporter.h"
	46
	47	PythonQtQFileImporter::PythonQtQFileImporter() {
	48	}
	49
	50	PythonQtQFileImporter::~PythonQtQFileImporter() {
	51	}
	52
	53	QByteArray PythonQtQFileImporter::readFileAsBytes (const QString &filename) {
	54	QFile f(filename);
	55	if (f.open(QIODevice::ReadOnly)) {
	56	return f.readAll();
	57	} else {
	58	return QByteArray();
	59	}
	60	}
	61
	62	QByteArray PythonQtQFileImporter::readSourceFile (const QString &filename, bool &ok) {
	63	QFile f(filename);
	64	if (f.open(QIODevice::ReadOnly \| QIODevice::Text)) {
	65	ok = true;
	66	return f.readAll();
	67	} else {
	68	ok = false;
	69	return QByteArray();
	70	}
	71	}
	72
	73	bool PythonQtQFileImporter::exists (const QString &filename) {
	74	return QFile::exists(filename);
	75	}
	76
	77	QDateTime PythonQtQFileImporter::lastModifiedDate (const QString &filename) {
	78	QFileInfo fi(filename);
	79	return fi.lastModified();
	80	}

src/PythonQtQFileImporter.h created 644 +63 0

@@ -0,0 +1,63
	1	#ifndef _PYTHONQTQFILEIMPORTER_H
	2	#define _PYTHONQTQFILEIMPORTER_H
	3
	4	/*
	5	*
	6	* Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
	7	*
	8	* This library is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License as published by the Free Software Foundation; either
	11	* version 2.1 of the License, or (at your option) any later version.
	12	*
	13	* This library is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* Lesser General Public License for more details.
	17	*
	18	* Further, this software is distributed without any warranty that it is
	19	* free of the rightful claim of any third person regarding infringement
	20	* or the like. Any license provided herein, whether implied or
	21	* otherwise, applies only to this software file. Patent licenses, if
	22	* any, provided herein do not apply to combinations of this program with
	23	* other software, or any other product whatsoever.
	24	*
	25	* You should have received a copy of the GNU Lesser General Public
	26	* License along with this library; if not, write to the Free Software
	27	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	28	*
	29	* Contact information: MeVis Research GmbH, Universitaetsallee 29,
	30	* 28359 Bremen, Germany or:
	31	*
	32	* http://www.mevis.de
	33	*
	34	*/
	35
	36	//----------------------------------------------------------------------------------
	37	/*!
	38	// \file PythonQtQFileImporter.h
	39	// \author Florian Link
	40	// \author Last changed by $Author: florian $
	41	// \date 2009-03
	42	*/
	43	//----------------------------------------------------------------------------------
	44
	45	#include <PythonQtImportFileInterface.h>
	46
	47	//! default importer implementation using QFile to load python code
	48	class PythonQtQFileImporter : public PythonQtImportFileInterface {
	49	public:
	50	PythonQtQFileImporter();
	51	~PythonQtQFileImporter();
	52
	53	QByteArray readFileAsBytes (const QString &filename);
	54
	55	QByteArray readSourceFile (const QString &filename, bool &ok);
	56
	57	bool exists (const QString &filename);
	58
	59	QDateTime lastModifiedDate (const QString &filename);
	60
	61	};
	62
	63	#endif

examples/CPPPyWrapperExample/CPPPyWrapperExample.cpp +2 -5

             #include <PythonQt.h>
             #include <QtGui>
-            #include "QFileImportInterface.h"
             int main (int argc, char* argv[]) {
                 QApplication app(argc, argv);
                 PythonQt::init();
                 PythonQtObjectPtr mainModule = PythonQt::self()->getMainModule();
                 mainModule.evalScript(QString("import sys\n"));
                 Q_ASSERT(!mainModule.isNull());
                 {
                   // evaluate a python file embedded in executable as resource:
                   mainModule.evalFile(":eyed3tagger.py");
                   // create an object, hold onto its reference
                   PythonQtObjectPtr tag = mainModule.evalScript("EyeD3Tagger()\n", Py_eval_input);
                   Q_ASSERT(!tag.isNull());
                   tag.call("setFileName", QVariantList() << "t.mp3");
                   QVariant fn = tag.call("fileName", QVariantList());
                   Q_ASSERT(fn.toString() == QString("t.mp3"));
                   // tag goes out of scope, reference count decremented.
                 }
-                qDebug() << "test1";
-            /*
                 {
                   // Allow the python system path to recognize QFile paths in the sys.path
-                  QFileImportInterface qfii;
+                  //QFileImportInterface qfii;
+                  PythonQt::self()->setImporter(NULL);
                   // append the Qt resource root directory to the sys.path
                   mainModule.evalScript("sys.path.append(':')\n");
                   mainModule.evalScript("import eyed3tagger\n");
                   PythonQtObjectPtr tag = mainModule.evalScript("eyed3tagger.EyeD3Tagger()\n", Py_eval_input);
                   Q_ASSERT(!tag.isNull());
                   tag.call("setFileName", QVariantList() << "t.mp3");
                   QVariant fn = tag.call("fileName", QVariantList());
                   Q_ASSERT(fn.toString() == QString("t.mp3"));
                 }
-                qDebug() << "test2"; */
                 { // alternative using import and loading it as a real module from sys.path
                   // import sys first
                   mainModule.evalScript(QString("sys.path.append('%1')\n").arg(QDir::currentPath()));
                   mainModule.evalScript("import eyed3tagger\n");
                   PythonQtObjectPtr tag = mainModule.evalScript("eyed3tagger.EyeD3Tagger()\n", Py_eval_input);
                   Q_ASSERT(!tag.isNull());
                   tag.call("setFileName", QVariantList() << "t.mp3");
                   QVariant fn = tag.call("fileName", QVariantList());
                   Q_ASSERT(fn.toString() == QString("t.mp3"));
                 }
                 qDebug() << "finished";
                 return 0;
             }

examples/CPPPyWrapperExample/CPPPyWrapperExample.pro +3 -3

             CONFIG += debug
             VPATH +=
             INCLUDEPATH += . $$(PYTHONQT_ROOT)/src /usr/include/python2.5
-            SOURCES += CPPPyWrapperExample.cpp QFileImportInterface.cpp
+            SOURCES += CPPPyWrapperExample.cpp
-            HEADERS += QFileImportInterface.h
+            mac { CONFIG -= app_bundle }
-            LIBS += -L$$(PYTHONQT_ROOT)/lib -lPythonQt  -lutil
+            LIBS += -L$$(PYTHONQT_ROOT)/lib -lPythonQt_d  -lutil
             RESOURCES += CPPPyWrapperExample.qrc

src/PythonQt.cpp +26 -8

             /*
             *
             *  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>
             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*>");
               PythonQt::self()->addDecorators(new PythonQtStdDecorators());
               PythonQt::priv()->addVariantWrapper("QBitArray", new PythonQtQBitArrayWrapper);
               PythonQt::priv()->addVariantWrapper("QDate", new PythonQtQDateWrapper);
               PythonQt::priv()->addVariantWrapper("QTime", new PythonQtQTimeWrapper);
               PythonQt::priv()->addVariantWrapper("QDateTime", new PythonQtQDateTimeWrapper);
               PythonQt::priv()->addVariantWrapper("QUrl", new PythonQtQUrlWrapper);
               PythonQt::priv()->addVariantWrapper("QLocale", new PythonQtQLocaleWrapper);
               PythonQt::priv()->addVariantWrapper("QRect", new PythonQtQRectWrapper);
               PythonQt::priv()->addVariantWrapper("QRectF", new PythonQtQRectFWrapper);
               PythonQt::priv()->addVariantWrapper("QSize", new PythonQtQSizeWrapper);
               PythonQt::priv()->addVariantWrapper("QSizeF", new PythonQtQSizeFWrapper);
               PythonQt::priv()->addVariantWrapper("QLine", new PythonQtQLineWrapper);
               PythonQt::priv()->addVariantWrapper("QLineF", new PythonQtQLineFWrapper);
               PythonQt::priv()->addVariantWrapper("QPoint", new PythonQtQPointWrapper);
               PythonQt::priv()->addVariantWrapper("QPointF", new PythonQtQPointFWrapper);
               PythonQt::priv()->addVariantWrapper("QRegExp", new PythonQtQRegExpWrapper);
               PythonQt::priv()->addVariantWrapper("QFont", new PythonQtQFontWrapper);
               PythonQt::priv()->addVariantWrapper("QPixmap", new PythonQtQPixmapWrapper);
               PythonQt::priv()->addVariantWrapper("QBrush", new PythonQtQBrushWrapper);
               PythonQt::priv()->addVariantWrapper("QColor", new PythonQtQColorWrapper);
               PythonQt::priv()->addVariantWrapper("QPalette", new PythonQtQPaletteWrapper);
               PythonQt::priv()->addVariantWrapper("QIcon", new PythonQtQIconWrapper);
               PythonQt::priv()->addVariantWrapper("QImage", new PythonQtQImageWrapper);
               PythonQt::priv()->addVariantWrapper("QPolygon", new PythonQtQPolygonWrapper);
               PythonQt::priv()->addVariantWrapper("QRegion", new PythonQtQRegionWrapper);
               PythonQt::priv()->addVariantWrapper("QBitmap", new PythonQtQBitmapWrapper);
               PythonQt::priv()->addVariantWrapper("QCursor", new PythonQtQCursorWrapper);
               PythonQt::priv()->addVariantWrapper("QSizePolicy", new PythonQtQSizePolicyWrapper);
               PythonQt::priv()->addVariantWrapper("QKeySequence", new PythonQtQKeySequenceWrapper);
               PythonQt::priv()->addVariantWrapper("QPen", new PythonQtQPenWrapper);
               PythonQt::priv()->addVariantWrapper("QTextLength", new PythonQtQTextLengthWrapper);
               PythonQt::priv()->addVariantWrapper("QTextFormat", new PythonQtQTextFormatWrapper);
               PythonQt::priv()->addVariantWrapper("QMatrix", new PythonQtQMatrixWrapper);
             }
             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
               if (PyType_Ready(&PythonQtWrapper_Type) < 0) {
                 std::cerr << "could not initialize PythonQtWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtWrapper_Type);
               // add our own python object types for qt objects
               if (PyType_Ready(&PythonQtVariantWrapper_Type) < 0) {
                 std::cerr << "could not initialize PythonQtVariantWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtVariantWrapper_Type);
               // add our own python object types for qt objects
               if (PyType_Ready(&PythonQtMetaObjectWrapper_Type) < 0) {
                 std::cerr << "could not initialize PythonQtMetaObjectWrapper_Type" << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
               }
               Py_INCREF(&PythonQtMetaObjectWrapper_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<int , QPair<PythonQtClassInfo*, QObject*> > i(_knownVariantWrappers);
                 while (i.hasNext()) {
                   delete i.next().value().first;
                 }
               }
               {
                 QHashIterator<QByteArray, PythonQtSlotInfo *> i(_constructorSlots);
                 while (i.hasNext()) {
-                  delete i.next().value();
+                  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()) {
-                  delete i.next().value();
+                  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();
               delete _qtNamespace;
             }
             PythonQtImportFileInterface* PythonQt::importInterface()
             {
-              return _self->_p->_importInterface;
+              return _self->_p->_importInterface?_self->_p->_importInterface:_self->_p->_defaultImporter;
             }
             void PythonQt::registerClass(const QMetaObject* metaobject)
             {
               _p->registerClass(metaobject);
             }
             void PythonQt::qObjectNoLongerWrappedCB(QObject* o)
             {
               if (_self->_p->_noLongerWrappedCB) {
                 (*_self->_p->_noLongerWrappedCB)(o);
               };
             }
             void PythonQtPrivate::registerClass(const QMetaObject* metaobject)
             {
               // we register all classes in the hierarchy
               const QMetaObject* m = metaobject;
               while (m) {
                 PythonQtClassInfo* info = _knownQtClasses.value(m->className());
                 if (!info) {
                   info = new PythonQtClassInfo(m);
                   _knownQtClasses.insert(m->className(), info);
                   PyModule_AddObject(_pythonQtModule, m->className(), (PyObject*)createNewPythonQtMetaObjectWrapper(info));
                 }
                 m = m->superClass();
               }
             }
             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;
               }
               PythonQtWrapper* 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 = createNewPythonQtWrapper(obj, classInfo);
                 //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
               } else {
                 Py_INCREF(wrap);
                 //    mlabDebugConst("MLABPython","qobject wrapper reused " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
               }
               return (PyObject*)wrap;
             }
             PyObject* PythonQtPrivate::wrapPtr(void* ptr, const QByteArray& name)
             {
               if (!ptr) {
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               PythonQtWrapper* 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 = createNewPythonQtWrapper(qptr, info);
                   //    mlabDebugConst("MLABPython","new qobject wrapper added " << " " << wrap->_obj->className() << " " << wrap->_info->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():&QObject::staticQtMetaObject, name);
                     _knownQtWrapperClasses.insert(name, info);
                     PyModule_AddObject(_pythonQtModule, name, (PyObject*)createNewPythonQtMetaObjectWrapper(info));
                   } else {
                     if (wrapper && (info->metaObject() != wrapper->metaObject())) {
                       info->setMetaObject(wrapper->metaObject());
                     }
                   }
                   wrap = createNewPythonQtWrapper(wrapper, info, ptr);
                   //          mlabDebugConst("MLABPython","new c++ wrapper added " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
                 }
               } else {
                 Py_INCREF(wrap);
                 //mlabDebugConst("MLABPython","c++ wrapper reused " << wrap->_wrappedPtr << " " << wrap->_obj->className() << " " << wrap->_info->wrappedClassName().latin1());
               }
               return (PyObject*)wrap;
             }
             void PythonQt::registerCPPClassNames(const QStringList& names)
             {
               foreach ( QString n, names) {
                 QByteArray name = n.toLatin1();
                 PythonQtClassInfo* info = _p->_knownQtWrapperClasses.value(name);
                 if (!info) {
                   info = new PythonQtClassInfo(&QObject::staticMetaObject, name);
                   _p->_knownQtWrapperClasses.insert(name, info);
                   PyModule_AddObject(_p->_pythonQtModule, name.data(), (PyObject*)_p->createNewPythonQtMetaObjectWrapper(info));
                 }
               }
             }
             PythonQtWrapper* PythonQtPrivate::createNewPythonQtWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr) {
               PythonQtWrapper* result;
               result = (PythonQtWrapper *)PythonQtWrapper_Type.tp_new(&PythonQtWrapper_Type,
                 NULL, NULL);
               result->setQObject(obj);
               result->_info = info;
               result->_wrappedPtr = wrappedPtr;
               result->_ownedByPythonQt = 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;
             }
             PythonQtVariantWrapper* PythonQtPrivate::createNewPythonQtVariantWrapper(const QVariant& variant) {
               PythonQtVariantWrapper* result;
               result = (PythonQtVariantWrapper *)PythonQtVariantWrapper_Type.tp_new(&PythonQtVariantWrapper_Type,
                 NULL, NULL);
               *result->_variant = variant;
               QPair<PythonQtClassInfo*, QObject*> pair = _knownVariantWrappers.value(variant.userType());
               result->_wrapper = pair.second;
               result->_info = pair.first;
               return result;
             }
             PythonQtMetaObjectWrapper* PythonQtPrivate::createNewPythonQtMetaObjectWrapper(PythonQtClassInfo* info) {
               PythonQtMetaObjectWrapper* result;
               result = (PythonQtMetaObjectWrapper *)PythonQtMetaObjectWrapper_Type.tp_new(&PythonQtMetaObjectWrapper_Type,
                 NULL, NULL);
               result->_info = info;
               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() || o->m_self->ob_type == &PythonQtVariantWrapper_Type);
                       info = info->nextInfo();
                     }
                   } else if (object->ob_type == &PythonQtMetaObjectWrapper_Type) {
                     PythonQtMetaObjectWrapper* o = (PythonQtMetaObjectWrapper*)object.object();
                     PythonQtSlotInfo* info = o->_info->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, true, false);
             }
             void PythonQt::addClassDecorators(QObject* o)
             {
               _p->addDecorators(o, false, true);
             }
             void PythonQt::addDecorators(QObject* o)
             {
               _p->addDecorators(o, true, true);
             }
             void PythonQt::registerQObjectClassNames(const QStringList& names)
             {
               _p->registerQObjectClassNames(names);
             }
             void PythonQt::setImporter(PythonQtImportFileInterface* importInterface)
             {
-              static bool first = true;
-              if (first) {
-                first = false;
-                _p->_importInterface = 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;
             }
             void PythonQtPrivate::addDecorators(QObject* o, bool instanceDeco, bool classDeco)
             {
               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 (!classDeco) 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 (!classDeco) 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 (!classDeco) 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 (!instanceDeco) 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::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));
               _p->_qtNamespace = new PythonQtClassInfo(&staticQtMetaObject);
               PyModule_AddObject(_p->_pythonQtModule, "Qt", (PyObject*)_p->createNewPythonQtMetaObjectWrapper(_p->_qtNamespace));
               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::addVariantWrapper(const char* typeName, QObject* wrapper)
             {
               _p->addVariantWrapper(typeName, wrapper);
             }
             void PythonQtPrivate::addVariantWrapper(const char* typeName, QObject* wrapper)
             {
               int type = QMetaType::type(typeName);
               PythonQtClassInfo* info = new PythonQtClassInfo(wrapper->metaObject(), typeName);
               _knownVariantWrappers.insert(type, qMakePair(info, wrapper));
               addDecorators(wrapper, false, true);
               PyModule_AddObject(_pythonQtModule, typeName, (PyObject*)createNewPythonQtMetaObjectWrapper(info));
             }
             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);
             }
             PythonQtWrapper* PythonQtPrivate::findWrapperAndRemoveUnused(void* obj)
             {
               PythonQtWrapper* 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 +19 -1

             #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 "PythonQtWrapper.h"
             #include "PythonQtVariantWrapper.h"
             #include "PythonQtMetaObjectWrapper.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);
             //! 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);
               //! 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)
               //! All added metaobjects will be visible under the className in the PythonQt module as MetaObjectWrappers and the enums
               //! and constructors (added by addConstructors) will be available.
               /* 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);
               //! 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);
               //! this will register CPP classnames as known CPP classes (NOT QObjects) and make their MetaObjectWrapper available in
               //! the PythonQt module. In combination with addConstuctors(), this can be used to create CPP objects from PythonQt
               void registerCPPClassNames(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);
               //@}
               //@{ 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 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 addVariantWrapper(const char* typeName, QObject* wrapper);
               //! 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().
-              //! It can only be called once, further calls will be ignored silently. (ownership stays with caller)
+              //! 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();
               //! returns if the id is the id for PythonQtObjectPtr
               bool isPythonQtObjectPtrMetaId(int id) { return _PythonQtObjectPtr_metaId == id; }
               //! 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);
               //! 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, bool instanceDeco, bool classDeco);
               //! add a wrapper object for the given qvariant, also does an addConstructors() to add constructors for variants
               void addVariantWrapper(const char* typeName, QObject* wrapper);
               //! 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 PythonQtMetaObjectWrapper object
               PythonQtMetaObjectWrapper* createNewPythonQtMetaObjectWrapper(PythonQtClassInfo* info);
               //! helper method that creates a PythonQtWrapper object and registers it in the object map
               PythonQtWrapper* createNewPythonQtWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);
               //! helper method that creates a PythonQtVariantWrapper object
               PythonQtVariantWrapper* createNewPythonQtVariantWrapper(const QVariant& variant);
               //! get the class info for a meta object (if available)
               PythonQtClassInfo* getClassInfo(const QMetaObject* meta) { return _knownQtClasses.value(meta->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);
             private:
               //! get the wrapper for a given pointer (and remove a wrapper of an already destroyed qobject)
               PythonQtWrapper* findWrapperAndRemoveUnused(void* obj);
               //! stores pointer to PyObject mapping of wrapped QObjects AND C++ objects
               QHash<void* , PythonQtWrapper *>       _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<int , QPair<PythonQtClassInfo*, QObject*> > _knownVariantWrappers;
               PythonQtClassInfo* _qtNamespace;
               int _initFlags;
               int _PythonQtObjectPtr_metaId;
               friend class PythonQt;
             };
             #endif

src/PythonQtConversion.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    PythonQtConversion.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtConversion.h"
             #include "PythonQtVariants.h"
             #include "PythonQtVariantWrapper.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;
             PyObject* PythonQtConv::GetPyBool(bool val)
             {
               PyObject* r = val?Py_True:Py_False;
               Py_INCREF(r);
               return r;
             }
             PyObject* PythonQtConv::ConvertQtValueToPython(const PythonQtMethodInfo::ParameterInfo& info, void* data) {
               if (info.typeId == QMetaType::Void) {
                 Py_INCREF(Py_None);
                 return Py_None;
               } else {
                 if (info.isPointer && (info.typeId == PythonQtMethodInfo::Unknown)) {
                   // try to convert the pointer to a Python Object
                   PyObject* pyObj = PythonQt::priv()->wrapPtr(*((void**)data), info.name);
                   if (pyObj) {
                     return pyObj;
                   } else {
                     std::cerr << "unknown pointer type " << info.name.data() << ", in " << __FILE__ << ":" << __LINE__ << std::endl;
                     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) {
                     if (info.name.startsWith("QList<")) {
                       QByteArray innerType = info.name.mid(6,info.name.length()-7);
                       if (innerType.endsWith("*")) {
                         innerType.truncate(innerType.length()-1);
                         return ConvertQListWithPointersToPython((QList<void*>*)data, innerType);
                       }
                     }
                   }
                   // handle values that are not yet handled and not pointers
                   return ConvertQtValueToPythonInternal(info.typeId, data);
                 }
               }
             }
             PyObject* PythonQtConv::ConvertQtValueToPythonInternal(int type, 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));
               // the following cases could be handled by the default case, but it is faster to do it with
               // direct casts:
               case QMetaType::QDate:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QDate*)data)));
               case QMetaType::QTime:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QTime*)data)));
               case QMetaType::QDateTime:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QDateTime*)data)));
               case QMetaType::QRect:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QRect*)data)));
               case QMetaType::QSize:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QSize*)data)));
               case QMetaType::QPoint:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QPoint*)data)));
               case QMetaType::QColor:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QColor*)data)));
               case QMetaType::QPixmap:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QPixmap*)data)));
               case QMetaType::QUrl:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QUrl*)data)));
               case QMetaType::QRectF:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QRectF*)data)));
               case QMetaType::QSizeF:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QSizeF*)data)));
               case QMetaType::QLine:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QLine*)data)));
               case QMetaType::QLineF:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QLineF*)data)));
               case QMetaType::QPointF:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QPointF*)data)));
               case QMetaType::QRegExp:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QRegExp*)data)));
               case QMetaType::QBitArray:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QBitArray*)data)));
               case QMetaType::QLocale:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QLocale*)data)));
               case QMetaType::QFont:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QFont*)data)));
               case QMetaType::QBrush:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QBrush*)data)));
               case QMetaType::QPalette:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QPalette*)data)));
               case QMetaType::QIcon:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(qVariantFromValue(*((QIcon*)data)));
               case QMetaType::QImage:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QImage*)data)));
               case QMetaType::QPolygon:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QPolygon*)data)));
               case QMetaType::QRegion:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QRegion*)data)));
               case QMetaType::QBitmap:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(qVariantFromValue(*((QBitmap*)data)));
               case QMetaType::QCursor:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QCursor*)data)));
               case QMetaType::QSizePolicy:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(QVariant(*((QSizePolicy*)data)));
               case QMetaType::QKeySequence:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(qVariantFromValue(*((QKeySequence*)data)));
               case QMetaType::QPen:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(qVariantFromValue(*((QPen*)data)));
               case QMetaType::QTextLength:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(qVariantFromValue(*((QTextLength*)data)));
               case QMetaType::QTextFormat:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(qVariantFromValue(*((QTextFormat*)data)));
               case QMetaType::QMatrix:
                 return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(qVariantFromValue(*((QMatrix*)data)));
               default:
                 if (PythonQt::priv()->isPythonQtObjectPtrMetaId(type)) {
                   PyObject* o = ((PythonQtObjectPtr*)data)->object();
                   Py_INCREF(o);
                   return o;
                 } else {
                   if (type != PythonQtMethodInfo::Unknown) {
                     QVariant v(type, data);
                     if (v.isValid()) {
                       return (PyObject*)PythonQt::priv()->createNewPythonQtVariantWrapper(v);
                     }
                   }
                   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 (info.isPointer) {
                  if (obj->ob_type == &PythonQtWrapper_Type) {
                    PythonQtWrapper* wrap = (PythonQtWrapper*)obj;
                    // c++ wrapper, check if the class names of the c++ objects match
                    if (wrap->_info->isCPPWrapper()) {
                      //TODO: we could support inheritance on cpp wrappers as well
                      if (wrap->_info->wrappedCPPClassName() == info.name) {
                        PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, wrap->_wrappedPtr, ptr);
                      } else {
                        // not matching
                      }
                    } else {
                      if (wrap->_info->inherits(info.name)) {
                        QObject* myObject = wrap->_obj;
                        PythonQtValueStorage_ADD_VALUE(global_ptrStorage, void*, myObject, ptr);
                      } else {
                        // not matching
                      }
                    }
                  } else
                    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);
                        }
                      }
                      // EXTRA: we could support pointers to other simple types, but this would not make sense in most situations
                    }
                } 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 = ConvertPythonListToQListOfType(obj, (QList<void*>*)ptr, innerType, 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 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 == &PythonQtWrapper_Type) {
                   PythonQtWrapper* wrap = (PythonQtWrapper*)val;
                   // c++ wrapper, check if the class names of the c++ objects match
                   if (wrap->_info->isCPPWrapper()) {
                     // is this worth anything? we loose the knowledge of the cpp object type
                     v = qVariantFromValue(wrap->_wrappedPtr);
                   } else {
                     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 if (val->ob_type == &PythonQtVariantWrapper_Type) {
                   PythonQtVariantWrapper* varWrap = (PythonQtVariantWrapper*)val;
                   if (varWrap->_variant->userType() == type) {
                     v = *varWrap->_variant;
                     return v;
                   }
                 } 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 == &PythonQtVariantWrapper_Type) {
                   PythonQtVariantWrapper* varWrap = (PythonQtVariantWrapper*)val;
                   if (varWrap->_variant->userType() == type) {
                     v = *varWrap->_variant;
                   }
                 } 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::ConvertQListWithPointersToPython(QList<void*>* list, const QByteArray& type)
             {
               PyObject* result = PyTuple_New(list->count());
               int i = 0;
               foreach (void* value, *list) {
                 PyTuple_SET_ITEM(result, i, PythonQt::priv()->wrapPtr(value, type));
                 i++;
               }
               return result;
             }
-            bool PythonQtConv::ConvertPythonListToQListOfType(PyObject* obj, QList<void*>* list, const QByteArray& type, bool strict)
+            bool PythonQtConv::ConvertPythonListToQListOfType(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 == &PythonQtWrapper_Type) {
                     PythonQtWrapper* wrap = (PythonQtWrapper*)value;
                     // c++ wrapper, check if the class names of the c++ objects match
                     if (wrap->_info->isCPPWrapper()) {
                       //TODO: we could support inheritance on cpp wrappers as well
                       if (wrap->_info->wrappedCPPClassName() == type) {
                         list->append(wrap->_wrappedPtr);
                       } else {
                         result = false;
                         break;
                       }
                     } else {
                       if (wrap->_info->inherits(type)) {
                         QObject* myObject = wrap->_obj;
                         list->append((void*)myObject);
                       } else {
                         result = false;
                         break;
                       }
                     }
                   }
                 }
               }
               return result;
             }

src/PythonQtDoc.h +2 -6

             #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.trolltech.com).
+             \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.
              In contrast to <a href="http://www.riverbankcomputing.co.uk/pyqt/">PyQt</a> , PythonQt is \b not a complete
              Python wrapper around the complete Qt functionality. So if you are looking for a way to
              write complete applications in Python using the Qt GUI, you should use PyQt.
              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 Licensing
              PythonQt is distributed under the LGPL license.
              \section Download
              PythonQt is hosted on SourceForge at http://sourceforge.net/projects/pythonqt , you can access it via SVN
              or download a tarball.
              \section Features
              - Easy wrapping of Python objects from C++ with smart, reference-counting PythonQtObjectPtr.
              - Convenient conversions to/from QVariant for PythonQtObjectPtr.
              - 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++)
              - 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)
              \section Non-Features
              Features that PythonQt does NOT support (and will not support):
              - you can not derive from QObjects inside of Python, this would require wrapper generation like PyQt does
              - you can only script QObject derived classes, for normal C++ classes you need to create a PythonQtCppWrapperFactory and adequate wrapper classes or add decorator slots
              - you can not access normal member functions of QObjects, only slots and properties, because the \b moc does not store normal member functions in the MetaObject system
              \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 default binding for the complete QWidget set, which
              needs to be enabled via PythonQtGui::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>variant wrapper, optionally with a wrapper provided by addVariantWrapper()</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
              - 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 QObject 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 CPP class, QObject derived class and QVariant type, PythonQt provides a Meta class. These meta classes are visible
             inside of the "PythonQt" python module.
             A Meta class supports:
             - access to all declared enum values
             - constructors
             - static decorator slots
             - help() and className()
             From within Python, you can import the module "PythonQt" to access these meta objects and the Qt namespace.
             \code
             from PythonQt import *
             # namespace access:
             print Qt.AlignLeft
             # constructors
             a = QSize(12,13)
             b = QFont()
             # static method
             QDate.currentDate()
             # enum value
             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.
             - QVariant new_SomeClassName(...) - defines a constructor for "SomeClassName" that returns a QVariant
             - 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 variant that takes a QPoint
               QVariant new_QSize(const QPoint& p) { return 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()->registerClass(&QPushButton::staticMetaObject);
             PythonQt::self()->registerCPPClassNames(QStringList() << "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 *
             # call our new constructor of QSize
             size = QSize(QPoint(1,2));
             # call our new QPushButton constructor
             button = 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 = 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 or 2.5 on Windows, Linux and MacOS X.
+             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);
               // register all other QObjects that you want to script and that are returned by your API
               PythonQt::self()->registerClass(&QMainWindow::staticMetaObject);
               PythonQt::self()->registerClass(&QPushButton::staticMetaObject);
               ...
               // 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
-              \section TODOs
-              - add more information on how to distribute an application that uses PythonQt, including the Python distribution
             */

src/PythonQtImportFileInterface.h +3 0

             #ifndef _PYTHONQTIMPORTFILEINTERFACE_H
             #define _PYTHONQTIMPORTFILEINTERFACE_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    PythonQtImportFileInterface.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include <QDateTime>
             #include <QString>
             #include <QByteArray>
             //! Defines an abstract interface to file access for the Python import statement.
             //! see PythonQt::setImporter()
             class PythonQtImportFileInterface {
             public:
+              // get rid of warnings
+              virtual ~PythonQtImportFileInterface() {}
               //! read the given file as byte array, without doing any linefeed translations
               virtual QByteArray readFileAsBytes(const QString& filename) = 0;
               //! read a source file, expects a readable Python text file with translated line feeds.
               //! If the file can not be load OR it can not be verified, ok is set to false
               virtual QByteArray readSourceFile(const QString& filename, bool& ok) = 0;
               //! returns if the file exists
               virtual bool exists(const QString& filename) = 0;
               //! get the last modified data of a file
               virtual QDateTime lastModifiedDate(const QString& filename) = 0;
             };
             #endif

src/PythonQtImporter.cpp +36 -45

             /*
              *
              *  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    PythonQtImporter.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             // This module was inspired by the zipimport.c module of the original
             // Python distribution. Most of the functions are identical or slightly
             // modified to do all the loading of Python files via an external file interface.
             // In contrast to zipimport.c, this module also writes *.pyc files
             // automatically if it has write access/is not inside of a zip file.
             //----------------------------------------------------------------------------------
             #include "PythonQtImporter.h"
             #include "PythonQtImportFileInterface.h"
             #include "PythonQt.h"
             #include <QFile>
             #include <QFileInfo>
             #define IS_SOURCE   0x0
             #define IS_BYTECODE 0x1
             #define IS_PACKAGE  0x2
             struct st_mlab_searchorder {
               char suffix[14];
               int type;
             };
             /* mlab_searchorder defines how we search for a module in the Zip
                archive: we first search for a package __init__, then for
                non-package .pyc, .pyo and .py entries. The .pyc and .pyo entries
                are swapped by initmlabimport() if we run in optimized mode. Also,
                '/' is replaced by SEP there. */
              struct st_mlab_searchorder mlab_searchorder[] = {
               {"/__init__.pyc", IS_PACKAGE | IS_BYTECODE},
               {"/__init__.pyo", IS_PACKAGE | IS_BYTECODE},
               {"/__init__.py", IS_PACKAGE | IS_SOURCE},
               {".pyc", IS_BYTECODE},
               {".pyo", IS_BYTECODE},
               {".py", IS_SOURCE},
               {"", 0}
             };
             extern PyTypeObject PythonQtImporter_Type;
             PyObject *PythonQtImportError;
             QString PythonQtImport::getSubName(const QString& str)
             {
               int idx = str.lastIndexOf('.');
               if (idx!=-1) {
                 return str.mid(idx+1);
               } else {
                 return str;
               }
             }
             PythonQtImport::module_info PythonQtImport::getModuleInfo(PythonQtImporter* self, const QString& fullname)
             {
               QString subname;
               struct st_mlab_searchorder *zso;
               subname = getSubName(fullname);
               QString path = *self->_path + "/" + subname;
               QString test;
               for (zso = mlab_searchorder; *zso->suffix; zso++) {
                 test = path + zso->suffix;
                 if (PythonQt::importInterface()->exists(test)) {
                   if (zso->type & IS_PACKAGE)
                     return MI_PACKAGE;
                   else
                     return MI_MODULE;
                 }
               }
               return MI_NOT_FOUND;
             }
             /* PythonQtImporter.__init__
               Just store the path argument
             */
-            int PythonQtImporter_init(PythonQtImporter *self, PyObject *args, PyObject *kwds)
+            int PythonQtImporter_init(PythonQtImporter *self, PyObject *args, PyObject * /*kwds*/)
             {
               self->_path = NULL;
               const char* path;
               if (!PyArg_ParseTuple(args, "s",
                 &path))
                 return -1;
               if (PythonQt::importInterface()->exists(path)) {
                 //qDebug("path %s", path);
                 QString p(path);
                 const QStringList& ignorePaths = PythonQt::self()->getImporterIgnorePaths();
                 foreach(QString a, ignorePaths) {
                   if (a==p) {
                     PyErr_SetString(PythonQtImportError,
                       "path ignored");
                     return -1;
                   }
                 }
                 self->_path = new QString(p);
                 //mlabDebugConst("MLABPython", "PythonQtImporter init: " << *self->_path);
                 return 0;
               } else {
                 PyErr_SetString(PythonQtImportError,
                     "path does not exist error");
                 return -1;
               }
             }
             void
             PythonQtImporter_dealloc(PythonQtImporter *self)
             {
               // free the stored path
               if (self->_path) delete self->_path;
               // free ourself
               self->ob_type->tp_free((PyObject *)self);
             }
             /* Check whether we can satisfy the import of the module named by
                'fullname'. Return self if we can, None if we can't. */
             PyObject *
             PythonQtImporter_find_module(PyObject *obj, PyObject *args)
             {
               PythonQtImporter *self = (PythonQtImporter *)obj;
               PyObject *path = NULL;
               char *fullname;
               if (!PyArg_ParseTuple(args, "s|O:PythonQtImporter.find_module",
                         &fullname, &path))
                 return NULL;
             //  mlabDebugConst("MLABPython", "FindModule " << fullname << " in " << *self->_path);
               PythonQtImport::module_info info = PythonQtImport::getModuleInfo(self, fullname);
               if (info == PythonQtImport::MI_MODULE || info == PythonQtImport::MI_PACKAGE) {
                 Py_INCREF(self);
                 return (PyObject *)self;
               } else {
                 Py_INCREF(Py_None);
                 return Py_None;
               }
             }
             /* Load and return the module named by 'fullname'. */
             PyObject *
             PythonQtImporter_load_module(PyObject *obj, PyObject *args)
             {
               PythonQtImporter *self = (PythonQtImporter *)obj;
               PyObject *code, *mod, *dict;
               char *fullname;
               QString modpath;
               int ispackage;
               if (!PyArg_ParseTuple(args, "s:PythonQtImporter.load_module",
                         &fullname))
                 return NULL;
               code = PythonQtImport::getModuleCode(self, fullname, &ispackage, modpath);
               if (code == NULL)
                 return NULL;
               mod = PyImport_AddModule(fullname);
               if (mod == NULL) {
                 Py_DECREF(code);
                 return NULL;
               }
               dict = PyModule_GetDict(mod);
-              if (PyDict_SetItemString(dict, "__loader__", (PyObject *)self) != 0)
+              if (PyDict_SetItemString(dict, "__loader__", (PyObject *)self) != 0) {
-                goto error;
+                Py_DECREF(code);
+                Py_DECREF(mod);
+                return NULL;
+              }
               if (ispackage) {
                 PyObject *pkgpath, *fullpath;
                 QString subname = PythonQtImport::getSubName(fullname);
                 int err;
                 fullpath = PyString_FromFormat("%s%c%s",
                       self->_path->toLatin1().constData(),
                       SEP,
                       subname.toLatin1().constData());
-                if (fullpath == NULL)
+                if (fullpath == NULL) {
-                  goto error;
+                  Py_DECREF(code);
+                  Py_DECREF(mod);
+                  return NULL;
+                }
                 pkgpath = Py_BuildValue("[O]", fullpath);
                 Py_DECREF(fullpath);
-                if (pkgpath == NULL)
+                if (pkgpath == NULL) {
-                  goto error;
+                  Py_DECREF(code);
+                  Py_DECREF(mod);
+                  return NULL;
+                }
                 err = PyDict_SetItemString(dict, "__path__", pkgpath);
                 Py_DECREF(pkgpath);
-                if (err != 0)
+                if (err != 0) {
-                  goto error;
+                  Py_DECREF(code);
+                  Py_DECREF(mod);
+                  return NULL;
+                }
               }
               mod = PyImport_ExecCodeModuleEx(fullname, code, (char*)modpath.toLatin1().data());
               Py_DECREF(code);
               if (Py_VerboseFlag)
                 PySys_WriteStderr("import %s # loaded from %s\n",
-                      fullname, modpath);
+                      fullname, modpath.toLatin1().constData());
               return mod;
-            error:
-              Py_DECREF(code);
-              Py_DECREF(mod);
-              return NULL;
             }
             PyObject *
-            PythonQtImporter_get_data(PyObject *obj, PyObject *args)
+            PythonQtImporter_get_data(PyObject* /*obj*/, PyObject* /*args*/)
             {
               // EXTRA, NOT YET IMPLEMENTED
               return NULL;
             }
             PyObject *
             PythonQtImporter_get_code(PyObject *obj, PyObject *args)
             {
               PythonQtImporter *self = (PythonQtImporter *)obj;
               char *fullname;
               if (!PyArg_ParseTuple(args, "s:PythonQtImporter.get_code", &fullname))
                 return NULL;
               QString notused;
               return PythonQtImport::getModuleCode(self, fullname, NULL, notused);
             }
             PyObject *
-            PythonQtImporter_get_source(PyObject *obj, PyObject *args)
+            PythonQtImporter_get_source(PyObject * /*obj*/, PyObject * /*args*/)
             {
               // EXTRA, NOT YET IMPLEMENTED
             /*
               PythonQtImporter *self = (PythonQtImporter *)obj;
               PyObject *toc_entry;
               char *fullname, *subname, path[MAXPATHLEN+1];
               int len;
               enum module_info mi;
               if (!PyArg_ParseTuple(args, "s:PythonQtImporter.get_source", &fullname))
                 return NULL;
               mi = get_module_info(self, fullname);
               if (mi == MI_ERROR)
                 return NULL;
               if (mi == MI_NOT_FOUND) {
                 PyErr_Format(PythonQtImportError, "can't find module '%.200s'",
                        fullname);
                 return NULL;
               }
               subname = get_subname(fullname);
               len = make_filename(PyString_AsString(self->prefix), subname, path);
               if (len < 0)
                 return NULL;
               if (mi == MI_PACKAGE) {
                 path[len] = SEP;
                 strcpy(path + len + 1, "__init__.py");
               }
               else
                 strcpy(path + len, ".py");
               toc_entry = PyDict_GetItemString(self->files, path);
               if (toc_entry != NULL)
                 return get_data(PyString_AsString(self->archive), toc_entry);
               Py_INCREF(Py_None);
               return Py_None;
             */
               return NULL;
             }
             PyDoc_STRVAR(doc_find_module,
             "find_module(fullname, path=None) -> self or None.\n\
             \n\
             Search for a module specified by 'fullname'. 'fullname' must be the\n\
             fully qualified (dotted) module name. It returns the PythonQtImporter\n\
             instance itself if the module was found, or None if it wasn't.\n\
             The optional 'path' argument is ignored -- it's there for compatibility\n\
             with the importer protocol.");
             PyDoc_STRVAR(doc_load_module,
             "load_module(fullname) -> module.\n\
             \n\
             Load the module specified by 'fullname'. 'fullname' must be the\n\
             fully qualified (dotted) module name. It returns the imported\n\
             module, or raises PythonQtImportError if it wasn't found.");
             PyDoc_STRVAR(doc_get_data,
             "get_data(pathname) -> string with file data.\n\
             \n\
             Return the data associated with 'pathname'. Raise IOError if\n\
             the file wasn't found.");
             PyDoc_STRVAR(doc_get_code,
             "get_code(fullname) -> code object.\n\
             \n\
             Return the code object for the specified module. Raise PythonQtImportError\n\
             is the module couldn't be found.");
             PyDoc_STRVAR(doc_get_source,
             "get_source(fullname) -> source string.\n\
             \n\
             Return the source code for the specified module. Raise PythonQtImportError\n\
             is the module couldn't be found, return None if the archive does\n\
             contain the module, but has no source for it.");
             PyMethodDef PythonQtImporter_methods[] = {
               {"find_module", PythonQtImporter_find_module, METH_VARARGS,
                doc_find_module},
               {"load_module", PythonQtImporter_load_module, METH_VARARGS,
                doc_load_module},
               {"get_data", PythonQtImporter_get_data, METH_VARARGS,
                doc_get_data},
               {"get_code", PythonQtImporter_get_code, METH_VARARGS,
                doc_get_code},
               {"get_source", PythonQtImporter_get_source, METH_VARARGS,
                doc_get_source},
-              {NULL,    NULL} /* sentinel */
+              {NULL,    NULL, 0 , NULL} /* sentinel */
             };
             PyDoc_STRVAR(PythonQtImporter_doc,
             "PythonQtImporter(path) -> PythonQtImporter object\n\
             \n\
             Create a new PythonQtImporter instance. 'path' must be a valid path on disk/or inside of a zip file known to MeVisLab\n\
             . Every path is accepted.");
             #define DEFERRED_ADDRESS(ADDR) 0
             PyTypeObject PythonQtImporter_Type = {
               PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type))
 ,
               "PythonQtImport.PythonQtImporter",
               sizeof(PythonQtImporter),
 ,          /* tp_itemsize */
               (destructor)PythonQtImporter_dealloc, /* tp_dealloc */
 ,          /* tp_print */
 ,          /* tp_getattr */
 ,          /* tp_setattr */
 ,          /* tp_compare */
 ,    /* tp_repr */
 ,          /* tp_as_number */
 ,          /* tp_as_sequence */
 ,          /* tp_as_mapping */
 ,          /* tp_hash */
 ,          /* tp_call */
 ,          /* tp_str */
               PyObject_GenericGetAttr,    /* tp_getattro */
 ,          /* tp_setattro */
 ,          /* tp_as_buffer */
               Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE ,    /* tp_flags */
               PythonQtImporter_doc,     /* tp_doc */
 ,      /* tp_traverse */
 ,          /* tp_clear */
 ,          /* tp_richcompare */
 ,          /* tp_weaklistoffset */
 ,          /* tp_iter */
 ,          /* tp_iternext */
               PythonQtImporter_methods,     /* tp_methods */
 ,          /* tp_members */
 ,          /* tp_getset */
 ,          /* tp_base */
 ,          /* tp_dict */
 ,          /* tp_descr_get */
 ,          /* tp_descr_set */
 ,          /* tp_dictoffset */
               (initproc)PythonQtImporter_init,    /* tp_init */
               PyType_GenericAlloc,      /* tp_alloc */
               PyType_GenericNew,      /* tp_new */
               PyObject_Del,     /* tp_free */
             };
             /* Given a buffer, return the long that is represented by the first
 bytes, encoded as little endian. This partially reimplements
                marshal.c:r_long() */
             long
             PythonQtImport::getLong(unsigned char *buf)
             {
               long x;
               x =  buf[0];
               x |= (long)buf[1] <<  8;
               x |= (long)buf[2] << 16;
               x |= (long)buf[3] << 24;
             #if SIZEOF_LONG > 4
               /* Sign extension for 64-bit machines */
               x |= -(x & 0x80000000L);
             #endif
               return x;
             }
             FILE *
             open_exclusive(const QString& filename)
             {
             #if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
               /* Use O_EXCL to avoid a race condition when another process tries to
                  write the same file.  When that happens, our open() call fails,
                  which is just fine (since it's only a cache).
                  XXX If the file exists and is writable but the directory is not
                  writable, the file will never be written.  Oh well.
               */
               QFile::remove(filename);
               int fd;
               int flags = O_EXCL|O_CREAT|O_WRONLY|O_TRUNC;
             #ifdef O_BINARY
                 flags |= O_BINARY;   /* necessary for Windows */
             #endif
             #ifdef WIN32
               fd = _wopen(filename.ucs2(), flags, 0666);
             #else
               fd = open(filename.local8Bit(), flags, 0666);
             #endif
               if (fd < 0)
                 return NULL;
               return fdopen(fd, "wb");
             #else
               /* Best we can do -- on Windows this can't happen anyway */
               return fopen(filename.toLocal8Bit().constData(), "wb");
             #endif
             }
             void PythonQtImport::writeCompiledModule(PyCodeObject *co, const QString& filename, long mtime)
             {
               FILE *fp;
               fp = open_exclusive(filename);
               if (fp == NULL) {
                 if (Py_VerboseFlag)
                   PySys_WriteStderr(
                   "# can't create %s\n", filename.toLatin1().constData());
                 return;
               }
             #if PY_VERSION_HEX < 0x02040000
               PyMarshal_WriteLongToFile(PyImport_GetMagicNumber(), fp);
             #else
               PyMarshal_WriteLongToFile(PyImport_GetMagicNumber(), fp, Py_MARSHAL_VERSION);
             #endif
               /* First write a 0 for mtime */
             #if PY_VERSION_HEX < 0x02040000
               PyMarshal_WriteLongToFile(0L, fp);
             #else
               PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
             #endif
             #if PY_VERSION_HEX < 0x02040000
               PyMarshal_WriteObjectToFile((PyObject *)co, fp);
             #else
               PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
             #endif
               if (ferror(fp)) {
                 if (Py_VerboseFlag)
                   PySys_WriteStderr("# can't write %s\n", filename.toLatin1().constData());
                 /* Don't keep partial file */
                 fclose(fp);
                 QFile::remove(filename);
                 return;
               }
               /* Now write the true mtime */
               fseek(fp, 4L, 0);
             #if PY_VERSION_HEX < 0x02040000
               PyMarshal_WriteLongToFile(mtime, fp);
             #else
               PyMarshal_WriteLongToFile(mtime, fp, Py_MARSHAL_VERSION);
             #endif
               fflush(fp);
               fclose(fp);
               if (Py_VerboseFlag)
                 PySys_WriteStderr("# wrote %s\n", filename.toLatin1().constData());
             //#ifdef macintosh
             //  PyMac_setfiletype(cpathname, 'Pyth', 'PYC ');
             //#endif
             }
             /* Given the contents of a .py[co] file in a buffer, unmarshal the data
                and return the code object. Return None if it the magic word doesn't
                match (we do this instead of raising an exception as we fall back
                to .py if available and we don't want to mask other errors).
                Returns a new reference. */
             PyObject *
             PythonQtImport::unmarshalCode(const QString& path, const QByteArray& data, time_t mtime)
             {
               PyObject *code;
               // ugly cast, but Python API is not const safe
               char *buf = (char*) data.constData();
               int size = data.size();
               if (size <= 9) {
                 PySys_WriteStderr("# %s has bad pyc data\n",
                         path.toLatin1().constData());
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               if (getLong((unsigned char *)buf) != PyImport_GetMagicNumber()) {
                 if (Py_VerboseFlag)
                   PySys_WriteStderr("# %s has bad magic\n",
                         path.toLatin1().constData());
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               if (mtime != 0 && !(getLong((unsigned char *)buf + 4) == mtime)) {
                 if (Py_VerboseFlag)
                   PySys_WriteStderr("# %s has bad mtime\n",
                         path.toLatin1().constData());
                 Py_INCREF(Py_None);
                 return Py_None;
               }
               code = PyMarshal_ReadObjectFromString(buf + 8, size - 8);
               if (code == NULL)
                 return NULL;
               if (!PyCode_Check(code)) {
                 Py_DECREF(code);
                 PyErr_Format(PyExc_TypeError,
                      "compiled module %.200s is not a code object",
                      path.toLatin1().constData());
                 return NULL;
               }
               return code;
             }
             /* Given a string buffer containing Python source code, compile it
                return and return a code object as a new reference. */
             PyObject *
             PythonQtImport::compileSource(const QString& path, const QByteArray& data)
             {
               PyObject *code;
               QByteArray data1 = data;
             // in qt4, data is null terminated
             //  data1.resize(data.size()+1);
             //  data1.data()[data.size()-1] = 0;
               code = Py_CompileString(data.data(), path.toLatin1().constData(),
                     Py_file_input);
               return code;
             }
             /* Return the code object for the module named by 'fullname' from the
                Zip archive as a new reference. */
             PyObject *
-            PythonQtImport::getCodeFromData(const QString& path, int isbytecode,int ispackage, time_t mtime)
+            PythonQtImport::getCodeFromData(const QString& path, int isbytecode,int /*ispackage*/, time_t mtime)
             {
-              bool hasImporter = PythonQt::importInterface()!=NULL;
               PyObject *code;
               QByteArray qdata;
-              if (!hasImporter) {
-                QFile file(path);
-                QIODevice::OpenMode flags = QIODevice::ReadOnly;
-                if (!isbytecode) {
-                  flags |= QIODevice::Text;
-                if (!file.open(flags)) {
-                  return NULL;
-                qdata = file.readAll();
-              } else {
                 if (!isbytecode) {
                   //    mlabDebugConst("MLABPython", "reading source " << path);
                   bool ok;
                   qdata = PythonQt::importInterface()->readSourceFile(path, ok);
                   if (!ok) {
                     //    mlabErrorConst("PythonQtImporter","File could not be verified" << path);
                     return NULL;
                   }
                   if (qdata == " ") {
                     qdata.clear();
                   }
                 } else {
                   qdata = PythonQt::importInterface()->readFileAsBytes(path);
                 }
               if (isbytecode) {
             //    mlabDebugConst("MLABPython", "reading bytecode " << path);
                 code = unmarshalCode(path, qdata, mtime);
               }
               else {
               //  mlabDebugConst("MLABPython", "compiling source " << path);
                 code = compileSource(path, qdata);
                 if (code) {
                   // save a pyc file if possible
                   QDateTime time;
-                  time = hasImporter?PythonQt::importInterface()->lastModifiedDate(path):QFileInfo(path).lastModified();
+                  time = PythonQt::importInterface()->lastModifiedDate(path);
                   writeCompiledModule((PyCodeObject*)code, path+"c", time.toTime_t());
                 }
               }
               return code;
             }
             time_t
             PythonQtImport::getMTimeOfSource(const QString& path)
             {
               time_t mtime = 0;
               QString path2 = path;
               path2.truncate(path.length()-1);
-              bool hasImporter = PythonQt::importInterface()!=NULL;
-              if (hasImporter) {
               if (PythonQt::importInterface()->exists(path2)) {
                 mtime = PythonQt::importInterface()->lastModifiedDate(path2).toTime_t();
               }
-              } else {
-                if (QFile::exists(path2)) {
-                  mtime = QFileInfo(path2).lastModified().toTime_t();
               return mtime;
             }
             /* Get the code object associated with the module specified by
                'fullname'. */
             PyObject *
             PythonQtImport::getModuleCode(PythonQtImporter *self, char *fullname,
                 int *p_ispackage, QString& modpath)
             {
               QString subname;
               struct st_mlab_searchorder *zso;
               subname = getSubName(fullname);
               QString path = *self->_path + "/" + subname;
               QString test;
               for (zso = mlab_searchorder; *zso->suffix; zso++) {
                 PyObject *code = NULL;
                 test = path + zso->suffix;
                 if (Py_VerboseFlag > 1)
                   PySys_WriteStderr("# trying %s\n",
                         test.toLatin1().constData());
                 if (PythonQt::importInterface()->exists(test)) {
                   time_t mtime = 0;
                   int ispackage = zso->type & IS_PACKAGE;
                   int isbytecode = zso->type & IS_BYTECODE;
                   if (isbytecode)
                     mtime = getMTimeOfSource(test);
                   if (p_ispackage != NULL)
                     *p_ispackage = ispackage;
                   code = getCodeFromData(test, isbytecode, ispackage, mtime);
                   if (code == Py_None) {
                     Py_DECREF(code);
                     continue;
                   }
                   if (code != NULL)
                     modpath = test;
                   return code;
                 }
               }
               PyErr_Format(PythonQtImportError, "can't find module '%.200s'", fullname);
               return NULL;
             }
             QString PythonQtImport::replaceExtension(const QString& str, const QString& ext)
             {
              QString r;
              int i = str.lastIndexOf('.');
              if (i!=-1) {
                r = str.mid(0,i) + "." + ext;
              } else {
                r = str + "." + ext;
              }
              return r;
             }
             PyObject* PythonQtImport::getCodeFromPyc(const QString& file)
             {
-              bool hasImporter = PythonQt::importInterface()!=NULL;
               PyObject* code;
               const static QString pycStr("pyc");
               QString pyc = replaceExtension(file, pycStr);
-              if ((hasImporter && PythonQt::importInterface()->exists(pyc)) ||
+              if (PythonQt::importInterface()->exists(pyc)) {
-                (!hasImporter && QFile::exists(pyc))) {
                 time_t mtime = 0;
                 mtime = getMTimeOfSource(pyc);
                 code = getCodeFromData(pyc, true, false, mtime);
                 if (code != Py_None && code != NULL) {
                   return code;
                 }
                 if (code) {
                   Py_DECREF(code);
                 }
               }
               code = getCodeFromData(file,false,false,0);
               return code;
             }
             /* Module init */
             PyDoc_STRVAR(mlabimport_doc,
-            "Imports python files into MeVisLab, completely replaces internal python import");
+            "Imports python files into PythonQt, completely replaces internal python import");
             void PythonQtImport::init()
             {
+              static bool first = true;
+              if (!first) {
+                return;
+              }
+              first = false;
               PyObject *mod;
               if (PyType_Ready(&PythonQtImporter_Type) < 0)
                 return;
               /* Correct directory separator */
               mlab_searchorder[0].suffix[0] = SEP;
               mlab_searchorder[1].suffix[0] = SEP;
               mlab_searchorder[2].suffix[0] = SEP;
               if (Py_OptimizeFlag) {
                 /* Reverse *.pyc and *.pyo */
                 struct st_mlab_searchorder tmp;
                 tmp = mlab_searchorder[0];
                 mlab_searchorder[0] = mlab_searchorder[1];
                 mlab_searchorder[1] = tmp;
                 tmp = mlab_searchorder[3];
                 mlab_searchorder[3] = mlab_searchorder[4];
                 mlab_searchorder[4] = tmp;
               }
               mod = Py_InitModule4("PythonQtImport", NULL, mlabimport_doc,
                        NULL, PYTHON_API_VERSION);
               PythonQtImportError = PyErr_NewException("PythonQtImport.PythonQtImportError",
                           PyExc_ImportError, NULL);
               if (PythonQtImportError == NULL)
                 return;
               Py_INCREF(PythonQtImportError);
               if (PyModule_AddObject(mod, "PythonQtImportError",
                          PythonQtImportError) < 0)
                 return;
               Py_INCREF(&PythonQtImporter_Type);
               if (PyModule_AddObject(mod, "PythonQtImporter",
                          (PyObject *)&PythonQtImporter_Type) < 0)
                 return;
               // set our importer into the path_hooks to handle all path on sys.path
               PyObject* classobj = PyDict_GetItemString(PyModule_GetDict(mod), "PythonQtImporter");
               PyObject* path_hooks = PySys_GetObject("path_hooks");
               PyList_Append(path_hooks, classobj);
             #ifndef WIN32
               // reload the encodings module, because it might fail to custom import requirements (e.g. encryption).
               PyObject* modules         = PyImport_GetModuleDict();
               PyObject* encodingsModule = PyDict_GetItemString(modules, "encodings");
               if (encodingsModule != NULL) {
                 PyImport_ReloadModule(encodingsModule);
               }
             #endif
             }

src/PythonQtMetaObjectWrapper.cpp +3 -3

             /*
              *
              *  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    PythonQtMetaObjectWrapper.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtMetaObjectWrapper.h"
             #include <QObject>
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtConversion.h"
             static void PythonQtMetaObjectWrapper_dealloc(PythonQtMetaObjectWrapper* self)
             {
               self->ob_type->tp_free((PyObject*)self);
             }
-            static PyObject* PythonQtMetaObjectWrapper_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+            static PyObject* PythonQtMetaObjectWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               PythonQtMetaObjectWrapper *self;
               self = (PythonQtMetaObjectWrapper *)type->tp_alloc(type, 0);
               if (self != NULL) {
                 self->_info = NULL;
               }
               return (PyObject *)self;
             }
-            static int PythonQtMetaObjectWrapper_init(PythonQtMetaObjectWrapper *self, PyObject *args, PyObject *kwds)
+            static int PythonQtMetaObjectWrapper_init(PythonQtMetaObjectWrapper * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               return 0;
             }
             PyObject *PythonQtMetaObjectWrapper_call(PyObject *func, PyObject *args, PyObject *kw) {
               PythonQtMetaObjectWrapper* wrapper = (PythonQtMetaObjectWrapper*)func;
               PyObject* result = NULL;
               QString error;
               PyObject* err = NULL;
               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 (result->ob_type == &PythonQtWrapper_Type) {
                   ((PythonQtWrapper*)result)->_ownedByPythonQt = true;
                 }
               } else {
                 if (!wrapper->_info->constructors()) {
                   if (!err) {
                     if (error.isEmpty()) {
                       error = QString("No constructors available for ") + wrapper->_info->className();
                     }
                     PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                   }
                 }
               }
               return result;
             }
             static PyObject *PythonQtMetaObjectWrapper_classname(PythonQtMetaObjectWrapper* type)
             {
               return PyString_FromString((QString("Meta_") + type->_info->className()).toLatin1().data());
             }
             static PyObject *PythonQtMetaObjectWrapper_help(PythonQtMetaObjectWrapper* type)
             {
               return PythonQt::self()->helpCalled(type->_info);
             }
             static PyMethodDef PythonQtMetaObjectWrapper_methods[] = {
                 {"className", (PyCFunction)PythonQtMetaObjectWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
                 {"help", (PyCFunction)PythonQtMetaObjectWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
-                {NULL}  /* Sentinel */
+                {NULL, NULL, 0 , NULL}  /* Sentinel */
             };
             static PyObject *PythonQtMetaObjectWrapper_getattro(PyObject *obj,PyObject *name)
             {
               const char *attributeName;
               PythonQtMetaObjectWrapper *wt = (PythonQtMetaObjectWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL) {
                 return NULL;
               }
               PythonQtMemberInfo member = wt->_info->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( PythonQtMetaObjectWrapper_methods, obj, (char*)attributeName);
               if (internalMethod) {
                 return internalMethod;
               }
               PyErr_Clear();
               if (qstrcmp(attributeName, "__dict__")==0) {
                 QStringList l = wt->_info->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(wt->_info->className()) + " has no attribute named '" + QString(attributeName) + "'";
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return NULL;
             }
             static PyObject * PythonQtMetaObjectWrapper_repr(PyObject * obj)
             {
               PythonQtMetaObjectWrapper* wt = (PythonQtMetaObjectWrapper*)obj;
               if (wt->_info->isCPPWrapper()) {
                 return PyString_FromFormat("%s Class (C++ wrapped by %s)", wt->_info->className(), wt->_info->metaObject()->className());
               } else {
                 return PyString_FromFormat("%s Class", wt->_info->className());
               }
             }
             static int PythonQtMetaObjectWrapper_compare(PyObject * obj1, PyObject * obj2)
             {
               if (obj1->ob_type == &PythonQtMetaObjectWrapper_Type &&
                 obj2->ob_type == &PythonQtMetaObjectWrapper_Type) {
                 PythonQtMetaObjectWrapper* w1 = (PythonQtMetaObjectWrapper*)obj1;
                 PythonQtMetaObjectWrapper* w2 = (PythonQtMetaObjectWrapper*)obj2;
                 if (w1->_info == w2->_info) {
                   return 0;
                 } else {
                   return -1;
                 }
               } else {
                 return -1;
               }
             }
             static long PythonQtMetaObjectWrapper_hash(PythonQtMetaObjectWrapper *obj)
             {
               return reinterpret_cast<long>(obj->_info);
             }
             PyTypeObject PythonQtMetaObjectWrapper_Type = {
                 PyObject_HEAD_INIT(NULL)
 ,                         /*ob_size*/
                 "PythonQt.PythonQtMetaObjectWrapper",             /*tp_name*/
                 sizeof(PythonQtMetaObjectWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
                 (destructor)PythonQtMetaObjectWrapper_dealloc, /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
                 PythonQtMetaObjectWrapper_compare,         /*tp_compare*/
                 PythonQtMetaObjectWrapper_repr,            /*tp_repr*/
 ,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
                 (hashfunc)PythonQtMetaObjectWrapper_hash,                         /*tp_hash */
                 PythonQtMetaObjectWrapper_call,                         /*tp_call*/
 ,                         /*tp_str*/
                 PythonQtMetaObjectWrapper_getattro,                         /*tp_getattro*/
 ,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
                 "PythonQtMetaObjectWrapper 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)PythonQtMetaObjectWrapper_init,      /* tp_init */
 ,                         /* tp_alloc */
                 PythonQtMetaObjectWrapper_new,                 /* tp_new */
             };
             //-------------------------------------------------------

src/PythonQtMetaObjectWrapper.h +3 0

             #ifndef _PYTHONQTMETAOBJECTWRAPPER_H
             #define _PYTHONQTMETAOBJECTWRAPPER_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    PythonQtMetaObjectWrapper.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;
             extern PyTypeObject PythonQtMetaObjectWrapper_Type;
             //---------------------------------------------------------------
             //! a Python wrapper object for Qt meta objects
             typedef struct {
               PyObject_HEAD
               //! the class information (which contains the meta object as well)
               PythonQtClassInfo* _info;
             } PythonQtMetaObjectWrapper;
             //---------------------------------------------------------------
             // 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

src/PythonQtMisc.h +1 0

             #ifndef _PYTHONQTMISC_H
             #define _PYTHONQTMISC_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    PythonQtMisc.h
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include <QList>
             #define PythonQtValueStorage_ADD_VALUE(store, type, value, ptr) \
             {  type* item = (type*)store.nextValuePtr(); \
                *item = value; \
                ptr = (void*)item; \
             }
             //! stores a position in the PythonQtValueStorage
             class PythonQtValueStoragePosition {
             public:
               PythonQtValueStoragePosition() { chunkIdx = 0; chunkOffset = 0; }
               int chunkIdx;
               int chunkOffset;
             };
             //! a helper class that stores basic C++ value types in chunks
             template <typename T, int chunkEntries> class PythonQtValueStorage
             {
             public:
               PythonQtValueStorage() {
                 _chunkIdx  = 0;
                 _chunkOffset = 0;
                 _currentChunk = new T[chunkEntries];
                 _chunks.append(_currentChunk);
               };
               //! clear all memory
               void clear() {
                 T* chunk;
                 foreach(chunk, _chunks) {
                   delete[]chunk;
                 }
+                _chunks.clear();
               }
               //! reset the storage to 0 (without freeing memory, thus caching old entries for reuse)
               void reset() {
                 _chunkIdx = 0;
                 _chunkOffset = 0;
                 _currentChunk = _chunks.at(0);
               }
               //! get the current position to be restored with setPos
               void getPos(PythonQtValueStoragePosition & pos) {
                 pos.chunkIdx = _chunkIdx;
                 pos.chunkOffset = _chunkOffset;
               }
               //! set the current position (without freeing memory, thus caching old entries for reuse)
               void setPos(const PythonQtValueStoragePosition& pos) {
                 _chunkOffset = pos.chunkOffset;
                 if (_chunkIdx != pos.chunkIdx) {
                   _chunkIdx = pos.chunkIdx;
                   _currentChunk = _chunks.at(_chunkIdx);
                 }
               }
               //! add one default constructed value and return the pointer to it
               T* nextValuePtr() {
                 if (_chunkOffset>=chunkEntries) {
                   _chunkIdx++;
                   if (_chunkIdx >= _chunks.size()) {
                     T* newChunk = new T[chunkEntries];
                     _chunks.append(newChunk);
                     _currentChunk = newChunk;
                   } else {
                     _currentChunk = _chunks.at(_chunkIdx);
                   }
                   _chunkOffset = 0;
                 }
                 T* newEntry = _currentChunk + _chunkOffset;
                 _chunkOffset++;
                 return newEntry;
               };
             private:
               QList<T*> _chunks;
               int _chunkIdx;
               int _chunkOffset;
               T*  _currentChunk;
             };
             #endif

src/PythonQtSlot.cpp +10 -6

             /*
             *
             *  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 "PythonQtWrapper.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, bool isVariantCall, void* firstArgument)
             {
               if (isVariantCall && info->isInstanceDecorator()) return NULL;
               static unsigned int recursiveEntry = 0;
               // 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);
                 }
               }
               const QMetaObject* meta = objectToCall?objectToCall->metaObject():NULL;
               bool ok = true;
               bool skipFirst = false;
               if (info->isInstanceDecorator() || isVariantCall) {
                 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) {
                     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);
               // NOTE: it is important to only return here, otherwise the stack will not be popped!!!
               return result;
             }
             //-----------------------------------------------------------------------------------
             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 == &PythonQtWrapper_Type) {
                 PythonQtWrapper* self = (PythonQtWrapper*) f->m_self;
                 return PythonQtSlotFunction_CallImpl(self->_obj, info, args, kw, false, self->_wrappedPtr);
               } else if (f->m_self->ob_type == &PythonQtVariantWrapper_Type) {
                 PythonQtVariantWrapper* self = (PythonQtVariantWrapper*) f->m_self;
                 if (!info->isClassDecorator()) {
                   return PythonQtSlotFunction_CallImpl(self->_wrapper, info, args, kw, true, (void*)self->_variant->constData());
                 } else {
                   return PythonQtSlotFunction_CallImpl(NULL, info, args, kw);
                 }
               } else if (f->m_self->ob_type == &PythonQtMetaObjectWrapper_Type) {
                 return PythonQtSlotFunction_CallImpl(NULL, info, args, kw);
               } else {
                 return NULL;
               }
             }
-            PyObject *PythonQtSlotFunction_CallImpl(QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject *kw, bool isVariantCall, void* firstArg)
+            PyObject *PythonQtSlotFunction_CallImpl(QObject* objectToCall, PythonQtSlotInfo* info, PyObject *args, PyObject * /*kw*/, bool isVariantCall, void* firstArg)
             {
               int argc = PyTuple_Size(args);
             #ifdef PYTHONQT_DEBUG
               std::cout << "called " << info->metaMethod()->typeName() << " " << info->metaMethod()->signature() << std::endl;
             #endif
               PyObject* r = NULL;
               if (info->nextInfo()) {
                 // overloaded slot call, try on all slots with strict conversion first
                 PythonQtSlotInfo* i = info;
                 while (i && r==NULL) {
                   bool skipFirst = (i->isInstanceDecorator() || isVariantCall);
                   if (i->parameterCount()-1-(skipFirst?1:0) == argc) {
                     PyErr_Clear();
                     r = PythonQtCallSlot(objectToCall, args, true, i, isVariantCall, firstArg);
                     if (PyErr_Occurred()) break;
                   }
                   i = i->nextInfo();
                 }
                 if (!r) {
                   // try on all slots with non-strict conversion
                   i = info;
                   while (i && r==NULL) {
                     bool skipFirst = (i->isInstanceDecorator() || isVariantCall);
                     if (i->parameterCount()-1-(skipFirst?1:0) == argc) {
                       PyErr_Clear();
                       r = PythonQtCallSlot(objectToCall, args, false, i, isVariantCall, firstArg);
                       if (PyErr_Occurred()) break;
                     }
                     i = i->nextInfo();
                   }
                 }
                 if (r==NULL && !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() || isVariantCall);
                     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() || isVariantCall);
                 if (info->parameterCount()-1-(skipFirst?1:0) == argc) {
                   PyErr_Clear();
                   r = PythonQtCallSlot(objectToCall, args, false, info, isVariantCall, firstArg);
                   if (r==NULL && !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)
+            meth_get__doc__(PythonQtSlotFunctionObject * /*m*/, void * /*closure*/)
             {
               Py_INCREF(Py_None);
               return Py_None;
             }
             static PyObject *
-            meth_get__name__(PythonQtSlotFunctionObject *m, void *closure)
+            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)
+            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},
-              {0}
+              {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), WRITE_RESTRICTED},
+              {"__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/PythonQtStdOut.cpp +3 -3

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

src/PythonQtVariantWrapper.cpp +3 -3

             /*
             *
             *  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    PythonQtVariantWrapper.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtVariantWrapper.h"
             #include <QObject>
             #include <QDate>
             #include <QDateTime>
             #include <QTime>
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtConversion.h"
             static void PythonQtVariantWrapper_dealloc(PythonQtVariantWrapper* self)
             {
               if (self->_variant) {
                 delete self->_variant;
                 self->_variant = NULL;
               }
               self->ob_type->tp_free((PyObject*)self);
             }
-            static PyObject* PythonQtVariantWrapper_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+            static PyObject* PythonQtVariantWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               PythonQtVariantWrapper *self;
               self = (PythonQtVariantWrapper *)type->tp_alloc(type, 0);
               if (self != NULL) {
                 self->_variant = new QVariant();
                 self->_info = NULL;
               }
               return (PyObject *)self;
             }
-            static int PythonQtVariantWrapper_init(PythonQtVariantWrapper *self, PyObject *args, PyObject *kwds)
+            static int PythonQtVariantWrapper_init(PythonQtVariantWrapper * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               return 0;
             }
             static PyObject *PythonQtVariantWrapper_classname(PythonQtVariantWrapper* type)
             {
               return PyString_FromString(type->_info->className());
             }
             static PyObject *PythonQtVariantWrapper_help(PythonQtVariantWrapper* type)
             {
               return PythonQt::self()->helpCalled(type->_info);
             }
             static PyMethodDef PythonQtVariantWrapper_methods[] = {
                 {"className", (PyCFunction)PythonQtVariantWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
                 {"help", (PyCFunction)PythonQtVariantWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
-                {NULL}  /* Sentinel */
+                {NULL,NULL,0,NULL}  /* Sentinel */
             };
             static PyObject *PythonQtVariantWrapper_getattro(PyObject *obj,PyObject *name)
             {
               const char *attributeName;
               PythonQtVariantWrapper *wt = (PythonQtVariantWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL) {
                 return NULL;
               }
               if (wt->_wrapper && wt->_info) {
                 PythonQtMemberInfo member = wt->_info->member(attributeName);
                 if (member._type == PythonQtMemberInfo::Slot) {
                   return PythonQtSlotFunction_New(member._slot, obj, NULL);
                 } else if (member._type == PythonQtMemberInfo::EnumValue) {
                   return PyInt_FromLong(member._enumValue);
                 }
               }
               // look for the interal methods (className(), help())
               PyObject* internalMethod = Py_FindMethod( PythonQtVariantWrapper_methods, obj, (char*)attributeName);
               if (internalMethod) {
                 return internalMethod;
               }
               PyErr_Clear();
               if (qstrcmp(attributeName, "__dict__")==0) {
                 QStringList l = wt->_info->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);
                 }
                 return dict;
               }
               QString error = QString(wt->_variant->typeName()) + " has no attribute named '" + QString(attributeName) + "'";
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return NULL;
             }
             QString qVariantToString(const QVariant& v) {
               QString r;
               switch (v.type()) {
               case QVariant::Size:
                 r = QString::number(v.toSize().width()) + ", " + QString::number(v.toSize().height());
                 break;
               case QVariant::SizeF:
                 r = QString::number(v.toSizeF().width()) + ", " + QString::number(v.toSizeF().height());
                 break;
               case QVariant::Point:
                 r = QString::number(v.toPoint().x()) + ", " + QString::number(v.toPoint().y());
                 break;
               case QVariant::PointF:
                 r = QString::number(v.toPointF().x()) + ", " + QString::number(v.toPointF().y());
                 break;
               case QVariant::Rect:
                 r = QString::number(v.toRect().x()) + ", " + QString::number(v.toRect().y());
                 r += ", " + QString::number(v.toRect().width()) + ", " + QString::number(v.toRect().height());
                 break;
               case QVariant::RectF:
                 r = QString::number(v.toRectF().x()) + ", " + QString::number(v.toRectF().y());
                 r += ", " + QString::number(v.toRectF().width()) + ", " + QString::number(v.toRectF().height());
                 break;
               case QVariant::Date:
                 r = v.toDate().toString(Qt::ISODate);
                 break;
               case QVariant::DateTime:
                 r = v.toDateTime().toString(Qt::ISODate);
                 break;
               case QVariant::Time:
                 r = v.toTime().toString(Qt::ISODate);
                 break;
               case QVariant::Pixmap:
                 {
                   QPixmap p = qvariant_cast<QPixmap>(v);
                   r = QString("Pixmap ") + QString::number(p.width()) + ", " + QString::number(p.height());
                 }
                 break;
               case QVariant::Image:
                 {
                   QImage img = qvariant_cast<QImage>(v);
                   r = QString("Image ") + QString::number(img.width()) + ", " + QString::number(img.height());
                 }
                 break;
                 //TODO: add more printing for other variant types
               default:
                 r = v.toString();
               }
               return r;
             }
             static PyObject * PythonQtVariantWrapper_str(PyObject * obj)
             {
               PythonQtVariantWrapper* wt = (PythonQtVariantWrapper*)obj;
               QString val = qVariantToString(*wt->_variant);
               if (val.isEmpty()) {
                 val = wt->_variant->typeName();
               }
               return PyString_FromFormat("%s", val.toLatin1().constData());
             }
             static PyObject * PythonQtVariantWrapper_repr(PyObject * obj)
             {
               PythonQtVariantWrapper* wt = (PythonQtVariantWrapper*)obj;
               QString val = qVariantToString(*wt->_variant);
               return PyString_FromFormat("%s(%s)", wt->_variant->typeName(), val.toLatin1().constData());
             }
             static int PythonQtVariantWrapper_compare(PyObject * obj1, PyObject * obj2)
             {
               if (obj1->ob_type == &PythonQtVariantWrapper_Type &&
                 obj2->ob_type == &PythonQtVariantWrapper_Type) {
                 PythonQtVariantWrapper* w1 = (PythonQtVariantWrapper*)obj1;
                 PythonQtVariantWrapper* w2 = (PythonQtVariantWrapper*)obj2;
                 if (*w1->_variant == *w2->_variant) {
                   return 0;
                 } else {
                   return -1;
                 }
               } else {
                 return -1;
               }
             }
             PyTypeObject PythonQtVariantWrapper_Type = {
               PyObject_HEAD_INIT(NULL)
 ,                         /*ob_size*/
                 "PythonQt.PythonQtVariantWrapper",             /*tp_name*/
                 sizeof(PythonQtVariantWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
                 (destructor)PythonQtVariantWrapper_dealloc, /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
                 PythonQtVariantWrapper_compare,         /*tp_compare*/
                 PythonQtVariantWrapper_repr,            /*tp_repr*/
 ,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
 ,                         /*tp_hash */
 ,                         /*tp_call*/
                 PythonQtVariantWrapper_str,                         /*tp_str*/
                 PythonQtVariantWrapper_getattro,                         /*tp_getattro*/
 ,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
                 "PythonQtVariantWrapper 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)PythonQtVariantWrapper_init,      /* tp_init */
 ,                         /* tp_alloc */
                 PythonQtVariantWrapper_new,                 /* tp_new */
             };
             //-------------------------------------------------------

src/PythonQtWrapper.cpp +6 -3

             /*
             *
             *  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    PythonQtWrapper.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtWrapper.h"
             #include <QObject>
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtConversion.h"
             static void PythonQtWrapper_dealloc(PythonQtWrapper* self)
             {
               if (self->_wrappedPtr) {
                 //mlabDebugConst("Python","c++ wrapper removed " << self->_wrappedPtr << " " << self->_obj->className() << " " << self->_info->wrappedClassName().latin1());
                 PythonQt::priv()->removeWrapperPointer(self->_wrappedPtr);
                 // we own our qobject, so we delete it now:
                 delete self->_obj;
                 self->_obj = NULL;
                 if (self->_ownedByPythonQt) {
                   PythonQtSlotInfo* slot = PythonQt::priv()->getDestructorSlot(self->_info->wrappedCPPClassName());
                   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 {
                     // TODO: print a warning? we can not destroy that object
                   }
                 }
               } else {
                 //mlabDebugConst("Python","qobject wrapper removed " << self->_obj->className() << " " << self->_info->wrappedClassName().latin1());
                 if (self->_objPointerCopy) {
                   PythonQt::priv()->removeWrapperPointer(self->_objPointerCopy);
                 }
                 if (self->_obj) {
                   if (self->_ownedByPythonQt) {
                     if (!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;
               self->_obj.~QPointer<QObject>();
               self->ob_type->tp_free((PyObject*)self);
             }
-            static PyObject* PythonQtWrapper_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+            static PyObject* PythonQtWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               PythonQtWrapper *self;
               self = (PythonQtWrapper *)type->tp_alloc(type, 0);
               if (self != NULL) {
                 self->_info = NULL;
                 new (&self->_obj) QPointer<QObject>();
                 self->_wrappedPtr = NULL;
                 self->_ownedByPythonQt = false;
               }
               return (PyObject *)self;
             }
-            static int PythonQtWrapper_init(PythonQtWrapper *self, PyObject *args, PyObject *kwds)
+            static int PythonQtWrapper_init(PythonQtWrapper * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               return 0;
             }
             static PyObject *PythonQtWrapper_classname(PythonQtWrapper* type)
             {
               return PyString_FromString(type->_info->className());
             }
             static PyObject *PythonQtWrapper_help(PythonQtWrapper* type)
             {
               return PythonQt::self()->helpCalled(type->_info);
             }
             static PyMethodDef PythonQtWrapper_methods[] = {
                 {"className", (PyCFunction)PythonQtWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
                 {"help", (PyCFunction)PythonQtWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
-                {NULL}  /* Sentinel */
+                {NULL, NULL, 0, NULL}  /* Sentinel */
             };
             static PyObject *PythonQtWrapper_getattro(PyObject *obj,PyObject *name)
             {
               const char *attributeName;
               PythonQtWrapper *wt = (PythonQtWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL) {
                 return NULL;
               }
               if (!wt->_obj && !wt->_wrappedPtr) {
                 QString error = QString("Trying to read attribute '") + attributeName + "' from a destroyed " + wt->_info->className() + " object";
                 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                 return NULL;
               }
               //  mlabDebugConst("Python","get " << attributeName);
               // TODO: dynamic properties are missing
               PythonQtMemberInfo member = wt->_info->member(attributeName);
               switch (member._type) {
               case PythonQtMemberInfo::Property:
                 if (wt->_obj) {
                   return PythonQtConv::QVariantToPyObject(member._property.read(wt->_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( PythonQtWrapper_methods, obj, (char*)attributeName);
               if (internalMethod) {
                 return internalMethod;
               }
               PyErr_Clear();
               if (wt->_obj) {
                 // look for a child
                 QObjectList children = wt->_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 = wt->_info->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(wt->_info->className()) + " has no attribute named '" + QString(attributeName) + "'";
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return NULL;
             }
             static int PythonQtWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
             {
               QString error;
               char *attributeName;
               PythonQtWrapper *wt = (PythonQtWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL)
                 return -1;
               if (!wt->_obj) {
                 error = QString("Trying to set attribute '") + attributeName + "' on a destroyed " + wt->_info->className() + " object";
                 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
                 return -1;
               }
               PythonQtMemberInfo member = wt->_info->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(wt->_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 " + wt->_info->className() + " object is not writable";
                 }
               } else {
                 if (member._type == PythonQtMemberInfo::Slot) {
                   error = QString("Slot '") + attributeName + "' can not be overwritten on " + wt->_info->className() + " object";
                 } else if (member._type == PythonQtMemberInfo::EnumValue) {
                   error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + wt->_info->className() + " object";
                 }
               }
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return -1;
             }
             static PyObject * PythonQtWrapper_repr(PyObject * obj)
             {
               PythonQtWrapper* wt = (PythonQtWrapper*)obj;
               QObject *qobj = wt->_obj;
               if (wt->_wrappedPtr) {
                 if (wt->_obj) {
                   return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wt->_info->className(), wt->_wrappedPtr, wt->_obj->metaObject()->className(), qobj);
                 } else {
                   return PyString_FromFormat("%s (C++ Object %p unwrapped)", wt->_info->className(), wt->_wrappedPtr);
                 }
               } else {
                 return PyString_FromFormat("%s (QObject %p)", wt->_info->className(), qobj);
               }
             }
             static int PythonQtWrapper_compare(PyObject * obj1, PyObject * obj2)
             {
               if (obj1->ob_type == &PythonQtWrapper_Type &&
                 obj2->ob_type == &PythonQtWrapper_Type) {
                 PythonQtWrapper* w1 = (PythonQtWrapper*)obj1;
                 PythonQtWrapper* w2 = (PythonQtWrapper*)obj2;
                 if (w1->_wrappedPtr != NULL) {
                   if (w1->_wrappedPtr == w1->_wrappedPtr) {
                     return 0;
                   } else {
                     return -1;
                   }
                 } else if (w1->_obj == w2->_obj) {
                   return 0;
                 } else {
                   return -1;
                 }
               } else {
                 return -1;
               }
             }
             static int PythonQtWrapper_nonzero(PyObject *obj)
             {
               PythonQtWrapper* wt = (PythonQtWrapper*)obj;
               return (wt->_wrappedPtr == NULL && wt->_obj == NULL)?0:1;
             }
             static long PythonQtWrapper_hash(PythonQtWrapper *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 PythonQtWrapper_as_number = {
 ,      /* nb_add */
 ,      /* nb_subtract */
 ,      /* nb_multiply */
 ,      /* nb_divide */
 ,      /* nb_remainder */
 ,      /* nb_divmod */
 ,      /* nb_power */
 ,      /* nb_negative */
 ,      /* nb_positive */
 ,      /* nb_absolute */
                 PythonQtWrapper_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 PythonQtWrapper_Type = {
               PyObject_HEAD_INIT(NULL)
 ,                         /*ob_size*/
                 "PythonQt.PythonQtWrapper",             /*tp_name*/
                 sizeof(PythonQtWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
                 (destructor)PythonQtWrapper_dealloc, /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
                 PythonQtWrapper_compare,         /*tp_compare*/
                 PythonQtWrapper_repr,            /*tp_repr*/
                 &PythonQtWrapper_as_number,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
                 (hashfunc)PythonQtWrapper_hash,                         /*tp_hash */
 ,                         /*tp_call*/
 ,                         /*tp_str*/
                 PythonQtWrapper_getattro,                         /*tp_getattro*/
                 PythonQtWrapper_setattro,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
                 "PythonQtWrapper 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)PythonQtWrapper_init,      /* tp_init */
 ,                         /* tp_alloc */
                 PythonQtWrapper_new,                 /* tp_new */
             };
             //-------------------------------------------------------

src/src.pri +2 0

             DEFINES +=  PYTHONQT_EXPORTS
             HEADERS +=                    \
               $$PWD/PythonQt.h                  \
               $$PWD/PythonQtStdDecorators.h     \
               $$PWD/PythonQtClassInfo.h         \
               $$PWD/PythonQtImporter.h          \
               $$PWD/PythonQtObjectPtr.h         \
               $$PWD/PythonQtSlot.h              \
               $$PWD/PythonQtStdOut.h            \
               $$PWD/PythonQtMisc.h              \
               $$PWD/PythonQtMethodInfo.h        \
               $$PWD/PythonQtImportFileInterface.h \
               $$PWD/PythonQtConversion.h        \
               $$PWD/PythonQtSignalReceiver.h    \
               $$PWD/PythonQtWrapper.h           \
               $$PWD/PythonQtMetaObjectWrapper.h \
               $$PWD/PythonQtCppWrapperFactory.h \
               $$PWD/PythonQtVariants.h          \
               $$PWD/PythonQtVariantWrapper.h    \
+              $$PWD/PythonQtQFileImporter.h     \
               $$PWD/wrapper/PythonQtWrappedVariants.h    \
               $$PWD/gui/PythonQtScriptingConsole.h    \
               $$PWD/PythonQtSystem.h
             SOURCES +=                    \
               $$PWD/PythonQtStdDecorators.cpp   \
               $$PWD/PythonQt.cpp                \
               $$PWD/PythonQtClassInfo.cpp       \
               $$PWD/PythonQtImporter.cpp        \
               $$PWD/PythonQtObjectPtr.cpp       \
               $$PWD/PythonQtStdOut.cpp          \
               $$PWD/PythonQtSlot.cpp            \
               $$PWD/PythonQtMisc.cpp            \
               $$PWD/PythonQtMethodInfo.cpp      \
               $$PWD/PythonQtConversion.cpp      \
               $$PWD/PythonQtSignalReceiver.cpp  \
               $$PWD/PythonQtVariants.cpp        \
               $$PWD/PythonQtVariantWrapper.cpp \
               $$PWD/PythonQtWrapper.cpp         \
+              $$PWD/PythonQtQFileImporter.cpp    \
               $$PWD/PythonQtMetaObjectWrapper.cpp \
               $$PWD/gui/PythonQtScriptingConsole.cpp

examples/CPPPyWrapperExample/QFileImportInterface.cpp removed 0 -42

NO CONTENT: file was removed

examples/CPPPyWrapperExample/QFileImportInterface.h removed 0 -20

NO CONTENT: file was removed

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