PythonQt.h

Go to the documentation of this file.

#ifndef _PYTHONQT_H
#define _PYTHONQT_H

/*
 *
 *  Copyright (C) 2010 MeVis Medical Solutions AG 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 Medical Solutions AG, Universitaetsallee 29,
 *  28359 Bremen, Germany or:
 *
 *  http://www.mevis.de
 *
 */

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

#include "PythonQtSystem.h"
#include "PythonQtInstanceWrapper.h"
#include "PythonQtClassWrapper.h"
#include "PythonQtSlot.h"
#include "PythonQtObjectPtr.h"
#include "PythonQtStdIn.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 PythonQtForeignWrapperFactory;
class PythonQtQFileImporter;

typedef void  PythonQtQObjectWrappedCB(QObject* object);
typedef void  PythonQtQObjectNoLongerWrappedCB(QObject* object);
typedef void* PythonQtPolymorphicHandlerCB(const void *ptr, const char **class_name);

typedef void PythonQtShellSetInstanceWrapperCB(void* object, PythonQtInstanceWrapper* wrapper);

template<class T> void PythonQtSetInstanceWrapperOnShell(void* object, PythonQtInstanceWrapper* wrapper) { 
  (reinterpret_cast<T*>(object))->_wrapper = wrapper;
}

template<class T1, class T2> int PythonQtUpcastingOffset() {
  return ((reinterpret_cast<char*>(static_cast<T2*>(reinterpret_cast<T1*>(0x100)))) 
          - (reinterpret_cast<char*>(reinterpret_cast<T1*>(0x100))));
}

typedef QObject* PythonQtQObjectCreatorFunctionCB();

template<class T> QObject* PythonQtCreateObject() { return new T(); };


class PYTHONQT_EXPORT PythonQt : public QObject {

  Q_OBJECT

public:

  enum InitFlags {
    RedirectStdOut = 1,   
    IgnoreSiteModule = 2, 
    ExternalHelp = 4,     
    PythonAlreadyInitialized = 8 
  };

  enum TypeSlots {
    Type_Add = 1,
    Type_Subtract = 1 << 1,
    Type_Multiply = 1 << 2,
    Type_Divide = 1 << 3,
    Type_Mod = 1 << 4,
    Type_And = 1 << 5,
    Type_Or = 1 << 6,
    Type_Xor = 1 << 7,
    Type_LShift = 1 << 8,
    Type_RShift = 1 << 9,

    Type_InplaceAdd = 1 << 10,
    Type_InplaceSubtract = 1 << 11,
    Type_InplaceMultiply = 1 << 12,
    Type_InplaceDivide = 1 << 13,
    Type_InplaceMod = 1 << 14,
    Type_InplaceAnd = 1 << 15,
    Type_InplaceOr = 1 << 16,
    Type_InplaceXor = 1 << 17,
    Type_InplaceLShift = 1 << 18,
    Type_InplaceRShift = 1 << 19,

    // Not yet needed/nicely mappable/generated...
    //Type_Positive = 1 << 29,
    //Type_Negative = 1 << 29,
    //Type_Abs = 1 << 29,
    //Type_Hash = 1 << 29,

    Type_Invert = 1 << 29,
    Type_RichCompare = 1 << 30,
    Type_NonZero     = 1 << 31,

  };

  enum ProfilingCallbackState {
    Enter = 1,
    Leave = 2
  };

  typedef void ProfilingCB(ProfilingCallbackState state, const char* className, const char* methodName);

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


  static void init(int flags = IgnoreSiteModule | RedirectStdOut, const QByteArray& pythonQtModuleName = QByteArray());

  static void cleanup();

  static PythonQt* self();


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


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


  void setRedirectStdInCallback(PythonQtInputChangedCB* callback, void * callbackData = 0);

  void setRedirectStdInCallbackEnabled(bool enabled);


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


  PythonQtObjectPtr getMainModule();

  PythonQtObjectPtr importModule(const QString& name);

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

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

  PythonQtObjectPtr createUniqueModule();


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


  void overwriteSysPath(const QStringList& paths);

  void addSysPath(const QString& path);

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


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


  /* 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, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);


  void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL);

  void registerQObjectClassNames(const QStringList& names);

  bool addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset=0);

  void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);


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


  PythonQtObjectPtr parseFile(const QString& filename);

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

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

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


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


  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* object, const QString& name, QObject* qObject);

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

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

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

  QStringList introspection(PyObject* object, const QString& objectname, ObjectType type);
  QStringList introspectObject(PyObject* object, ObjectType type);
  QStringList introspectType(const QString& typeName, ObjectType type);

  PythonQtObjectPtr lookupCallable(PyObject* object, const QString& name);
  
  QString getReturnTypeOfWrappedMethod(PyObject* module, const QString& objectname);  
  QString getReturnTypeOfWrappedMethod(const QString& typeName, const QString& methodName);

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


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

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

  PyObject* callAndReturnPyObject(PyObject* callable, const QVariantList& args = QVariantList());


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



  void addInstanceDecorators(QObject* o);


  void addClassDecorators(QObject* o);

  void addDecorators(QObject* o);

  void addWrapperFactory(PythonQtCppWrapperFactory* factory);

  void addWrapperFactory(PythonQtForeignWrapperFactory* factory);

  void removeWrapperFactory(PythonQtCppWrapperFactory* factory);

  void removeWrapperFactory(PythonQtForeignWrapperFactory* factory);


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


  void setImporter(PythonQtImportFileInterface* importInterface);

  void installDefaultImporter() { setImporter(NULL); }

  void setImporterIgnorePaths(const QStringList& paths);

  const QStringList& getImporterIgnorePaths();

  static PythonQtImportFileInterface* importInterface();


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


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

  bool handleError();

  void clearNotFoundCachedMembers();

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

  static void qObjectNoLongerWrappedCB(QObject* o);

  PyObject* helpCalled(PythonQtClassInfo* info);

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

  void setProfilingCallback(ProfilingCB* cb);


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

  void pythonHelpRequest(const QByteArray& cppClassName);

private:
  void initPythonQtModule(bool redirectStdOut, const QByteArray& pythonQtModuleName);
  
  QString getReturnTypeOfWrappedMethodHelper(const PythonQtObjectPtr& variableObject, const QString& methodName, const QString& context);
  
  PyObject* getObjectByType(const QString& typeName);

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

  PythonQtSignalReceiver* getSignalReceiver(QObject* obj);

  PythonQt(int flags, const QByteArray& pythonQtModuleName);
  ~PythonQt();

  static PythonQt* _self;
  static int _uniqueModuleCount;

  PythonQtPrivate* _p;

};

class PYTHONQT_EXPORT PythonQtPrivate : public QObject {

  Q_OBJECT

public:
  PythonQtPrivate();
  ~PythonQtPrivate();

  enum DecoratorTypes {
    StaticDecorator = 1,
    ConstructorDecorator = 2,
    DestructorDecorator = 4,
    InstanceDecorator = 8,
    AllDecorators = 0xffff
  };

  const QStringList& sharedLibrarySuffixes() { return _sharedLibrarySuffixes; }

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

  void addWrapperPointer(void* obj, PythonQtInstanceWrapper* wrapper);
  void removeWrapperPointer(void* obj);

  void shellClassDeleted(void* shellClass);

  void* unwrapForeignWrapper(const QByteArray& classname, PyObject* obj);

  bool addParentClass(const char* typeName, const char* parentTypeName, int upcastingOffset);

  void addPolymorphicHandler(const char* typeName, PythonQtPolymorphicHandlerCB* cb);

  PythonQtClassInfo* lookupClassInfoAndCreateIfNotPresent(const char* typeName);

  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, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);


  void registerCPPClass(const char* typeName, const char* parentTypeName = NULL, const char* package = NULL, PythonQtQObjectCreatorFunctionCB* wrapperCreator = NULL, PythonQtShellSetInstanceWrapperCB* shell = NULL, PyObject* module = NULL, int typeSlots = 0);

  void registerQObjectClassNames(const QStringList& names);

  void addDecorators(QObject* o, int decoTypes);

  PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* module);

  static PyObject*  createEnumValueInstance(PyObject* enumType, unsigned int enumValue);

  static PyObject* createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject);

  PythonQtInstanceWrapper* createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info, void* wrappedPtr = NULL);

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

  PythonQtClassInfo* getClassInfo(const QByteArray& className) { return _knownClassInfos.value(className); }

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

  PythonQtClassInfo* currentClassInfoForClassWrapperCreation();

  static PyObject* dummyTuple();

  void handleVirtualOverloadReturnError(const char* signature, const PythonQtMethodInfo* methodInfo, PyObject* result);

  PythonQtObjectPtr pythonQtModule() const { return _pythonQtModule; }

  PythonQt::ProfilingCB* profilingCB() const { return _profilingCB; }
  
  QString getSignature(PyObject* object);
  
  bool isMethodDescriptor(PyObject* object) const;

private:
  void setupSharedLibrarySuffixes();

  void createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module = NULL);

  PyObject* packageByName(const char* name);

  PythonQtInstanceWrapper* findWrapperAndRemoveUnused(void* obj);

  QHash<void* , PythonQtInstanceWrapper *> _wrappedObjects;

  QHash<QByteArray, PythonQtClassInfo *>   _knownClassInfos;

  QHash<QByteArray, bool> _knownQObjectClassNames;

  QHash<QObject* , PythonQtSignalReceiver *> _signalReceivers;

  PythonQtObjectPtr _pythonQtModule;

  QByteArray _pythonQtModuleName;

  PythonQtImportFileInterface* _importInterface;

  PythonQtQFileImporter* _defaultImporter;

  PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
  PythonQtQObjectWrappedCB* _wrappedCB;

  QStringList _importIgnorePaths;
  QStringList _sharedLibrarySuffixes;

  QList<PythonQtCppWrapperFactory*> _cppWrapperFactories;

  QList<PythonQtForeignWrapperFactory*> _foreignWrapperFactories;

  QHash<QByteArray, PyObject*> _packages;

  PythonQtClassInfo* _currentClassInfoForClassWrapperCreation;

  PythonQt::ProfilingCB* _profilingCB;

  int _initFlags;
  int _PythonQtObjectPtr_metaId;

  friend class PythonQt;
};

#endif