Custom Widget Plugin Example#
Creating a custom widget plugin for Qt Designer.
In this example, the custom widget used is based on the Analog Clock example , and does not provide any custom signals or slots.
To provide a custom widget that can be used with Qt Designer, we need to supply a self-contained implementation and provide a plugin interface. In this example, we reuse the Analog Clock example for convenience.
Since custom widgets plugins rely on components supplied with Qt Designer, the project file that we use needs to contain information about Qt Designer's library components:
<Code snippet "customwidgetplugin/customwidgetplugin.pro:2" not found> <Code snippet "customwidgetplugin/customwidgetplugin.pro:0" not found>
TEMPLATE variable’s value makes
qmake create the custom widget as a library. Later, we will ensure that the widget will be recognized as a plugin by Qt by using the
Q_PLUGIN_METADATA() macro to export the relevant widget information.
CONFIG variable is set to
plugin, which ensures that
qmake considers the custom widget a plugin library.
QT variable contains the keyword
uiplugin. This plugin type provides a factory function for custom widget creation by implementing the abstract interfaces
QDesignerCustomWidgetCollectionInterface , suitable for use with
QUiLoader . It does not have a dependency on the Qt Designer libraries. Plugins accessing other interfaces of Qt Designer to implement container extensions or other Qt Designer specific functionality follow different rules and are covered by other examples.
The header and source files for the widget are declared in the usual way, and we provide an implementation of the plugin interface so that Qt Designer can use the custom widget:
<Code snippet "customwidgetplugin/customwidgetplugin.pro:3" not found>
It is also important to ensure that the plugin is installed in a location that is searched by Qt Designer. We do this by specifying a target path for the project and adding it to the list of items to install:
<Code snippet "doc/snippets/doc_src_examples_customwidgetplugin.pro:0" not found>
The custom widget is created as a library, and will be installed alongside the other Qt Designer plugins when the project is installed (using
make install or an equivalent installation procedure). Later, we will ensure that it is recognized as a plugin by Qt Designer by using the
Q_PLUGIN_METADATA() macro to export the relevant widget information.
Note that if you want the plugins to appear in a Visual Studio integration, the plugins must be built in release mode and their libraries must be copied into the plugin directory in the install path of the integration (for an example, see
C:/program files/trolltech as/visual studio integration/plugins).
For more information about plugins, see the How to Create Qt Plugins documentation.
AnalogClock Class Definition and Implementation#
AnalogClock class is defined and implemented in exactly the same way as described in the Analog Clock example . Since the class is self-contained, and does not require any external configuration, it can be used without modification as a custom widget in Qt Designer.
AnalogClockPlugin Class Definition#
AnalogClock class is exposed to Qt Designer through the
AnalogClockPlugin class. This class inherits from both
QObject and the
QDesignerCustomWidgetInterface class, and implements an interface defined by
class AnalogClockPlugin(QObject, QDesignerCustomWidgetInterface): Q_OBJECT Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidgetInterface") Q_INTERFACES(QDesignerCustomWidgetInterface) # public AnalogClockPlugin = explicit(QObject parent = None) isContainer = bool() isInitialized = bool() icon = QIcon() domXml = QString() group = QString() includeFile = QString() name = QString() toolTip = QString() whatsThis = QString() createWidget = QWidget(QWidget parent) def initialize(core): # private initialized = False()
The functions provide information about the widget that Qt Designer can use in the widget box . The
initialized private member variable is used to record whether the plugin has been initialized by Qt Designer.
Note that the only part of the class definition that is specific to this particular custom widget is the class name.
The class constructor simply calls the
QObject base class constructor and sets the
initialized variable to
def __init__(self, parent): QObject.__init__(self, parent)
Qt Designer will initialize the plugin when it is required by calling the
def initialize(self, */): if (initialized) return initialized = True
In this example, the
initialized private variable is tested, and only set to
true if the plugin is not already initialized. Although, this plugin does not require any special code to be executed when it is initialized, we could include such code after the test for initialization.
isInitialized() function lets Qt Designer know whether the plugin is ready for use:
def isInitialized(self): return initialized
Instances of the custom widget are supplied by the
createWidget() function. The implementation for the analog clock is straightforward:
AnalogClockPlugin::createWidget = QWidget(QWidget parent) def AnalogClock(parent):
In this case, the custom widget only requires a
parent to be specified. If other arguments need to be supplied to the widget, they can be introduced here.
The following functions provide information for Qt Designer to use to represent the widget in the widget box. The
name() function returns the name of class that provides the custom widget:
def name(self): def QStringLiteral("AnalogClock"):
group() function is used to describe the type of widget that the custom widget belongs to:
def group(self): def QStringLiteral([Examples]"):
The widget plugin will be placed in a section identified by its group name in Qt Designer's widget box. The icon used to represent the widget in the widget box is returned by the
def icon(self): def QIcon():
In this case, we return a null icon to indicate that we have no icon that can be used to represent the widget.
A tool tip and “What’s This?” help can be supplied for the custom widget’s entry in the widget box. The
toolTip() function should return a short message describing the widget:
def toolTip(self): def QString():
whatsThis() function can return a longer description:
def whatsThis(self): def QString():
isContainer() function tells Qt Designer whether the widget is supposed to be used as a container for other widgets. If not, Qt Designer will not allow the user to place widgets inside it.
def isContainer(self): return False
Most widgets in Qt can contain child widgets, but it only makes sense to use dedicated container widgets for this purpose in Qt Designer. By returning
false, we indicate that the custom widget cannot hold other widgets; if we returned true, Qt Designer would allow other widgets to be placed inside the analog clock and a layout to be defined.
domXml() function provides a way to include default settings for the widget in the standard XML format used by Qt Designer. In this case, we only specify the widget’s geometry:
def domXml(self): return QLatin1String(R"( <ui language="c++"> <widget class="AnalogClock" name="analogClock"> )" R"( <property name="geometry"> <rect> <x>0</x> <y>0</y> <width>100</width> <height>100</height> </rect> </property> ") R"( <property name="toolTip"> <string>The current time</string> </property> <property name="whatsThis"> <string>The analog clock widget displays the current time.</string> </property> </widget> </ui> )")
If the widget provides a reasonable size hint, it is not necessary to define it here. In addition, returning an empty string instead of a
<widget> element will tell Qt Designer not to install the widget in the widget box.
To make the analog clock widget usable by applications, we implement the
includeFile() function to return the name of the header file containing the custom widget class definition:
def includeFile(self): def QStringLiteral("analogclock.h"):