World Time Clock Plugin Example▲
In this example, we simply extend the Custom Widget Plugin example and its custom widget (based on the Analog Clock example), by introducing the concept of signals and slots.
The World Time Clock Plugin example consists of two classes:
-
WorldTimeClock is a custom clock widget with hour and minute hands that is automatically updated every few seconds.
-
WorldTimeClockPlugin exposes the WorldTimeClock class to Qt Designer.
First we will take a look at the WorldTimeClock class which extends the Custom Widget Plugin example's AnalogClock class by providing a signal and a slot. Then we will take a quick look at the WorldTimeClockPlugin class, but this class is in most parts identical to the Custom Widget Plugin example's implementation.
Finally we take a look at the plugin's project file. The project file for custom widget plugins needs some additional information to ensure that they will work within Qt Designer. This is also covered in the Custom Widget Plugin example, but due to its importance (custom widget plugins rely on components supplied with Qt Designer which must be specified in the project file that we use) we will repeat it here.
WorldTimeClock Class▲
The WorldTimeClock class inherits QWidget, and is a custom clock widget with hour and minute hands that is automatically updated every few seconds. What makes this example different from the Custom Widget Plugin example, is the introduction of the signal and slot in the custom widget class:
class QDESIGNER_WIDGET_EXPORT WorldTimeClock : public QWidget
{
Q_OBJECT
public:
explicit WorldTimeClock(QWidget *parent = nullptr);
public slots:
void setTimeZone(int hourOffset);
signals:
void updated(QTime currentTime);
protected:
void paintEvent(QPaintEvent *event) override;
private:
int timeZoneOffset = 0;
};Note the use of the QDESIGNER_WIDGET_EXPORT macro. This is needed to ensure that Qt Designer can create instances of the widget on some platforms, but it is a good idea to use it on all platforms.
We declare the setTimeZone() slot with an associated timeZoneOffset variable, and we declare an updated() signal which takes the current time as argument and is emitted whenever the widget is repainted.
In Qt Designer's workspace we can then, for example, connect the WorldTimeClock widget's updated() signal to a QTimeEdit's setTime() slot using Qt Designer's mode for editing signal and slots.
We can also connect a QSpinBox's valueChanged() signal to the WorldTimeClock's setTimeZone() slot.
WorldTimeClockPlugin Class▲
The WorldTimeClockPlugin class exposes the WorldTimeClock class to Qt Designer. Its definition is equivalent to the Custom Widget Plugin example's plugin class which is explained in detail. The only part of the class definition that is specific to this particular custom widget is the class name.
To ensure that Qt recognizes the widget as a plugin, export relevant information about the widget by adding the Q_PLUGIN_METADATA() macro:
class WorldTimeClockPlugin : public QObject,
public QDesignerCustomWidgetInterface
{
Q_OBJECT
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidgetInterface")
Q_INTERFACES(QDesignerCustomWidgetInterface)
public:
explicit WorldTimeClockPlugin(QObject *parent = nullptr);
bool isContainer() const override;
bool isInitialized() const override;
QIcon icon() const override;
QString domXml() const override;
QString group() const override;
QString includeFile() const override;
QString name() const override;
QString toolTip() const override;
QString whatsThis() const override;
QWidget *createWidget(QWidget *parent) override;
void initialize(QDesignerFormEditorInterface *core) override;
private:
bool initialized = false;
};The plugin class provides Qt Designer with basic information about our plugin, such as its class name and its include file. Furthermore it knows how to create instances of the WorldTimeClockPlugin widget. WorldTimeClockPlugin also defines the initialize() function which is called after the plugin is loaded into Qt Designer. The function's QDesignerFormEditorInterface parameter provides the plugin with a gateway to all of Qt Designer's API's.
The WorldTimeClockPlugin class inherits from both QObject and QDesignerCustomWidgetInterface. It is important to remember, when using multiple inheritance, to ensure that all the interfaces (i.e. the classes that doesn't inherit Q_OBJECT) are made known to the meta object system using the Q_INTERFACES() macro. This enables Qt Designer to use qobject_cast() to query for supported interfaces using nothing but a QObject pointer.
The implementation of the WorldTimeClockPlugin is also equivalent to the plugin interface implementation in the Custom Widget Plugin example (only the class name and the implementation of QDesignerCustomWidgetInterface::domXml() differ). The main thing to remember is to use the Q_PLUGIN_METADATA() macro to export the WorldTimeClockPlugin class for use with Qt Designer:
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidgetInterface")Without this macro, there is no way for Qt Designer to use the widget.
Project files▲
CMake▲
The project files need to state that a plugin linking to the Qt Designer libraries is to be built:
find_package(Qt6 REQUIRED COMPONENTS Core Gui UiPlugin Widgets)
qt_add_plugin(worldtimeclockplugin)
target_link_libraries(worldtimeclockplugin PUBLIC
Qt::Core
Qt::Gui
Qt::UiPlugin
Qt::Widgets
)The link libraries list specifies Qt::UiPlugin. This indicates that the plugin uses the abstract interfaces QDesignerCustomWidgetInterface and QDesignerCustomWidgetCollectionInterface only and has no linkage to the Qt Designer libraries. When accessing other interfaces of Qt Designer that have linkage, Designer should be used instead; this ensures that the plugin dynamically links to the Qt Designer libraries and has a run-time dependency on them.
The header and source files for the widget are declared in the usual way:
target_sources(worldtimeclockplugin PRIVATE
worldtimeclock.cpp worldtimeclock.h
worldtimeclockplugin.cpp worldtimeclockplugin.h
)We provide an implementation of the plugin interface so that Qt Designer can use the custom widget. In this particular example we also provide implementations of the container extension interface and the extension factory.
It is 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:
set(INSTALL_EXAMPLEDIR "${QT6_INSTALL_PREFIX}/${QT6_INSTALL_PLUGINS}/designer")
install(TARGETS worldtimeclockplugin
RUNTIME DESTINATION "${INSTALL_EXAMPLEDIR}"
BUNDLE DESTINATION "${INSTALL_EXAMPLEDIR}"
LIBRARY DESTINATION "${INSTALL_EXAMPLEDIR}"
)The custom widget is created as a library. It will be installed alongside the other Qt Designer plugins when the project is installed (using ninja install or an equivalent installation procedure).
For more information about plugins, see the How to Create Qt Plugins documentation.
qmake▲
The following example shows how to link a plugin to the Qt Designer libraries:
TEMPLATE = lib
CONFIG += plugin
QT += widgets uipluginThe QT variable contains the keyword uiplugin, which is the equivalent of the Qt::UiPlugin library.
The following example shows how to add the header and source files of the widget:
HEADERS = worldtimeclock.h \
worldtimeclockplugin.h
SOURCES = worldtimeclock.cpp \
worldtimeclockplugin.cppThe following example shows how to install a plugin to the Qt Designer's plugin path:
target.path = $$[QT_INSTALL_PLUGINS]/designer
INSTALLS += target