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 "PythonQtPythonInclude.h"
#include "PythonQtUtils.h"
#include "PythonQtSystem.h"
#include "PythonQtInstanceWrapper.h"
#include "PythonQtClassWrapper.h"
#include "PythonQtSlot.h"
#include "PythonQtObjectPtr.h"
#include "PythonQtStdIn.h"
#include "PythonQtThreadSupport.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 PythonQtVoidPtrCB(void* object);
typedef void PythonQtQObjectWrappedCB(QObject* object);
typedef void PythonQtQObjectNoLongerWrappedCB(QObject* object);
typedef void* PythonQtPolymorphicHandlerCB(const void* ptr, const char** class_name);
typedef QString PythonQtQObjectMissingAttributeCB(QObject* object, const QString& attribute);
 
typedef void PythonQtShellSetInstanceWrapperCB(void* object, PythonQtInstanceWrapper* wrapper);
 
template<class T>
void PythonQtSetInstanceWrapperOnShell(void* object, PythonQtInstanceWrapper* wrapper)
{
  (reinterpret_cast<T*>(object))->_wrapper = wrapper;
}
 
template<class T>
class PythonQtPassOwnershipToCPP
{
public:
  PythonQtPassOwnershipToCPP(const T& t)
    : _t(t)
  {
  }
  operator T() const { return _t; }
 
  T _t;
};
 
template<class T>
class PythonQtPassOwnershipToPython
{
public:
  PythonQtPassOwnershipToPython(const T& t)
    : _t(t)
  {
  }
  operator T() const { return _t; }
 
  T _t;
};
 
template<class T>
class PythonQtNewOwnerOfThis
{
public:
  PythonQtNewOwnerOfThis(const T& t)
    : _t(t)
  {
  }
  operator T() const { return _t; }
 
  T _t;
};
 
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();
}
 
#define QStringToPythonConstCharPointer(arg) ((arg).toUtf8().constData())
#define QStringToPythonCharPointer(arg) ((arg).toUtf8().data())
#define QStringToPythonEncoding(arg) ((arg).toUtf8())
 
 
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,
 
    Type_Length = 1 << 20,
    Type_MappingSetItem = 1 << 21,
    Type_MappingGetItem = 1 << 22,
 
    Type_EnterExit = 1 << 23,
 
    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, PyObject* args);
 
  //---------------------------------------------------------------------------
 
 
  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 = nullptr);
 
  void setRedirectStdInCallbackEnabled(bool enabled);
 
 
  //---------------------------------------------------------------------------
 
 
  bool redirectStdOutCallbackEnabled() const;
 
  void setRedirectStdOutCallbackEnabled(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 = nullptr,
    PythonQtQObjectCreatorFunctionCB* wrapperCreator = nullptr, PythonQtShellSetInstanceWrapperCB* shell = nullptr);
 
 
  void registerCPPClass(const char* typeName, const char* parentTypeName = nullptr, const char* package = nullptr,
    PythonQtQObjectCreatorFunctionCB* wrapperCreator = nullptr, PythonQtShellSetInstanceWrapperCB* shell = nullptr);
 
  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);
 
  PythonQtObjectPtr parseFileWithPythonLoaders(const QString& filename);
 
  QVariant evalCode(PyObject* object, PyObject* pycode);
 
  QVariant evalScript(PyObject* object, const QString& script, int start = Py_file_input);
 
  QVariant evalScript(const QString& script, PyObject* globals, PyObject* locals, int start);
 
  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 removeSignalHandlers();
 
 
  //---------------------------------------------------------------------------
 
 
  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);
 
  QVariant getNativeVariable(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(),
    const QVariantMap& kwargs = QVariantMap());
 
  QVariant call(PyObject* callable, const QVariantList& args = QVariantList(),
    const QVariantMap& kwargs = QVariantMap());
 
  PyObject* callAndReturnPyObject(PyObject* callable, const QVariantList& args = QVariantList(),
    const QVariantMap& kwargs = QVariantMap());
 
 
  //---------------------------------------------------------------------------
 
 
 
  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(nullptr); }
 
  void setImporterIgnorePaths(const QStringList& paths);
 
  const QStringList& getImporterIgnorePaths();
 
  static PythonQtImportFileInterface* importInterface();
 
 
  //---------------------------------------------------------------------------
 
 
  static PythonQtPrivate* priv() { return _self ? _self->_p : nullptr; }
 
  void clearNotFoundCachedMembers();
 
  bool handleError(bool printStack = true);
 
  bool hadError() const;
 
  void clearError();
 
  void setSystemExitExceptionHandlerEnabled(bool value);
 
  bool systemExitExceptionHandlerEnabled() const;
 
  void setQObjectWrappedCallback(PythonQtQObjectWrappedCB* cb);
  void setQObjectNoLongerWrappedCallback(PythonQtQObjectNoLongerWrappedCB* cb);
 
  static void qObjectNoLongerWrappedCB(QObject* o);
 
  void setQObjectMissingAttributeCallback(PythonQtQObjectMissingAttributeCB* cb);
 
  static QString qObjectMissingAttributeCallback(QObject* o, const QString& attribute);
 
  PyObject* helpCalled(PythonQtClassInfo* info);
 
  PythonQtObjectPtr lookupObject(PyObject* module, const QString& name);
 
  void setProfilingCallback(ProfilingCB* cb);
 
  static void setEnableThreadSupport(bool flag);
 
 
Q_SIGNALS:
  void pythonStdOut(const QString& str);
  void pythonStdErr(const QString& str);
 
  void pythonHelpRequest(const QByteArray& cppClassName);
 
  void systemExitExceptionRaised(int exitCode);
 
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() override;
  static PythonQt* _self;
  static int _uniqueModuleCount;
 
  PythonQtPrivate* _p;
};
 
class PythonQtDebugAPI;
class PythonQtConfigAPI;
 
class PYTHONQT_EXPORT PythonQtPrivate : public QObject
{
 
  Q_OBJECT
 
public:
  PythonQtPrivate();
  ~PythonQtPrivate() override;
 
  enum DecoratorTypes {
    StaticDecorator = 1,
    ConstructorDecorator = 2,
    DestructorDecorator = 4,
    InstanceDecorator = 8,
    AllDecorators = 0xffff
  };
 
  void setTaskDoneCallback(const PythonQtObjectPtr& callable);
 
  PythonQtObjectPtr checkAndRunCoroutine(const PythonQtObjectPtr& object);
 
  PythonQtObjectPtr createAsyncioFuture();
 
  const QStringList& sharedLibrarySuffixes() { return _sharedLibrarySuffixes; }
 
  bool isPythonQtObjectPtrMetaId(int id) { return _PythonQtObjectPtr_metaId == id; }
  bool isPythonQtSafeObjectPtrMetaId(int id) { return _PythonQtSafeObjectPtr_metaId == id; }
  bool isPythonQtAnyObjectPtrMetaId(int id)
  {
    return _PythonQtObjectPtr_metaId == id || _PythonQtSafeObjectPtr_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, bool passOwnership = false);
 
  static PyObject* wrapMemoryAsBuffer(const void* data, Py_ssize_t size);
 
  static PyObject* wrapMemoryAsBuffer(void* data, Py_ssize_t size);
 
  /* 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 = nullptr,
    PythonQtQObjectCreatorFunctionCB* wrapperCreator = nullptr, PythonQtShellSetInstanceWrapperCB* shell = nullptr,
    PyObject* module = nullptr, int typeSlots = 0);
 
 
  void registerCPPClass(const char* typeName, const char* parentTypeName = nullptr, const char* package = nullptr,
    PythonQtQObjectCreatorFunctionCB* wrapperCreator = nullptr, PythonQtShellSetInstanceWrapperCB* shell = nullptr,
    PyObject* module = nullptr, int typeSlots = 0);
 
  void registerGlobalNamespace(const char* typeName, const char* package,
    PythonQtQObjectCreatorFunctionCB* wrapperCreator, const QMetaObject& metaObject, PyObject* module = nullptr);
 
  void registerQObjectClassNames(const QStringList& names);
 
  void addDecorators(QObject* o, int decoTypes);
 
  PythonQtClassWrapper* createNewPythonQtClassWrapper(PythonQtClassInfo* info, PyObject* module,
    const QByteArray& pythonClassName);
 
  static PyObject* createEnumValueInstance(PyObject* enumType, unsigned int enumValue);
 
  static PyObject* createNewPythonQtEnumWrapper(const char* enumName, PyObject* parentObject);
 
  PythonQtInstanceWrapper* createNewPythonQtInstanceWrapper(QObject* obj, PythonQtClassInfo* info,
    void* wrappedPtr = nullptr);
 
  PythonQtClassInfo* getClassInfo(const QMetaObject* meta);
 
  PythonQtClassInfo* getClassInfo(const QByteArray& className);
 
  void registerLazyClass(const QByteArray& name, const QByteArray& moduleToImport);
 
  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;
 
  const QMetaObject* getDynamicMetaObject(PythonQtInstanceWrapper* wrapper, const QMetaObject* prototypeMetaObject);
 
  const QMetaObject* setupDynamicMetaObjectChain(PythonQtClassWrapper* type, const QMetaObject* prototypeMetaObject);
 
  const QMetaObject* buildDynamicMetaObject(PythonQtClassWrapper* type, const QMetaObject* prototypeMetaObject);
 
  int handleMetaCall(QObject* object, PythonQtInstanceWrapper* wrapper, QMetaObject::Call call, int id, void** args);
 
  void callMethodInPython(QMetaMethod& method, PythonQtInstanceWrapper* wrapper, void** args);
 
private:
  void setupSharedLibrarySuffixes();
 
  void createPythonQtClassWrapper(PythonQtClassInfo* info, const char* package, PyObject* module = nullptr);
 
  PyObject* packageByName(const char* name);
 
  PythonQtInstanceWrapper* findWrapperAndRemoveUnused(void* obj);
 
  QHash<void*, PythonQtInstanceWrapper*> _wrappedObjects;
 
  QHash<QByteArray, PythonQtClassInfo*> _knownClassInfos;
 
  QHash<QByteArray, bool> _knownQObjectClassNames;
 
  QHash<QByteArray, QByteArray> _knownLazyClasses;
 
  QHash<QObject*, PythonQtSignalReceiver*> _signalReceivers;
 
  PythonQtObjectPtr _pythonQtModule;
 
  QByteArray _pythonQtModuleName;
 
  PythonQtImportFileInterface* _importInterface;
 
  PythonQtQFileImporter* _defaultImporter;
 
  PythonQtQObjectNoLongerWrappedCB* _noLongerWrappedCB;
  PythonQtQObjectWrappedCB* _wrappedCB;
  PythonQtQObjectMissingAttributeCB* _qObjectMissingAttribCB;
 
  QStringList _importIgnorePaths;
  QStringList _sharedLibrarySuffixes;
 
  PythonQtObjectPtr _pySourceFileLoader;
  PythonQtObjectPtr _pySourcelessFileLoader;
  PythonQtObjectPtr _pyEnsureFuture;
  PythonQtObjectPtr _pyFutureClass;
 
  PythonQtObjectPtr _pyTaskDoneCallback;
 
  QList<PythonQtCppWrapperFactory*> _cppWrapperFactories;
 
  QList<PythonQtForeignWrapperFactory*> _foreignWrapperFactories;
 
  QHash<QByteArray, PyObject*> _packages;
 
  PythonQtClassInfo* _currentClassInfoForClassWrapperCreation;
 
  PythonQt::ProfilingCB* _profilingCB;
 
  PythonQtDebugAPI* _debugAPI;
  PythonQtConfigAPI* _configAPI;
 
  int _initFlags;
  int _PythonQtObjectPtr_metaId;
  int _PythonQtSafeObjectPtr_metaId;
 
  bool _hadError;
  bool _systemExitExceptionHandlerEnabled;
 
  friend class PythonQt;
};
 
#endif