- removed warnings

- fixed some memory leaks (only on cleanup)
- fixed bad QString usage as %s argument
- added PythonQtQFileImporter, which implements a default importer using QFile
- added PythonQt::self()->installDefaultImporter() to enable the new default importer
- modified example to make use of new importer
- removed ugly goto, which was copied from original zip import


git-svn-id: http://svn.code.sf.net/p/pythonqt/code/trunk@43 ea8d5007-eb21-0410-b261-ccb3ea6e24a9

Author: florianlink

examples/CPPPyWrapperExample/CPPPyWrapperExample.cpp

@@ -1,6 +1,5 @@
 #include <PythonQt.h>
 #include <QtGui>
-#include "QFileImportInterface.h"
 
 int main (int argc, char* argv[]) {
     QApplication app(argc, argv);
@@ -19,11 +18,10 @@ int main (int argc, char* 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");
@@ -33,7 +31,6 @@ int main (int argc, char* argv[]) {
       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

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

examples/CPPPyWrapperExample/QFileImportInterface.cpp

@@ -49,6 +49,7 @@
 #include "PythonQtCppWrapperFactory.h"
 #include "PythonQtVariants.h"
 #include "PythonQtStdDecorators.h"
+#include "PythonQtQFileImporter.h"
 #include <pydebug.h>
 
 PythonQt* PythonQt::_self = NULL;
@@ -163,6 +164,14 @@ PythonQt::~PythonQt() {
 }
 
 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()) {
@@ -184,13 +193,25 @@ PythonQtPrivate::~PythonQtPrivate() {
   {
     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();
@@ -204,7 +225,7 @@ PythonQtPrivate::~PythonQtPrivate() {
 
 PythonQtImportFileInterface* PythonQt::importInterface()
 {
-  return _self->_p->_importInterface;
+  return _self->_p->_importInterface?_self->_p->_importInterface:_self->_p->_defaultImporter;
 }
 
 void PythonQt::registerClass(const QMetaObject* metaobject)
@@ -760,12 +781,8 @@ void PythonQt::registerQObjectClassNames(const QStringList& names)
 
 void PythonQt::setImporter(PythonQtImportFileInterface* importInterface)
 {
-  static bool first = true;
-  if (first) {
-    first = false;
-    _p->_importInterface = importInterface;
-    PythonQtImport::init();
-  }
+  PythonQtImport::init();
+  _p->_importInterface = importInterface;
 }
 
 void PythonQt::setImporterIgnorePaths(const QStringList& paths)
@@ -797,6 +814,7 @@ const QList<PythonQtConstructorHandler*>& PythonQt::constructorHandlers()
 PythonQtPrivate::PythonQtPrivate()
 {
   _importInterface = NULL;
+  _defaultImporter = new PythonQtQFileImporter;
   _noLongerWrappedCB = NULL;
   _wrappedCB = NULL;
 }

examples/CPPPyWrapperExample/QFileImportInterface.h

@@ -65,6 +65,7 @@ class PythonQtSignalReceiver;
 class PythonQtImportFileInterface;
 class PythonQtCppWrapperFactory;
 class PythonQtConstructorHandler;
+class PythonQtQFileImporter;
 
 typedef void PythonQtQObjectWrappedCB(QObject* object);
 typedef void PythonQtQObjectNoLongerWrappedCB(QObject* object);
@@ -278,9 +279,23 @@ class PYTHONQT_EXPORT PythonQt : public QObject {
 
   //! 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);
 
@@ -442,6 +457,9 @@ class PythonQtPrivate : public QObject {
   //! the importer interface (if set)
   PythonQtImportFileInterface* _importInterface;
 
+  //! the default importer
+  PythonQtQFileImporter* _defaultImporter;
+  
   PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
   PythonQtQObjectWrappedCB* _wrappedCB;
 

src/PythonQt.cpp

@@ -588,7 +588,7 @@ QString PythonQtConv::PyObjGetString(PyObject* val, bool strict, bool& ok) {
   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) {
@@ -980,7 +980,7 @@ PyObject* PythonQtConv::ConvertQListWithPointersToPython(QList<void*>* list, con
   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/PythonQt.h

@@ -51,7 +51,7 @@
 
  \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.
 
@@ -339,7 +339,7 @@ yourCpp = None
 
  \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.
@@ -459,8 +459,4 @@ the python2x.[lib | dll | so | dynlib].
  \endcode
 
 
-  \section TODOs
-
-  - add more information on how to distribute an application that uses PythonQt, including the Python distribution
-
 */

src/PythonQtConversion.cpp

@@ -51,6 +51,9 @@
 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;