Extension du menu des tâches

L'exemple « Extension du menu des tâches » montre comment créer un plugin de widget personnalisé pour Qt Widgets Designer, et comment utiliser la classe ` QDesignerTaskMenuExtension ` pour fournir des entrées personnalisées du menu des tâches associées au plugin.

Qt Widgets Designer." src="images/taskmenuextension-example.webp" title="Capture d'écran d'une action personnalisée « Modifier l'état... » dans le menu contextuel de Qt Widgets Designer."/>

Pour proposer un widget personnalisé utilisable avec Qt Widgets Designer, il faut fournir une implémentation autonome. Dans cet exemple, nous utilisons un widget personnalisé conçu pour illustrer la fonctionnalité d’extension du menu des tâches : le widget TicTacToe.

Une extension est un objet qui modifie le comportement d’ Qt Widgets Designer. L’ QDesignerTaskMenuExtension peut proposer des entrées de menu de tâches personnalisées lorsqu’un widget doté de cette extension est sélectionné.

Il existe quatre types d’extensions disponibles dans l’ Qt Widgets Designer :

• QDesignerContainerExtension fournit une extension qui vous permet d’ajouter (et de supprimer) des pages à un plugin de conteneur multipages dans l’ Qt Widgets Designer.
• QDesignerMemberSheetExtension fournit une extension qui vous permet de manipuler les fonctions membres d’un widget, affichées lors de la configuration des connexions à l’aide du mode d’ Qt Widgets Designer dédié à l’édition des signaux et des slots.
• QDesignerPropertySheetExtension fournit une extension qui vous permet de manipuler les propriétés d’un widget affichées dans l’éditeur de propriétés d’ Qt Widgets Designer.
• QDesignerTaskMenuExtension fournit une extension qui vous permet d’ajouter des entrées de menu personnalisées au menu des tâches d’ Qt Widgets Designer.

Vous pouvez utiliser toutes les extensions en suivant le même modèle que dans cet exemple, en remplaçant simplement la classe de base de l'extension correspondante. Pour plus d'informations, consultez la section Qt Widgets Designer C++ Classes.

L'exemple d'extension du menu des tâches se compose de cinq classes :

• TicTacToe est un widget personnalisé qui permet à l’utilisateur de jouer au jeu Tic-Tac-Toe.
• TicTacToePlugin expose la classe ` TicTacToe ` à l'Qt Widgets Designer.
• TicTacToeTaskMenuFactory crée un objet « TicTacToeTaskMenu ».
• TicTacToeTaskMenu fournit l’extension du menu des tâches, c’est-à-dire les entrées du menu des tâches associées au plugin.
• TicTacToeDialog permet à l’utilisateur de modifier l’état d’un plugin Tic-Tac-Toe chargé dans l’ Qt Widgets Designer.

Le fichier de projet des plugins de widgets personnalisés nécessite des informations supplémentaires pour garantir leur bon fonctionnement au sein d’ Qt Widgets Designer. Par exemple, les plugins de widgets personnalisés s’appuient sur des composants fournis avec Qt Widgets Designer, ce qui doit être spécifié dans le fichier de projet que nous utilisons. Nous allons d’abord examiner le fichier de projet du plugin.

Nous poursuivrons ensuite par l’examen de la classe ` TicTacToePlugin `, puis nous nous intéresserons aux classes ` TicTacToeTaskMenuFactory ` et ` TicTacToeTaskMenu `. Enfin, nous examinerons la classe ` TicTacToeDialog ` avant de jeter un coup d’œil rapide à la définition de la classe du widget ` TicTacToe `.

Fichiers de projet

CMake

Les fichiers de projet doivent indiquer qu’un plugin s’associant aux bibliothèques du Designer d’ Qt Widgets doit être compilé :

find_package(Qt6 REQUIRED COMPONENTS Core Designer Gui Widgets)

qt_add_plugin(taskmenuextension)

target_link_libraries(taskmenuextension PUBLIC
    Qt::Core
    Qt::Designer
    Qt::Gui
    Qt::Widgets
)

L'exemple suivant montre comment ajouter les fichiers d'en-tête et les fichiers source du widget :

target_sources(taskmenuextension PRIVATE
    tictactoe.cpp tictactoe.h
    tictactoedialog.cpp tictactoedialog.h
    tictactoeplugin.cpp tictactoeplugin.h
    tictactoetaskmenu.cpp tictactoetaskmenu.h
)

Nous fournissons une implémentation de l’interface du plugin afin qu’ Qt Widgets Designer puisse utiliser le widget personnalisé. Dans cet exemple particulier, nous fournissons également des implémentations de l’extension du menu des tâches et de l’usine d’extensions, ainsi qu’une implémentation de boîte de dialogue.

Il est important de s’assurer que le plugin est installé dans un emplacement pris en compte par Qt Widgets Designer. Pour ce faire, nous spécifions un chemin cible pour le projet et l’ajoutons à la liste des éléments à installer :

   set(INSTALL_EXAMPLEDIR "${QT6_INSTALL_PREFIX}/${QT6_INSTALL_PLUGINS}/designer")
install(TARGETS taskmenuextension
    RUNTIME DESTINATION "${INSTALL_EXAMPLEDIR}"
    BUNDLE DESTINATION "${INSTALL_EXAMPLEDIR}"
    LIBRARY DESTINATION "${INSTALL_EXAMPLEDIR}"
)

L’extension du menu des tâches est créée sous forme de bibliothèque. Elle sera installée aux côtés des autres plugins d’ Qt Widgets Designer lors de l’installation du projet (à l’aide de ninja install ou d’une procédure d’installation équivalente).

Pour plus d’informations sur les plugins, consultez la documentation « Comment créer des plugins Qt ».

qmake

L'exemple suivant montre comment lier un plugin aux bibliothèques d'Qt Widgets Designer :

TEMPLATE = lib
CONFIG  += plugin

QT      += widgets designer

L'exemple suivant montre comment ajouter les fichiers d'en-tête et les fichiers source du widget :

HEADERS += tictactoe.h \
           tictactoedialog.h \
           tictactoeplugin.h \
           tictactoetaskmenu.h
SOURCES += tictactoe.cpp \
           tictactoedialog.cpp \
           tictactoeplugin.cpp \
           tictactoetaskmenu.cpp
OTHER_FILES += tictactoe.json

L'exemple suivant montre comment installer un plugin dans le chemin d'accès aux plugins de l'Qt Widgets Designer :

target.path = $$[QT_INSTALL_PLUGINS]/designer
INSTALLS += target

Définition de la classe TicTacToePlugin

La classe ` TicTacToePlugin ` expose la classe TicTacToe d'the à Qt Widgets Designer. Sa définition est équivalente à celle de la classe de plugin de l'exemple « Custom Widget Plugin », qui est expliquée en détail. La seule partie de la définition de la classe qui est spécifique à ce widget personnalisé particulier est le nom de la classe.

Pour que Qt reconnaisse le widget comme un plugin, il faut exporter les informations pertinentes concernant le widget en ajoutant la macro Q_PLUGIN_METADATA():

#ifndef TICTACTOEPLUGIN_H
#define TICTACTOEPLUGIN_H

#include <QtUiPlugin/QDesignerCustomWidgetInterface>

class QIcon;
class QWidget;

class TicTacToePlugin : public QObject, public QDesignerCustomWidgetInterface
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidgetInterface")
    Q_INTERFACES(QDesignerCustomWidgetInterface)

public:
    explicit TicTacToePlugin(QObject *parent = nullptr);

    QString name() const override;
    QString group() const override;
    QString toolTip() const override;
    QString whatsThis() const override;
    QString includeFile() const override;
    QIcon icon() const override;
    bool isContainer() const override;
    QWidget *createWidget(QWidget *parent) override;
    bool isInitialized() const override;
    void initialize(QDesignerFormEditorInterface *formEditor) override;
    QString domXml() const override;

private:
    bool initialized = false;
};

#endif

Qt Widgets La classe de plugin fournit à l’ initialize Designer des informations de base sur notre plugin, telles que son nom de classe et son fichier d’inclusion. De plus, elle sait comment créer des instances du widget TicTacToe. TicTacToePlugin définit également la fonction (), qui est appelée une fois le plugin chargé dans l’ Qt Widgets Designer. Le paramètre ` QDesignerFormEditorInterface ` de cette fonction fournit au plugin un accès à l’ensemble des API de Qt Widgets Designer.

La classe ` TicTacToePlugin ` hérite à la fois de ` QObject ` et de ` QDesignerCustomWidgetInterface`. Il est important de garder à l’esprit, lors de l’utilisation de l’héritage multiple, de s’assurer que toutes les interfaces (c’est-à-dire les classes qui n’héritent pas de ` Q_OBJECT`) sont signalées au système de méta-objets à l’aide de la macro ` Q_INTERFACES()`. Cela permet à Qt Widgets Designer d’utiliser ` qobject_cast()` pour rechercher les interfaces prises en charge en utilisant uniquement un pointeur ` QObject `.

Implémentation de la classe TicTacToePlugin

L’implémentation de la classe `TicTacToePlugin` est, pour l’essentiel, équivalente à celle de la classe de plugin de l’exemple « Custom Widget Plugin »:

TicTacToePlugin::TicTacToePlugin(QObject *parent)
    : QObject(parent)
{
}

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

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

QString TicTacToePlugin::toolTip() const
{
    return u"Tic Tac Toe Example, demonstrating class QDesignerTaskMenuExtension (C++)"_s;
}

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

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

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

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

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

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

La seule fonction qui diffère significativement est la fonction initialize() :

void TicTacToePlugin::initialize(QDesignerFormEditorInterface *formEditor)
{

La fonction ` initialize() ` prend un objet ` QDesignerFormEditorInterface ` en argument. La classe ` QDesignerFormEditorInterface ` permet d’accéder aux composants du Designer d’ Qt Widgets.

Dans Qt Widgets Designer, vous pouvez créer deux types de plugins : des plugins de widgets personnalisés et des plugins d’outils. QDesignerFormEditorInterface donne accès à tous les composants d’ Qt Widgets Designer dont vous avez normalement besoin pour créer un plugin d’outils : le gestionnaire d’extensions, l’inspecteur d’objets, l’éditeur de propriétés et la boîte à widgets. Les plugins de widgets personnalisés ont accès aux mêmes composants.

    if (initialized)
        return;

    auto *manager = formEditor->extensionManager();
    Q_ASSERT(manager != nullptr);

Lors de la création d’extensions associées à des plugins de widgets personnalisés, il est nécessaire d’accéder au gestionnaire d’extensions actuel d’ Qt Widgets Designer, que l’on récupère à partir du paramètre QDesignerFormEditorInterface.

Qt Widgets L’ QDesignerFormEditorInterface de Designer contient des informations sur tous les composants d’ Qt Designer: l’éditeur d’actions, l’inspecteur d’objets, l’éditeur de propriétés, la boîte à widgets, ainsi que les gestionnaires d’extensions et de fenêtres de formulaire.

La classe ` QExtensionManager ` fournit des fonctionnalités de gestion des extensions pour Designer d'Qt Widgets. À l'aide du gestionnaire d'extensions actuel de Designer d'Qt Widgets, vous pouvez récupérer l'extension associée à un objet donné. Vous pouvez également enregistrer ou désenregistrer une extension pour un objet donné. N'oubliez pas qu'une extension est un objet qui modifie le comportement de Designer d'Qt Widgets.

Lors de l'enregistrement d’une extension, c’est en réalité l’usine d’extensions associée qui est enregistrée. Dans Qt Widgets Designer, les usines d’extensions sont utilisées pour rechercher et créer des extensions nommées à la demande. Ainsi, dans cet exemple, l’extension du menu des tâches n’est créée qu’au moment où l’utilisateur demande un menu des tâches.

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

    initialized = true;
}

QString TicTacToePlugin::domXml() const
{
    return uR"(
<ui language="c++">
    <widget class="TicTacToe" name="ticTacToe"/>
    <customwidgets>
        <customwidget>
            <class>TicTacToe</class>
            <propertyspecifications>
            <tooltip name="state">Tic Tac Toe state</tooltip>
            <stringpropertyspecification name="state" notr="true" type="singleline"/>
            </propertyspecifications>
        </customwidget>
    </customwidgets>
</ui>
)"_s;
}

Nous créons un objet ` TicTacToeTaskMenuFactory ` que nous enregistrons à l’aide de l’ extension manager e actuel du concepteur ` Qt Widgets `, récupéré à partir du paramètre ` QDesignerFormEditorInterface `. Le premier argument est la fabrique nouvellement créée et le deuxième argument est un identifiant d’extension, qui est une chaîne de caractères. La macro ` Q_TYPEID() ` convertit simplement cette chaîne en un ` QLatin1String`.

La classe ` TicTacToeTaskMenuFactory ` est une sous-classe de ` QExtensionFactory`. Lorsque l’utilisateur demande un menu de tâches en cliquant avec le bouton droit de la souris sur un widget doté de l’extension de menu de tâches spécifiée, le gestionnaire d’extensions d’ Qt Widgets Designer parcourt toutes ses fabriques enregistrées et invoque la première capable de créer une extension de menu de tâches pour le widget sélectionné. Cette fabrique créera à son tour un objet ` TicTacToeTaskMenu ` (l’extension).

Nous omettons de réimplémenter la fonction ` QDesignerCustomWidgetInterface::domXml()` (qui inclut les paramètres par défaut du widget au format XML standard utilisé par le Designer d’ Qt Widgets ), car aucune valeur par défaut n’est nécessaire.

    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidgetInterface")

Enfin, nous utilisons la macro Q_PLUGIN_METADATA() pour exporter la classe TicTacToePlugin afin de l’utiliser avec les classes de gestion des plugins de Qt : cette macro garantit que le Designer d’ Qt Widgets peut accéder au widget personnalisé et le construire. Sans cette macro, le Designer d’ Qt Widgets ne peut en aucun cas utiliser le widget.

Définition de la classe `TicTacToeTaskMenuFactory`

La classe ` TicTacToeTaskMenuFactory ` hérite de ` QExtensionFactory `, qui fournit une fabrique d’extensions standard pour le Designer d’ Qt Widgets.

class TicTacToeTaskMenuFactory : public QExtensionFactory
{
    Q_OBJECT

public:
    explicit TicTacToeTaskMenuFactory(QExtensionManager *parent = nullptr);

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

Le but de la sous-classe est de réimplémenter la fonction ` QExtensionFactory::createExtension()`, afin de permettre la création d’une extension de menu de tâches pour ` TicTacToe `.

Implémentation de la classe `TicTacToeTaskMenuFactory`

Le constructeur de la classe appelle simplement le constructeur de la classe de base ` QExtensionFactory ` :

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

Comme décrit ci-dessus, l’usine est invoquée lorsque l’utilisateur demande un menu de tâches en cliquant avec le bouton droit de la souris sur un widget doté de l’extension de menu de tâches spécifiée dans Qt Widgets Designer.

Qt Widgets Le comportement de Designer est le même, que l’extension demandée soit associée à un conteneur, à une feuille de membres, à une feuille de propriétés ou à un menu de tâches : son gestionnaire d’extensions parcourt toutes ses fabriques d’extensions enregistrées en appelant createExtension() pour chacune d’entre elles, jusqu’à ce qu’une d’entre elles réponde en créant l’extension demandée.

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

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

    return nullptr;
}

La première chose que nous faisons dans ` TicTacToeTaskMenuFactory::createExtension() `, c’est donc de vérifier si l’extension demandée est une extension de menu de tâches. Si c’est le cas, et que le widget qui la demande est un widget ` TicTacToe `, nous créons et renvoyons un objet ` TicTacToeTaskMenu `. Sinon, nous renvoyons simplement un pointeur null, ce qui permet au gestionnaire d’extensions de Qt Widgets Designer de poursuivre sa recherche parmi les fabriques enregistrées.

Définition de la classe TicTacToeTaskMenu

La classe ` TicTacToeTaskMenu ` hérite de ` QDesignerTaskMenuExtension `, ce qui vous permet d’ajouter des entrées personnalisées (sous la forme de `QActions`) au menu des tâches dans Qt Widgets Designer.

class TicTacToeTaskMenu : public QObject, public QDesignerTaskMenuExtension
{
    Q_OBJECT
    Q_INTERFACES(QDesignerTaskMenuExtension)

public:
    explicit TicTacToeTaskMenu(TicTacToe *tic, QObject *parent);

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

private slots:
    void editState();

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

Nous réimplémentons les fonctions ` preferredEditAction() ` et ` taskActions() `. Notez que nous implémentons un constructeur qui prend deux arguments : le widget parent et le widget ` TicTacToe ` pour lequel le menu de tâches est demandé.

De plus, nous déclarons le slot privé ` editState() `, notre fonction personnalisée ` editStateAction ` et un pointeur privé vers le widget ` TicTacToe ` dont nous souhaitons modifier l’état.

Implémentation de la classe TicTacToeTaskMenu

TicTacToeTaskMenu::TicTacToeTaskMenu(TicTacToe *tic, QObject *parent)
    : QObject(parent)
    , editStateAction(new QAction(tr("Edit State..."), this))
    , ticTacToe(tic)
{
    connect(editStateAction, &QAction::triggered, this, &TicTacToeTaskMenu::editState);
}

Dans le constructeur, nous enregistrons tout d’abord la référence au widget « TicTacToe » transmis en paramètre, c’est-à-dire le widget dont nous souhaitons modifier l’état. Nous en aurons besoin ultérieurement, lorsque notre action personnalisée sera appelée. Nous créons également notre action personnalisée « editStateAction » et la connectons au slot « editState() ».

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

Le slot « editState() » est appelé chaque fois que l’utilisateur sélectionne l’option « Modifier l’état… » dans le menu des tâches d’un widget « TicTacToe ». Ce slot crée un « TicTacToeDialog » présentant l’état actuel du widget et permettant à l’utilisateur de modifier cet état en jouant au jeu.

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

Nous réimplémentons la fonction ` preferredEditAction() ` pour qu’elle renvoie notre ` editStateAction ` personnalisé comme action à invoquer lors de la sélection d’un widget ` TicTacToe ` et de l’appui sur la touche F2.

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

Nous réimplémentons la fonction ` taskActions() ` pour qu’elle renvoie une liste de nos actions personnalisées, afin que celles-ci apparaissent au-dessus des entrées par défaut dans le menu des tâches d’un widget ` TicTacToe `.

Définition de la classe TicTacToeDialog

La classe ` TicTacToeDialog ` hérite de ` QDialog`. La boîte de dialogue permet à l’utilisateur de modifier l’état du plugin Tic-Tac-Toe actuellement sélectionné.

class TicTacToeDialog : public QDialog
{
    Q_OBJECT

public:
    explicit TicTacToeDialog(TicTacToe *plugin = nullptr, QWidget *parent = nullptr);

    QSize sizeHint() const override;

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

private:
    TicTacToe *editor;
    TicTacToe *ticTacToe;
    QDialogButtonBox *buttonBox;
};

Nous réimplémentons la fonction ` sizeHint() `. Nous déclarons également deux slots privés : ` resetState() ` et ` saveState()`. Outre les boutons et la mise en page de la boîte de dialogue, nous déclarons deux pointeurs de type ` TicTacToe `, l’un vers le widget avec lequel l’utilisateur peut interagir, et l’autre vers le plugin de widget personnalisé d’origine dont l’utilisateur souhaite modifier l’état.

Implémentation de la classe TicTacToeDialog

TicTacToeDialog::TicTacToeDialog(TicTacToe *tic, QWidget *parent)
    : QDialog(parent)
    , editor(new TicTacToe)
    , ticTacToe(tic)
    , buttonBox(new QDialogButtonBox(QDialogButtonBox::Ok
                                     | QDialogButtonBox::Cancel
                                     | QDialogButtonBox::Reset))
{
    editor->setState(ticTacToe->state());

    connect(buttonBox->button(QDialogButtonBox::Reset), &QAbstractButton::clicked,
            this, &TicTacToeDialog::resetState);
    connect(buttonBox, &QDialogButtonBox::accepted, this, &TicTacToeDialog::saveState);
    connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);

    auto *mainLayout = new QVBoxLayout(this);
    mainLayout->addWidget(editor);
    mainLayout->addWidget(buttonBox);

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

Dans le constructeur, nous enregistrons d’abord la référence au widget TicTacToe transmis en paramètre, c’est-à-dire le widget dont l’utilisateur souhaite modifier l’état. Ensuite, nous créons un nouveau widget TicTacToe et définissons son état de manière à ce qu’il soit identique à celui du widget passé en paramètre.

Enfin, nous créons les boutons et la mise en page de la boîte de dialogue.

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

Nous réimplémentons la fonction ` sizeHint() ` pour garantir que la boîte de dialogue ait une taille raisonnable.

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

Le slot « resetState() » est appelé chaque fois que l’utilisateur appuie sur le bouton « Reset ». La seule chose que nous faisons est d’appeler la fonction « clearBoard() » pour le widget éditeur, c’est-à-dire le widget « TicTacToe » que nous avons créé dans le constructeur de la boîte de dialogue.

void TicTacToeDialog::saveState()
{

Le slot « saveState() » est appelé chaque fois que l’utilisateur clique sur le bouton « OK » et transfère l’état du widget éditeur vers le widget dont nous souhaitons modifier l’état. Afin que le changement d’état soit visible dans Qt Widgets Designer, nous devons définir la propriété « state » de ce dernier widget à l’aide de la classe « QDesignerFormWindowInterface ».

QDesignerFormWindowInterface Qt Widgets Elle vous fournit des informations sur la fenêtre de formulaire associée et vous permet de modifier ses propriétés. Cette interface n’est pas destinée à être instanciée directement, mais à donner accès aux fenêtres de formulaire actives d’ Designer, gérées par le gestionnaire de fenêtres de formulaire d’ Designer. Qt Widgets

Si vous recherchez la fenêtre de formulaire contenant un widget spécifique, vous pouvez utiliser la fonction statique ` QDesignerFormWindowInterface::findFormWindow()` :

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

Après avoir récupéré la fenêtre de formulaire du widget (dont nous souhaitons modifier l'état), nous utilisons la fonction ` QDesignerFormWindowInterface::cursor()` pour récupérer le curseur de cette fenêtre.

La classe ` QDesignerFormWindowCursorInterface ` fournit une interface vers le curseur de texte de la fenêtre de formulaire. Une fois que nous disposons du curseur, nous pouvons enfin définir la propriété d’état à l’aide de la fonction ` QDesignerFormWindowCursorInterface::setProperty()`.

    accept();
}

Pour finir, nous appelons la fonction ` QEvent::accept()`, qui active le drapeau « accept » de l’objet événement. L’activation du paramètre ` accept ` indique que le récepteur d’événement souhaite recevoir cet événement. Les événements indésirables pourraient être propagés au widget parent.

Définition de la classe TicTacToe

La classe ` TicTacToe ` est un widget personnalisé qui permet à l’utilisateur de jouer au jeu Tic-Tac-Toe.

class TicTacToe : public QWidget
{
    Q_OBJECT
    Q_PROPERTY(QString state READ state WRITE setState)

public:
    explicit TicTacToe(QWidget *parent = nullptr);

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

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

private:
    static constexpr char16_t Empty = '-';
    static constexpr char16_t Cross = 'X';
    static constexpr char16_t Nought = 'O';

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

    QString myState;
    int turnNumber = 0;
};

Les principaux éléments à retenir dans la définition de la classe TicTacToe sont la déclaration de la propriété state et ses fonctions state() et setState().

Nous devons déclarer l’état du widget TicTacToe en tant que propriété afin de le rendre visible dans l’éditeur Qt Widgets; cela permet à l’éditeur Qt Widgets de le gérer de la même manière qu’il gère les propriétés dont le widget TicTacToe hérite de QWidget et QObject, notamment via l’éditeur de propriétés.

Exemple de projet sur code.qt.io