The main interface to PythonQt is the PythonQt singleton. PythonQt needs to be initialized via PythonQt::init() once. Afterwards you communicate with the singleton via PythonQt::self(). PythonQt offers a complete Qt binding, which needs to be enabled via PythonQt_QtAll::init().
Datatype MappingThe following table shows the mapping between Python and Qt objects:
Qt/C++ Python bool bool double float float float char/uchar,int/uint,short,ushort,QChar integer long integer ulong,longlong,ulonglong long QString (1) unicode string QByteArray (2) QByteArray wrapper (3) char* str QStringList tuple of unicode strings QVariantList tuple of objects QVariantMap dict of objects QVariant depends on type (4) QSize, QRect and all other standard Qt QVariants variant wrapper that supports complete API of the respective Qt classes OwnRegisteredMetaType C++ wrapper, optionally with additional information/wrapping provided by registerCPPClass() QList<AnyObject*> converts to a list of CPP wrappers QVector<AnyObject*> converts to a list of CPP wrappers EnumType Enum wrapper derived from python integer QObject (and derived classes) QObject wrapper C++ object CPP wrapper, either wrapped via PythonQtCppWrapperFactory or just decorated with decorators PyObject PyObject (5)All Qt QVariant types are implemented, PythonQt supports the complete Qt API for these objects.
QObject WrappingAll classes derived from QObject are automatically wrapped with a python wrapper class when they become visible to the Python interpreter. This can happen via
It is important that you call PythonQt::registerClass() for any QObject derived class that may become visible to Python, except when you add it via PythonQt::addObject(). This will register the complete parent hierachy of the registered class, so that when you register e.g. a QPushButton, QWidget will be registered as well (and all intermediate parents).
From Python, you can talk to the returned QObjects in a natural way by calling their slots and receiving the return values. You can also read/write all properties of the objects as if they where normal python properties.
In addition to this, the wrapped objects support
The below example shows how to connect signals in Python:
# define a signal handler function
PyObject * PythonQtConvertPairToPython(const void *inPair, int metaTypeId)
And this example shows how you can define your own signals and slots:
print(
f"progress: {value}")
sender.connect(
"emitProgress(double)",
receiver,
"progress(double)")
CPP WrappingYou can create dedicated wrapper QObjects for any C++ class. This is done by deriving from PythonQtCppWrapperFactory and adding your factory via addWrapperFactory(). Whenever PythonQt encounters a CPP pointer (e.g. on a slot or signal) and it does not known it as a QObject derived class, it will create a generic CPP wrapper. So even unknown C++ objects can be passed through Python. If the wrapper factory supports the CPP class, a QObject wrapper will be created for each instance that enters Python. An alternative to a complete wrapper via the wrapper factory are decorators, see Decorator slots
Meta Object/Class accessFor each known C++ class, PythonQt provides a Python class. These classes are visible inside of the "PythonQt" python module or in subpackages if a package is given when the class is registered.
A Meta class supports:
From within Python, you can import the module "PythonQt" to access these classes and the Qt namespace.
# namespace access:
print QtCore.Qt.AlignLeft
# constructors
a = QtCore.QSize(12,13)
b = QtCore.QFont()
# static method
QtCore.QDate.currentDate()
# enum value
QtCore.QFont.UltraCondensed
# or, alternatively
QtCore.QFont.Stretch.UltraCondensed
The main interface to the Python Qt binding, realized as a singleton.
Decorator slotsPythonQt introduces a new generic approach to extend any wrapped QObject or CPP object with
The idea behind decorators is that we wanted to make it as easy as possible to extend wrapped objects. Since we already have an implementation for invoking any Qt Slot from Python, it looked promising to use this approach for the extension of wrapped objects as well. This avoids that the PythonQt user needs to care about how Python arguments are mapped from/to Qt when he wants to create static methods, constructors and additional member functions.
The basic idea about decorators is to create a QObject derived class that implements slots which take one of the above roles (e.g. constructor, destructor etc.) via a naming convention. These slots are then assigned to other classes via the naming convention.
The below example shows all kinds of decorators in action:
public:
private:
};
{
};
...
void registerCPPClass(const char *typeName, const char *parentTypeName=nullptr, const char *package=nullptr, PythonQtQObjectCreatorFunctionCB *wrapperCreator=nullptr, PythonQtShellSetInstanceWrapperCB *shell=nullptr)
static PythonQt * self()
get the singleton instance
After you have registered an instance of the above ExampleDecorator, you can do the following from Python (all these calls are mapped to the above decorator slots):
# call our new constructor of QSize
size = QtCore.QSize(QPoint(1,2));
# call our new QPushButton constructor
# call the move slot (overload1)
# call the move slot (overload2)
# call the static method
# create a CPP object via constructor
# call the wrapped method on CPP object
# destructor will be called:
Ownership managementIn PythonQt, each wrapped C++ object is either owned by Python or C++. When an object is created via a Python constructor, it is owned by Python by default. When an object is returned from a C++ API (e.g. a slot), it is owned by C++ by default. Since the Qt API contains various APIs that pass the ownership from/to other C++ objects, PythonQt needs to keep track of such API calls. This is archieved by annotating arguments and return values in wrapper slots with magic templates:
These annotation templates work for since C++ pointer types. In addition to that, they work for QList<AnyObject*>, to pass the ownership for each object in the list.
Examples:
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4