#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 * */ //---------------------------------------------------------------------------------- /*! // \file PythonQt.h // \author Florian Link // \author Last changed by $Author: florian $ // \date 2006-05 */ //---------------------------------------------------------------------------------- #include "PythonQtSystem.h" #include "PythonQtWrapper.h" #include "PythonQtSlot.h" #include "PythonQtObjectPtr.h" #include #include #include #include #include #include #include #include class PythonQtClassInfo; class PythonQtPrivate; class PythonQtMethodInfo; class PythonQtSignalReceiver; class PythonQtImportFileInterface; class PythonQtCppWrapperFactory; //! the main interface to the Python Qt binding, realized as a singleton class PYTHONQT_EXPORT PythonQt : public QObject { Q_OBJECT public: enum InitFlags { RedirectStdOut=1, IgnoreSiteModule=2 }; //! initialize the python qt binding (flags are a or combination of InitFlags) static void init(int flags); //! cleanup static void cleanup(); //! get the singleton instance static PythonQt* self() { return _self; } //----------------------------------------------------------------------------- // Public API: //! defines the object types for introspection enum ObjectType { Class, Function, Variable, Module }; //! overwrite the python sys path (call this directly after PythonQt::init() if you want to change the std python sys path) void overwriteSysPath(const QStringList& paths); //! sets the __path__ list of a module to the given list (important for local imports) void setModuleImportPath(PyObject* module, const QStringList& paths); //! get the __main__ module of python PythonQtObjectPtr getMainModule(); //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well) /* 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); //! add the given factory to PythonQt (ownership stays with caller) void addWrapperFactory(PythonQtCppWrapperFactory* factory); //! parses the given file and returns the python code object, this can then be used to call evalCode() PythonQtObjectPtr parseFile(const QString& filename); //! evaluates the given code and returns the result value (use Py_Compile etc. to create pycode from string) //! If pycode is NULL, a python error is printed. QVariant evalCode(PyObject* module, PyObject* pycode); //! evaluates the given script code and returns the result value QVariant evalScript(PyObject* module, const QString& script, int start = Py_file_input); //@{ Signal handlers //! add a signal handler to the given \c signal of \c obj and connect it to a callable \c objectname in module bool addSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname); //! remove a signal handler from the given \c signal of \c obj bool removeSignalHandler(QObject* obj, const char* signal, PyObject* module, const QString& objectname); //! add a signal handler to the given \c signal of \c obj and connect it to a callable \c receiver bool addSignalHandler(QObject* obj, const char* signal, PyObject* receiver); //! remove a signal handler from the given \c signal of \c obj bool removeSignalHandler(QObject* obj, const char* signal, PyObject* receiver); //@} //@{ Variable access //! add the given \c object to the \c module as a variable with \c name (it can be removed via clearVariable) void addObject(PyObject* module, const QString& name, QObject* object); //! add the given variable to the module void addVariable(PyObject* module, const QString& name, const QVariant& v); //! remove the given variable void removeVariable(PyObject* module, const QString& name); //! get the variable with the \c name of the \c module, returns an invalid QVariant on error QVariant getVariable(PyObject* module, const QString& name); //! read vars etc. in scope of a module, optional looking inside of an object \c objectname QStringList introspection(PyObject* module, const QString& objectname, ObjectType type); //! returns the found callable object or NULL //! @return new reference PythonQtObjectPtr lookupCallable(PyObject* module, const QString& name); //@} //@{ Calling of python callables //! call the given python method, returns the result converted to a QVariant QVariant call(PyObject* module, const QString& callable, const QVariantList& args); //@} //@{ Custom importer (to replace internal import implementation of python) //! 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) void setImporter(PythonQtImportFileInterface* importInterface); //! set paths that the importer should ignore void setImporterIgnorePaths(const QStringList& paths); //! get paths that the importer should ignore const QStringList& getImporterIgnorePaths(); //@} //! get access to internal data (should not be used on the public API, but is used by some C functions) static PythonQtPrivate* priv() { return _self->_p; } //! get access to the file importer (if set) static PythonQtImportFileInterface* importInterface(); //! handle a python error, call this when a python function fails. If no error occurred, it returns false. //! The error is currently just output to the python stderr, future version might implement better trace printing bool handleError(); signals: //! emitted when python outputs something to stdout (and redirection is turned on) void pythonStdOut(const QString& str); //! emitted when python outputs something to stderr (and redirection is turned on) void pythonStdErr(const QString& str); private: void initPythonQtModule(bool redirectStdOut); //! callback for stdout redirection, emits pythonStdOut signal static void stdOutRedirectCB(const QString& str); //! callback for stderr redirection, emits pythonStdErr signal static void stdErrRedirectCB(const QString& str); //! returns the found object or NULL //! @return new reference PythonQtObjectPtr lookupObject(PyObject* module, const QString& name); //! get (and create if not available) the signal receiver of that QObject, signal receiver is made child of the passed \c obj PythonQtSignalReceiver* getSignalReceiver(QObject* obj); PythonQt(int flags); ~PythonQt(); static PythonQt* _self; PythonQtPrivate* _p; }; //! stores information about a currently created (pending) wrapper object struct PythonQtPendingObject { QObject* _obj; void* _wrappedPtr; PythonQtClassInfo* _info; }; //! internal PythonQt details class PythonQtPrivate : public QObject { Q_OBJECT public: PythonQtPrivate(); ~PythonQtPrivate(); //! get information on the pending object to be wrapped PythonQtPendingObject* pendingObject() { return &_pendingObject; } //! remove the wrapper ptr again void removeWrapperPointer(void* obj) { _wrappedObjects.take(obj); } //! returns the signal info if the signature, uses a signal cache internally to speed up //! multiple requests for the same signal const PythonQtMethodInfo* getSignalInfo(const QMetaMethod& signal); //! wrap the given QObject into a Python object (or return existing wrapper!) PyObject* wrapQObject(QObject* obj); //! wrap the given ptr into a Python object (or return existing wrapper!) if there is a known QObject of that name or a known wrapper in the factory PyObject* wrapPtr(void* ptr, const QByteArray& name); //! registers a QObject derived class to PythonQt (this is implicitly called by addObject as well) /* 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); protected slots: //! called when a wrapped QObject is destroyed void wrappedObjectDestroyed(QObject* obj); //! called when a signal emitting QObject is destroyed to remove the signal handler from the hash map void destroyedSignalEmitter(QObject* obj); private: //! stores pointer to PyObject mapping of wrapped QObjects AND C++ objects QHash _wrappedObjects; //! stores the meta info if known Qt classes QHash _knownQtClasses; //! stores the meta info if known Qt C++ wrapper classes QHash _knownQtWrapperClasses; //! stores the cached signatures of signals to speedup mapping from Qt to Python types QHash _cachedSignalSignatures; //! stores signal receivers for QObjects QHash _signalReceivers; //! stores a pending object to be injected inside of the PythonQtWrapper constructor (because marshalling would be ugly as well) PythonQtPendingObject _pendingObject; //! the PythonQt python module PythonQtObjectPtr _pythonQtModule; //! the importer interface (if set) PythonQtImportFileInterface* _importInterface; QStringList _importIgnorePaths; //! the cpp object wrapper factories QList _cppWrapperFactories; friend class PythonQt; }; #endif