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

Exemple de drapeaux de fenêtre

L'exemple des drapeaux de fenêtre montre comment utiliser les drapeaux de fenêtre disponibles dans Qt.

Un indicateur de fenêtre est soit un type, soit un indice. Un type est utilisé pour spécifier diverses propriétés du système de fenêtres pour le widget. Un widget ne peut avoir qu'un seul type, et la valeur par défaut est Qt::Widget. Cependant, un widget peut avoir zéro ou plusieurs indices. Les indices sont utilisés pour personnaliser l'apparence des fenêtres de premier niveau.

Les drapeaux d'un widget sont stockés dans un type Qt::WindowFlags qui stocke une combinaison OR des drapeaux.

Fenêtre du contrôleur et fenêtre de prévisualisation

Capture d'écran de l'exemple Window Flags

L'exemple se compose de deux classes :

  • ControllerWindow le widget principal de l'application qui permet à l'utilisateur de choisir parmi les drapeaux de fenêtre disponibles et qui affiche l'effet dans une fenêtre de prévisualisation séparée.
  • PreviewWindow est un widget personnalisé qui affiche le nom des drapeaux 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 la classe QWidget. Le widget permet à l'utilisateur de choisir parmi les drapeaux de fenêtre disponibles et affiche l'effet dans une fenêtre de prévisualisation séparée.

Nous déclarons un slot privé updatePreview() pour rafraîchir la fenêtre de prévisualisation chaque fois que l'utilisateur modifie les drapeaux 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(), et nous les rassemblons dans un cadre. De la même manière, nous utilisons la fonction createHintsGroupBox() pour créer une case à cocher pour chaque indice disponible, en utilisant la fonction privée createCheckBox().

Outre les divers boutons radio et cases à cocher, nous avons besoin d'un site PreviewWindow pour montrer l'effet des drapeaux de fenêtre actuellement choisis.

Fenêtre du contrôleur avec les différents types de drapeaux et conseils

Mise en œuvre 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 = nouveau 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 de prévisualisation. Ensuite, nous créons les boîtes de groupe contenant les drapeaux de fenêtre disponibles à l'aide des fonctions privées createTypeGroupBox() et createHintsGroupBox(). En outre, nous créons un bouton Quit. Nous plaçons le bouton et un espace extensible dans une disposition séparée pour que le bouton apparaisse dans le coin inférieur droit du widget WindowFlag.

Enfin, nous ajoutons la disposition du bouton et les deux boîtes de groupe à une page QVBoxLayout, définissons le titre de la fenêtre et rafraîchissons la fenêtre de prévisualisation à l'aide de l'emplacement 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 drapeaux de la fenêtre. Nous créons d'abord un Qt::WindowFlags flags vide, 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 les indices cochés et les ajoutons à flags à l'aide d'un opérateur OR. Nous utilisons flags pour définir les drapeaux de fenêtre pour la fenêtre de prévisualisation.

    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 de prévisualisation. La raison en est que, sur certaines plates-formes, le fait de jouer avec le cadre de la fenêtre peut entraîner une modification de la position de la fenêtre dans notre dos. Si une fenêtre est située dans le coin supérieur gauche de l'écran, certaines parties de la fenêtre peuvent ne pas être visibles. Nous ajustons donc la position du widget pour nous assurer que, si cela se produit, la fenêtre est déplacée à l'intérieur des 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 à partir du constructeur.

Nous créons d'abord un cadre, puis un bouton radio (à l'aide de la fonction privée createRadioButton() ) pour chacun des types disponibles parmi les drapeaux de la fenêtre. Le type initialement appliqué est Qt::Window. Nous plaçons les boutons radio dans une page QGridLayout et installons la disposition sur le cadre.

Nous n'incluons pas le type par défaut Qt::Widget. En effet, son comportement est quelque peu différent de celui des autres types. Si le type n'est pas spécifié pour un widget et qu'il n'a pas de parent, le widget est une fenêtre. Toutefois, 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 astuces 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 à partir du constructeur.

Encore une fois, la première chose que nous faisons est de créer une boîte de groupe. Nous créons ensuite une case à cocher, à l'aide de la fonction privée createCheckBox(), pour chacun des indices disponibles parmi les drapeaux de la fenêtre. Nous plaçons les cases à cocher dans un site QGridLayout et installons la mise en page sur le cadre.

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 à partir de createHintsGroupBox().

Nous créons simplement un QCheckBox avec le texte fourni, nous le connectons à l'emplacement privé updatePreview() et 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(), c'est un QRadioButton que nous créons avec le texte fourni et que nous connectons à l'emplacement privé updatePreview(). La fonction est appelée à partir de createTypeGroupBox() et renvoie un pointeur sur 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 drapeaux de fenêtre actuellement définis dans un éditeur de texte en lecture seule. Elle est également dotée d'un bouton QPushbutton qui permet 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 drapeaux de la fenêtre.

Fenêtre de prévisualisation affichant les drapeaux de la fenêtre

Mise en œuvre 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 un site QTextEdit et nous nous assurons qu'il est en lecture seule.

Nous interdisons également tout retour à la ligne dans l'éditeur de texte à l'aide de la fonction QTextEdit::setLineWrapMode(). Le résultat est qu'une barre de défilement horizontale apparaît lorsque le nom d'un drapeau 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 et 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 drapeaux des widgets à l'aide de la fonction QWidget::setWindowFlags(). Ensuite, nous passons en revue les drapeaux de fenêtre disponibles, en créant un texte contenant les noms des drapeaux correspondant au paramètre flags. Enfin, nous affichons le texte dans l'éditeur de texte des widgets.

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.