GeezerVison

callback for profiling. className and methodName are only passed when state == Enter, otherwise they are NULL.

Definition at line 234 of file PythonQt.h.

flags that can be passed to PythonQt::init()

Definition at line 186 of file PythonQt.h.

defines the object types for introspection

Definition at line 254 of file PythonQt.h.

enum for profiling callback

Definition at line 230 of file PythonQt.h.

flags that tell PythonQt which operators to expect on the registered type

Definition at line 194 of file PythonQt.h.

add an object whose slots will be used as decorator slots for class objects (ownership is passed to PythonQt)

The slots need to follow the following convention:

• SomeClass* new_SomeClass(...)
• QVariant new_SomeClass(...)
• void delete_SomeClass(SomeClass*)
• ... static_SomeClass_someName(...)

This will add:

• a constructor
• a constructor which generates a QVariant
• a destructor (only useful for CPP objects)
• a static decorator slot which will be available on the MetaObject (visible in PythonQt module)

this will add the object both as class and instance decorator (ownership is passed to PythonQt)

add an object whose slots will be used as decorator slots for other QObjects or CPP classes. The slots need to follow the convention that the first argument is a pointer to the wrapped object. (ownership is passed to PythonQt)

Example:

A slot with the signature

will extend QWidget instances (and derived classes) with a "bool doSomething(int a)" slot that will be called with the concrete instance as first argument. So in Python you can now e.g. call

without QWidget really having this method. This allows to easily make normal methods of Qt classes callable by forwarding them with such decorator slots or to make CPP classes (which are not derived from QObject) callable from Python.

add the given qObject to the python object as a variable with name (it can be removed via clearVariable)

add a parent class relation to the given typeName, the upcastingOffset is needed for multiple inheritance and can be calculated using PythonQtUpcastingOffset<type,parentType>(), which also verifies that type is really derived from parentType. Returns false if the typeName was not yet registered.

add a handler for polymorphic downcasting

add a signal handler to the given signal of obj and connect it to a callable objectname in module

add a signal handler to the given signal of obj and connect it to a callable receiver

prepend a path to sys.path to allow importing from it

add the given variable to the object

add the given factory to PythonQt (ownership stays with caller)

add the given factory to PythonQt (ownership stays with caller)

call the given python object, returns the result converted to a QVariant

call the given python callable in the scope of object, returns the result converted to a QVariant

call the given python object, returns the result as new PyObject

cleanup of the singleton

reset error flag. After calling this, hadError() will return false.

See also

hadError()

clear all NotFound entries on all class infos, to ensure that newly loaded wrappers can add methods even when the object was wrapped by PythonQt before the wrapper was loaded

creates the new module name and evaluates the given file in the context of that module If the script is empty, the module contains no initial code. You can use evalScript/evalCode to add code to a module later on. The user needs to make sure that the name is unique in the python module dictionary.

creates the new module name and evaluates the given script in the context of that module. If the script is empty, the module contains no initial code. You can use evalScript/evalCode to add code to a module later on. The user needs to make sure that the name is unique in the python module dictionary.

create a uniquely named module, you can use evalFile or evalScript to populate the module with script code

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.

evaluates the given script code from file

evaluates the given script code in context of given globals and locals and returns the result value

evaluates the given script code and returns the result value

get paths that the importer should ignore

get the main module of python

get the variable with the name of the object as QVariant of type PythonQtObjectPtr, returns an invalid QVariant on error

returns the return type of the method methodName of a wrapped c++ type referenced by typeName

returns the return type of the method of a wrapped c++ object referenced by objectname

get the variable with the name of the object, returns an invalid QVariant on error

return true if handleError() has been called and an error occurred.

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

called by internal help methods

get access to the file importer (if set)

Referenced by setImporter().

import the given module and return a reference to it (useful to import e.g. "sys" and call something on it) If a module is already imported, this returns the already imported module.

initialize the python qt binding (flags are a or combination of PythonQt::InitFlags), if pythonQtModuleName is given it defines the name of the python module that PythonQt will add, otherwise "PythonQt" is used. This can be used to e.g. pass in PySide or PyQt4 to make it more compatible.

References IgnoreSiteModule, and RedirectStdOut.

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.

Definition at line 554 of file PythonQt.h.

References setImporter().

read vars etc. in scope of an object, optional looking inside of an object objectname

read vars etc. in scope of the given object

read vars etc. in scope of the type object called typename. First the typename of the form module.type is split into module and type. Then the module is looked up in sys.modules. If the module or type is not found there, then the type is looked up in the builtin module.

returns the found callable object or NULL

Returns

new reference

returns the found object or NULL

Returns

new reference

overwrite the python sys path (call this directly after PythonQt::init() if you want to change the std python sys path)

parses the given file (using PythonQt's own import mechanism) and returns the python code object, this can then be used to call evalCode()

Parses the given file and returns the python code object, this can then be used to call evalCode() It uses Python's importlib machinery to load the file's code and supports source and sourceless loading and generation of cache files.

get access to internal data (should not be used on the public API, but is used by some C functions)

Definition at line 572 of file PythonQt.h.

Referenced by PythonQtConvertListOfKnownClassToPythonList(), and PythonQtConvertPythonListToListOfKnownClass().

emitted when help() is called on a PythonQt object and ExternalHelp is enabled

emitted when python outputs something to stderr (and redirection is turned on)

emitted when python outputs something to stdout (and redirection is turned on)

call the callback if it is set

call the callback if it is set

return true if std out/err redirection is enabled.

registers a QObject derived class to PythonQt (this is implicitly called by addObject as well)

add a wrapper object for the given QMetaType typeName, also does an addClassDecorators() to add constructors for variants (ownership of wrapper is passed to PythonQt)

Make sure that you have done a qRegisterMetaType first, if typeName is a user type!

This will add a wrapper object that is used to make calls to the given classname typeName. All slots that take a pointer to typeName as the first argument will be callable from Python on a variant object that contains such a type.

as an alternative to registerClass, you can tell PythonQt the names of QObject derived classes and it will register the classes when it first sees a pointer to such a derived class

remove a signal handler from the given signal of obj

remove a signal handler from the given signal of obj

globally removes all signal handlers (connections between QObjects and Python).

remove the given variable

remove the wrapper factory

remove the wrapper factory

get the singleton instance

Enable GIL and thread state handling (turned off by default). If you want to use Python threading, you have to call this with true early in your main thread, before you launch any threads in Python. It can be called before or after PythonQt::init().

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(). 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 importInterface. Passing NULL will install a default QFile importer. (importInterface ownership stays with caller)

References importInterface().

Referenced by installDefaultImporter().

set paths that the importer should ignore

sets the path list of a module to the given list (important for local imports)

sets a callback that is called before and after function calls for profiling

set a callback that is called when a QObject does not have a specific attribute.

set a callback that is called when a QObject with parent == NULL is no longer wrapped by PythonQt

set a callback that is called when a QObject with parent == NULL is wrapped by PythonQt

Overwrite default handling of stdin using a custom callback. It internally backup the original 'sys.stdin' into 'sys.pythonqt_original_stdin'

Enable or disable stdin custom callback. It resets 'sys.stdin' using either 'sys.pythonqt_stdin' or 'sys.pythonqt_original_stdin'

enable or disable std out/err redirection to pythonStdOut() and pythonStdErr() signals.

if set to true, the systemExitExceptionRaised signal will be emitted if exception SystemExit is caught

See also

handleError()

return true if SystemExit exception is handled by PythonQt

See also

setSystemExitExceptionHandlerEnabled()

emitted when both custom SystemExit exception handler is enabled and a SystemExit exception is raised.

See also

setSystemExitExceptionHandlerEnabled(bool)