Back to Qt.io
Contact Us Blog Download Qt
Sur cette page

Exemple de drapeaux de fenêtre

L'exemple « Indicateurs de fenêtre » montre comment utiliser les indicateurs de fenêtre disponibles dans Qt.

Un indicateur de fenêtre est soit un type, soit une indication. Un type sert à spécifier diverses propriétés du système de fenêtr Qt::Widget s pour le widget. Un widget ne peut avoir qu'un seul type, et la valeur par défaut est « ». En revanche, un widget peut avoir zéro ou plusieurs indications. Les indications servent à personnaliser l'apparence des fenêtres de niveau supérieur.

Les indicateurs d'un widget sont stockés dans un type « Qt::WindowFlags » qui contient une combinaison OR de ces indicateurs.

Fenêtre de contrôle et fenêtre d'aperçu

Capture d’écran de l’exemple « Window Flags »

L'exemple se compose de deux classes :

  • ControllerWindow est le widget principal de l'application qui permet à l'utilisateur de choisir parmi les indicateurs de fenêtre disponibles et affiche le résultat dans une fenêtre de prévisualisation distincte.
  • PreviewWindow est un widget personnalisé affichant le nom des indicateurs de fenêtre actuellement définis dans un éditeur de texte en lecture seule.

Nous commencerons par examiner la classe ` ControllerWindow `, puis nous nous pencherons sur la classe ` PreviewWindow `.

Définition de la classe `ControllerWindow`

class ControllerWindow : public QWidget
{
    Q_OBJECT

public:
    ControllerWindow(QWidget *parent = nullptr);

private slots:
    void updatePreview();

private:
    void createTypeGroupBox();
    void createHintsGroupBox();
    QCheckBox *createCheckBox(const QString &text);
    QRadioButton *createRadioButton(const QString &text);

    PreviewWindow *previewWindow;

    QGroupBox *typeGroupBox;
    QGroupBox *hintsGroupBox;
    QPushButton *quitButton;

    QRadioButton *windowRadioButton;
    QRadioButton *dialogRadioButton;
    QRadioButton *sheetRadioButton;
    QRadioButton *drawerRadioButton;
    QRadioButton *popupRadioButton;
    QRadioButton *toolRadioButton;
    QRadioButton *toolTipRadioButton;
    QRadioButton *splashScreenRadioButton;

    QCheckBox *msWindowsFixedSizeDialogCheckBox;
    QCheckBox *x11BypassWindowManagerCheckBox;
    QCheckBox *framelessWindowCheckBox;
    QCheckBox *windowNoShadowCheckBox;
    QCheckBox *windowTitleCheckBox;
    QCheckBox *windowSystemMenuCheckBox;
    QCheckBox *windowMinimizeButtonCheckBox;
    QCheckBox *windowMaximizeButtonCheckBox;
    QCheckBox *windowCloseButtonCheckBox;
    QCheckBox *windowContextHelpButtonCheckBox;
    QCheckBox *windowShadeButtonCheckBox;
    QCheckBox *windowStaysOnTopCheckBox;
    QCheckBox *windowStaysOnBottomCheckBox;
    QCheckBox *customizeWindowHintCheckBox;
};

La classe ` ControllerWindow ` hérite de ` QWidget`. Ce widget permet à l'utilisateur de choisir parmi les indicateurs de fenêtre disponibles et affiche le résultat dans une fenêtre d'aperçu distincte.

Nous déclarons un slot privé « updatePreview() » pour actualiser la fenêtre de prévisualisation chaque fois que l'utilisateur modifie les indicateurs de fenêtre.

Nous déclarons également plusieurs fonctions privées pour simplifier le constructeur : nous appelons la fonction ` createTypeGroupBox() ` pour créer un bouton radio pour chaque type de fenêtre disponible, à l’aide de la fonction privée ` createButton() `, puis nous les regroupons dans une zone de groupe. De la même manière, nous utilisons la fonction ` createHintsGroupBox() ` pour créer une case à cocher pour chaque astuce disponible, à l’aide de la fonction privée ` createCheckBox() `.

En plus des différents boutons radio et cases à cocher, nous avons besoin d’un élément « PreviewWindow » associé pour afficher l’effet des indicateurs de fenêtre actuellement sélectionnés.

Fenêtre du contrôleur présentant les différents types d'indicateurs et des conseils

Implémentation de la classe ControllerWindow

ControllerWindow::ControllerWindow(QWidget*parent)
    : QWidget(parent)
{
    previewWindow = new PreviewWindow(this);

    createTypeGroupBox();
    createHintsGroupBox();

    quitButton = new QPushButton(tr("&Quit"));
    connect(quitButton, &QPushButton::clicked,
            qApp, &QCoreApplication::quit);

    QHBoxLayout*bottomLayout = new QHBoxLayout;
    bottomLayout->addStretch();
    bottomLayout->addWidget(quitButton);

    QHBoxLayout*mainLayout = new QHBoxLayout;
    mainLayout->addWidget(typeGroupBox);
    mainLayout->addWidget(hintsGroupBox);
    mainLayout->addLayout(bottomLayout);
    setLayout(mainLayout);

    setWindowTitle(tr("Window Flags"));
    updatePreview();
}

Dans le constructeur, nous créons d'abord la fenêtre d'aperçu. Ensuite, nous créons les zones de groupe contenant les indicateurs de fenêtre disponibles à l'aide des fonctions privées ` createTypeGroupBox() ` et ` createHintsGroupBox() `. De plus, nous créons un bouton « Quit ». Nous plaçons le bouton et un espace extensible dans une mise en page distincte afin que le bouton apparaisse dans le coin inférieur droit du widget ` WindowFlag `.

Enfin, nous ajoutons la mise en page du bouton et les deux boîtes de groupe à un ` QVBoxLayout`, définissons le titre de la fenêtre et actualisons la fenêtre d’aperçu à l’aide du slot ` updatePreview() `.

void ControllerWindow::updatePreview()
{
    Qt::WindowFlags flags;

    if (windowRadioButton->isChecked())
        flags = Qt::Window;
    else if (dialogRadioButton->isChecked())
        flags = Qt::Dialog;
    else if (sheetRadioButton->isChecked())
        flags = Qt::Sheet;
    else if (drawerRadioButton->isChecked())
        flags = Qt::Drawer;
    else if (popupRadioButton->isChecked())
        flags = Qt::Popup;
    else if (toolRadioButton->isChecked())
        flags = Qt::Tool;
    else if (toolTipRadioButton->isChecked())
        flags = Qt::ToolTip;
    else if (splashScreenRadioButton->isChecked())
        flags = Qt::SplashScreen;

Le slot « updatePreview() » est appelé chaque fois que l’utilisateur modifie l’un des indicateurs de la fenêtre. Nous créons d’abord un « Qt::WindowFlags » vide flags, puis nous déterminons lequel des types est coché et l’ajoutons à « flags ».

    if (msWindowsFixedSizeDialogCheckBox->isChecked())
        flags |= Qt::MSWindowsFixedSizeDialogHint;
    if (x11BypassWindowManagerCheckBox->isChecked())
        flags |= Qt::X11BypassWindowManagerHint;
    if (framelessWindowCheckBox->isChecked())
        flags |= Qt::FramelessWindowHint;
    if (windowNoShadowCheckBox->isChecked())
        flags |= Qt::NoDropShadowWindowHint;
    if (windowTitleCheckBox->isChecked())
        flags |= Qt::WindowTitleHint;
    if (windowSystemMenuCheckBox->isChecked())
        flags |= Qt::WindowSystemMenuHint;
    if (windowMinimizeButtonCheckBox->isChecked())
        flags |= Qt::WindowMinimizeButtonHint;
    if (windowMaximizeButtonCheckBox->isChecked())
        flags |= Qt::WindowMaximizeButtonHint;
    if (windowCloseButtonCheckBox->isChecked())
        flags |= Qt::WindowCloseButtonHint;
    if (windowContextHelpButtonCheckBox->isChecked())
        flags |= Qt::WindowContextHelpButtonHint;
    if (windowShadeButtonCheckBox->isChecked())
        flags |= Qt::WindowShadeButtonHint;
    if (windowStaysOnTopCheckBox->isChecked())
        flags |= Qt::WindowStaysOnTopHint;
    if (windowStaysOnBottomCheckBox->isChecked())
        flags |= Qt::WindowStaysOnBottomHint;
    if (customizeWindowHintCheckBox->isChecked())
        flags |= Qt::CustomizeWindowHint;

    previewWindow->setWindowFlags(flags);

Nous déterminons également quels sont les conseils cochés, puis nous les ajoutons à flags à l’aide d’un opérateur OU. Nous utilisons flags pour définir les indicateurs de la fenêtre d’aperçu.

    QPoint pos = previewWindow->pos();
    if (pos.x() < 0)
        pos.setX(0);
    if (pos.y() < 0)
        pos.setY(0);
    previewWindow->move(pos);
    previewWindow->showNormal();
}

Nous ajustons la position de la fenêtre d’aperçu. En effet, sur certaines plateformes, le fait de manipuler le cadre de la fenêtre peut entraîner un déplacement de celle-ci à notre insu. Si une fenêtre se trouve dans le coin supérieur gauche de l’écran, certaines parties de celle-ci risquent de ne pas être visibles. Nous ajustons donc la position du widget pour nous assurer que, si cela se produit, la fenêtre reste dans les limites de l’écran. Enfin, nous appelons ` QWidget::show()` pour nous assurer que la fenêtre de prévisualisation est visible.

void ControllerWindow::createTypeGroupBox()
{
    typeGroupBox = new QGroupBox(tr("Type"));

    windowRadioButton = createRadioButton(tr("Window"));
    dialogRadioButton = createRadioButton(tr("Dialog"));
    sheetRadioButton = createRadioButton(tr("Sheet"));
    drawerRadioButton = createRadioButton(tr("Drawer"));
    popupRadioButton = createRadioButton(tr("Popup"));
    toolRadioButton = createRadioButton(tr("Tool"));
    toolTipRadioButton = createRadioButton(tr("Tooltip"));
    splashScreenRadioButton = createRadioButton(tr("Splash screen"));
    windowRadioButton->setChecked(true);

    QGridLayout *layout = new QGridLayout;
    layout->addWidget(windowRadioButton, 0, 0);
    layout->addWidget(dialogRadioButton, 1, 0);
    layout->addWidget(sheetRadioButton, 2, 0);
    layout->addWidget(drawerRadioButton, 3, 0);
    layout->addWidget(popupRadioButton, 0, 1);
    layout->addWidget(toolRadioButton, 1, 1);
    layout->addWidget(toolTipRadioButton, 2, 1);
    layout->addWidget(splashScreenRadioButton, 3, 1);
    typeGroupBox->setLayout(layout);
}

La fonction privée ` createTypeGroupBox() ` est appelée depuis le constructeur.

Nous créons d’abord une zone de groupe, puis nous créons un bouton radio (à l’aide de la fonction privée ` createRadioButton() `) pour chacun des types disponibles parmi les indicateurs de fenêtre. Nous définissons ` Qt::Window ` comme type appliqué par défaut. Nous plaçons les boutons radio dans une ` QGridLayout ` et installons cette disposition sur la zone de groupe.

Nous n’incluons pas le type par défaut « Qt::Widget ». En effet, celui-ci se comporte de manière quelque peu différente des autres types. Si le type n’est pas spécifié pour un widget et que celui-ci n’a pas de parent, le widget est une fenêtre. En revanche, s’il a un parent, il s’agit d’un widget enfant standard. Les autres types sont tous des fenêtres de niveau supérieur, et comme les indications n’affectent que les fenêtres de niveau supérieur, nous abandonnons le type « Qt::Widget ».

void ControllerWindow::createHintsGroupBox()
{
    hintsGroupBox = new QGroupBox(tr("Hints"));

    msWindowsFixedSizeDialogCheckBox =
            createCheckBox(tr("MS Windows fixed size dialog"));
    x11BypassWindowManagerCheckBox =
            createCheckBox(tr("X11 bypass window manager"));
    framelessWindowCheckBox = createCheckBox(tr("Frameless window"));
    windowNoShadowCheckBox = createCheckBox(tr("No drop shadow"));
    windowTitleCheckBox = createCheckBox(tr("Window title"));
    windowSystemMenuCheckBox = createCheckBox(tr("Window system menu"));
    windowMinimizeButtonCheckBox = createCheckBox(tr("Window minimize button"));
    windowMaximizeButtonCheckBox = createCheckBox(tr("Window maximize button"));
    windowCloseButtonCheckBox = createCheckBox(tr("Window close button"));
    windowContextHelpButtonCheckBox =
            createCheckBox(tr("Window context help button"));
    windowShadeButtonCheckBox = createCheckBox(tr("Window shade button"));
    windowStaysOnTopCheckBox = createCheckBox(tr("Window stays on top"));
    windowStaysOnBottomCheckBox = createCheckBox(tr("Window stays on bottom"));
    customizeWindowHintCheckBox= createCheckBox(tr("Customize window"));

    QGridLayout *layout = new QGridLayout;
    layout->addWidget(msWindowsFixedSizeDialogCheckBox, 0, 0);
    layout->addWidget(x11BypassWindowManagerCheckBox, 1, 0);
    layout->addWidget(framelessWindowCheckBox, 2, 0);
    layout->addWidget(windowNoShadowCheckBox, 3, 0);
    layout->addWidget(windowTitleCheckBox, 4, 0);
    layout->addWidget(windowSystemMenuCheckBox, 5, 0);
    layout->addWidget(customizeWindowHintCheckBox, 6, 0);
    layout->addWidget(windowMinimizeButtonCheckBox, 0, 1);
    layout->addWidget(windowMaximizeButtonCheckBox, 1, 1);
    layout->addWidget(windowCloseButtonCheckBox, 2, 1);
    layout->addWidget(windowContextHelpButtonCheckBox, 3, 1);
    layout->addWidget(windowShadeButtonCheckBox, 4, 1);
    layout->addWidget(windowStaysOnTopCheckBox, 5, 1);
    layout->addWidget(windowStaysOnBottomCheckBox, 6, 1);
    hintsGroupBox->setLayout(layout);
}

La fonction privée ` createHintsGroupBox() ` est également appelée depuis le constructeur.

Une fois encore, la première chose que nous faisons est de créer une zone de groupe. Ensuite, nous créons une case à cocher, à l’aide de la fonction privée ` createCheckBox() `, pour chacun des indices disponibles parmi les indicateurs de fenêtre. Nous plaçons les cases à cocher dans un ` QGridLayout ` et installons la disposition sur la zone de groupe.

QCheckBox *ControllerWindow::createCheckBox(const QString &text)
{
    QCheckBox *checkBox = new QCheckBox(text);
    connect(checkBox, &QCheckBox::clicked,
            this, &ControllerWindow::updatePreview);
    return checkBox;
}

La fonction privée ` createCheckBox() ` est appelée depuis ` createHintsGroupBox()`.

Nous créons simplement une QCheckBox avec le texte fourni, nous la connectons au slot privé updatePreview(), puis nous renvoyons un pointeur vers la case à cocher.

QRadioButton *ControllerWindow::createRadioButton(const QString &text)
{
    QRadioButton *button = new QRadioButton(text);
    connect(button, &QRadioButton::clicked,
            this, &ControllerWindow::updatePreview);
    return button;
}

Dans la fonction privée ` createRadioButton() `, nous créons un ` QRadioButton ` avec le texte fourni, puis nous le connectons au slot privé ` updatePreview() `. La fonction est appelée depuis ` createTypeGroupBox()` et renvoie un pointeur vers le bouton.

Définition de la classe `PreviewWindow`

class PreviewWindow : public QWidget
{
    Q_OBJECT

public:
    PreviewWindow(QWidget *parent = nullptr);

    void setWindowFlags(Qt::WindowFlags flags);

private:
    QTextEdit *textEdit;
    QPushButton *closeButton;
};

La classe ` PreviewWindow ` hérite de ` QWidget`. Il s’agit d’un widget personnalisé qui affiche les noms des indicateurs de fenêtre actuellement définis dans un éditeur de texte en lecture seule. Elle est également fournie avec un bouton QPushbutton permettant de fermer la fenêtre.

Nous réimplémentons le constructeur pour créer le bouton « Close » et l'éditeur de texte, ainsi que la fonction ` QWidget::setWindowFlags()` pour afficher les noms des indicateurs de fenêtre.

Fenêtre d'aperçu affichant les indicateurs de fenêtre

Implémentation de la classe `PreviewWindow`

PreviewWindow::PreviewWindow(QWidget *parent)
    : QWidget(parent)
{
    textEdit = new QTextEdit;
    textEdit->setReadOnly(true);
    textEdit->setLineWrapMode(QTextEdit::NoWrap);

    closeButton = new QPushButton(tr("&Close"));
    connect(closeButton, &QPushButton::clicked,
            this, &PreviewWindow::close);

    QVBoxLayout *layout = new QVBoxLayout;
    layout->addWidget(textEdit);
    layout->addWidget(closeButton);
    setLayout(layout);

    setWindowTitle(tr("Preview"));
}

Dans le constructeur, nous créons d’abord une instance de ` QTextEdit ` et nous nous assurons qu’elle est en lecture seule.

Nous interdisons également tout retour à la ligne dans l'éditeur de texte à l'aide de la fonction ` QTextEdit::setLineWrapMode()`. Il en résulte l'apparition d'une barre de défilement horizontale lorsque le nom d'un indicateur de fenêtre dépasse la largeur de l'éditeur. Il s'agit d'une solution raisonnable puisque nous construisons le texte affiché avec des sauts de ligne intégrés. Si aucun saut de ligne n'était garanti, l'utilisation d'un autre ` QTextEdit::LineWrapMode ` serait peut-être plus judicieuse.

Nous créons ensuite le bouton « Close », puis nous plaçons les deux widgets dans un QVBoxLayout avant de définir le titre de la fenêtre.

void PreviewWindow::setWindowFlags(Qt::WindowFlags flags)
{
    QWidget::setWindowFlags(flags);

    QString text;

    Qt::WindowFlags type = (flags & Qt::WindowType_Mask);
    if (type == Qt::Window)
        text = "Qt::Window";
    else if (type == Qt::Dialog)
        text = "Qt::Dialog";
    else if (type == Qt::Sheet)
        text = "Qt::Sheet";
    else if (type == Qt::Drawer)
        text = "Qt::Drawer";
    else if (type == Qt::Popup)
        text = "Qt::Popup";
    else if (type == Qt::Tool)
        text = "Qt::Tool";
    else if (type == Qt::ToolTip)
        text = "Qt::ToolTip";
    else if (type == Qt::SplashScreen)
        text = "Qt::SplashScreen";

    if (flags & Qt::MSWindowsFixedSizeDialogHint)
        text += "\n| Qt::MSWindowsFixedSizeDialogHint";
    if (flags & Qt::X11BypassWindowManagerHint)
        text += "\n| Qt::X11BypassWindowManagerHint";
    if (flags & Qt::FramelessWindowHint)
        text += "\n| Qt::FramelessWindowHint";
    if (flags & Qt::NoDropShadowWindowHint)
        text += "\n| Qt::NoDropShadowWindowHint";
    if (flags & Qt::WindowTitleHint)
        text += "\n| Qt::WindowTitleHint";
    if (flags & Qt::WindowSystemMenuHint)
        text += "\n| Qt::WindowSystemMenuHint";
    if (flags & Qt::WindowMinimizeButtonHint)
        text += "\n| Qt::WindowMinimizeButtonHint";
    if (flags & Qt::WindowMaximizeButtonHint)
        text += "\n| Qt::WindowMaximizeButtonHint";
    if (flags & Qt::WindowCloseButtonHint)
        text += "\n| Qt::WindowCloseButtonHint";
    if (flags & Qt::WindowContextHelpButtonHint)
        text += "\n| Qt::WindowContextHelpButtonHint";
    if (flags & Qt::WindowShadeButtonHint)
        text += "\n| Qt::WindowShadeButtonHint";
    if (flags & Qt::WindowStaysOnTopHint)
        text += "\n| Qt::WindowStaysOnTopHint";
    if (flags & Qt::WindowStaysOnBottomHint)
        text += "\n| Qt::WindowStaysOnBottomHint";
    if (flags & Qt::CustomizeWindowHint)
        text += "\n| Qt::CustomizeWindowHint";

    textEdit->setPlainText(text);
}

Dans notre réimplémentation de la fonction ` setWindowFlags() `, nous définissons d’abord les indicateurs des widgets à l’aide de la fonction ` QWidget::setWindowFlags()`. Ensuite, nous parcourons les indicateurs de fenêtre disponibles, en créant un texte contenant les noms des indicateurs correspondant au paramètre ` flags `. Enfin, nous affichons ce texte dans l’éditeur de texte du widget.

Exemple de projet @ code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.