PythonQt.h

Go to the documentation of this file.

#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
 *
 */

//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------

#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);

class PYTHONQT_EXPORT PythonQt : public QObject {

  Q_OBJECT

public:
  enum InitFlags {
    RedirectStdOut = 1,   
    IgnoreSiteModule = 2, 
    ExternalHelp = 4      
  };

  static void init(int flags = IgnoreSiteModule | RedirectStdOut);

  static void cleanup();

  static PythonQt* self() { return _self; }

  //-----------------------------------------------------------------------------
  // Public API:

  enum ObjectType {
    Class,
    Function,
    Variable,
    Module,
    Anything,
    CallOverloads
  };

  void overwriteSysPath(const QStringList& paths);

  void setModuleImportPath(PyObject* module, const QStringList& paths);

  PythonQtObjectPtr getMainModule();

  /* 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);

  void registerQObjectClassNames(const QStringList& names);

  void registerCPPClassNames(const QStringList& names);

  PythonQtObjectPtr parseFile(const QString& filename);

  QVariant evalCode(PyObject* module, PyObject* pycode);

  QVariant evalScript(PyObject* module, const QString& script, int start = Py_file_input);

  void evalFile(PyObject* module, const QString& filename);

  PythonQtObjectPtr createModuleFromFile(const QString& name, const QString& filename);

  PythonQtObjectPtr createModuleFromScript(const QString& name, const QString& script = QString());

  PythonQtObjectPtr createUniqueModule();


  bool addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname);

  bool removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname);

  bool addSignalHandler(QObject* obj, const char* signal, PyObject* receiver);

  bool removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver);



  void addObject(PyObject* module, const QString& name, QObject* object);

  void addVariable(PyObject* module, const QString& name, const QVariant& v);

  void removeVariable(PyObject* module, const QString& name);

  QVariant getVariable(PyObject* module, const QString& name);

  QStringList introspection(PyObject* module, const QString& objectname, ObjectType type);

  PythonQtObjectPtr lookupCallable(PyObject* module, const QString& name);



  QVariant call(PyObject* module, const QString& callable, const QVariantList& args);





  void addInstanceDecorators(QObject* o);


  void addClassDecorators(QObject* o);

  void addDecorators(QObject* o);


  void addVariantWrapper(const char* typeName, QObject* wrapper);

  void addWrapperFactory(PythonQtCppWrapperFactory* factory);

  void addConstructorHandler(PythonQtConstructorHandler* handler);

  const QList<PythonQtConstructorHandler*>& constructorHandlers();



  void setImporter(PythonQtImportFileInterface* importInterface);

  void installDefaultImporter() { setImporter(NULL); }

  void setImporterIgnorePaths(const QStringList& paths);

  const QStringList& getImporterIgnorePaths();


  static PythonQtPrivate* priv() { return _self->_p; }

  static PythonQtImportFileInterface* importInterface();

  bool handleError();

  void setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb);
  void setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb);

  static void qObjectNoLongerWrappedCB(QObject* o);

signals:
  void pythonStdOut(const QString& str);
  void pythonStdErr(const QString& str);

  void pythonHelpRequest(const QByteArray& cppClassName);


public:
  PyObject* helpCalled(PythonQtClassInfo* info);

  PythonQtObjectPtr lookupObject(PyObject* module, const QString& name);

private:
  void initPythonQtModule(bool redirectStdOut);

  static void stdOutRedirectCB(const QString& str);
  static void stdErrRedirectCB(const QString& str);

  PythonQtSignalReceiver* getSignalReceiver(QObject* obj);

  PythonQt(int flags);
  ~PythonQt();

  static PythonQt* _self;
  static int _uniqueModuleCount;

  PythonQtPrivate* _p;

};

class PythonQtPrivate : public QObject {

  Q_OBJECT

public:
  PythonQtPrivate();
  ~PythonQtPrivate();

  bool isPythonQtObjectPtrMetaId(int id) { return _PythonQtObjectPtr_metaId == id; }

  void removeWrapperPointer(void* obj);

  void removeSignalEmitter(QObject* obj);

  PyObject* wrapQObject(QObject* obj);

  PyObject* wrapPtr(void* ptr, const QByteArray& name);

  /* 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);

  void registerQObjectClassNames(const QStringList& names);

  void addDecorators(QObject* o, bool instanceDeco, bool classDeco);

  void addVariantWrapper(const char* typeName, QObject* wrapper);

  QList<PythonQtSlotInfo*> getDecoratorSlots(const QByteArray& className);

  bool isEnumType(const QMetaObject* meta, const QByteArray& name);

  PythonQtMetaObjectWrapper* createNewPythonQtMetaObjectWrapper(PythonQtClassInfo* info);

  PythonQtWrapper* createNewPythonQtWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);

  PythonQtVariantWrapper* createNewPythonQtVariantWrapper(const QVariant& variant);

  PythonQtClassInfo* getClassInfo(const QMetaObject* meta) { return _knownQtClasses.value(meta->className()); }

  PythonQtSlotInfo* getConstructorSlot(const QByteArray& className) { return _constructorSlots.value(className); }

  PythonQtSlotInfo* getDestructorSlot(const QByteArray& className) { return _destructorSlots.value(className); }

  PythonQtObjectPtr createModule(const QString& name, PyObject* pycode);

private:

  PythonQtWrapper* findWrapperAndRemoveUnused(void* obj);

  QHash<void* , PythonQtWrapper *>       _wrappedObjects;

  QHash<QByteArray, PythonQtClassInfo *> _knownQtClasses;

  QHash<QByteArray, PythonQtClassInfo *> _knownQtWrapperClasses;

  QMultiHash<QByteArray, PythonQtSlotInfo *> _knownQtDecoratorSlots;

  QHash<QByteArray, bool> _knownQObjectClassNames;

  QHash<QObject* , PythonQtSignalReceiver *> _signalReceivers;

  PythonQtObjectPtr _pythonQtModule;

  PythonQtImportFileInterface* _importInterface;

  PythonQtQFileImporter* _defaultImporter;
  
  PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
  PythonQtQObjectWrappedCB* _wrappedCB;

  QStringList _importIgnorePaths;

  QList<PythonQtCppWrapperFactory*> _cppWrapperFactories;

  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

---