En esta página

Ejemplo de banderas para ventanas

El ejemplo «Indicadores de ventana» muestra cómo utilizar los indicadores de ventana disponibles en Qt.

Un indicador de ventana puede ser un tipo o una sugerencia. Un tipo se utiliza para especificar diversas propiedades del sistema de ventanas para el widget. Un widget solo puede tener un tipo, y el valor por defecto es ` Qt::Widget`. Sin embargo, un widget puede tener cero o más sugerencias. Las sugerencias se utilizan para personalizar el aspecto de las ventanas de nivel superior.

Los indicadores de un widget se almacenan en un tipo « Qt::WindowFlags », que contiene una combinación OR de dichos indicadores.

Ventana del controlador y ventana de vista previa

Captura de pantalla del ejemplo «Indicadores de ventana»

El ejemplo consta de dos clases:

  • ControllerWindow es el widget principal de la aplicación, que permite al usuario elegir entre los indicadores de ventana disponibles y muestra el efecto en una ventana de vista previa independiente.
  • PreviewWindow es un widget personalizado que muestra el nombre de las opciones de ventana actualmente configuradas en un editor de texto de solo lectura.

Empezaremos por repasar la clase ` ControllerWindow ` y, a continuación, analizaremos la clase ` PreviewWindow `.

Definición de la clase `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 clase ` ControllerWindow ` hereda de ` QWidget`. El widget permite al usuario elegir entre los indicadores de ventana disponibles y muestra el efecto en una ventana de vista previa independiente.

Declaramos una ranura privada de ` updatePreview() ` para actualizar la ventana de vista previa cada vez que el usuario cambie los indicadores de ventana.

También declaramos varias funciones privadas para simplificar el constructor: llamamos a la función ` createTypeGroupBox() ` para crear un botón de opción para cada tipo de ventana disponible, utilizando la función privada ` createButton() `, y los agrupamos en un cuadro de grupo. De forma similar, utilizamos la función ` createHintsGroupBox() ` para crear una casilla de selección para cada sugerencia disponible, utilizando la función privada ` createCheckBox() `.

Además de los distintos botones de opción y casillas de selección, necesitamos un cuadro de información ( PreviewWindow ) asociado para mostrar el efecto de los indicadores de ventana seleccionados actualmente.

Ventana del controlador con los distintos tipos de indicadores y sugerencias

Implementación de la clase `ControllerWindow`

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

    createTypeGroupBox();
    createHintsGroupBox();

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

En el constructor, primero creamos la ventana de vista previa. A continuación, creamos los cuadros de grupo que contienen los indicadores de ventana disponibles utilizando las funciones privadas ` createTypeGroupBox() ` y ` createHintsGroupBox() `. Además, creamos un botón « Quit ». Colocamos el botón y un espacio ampliable en un diseño independiente para que el botón aparezca en la esquina inferior derecha del widget ` WindowFlag `.

Por último, añadimos el diseño del botón y los dos cuadros de grupo a un ` QVBoxLayout`, establecemos el título de la ventana y actualizamos la ventana de vista previa utilizando la ranura ` 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;

La ranura « updatePreview() » se invoca cada vez que el usuario cambia cualquiera de los indicadores de la ventana. Primero creamos un « Qt::WindowFlags » vacío flags, luego determinamos cuál de los tipos está marcado y lo añadimos a « 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);

También determinamos cuáles de las sugerencias están marcadas y las añadimos a flags utilizando un operador OR. Utilizamos flags para configurar los indicadores de la ventana de vista previa.

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

Ajustamos la posición de la ventana de vista previa. La razón por la que lo hacemos es que, en algunas plataformas, manipular el marco de la ventana puede provocar que su posición cambie sin que nos demos cuenta. Si una ventana se encuentra en la esquina superior izquierda de la pantalla, es posible que algunas partes de la misma no sean visibles. Por eso ajustamos la posición del widget para asegurarnos de que, si esto ocurre, la ventana se mueva dentro de los límites de la pantalla. Por último, llamamos a QWidget::show() para asegurarnos de que la ventana de vista previa 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 función privada ` createTypeGroupBox() ` se invoca desde el constructor.

Primero creamos un cuadro de grupo y, a continuación, creamos un botón de opción (utilizando la función privada ` createRadioButton() `) para cada uno de los tipos disponibles entre los indicadores de la ventana. Establecemos ` Qt::Window ` como el tipo aplicado inicialmente. Colocamos los botones de opción en un ` QGridLayout ` e instalamos el diseño en el cuadro de grupo.

No incluimos el tipo predeterminado « Qt::Widget ». El motivo es que se comporta de forma algo diferente al resto de tipos. Si no se especifica el tipo de un widget y este no tiene ningún padre, el widget es una ventana. Sin embargo, si tiene un padre, es un widget hijo estándar. Los demás tipos son todos ventanas de nivel superior y, dado que las sugerencias solo afectan a las ventanas de nivel superior, descartamos el tipo « 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 función privada ` createHintsGroupBox() ` también se invoca desde el constructor.

De nuevo, lo primero que hacemos es crear un cuadro de grupo. A continuación, creamos una casilla de selección, utilizando la función privada ` createCheckBox() `, para cada una de las sugerencias disponibles entre los indicadores de ventana. Colocamos las casillas de selección en un ` QGridLayout ` e instalamos el diseño en el cuadro de grupo.

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

La función privada ` createCheckBox() ` se invoca desde ` createHintsGroupBox()`.

Simplemente creamos un ` QCheckBox ` con el texto proporcionado, lo conectamos a la ranura privada de ` updatePreview() ` y devolvemos un puntero a la casilla de selección.

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

En la función privada ` createRadioButton() `, creamos un ` QRadioButton ` con el texto proporcionado y lo conectamos a la ranura privada ` updatePreview() `. La función se invoca desde ` createTypeGroupBox()` y devuelve un puntero al botón.

Definición de la clase `PreviewWindow`

class PreviewWindow : public QWidget
{
    Q_OBJECT

public:
    PreviewWindow(QWidget *parent = nullptr);

    void setWindowFlags(Qt::WindowFlags flags);

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

La clase ` PreviewWindow ` hereda de ` QWidget`. Se trata de un widget personalizado que muestra los nombres de los indicadores de ventana actualmente establecidos en un editor de texto de solo lectura. También incluye un botón `QPushbutton` que cierra la ventana.

Reimplementamos el constructor para crear el botón « Close » y el editor de texto, así como la función ` QWidget::setWindowFlags()` para mostrar los nombres de los indicadores de ventana.

Ventana de vista previa que muestra los indicadores de la ventana

Implementación de la clase `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"));
}

En el constructor, primero creamos un ` QTextEdit ` y nos aseguramos de que sea de solo lectura.

También desactivamos cualquier salto de línea en el editor de texto mediante la función ` QTextEdit::setLineWrapMode()`. El resultado es que aparece una barra de desplazamiento horizontal cuando el nombre de un indicador de ventana supera el ancho del editor. Se trata de una solución razonable, ya que construimos el texto mostrado con saltos de línea incorporados. Si no se garantizaran los saltos de línea, quizá tendría más sentido utilizar otro ` QTextEdit::LineWrapMode `.

A continuación, creamos el botón « Close » y colocamos ambos widgets dentro de un ` QVBoxLayout ` antes de establecer el título de la ventana.

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

En nuestra reimplementación de la función ` setWindowFlags() `, primero configuramos los indicadores de los widgets mediante la función ` QWidget::setWindowFlags()`. A continuación, recorremos los indicadores de ventana disponibles y creamos un texto que contiene los nombres de los indicadores que coinciden con el parámetro ` flags `. Por último, mostramos el texto en el editor de texto de los widgets.

Proyecto de ejemplo en 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.