Custom Widget Plugin Example

AnalogClockPlugin Implementation

The class constructor simply calls the QObject base class constructor and sets the initialized variable to false.

 AnalogClockPlugin::AnalogClockPlugin(QObject *parent)
     : QObject(parent)
 {
     initialized = false;
 }

Qt Designer will initialize the plugin when it is required by calling the initialize() function:

 void AnalogClockPlugin::initialize(QDesignerFormEditorInterface * /* core */)
 {
     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.

The isInitialized() function lets Qt Designer know whether the plugin is ready for use:

 bool AnalogClockPlugin::isInitialized() const
 {
     return initialized;
 }

Instances of the custom widget are supplied by the createWidget() function. The implementation for the analog clock is straightforward:

 QWidget *AnalogClockPlugin::createWidget(QWidget *parent)
 {
     return new 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:

 QString AnalogClockPlugin::name() const
 {
     return "AnalogClock";
 }

The group() function is used to describe the type of widget that the custom widget belongs to:

 QString AnalogClockPlugin::group() const
 {
     return "Display Widgets [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 icon() function:

 QIcon AnalogClockPlugin::icon() const
 {
     return 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:

 QString AnalogClockPlugin::toolTip() const
 {
     return "";
 }

The whatsThis() function can return a longer description:

 QString AnalogClockPlugin::whatsThis() const
 {
     return "";
 }

The 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.

 bool AnalogClockPlugin::isContainer() const
 {
     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.

The 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:

 QString AnalogClockPlugin::domXml() const
 {
     return "<widget class=\"AnalogClock\" name=\"analogClock\">\n"
            " <property name=\"geometry\">\n"
            "  <rect>\n"
            "   <x>0</x>\n"
            "   <y>0</y>\n"
            "   <width>100</width>\n"
            "   <height>100</height>\n"
            "  </rect>\n"
            " </property>\n"
            " <property name=\"toolTip\" >\n"
            "  <string>The current time</string>\n"
            " </property>\n"
            " <property name=\"whatsThis\" >\n"
            "  <string>The analog clock widget displays "
            "the current time.</string>\n"
            " </property>\n"
            "</widget>\n";
 }

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:

 QString AnalogClockPlugin::includeFile() const
 {
     return "analogclock.h";
 }

Finally, we use the Q_EXPORT_PLUGIN2() macro to export the AnalogClockPlugin class for use with Qt Designer:

 Q_EXPORT_PLUGIN2(customwidgetplugin, AnalogClockPlugin)

This macro ensures that Qt Designer can access and construct the custom widget. Without this macro, there is no way for Qt Designer to use the widget.

It is important to note that you can only use the Q_EXPORT_PLUGIN2() macro once in any implementation. If you have several custom widgets in an implementation that you wish to make available to Qt Designer, you will need to implement QDesignerCustomWidgetCollectionInterface.