| Qt/C++ | Python |
|---|
| bool | bool |
| double | float |
| float | float |
| char/uchar,int/uint,short,ushort,QChar | integer |
| long | integer |
| ulong,longlong,ulonglong | long |
| QString | unicode string |
| QByteArray | str |
| char* | str |
| QStringList | tuple of unicode strings |
| QVariantList | tuple of objects |
| QVariantMap | dict of objects |
| QVariant | depends on type, see below |
| QSize, QRect and all other standard Qt QVariants | variant wrapper that supports complete API of the respective Qt classes |
| OwnRegisteredMetaType | variant wrapper, optionally with a wrapper provided by addVariantWrapper() |
| EnumType | integer (all enums that are known via the moc and the Qt namespace are supported) |
| QObject (and derived classes) | QObject wrapper |
| C++ object | CPP wrapper, either wrapped via PythonQtCppWrapperFactory or just decorated with decorators |
| PyObject | PyObject |
PyObject is passed as simple pointer, which allows to pass/return any Python Object directly to/from
a Qt slot.
QVariants are mapped recursively as given above, e.g. a dictionary can
contain lists of dictionaries of doubles.
For example a QVariant of type "String" is mapped to a python unicode string.
All Qt QVariant types are implemented, PythonQt supports the complete Qt API for these object.
\section QObject QObject Wrapping
All classes derived from QObject are automatically wrapped with a python wrapper class
when they become visible to the Python interpreter. This can happen via
- the PythonQt::addObject() method
- when a Qt \b slot returns a QObject derived object to python
- when a Qt \b signal contains a QObject and is connected to a python function
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
- className() - returns a string that reprents the classname of the QObject
- help() - shows all properties, slots, enums, decorator slots and constructors of the object, in a printable form
- connect(signal, function) - connect the signal of the given object to a python function
- connect(signal, qobject, slot) - connect the signal of the given object to a slot of another QObject
- disconnect(signal, function) - disconnect the signal of the given object from a python function
- disconnect(signal, qobject, slot) - disconnect the signal of the given object from a slot of another QObject
- children() - returns the children of the object
- setParent(QObject) - set the parent
- QObject* parent() - get the parent
The below example shows how to connect signals in Python:
\code
# define a signal handler function
def someFunction(flag):
print flag
# button1 is a QPushButton that has been added to Python via addObject()
# connect the clicked signal to a python function:
button1.connect("clicked(bool)", someFunction)
\endcode
\section CPP CPP Wrapping
You can create dedicated wrapper QObject 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 \ref Decorators
\section MetaObject Meta Object/Class access
For each known CPP class, QObject derived class and QVariant type, PythonQt provides a Meta class. These meta classes are visible
inside of the "PythonQt" python module.
A Meta class supports:
- access to all declared enum values
- constructors
- static decorator slots
- help() and className()
From within Python, you can import the module "PythonQt" to access these meta objects and the Qt namespace.
\code
from PythonQt import *
# namespace access:
print Qt.AlignLeft
# constructors
a = QSize(12,13)
b = QFont()
# static method
QDate.currentDate()
# enum value
QFont.UltraCondensed
\endcode
\section Decorators Decorator slots
PythonQt introduces a new generic approach to extend any wrapped QObject or CPP object with
- constructors
- destructors (for CPP objects)
- additional slots
- static slots (callable on both the Meta object and the instances)
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.
- QVariant new_SomeClassName(...) - defines a constructor for "SomeClassName" that returns a QVariant
- SomeClassName* new_SomeClassName(...) - defines a constructor for "SomeClassName" that returns a new object of type SomeClassName (where SomeClassName can be any CPP class, not just QObject classes)
- void delete_SomeClassName(SomeClassName* o) - defines a destructor, which should delete the passed in object o
- anything static_SomeClassName_someMethodName(...) - defines a static method that is callable on instances and the meta class
- anything someMethodName(SomeClassName* o, ...) - defines a slot that will be available on SomeClassName instances (and derived instances). When such a slot is called the first argument is the pointer to the instance and the rest of the arguments can be used to make a call on the instance.
The below example shows all kinds of decorators in action:
\code
// an example CPP object
class YourCPPObject {
public:
YourCPPObject(int arg1, float arg2) { a = arg1; b = arg2; }
float doSomething(int arg1) { return arg1*a*b; };
private:
int a;
float b;
};
// an example decorator
class ExampleDecorator : public QObject
{
Q_OBJECT
public slots:
// add a constructor to QSize variant that takes a QPoint
QVariant new_QSize(const QPoint& p) { return QSize(p.x(), p.y()); }
// add a constructor for QPushButton that takes a text and a parent widget
QPushButton* new_QPushButton(const QString& text, QWidget* parent=NULL) { return new QPushButton(text, parent); }
// add a constructor for a CPP object
YourCPPObject* new_YourCPPObject(int arg1, float arg2) { return new YourCPPObject(arg1, arg2); }
// add a destructor for a CPP object
void delete_YourCPPObject(YourCPPObject* obj) { delete obj; }
// add a static method to QWidget
QWidget* static_QWidget_mouseGrabber() { return QWidget::mouseGrabber(); }
// add an additional slot to QWidget (make move() callable, which is not declared as a slot in QWidget)
void move(QWidget* w, const QPoint& p) { w->move(p); }
// add an additional slot to QWidget, overloading the above move method
void move(QWidget* w, int x, int y) { w->move(x,y); }
// add a method to your own CPP object
int doSomething(YourCPPObject* obj, int arg1) { return obj->doSomething(arg1); }
};
...
PythonQt::self()->addDecorators(new ExampleDecorator());
PythonQt::self()->registerClass(&QPushButton::staticMetaObject);
PythonQt::self()->registerCPPClassNames(QStringList() << "YourCPPObject");
\endcode
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):
\code
from PythonQt import *
# call our new constructor of QSize
size = QSize(QPoint(1,2));
# call our new QPushButton constructor
button = QPushButton("sometext");
# call the move slot (overload1)
button.move(QPoint(0,0))
# call the move slot (overload2)
button.move(0,0)
# call the static method
grabber = QWidget.mouseWrapper();
# create a CPP object via constructor
yourCpp = YourCPPObject(1,11.5)
# call the wrapped method on CPP object
print yourCpp.doSomething(1);
# destructor will be called:
yourCpp = None
\endcode
\section Building
PythonQt requires at least Qt 4.2.2 (or higher) and Python 2.3, 2.4 or 2.5 on Windows, Linux and MacOS X.
To compile PythonQt, you will need a python developer installation which includes Python's header files and
the python2x.[lib | dll | so | dynlib].
The build scripts a currently set to use Python 2.5.
You may need to tweak the \b build/python.prf file to set the correct Python includes and libs on your system.
\subsection Windows
On Windows, the (non-source) Python Windows installer can be used.
Make sure that you use the same compiler, the current Python distribution is built
with Visual Studio 2003. If you want to use another compiler, you will need to build
Python yourself, using your compiler.
To build PythonQt, you need to set the environment variable \b PYTHON_PATH to point to the root
dir of the python installation and \b PYTHON_LIB to point to
the directory where the python lib file is located.
When using the prebuild Python installer, this will be:
\code
> set PYTHON_PATH = c:\Python25
> set PYTHON_LIB = c:\Python25\libs
\endcode
When using the python sources, this will be something like:
\code
> set PYTHON_PATH = c:\yourDir\Python-2.5.1\
> set PYTHON_LIB = c:\yourDir\Python-2.5.1\PCbuild8\Win32
\endcode
To build all, do the following (after setting the above variables):
\code
> cd PythonQtRoot
> vcvars32
> qmake
> nmake
\endcode
This should build everything. If Python can not be linked or include files can not be found,
you probably need to tweak \b build/python.prf
The tests and examples are located in PythonQt/lib.
\subsection Linux
On Linux, you need to install a Python-dev package.
If Python can not be linked or include files can not be found,
you probably need to tweak \b build/python.prf
To build PythonQt, just do a:
\code
> cd PythonQtRoot
> qmake
> make all
\endcode
The tests and examples are located in PythonQt/lib.
You should add PythonQt/lib to your LD_LIBRARY_PATH so that the runtime
linker can find the *.so files.
\subsection MacOsX
On Mac, Python is installed as a Framework, so you should not need to install it.
To build PythonQt, just do a:
\code
> cd PythonQtRoot
> qmake
> make all
\endcode
\section Tests
There is a unit test that tests most features of PythonQt, see the \b tests subdirectory for details.
\section Examples
Examples are available in the \b examples directory. The PyScriptingConsole implements a simple
interactive scripting console that shows how to script a simple application.
The following shows how to integrate PythonQt into you Qt application:
\code
#include "PythonQt.h"
#include