Back to Qt.io
Contact Us Blog Download Qt
Auf dieser Seite

Beispiel für Fensterfahnen

Das Beispiel „Fensterflags“ zeigt, wie die in Qt verfügbaren Fensterflags verwendet werden.

Ein Fensterflag ist entweder ein Typ oder ein Hinweis. Ein Typ wird verwendet, um verschiedene Eigenschaften des Fenstersystems für das Widget festzulegen. Ein Widget kann nur einen Typ haben, wobei der Standardwert „ Qt::Widget “ ist. Ein Widget kann jedoch null oder mehr Hinweise haben. Die Hinweise dienen dazu, das Erscheinungsbild von Fenstern der obersten Ebene anzupassen.

Die Flags eines Widgets werden in einem Typ „ Qt::WindowFlags “ gespeichert, der eine ODER-Kombination der Flags enthält.

Controller-Fenster und Vorschaufenster

Screenshot des Beispiels „Window Flags“

Das Beispiel besteht aus zwei Klassen:

  • ControllerWindow ist das Haupt-Anwendungs-Widget, mit dem der Benutzer zwischen den verfügbaren Fensterflags wählen kann und das die Auswirkung in einem separaten Vorschaufenster anzeigt.
  • PreviewWindow ist ein benutzerdefiniertes Widget, das den Namen der aktuell eingestellten Fensterflags in einem schreibgeschützten Texteditor anzeigt.

Zunächst werden wir uns die Klasse „ ControllerWindow “ ansehen, anschließend werden wir einen Blick auf die Klasse „ PreviewWindow “ werfen.

Definition der Klasse „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;
};

Die Klasse „ ControllerWindow “ erbt von „ QWidget “. Das Widget ermöglicht es dem Benutzer, zwischen den verfügbaren Fensterflags zu wählen, und zeigt die Auswirkung in einem separaten Vorschaufenster an.

Wir deklarieren einen privaten „ updatePreview() “-Slot, um das Vorschaufenster jedes Mal zu aktualisieren, wenn der Benutzer die Fensterflags ändert.

Außerdem deklarieren wir mehrere private Funktionen, um den Konstruktor zu vereinfachen: Wir rufen die Funktion ` createTypeGroupBox() ` auf, um mithilfe der privaten Funktion ` createButton() ` für jeden verfügbaren Fenstertyp ein Optionsfeld zu erstellen, und fassen diese in einem Gruppenfeld zusammen. Auf ähnliche Weise verwenden wir die Funktion ` createHintsGroupBox() `, um mithilfe der privaten Funktion ` createCheckBox() ` für jeden verfügbaren Hinweis ein Kontrollkästchen zu erstellen.

Zusätzlich zu den verschiedenen Optionsfeldern und Kontrollkästchen benötigen wir ein zugehöriges „ PreviewWindow “, um die Auswirkungen der aktuell ausgewählten Fenster-Flags anzuzeigen.

Controller-Fenster mit den verschiedenen Flag-Typen und Hinweisen

Implementierung der Klasse „ControllerWindow“

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

    createTypeGroupBox();
    createHintsGroupBox();

    quitButton = new QPushButton(tr("&Beenden"));
    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();
}

Im Konstruktor erstellen wir zunächst das Vorschaufenster. Anschließend erstellen wir mithilfe der privaten Funktionen ` createTypeGroupBox() ` und ` createHintsGroupBox() ` die Gruppenfelder, die die verfügbaren Fensterflags enthalten. Darüber hinaus erstellen wir eine Schaltfläche „ Quit “. Wir platzieren die Schaltfläche und einen dehnbaren Bereich in einem separaten Layout, damit die Schaltfläche in der rechten unteren Ecke des Widgets „ WindowFlag “ erscheint.

Abschließend fügen wir das Layout der Schaltfläche und die beiden Gruppenfelder zu einem „ QVBoxLayout “ hinzu, legen den Fenstertitel fest und aktualisieren das Vorschaufenster mithilfe des Slots „ 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;

Der Slot „ updatePreview() “ wird immer dann aufgerufen, wenn der Benutzer eines der Fenster-Flags ändert. Zunächst erstellen wir ein leeres „ Qt::WindowFlags “- flags, dann ermitteln wir, welcher der Typen markiert ist, und fügen ihn zu „ flags “ hinzu.

    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);

Außerdem ermitteln wir, welche der Hinweise markiert sind, und fügen sie mithilfe eines OR-Operators zu ` flags ` hinzu. Wir verwenden ` flags `, um die Fensterflags für das Vorschaufenster festzulegen.

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

Wir passen die Position des Vorschaufensters an. Der Grund dafür ist, dass das Herumspielen mit dem Fensterrahmen auf manchen Plattformen dazu führen kann, dass sich die Position des Fensters ohne unser Wissen ändert. Befindet sich ein Fenster in der oberen linken Ecke des Bildschirms, sind möglicherweise Teile des Fensters nicht sichtbar. Deshalb passen wir die Position des Widgets so an, dass das Fenster in einem solchen Fall innerhalb der Bildschirmgrenzen bleibt. Schließlich rufen wir ` QWidget::show()` auf, um sicherzustellen, dass das Vorschaufenster sichtbar ist.

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);
}

Die private Funktion ` createTypeGroupBox() ` wird vom Konstruktor aus aufgerufen.

Zunächst erstellen wir eine Gruppenbox und anschließend für jeden der in den Fensterflags verfügbaren Typen ein Optionsfeld (unter Verwendung der privaten Funktion ` createRadioButton() `). Wir legen „ Qt::Window “ als anfänglich ausgewählten Typ fest. Wir fügen die Optionsfelder in eine „ QGridLayout “ ein und weisen das Layout der Gruppenbox zu.

Den Standardtyp „ Qt::Widget “ lassen wir dabei außer Acht. Der Grund dafür ist, dass er sich etwas anders verhält als die anderen Typen. Wenn für ein Widget kein Typ angegeben ist und es kein übergeordnetes Element hat, ist das Widget ein Fenster. Hat es jedoch ein übergeordnetes Element, ist es ein normales untergeordnetes Widget. Die anderen Typen sind allesamt Fenster der obersten Ebene, und da sich die Hinweise nur auf Fenster der obersten Ebene auswirken, verzichten wir auf den Typ „ 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);
}

Die private Funktion „ createHintsGroupBox() “ wird ebenfalls vom Konstruktor aufgerufen.

Auch hier erstellen wir als Erstes ein Gruppenfeld. Anschließend erstellen wir mithilfe der privaten Funktion ` createCheckBox() ` für jeden der in den Fensterflags verfügbaren Hinweise ein Kontrollkästchen. Wir fügen die Kontrollkästchen in ein ` QGridLayout ` ein und ordnen das Layout dem Gruppenfeld zu.

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

Die private Funktion ` createCheckBox() ` wird von ` createHintsGroupBox()` aufgerufen.

Wir erstellen einfach ein ` QCheckBox ` mit dem angegebenen Text, verbinden es mit dem privaten Slot von ` updatePreview() ` und geben einen Zeiger auf das Kontrollkästchen zurück.

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

In der privaten Funktion ` createRadioButton() ` erstellen wir ein ` QRadioButton ` mit dem angegebenen Text und verbinden es mit dem privaten Slot ` updatePreview() `. Die Funktion wird von ` createTypeGroupBox()` aufgerufen und gibt einen Zeiger auf die Schaltfläche zurück.

Definition der Klasse „PreviewWindow“

class PreviewWindow : public QWidget
{
    Q_OBJECT

public:
    PreviewWindow(QWidget *parent = nullptr);

    void setWindowFlags(Qt::WindowFlags flags);

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

Die Klasse „ PreviewWindow “ erbt von „ QWidget “. Es handelt sich um ein benutzerdefiniertes Widget, das die Namen der aktuell gesetzten Fensterflags in einem schreibgeschützten Texteditor anzeigt. Außerdem verfügt es über eine „QPushbutton“-Schaltfläche, mit der das Fenster geschlossen werden kann.

Wir implementieren den Konstruktor neu, um die Schaltfläche „ Close “ und den Texteditor zu erstellen, sowie die Funktion „ QWidget::setWindowFlags()“, um die Namen der Fensterflags anzuzeigen.

Vorschaufenster mit Fensterkennzeichen

Implementierung der Klasse „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"));
}

Im Konstruktor erstellen wir zunächst ein ` QTextEdit ` und stellen sicher, dass es schreibgeschützt ist.

Außerdem verhindern wir mithilfe der Funktion ` QTextEdit::setLineWrapMode()` jeglichen Zeilenumbruch im Texteditor. Das hat zur Folge, dass eine horizontale Bildlaufleiste erscheint, wenn der Name eines Fenster-Flags die Breite des Editors überschreitet. Dies ist eine sinnvolle Lösung, da wir den angezeigten Text mit integrierten Zeilenumbrüchen erstellen. Wären keine Zeilenumbrüche garantiert, wäre die Verwendung eines anderen ` QTextEdit::LineWrapMode ` vielleicht sinnvoller.

Anschließend erstellen wir die Schaltfläche „ Close “ und fügen beide Widgets in ein „ QVBoxLayout “ ein, bevor wir den Fenstertitel festlegen.

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);
}

Bei unserer Neuimplementierung der Funktion „ setWindowFlags() “ setzen wir zunächst die Flags der Widgets mithilfe der Funktion „ QWidget::setWindowFlags()“. Anschließend durchlaufen wir die verfügbaren Fenster-Flags und erstellen einen Text, der die Namen der Flags enthält, die dem Parameter „ flags “ entsprechen. Schließlich zeigen wir den Text im Texteditor des Widgets an.

Beispielprojekt @ 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.