QQuickWindow Class
La clase QQuickWindow proporciona la ventana para mostrar una escena gráfica QML. Más información...
| Encabezado: | #include <QQuickWindow> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Quick) target_link_libraries(mytarget PRIVATE Qt6::Quick) |
| qmake: | QT += quick |
| En QML: | Window |
| Heredado de: | QWindow |
| Heredado por: |
Tipos públicos
| struct | GraphicsStateInfo |
| enum | CreateTextureOption { TextureHasAlphaChannel, TextureHasMipmaps, TextureOwnsGLTexture, TextureCanUseAtlas, TextureIsOpaque } |
| flags | CreateTextureOptions |
| enum | RenderStage { BeforeSynchronizingStage, AfterSynchronizingStage, BeforeRenderingStage, AfterRenderingStage, AfterSwapStage, NoStage } |
| enum | SceneGraphError { ContextNotAvailable } |
| enum | TextRenderType { QtTextRendering, NativeTextRendering, CurveTextRendering } |
Propiedades
|
|
Funciones públicas
| QQuickWindow(QQuickRenderControl *control) | |
| QQuickWindow(QWindow *parent = nullptr) | |
| virtual | ~QQuickWindow() override |
| QQuickItem * | activeFocusItem() const |
| void | beginExternalCommands() |
| QColor | color() const |
| QQuickItem * | contentItem() const |
| QSGImageNode * | createImageNode() const |
| QSGNinePatchNode * | createNinePatchNode() const |
| QSGRectangleNode * | createRectangleNode() const |
(since 6.7) QSGTextNode * | createTextNode() const |
| QSGTexture * | createTextureFromImage(const QImage &image, QQuickWindow::CreateTextureOptions options) const |
| QSGTexture * | createTextureFromImage(const QImage &image) const |
(since 6.6) QSGTexture * | createTextureFromRhiTexture(QRhiTexture *texture, QQuickWindow::CreateTextureOptions options = {}) const |
| qreal | effectiveDevicePixelRatio() const |
| void | endExternalCommands() |
| QImage | grabWindow() |
(since 6.0) QQuickGraphicsConfiguration | graphicsConfiguration() const |
(since 6.0) QQuickGraphicsDevice | graphicsDevice() const |
| const QQuickWindow::GraphicsStateInfo & | graphicsStateInfo() |
| QQmlIncubationController * | incubationController() const |
| bool | isPersistentGraphics() const |
| bool | isPersistentSceneGraph() const |
| bool | isSceneGraphInitialized() const |
(since 6.0) QQuickRenderTarget | renderTarget() const |
| QSGRendererInterface * | rendererInterface() const |
(since 6.6) QRhi * | rhi() const |
| void | scheduleRenderJob(QRunnable *job, QQuickWindow::RenderStage stage) |
| void | setColor(const QColor &color) |
(since 6.0) void | setGraphicsConfiguration(const QQuickGraphicsConfiguration &config) |
(since 6.0) void | setGraphicsDevice(const QQuickGraphicsDevice &device) |
| void | setPersistentGraphics(bool persistent) |
| void | setPersistentSceneGraph(bool persistent) |
(since 6.0) void | setRenderTarget(const QQuickRenderTarget &target) |
(since 6.6) QRhiSwapChain * | swapChain() const |
Funciones públicas reimplementadas
| virtual QAccessibleInterface * | accessibleRoot() const override |
Ranuras públicas
| void | releaseResources() |
| void | update() |
Señales
| void | activeFocusItemChanged() |
| void | afterAnimating() |
(since 6.0) void | afterFrameEnd() |
| void | afterRenderPassRecording() |
| void | afterRendering() |
| void | afterSynchronizing() |
(since 6.0) void | beforeFrameBegin() |
| void | beforeRenderPassRecording() |
| void | beforeRendering() |
| void | beforeSynchronizing() |
| void | colorChanged(const QColor &) |
(since 6.11) void | devicePixelRatioChanged() |
| void | frameSwapped() |
| void | sceneGraphAboutToStop() |
| void | sceneGraphError(QQuickWindow::SceneGraphError error, const QString &message) |
| void | sceneGraphInitialized() |
| void | sceneGraphInvalidated() |
Miembros públicos estáticos
(since 6.0) QSGRendererInterface::GraphicsApi | graphicsApi() |
| bool | hasDefaultAlphaBuffer() |
| QString | sceneGraphBackend() |
| void | setDefaultAlphaBuffer(bool useAlpha) |
(since 6.0) void | setGraphicsApi(QSGRendererInterface::GraphicsApi api) |
| void | setSceneGraphBackend(const QString &backend) |
| void | setTextRenderType(QQuickWindow::TextRenderType renderType) |
| QQuickWindow::TextRenderType | textRenderType() |
Funciones protegidas reimplementadas
| virtual void | closeEvent(QCloseEvent *e) override |
| virtual bool | event(QEvent *event) override |
| virtual void | exposeEvent(QExposeEvent *) override |
| virtual void | focusInEvent(QFocusEvent *ev) override |
| virtual void | focusOutEvent(QFocusEvent *ev) override |
| virtual void | hideEvent(QHideEvent *) override |
| virtual void | keyPressEvent(QKeyEvent *e) override |
| virtual void | keyReleaseEvent(QKeyEvent *e) override |
| virtual void | mouseDoubleClickEvent(QMouseEvent *event) override |
| virtual void | mouseMoveEvent(QMouseEvent *event) override |
| virtual void | mousePressEvent(QMouseEvent *event) override |
| virtual void | mouseReleaseEvent(QMouseEvent *event) override |
| virtual void | resizeEvent(QResizeEvent *ev) override |
| virtual void | showEvent(QShowEvent *) override |
| virtual void | tabletEvent(QTabletEvent *event) override |
| virtual void | wheelEvent(QWheelEvent *event) override |
Descripción detallada
QQuickWindow proporciona la gestión gráfica de escenas necesaria para interactuar con una escena de QQuickItems y mostrarla.
Una QQuickWindow siempre tiene un único elemento raíz invisible. Para añadir elementos a esta ventana, cambia la relación de parentesco de los elementos para que apunten al elemento raíz o a un elemento ya existente en la escena.
Para visualizar fácilmente una escena desde un archivo QML, consulta QQuickView.
Representación
QQuickWindow utiliza un grafo de escena para representar lo que debe renderizarse. Este grafo de escena está desconectado de la escena QML y, dependiendo de la implementación de la plataforma, puede ejecutarse en otro hilo. Dado que el grafo de escena de renderizado funciona de forma independiente de la escena QML, también puede liberarse por completo sin afectar al estado de la escena QML.
La señal sceneGraphInitialized() se emite en el hilo de renderizado antes de que la escena QML se renderice en pantalla por primera vez. Si el grafo de escena de renderizado se ha liberado, la señal se emitirá de nuevo antes de que se renderice el siguiente fotograma. Una ventana QQuickWindow visible en pantalla está controlada internamente por un ` render loop`, del que existen múltiples implementaciones en el grafo de escena. Para obtener más detalles sobre el proceso de renderizado del grafo de escena, consulta «Qt Quick Scene Graph».
Por defecto, una QQuickWindow se renderiza utilizando una API de gráficos 3D acelerada, como OpenGL o Vulkan. Consulte Adaptaciones del grafo de escena para obtener una descripción detallada de los backends del grafo de escena y las API gráficas compatibles.
Advertencia: Es fundamental que las operaciones gráficas y la interacción con el grafo de escena se produzcan exclusivamente en el hilo de renderizado, principalmente durante la fase updatePaintNode().
Advertencia: Dado que muchas de las señales relacionadas con el renderizado se emiten desde el hilo de renderizado, las conexiones deben realizarse utilizando ` Qt::DirectConnection`.
Integración con API de gráficos 3D acelerados
Es posible integrar llamadas a OpenGL, Vulkan, Metal o Direct3D 11 directamente en QQuickWindow, siempre que tanto QQuickWindow como el grafo de escena subyacente se rendericen utilizando la misma API. Para acceder a objetos gráficos nativos, como identificadores de dispositivos u objetos de contexto, utiliza ` QSGRendererInterface`. Se puede consultar una instancia de ` QSGRendererInterface ` desde `QQuickWindow` llamando a ` rendererInterface()`. Los elementos que permiten esta integración son las señales ` beforeRendering()`, ` beforeRenderPassRecording()`, ` afterRenderPassRecording()` y otras relacionadas. Estas permiten renderizar capas subyacentes o superpuestas. Como alternativa, QNativeInterface::QSGOpenGLTexture, QNativeInterface::QSGVulkanTexture y otras clases similares permiten envolver un objeto de textura o imagen nativo existente en un QSGTexture que luego se puede utilizar con el grafo de escena.
Renderización sin aceleración
También hay disponible una ruta de renderizado limitada y basada exclusivamente en software. Con el backend software, no están disponibles varias funciones de Qt Quick; los elementos QML que dependan de ellas no se renderizarán en absoluto. Al mismo tiempo, esto permite que QQuickWindow sea funcional incluso en sistemas en los que no exista ninguna API de gráficos 3D disponible. Consulta «Adaptación de software deQt Quick » para obtener más detalles.
Representación redirigida
Una QQuickWindow no tiene por qué estar respaldada por una ventana nativa en pantalla. El renderizado puede redirigirse hacia un destino de renderizado personalizado, como una textura nativa determinada. Esto se consigue en combinación con la clase QQuickRenderControl y funciones como setRenderTarget(), setGraphicsDevice() y setGraphicsConfiguration().
En este caso, QQuickWindow representa la escena y proporciona la infraestructura necesaria para renderizar un fotograma. No estará respaldado por un bucle de renderizado ni por una ventana nativa. En su lugar, en este caso es la aplicación la que controla el renderizado, sustituyendo de hecho a los bucles de renderizado. Esto permite generar secuencias de imágenes, renderizar en texturas para su uso en motores 3D externos o renderizar contenido « Qt Quick » dentro de un entorno de realidad virtual.
Gestión de recursos
QML intentará almacenar en caché imágenes y nodos del grafo de escena para mejorar el rendimiento, pero en algunos casos de escasa memoria puede ser necesario liberar estos recursos de forma agresiva. La función ` releaseResources()` se puede utilizar para forzar la limpieza de determinados recursos, especialmente aquellos que están almacenados en caché y que se pueden volver a crear más adelante cuando se necesiten de nuevo.
Además, llamar a ` releaseResources()` puede provocar la liberación de todo el grafo de escena y los recursos gráficos asociados. Cuando esto ocurra, se emitirá la señal ` sceneGraphInvalidated()`. Este comportamiento se controla mediante las funciones ` setPersistentGraphics()` y ` setPersistentSceneGraph()`.
Nota: Todas las clases con el prefijo QSG deben utilizarse exclusivamente en el hilo de renderizado del grafo de escena. Consulta «Grafo de escena y renderizado» para obtener más información.
Exposición y visibilidad
Cuando una instancia de `QQuickWindow` se oculta deliberadamente con ` hide()` o `setVisible(false)`, dejará de renderizarse y es posible que su grafo de escena y su contexto gráfico también se liberen. Esto depende de la configuración establecida mediante ` setPersistentGraphics()` y ` setPersistentSceneGraph()`. El comportamiento a este respecto es idéntico al de llamar explícitamente a la función ` releaseResources()`. Una ventana también puede dejar de estar expuesta —es decir, dejar de ser renderizable— por otros medios. Esto depende de la plataforma y del sistema de ventanas. Por ejemplo, en Windows, minimizar una ventana hace que deje de renderizarse. En macOS, el hecho de que otras ventanas situadas encima oculten por completo una ventana provoca el mismo efecto. En Linux/X11, el comportamiento depende del gestor de ventanas.
Formatos de contexto y superficie de OpenGL
Aunque es posible especificar un contexto de OpenGL ( QSurfaceFormat ) para cada QQuickWindow llamando a la función miembro ` setFormat()`, las ventanas también pueden crearse desde QML utilizando los elementos `Window` y ` ApplicationWindow `. En este caso, no hay código C++ involucrado en la creación de la instancia de ventana; sin embargo, es posible que las aplicaciones deseen establecer ciertos valores de formato de superficie, por ejemplo, para solicitar una versión o perfil concreto de OpenGL. Dichas aplicaciones pueden llamar a la función estática ` QSurfaceFormat::setDefaultFormat()` al iniciarse. El formato especificado se utilizará para todas las ventanas Quick creadas a partir de ese momento.
Instancia de Vulkan
Al utilizar Vulkan, una `QQuickWindow` se asocia automáticamente a una ` QVulkanInstance ` que es creada y gestionada internamente por el grafo de escena. De este modo, la mayoría de las aplicaciones no tienen que preocuparse por disponer de una ` VkInstance `, ya que todo ocurre de forma automática. En casos avanzados, es posible que una aplicación desee crear su propia ` QVulkanInstance` para configurarla de una manera específica. Esto también es posible. Al llamar a ` setVulkanInstance()` en el `QQuickWindow` justo después de su construcción, antes de hacerlo visible, se utiliza el ` QVulkanInstance ` proporcionado por la aplicación (y el ` VkInstance` subyacente). Al redirigir a través de ` QQuickRenderControl`, no se proporciona automáticamente ningún ` QVulkanInstance `, sino que se espera que la aplicación proporcione el suyo propio y lo asocie con el `QQuickWindow`.
Contextos gráficos y dispositivos
Cuando se inicializa el grafo de escena —lo que suele ocurrir cuando la ventana queda expuesta o, en caso de renderizado redirigido, cuando la inicialización se realiza c via QQuickRenderControl —, los objetos de contexto o dispositivo necesarios para el renderizado se crean automáticamente. Esto incluye contextos OpenGL, dispositivos Direct3D y contextos de dispositivo, así como dispositivos Vulkan y Metal. Posteriormente, el código de la aplicación también puede consultar estos objetos mediante QSGRendererInterface. Al utilizar el bucle de renderizado basic, que realiza todo el renderizado en el hilo de la interfaz gráfica de usuario, se utiliza el mismo contexto o dispositivo con todas las QQuickWindows visibles. El bucle de renderizado threaded utiliza un contexto o un objeto de dispositivo específico para cada hilo de renderizado y, por lo tanto, para cada QQuickWindow. Con algunas API gráficas, existe un cierto grado de personalización que se proporciona a través de setGraphicsConfiguration(). Esto permite, por ejemplo, especificar la lista de extensiones de Vulkan que se deben habilitar en VkDevice. Como alternativa, también es posible proporcionar un conjunto de objetos de contexto o dispositivo ya existentes para que los utilice el QQuickWindow, en lugar de dejar que este construya los suyos propios. Esto se consigue mediante setGraphicsDevice().
Véase también QQuickView, QQuickRenderControl, QQuickRenderTarget, QQuickGraphicsDevice, QQuickGraphicsConfiguration y QSGRendererInterface.
Documentación sobre los tipos de miembros
enum QQuickWindow::CreateTextureOption
flags QQuickWindow::CreateTextureOptions
Las enumeraciones de CreateTextureOption se utilizan para personalizar el modo en que se envuelve una textura.
| Constante | Valor | Descripción |
|---|---|---|
QQuickWindow::TextureHasAlphaChannel | 0x0001 | La textura tiene un canal alfa y debe dibujarse utilizando la mezcla. |
QQuickWindow::TextureHasMipmaps | 0x0002 | La textura tiene mipmaps y se puede dibujar con el mipmapping activado. |
QQuickWindow::TextureOwnsGLTexture | 0x0004 | A partir de Qt 6.0, este indicador no se utiliza en la práctica y se ignora. La propiedad de los recursos gráficos nativos no es transferible al objeto envolvente ` QSGTexture`, ya que ` Qt Quick ` puede no disponer de la información necesaria sobre cómo se deben liberar dicho objeto y la memoria asociada. |
QQuickWindow::TextureCanUseAtlas | 0x0008 | La imagen se puede cargar en un atlas de texturas. |
QQuickWindow::TextureIsOpaque | 0x0010 | La textura devolverá «false» para ` QSGTexture::hasAlphaChannel()` y no se mezclará. Esta bandera se añadió en Qt 5.6. |
El tipo `CreateTextureOptions` es un `typedef` para ` QFlags<CreateTextureOption>`. Almacena una combinación OR de valores de `CreateTextureOption`.
enum QQuickWindow::RenderStage
| Constante | Valor | Descripción |
|---|---|---|
QQuickWindow::BeforeSynchronizingStage | 0 | Antes de la sincronización. |
QQuickWindow::AfterSynchronizingStage | 1 | Después de la sincronización. |
QQuickWindow::BeforeRenderingStage | 2 | Antes del renderizado. |
QQuickWindow::AfterRenderingStage | 3 | Después del renderizado. |
QQuickWindow::AfterSwapStage | 4 | Después de que se haya intercambiado el fotograma. |
QQuickWindow::NoStage | 5 | Lo antes posible. Este valor se añadió en Qt 5.6. |
Véase también «Grafo de escena»y «Renderizado».
enum QQuickWindow::SceneGraphError
Esta enumeración describe el error en una señal de ` sceneGraphError()`.
| Constante | Valor | Descripción |
|---|---|---|
QQuickWindow::ContextNotAvailable | 1 | Error al crear el contexto gráfico. Esto suele significar que no se ha encontrado ninguna implementación adecuada de OpenGL, por ejemplo, porque no hay controladores gráficos instalados y, por lo tanto, no hay compatibilidad con OpenGL 2. En placas móviles y embebidas que utilizan OpenGL ES, es probable que este error indique problemas en la integración del sistema de ventanas y, posiblemente, una configuración incorrecta de Qt OpenGL. |
enum QQuickWindow::TextRenderType
Esta enumeración describe el tipo de representación predeterminado de los elementos de tipo texto en Qt Quick (Text, TextInput, etc.).
Selecciona «NativeTextRendering» si prefieres que el texto tenga un aspecto nativo en la plataforma de destino y no necesitas funciones avanzadas, como la transformación del texto. El uso de dichas funciones en combinación con el tipo de representación «NativeTextRendering» dará lugar a resultados de mala calidad y, en ocasiones, pixelados.
Tanto « QtTextRendering » como « CurveTextRendering » son técnicas aceleradas por hardware. « QtTextRendering » es la más rápida de las dos, pero consume más memoria y presenta artefactos de renderizado en tamaños grandes. « CurveTextRendering » debe considerarse como alternativa en los casos en que « QtTextRendering » no ofrezca buenos resultados visuales o cuando la reducción del consumo de memoria gráfica sea una prioridad.
| Constante | Valor | Descripción |
|---|---|---|
QQuickWindow::QtTextRendering | 0 | Utiliza el algoritmo de rasterización propio de Qt. |
QQuickWindow::NativeTextRendering | 1 | Utiliza el rasterizador nativo del sistema operativo para el texto. |
QQuickWindow::CurveTextRendering | 2 | El texto se representa mediante un rasterizador de curvas que se ejecuta directamente en el hardware gráfico. (Introducido en Qt 6.7.0.) |
Documentación de la propiedad
[read-only] activeFocusItem : QQuickItem*
Esta propiedad contiene el elemento que tiene el foco activo en ese momento o ` null ` si no hay ningún elemento con el foco activo.
Funciones de acceso:
| QQuickItem * | activeFocusItem() const |
Señal de notificación:
| void | activeFocusItemChanged() |
Véase también ` QQuickItem::forceActiveFocus()` y «Foco del teclado» en Qt Quick.
color : QColor
Esta propiedad almacena el color que se utiliza para borrar el búfer de color al inicio de cada fotograma.
Por defecto, el color de borrado es el blanco.
Funciones de acceso:
| QColor | color() const |
| void | setColor(const QColor &color) |
Señal de notificación:
| void | colorChanged(const QColor &) |
Véase también ` setDefaultAlphaBuffer()`.
[read-only] contentItem : QQuickItem* const
Esta propiedad contiene el elemento raíz invisible de la escena.
Una ventana « QQuickWindow » siempre tiene un único elemento raíz invisible que contiene todo su contenido. Para añadir elementos a esta ventana, reasigna la relación de parentesco de los elementos al «contentItem» o a un elemento ya existente en la escena.
Funciones de acceso:
| QQuickItem * | contentItem() const |
[read-only, since 6.11] devicePixelRatio : qreal
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.
Esta enumeración se introdujo en Qt 6.11.
Funciones de acceso:
| qreal | effectiveDevicePixelRatio() const |
Señal de notificador:
| void | devicePixelRatioChanged() |
transientParent : QWindow*
Esta propiedad contiene la ventana respecto a la cual 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, que puede ser cualquier tipo de QWindow.
Para que la ventana se centre por defecto sobre su ventana principal transitoria, dependiendo del gestor de ventanas, también puede ser necesario establecer la propiedad ` flags ` con un valor adecuado de ` Qt::WindowType ` (como ` Qt::Dialog`).
Véase también parent().
Documentación de las funciones miembro
[explicit] QQuickWindow::QQuickWindow(QQuickRenderControl *control)
Crea una ventana para mostrar una escena QML, cuyo renderizado será controlado por el objeto ` control `. Para obtener más información, consulta la documentación de QQuickRenderControl.
[explicit] QQuickWindow::QQuickWindow(QWindow *parent = nullptr)
Crea una ventana para mostrar una escena QML cuya ventana principal es parent.
[override virtual noexcept] QQuickWindow::~QQuickWindow()
Cierra la ventana.
[override virtual] QAccessibleInterface *QQuickWindow::accessibleRoot() const
Devuelve una interfaz de accesibilidad para esta ventana, o 0 si no es posible crear dicha interfaz.
[signal] void QQuickWindow::afterAnimating()
Esta señal se emite en el hilo de la interfaz gráfica de usuario antes de solicitar al hilo de renderizado que realice la sincronización del grafo de escena.
A diferencia de otras señales similares, esta se emite en el hilo de la interfaz gráfica de usuario (GUI) en lugar de en el hilo de renderizado. Se puede utilizar para sincronizar sistemas de animación externos con el contenido QML. Al mismo tiempo, esto significa que esta señal no es adecuada para activar operaciones gráficas.
[signal, since 6.0] void QQuickWindow::afterFrameEnd()
Esta señal se emite cuando el grafo de escena ha enviado un fotograma. Se emite después de todas las demás señales relacionadas, como afterRendering(). Es la última señal que emite el hilo de renderizado del grafo de escena al renderizar un fotograma.
Nota: A diferencia de frameSwapped(), se garantiza que esta señal se emita también cuando la salida de « Qt Quick » se redirija mediante « QQuickRenderControl ».
Advertencia: Esta señal se emite desde el hilo de renderizado del grafo de escena. Si tu función de slot necesita finalizar antes de que continúe la ejecución, debes asegurarte de que la conexión sea directa (véase Qt::ConnectionType).
Esta función se introdujo en Qt 6.0.
Véase también beforeFrameBegin() y rendererInterface().
[signal] void QQuickWindow::afterRenderPassRecording()
Esta señal se emite después de que el grafo de escena haya registrado los comandos para su pasada de renderizado principal, pero antes de que dicha pasada se haya finalizado en el búfer de comandos.
Esta señal se emite antes que ` afterRendering()` y garantiza que no solo el fotograma, sino también el registro de la pasada de renderizado principal del grafo de escena, siga activo. Esto permite insertar comandos sin tener que generar una pasada de renderizado completa e independiente (lo que normalmente borraría las imágenes adjuntas). Los objetos gráficos nativos se pueden consultar mediante ` QSGRendererInterface`.
Nota: Las actualizacionesde recursos (cargas, copias) normalmente no se pueden poner en cola desde dentro de un paso de renderizado. Por lo tanto, los renderizados de usuario más complejos deberán conectarse tanto a beforeRendering() como a esta señal.
Advertencia: Esta señal se emite desde el hilo de renderizado del grafo de escena. Si tu función de slot debe finalizar antes de que continúe la ejecución, debes asegurarte de que la conexión sea directa (véase Qt::ConnectionType).
Véase también rendererInterface() y «Grafo de escena - RHI» en QML.
[signal] void QQuickWindow::afterRendering()
La señal se emite una vez que el grafo de escena ha añadido sus comandos al búfer de comandos, que aún no se ha enviado a la cola de gráficos. Si se desea, la función de slot conectada a esta señal puede consultar recursos nativos, como el búfer de comandos, mediante QSGRendererInterface. Sin embargo, hay que tener en cuenta que la pasada (o pasadas) de renderizado ya se han registrado en este momento y no es posible añadir más comandos dentro de la pasada del grafo de escena. En su lugar, utilice ` afterRenderPassRecording()` para ello. Por lo tanto, esta señal tiene un uso limitado en Qt 6, a diferencia de lo que ocurría en Qt 5. En su lugar, lo que se suele utilizar para lograr la superposición o la subposición del renderizado personalizado es la combinación de ` beforeRendering()` y ` beforeRenderPassRecording()`, o bien ` beforeRendering()` y ` afterRenderPassRecording()`.
Advertencia: Esta señal se emite desde el hilo de renderizado del grafo de escena. Si tu función de slot necesita finalizar antes de que continúe la ejecución, debes asegurarte de que la conexión sea directa (véase Qt::ConnectionType).
Nota: Al utilizar OpenGL, ten en cuenta que configurar estados específicos de OpenGL 3.x o 4.x y dejarlos habilitados o con valores distintos de los predeterminados al salir del slot conectado puede interferir en el renderizado del grafo de escena. La QOpenGLContext utilizada para el renderizado por parte del grafo de escena quedará vinculada cuando se emita la señal.
Véase también rendererInterface(), Gráfico de escena - RHI en QML, Gráfico de escena - OpenGL en QML, Gráfico de escena - Metal en QML, Gráfico de escena - Vulkan en QML y Gráfico de escena - Direct3D 11 en QML.
[signal] void QQuickWindow::afterSynchronizing()
Esta señal se emite una vez que el grafo de escenas se ha sincronizado con el estado de QML.
Esta señal se puede utilizar para realizar los preparativos necesarios tras las llamadas a QQuickItem::updatePaintNode(), mientras el hilo de la interfaz gráfica de usuario sigue bloqueado.
Al utilizar OpenGL, el ` QOpenGLContext ` utilizado para el renderizado por el grafo de escena quedará vinculado en este momento.
Advertencia: Esta señal se emite desde el hilo de renderizado del grafo de escena. Si tu función de ranura necesita finalizar antes de que continúe la ejecución, debes asegurarte de que la conexión sea directa (véase Qt::ConnectionType).
Advertencia: Al utilizar OpenGL, ten en cuenta que establecer estados específicos de OpenGL 3.x o 4.x y dejarlos habilitados o configurados con valores distintos de los predeterminados al salir de la ranura conectada puede interferir en el renderizado del grafo de escena.
[signal, since 6.0] void QQuickWindow::beforeFrameBegin()
Esta señal se emite antes de que el grafo de escena comience a preparar el fotograma. Precede a señales como beforeSynchronizing() o beforeRendering(). Es la primera señal que emite el hilo de renderizado del grafo de escena al comenzar a preparar un nuevo fotograma.
Esta señal es relevante para los marcos gráficos de bajo nivel que necesitan ejecutar ciertas operaciones, como la limpieza de recursos, en una fase en la que Qt Quick aún no ha iniciado la grabación de un nuevo fotograma a través de las API de la interfaz de hardware de renderizado subyacente.
Advertencia: Esta señal es emitida por el hilo de renderizado del grafo de escena. Si su función de ranura necesita finalizar antes de que continúe la ejecución, debe asegurarse de que la conexión sea directa (véase Qt::ConnectionType).
Esta función se introdujo en Qt 6.0.
Véase también afterFrameEnd() y rendererInterface().
[signal] void QQuickWindow::beforeRenderPassRecording()
Esta señal se emite antes de que el grafo de escena comience a registrar los comandos para la pasada de renderizado principal. (Las capas tienen sus propias pasadas y ya se han registrado por completo en el momento en que se emite esta señal.) La pasada de renderizado ya está activa en el búfer de comandos cuando se emite la señal.
Esta señal se emite después de ` beforeRendering()` y garantiza que no solo el fotograma, sino también el registro del paso de renderizado principal del grafo de escena, esté activo. Esto permite insertar comandos sin tener que generar un paso de renderizado completo e independiente (lo que normalmente borraría las imágenes adjuntas). Los objetos gráficos nativos se pueden consultar mediante ` QSGRendererInterface`.
Nota: Las actualizacionesde recursos (cargas, copias) normalmente no se pueden poner en cola desde dentro de un paso de renderizado. Por lo tanto, los renderizados de usuario más complejos tendrán que conectarse tanto a beforeRendering() como a esta señal.
Advertencia: Esta señal se emite desde el hilo de renderizado del grafo de escena. Si tu función de slot necesita finalizar antes de que continúe la ejecución, debes asegurarte de que la conexión sea directa (véase Qt::ConnectionType).
Véase también rendererInterface() y «Grafo de escena - RHI» en QML.
[signal] void QQuickWindow::beforeRendering()
Esta señal se emite una vez finalizados los preparativos para el fotograma, lo que significa que hay un búfer de comandos en modo de grabación, cuando proceda. Si se desea, la función de ranura conectada a esta señal puede consultar recursos nativos, como el comando anterior, a través de QSGRendererInterface. Sin embargo, hay que tener en cuenta que, en este momento, la grabación de la pasada de renderizado principal aún no ha comenzado y no es posible añadir comandos dentro de dicha pasada. Iniciar una pasada implica borrar los búferes de color, profundidad y estarcido, por lo que no es posible lograr un renderizado de tipo «underlay» simplemente conectándose a esta señal. En su lugar, conéctate a beforeRenderPassRecording(). No obstante, conectarse a esta señal sigue siendo importante si se desea la grabación de comandos de tipo «copy», ya que estos no pueden ponerse en cola dentro de una pasada de renderizado.
Advertencia: Esta señal se emite desde el hilo de renderizado del grafo de escena. Si tu función de ranura necesita finalizar antes de que continúe la ejecución, debes asegurarte de que la conexión sea directa (véase Qt::ConnectionType).
Nota: Al utilizar OpenGL, ten en cuenta que establecer estados específicos de OpenGL 3.x o 4.x y dejarlos habilitados o con valores distintos de los predeterminados al salir de la ranura conectada puede interferir con el renderizado del grafo de escena. El QOpenGLContext utilizado para el renderizado por el grafo de escena quedará vinculado cuando se emita la señal.
Véase también rendererInterface(), Gráfico de escena - RHI en QML, Gráfico de escena - OpenGL en QML, Gráfico de escena - Metal en QML, Gráfico de escena - Vulkan en QML y Gráfico de escena - Direct3D 11 en QML.
[signal] void QQuickWindow::beforeSynchronizing()
Esta señal se emite antes de que el grafo de escena se sincronice con el estado de QML.
Aunque la señal se emite desde el hilo de renderizado del grafo de escena, se garantiza que el hilo de la interfaz gráfica de usuario (GUI) quede bloqueado, al igual que ocurre en ` QQuickItem::updatePaintNode()`. Por lo tanto, es seguro acceder a los datos del hilo de la GUI en una ranura (slot) o una función lambda conectada a ` Qt::DirectConnection`.
Esta señal se puede utilizar para realizar cualquier preparación necesaria antes de llamar a ` QQuickItem::updatePaintNode()`.
Al utilizar OpenGL, el ` QOpenGLContext ` utilizado para el renderizado por el grafo de escena estará vinculado en este momento.
Advertencia: Esta señal se emite desde el hilo de renderizado del grafo de escena. Si tu función de slot necesita finalizar antes de que continúe la ejecución, debes asegurarte de que la conexión sea directa (véase Qt::ConnectionType).
Advertencia: Al utilizar OpenGL, ten en cuenta que establecer estados específicos de OpenGL 3.x o 4.x y dejarlos habilitados o configurados con valores distintos de los predeterminados al salir de la ranura conectada puede interferir en el renderizado del grafo de escena.
void QQuickWindow::beginExternalCommands()
Al combinar comandos gráficos sin procesar (OpenGL, Vulkan, Metal, etc.) con el renderizado del grafo de escena, es necesario llamar a esta función antes de grabar los comandos en el búfer de comandos que utiliza el grafo de escena para renderizar su pasada de renderizado principal. El objetivo es evitar sobrescribir el estado.
En la práctica, esta función suele llamarse desde una ranura conectada a las señales « beforeRenderPassRecording()» o « afterRenderPassRecording()».
No es necesario llamar a la función cuando se graban comandos en el propio búfer de comandos de la aplicación (como, por ejemplo, un VkCommandBuffer o un MTLCommandBuffer + MTLRenderCommandEncoder creado y gestionado por la aplicación, y no obtenido del grafo de escena). En el caso de las API gráficas que no exponen el concepto nativo de búfer de comandos (OpenGL, Direct 3D 11), las funciones beginExternalCommands() y endExternalCommands() juntas sustituyen a la función resetOpenGLState() de Qt 5.
No es necesario llamar a esta función ni a ` endExternalCommands()` dentro de la implementación de ` render()` de un ` QSGRenderNode `, ya que el grafo de escena realiza los pasos necesarios de forma implícita para los nodos de renderizado.
Se puede acceder a los objetos gráficos nativos (como el dispositivo gráfico, el búfer de comandos o el codificador) a través de ` QSGRendererInterface::getResource()`.
Advertencia: Ten en cuenta que QSGRendererInterface::CommandListResource puede devolver un objeto diferente entre beginExternalCommands() y endExternalCommands(). Esto puede ocurrir cuando la implementación subyacente proporciona un búfer de comandos secundario dedicado para registrar comandos gráficos externos dentro de una pasada de renderizado. Por lo tanto, consulta siempre CommandListResource después de llamar a esta función. No intentes reutilizar un objeto de una consulta anterior.
Nota: Cuando el grafo de escena utiliza OpenGL, hay que tener en cuenta que el estado de OpenGL en el contexto puede tener configuraciones arbitrarias, y que esta función no restablece el estado a sus valores predeterminados.
Véase también endExternalCommands() y QQuickOpenGLUtils::resetOpenGLState().
[override virtual protected] void QQuickWindow::closeEvent(QCloseEvent *e)
Reimplementa: ` QWindow::closeEvent(QCloseEvent *ev)`.
QSGImageNode *QQuickWindow::createImageNode() const
Crea un nodo de imagen sencillo. Cuando el grafo de escena no está inicializado, el valor devuelto es nulo.
Se trata de una alternativa válida para todos los backends a la creación directa de un ` QSGSimpleTextureNode `.
Véase también QSGImageNode.
QSGNinePatchNode *QQuickWindow::createNinePatchNode() const
Crea un nodo «nine patch». Si el grafo de escena no está inicializado, el valor devuelto es nulo.
QSGRectangleNode *QQuickWindow::createRectangleNode() const
Crea un nodo rectangular sencillo. Cuando el grafo de escena no está inicializado, el valor devuelto es nulo.
Se trata de una alternativa compatible con todos los backends para construir directamente un ` QSGSimpleRectNode `.
Véase también ` QSGRectangleNode`.
[since 6.7] QSGTextNode *QQuickWindow::createTextNode() const
Crea un nodo de texto. Si el grafo de escena no está inicializado, el valor devuelto es nulo.
Esta función se introdujo en Qt 6.7.
Véase también QSGTextNode.
QSGTexture *QQuickWindow::createTextureFromImage(const QImage &image, QQuickWindow::CreateTextureOptions options) const
Crea un nuevo objeto ` QSGTexture ` a partir del objeto ` image` proporcionado. Si la imagen tiene un canal alfa, la textura resultante también lo tendrá.
Quien llama a la función es responsable de eliminar la textura devuelta. A continuación, el objeto de textura nativo subyacente se destruye junto con el ` QSGTexture`.
Cuando options contiene TextureCanUseAtlas, el motor puede incluir la imagen en un atlas de texturas. Las texturas de un atlas deben utilizar QSGTexture::normalizedTextureSubRect() para su geometría y no admiten QSGTexture::Repeat. Se ignoran los demás valores de CreateTextureOption.
Cuando options contiene TextureIsOpaque, el motor creará una textura RGB que devuelve «false» para QSGTexture::hasAlphaChannel(). Las texturas opacas suelen renderizarse más rápido en la mayoría de los casos. Si no se activa esta opción, la textura tendrá un canal alfa basado en el formato de la imagen.
Cuando options contiene TextureHasMipmaps, el motor creará una textura que puede utilizar filtrado mipmap. Las texturas con mipmap no pueden formar parte de un atlas.
Establecer ` TextureHasAlphaChannel ` en ` options ` no tiene sentido para esta función, ya que por defecto se asume un canal alfa y la mezcla. Para desactivarlo, establece ` TextureIsOpaque`.
Cuando el grafo de escena utiliza OpenGL, la textura devuelta utilizará GL_TEXTURE_2D como destino de textura y GL_RGBA como formato interno. Con otras API gráficas, el formato de textura suele ser RGBA8. Reimplementa QSGTexture para crear texturas con parámetros diferentes.
Advertencia: Esta función devolverá 0 si el grafo de escena aún no se ha inicializado.
Advertencia: La memoriade la textura devuelta no es gestionada por el grafo de escena y debe ser eliminada explícitamente por el llamante en el hilo de renderizado. Esto se consigue eliminando la textura desde un destructor de ` QSGNode ` o utilizando ` deleteLater()` en el caso de que la textura ya tenga afinidad con el hilo de renderizado.
Esta función puede invocarse tanto desde el hilo principal como desde el hilo de renderizado.
Véase también sceneGraphInitialized() y QSGTexture.
QSGTexture *QQuickWindow::createTextureFromImage(const QImage &image) const
Esta es una función sobrecargada.
[since 6.6] QSGTexture *QQuickWindow::createTextureFromRhiTexture(QRhiTexture *texture, QQuickWindow::CreateTextureOptions options = {}) const
Crea un nuevo objeto ` QSGTexture ` a partir del objeto ` texture` proporcionado.
Utiliza options para personalizar los atributos de la textura. Esta función solo tiene en cuenta el indicador TextureHasAlphaChannel. Cuando se activa, el renderizador del grafo de escena siempre trata el QSGTexture resultante como si requiriera mezcla. En el caso de texturas totalmente opacas, no activar el indicador puede ahorrar el coste de realizar la mezcla alfa durante el renderizado. El indicador no tiene una correspondencia directa con el tipo de textura ( format ) de la textura ( QRhiTexture); es decir, no establecer el indicador mientras se utiliza un formato de textura como el comúnmente utilizado QRhiTexture::RGBA8 es perfectamente normal.
El mipmapping no se controla mediante options, ya que texture ya está creado y tiene incorporada la presencia o ausencia de mipmaps.
El ` QSGTexture ` devuelto es propietario del ` QRhiTexture`, lo que significa que ` texture ` se destruye junto con el ` QSGTexture` devuelto.
Si texture es propietario de sus recursos gráficos nativos subyacentes (objeto de textura OpenGL, imagen Vulkan, etc.), esto depende de cómo se haya creado QRhiTexture (QRhiTexture::create() o QRhiTexture::createFrom()), y no es algo que esta función controle ni modifique.
Nota: Esto solo funciona cuando el grafo de escena ya se ha inicializado y utiliza la adaptación predeterminada basada en ` QRhi`. En caso contrario, el valor de retorno es ` nullptr `.
Nota: Esta función solo se puede invocar en el hilo de renderizado del grafo de escena.
Esta función se introdujo en Qt 6.6.
Véase también createTextureFromImage(), sceneGraphInitialized() y QSGTexture.
[signal, since 6.11] void QQuickWindow::devicePixelRatioChanged()
Esta señal se emite cuando se ha modificado la relación de píxeles efectiva del dispositivo.
Nota: Señalde notificación para la propiedad ` devicePixelRatio`.
Esta función se introdujo en Qt 6.11.
Véase también ` effectiveDevicePixelRatio()`.
qreal QQuickWindow::effectiveDevicePixelRatio() const
Devuelve la relación de píxeles del dispositivo para esta ventana.
Esto difiere de ` QWindow::devicePixelRatio()` en que admite el renderizado redirigido a través de ` QQuickRenderControl ` y ` QQuickRenderTarget`. Cuando se utiliza un ` QQuickRenderControl`, a menudo el ` QQuickWindow ` no se crea por completo, lo que significa que nunca se muestra y no se crea ninguna ventana nativa subyacente en el sistema de ventanas. Como consecuencia, la consulta de propiedades como la relación de píxeles del dispositivo no puede ofrecer resultados correctos. Esta función tiene en cuenta tanto QQuickRenderControl::renderWindowFor() como QQuickRenderTarget::devicePixelRatio(). Cuando no hay ninguna redirección activa, el resultado es el mismo que el de QWindow::devicePixelRatio().
Nota: Funcióngetter para la propiedad devicePixelRatio.
Véase también QQuickRenderControl, QQuickRenderTarget, setRenderTarget() y QWindow::devicePixelRatio().
void QQuickWindow::endExternalCommands()
Al combinar comandos gráficos sin procesar (OpenGL, Vulkan, Metal, etc.) con el renderizado del grafo de escena, es necesario llamar a esta función tras grabar los comandos en el búfer de comandos que utiliza el grafo de escena para renderizar su pasada de renderizado principal. Esto se hace para evitar sobrescribir el estado.
En la práctica, esta función suele invocarse desde una ranura conectada a las señales « beforeRenderPassRecording()» o « afterRenderPassRecording()».
No es necesario llamar a esta función cuando se graban comandos en el propio búfer de comandos de la aplicación (como, por ejemplo, un `VkCommandBuffer` o un `MTLCommandBuffer` + `MTLRenderCommandEncoder` creado y gestionado por la aplicación, y no obtenido del grafo de escena). En el caso de las API gráficas en las que no se expone el concepto nativo de búfer de comandos (OpenGL, Direct 3D 11), las funciones beginExternalCommands() y endExternalCommands() juntas sustituyen a la función resetOpenGLState() de Qt 5.
No es necesario llamar a esta función ni a ` beginExternalCommands()` dentro de la implementación de ` render()` de un ` QSGRenderNode `, ya que el grafo de escena realiza los pasos necesarios de forma implícita para los nodos de renderizado.
Véanse también beginExternalCommands() y QQuickOpenGLUtils::resetOpenGLState().
[override virtual protected] bool QQuickWindow::event(QEvent *event)
Reimplementa: ` QWindow::event(QEvent *ev)`.
[override virtual protected] void QQuickWindow::exposeEvent(QExposeEvent *)
Reimplementa: QWindow::exposeEvent(QExposeEvent *ev).
[override virtual protected] void QQuickWindow::focusInEvent(QFocusEvent *ev)
Reimplementa: ` QWindow::focusInEvent(QFocusEvent *ev)`.
[override virtual protected] void QQuickWindow::focusOutEvent(QFocusEvent *ev)
Reimplementa: QWindow::focusOutEvent(QFocusEvent *ev).
[signal] void QQuickWindow::frameSwapped()
Esta señal se emite cuando se ha puesto en cola un fotograma para su visualización. Con la sincronización vertical activada, la señal se emite como máximo una vez por intervalo de vsync en una escena con animación continua.
Esta señal se emitirá desde el hilo de renderizado del grafo de escena.
QImage QQuickWindow::grabWindow()
Recoge el contenido de la ventana y lo devuelve como una imagen.
Es posible llamar a la función grabWindow() aunque la ventana no esté visible. Para ello, es necesario que la ventana sea de tipo « created », tenga un tamaño válido y que no haya otras instancias de « QQuickWindow » representándose en el mismo proceso.
Nota: Al utilizar esta ventana en combinación con QQuickRenderControl, el resultado de esta función es una imagen vacía, a menos que se esté utilizando el backend software. Esto se debe a que, al redirigir la salida a un recurso gráfico gestionado por la aplicación (como, por ejemplo, una textura) mediante QQuickRenderControl y setRenderTarget(), la aplicación está mejor preparada para gestionar y ejecutar una eventual operación de relectura, ya que, para empezar, tiene el control total del recurso.
Advertencia: La llamada a esta función provocará problemas de rendimiento.
Advertencia: Esta función solo se puede invocar desde el hilo de la interfaz gráfica de usuario.
[static, since 6.0] QSGRendererInterface::GraphicsApi QQuickWindow::graphicsApi()
Devuelve la API gráfica que utilizaría el grafo de escena si se inicializara en este momento.
La forma estándar de consultar la API utilizada por el grafo de escena es emplear ` QSGRendererInterface::graphicsApi()` una vez que el grafo de escena se haya inicializado, por ejemplo, cuando se emite la señal ` sceneGraphInitialized()` o después de ello. En ese caso se obtiene el resultado verdadero y real, ya que entonces se sabe que todo se ha inicializado correctamente utilizando esa API gráfica.
Esto no siempre resulta conveniente. Si la aplicación necesita configurar marcos externos, o debe trabajar con ` setGraphicsDevice()` de una manera que dependa de la lógica de selección de API integrada en el grafo de escena, no siempre es viable aplazar dichas operaciones hasta después de que ` QQuickWindow ` se haya hecho visible o se haya llamado a ` QQuickRenderControl::initialize()`.
Por lo tanto, esta función estática se proporciona como contrapartida a setGraphicsApi(): puede invocarse en cualquier momento, y el resultado refleja qué API elegiría el grafo de escena si se inicializara en el momento de la llamada.
Nota: Esta función estática está pensada para ser llamada únicamente en el hilo principal (GUI). Para consultar la API durante el renderizado, utiliza QSGRendererInterface, ya que ese objeto reside en el hilo de renderizado.
Nota: Esta función no tiene en cuenta los backends del grafo de escena.
Esta función se introdujo en Qt 6.0.
Véase también setGraphicsApi().
[since 6.0] QQuickGraphicsConfiguration QQuickWindow::graphicsConfiguration() const
Devuelve el objeto ` QQuickGraphicsConfiguration ` pasado a ` setGraphicsConfiguration()`, o uno creado con los valores por defecto en caso contrario.
Esta función se introdujo en Qt 6.0.
Véase también ` setGraphicsConfiguration()`.
[since 6.0] QQuickGraphicsDevice QQuickWindow::graphicsDevice() const
Devuelve el objeto ` QQuickGraphicsDevice ` pasado a ` setGraphicsDevice()` o, en su defecto, uno creado con los valores predeterminados
Esta función se introdujo en Qt 6.0.
Véase también setGraphicsDevice().
const QQuickWindow::GraphicsStateInfo &QQuickWindow::graphicsStateInfo()
Devuelve una referencia a una estructura ` GraphicsStateInfo ` que describe parte del estado interno del RHI; en concreto, el estado de búfer doble o triple del backend (como, por ejemplo, las integraciones con Vulkan o Metal). Esto resulta relevante cuando las API gráficas subyacentes son Vulkan o Metal, y el código de renderizado externo desea aplicar un búfer doble o triple a sus propios recursos que cambian con frecuencia —como los búferes uniformes— con el fin de evitar el bloqueo del pipeline.
[static] bool QQuickWindow::hasDefaultAlphaBuffer()
Devuelve si se debe utilizar transparencia alfa en las ventanas recién creadas.
Véase también ` setDefaultAlphaBuffer()`.
[override virtual protected] void QQuickWindow::hideEvent(QHideEvent *)
Reimplementa: QWindow::hideEvent(QHideEvent *ev).
QQmlIncubationController *QQuickWindow::incubationController() const
Devuelve un controlador de incubación que intercala la incubación entre fotogramas para esta ventana. QQuickView instala automáticamente este controlador; de lo contrario, tendrás que instalarlo tú mismo utilizando QQmlEngine::setIncubationController().
El controlador pertenece a la ventana y se eliminará cuando se elimine la ventana.
bool QQuickWindow::isPersistentGraphics() const
Devuelve si los recursos gráficos esenciales pueden liberarse durante el ciclo de vida del ` QQuickWindow`.
Nota: Se tratade una sugerencia, y no se garantiza que se tenga en cuenta.
Véase también setPersistentGraphics().
bool QQuickWindow::isPersistentSceneGraph() const
Devuelve si los nodos y recursos del grafo de escena pueden liberarse durante el ciclo de vida de este ` QQuickWindow`.
Nota: Esto es una indicación. El momento y la forma en que esto ocurre dependen de la implementación.
bool QQuickWindow::isSceneGraphInitialized() const
Devuelve «true» si se ha inicializado el grafo de escena; en caso contrario, devuelve «false».
[override virtual protected] void QQuickWindow::keyPressEvent(QKeyEvent *e)
Reimplementa: QWindow::keyPressEvent(QKeyEvent *ev).
[override virtual protected] void QQuickWindow::keyReleaseEvent(QKeyEvent *e)
Reimplementa: QWindow::keyReleaseEvent(QKeyEvent *ev).
[override virtual protected] void QQuickWindow::mouseDoubleClickEvent(QMouseEvent *event)
Reimplementa: QWindow::mouseDoubleClickEvent(QMouseEvent *ev).
[override virtual protected] void QQuickWindow::mouseMoveEvent(QMouseEvent *event)
Reimplementa: QWindow::mouseMoveEvent(QMouseEvent *ev).
[override virtual protected] void QQuickWindow::mousePressEvent(QMouseEvent *event)
Reimplementa: QWindow::mousePressEvent(QMouseEvent *ev).
[override virtual protected] void QQuickWindow::mouseReleaseEvent(QMouseEvent *event)
Reimplementa: QWindow::mouseReleaseEvent(QMouseEvent *ev).
[slot] void QQuickWindow::releaseResources()
Esta función intenta liberar los recursos redundantes que actualmente mantiene la escena QML.
Al llamar a esta función, se solicita al grafo de escena que libere los recursos gráficos almacenados en caché, como objetos del canal de procesamiento gráfico, programas de sombreado o datos de imagen.
Además, dependiendo del bucle de renderizado que se esté utilizando, esta función también puede provocar que se liberen el grafo de escena y todos los recursos de renderizado relacionados con la ventana. Si esto ocurre, se emitirá la señal ` sceneGraphInvalidated()`, lo que permitirá a los usuarios limpiar sus propios recursos gráficos. Las funciones ` setPersistentGraphics()` y ` setPersistentSceneGraph()` pueden utilizarse para evitar que esto suceda, si no es viable gestionar la limpieza en la aplicación, a costa de un mayor consumo de memoria.
Nota: La liberación de recursos gráficos almacenados en caché, como los flujos de trabajo gráficos o los programas de sombreado, no depende de las indicaciones de persistencia. La liberación de dichos recursos se producirá independientemente de los valores de las indicaciones de gráficos persistentes y del grafo de escena.
Nota: Esta función no está relacionada con la función virtual ` QQuickItem::releaseResources()`.
Véase también sceneGraphInvalidated(), setPersistentGraphics() y setPersistentSceneGraph().
[since 6.0] QQuickRenderTarget QQuickWindow::renderTarget() const
Devuelve el objeto ` QQuickRenderTarget ` pasado a ` setRenderTarget()`; en caso contrario, devuelve uno construido por defecto
Esta función se introdujo en Qt 6.0.
Véase también setRenderTarget().
QSGRendererInterface *QQuickWindow::rendererInterface() const
Devuelve la interfaz del renderizador actual. El valor siempre es válido y nunca es nulo.
Nota: Esta función se puede invocar en cualquier momento tras crear el ` QQuickWindow`, incluso mientras ` isSceneGraphInitialized()` siga siendo falso. Sin embargo, algunas funciones de la interfaz del renderizador, en particular ` QSGRendererInterface::getResource()`, no estarán operativas hasta que el grafo de escena esté en funcionamiento. Por otro lado, las consultas al backend, como ` QSGRendererInterface::graphicsApi()` o ` QSGRendererInterface::shaderType()`, siempre estarán operativas.
Nota: La propiedad del puntero devuelto recae en Qt. La instancia devuelta puede compartirse o no entre diferentes instancias de ` QQuickWindow `, dependiendo del backend del grafo de escena que se utilice. Por lo tanto, se espera que las aplicaciones consulten el objeto de interfaz para cada ` QQuickWindow ` en lugar de reutilizar el puntero ya consultado.
Véase también QSGRenderNode y QSGRendererInterface.
[override virtual protected] void QQuickWindow::resizeEvent(QResizeEvent *ev)
Reimplementa: QWindow::resizeEvent(QResizeEvent *ev).
[since 6.6] QRhi *QQuickWindow::rhi() const
Devuelve el objeto ` QRhi ` que utiliza esta ventana para el renderizado.
Solo está disponible cuando la ventana utiliza la API Qt 3D y las abstracciones del lenguaje de sombreado, lo que significa que el resultado siempre es nulo cuando se utiliza la adaptación ` software `.
El resultado solo es válido cuando se ha inicializado el renderizado, lo cual se indica mediante la emisión de la señal ` sceneGraphInitialized()`. Antes de ese momento, el valor devuelto es nulo. Con un grafo de escena ` QQuickWindow ` normal en pantalla, la inicialización suele producirse cuando la ventana nativa se muestra por primera vez. Al utilizar QQuickRenderControl, la inicialización se realiza mediante la llamada explícita a initialize().
En la práctica, esta función es un atajo para consultar el QRhi a través de QSGRendererInterface.
Esta función se introdujo en Qt 6.6.
[signal] void QQuickWindow::sceneGraphAboutToStop()
Esta señal se emite en el hilo de renderizado cuando el grafo de escena está a punto de dejar de renderizarse. Esto suele ocurrir porque la ventana se ha ocultado.
Las aplicaciones pueden utilizar esta señal para liberar recursos, pero deben estar preparadas para volver a instanciarlos rápidamente. El grafo de escena y el contexto gráfico no se liberan en este momento.
Advertencia: Esta señal se emite desde el hilo de renderizado del grafo de escena. Si tu función de slot necesita finalizar antes de que continúe la ejecución, debes asegurarte de que la conexión sea directa (véase Qt::ConnectionType).
Advertencia: Asegúrate bien de que un controlador de señal para sceneGraphAboutToStop() deje el contexto gráfico en el mismo estado en el que se encontraba al entrar en el controlador de señal. De no hacerlo, la escena podría no renderizarse correctamente.
Véase también sceneGraphInvalidated().
[static] QString QQuickWindow::sceneGraphBackend()
Devuelve el backend de grafo de escena « Qt Quick » solicitado.
Nota: El valor devuelto por esta función puede quedar desactualizado por llamadas posteriores a setSceneGraphBackend() hasta que se haya construido el primer QQuickWindow en la aplicación.
Nota: El valor solo refleja la solicitud de la variable de entorno QT_QUICK_BACKEND una vez que se haya construido un QQuickWindow.
Véase también setSceneGraphBackend().
[signal] void QQuickWindow::sceneGraphError(QQuickWindow::SceneGraphError error, const QString &message)
Esta señal se emite cuando se produce un error de « error » durante la inicialización del grafo de escenas.
Las aplicaciones deben conectarse a esta señal si desean gestionar los errores, como los fallos en la creación del contexto gráfico, de forma personalizada. Cuando no hay ningún slot conectado a la señal, el comportamiento será diferente: Quick mostrará el message o mostrará un cuadro de mensaje y cerrará la aplicación.
Esta señal se emitirá desde el hilo de la interfaz gráfica de usuario.
[signal] void QQuickWindow::sceneGraphInitialized()
Esta señal se emite cuando se ha inicializado el grafo de escena.
Esta señal se emitirá desde el hilo de renderizado del grafo de escena.
[signal] void QQuickWindow::sceneGraphInvalidated()
Esta señal se emite cuando el grafo de escena ha quedado invalidado.
Esta señal implica que el contexto de renderizado gráfico utilizado ha quedado invalidado y que deben liberarse todos los recursos de usuario vinculados a dicho contexto.
Al renderizar con OpenGL, el contexto de renderizado de la ventana ( QOpenGLContext ) quedará vinculado cuando se llame a esta función. La única excepción es si el OpenGL nativo se ha destruido fuera del control de Qt, por ejemplo, a través de EGL_CONTEXT_LOST.
Esta señal se emitirá desde el hilo de renderizado del grafo de escena.
void QQuickWindow::scheduleRenderJob(QRunnable *job, QQuickWindow::RenderStage stage)
Programa job para que se ejecute cuando la representación de esta ventana llegue al punto stage.
Se trata de una forma más cómoda de utilizar las señales equivalentes de QQuickWindow para tareas «únicas».
La ventana asume la propiedad de job y lo eliminará cuando el trabajo haya finalizado.
Si el renderizado se detiene antes de que job tenga oportunidad de ejecutarse, el trabajo se ejecutará y luego se eliminará como parte de la limpieza del grafo de escena. Si la ventana nunca se muestra y no se produce ningún renderizado antes de que se destruya QQuickWindow, todos los trabajos pendientes se destruirán sin que se llame a su método run().
Si el renderizado se está realizando en un hilo diferente, el trabajo se ejecutará en el hilo de renderizado.
Si stage es de tipo NoStage, job se ejecutará en cuanto sea posible, siempre que el hilo de renderizado no esté ocupado renderizando un fotograma. Si la ventana no está expuesta y no es renderizable en el momento en que se envía o se gestiona la tarea, esta se elimina sin ejecutar el método run(). Si se utiliza un renderizador sin subprocesos, el método run() del trabajo se ejecuta de forma sincrónica. Al renderizar con OpenGL, el contexto de OpenGL se cambia al contexto del renderizador antes de ejecutar cualquier trabajo, incluidos los trabajos de NoStage.
Nota: Esta función no activa la renderización; los trabajos destinados a cualquier etapa que no sea « NoStage » se almacenarán y se ejecutarán cuando la renderización se active en otro lugar. Para forzar la ejecución anticipada del trabajo, llame a QQuickWindow::update();
Véase también beforeRendering(), afterRendering(), beforeSynchronizing(), afterSynchronizing(), frameSwapped() y sceneGraphInvalidated().
[static] void QQuickWindow::setDefaultAlphaBuffer(bool useAlpha)
useAlpha Especifica si se debe utilizar la transparencia alfa en las ventanas de nueva creación.
En cualquier aplicación que prevea crear ventanas translúcidas, es necesario establecer este parámetro en «true» antes de crear la primera QQuickWindow. El valor por defecto es «false».
Véase también hasDefaultAlphaBuffer().
[static, since 6.0] void QQuickWindow::setGraphicsApi(QSGRendererInterface::GraphicsApi api)
Solicita los gráficos especificados api.
Cuando se utiliza la adaptación gráfica predeterminada integrada, api especifica qué API gráfica (OpenGL, Vulkan, Metal o Direct3D) debe utilizar el grafo de escena para el renderizado. Además, el backend software también está integrado y se puede solicitar estableciendo api en QSGRendererInterface::Software.
A diferencia de ` setSceneGraphBackend()` —que solo puede utilizarse para solicitar un backend concreto (ya sea integrado de serie o instalado como complementos cargados dinámicamente)—, esta función opera con el concepto de nivel superior de las API gráficas. Abarca los backends que se incluyen con ` Qt Quick` y, por lo tanto, tienen valores correspondientes en la enumeración ` QSGRendererInterface::GraphicsApi `.
Cuando no se invoca esta función en absoluto, y tampoco se ha establecido la variable de entorno equivalente QSG_RHI_BACKEND, el grafo de escena elegirá la API gráfica que se va a utilizar en función de la plataforma.
Esta función cobra importancia en aplicaciones que solo están preparadas para el renderizado con una API determinada. Por ejemplo, si la aplicación realiza renderizado nativo con OpenGL o Vulkan, querrá asegurarse de que Qt Quick también utilice OpenGL o Vulkan para el renderizado. Se espera que este tipo de aplicaciones llamen a esta función al principio de su función main().
Nota: La llamada a la función debe realizarse antes de crear el primer ` QQuickWindow ` en la aplicación. La API gráfica no se puede cambiar posteriormente.
Nota: Cuando se utiliza en combinación con ` QQuickRenderControl`, esta regla se flexibiliza: es posible cambiar la API gráfica, pero solo cuando se hayan destruido todas las instancias existentes de ` QQuickRenderControl ` y ` QQuickWindow `.
Para consultar qué API gráfica está utilizando el grafo de escena para el renderizado, llama a ` QSGRendererInterface::graphicsApi()` después de que el grafo de escena haya llamado a ` has initialized`, lo que suele ocurrir bien cuando la ventana se hace visible por primera vez, bien cuando se llama a ` QQuickRenderControl::initialize()`.
Para volver al comportamiento predeterminado, en el que el grafo de escena elige una API gráfica en función de la plataforma y otras condiciones, establezca ` api ` en ` QSGRendererInterface::Unknown`.
Esta función se introdujo en Qt 6.0.
Véase también graphicsApi().
[since 6.0] void QQuickWindow::setGraphicsConfiguration(const QQuickGraphicsConfiguration &config)
Establece la configuración gráfica de esta ventana. ` config ` contiene diversos parámetros que el grafo de escena puede tener en cuenta al inicializar los dispositivos y contextos gráficos subyacentes.
Dicha configuración adicional, que especifica, por ejemplo, qué extensiones de dispositivo se deben habilitar para Vulkan, resulta relevante y esencial a la hora de integrar código de renderizado gráfico nativo que depende de determinadas extensiones. Lo mismo ocurre al integrar motores 3D o de realidad virtual externos, como OpenXR.
Nota: La configuración se ignora al adoptar dispositivos gráficos existentes mediante setGraphicsDevice(), ya que, en ese caso, el grafo de escena no controla la construcción real de dichos objetos.
QQuickGraphicsConfiguration Las instancias se comparten implícitamente, son copiables y pueden pasarse por valor.
Advertencia: La configuración de un ` QQuickGraphicsConfiguration ` en un ` QQuickWindow ` debe realizarse con suficiente antelación, antes de que se inicialice el grafo de escena por primera vez para esa ventana. En el caso de las ventanas en pantalla, esto significa que la llamada debe realizarse antes de invocar ` show()` en ` QQuickWindow ` o ` QQuickView`. Con ` QQuickRenderControl `, la configuración debe estar finalizada antes de llamar a ` initialize()`.
Esta función se introdujo en Qt 6.0.
Véase también graphicsConfiguration().
[since 6.0] void QQuickWindow::setGraphicsDevice(const QQuickGraphicsDevice &device)
Establece los objetos del dispositivo gráfico para esta ventana. El grafo de escena utilizará el dispositivo existente, el dispositivo físico y otros objetos especificados mediante ` device `, en lugar de crear otros nuevos.
Esta función se utiliza muy a menudo junto con ` QQuickRenderControl ` y ` setRenderTarget()`, con el fin de redirigir el renderizado de ` Qt Quick ` a una textura.
Un ` QQuickGraphicsDevice ` construido por defecto no modifica el comportamiento predeterminado en modo alguno. Una vez que se pasa un ` device ` creado mediante una de las funciones de fábrica de ` QQuickGraphicsDevice `, como ` QQuickGraphicsDevice::fromDeviceObjects()`, y el grafo de escena utiliza una API gráfica compatible (en el ejemplo de `fromDeviceObjects()`, sería Vulkan), el grafo de escena utilizará los objetos de dispositivo existentes (como VkPhysicalDevice, VkDevice y el índice de la familia de colas gráficas, en el caso de Vulkan) encapsulados por QQuickGraphicsDevice. Esto permite utilizar el mismo dispositivo y, por lo tanto, compartir recursos, como búferes y texturas, entre Qt Quick y los motores de renderizado nativos.
Advertencia: Esta función solo se puede invocar antes de inicializar el grafo de escena y no tendrá ningún efecto si se invoca después. En la práctica, esto suele significar invocarla justo antes de QQuickRenderControl::initialize().
A modo de ejemplo, esta vez con Direct3D, se espera que el uso habitual sea el siguiente:
// native graphics resources set up by a custom D3D rendering engine
ID3D11Device *device;
ID3D11DeviceContext *context;
ID3D11Texture2D *texture;
...
// now to redirect Qt Quick content into 'texture' we could do the following:
QQuickRenderControl *renderControl = new QQuickRenderControl;
QQuickWindow *window = new QQuickWindow(renderControl); // this window will never be shown on-screen
...
window->setGraphicsDevice(QQuickGraphicsDevice::fromDeviceAndContext(device, context));
renderControl->initialize();
window->setRenderTarget(QQuickRenderTarget::fromD3D11Texture(texture, textureSize);
...El aspecto clave al utilizar esta función es garantizar que los recursos o los identificadores de recursos, como texture en el ejemplo anterior, sean visibles y utilizables tanto por el motor de renderizado externo como por el renderizador del grafo de escena. Esto requiere utilizar el mismo dispositivo gráfico (o, en el caso de OpenGL, el mismo contexto de OpenGL).
QQuickGraphicsDevice Las instancias se comparten implícitamente, son copiables y pueden pasarse por valor. No son propietarias de los objetos nativos asociados (como, por ejemplo, el `ID3D11Device` del ejemplo).
Nota: El uso de ` QQuickRenderControl ` no implica siempre tener que llamar a esta función. Cuando no sea necesario adoptar un dispositivo o contexto existente, no se debe llamar a esta función, y el grafo de escena inicializará entonces sus propios dispositivos y contextos de forma normal, tal y como lo haría con un ` QQuickWindow` en pantalla.
Esta función se introdujo en Qt 6.0.
Véase también graphicsDevice(), QQuickRenderControl, setRenderTarget() y setGraphicsApi().
void QQuickWindow::setPersistentGraphics(bool persistent)
Establece si los recursos gráficos (dispositivo o contexto gráfico, cadena de intercambio, búferes, texturas) deben conservarse y no pueden liberarse hasta que se elimine la última ventana, mediante la función ` persistent`. El valor por defecto es `true`.
Al llamar a ` releaseResources()` o cuando la ventana queda oculta (más concretamente, cuando ya no se puede renderizar), algunos bucles de renderizado tienen la posibilidad de liberar todos los recursos gráficos, no solo los almacenados en caché. Esto puede liberar memoria temporalmente, pero también significa que el motor de renderizado tendrá que realizar una reinicialización completa —y potencialmente costosa— de los recursos cuando la ventana necesite volver a renderizarse.
Nota: Las reglas que determinan cuándo una ventana no es renderizable dependen de la plataforma y del gestor de ventanas.
Nota: Todos los recursos gráficos se liberan cuando se elimina el último ` QQuickWindow `, independientemente de esta configuración.
Nota: Se tratade una sugerencia, y no se garantiza que se tenga en cuenta.
Nota: Esta sugerencia no se aplica a los recursos almacenados en caché, cuya eliminación y posterior recreación resultan relativamente baratas. Por lo tanto, llamar a ` releaseResources()` suele provocar la liberación de dichos recursos, independientemente del valor de esta sugerencia.
Véase también ` isPersistentGraphics()`, ` setPersistentSceneGraph()`, ` sceneGraphInitialized()`, ` sceneGraphInvalidated()` y ` releaseResources()`.
void QQuickWindow::setPersistentSceneGraph(bool persistent)
Establece si los nodos y recursos del grafo de escena son « persistent ». «Persistent» significa que los nodos y recursos no pueden liberarse. El valor por defecto es « true ».
Al llamar a releaseResources(), cuando la ventana queda oculta (más concretamente, cuando no es renderizable), algunos bucles de renderizado tienen la posibilidad de liberar los nodos del grafo de escena y los recursos gráficos relacionados. Esto libera memoria temporalmente, pero también implica que habrá que reconstruir el grafo de escena la próxima vez que se renderice la ventana.
Nota: Las reglas que determinan cuándo una ventana no es renderizable dependen de la plataforma y del gestor de ventanas.
Nota: Los nodosdel grafo de escena y los recursos siempre se liberan cuando se elimina el último ` QQuickWindow `, independientemente de esta configuración.
Nota: Se tratade una sugerencia, y no se garantiza que se tenga en cuenta.
Véase también isPersistentSceneGraph(), setPersistentGraphics(), sceneGraphInvalidated(), sceneGraphInitialized() y releaseResources().
[since 6.0] void QQuickWindow::setRenderTarget(const QQuickRenderTarget &target)
Establece el destino de renderizado de esta ventana en un objeto ` target`.
Un ` QQuickRenderTarget ` actúa como un identificador opaco para un objeto nativo renderizable, normalmente una textura 2D, y los metadatos asociados, como el tamaño en píxeles.
Un ` QQuickRenderTarget ` creado de forma predeterminada implica que no hay redirección. Por el contrario, un ` target` válido, creado mediante una de las funciones de fábrica estáticas ` QQuickRenderTarget `, permite la redirección del renderizado de la escena ` Qt Quick `: ya no se dirigirá a los búferes de color de la superficie asociada a la ventana, sino a las texturas u otros objetos gráficos especificados en ` target`.
Por ejemplo, suponiendo que el grafo de escena utilice Vulkan para el renderizado, se puede redirigir su salida a un ` VkImage`. En el caso de las API gráficas como Vulkan, también debe proporcionarse la disposición de la imagen. Las instancias de ` QQuickRenderTarget ` se comparten de forma implícita, son copiables y pueden pasarse por valor. Sin embargo, no son propietarias de los objetos nativos asociados (como, por ejemplo, el `VkImage` del ejemplo).
QQuickRenderTarget rt = QQuickRenderTarget::fromVulkanImage(vulkanImage, VK_IMAGE_LAYOUT_PREINITIALIZED, pixelSize);
quickWindow->setRenderTarget(rt);Esta función se utiliza muy a menudo en combinación con ` QQuickRenderControl ` y un ` QQuickWindow` invisible, con el fin de renderizar contenido de ` Qt Quick ` en una textura, sin crear una ventana nativa en pantalla para este ` QQuickWindow`.
Cuando cambie el destino deseado o los datos asociados, como el tamaño, llama a esta función con un nuevo ` QQuickRenderTarget`. Crear instancias de ` QQuickRenderTarget ` y llamar a esta función no supone un gran coste, pero ten en cuenta que establecer un nuevo ` target ` con un objeto nativo diferente u otros datos puede dar lugar a pasos de inicialización potencialmente costosos cuando el grafo de escena esté a punto de renderizar el siguiente fotograma. Por lo tanto, cambia el destino solo cuando sea necesario.
Nota: La ventana no asume la propiedad de ningún objeto nativo al que se haga referencia en target.
Nota: Es responsabilidad del llamante asegurarse de que los objetos nativos a los que se hace referencia en target también sean válidos para el renderizador del grafo de escena. Por ejemplo, con Vulkan, Metal y Direct3D, esto implica que la textura o la imagen se haya creado en el mismo dispositivo gráfico que utiliza internamente el grafo de escena. Por lo tanto, cuando intervienen objetos de textura creados en un dispositivo o contexto ya existente, esta función se utiliza a menudo en combinación con ` setGraphicsDevice()`.
Nota: En las API gráficas en las que sea relevante, la aplicación debe prestar atención a las transiciones de disposición de imágenes realizadas por el grafo de escena. Por ejemplo, una vez que un `VkImage` se asocia al grafo de escena mediante la llamada a esta función, su disposición pasará a ` VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL ` al renderizar un fotograma.
Advertencia: Esta función solo se puede invocar desde el hilo que realiza el renderizado.
Esta función se introdujo en Qt 6.0.
Véase también renderTarget(), QQuickRenderControl, setGraphicsDevice() y setGraphicsApi().
[static] void QQuickWindow::setSceneGraphBackend(const QString &backend)
Solicita un grafo de escena de Qt Quick backend . Los backends pueden ser integrados o instalarse en forma de complementos cargados dinámicamente.
Nota: La llamada a la función debe realizarse antes de construir el primer QQuickWindow en la aplicación. No se puede modificar posteriormente.
Consulta «Cambiar entre adaptaciones en tu aplicación» para obtener más información sobre la lista de backends. Si backend no es válido o se produce un error, la solicitud se ignora.
Nota: Llamar a esta función equivale a establecer las variables de entorno ` QT_QUICK_BACKEND ` o ` QMLSCENE_DEVICE `. Sin embargo, esta API es más segura de usar en aplicaciones que generan otros procesos, ya que no hay que preocuparse por la herencia del entorno.
Véase también sceneGraphBackend().
[static] void QQuickWindow::setTextRenderType(QQuickWindow::TextRenderType renderType)
Establece el tipo de representación predeterminado de los elementos de tipo texto en Qt Quick como renderType.
Nota: la configuración del tipo de representación solo afectará a los elementos creados a partir de ese momento; el tipo de representación de los elementos existentes no se modificará.
Véase también textRenderType().
[override virtual protected] void QQuickWindow::showEvent(QShowEvent *)
Reimplementa: QWindow::showEvent(QShowEvent *ev).
[since 6.6] QRhiSwapChain *QQuickWindow::swapChain() const
Devuelve el « QRhiSwapChain » utilizado por esta ventana, si lo hay.
Nota: Solo las ventanas en pantalla respaldadas por uno de los bucles de renderizado estándar (como basic o threaded) tendrán una cadena de intercambio. En caso contrario, el valor devuelto será nulo. Por ejemplo, el resultado siempre es nulo cuando la ventana se utiliza con QQuickRenderControl.
Esta función se introdujo en Qt 6.6.
[override virtual protected] void QQuickWindow::tabletEvent(QTabletEvent *event)
Reimplementa: QWindow::tabletEvent(QTabletEvent *ev).
[static] QQuickWindow::TextRenderType QQuickWindow::textRenderType()
Devuelve el tipo de representación de los elementos de tipo texto en Qt Quick. El valor por defecto es QQuickWindow::QtTextRendering.
Véase también setTextRenderType().
[slot] void QQuickWindow::update()
Programa la ventana para que represente otro fotograma.
La llamada a `QQuickWindow::update()` se diferencia de ` QQuickItem::update()` en que siempre provoca un repintado, independientemente de si se han producido cambios en el grafo de escena subyacente o no.
[override virtual protected] void QQuickWindow::wheelEvent(QWheelEvent *event)
Reimplementa: QWindow::wheelEvent(QWheelEvent *ev).
© 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.