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);
                   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");
                   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()));

examples/CPPPyWrapperExample/CPPPyWrapperExample.pro +3 -3

             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

             #include "PythonQtCppWrapperFactory.h"
             #include "PythonQtVariants.h"
             #include "PythonQtStdDecorators.h"
+            #include "PythonQtQFileImporter.h"
             #include <pydebug.h>
             PythonQt* PythonQt::_self = 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()) {
               {
                 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();
             PythonQtImportFileInterface* PythonQt::importInterface()
             {
-              return _self->_p->_importInterface;
+              return _self->_p->_importInterface?_self->_p->_importInterface:_self->_p->_defaultImporter;
             }
             void PythonQt::registerClass(const QMetaObject* metaobject)
             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)
             PythonQtPrivate::PythonQtPrivate()
             {
               _importInterface = NULL;
+              _defaultImporter = new PythonQtQFileImporter;
               _noLongerWrappedCB = NULL;
               _wrappedCB = NULL;
             }

src/PythonQt.h +19 -1

             class PythonQtImportFileInterface;
             class PythonQtCppWrapperFactory;
             class PythonQtConstructorHandler;
+            class PythonQtQFileImporter;
             typedef void PythonQtQObjectWrappedCB(QObject* object);
             typedef void PythonQtQObjectNoLongerWrappedCB(QObject* object);
               //! 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);
               //! the importer interface (if set)
               PythonQtImportFileInterface* _importInterface;
+              //! the default importer
+              PythonQtQFileImporter* _defaultImporter;
               PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
               PythonQtQObjectWrappedCB* _wrappedCB;

src/PythonQtConversion.cpp +2 -2

               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) {
               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)) {

src/PythonQtDoc.h +2 -6

              \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.
              \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.
              \endcode
-              \section TODOs
-              - add more information on how to distribute an application that uses PythonQt, including the Python distribution
             */

src/PythonQtImportFileInterface.h +3 0

             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;

src/PythonQtImporter.cpp +36 -45

             /* 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;
               }
               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;
                       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_source(PyObject *obj, PyObject *args)
+            PythonQtImporter_get_source(PyObject * /*obj*/, PyObject * /*args*/)
             {
               // EXTRA, NOT YET IMPLEMENTED
             /*
                doc_get_code},
               {"get_source", PythonQtImporter_get_source, METH_VARARGS,
                doc_get_source},
-              {NULL,    NULL} /* sentinel */
+              {NULL,    NULL, 0 , NULL} /* sentinel */
             };
             /* 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;
                 } else {
                   qdata = PythonQt::importInterface()->readFileAsBytes(path);
                 }
               if (isbytecode) {
             //    mlabDebugConst("MLABPython", "reading bytecode " << path);
                 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());
                 }
               }
               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;
             }
             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);
             /* 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)

src/PythonQtMetaObjectWrapper.cpp +3 -3

               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;
               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;
             }
                 {"help", (PyCFunction)PythonQtMetaObjectWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
-                {NULL}  /* Sentinel */
+                {NULL, NULL, 0 , NULL}  /* Sentinel */
             };

src/PythonQtMetaObjectWrapper.h +3 0

             // 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;
             };

src/PythonQtMisc.h +1 0

                 foreach(chunk, _chunks) {
                   delete[]chunk;
                 }
+                _chunks.clear();
               }
               //! reset the storage to 0 (without freeing memory, thus caching old entries for reuse)

src/PythonQtSlot.cpp +10 -6

               }
             }
-            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);
             }
             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 PyObject *
-            meth_get__self__(PythonQtSlotFunctionObject *m, void *closure)
+            meth_get__self__(PythonQtSlotFunctionObject *m, void * /*closure*/)
             {
               PyObject *self;
               if (PyEval_GetRestricted()) {
               {"__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}
             };

src/PythonQtStdOut.cpp +3 -3

             #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);
               return Py_BuildValue("");
             }
-            static PyObject *PythonQtStdOutRedirect_flush(PyObject *self, PyObject *args)
+            static PyObject *PythonQtStdOutRedirect_flush(PyObject * /*self*/, PyObject * /*args*/)
             {
               return Py_BuildValue("");
             }
               {"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[] = {

src/PythonQtVariantWrapper.cpp +3 -3

               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;
               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;
             }
                 {"help", (PyCFunction)PythonQtVariantWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
-                {NULL}  /* Sentinel */
+                {NULL,NULL,0,NULL}  /* Sentinel */
             };

src/PythonQtWrapper.cpp +6 -3

               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;
               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;
             }
                 {"help", (PyCFunction)PythonQtWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
-                {NULL}  /* Sentinel */
+                {NULL, NULL, 0, NULL}  /* Sentinel */
             };
               case PythonQtMemberInfo::EnumValue:
                 return PyInt_FromLong(member._enumValue);
                 break;
+                default:
+                  // is an invalid type, go on
+                break;
               }
               // look for the interal methods (className(), help())

src/src.pri +2 0

               $$PWD/PythonQtCppWrapperFactory.h \
               $$PWD/PythonQtVariants.h          \
               $$PWD/PythonQtVariantWrapper.h    \
+              $$PWD/PythonQtQFileImporter.h     \
               $$PWD/wrapper/PythonQtWrappedVariants.h    \
               $$PWD/gui/PythonQtScriptingConsole.h    \
               $$PWD/PythonQtSystem.h
               $$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