Task Menu Extension Example

TicTacToePlugin Class Implementation

The TicTacToePlugin class implementation is in most parts equivalent to the Custom Widget Plugin example's plugin class:

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

    QString TicTacToePlugin::name() const
    {
        return QString("TicTacToe");
    }

    QString TicTacToePlugin::group() const
    {
        return QString("Display Widgets [Examples]");
    }

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

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

    QString TicTacToePlugin::includeFile() const
    {
        return QString("tictactoe.h");
    }

    QIcon TicTacToePlugin::icon() const
    {
        return QIcon();
    }

    bool TicTacToePlugin::isContainer() const
    {
        return false;
    }

    QWidget *TicTacToePlugin::createWidget(QWidget *parent)
    {
        TicTacToe *ticTacToe = new TicTacToe(parent);
        ticTacToe->setState("-X-XO----");
        return ticTacToe;
    }

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

The only function that differs significantly is the initialize() function:

    void TicTacToePlugin::initialize(QDesignerFormEditorInterface *formEditor)
    {

The initialize() function takes a QDesignerFormEditorInterface object as argument. The QDesignerFormEditorInterface class provides access to Qt Designer's components.

In Qt Designer you can create two kinds of plugins: custom widget plugins and tool plugins. QDesignerFormEditorInterface provides access to all the Qt Designer components that you normally need to create a tool plugin: the extension manager, the object inspector, the property editor and the widget box. Custom widget plugins have access to the same components.

        if (initialized)
            return;

        QExtensionManager *manager = formEditor->extensionManager();
        Q_ASSERT(manager != 0);

When creating extensions associated with custom widget plugins, we need to access Qt Designer's current extension manager which we retrieve from the QDesignerFormEditorInterface parameter.

Qt Designer's QDesignerFormEditorInterface holds information about all Qt Designer's components: The action editor, the object inspector, the property editor, the widget box, and the extension and form window managers.

The QExtensionManager class provides extension management facilities for Qt Designer. Using Qt Designer's current extension manager you can retrieve the extension for a given object. You can also register and unregister an extension for a given object. Remember that an extension is an object which modifies the behavior of Qt Designer.

When registrering an extension, it is actually the associated extension factory that is registered. In Qt Designer, extension factories are used to look up and create named extensions as they are required. So, in this example, the task menu extension itself is not created until a task menu is requested by the user.

        manager->registerExtensions(new TicTacToeTaskMenuFactory(manager),
                                    Q_TYPEID(QDesignerTaskMenuExtension));

        initialized = true;
    }

We create a TicTacToeTaskMenuFactory object that we register using Qt Designer's current extension manager retrieved from the QDesignerFormEditorInterface parameter. The first argument is the newly created factory and the second argument is an extension identifier which is a string. The Q_TYPEID() macro simply convert the string into a QLatin1String.

The TicTacToeTaskMenuFactory class is a subclass of QExtensionFactory. When the user request a task menu by clicking the right mouse button over a widget with the specified task menu extension, Qt Designer's extension manager will run through all its registered factories invoking the first one that is able to create a task menu extension for the selected widget. This factory will in turn create a TicTacToeTaskMenu object (the extension).

We omit to reimplement the QDesignerCustomWidgetInterface::domXml() function (which include default settings for the widget in the standard XML format used by Qt Designer), since no default values are necessary.

    Q_EXPORT_PLUGIN2(taskmenuextension, TicTacToePlugin)

Finally, we use the Q_EXPORT_PLUGIN2() macro to export the TicTacToePlugin class for use with Qt's plugin handling classes: 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.

TicTacToeTaskMenuFactory Class Definition

The TicTacToeTaskMenuFactory class inherits QExtensionFactory which provides a standard extension factory for Qt Designer.

    class TicTacToeTaskMenuFactory: public QExtensionFactory
    {
        Q_OBJECT
    public:
        TicTacToeTaskMenuFactory(QExtensionManager *parent = 0);

    protected:
        QObject *createExtension(QObject *object, const QString &iid, QObject *parent) const;
    };

The subclass's purpose is to reimplement the QExtensionFactory::createExtension() function, making it able to create a TicTacToe task menu extension.

TicTacToeTaskMenuFactory Class Implementation

The class constructor simply calls the QExtensionFactory base class constructor:

    TicTacToeTaskMenuFactory::TicTacToeTaskMenuFactory(QExtensionManager *parent)
        : QExtensionFactory(parent)
    {}

As described above, the factory is invoked when the user request a task menu by clicking the right mouse button over a widget with the specified task menu extension in Qt Designer.

    QObject *TicTacToeTaskMenuFactory::createExtension(QObject *object,
                                                       const QString &iid,
                                                       QObject *parent) const
    {
        if (iid != Q_TYPEID(QDesignerTaskMenuExtension))
            return 0;

        if (TicTacToe *tic = qobject_cast<TicTacToe*>(object))
            return new TicTacToeTaskMenu(tic, parent);

        return 0;
    }

Qt Designer's behavior is the same whether the requested extension is associated with a container, a member sheet, a property sheet or a task menu: Its extension manager runs through all its registered extension factories calling createExtension() for each until one responds by creating the requested extension.

So the first thing we do in TicTacToeTaskMenuFactory::createExtension() is to check if the requested extension is a task menu extension. If it is, and the widget requesting it is a TicTacToe widget, we create and return a TicTacToeTaskMenu object. Otherwise, we simply return a null pointer, allowing Qt Designer's extension manager to continue its search through the registered factories.

TicTacToeTaskMenu Class Definition

The TicTacToeTaskMenu class inherits QDesignerTaskMenuExtension which allows you to add custom entries (in the form of QActions) to the task menu in Qt Designer.

    class TicTacToeTaskMenu: public QObject, public QDesignerTaskMenuExtension
    {
        Q_OBJECT
        Q_INTERFACES(QDesignerTaskMenuExtension)
    public:
        TicTacToeTaskMenu(TicTacToe *tic, QObject *parent);

        QAction *preferredEditAction() const;
        QList<QAction *> taskActions() const;

    private slots:
        void editState();

    private:
        QAction *editStateAction;
        TicTacToe *ticTacToe;
    };

We reimplement the preferredEditAction() and taskActions() functions. Note that we implement a constructor that takes two arguments: the parent widget, and the TicTacToe widget for which the task menu is requested.

In addition we declare the private editState() slot, our custom editStateAction and a private pointer to the TicTacToe widget which state we want to modify.

TicTacToeTaskMenu Class Implementation

    TicTacToeTaskMenu::TicTacToeTaskMenu(TicTacToe *tic, QObject *parent)
        : QObject(parent)
    {
        ticTacToe = tic;

        editStateAction = new QAction(tr("Edit State..."), this);
        connect(editStateAction, SIGNAL(triggered()), this, SLOT(editState()));
    }

In the constructor we first save the reference to the TicTacToe widget sent as parameter, i.e the widget which state we want to modify. We will need this later when our custom action is invoked. We also create our custom editStateAction and connect it to the editState() slot.

    void TicTacToeTaskMenu::editState()
    {
        TicTacToeDialog dialog(ticTacToe);
        dialog.exec();
    }

The editState() slot is called whenever the user chooses the Edit State... option in a TicTacToe widget's task menu. The slot creates a TicTacToeDialog presenting the current state of the widget, and allowing the user to edit its state by playing the game.

    QAction *TicTacToeTaskMenu::preferredEditAction() const
    {
        return editStateAction;
    }

We reimplement the preferredEditAction() function to return our custom editStateAction as the action that should be invoked when selecting a TicTacToe widget and pressing F2 .

    QList<QAction *> TicTacToeTaskMenu::taskActions() const
    {
        QList<QAction *> list;
        list.append(editStateAction);
        return list;
    }

We reimplement the taskActions() function to return a list of our custom actions making these appear on top of the default menu entries in a TicTacToe widget's task menu.

TicTacToeDialog Class Definition

The TicTacToeDialog class inherits QDialog. The dialog lets the user modify the state of the currently selected Tic-Tac-Toe plugin.

    class TicTacToeDialog : public QDialog
    {
        Q_OBJECT

    public:
        TicTacToeDialog(TicTacToe *plugin = 0, QWidget *parent = 0);
        QSize sizeHint() const;

    private slots:
        void resetState();
        void saveState();

    private:
        TicTacToe *editor;
        TicTacToe *ticTacToe;

        QPushButton *cancelButton;
        QPushButton *okButton;
        QPushButton *resetButton;

        QHBoxLayout *buttonLayout;
        QVBoxLayout *mainLayout;
    };

We reimplement the sizeHint() function. We also declare two private slots: resetState() and saveState(). In addition to the dialog's buttons and layouts we declare two TicTacToe pointers, one to the widget the user can interact with and the other to the original custom widget plugin which state the user wants to edit.

TicTacToeDialog Class Implementation

    TicTacToeDialog::TicTacToeDialog(TicTacToe *tic, QWidget *parent)
        : QDialog(parent)
    {
        ticTacToe = tic;
        editor = new TicTacToe;
        editor->setState(ticTacToe->state());

        cancelButton = new QPushButton(tr("Cancel"));
        connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject()));

        okButton = new QPushButton(tr("OK"));
        connect(okButton, SIGNAL(clicked()), this, SLOT(saveState()));

        resetButton = new QPushButton(tr("Reset"));
        connect(resetButton, SIGNAL(clicked()), this, SLOT(resetState()));

        buttonLayout = new QHBoxLayout;
        buttonLayout->addWidget(resetButton);
        buttonLayout->addStretch();
        buttonLayout->addWidget(okButton);
        buttonLayout->addWidget(cancelButton);

        mainLayout = new QVBoxLayout;
        mainLayout->addWidget(editor);
        mainLayout->addLayout(buttonLayout);

        setLayout(mainLayout);
        setWindowTitle(tr("Edit State"));
    }

In the constructor we first save the reference to the TicTacToe widget sent as parameter, i.e the widget which state the user want to modify. Then we create a new TicTacToe widget, and set its state to be equivalent to the parameter widget's state.

Finally, we create the dialog's buttons and layout.

    QSize TicTacToeDialog::sizeHint() const
    {
        return QSize(250, 250);
    }

We reimplement the sizeHint() function to ensure that the dialog is given a reasonable size.

    void TicTacToeDialog::resetState()
    {
        editor->clearBoard();
    }

The resetState() slot is called whenever the user press the Reset button. The only thing we do is to call the clearBoard() function for the editor widget, i.e. the TicTacToe widget we created in the dialog's constructor.

    void TicTacToeDialog::saveState()
    {

The saveState() slot is called whenever the user press the OK button, and transfers the state of the editor widget to the widget which state we want to modify. In order to make the change of state visible to Qt Designer we need to set the latter widget's state property using the QDesignerFormWindowInterface class.

QDesignerFormWindowInterface provides you with information about the associated form window as well as allowing you to alter its properties. The interface is not intended to be instantiated directly, but to provide access to Qt Designer's current form windows controlled by Qt Designer's form window manager.

If you are looking for the form window containing a specific widget, you can use the static QDesignerFormWindowInterface::findFormWindow() function:

        if (QDesignerFormWindowInterface *formWindow
                = QDesignerFormWindowInterface::findFormWindow(ticTacToe)) {
            formWindow->cursor()->setProperty("state", editor->state());
        }

After retrieving the form window of the widget (which state we want to modify), we use the QDesignerFormWindowInterface::cursor() function to retrieve the form window's cursor.

The QDesignerFormWindowCursorInterface class provides an interface to the form window's text cursor. Once we have cursor, we can finally set the state property using the QDesignerFormWindowCursorInterface::setProperty() function.

        accept();
    }

In the end we call the QEvent::accept() function which sets the accept flag of the event object. Setting the accept parameter indicates that the event receiver wants the event. Unwanted events might be propagated to the parent widget.

TicTacToe Class Definition

The TicTacToe class is a custom widget that lets the user play the Tic-Tac-Toe game.

    class TicTacToe : public QWidget
    {
        Q_OBJECT
        Q_PROPERTY(QString state READ state WRITE setState)
    public:
        TicTacToe(QWidget *parent = 0);

        QSize minimumSizeHint() const;
        QSize sizeHint() const;
        void setState(const QString &newState);
        QString state() const;
        void clearBoard();

    protected:
        void mousePressEvent(QMouseEvent *event);
        void paintEvent(QPaintEvent *event);

    private:
        enum {Empty = '-', Cross = 'X', Nought = 'O' };

        QRect cellRect(int row, int col) const;
        int cellWidth() const {return width()/ 3;}
        int cellHeight() const {return height()/ 3;}

        QString myState;
        int turnNumber;
    };

The main details to observe in the TicTacToe class defintion is the declaration of the state property and its state() and setState() functions.

We need to declare the TicTacToe widget's state as a property to make it visible to Qt Designer; allowing Qt Designer to manage it in the same way it manages the properties the TicTacToe widget inherits from QWidget and QObject, for example featuring the property editor.