En esta página

QWindow Class

La clase QWindow representa una ventana en el sistema de ventanas subyacente. Más información...

Encabezado: #include <QWindow>
CMake: find_package(Qt6 REQUIRED COMPONENTS Gui)
target_link_libraries(mytarget PRIVATE Qt6::Gui)
qmake: QT += gui
Heredado de:QObject y QSurface
Heredado por:

QPaintDeviceWindow, ` QQuickWindow` y QVulkanWindow

Tipos públicos

enum AncestorMode { ExcludeTransients, IncludeTransients }
enum Visibility { Windowed, Minimized, Maximized, FullScreen, AutomaticVisibility, Hidden }

Propiedades

Funciones públicas

QWindow(QScreen *targetScreen = nullptr)
QWindow(QWindow *parent)
virtual ~QWindow()
QSize baseSize() const
Qt::ScreenOrientation contentOrientation() const
void create()
QCursor cursor() const
void destroy()
qreal devicePixelRatio() const
QString filePath() const
Qt::WindowFlags flags() const
virtual QObject *focusObject() const
QRect frameGeometry() const
QMargins frameMargins() const
QPoint framePosition() const
QRect geometry() const
int height() const
QIcon icon() const
bool isActive() const
bool isAncestorOf(const QWindow *child, QWindow::AncestorMode mode = IncludeTransients) const
bool isExposed() const
bool isModal() const
bool isTopLevel() const
bool isVisible() const
(since 6.0) QPointF mapFromGlobal(const QPointF &pos) const
QPoint mapFromGlobal(const QPoint &pos) const
(since 6.0) QPointF mapToGlobal(const QPointF &pos) const
QPoint mapToGlobal(const QPoint &pos) const
QRegion mask() const
int maximumHeight() const
QSize maximumSize() const
int maximumWidth() const
int minimumHeight() const
QSize minimumSize() const
int minimumWidth() const
Qt::WindowModality modality() const
qreal opacity() const
QWindow *parent(QWindow::AncestorMode mode = ExcludeTransients) const
QPoint position() const
void reportContentOrientationChange(Qt::ScreenOrientation orientation)
QSurfaceFormat requestedFormat() const
void resize(const QSize &newSize)
void resize(int w, int h)
(since 6.9) QMargins safeAreaMargins() const
QScreen *screen() const
void setBaseSize(const QSize &size)
void setCursor(const QCursor &cursor)
void setFilePath(const QString &filePath)
void setFlag(Qt::WindowType flag, bool on = true)
void setFlags(Qt::WindowFlags flags)
void setFormat(const QSurfaceFormat &format)
void setFramePosition(const QPoint &point)
(since 6.12) void setFramePosition(int x, int y)
void setIcon(const QIcon &icon)
bool setKeyboardGrabEnabled(bool grab)
void setMask(const QRegion &region)
void setMaximumSize(const QSize &size)
void setMinimumSize(const QSize &size)
void setModality(Qt::WindowModality modality)
bool setMouseGrabEnabled(bool grab)
void setOpacity(qreal level)
void setParent(QWindow *parent)
void setPosition(const QPoint &pt)
void setPosition(int posx, int posy)
void setScreen(QScreen *newScreen)
void setSizeIncrement(const QSize &size)
void setSurfaceType(QSurface::SurfaceType surfaceType)
void setTransientParent(QWindow *parent)
void setVisibility(QWindow::Visibility v)
void setVulkanInstance(QVulkanInstance *instance)
void setWindowState(Qt::WindowState state)
void setWindowStates(Qt::WindowStates state)
QSize sizeIncrement() const
QString title() const
QWindow *transientParent() const
Qt::WindowType type() const
void unsetCursor()
QWindow::Visibility visibility() const
QVulkanInstance *vulkanInstance() const
int width() const
WId winId() const
Qt::WindowState windowState() const
Qt::WindowStates windowStates() const
int x() const
int y() const

Funciones públicas reimplementadas

virtual QSurfaceFormat format() const override
virtual QSize size() const override
virtual QSurface::SurfaceType surfaceType() const override

Ranuras públicas

void alert(int msec)
bool close()
void hide()
void lower()
void raise()
void requestActivate()
void requestUpdate()
void setGeometry(const QRect &rect)
void setGeometry(int posx, int posy, int w, int h)
void setHeight(int arg)
void setMaximumHeight(int h)
void setMaximumWidth(int w)
void setMinimumHeight(int h)
void setMinimumWidth(int w)
void setTitle(const QString &)
void setVisible(bool visible)
void setWidth(int arg)
void setX(int arg)
void setY(int arg)
void show()
void showFullScreen()
void showMaximized()
void showMinimized()
void showNormal()
bool startSystemMove()
bool startSystemResize(Qt::Edges edges)

Señales

void activeChanged()
void contentOrientationChanged(Qt::ScreenOrientation orientation)
void flagsChanged(Qt::WindowFlags flags)
void focusObjectChanged(QObject *object)
void heightChanged(int arg)
void maximumHeightChanged(int arg)
void maximumWidthChanged(int arg)
void minimumHeightChanged(int arg)
void minimumWidthChanged(int arg)
void modalityChanged(Qt::WindowModality modality)
void opacityChanged(qreal opacity)
(since 6.9) void safeAreaMarginsChanged(QMargins margins)
void screenChanged(QScreen *screen)
void transientParentChanged(QWindow *transientParent)
void visibilityChanged(QWindow::Visibility visibility)
void visibleChanged(bool arg)
void widthChanged(int arg)
void windowStateChanged(Qt::WindowState windowState)
void windowTitleChanged(const QString &title)
void xChanged(int arg)
void yChanged(int arg)

Miembros públicos estáticos

QWindow *fromWinId(WId id)

Funciones protegidas

virtual void closeEvent(QCloseEvent*ev)
virtual void exposeEvent(QExposeEvent*ev)
virtual void focusInEvent(QFocusEvent*ev)
virtual void focusOutEvent(QFocusEvent*ev)
virtual void hideEvent(QHideEvent*ev)
virtual void keyPressEvent(QKeyEvent*ev)
virtual void keyReleaseEvent(QKeyEvent*ev)
virtual void mouseDoubleClickEvent(QMouseEvent*ev)
virtual void mouseMoveEvent(QMouseEvent*ev)
virtual void mousePressEvent(QMouseEvent*ev)
virtual void mouseReleaseEvent(QMouseEvent*ev)
virtual void moveEvent(QMoveEvent*ev)
virtual bool nativeEvent(const QByteArray&eventType, void*message, qintptr*result)
(since 6.0) virtual void paintEvent(QPaintEvent*ev)
virtual void resizeEvent(QResizeEvent*ev)
virtual void showEvent(QShowEvent*ev)
virtual void tabletEvent(QTabletEvent*ev)
virtual void touchEvent(QTouchEvent*ev)
virtual void wheelEvent(QWheelEvent*ev)

Funciones protegidas reimplementadas

virtual bool event(QEvent *ev) override

Descripción detallada

Una ventana a la que se le proporciona una ventana padre se convierte en una ventana hija nativa de dicha ventana padre.

Normalmente, una aplicación utilizará QWidget o QQuickView para su interfaz de usuario, y no QWindow directamente. No obstante, es posible renderizar directamente en una QWindow mediante QBackingStore o QOpenGLContext, cuando se desee reducir al mínimo las dependencias o cuando se quiera utilizar OpenGL directamente. Los ejemplos «Raster Window Example» y «OpenGL Window Example» son ejemplos de referencia útiles sobre cómo renderizar en una QWindow utilizando cualquiera de estos dos enfoques.

Gestión de recursos

Las ventanas pueden llegar a consumir mucha memoria. Una medida habitual es el producto de la anchura por la altura por la profundidad de color. Una ventana también puede incluir varios búferes para admitir el doble y el triple búfer, así como búferes de profundidad y de plantilla. Para liberar los recursos de memoria de una ventana, llama a la función ` destroy()`.

Orientación del contenido

QWindow dispone de la función reportContentOrientationChange() que se puede utilizar para especificar la disposición del contenido de la ventana en relación con la pantalla. La orientación del contenido es simplemente una indicación para el sistema de ventanas sobre la orientación en la que se encuentra el contenido de la ventana. Resulta útil cuando se desea mantener el mismo tamaño de ventana, pero rotar el contenido, especialmente al realizar animaciones de rotación entre diferentes orientaciones. El sistema de ventanas podría utilizar este valor para determinar la disposición de las ventanas emergentes o los cuadros de diálogo del sistema.

Visibilidad y exposición al sistema de ventanas

Por defecto, la ventana no está visible, y debes llamar a setVisible(true), o a show() o similar para hacerla visible. Para volver a ocultar una ventana, llama a setVisible(false) o a hide(). La propiedad «visible» describe el estado en el que la aplicación desea que se encuentre la ventana. Dependiendo del sistema subyacente, es posible que una ventana visible aún no se muestre en la pantalla. Podría, por ejemplo, estar cubierta por otras ventanas opacas o desplazada fuera del área física de la pantalla. En los sistemas de ventanas que cuentan con notificaciones de exposición, el accesor ` isExposed()` indica si la ventana debe considerarse directamente visible en pantalla. La función « exposeEvent » () se invoca cada vez que se invalida un área de la ventana, por ejemplo, debido a un cambio en la exposición del sistema de ventanas. En los sistemas de ventanas que no hacen visible esta información para la aplicación, « isExposed » () simplemente devolverá el mismo valor que « isVisible » ().

QWindow::Visibility La consulta realizada mediante ` visibility()` es una API de conveniencia que combina las funciones de `visible()` y ` windowStates()`.

Representación

Existen dos API de Qt que se pueden utilizar para renderizar contenido en una ventana: ` QBackingStore ` para renderizar con un ` QPainter ` y volcar el contenido a una ventana de tipo ` QSurface::RasterSurface`, y ` QOpenGLContext ` para renderizar con OpenGL en una ventana de tipo ` QSurface::OpenGLSurface`.

La aplicación puede comenzar a renderizar tan pronto como isExposed() devuelva true, y puede seguir renderizando hasta que isExposed() devuelva false. Para saber cuándo cambia isExposed(), reimplementa exposeEvent(). La ventana siempre recibirá un evento de redimensionamiento antes del primer evento de exposición.

Geometría inicial

Si no se inicializan el ancho y la altura de la ventana, esta obtendrá una geometría predeterminada razonable de la ventana de la plataforma. Si no se inicializa la posición, la ventana de la plataforma permitirá que el sistema de ventanas coloque la ventana. Por ejemplo, en X11, el gestor de ventanas suele realizar algún tipo de posicionamiento inteligente para intentar evitar que las ventanas nuevas oculten por completo a las ya existentes. Sin embargo, ` setGeometry()` inicializa tanto la posición como el tamaño, por lo que, si se desea un tamaño fijo pero una posición automática, se debe llamar a ` resize()` o ` setWidth()` y ` setHeight()` en su lugar.

Documentación sobre los tipos de miembros

enum QWindow::AncestorMode

Esta enumeración se utiliza para controlar si los padres transitorios deben considerarse antepasados o no.

ConstanteValorDescripción
QWindow::ExcludeTransients0Los padres transitorios no se consideran antepasados.
QWindow::IncludeTransients1Los padres transitorios se consideran antepasados.

enum QWindow::Visibility

Esta enumeración describe qué parte de la pantalla ocupa o debería ocupar la ventana.

ConstanteValorDescripción
QWindow::Windowed2La ventana ocupa parte de la pantalla, pero no necesariamente toda la pantalla. Este estado solo se dará en sistemas de ventanas que admitan la visualización simultánea de varias ventanas. En este estado, el usuario puede mover y cambiar el tamaño de la ventana manualmente, siempre que WindowFlags lo permita y que el sistema de ventanas lo admita.
QWindow::Minimized3La ventana se reduce a un acceso o icono en la barra de tareas, el dock, la lista de tareas o el escritorio, dependiendo de cómo gestione el sistema de ventanas las ventanas minimizadas.
QWindow::Maximized4La ventana ocupa toda la pantalla y la barra de título sigue siendo visible. En la mayoría de los sistemas de ventanas, este es el estado que se consigue al hacer clic en el botón de maximizar de la barra de herramientas.
QWindow::FullScreen5La ventana ocupa toda la pantalla, no se puede cambiar su tamaño y no tiene barra de título. En algunas plataformas que no admiten la visualización simultánea de varias ventanas, este puede ser el estado habitual cuando la ventana no está oculta.
QWindow::AutomaticVisibility1Esto significa asignar a la ventana un estado de visibilidad predeterminado, que puede ser a pantalla completa o en modo ventana, dependiendo de la plataforma. Se puede especificar como parámetro de la función ` setVisibility `, pero nunca se recuperará mediante el accesor de visibilidad.
QWindow::Hidden0La ventana no es visible de ninguna manera; sin embargo, puede recordar una visibilidad latente que se puede restaurar estableciendo `AutomaticVisibility`.

Documentación de la propiedad

[read-only] active : bool

Esta propiedad indica el estado activo de la ventana

Funciones de acceso:

bool isActive() const

Señal de notificación:

void activeChanged()

Véase también requestActivate().

contentOrientation : Qt::ScreenOrientation

Esta propiedad indica la orientación del contenido de la ventana

Se trata de una indicación para el gestor de ventanas por si necesita mostrar contenido adicional, como ventanas emergentes, cuadros de diálogo, barras de estado o elementos similares relacionados con la ventana.

La orientación recomendada es QScreen::orientation(), pero una aplicación no tiene por qué admitir todas las orientaciones posibles, por lo que puede optar por ignorar la orientación actual de la pantalla.

La diferencia entre la orientación de la ventana y la del contenido determina el ángulo de rotación del contenido. Se pueden utilizar QScreen::angleBetween(), QScreen::transformBetween() y QScreen::mapBetween() para calcular la transformación necesaria.

El valor por defecto es Qt::PrimaryOrientation

Funciones de acceso:

Qt::ScreenOrientation contentOrientation() const
void reportContentOrientationChange(Qt::ScreenOrientation orientation)

Señal de notificación:

void contentOrientationChanged(Qt::ScreenOrientation orientation)

flags : Qt::WindowFlags

Esta propiedad contiene los indicadores de la ventana

Los indicadores de ventana controlan el aspecto de la ventana en el sistema de ventanas, ya sea un cuadro de diálogo, una ventana emergente o una ventana normal, y si debe tener una barra de título, etc.

Los indicadores de ventana reales pueden diferir de los establecidos con setFlags() si no se han podido aplicar los indicadores solicitados.

Funciones de acceso:

Qt::WindowFlags flags() const
void setFlags(Qt::WindowFlags flags)

Señal del notificador:

void flagsChanged(Qt::WindowFlags flags)

Véase también setFlag().

height : int

Esta propiedad contiene la altura de la geometría de la ventana

Funciones de acceso:

int height() const
void setHeight(int arg)

Señal de notificación:

void heightChanged(int arg)

maximumHeight : int

Esta propiedad contiene la altura máxima de la geometría de la ventana

Funciones de acceso:

int maximumHeight() const
void setMaximumHeight(int h)

Señal de notificación:

void maximumHeightChanged(int arg)

maximumWidth : int

Esta propiedad contiene la anchura máxima de la geometría de la ventana

Funciones de acceso:

int maximumWidth() const
void setMaximumWidth(int w)

Señal de notificación:

void maximumWidthChanged(int arg)

minimumHeight : int

Esta propiedad contiene la altura mínima de la geometría de la ventana

Funciones de acceso:

int minimumHeight() const
void setMinimumHeight(int h)

Señal de notificación:

void minimumHeightChanged(int arg)

minimumWidth : int

Esta propiedad contiene la anchura mínima de la geometría de la ventana

Funciones de acceso:

int minimumWidth() const
void setMinimumWidth(int w)

Señal de notificación:

void minimumWidthChanged(int arg)

modality : Qt::WindowModality

Esta propiedad determina la modalidad de la ventana

Una ventana modal impide que otras ventanas reciban eventos de entrada. Qt admite dos tipos de modalidad: « Qt::WindowModal » y « Qt::ApplicationModal ».

Por defecto, esta propiedad es Qt::NonModal

Funciones de acceso:

Qt::WindowModality modality() const
void setModality(Qt::WindowModality modality)

Señal de notificación:

void modalityChanged(Qt::WindowModality modality)

Véase también Qt::WindowModality.

opacity : qreal

Esta propiedad determina la opacidad de la ventana en el sistema de ventanas.

Si el sistema de ventanas admite la opacidad de las ventanas, esta propiedad se puede utilizar para hacer que la ventana aparezca y desaparezca gradualmente, o para hacerla semitransparente.

Un valor de 1,0 o superior se considera totalmente opaco, mientras que un valor de 0,0 o inferior se considera totalmente transparente. Los valores intermedios representan distintos niveles de translucidez entre ambos extremos.

El valor por defecto es 1,0.

Funciones de acceso:

qreal opacity() const
void setOpacity(qreal level)

Señal de notificador:

void opacityChanged(qreal opacity)

title : QString

Esta propiedad contiene el título de la ventana en el sistema de ventanas

El título de la ventana puede aparecer en el área de título de los elementos decorativos de la ventana, dependiendo del sistema de ventanas y de los indicadores de la ventana. El sistema de ventanas también puede utilizarlo para identificar la ventana en otros contextos, como en el selector de tareas.

Funciones de acceso:

QString title() const
void setTitle(const QString &)

Señal de notificador:

void windowTitleChanged(const QString &title)

Véase también ` flags()`.

transientParent : QWindow*

Esta propiedad contiene la ventana de la que esta ventana es una ventana emergente transitoria

Esto indica al gestor de ventanas que esta ventana es un cuadro de diálogo o una ventana emergente en nombre de la ventana principal transitoria.

Para que la ventana se centre de forma predeterminada sobre su « parent » transitoria, dependiendo del gestor de ventanas, también puede ser necesario llamar a ` setFlags()` con un ` Qt::WindowType ` adecuado (como ` Qt::Dialog`).

Funciones de acceso:

QWindow *transientParent() const
void setTransientParent(QWindow *parent)

Señal de notificador:

void transientParentChanged(QWindow *transientParent)

Véase también parent().

visibility : Visibility

Esta propiedad almacena el estado de ocupación de pantalla de la ventana

La visibilidad indica si la ventana debe aparecer en el sistema de ventanas como normal, minimizada, maximizada, a pantalla completa u oculta.

Establecer la visibilidad en « AutomaticVisibility » significa asignar a la ventana un estado visible por defecto, que puede ser a pantalla completa o en modo ventana, dependiendo de la plataforma. Al leer la propiedad de visibilidad, siempre se obtendrá el estado real, nunca « AutomaticVisibility ».

El valor por defecto es «Hidden».

Funciones de acceso:

QWindow::Visibility visibility() const
void setVisibility(QWindow::Visibility v)

Señal de notificador:

void visibilityChanged(QWindow::Visibility visibility)

visible : bool

Esta propiedad se mantiene independientemente de si la ventana está visible o no

Esta propiedad controla la visibilidad de la ventana en el sistema de ventanas.

Por defecto, la ventana no está visible; debes llamar a `setVisible(true)`, ` show()` o algo similar para hacerla visible.

Nota: Ocultar una ventana no la elimina del sistema de ventanas, sino que simplemente la oculta. En los sistemas de ventanas que asignan un escritorio dedicado a las aplicaciones a pantalla completa (como macOS), ocultar una ventana a pantalla completa no eliminará ese escritorio, sino que lo dejará en blanco. Es posible que otra ventana de la misma aplicación se muestre a pantalla completa y ocupe ese escritorio. Utiliza ` QWindow::close ` para eliminar por completo una ventana del sistema de ventanas.

Funciones de acceso:

bool isVisible() const
void setVisible(bool visible)

Señal de notificador:

void visibleChanged(bool arg)

Véase también ` show()`.

width : int

Esta propiedad contiene el ancho de la geometría de la ventana

Funciones de acceso:

int width() const
void setWidth(int arg)

Señal de notificación:

void widthChanged(int arg)

x : int

Esta propiedad contiene la posición x de la geometría de la ventana

Funciones de acceso:

int x() const
void setX(int arg)

Señal de notificación:

void xChanged(int arg)

y : int

Esta propiedad contiene la posición en el eje Y de la geometría de la ventana

Funciones de acceso:

int y() const
void setY(int arg)

Señal de notificación:

void yChanged(int arg)

Documentación de funciones de miembro

[explicit] QWindow::QWindow(QScreen *targetScreen = nullptr)

Crea una ventana de nivel superior en el ` targetScreen`.

La ventana no se muestra hasta que se llama a setVisible(true), show() o algo similar.

Véase también setScreen().

[explicit] QWindow::QWindow(QWindow *parent)

Crea una ventana como hija de la ventana « parent » especificada.

La ventana quedará incrustada dentro de la ventana principal, y sus coordenadas serán relativas a esta.

La pantalla se hereda de la ventana principal.

Véase también setParent().

[virtual noexcept] QWindow::~QWindow()

Cierra la ventana.

[slot] void QWindow::alert(int msec)

Hace que se muestre una alerta durante msec milisegundos. Si msec es 0 (valor por defecto), la alerta se muestra indefinidamente hasta que la ventana vuelva a estar activa. Esta función no tiene ningún efecto en una ventana activa.

En estado de alerta, la ventana indica que requiere atención, por ejemplo, haciendo parpadear o rebotar la entrada de la barra de tareas.

QSize QWindow::baseSize() const

Devuelve el tamaño base de la ventana.

Véase también setBaseSize().

[slot] bool QWindow::close()

Cierra la ventana.

Esto cierra la ventana, lo que equivale a llamar a ` destroy()` y puede provocar el cierre de la aplicación. Devuelve ` true ` si se realiza correctamente, y `false` si tiene una ventana principal (en cuyo caso se debe cerrar la ventana de nivel superior).

Véanse también destroy(), QGuiApplication::quitOnLastWindowClosed() y closeEvent().

[virtual protected] void QWindow::closeEvent(QCloseEvent *ev)

Sobrescribe esta función para gestionar los eventos de cierre (ev).

La función se invoca cuando se solicita el cierre de la ventana. Llama a QEvent::ignore() al producirse el evento si deseas impedir que se cierre la ventana.

Véase también close().

void QWindow::create()

Asigna los recursos de la plataforma asociados a la ventana.

Es en este momento cuando el formato de superficie establecido mediante ` setFormat()` se resuelve en una superficie nativa real. Sin embargo, la ventana permanece oculta hasta que se llama a ` setVisible()`.

Ten en cuenta que normalmente no es necesario llamar a esta función directamente, ya que será llamada implícitamente por show(), setVisible(), winId() y otras funciones que requieran acceso a los recursos de la plataforma.

Llama a destroy() para liberar los recursos de la plataforma si es necesario.

Véase también destroy().

QCursor QWindow::cursor() const

la forma del cursor para esta ventana

Véase también setCursor() y unsetCursor().

void QWindow::destroy()

Libera los recursos de la plataforma nativa asociados a esta ventana.

Véase también ` create()`.

qreal QWindow::devicePixelRatio() const

Devuelve la relación entre los píxeles físicos y los píxeles independientes del dispositivo para la ventana. Este valor depende de la pantalla en la que se encuentre la ventana y puede variar cuando se desplaza la ventana.

La instancia ` QWindow ` recibe un evento de tipo ` QEvent::DevicePixelRatioChange ` cuando cambia la relación de píxeles del dispositivo.

Los valores habituales son 1,0 en pantallas normales y 2,0 en pantallas «Retina» de Apple.

Nota: En el caso de las ventanas que no están respaldadas por una ventana de plataforma —es decir, aquellas en las que no se ha llamado a create()—, la función utilizará como valor por defecto la relación de píxeles del dispositivo de la QScreen asociada.

Véase también QScreen::devicePixelRatio() y QEvent::DevicePixelRatioChange.

[override virtual protected] bool QWindow::event(QEvent *ev)

Reimplementa: ` QObject::event(QEvent *e)`.

Sobrescribe este método para gestionar cualquier evento (ev) enviado a la ventana. Devuelve true si el evento se ha reconocido y procesado.

Recuerda llamar a la versión de la clase base si deseas que los eventos de ratón, los eventos de teclado, los eventos de cambio de tamaño, etc., se dispachen como de costumbre.

[virtual protected] void QWindow::exposeEvent(QExposeEvent *ev)

El evento «expose» (ev) es enviado por el sistema de ventanas cuando una ventana pasa del estado «no expuesta» al estado «expuesta».

Una ventana expuesta es potencialmente visible para el usuario. Si la ventana se desplaza fuera de la pantalla, queda totalmente oculta por otra ventana, se minimiza o algo similar, es posible que se llame a esta función y que el valor de isExposed() cambie a «false». Puedes utilizar este evento para limitar las operaciones que consumen muchos recursos, como las animaciones, de modo que solo se ejecuten cuando la ventana esté expuesta.

Este evento no debe utilizarse para dibujar. Para gestionar el dibujo, implementa en su lugar paintEvent().

Siempre se enviará un evento de redimensionamiento antes del evento «expose» la primera vez que se muestre una ventana.

Véase también ` paintEvent()` y ` isExposed()`.

QString QWindow::filePath() const

el nombre del archivo al que corresponde esta ventana.

Véase también ` setFilePath()`.

[virtual protected] void QWindow::focusInEvent(QFocusEvent *ev)

Sobrescribe este método para gestionar el foco en los eventos (ev).

Los eventos de enfoque se envían cuando la ventana recibe el enfoque del teclado.

Véase también focusOutEvent().

[virtual] QObject *QWindow::focusObject() const

Devuelve el objeto ` QObject ` que será el receptor final de los eventos vinculados al foco, como los eventos de teclas.

[signal] void QWindow::focusObjectChanged(QObject *object)

Esta señal se emite cuando el receptor final de los eventos vinculados al foco se cambia a object.

Véase también focusObject().

[virtual protected] void QWindow::focusOutEvent(QFocusEvent *ev)

Sobrescribe este método para gestionar los eventos de pérdida de foco (ev).

Los eventos de pérdida de foco se envían cuando la ventana pierde el foco del teclado.

Véase también focusInEvent().

[override virtual] QSurfaceFormat QWindow::format() const

Reimplementa: ` QSurface::format()` const.

Devuelve el formato real de esta ventana.

Una vez creada la ventana, esta función devolverá el formato real de la superficie de la ventana. Puede diferir del formato solicitado si la plataforma no ha podido cumplir con dicho formato. También puede ser un superconjunto; por ejemplo, ciertos tamaños de búfer pueden ser mayores que los solicitados.

Nota: Dependiendo de la plataforma, ciertos valores de este formato de superficie pueden seguir conteniendo los valores solicitados, es decir, los valores que se han pasado a ` setFormat()`. Ejemplos típicos son la versión de OpenGL, el perfil y las opciones. Es posible que estos no se actualicen durante la llamada a ` create()`, ya que son específicos del contexto y una misma ventana puede utilizarse junto con varios contextos a lo largo de su ciclo de vida. Utiliza en su lugar el método `format()` de ` QOpenGLContext` para consultar dichos valores.

Véanse también setFormat(), create(), requestedFormat() y QOpenGLContext::format().

QRect QWindow::frameGeometry() const

Devuelve la geometría de la ventana, incluido su marco.

La geometría se refiere a la función virtualGeometry() de su pantalla.

Véase también geometry() y frameMargins().

QMargins QWindow::frameMargins() const

Devuelve los márgenes del marco que rodean la ventana.

Véase también geometry() y frameGeometry().

QPoint QWindow::framePosition() const

Devuelve la posición de la esquina superior izquierda de la ventana, incluido el marco de la misma.

Esto devuelve el mismo valor que frameGeometry().topLeft().

Véase también setFramePosition(), geometry() y frameGeometry().

[static] QWindow *QWindow::fromWinId(WId id)

Crea una representación local de una ventana generada por otro proceso o mediante el uso de bibliotecas nativas subyacentes a Qt.

Dado el identificador id de una ventana nativa, este método crea un objeto QWindow que puede utilizarse para representar la ventana al invocar métodos como setParent() y setTransientParent().

Esto puede utilizarse, en las plataformas que lo admitan, para incrustar un QWindow dentro de una ventana nativa, o para incrustar una ventana nativa dentro de un QWindow.

Si las ventanas externas no son compatibles o si la incrustación de la ventana nativa ha fallado en el complemento de la plataforma, esta función devuelve un ` nullptr`.

Nota: El ` QWindow ` resultante no debe utilizarse para manipular la ventana nativa subyacente (aparte de cambiar su padre) ni para observar cambios de estado de la ventana nativa. Cualquier compatibilidad con este tipo de operaciones es incidental, depende en gran medida de la plataforma y no se ha probado.

Véase también ` setParent()`.

QRect QWindow::geometry() const

Devuelve la geometría de la ventana, sin incluir el marco de la misma.

La geometría se refiere a la virtualGeometry() de su pantalla.

Véase también setGeometry(), frameMargins() y frameGeometry().

[slot] void QWindow::hide()

Oculta la ventana.

Equivale a llamar a setVisible(false).

Véase también ` show()` y ` setVisible()`.

[virtual protected] void QWindow::hideEvent(QHideEvent *ev)

Sobrescribe esta función para gestionar los eventos de ocultación (ev).

La función se invoca cuando la ventana ha solicitado que se la oculte en el sistema de ventanas.

QIcon QWindow::icon() const

Devuelve el icono de la ventana en el sistema de ventanas

Véase también setIcon().

bool QWindow::isActive() const

Devuelve « true » si la ventana está activa.

Este es el caso de la ventana que tiene el foco de entrada, así como de las ventanas que se encuentran en la misma cadena de padres o de padres transitorios que la ventana con el foco.

Normalmente, las ventanas activas deberían aparecer como tales desde el punto de vista del estilo.

Para obtener la ventana que tiene el foco actualmente, utiliza QGuiApplication::focusWindow().

Nota: Funcióngetter para la propiedad active.

Véase también requestActivate().

bool QWindow::isAncestorOf(const QWindow *child, QWindow::AncestorMode mode = IncludeTransients) const

Devuelve ` true ` si la ventana es un antecesor de la ventana dada ` child`. Si ` mode ` es ` IncludeTransients`, entonces los padres transitorios también se consideran antecesores.

bool QWindow::isExposed() const

Devuelve si esta ventana está visible en el sistema de ventanas.

Cuando la ventana no está expuesta, la aplicación la muestra, pero aún no aparece en el sistema de ventanas, por lo que la aplicación debe minimizar las animaciones y otras actividades gráficas.

Cada vez que cambia este valor, se envía un evento « exposeEvent()».

Véase también exposeEvent().

bool QWindow::isModal() const

Devuelve si la ventana es modal.

Una ventana modal impide que otras ventanas reciban entradas.

Véase también QWindow::modality.

bool QWindow::isTopLevel() const

Devuelve si la ventana es de nivel superior, es decir, si no tiene ninguna ventana principal.

[virtual protected] void QWindow::keyPressEvent(QKeyEvent *ev)

Sobrescribe este método para gestionar los eventos de pulsación de teclas (ev).

Véase también keyReleaseEvent().

[virtual protected] void QWindow::keyReleaseEvent(QKeyEvent *ev)

Sobrescribe este método para gestionar los eventos de liberación de teclas (ev).

Véase también keyPressEvent().

[slot] void QWindow::lower()

Bajar la ventana en el sistema de ventanas.

Solicita que la ventana se baje para que aparezca por debajo de otras ventanas.

[since 6.0] QPointF QWindow::mapFromGlobal(const QPointF &pos) const

Convierte las coordenadas globales de la pantalla pos en coordenadas de la ventana.

Esta función se introdujo en Qt 6.0.

Véase también mapToGlobal().

QPoint QWindow::mapFromGlobal(const QPoint &pos) const

Esta es una función sobrecargada.

[since 6.0] QPointF QWindow::mapToGlobal(const QPointF &pos) const

Convierte las coordenadas de la ventana pos en coordenadas globales de la pantalla. Por ejemplo, mapToGlobal(QPointF(0,0)) devolvería las coordenadas globales del píxel situado en la esquina superior izquierda de la ventana.

Esta función se introdujo en Qt 6.0.

Véase también mapFromGlobal().

QPoint QWindow::mapToGlobal(const QPoint &pos) const

Esta es una función sobrecargada.

QRegion QWindow::mask() const

Devuelve la máscara establecida en la ventana.

La máscara indica al sistema de ventanas que la aplicación no desea recibir entradas del ratón o táctiles fuera de la región especificada.

Véase también setMask().

QSize QWindow::maximumSize() const

Devuelve el tamaño máximo de la ventana.

Véase también ` setMaximumSize()`.

QSize QWindow::minimumSize() const

Devuelve el tamaño mínimo de la ventana.

Véase también setMinimumSize().

[signal] void QWindow::modalityChanged(Qt::WindowModality modality)

Esta señal se emite cuando la propiedad Qwindow::modality cambia a « modality ».

Nota: Señalde notificación para la propiedad « modality ».

[virtual protected] void QWindow::mouseDoubleClickEvent(QMouseEvent *ev)

Sobrescribe este método para gestionar los eventos de doble clic del ratón (ev).

Véanse también mousePressEvent() y QStyleHints::mouseDoubleClickInterval().

[virtual protected] void QWindow::mouseMoveEvent(QMouseEvent *ev)

Sobrescribe este método para gestionar los eventos de movimiento del ratón (ev).

[virtual protected] void QWindow::mousePressEvent(QMouseEvent *ev)

Sobrescribe este método para gestionar los eventos de pulsación del ratón (ev).

Véase también mouseReleaseEvent().

[virtual protected] void QWindow::mouseReleaseEvent(QMouseEvent *ev)

Sobrescribe este método para gestionar los eventos de liberación del ratón (ev).

Véase también mousePressEvent().

[virtual protected] void QWindow::moveEvent(QMoveEvent *ev)

Sobrescribe este método para gestionar los eventos de desplazamiento de la ventana (ev).

[virtual protected] bool QWindow::nativeEvent(const QByteArray &eventType, void *message, qintptr *result)

Sobrescribe este método para gestionar eventos dependientes de la plataforma. Se le pasarán los objetos ` eventType`, ` message ` y ` result`.

Esto podría hacer que tu aplicación no sea portátil.

Solo debe devolver «true» si se ha gestionado el evento.

[virtual protected, since 6.0] void QWindow::paintEvent(QPaintEvent *ev)

El evento «paint» (ev) lo envía el sistema de ventanas cada vez que es necesario volver a dibujar una zona de la ventana, por ejemplo, al mostrar la ventana por primera vez o cuando se descubren partes de la ventana al mover otra ventana.

Se espera que la aplicación realice el renderizado en la ventana en respuesta al evento de pintura, independientemente del estado de exposición de la ventana. Por ejemplo, puede enviarse un evento de pintura antes de que la ventana quede expuesta, para prepararla para su visualización por parte del usuario.

Esta función se introdujo en Qt 6.0.

Véase también exposeEvent().

QWindow *QWindow::parent(QWindow::AncestorMode mode = ExcludeTransients) const

Devuelve la ventana principal, si la hay.

Si ` mode ` es ` IncludeTransients`, se devuelve la ventana padre transitoria si no hay ninguna ventana padre.

Una ventana sin ventana principal se denomina ventana de nivel superior.

Véase también setParent().

QPoint QWindow::position() const

Devuelve la posición de la ventana en el escritorio, sin tener en cuenta el marco de la ventana

Nota: No todos los sistemas de ventanas admiten la configuración o la consulta de las posiciones de las ventanas de nivel superior. En dichos sistemas, es posible que el desplazamiento de ventanas mediante programación no surta efecto y que se devuelvan valores artificiales para las posiciones actuales, como QPoint(0, 0).

Véase también setPosition().

[slot] void QWindow::raise()

Elevar la ventana en el sistema de ventanas.

Solicita que la ventana se sitúe por encima de las demás.

[slot] void QWindow::requestActivate()

Solicita que se active la ventana, es decir, que reciba el foco del teclado.

Véase también isActive() y QGuiApplication::focusWindow().

[slot] void QWindow::requestUpdate()

Programa un evento « QEvent::UpdateRequest » para que se envíe a esta ventana.

El evento se envía sincronizado con la sincronización vertical (vsync) de la pantalla en aquellas plataformas en las que sea posible. De lo contrario, el evento se envía tras un retraso de, como máximo, 5 ms. Si la pantalla asociada a la ventana indica un refresh rate superior a 60 Hz, el intervalo se reduce a un valor inferior a 5. Este tiempo adicional sirve para dar al bucle de eventos un poco de tiempo de inactividad para recopilar eventos del sistema, y puede anularse mediante la variable de entorno QT_QPA_UPDATE_IDLE_TIME.

Al gestionar animaciones, esta función debe llamarse una sola vez una vez finalizado el dibujo. Llamar a esta función varias veces dará lugar a que se envíe un único evento a la ventana.

Las subclases de ` QWindow ` deben reimplementar ` event()` (), interceptar el evento y llamar al código de renderizado de la aplicación, para luego llamar a la implementación de la clase base.

Nota: La reimplementación de event() por parte de la subclase debe invocar la implementación de la clase base, a menos que se tenga la certeza absoluta de que el evento no necesita ser gestionado por la clase base. Por ejemplo, la implementación predeterminada de esta función depende de los eventos QEvent::Timer. Por lo tanto, filtrarlos impediría la entrega de los eventos de actualización.

QSurfaceFormat QWindow::requestedFormat() const

Devuelve el formato de superficie solicitado para esta ventana.

Si la implementación de la plataforma no admite el formato solicitado, el formato solicitado (requestedFormat) diferirá del formato real de la ventana.

Este es el valor establecido con ` setFormat()`.

Véanse también setFormat() y format().

void QWindow::resize(const QSize &newSize)

Establece el tamaño de la ventana, sin contar el marco, en newSize

Véase también size() y geometry().

void QWindow::resize(int w, int h)

Establece el tamaño de la ventana, sin incluir el marco, en un objeto ` QSize ` creado a partir del ancho ` w ` y la altura h

Para cambiar el tamaño de las ventanas de forma interactiva, consulta startSystemResize().

Véase también ` size()` y ` geometry()`.

[virtual protected] void QWindow::resizeEvent(QResizeEvent *ev)

Sobrescribe este método para gestionar los eventos de cambio de tamaño (ev).

El evento de cambio de tamaño se activa cada vez que se modifica el tamaño de la ventana en el sistema de ventanas, ya sea directamente a través del sistema de ventanas al responder a una solicitud de setGeometry() o resize(), o indirectamente cuando el usuario cambia manualmente el tamaño de la ventana.

[since 6.9] QMargins QWindow::safeAreaMargins() const

Devuelve los márgenes del área segura de la ventana.

El área segura representa la parte de la ventana en la que se puede colocar contenido de forma segura, sin riesgo de que quede oculto por otros elementos de la interfaz de usuario —como las interfaces de usuario del sistema— ni de que entre en conflicto con ellos.

Los márgenes son relativos a la geometría interna de la ventana, es decir, QRect(0, 0, width(), height()).

void PaintDeviceWindow::paintEvent(QPaintEvent *)
{
    QPainter painter(this);
    QRect rect(0, 0, width(), height());
    painter.fillRect(rect, QGradient::SunnyMorning);
    painter.fillRect(rect - safeAreaMargins(), QGradient::DustyGrass);
}

Esta función se introdujo en Qt 6.9.

Véanse también geometry() y safeAreaMarginsChanged().

[signal, since 6.9] void QWindow::safeAreaMarginsChanged(QMargins margins)

Esta señal se emite cuando los márgenes del área segura cambian a margins.

Esta función se introdujo en Qt 6.9.

Véase también safeAreaMargins().

QScreen *QWindow::screen() const

Devuelve la pantalla en la que se muestra la ventana, o «null» si no hay ninguna.

En el caso de las ventanas secundarias, devuelve la pantalla de la ventana de nivel superior correspondiente.

Véanse también setScreen() y QScreen::virtualSiblings().

[signal] void QWindow::screenChanged(QScreen *screen)

Esta señal se emite cuando cambia el valor de « screen » de una ventana, ya sea al establecerlo explícitamente con la función « setScreen()», o de forma automática cuando se elimina la pantalla de la ventana.

void QWindow::setBaseSize(const QSize &size)

Establece el size o base de la ventana.

El tamaño base se utiliza para calcular un tamaño adecuado para la ventana si esta define sizeIncrement().

Véase también setMinimumSize(), setMaximumSize(), setSizeIncrement() y baseSize().

void QWindow::setCursor(const QCursor &cursor)

Establecer la forma del cursor para esta ventana

El ratón cursor adoptará esta forma cuando se sitúe sobre esta ventana, a menos que se haya definido un cursor de anulación. Consulte list of predefined cursor objects para ver una selección de formas útiles.

Si no se ha configurado ningún cursor, o tras llamar a unsetCursor(), se utiliza el cursor de la ventana principal.

Por defecto, el cursor tiene la forma Qt::ArrowCursor.

Algunas implementaciones de ventanas subyacentes restablecerán el cursor si este sale de una ventana, incluso si el ratón está capturado. Si desea establecer un cursor para todas las ventanas, incluso cuando se encuentre fuera de la ventana, considere la función QGuiApplication::setOverrideCursor().

Véase también ` cursor()` y ` QGuiApplication::setOverrideCursor()`.

void QWindow::setFilePath(const QString &filePath)

Establece el nombre del archivo que representa esta ventana.

Es posible que el sistema de ventanas utilice filePath para mostrar la ruta del documento que representa esta ventana en la barra de mosaicos.

Véase también filePath().

void QWindow::setFlag(Qt::WindowType flag, bool on = true)

Establece el indicador de ventana « flag » en esta ventana si « on » es verdadero; en caso contrario, desactiva el indicador.

Véanse también setFlags(), flags() y type().

void QWindow::setFormat(const QSurfaceFormat &format)

Establece el formato de la superficie de la ventana format.

El formato determina propiedades como la profundidad de color, el alfa, el tamaño de los búferes de profundidad y de plantilla, etc. Por ejemplo, para dar a una ventana un fondo transparente (siempre que el sistema de ventanas admita la composición y que el resto del contenido de la ventana no la vuelva a hacer opaca):

QSurfaceFormat format;
format.setAlphaBufferSize(8);
window.setFormat(format);

El formato de la superficie se resolverá en la función ` create()`. Llamar a esta función después de haber llamado a ` create()` no volverá a resolver el formato de la superficie nativa.

Cuando el formato no se establezca explícitamente mediante esta función, se utilizará el formato devuelto por QSurfaceFormat::defaultFormat(). Esto significa que, al haber varias ventanas, las llamadas individuales a esta función pueden sustituirse por una única llamada a QSurfaceFormat::setDefaultFormat() antes de crear la primera ventana.

Véanse también format(), create(), destroy() y QSurfaceFormat::setDefaultFormat().

void QWindow::setFramePosition(const QPoint &point)

Establece la posición superior izquierda de la ventana (point), incluido el marco de la misma.

La posición se refiere a la virtualGeometry() de su pantalla.

Véase también framePosition(), setGeometry() y frameGeometry().

[since 6.12] void QWindow::setFramePosition(int x, int y)

Establece la posición superior izquierda de la ventana, incluido su marco, en x, y

La posición se refiere a la geometría virtual (virtualGeometry()) de su pantalla.

Esta función se introdujo en Qt 6.12.

Véase también setGeometry() y frameGeometry().

[slot] void QWindow::setGeometry(const QRect &rect)

Establece la geometría de la ventana, excluyendo su marco, en ` rect`.

La geometría se refiere a la función virtualGeometry() de su pantalla.

Nota: Esta ranura está sobrecargada. Para conectarse a esta ranura:

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        window, qOverload(&QWindow::setGeometry));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        window, [receiver = window](const QRect &rect) { receiver->setGeometry(rect); });
Para ver más ejemplos y métodos, consulta «Conexión a ranuras sobrecargadas».

Véase también ` geometry()`.

[slot] void QWindow::setGeometry(int posx, int posy, int w, int h)

Establece la geometría de la ventana, excluyendo su marco, como un rectángulo construido a partir de posx, posy, w y h.

La geometría se refiere a la virtualGeometry() de su pantalla.

Nota: Esta ranura está sobrecargada. Para conectarse a esta ranura:

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        window, qOverload(&QWindow::setGeometry));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        window, [receiver = window](int posx, int posy, int w, int h) { receiver->setGeometry(posx, posy, w, h); });
Para ver más ejemplos y enfoques, consulta «Conexión a ranuras sobrecargadas».

Véase también ` geometry()`.

void QWindow::setIcon(const QIcon &icon)

Establece el icono de ventana ( icon ) en el sistema de ventanas

El icono de la ventana puede ser utilizado por el sistema de ventanas, por ejemplo, para decorar la ventana o en el selector de tareas.

Nota: En macOS, el icono de la barra de título de la ventana está pensado para ventanas que representan documentos, y solo aparecerá si también se ha establecido una ruta de archivo.

Véase también ` icon()` y ` setFilePath()`.

bool QWindow::setKeyboardGrabEnabled(bool grab)

Establece si se debe habilitar o no la captura del teclado (grab).

Si el valor devuelto es verdadero, la ventana recibe todos los eventos de teclado hasta que se llame a setKeyboardGrabEnabled(false); las demás ventanas no reciben ningún evento de teclado. Los eventos del ratón no se ven afectados. Utiliza setMouseGrabEnabled() si deseas bloquearlos.

Véase también setMouseGrabEnabled().

void QWindow::setMask(const QRegion &region)

Establece la máscara de la ventana.

La máscara indica al sistema de ventanas que la aplicación no desea recibir entradas del ratón o táctiles fuera del área especificada region.

El gestor de ventanas puede optar por mostrar o no las áreas de la ventana que no estén incluidas en la máscara; por lo tanto, es responsabilidad de la aplicación dejar transparentes las áreas que no formen parte de la máscara.

Véase también mask().

void QWindow::setMaximumSize(const QSize &size)

Establece el tamaño máximo de la ventana.

Esto sirve de indicación al gestor de ventanas para que evite cambiar el tamaño por encima del especificado en size.

Véase también setMinimumSize() y maximumSize().

void QWindow::setMinimumSize(const QSize &size)

Establece el tamaño mínimo de la ventana.

Esto sirve de indicación al gestor de ventanas para que evite que el tamaño se reduzca por debajo del especificado en size.

Véanse también setMaximumSize() y minimumSize().

bool QWindow::setMouseGrabEnabled(bool grab)

Establece si se debe habilitar o no la función de «mouse grab» (grab).

Si el valor devuelto es «true», la ventana recibe todos los eventos del ratón hasta que se llame a setMouseGrabEnabled(false); el resto de ventanas no reciben ningún evento del ratón. Los eventos del teclado no se ven afectados. Utiliza setKeyboardGrabEnabled() si deseas bloquearlos.

Véase también ` setKeyboardGrabEnabled()`.

void QWindow::setParent(QWindow *parent)

Establece la ventana « parent ». De este modo, el sistema de ventanas gestionará el recorte de la ventana, de modo que quede recortada a la ventana « parent ».

Si se establece ` parent ` como ` nullptr `, la ventana pasará a ser una ventana de nivel superior.

Si parent es una ventana creada mediante fromWinId(), la ventana actual se incrustará dentro de parent, siempre que la plataforma lo admita.

Véase también parent().

void QWindow::setPosition(const QPoint &pt)

Establecer la posición de la ventana en el escritorio en pt

La posición se refiere a la geometría virtual (virtualGeometry()) de su pantalla.

Para mover ventanas de forma interactiva, véase startSystemMove(). Para cambiar el tamaño de las ventanas de forma interactiva, véase startSystemResize().

Nota: No todos los sistemas de ventanas admiten la configuración o consulta de las posiciones de las ventanas de nivel superior. En dichos sistemas, el desplazamiento de ventanas mediante programación puede no surtir efecto, y es posible que se devuelvan valores artificiales para las posiciones actuales, como QPoint(0, 0).

Véase también position() y startSystemMove().

void QWindow::setPosition(int posx, int posy)

Establece la posición de la ventana en el escritorio en posx, posy

La posición se refiere a la geometría virtual (virtualGeometry()) de su pantalla.

Véase también position().

void QWindow::setScreen(QScreen *newScreen)

Establece la pantalla en la que debe mostrarse la ventana.

Si la ventana ya se ha creado, se volverá a crear en newScreen.

Nota: Si la pantalla forma parte de un escritorio virtual con varias pantallas, la ventana no se moverá automáticamente a newScreen. Para colocar la ventana en relación con la pantalla, utiliza la posición topLeft() de la pantalla.

Esta función solo funciona para ventanas de nivel superior.

Véase también ` screen()` y ` QScreen::virtualSiblings()`.

void QWindow::setSizeIncrement(const QSize &size)

Establece el incremento de tamaño (size) de la ventana.

Cuando el usuario cambia el tamaño de la ventana, este se modificará en pasos de sizeIncrement().width() píxeles en horizontal y sizeIncrement().height() píxeles en vertical, tomando como referencia baseSize().

Por defecto, esta propiedad contiene un tamaño con anchura y altura iguales a cero.

Es posible que el sistema de ventanas no admita incrementos de tamaño.

Véase también sizeIncrement(), setBaseSize(), setMinimumSize() y setMaximumSize().

void QWindow::setSurfaceType(QSurface::SurfaceType surfaceType)

Establece el tipo de renderizado « surfaceType » de la ventana.

Especifica si la ventana está destinada al renderizado ráster con QBackingStore o al renderizado OpenGL con QOpenGLContext.

El « surfaceType » se utilizará cuando se cree la superficie nativa en la función « create()». Llamar a esta función después de que se haya creado la superficie nativa requiere llamar a « destroy()» y « create()» para liberar la superficie nativa anterior y crear una nueva.

Véase también surfaceType(), QBackingStore, QOpenGLContext, create() y destroy().

void QWindow::setVulkanInstance(QVulkanInstance *instance)

Asocia esta ventana al ` instance` de Vulkan especificado.

instance Debe seguir siendo válido mientras exista esta instancia de QWindow.

Véase también vulkanInstance().

void QWindow::setWindowState(Qt::WindowState state)

Establecer el estado de ocupación de pantalla de la ventana

La ventana « state » indica si la ventana aparece en el sistema de ventanas como maximizada, minimizada, a pantalla completa o normal.

El valor de enumeración Qt::WindowActive no es un parámetro válido.

Véase también windowState(), showNormal(), showFullScreen(), showMinimized(), showMaximized() y setWindowStates().

void QWindow::setWindowStates(Qt::WindowStates state)

Establecer el estado de ocupación de pantalla de la ventana

La ventana « state » indica si la ventana aparece en el sistema de ventanas como maximizada, minimizada y/o a pantalla completa.

La ventana puede encontrarse en una combinación de varios estados. Por ejemplo, si la ventana está minimizada y maximizada a la vez, aparecerá minimizada, pero al hacer clic en su icono de la barra de tareas se restablecerá al estado maximizado.

No se debe establecer el valor de la enumeración ` Qt::WindowActive `.

Véase también windowStates(), showNormal(), showFullScreen(), showMinimized() y showMaximized().

[slot] void QWindow::show()

Muestra la ventana.

En el caso de las ventanas secundarias, esto equivale a llamar a showNormal(). En los demás casos, equivale a llamar a showFullScreen(), showMaximized() o showNormal(), dependiendo del comportamiento predeterminado de la plataforma para el tipo de ventana y los indicadores.

Véase también showFullScreen(), showMaximized(), showNormal(), hide(), QStyleHints::showIsFullScreen() y flags().

[virtual protected] void QWindow::showEvent(QShowEvent *ev)

Sobrescribe esta función para gestionar los eventos de visualización (ev).

La función se invoca cuando la ventana ha solicitado hacerse visible.

Si el sistema de ventanas muestra la ventana correctamente, a continuación se producirá un evento de cambio de tamaño y un evento de exposición.

[slot] void QWindow::showFullScreen()

Muestra la ventana a pantalla completa.

Equivale a llamar a ` setWindowStates` (Qt::WindowFullScreen) y, a continuación, a ` setVisible` (true).

Consulta la documentación de QWidget::showFullScreen() para conocer las consideraciones y limitaciones específicas de cada plataforma.

Véanse también setWindowStates() y setVisible().

[slot] void QWindow::showMaximized()

Muestra la ventana maximizada.

Equivale a llamar a ` setWindowStates` (Qt::WindowMaximized) y, a continuación, a ` setVisible(true)`.

Véase también setWindowStates() y setVisible().

[slot] void QWindow::showMinimized()

Muestra la ventana minimizada.

Equivale a llamar a ` setWindowStates` (Qt::WindowMinimized) y, a continuación, a ` setVisible(true)`.

Véase también setWindowStates() y setVisible().

[slot] void QWindow::showNormal()

Muestra la ventana de forma normal, es decir, ni maximizada, ni minimizada, ni a pantalla completa.

Equivale a llamar a ` setWindowStates` (Qt::WindowNoState) y, a continuación, a ` setVisible(true)`.

Véase también setWindowStates() y setVisible().

[override virtual] QSize QWindow::size() const

Reimplementa: ` QSurface::size()` const.

Devuelve el tamaño de la ventana, sin incluir el marco de la misma

Véase también resize().

QSize QWindow::sizeIncrement() const

Devuelve el incremento de tamaño de la ventana.

Véase también ` setSizeIncrement()`.

[slot] bool QWindow::startSystemMove()

Iniciar una operación de desplazamiento específica del sistema

Al llamar a este método, se iniciará una operación interactiva de desplazamiento de la ventana en aquellas plataformas que lo admitan. El comportamiento real puede variar en función de la plataforma. Por lo general, hará que la ventana siga al cursor del ratón hasta que se suelte un botón del ratón.

En las plataformas que lo admiten, este método de desplazamiento de ventanas es preferible a ` setPosition`, ya que permite un aspecto y un comportamiento más nativos a la hora de mover ventanas; por ejemplo, permite que el gestor de ventanas ajuste esta ventana contra otras ventanas, o que se produzcan comportamientos especiales de mosaico o redimensionamiento con animaciones al arrastrarla hasta el borde de la pantalla. Además, en algunas plataformas, como Wayland, no se admite ` setPosition `, por lo que esta es la única forma en que la aplicación puede influir en su posición.

Devuelve «true» si el sistema admite la operación.

[slot] bool QWindow::startSystemResize(Qt::Edges edges)

Iniciar una operación de cambio de tamaño específica del sistema

Al llamar a este método, se iniciará una operación interactiva de cambio de tamaño de la ventana en aquellas plataformas que lo admitan. El comportamiento real puede variar en función de la plataforma. Por lo general, hará que la ventana cambie de tamaño de modo que su borde siga al cursor del ratón.

En las plataformas que lo admiten, este método de cambio de tamaño de ventanas es preferible a ` setGeometry`, ya que permite un aspecto y un comportamiento más nativos a la hora de cambiar el tamaño de las ventanas; por ejemplo, permite que el gestor de ventanas ajuste esta ventana a otras ventanas, o que se produzca un comportamiento especial de cambio de tamaño con animaciones al arrastrarla hasta el borde de la pantalla.

edges Debe ser un único borde o dos bordes adyacentes (una esquina). No se admiten otros valores.

Devuelve «true» si el sistema admite la operación.

[override virtual] QSurface::SurfaceType QWindow::surfaceType() const

Reimplementa: QSurface::surfaceType() const.

Devuelve el tipo de superficie de la ventana.

Véase también setSurfaceType().

[virtual protected] void QWindow::tabletEvent(QTabletEvent *ev)

Sobrescribe este método para gestionar los eventos de pulsación, desplazamiento y liberación en tabletas (ev).

Los eventos de entrada y salida por proximidad no se envían a las ventanas, sino que se transmiten a la instancia de la aplicación.

[virtual protected] void QWindow::touchEvent(QTouchEvent *ev)

Sobrescribe este método para gestionar los eventos táctiles (ev).

Qt::WindowType QWindow::type() const

Devuelve el tipo de la ventana.

Devuelve la parte de los indicadores de la ventana que indica si se trata de un cuadro de diálogo, una información sobre herramientas, una ventana emergente, una ventana normal, etc.

Véase también flags() y setFlags().

void QWindow::unsetCursor()

Restablece el cursor de flecha predeterminado para esta ventana.

QVulkanInstance *QWindow::vulkanInstance() const

Devuelve la instancia de Vulkan asociada, si se ha definido alguna; en caso contrario, devuelve « nullptr ».

Véase también setVulkanInstance().

[virtual protected] void QWindow::wheelEvent(QWheelEvent *ev)

Sobrescribe este método para gestionar los eventos de la rueda del ratón u otras ruedas (ev).

WId QWindow::winId() const

Devuelve el identificador de plataforma de la ventana.

Nota: Esta función provocará la creación de la ventana de la plataforma si aún no existe. Devuelve 0 si falla la creación de la ventana de la plataforma.

En las plataformas en las que este identificador pueda resultar útil, el valor devuelto representará de forma única la ventana dentro de la pantalla correspondiente.

Véase también screen().

Qt::WindowState QWindow::windowState() const

el estado de ocupación de la pantalla de la ventana

Véase también setWindowState() y windowStates().

[signal] void QWindow::windowStateChanged(Qt::WindowState windowState)

Esta señal se emite cuando cambia el ` windowState `, ya sea al establecerlo explícitamente con ` setWindowStates()` o de forma automática cuando el usuario hace clic en uno de los botones de la barra de título o por otros medios.

Qt::WindowStates QWindow::windowStates() const

el estado de ocupación de la pantalla de la ventana

La ventana puede encontrarse en una combinación de varios estados. Por ejemplo, si la ventana está minimizada y maximizada al mismo tiempo, aparecerá minimizada, pero al hacer clic en su icono de la barra de tareas se restablecerá al estado maximizado.

Véase también setWindowStates().

© 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.