QQuickWindow Class

Documentation des fonctions membres

[explicit] QQuickWindow::QQuickWindow(QQuickRenderControl *control)

Crée une fenêtre permettant d'afficher une scène QML, dont le rendu sera géré par l'objet ` control `. Pour plus d'informations, veuillez consulter la documentation disponible à l'adresse QQuickRenderControl.

[explicit] QQuickWindow::QQuickWindow(QWindow *parent = nullptr)

Crée une fenêtre permettant d'afficher une scène QML dont la fenêtre parente est parent.

[override virtual noexcept] QQuickWindow::~QQuickWindow()

Supprime la fenêtre.

[override virtual] QAccessibleInterface *QQuickWindow::accessibleRoot() const

Renvoie une interface d'accessibilité pour cette fenêtre, ou 0 si une telle interface ne peut pas être créée.

[signal] void QQuickWindow::afterAnimating()

Ce signal est émis sur le thread de l'interface graphique avant de demander au thread de rendu d'effectuer la synchronisation de l'arborescence de scène.

Contrairement aux autres signaux similaires, celui-ci est émis sur le thread de l'interface graphique plutôt que sur le thread de rendu. Il peut être utilisé pour synchroniser des systèmes d'animation externes avec le contenu QML. Cela signifie également que ce signal n'est pas adapté au déclenchement d'opérations graphiques.

[signal, since 6.0] void QQuickWindow::afterFrameEnd()

Ce signal est émis lorsque le graphe de scène a soumis une image. Il est émis après tous les autres signaux associés, tels que ` afterRendering()`. Il s'agit du dernier signal émis par le thread de rendu du graphe de scène lors du rendu d'une image.

Cette fonction a été introduite dans Qt 6.0.

Voir également beforeFrameBegin() et rendererInterface().

[signal] void QQuickWindow::afterRenderPassRecording()

Ce signal est émis une fois que le graphe de scène a enregistré les commandes relatives à son passage de rendu principal, mais que ce passage n'est pas encore finalisé dans le tampon de commandes.

Ce signal est émis avant l'appel à ` afterRendering()`, et il garantit que non seulement l'image, mais aussi l'enregistrement du passage de rendu principal du graphe de scène sont toujours actifs. Cela permet d'insérer des commandes sans avoir à générer un passage de rendu complet et distinct (ce qui effacerait généralement les images associées). Les objets graphiques natifs peuvent être interrogés via ` QSGRendererInterface`.

Voir également rendererInterface() et « Graphique de scène - RHI » dans la section QML.

[signal] void QQuickWindow::afterRendering()

Le signal est émis une fois que le graphe de scène a ajouté ses commandes au tampon de commandes, qui n’a pas encore été soumis à la file d’attente graphique. Si vous le souhaitez, la fonction de slot connectée à ce signal peut interroger les ressources natives, telles que le tampon de commandes, avant l'appel à ` QSGRendererInterface`. Notez toutefois que le ou les passages de rendu sont déjà enregistrés à ce stade et qu'il n'est pas possible d'ajouter d'autres commandes au sein du passage du graphe de scène. Utilisez plutôt afterRenderPassRecording() à cette fin. Ce signal a donc une utilité limitée dans Qt 6, contrairement à Qt 5. C’est plutôt la combinaison de beforeRendering() et beforeRenderPassRecording(), ou de beforeRendering() et afterRenderPassRecording(), qui est généralement utilisée pour réaliser la superposition ou la sous-superposition du rendu personnalisé.

Voir également rendererInterface(), Graphique de scène - RHI sous QML, Graphique de scène - OpenGL sous QML, Graphique de scène - Metal sous QML, Graphique de scène - Vulkan sous QML et Graphique de scène - Direct3D 11 sous QML.

[signal] void QQuickWindow::afterSynchronizing()

Ce signal est émis une fois que le graphe de scène est synchronisé avec l'état QML.

Ce signal peut être utilisé pour effectuer les préparatifs nécessaires après les appels à ` QQuickItem::updatePaintNode()`, tant que le thread de l'interface graphique est encore verrouillé.

Lors de l’utilisation d’OpenGL, l’ QOpenGLContext utilisé pour le rendu par le graphe de scène sera lié à ce moment-là.

[signal, since 6.0] void QQuickWindow::beforeFrameBegin()

Ce signal est émis avant que le graphe de scène ne commence à préparer l'image. Il précède des signaux tels que beforeSynchronizing() ou beforeRendering(). Il s'agit du premier signal émis par le thread de rendu du graphe de scène lorsqu'il commence à préparer une nouvelle image.

Ce signal est pertinent pour les frameworks graphiques de bas niveau qui doivent exécuter certaines opérations, telles que le nettoyage des ressources, à un stade où Qt Quick n’a pas encore lancé l’enregistrement d’une nouvelle image via les API de l’interface matérielle de rendu sous-jacente.

Cette fonction a été introduite dans Qt 6.0.

Voir également ` afterFrameEnd()` et ` rendererInterface()`.

[signal] void QQuickWindow::beforeRenderPassRecording()

Ce signal est émis avant que le graphisme de scène ne commence à enregistrer les commandes pour le passage de rendu principal. (Les calques ont leurs propres passages et sont entièrement enregistrés au moment où ce signal est émis.) Le passage de rendu est déjà actif dans le tampon de commandes lorsque le signal est émis.

Ce signal est émis après l’appel ` beforeRendering()` et garantit que non seulement l’image, mais aussi l’enregistrement du passage de rendu principal du graphisme de scène sont actifs. Cela permet d’insérer des commandes sans avoir à générer un passage de rendu complet et distinct (ce qui effacerait généralement les images associées). Les objets graphiques natifs peuvent être interrogés via ` QSGRendererInterface`.

Voir également rendererInterface() et « Graphique de scène - RHI » sous QML.

[signal] void QQuickWindow::beforeRendering()

Ce signal est émis une fois que les préparatifs pour l'image sont terminés, ce qui signifie qu'il existe un tampon de commandes en mode enregistrement, le cas échéant. Si vous le souhaitez, la fonction de slot connectée à ce signal peut interroger les ressources natives, comme la commande précédente, via QSGRendererInterface. Notez toutefois que l'enregistrement du passage de rendu principal n'a pas encore commencé à ce stade et qu'il n'est pas possible d'ajouter des commandes au sein de ce passage. Lancer un passage implique d’effacer les tampons de couleur, de profondeur et de stencil ; il n’est donc pas possible d’obtenir un rendu de type « underlay » en se contentant de se connecter à ce signal. Il est préférable de se connecter à ` beforeRenderPassRecording()`. Toutefois, la connexion à ce signal reste importante si l’on souhaite enregistrer des commandes de type « copy », car celles-ci ne peuvent pas être mises en file d’attente au sein d’un passage de rendu.

Voir également rendererInterface(), Graphique de scène - RHI sous QML, Graphique de scène - OpenGL sous QML, Graphique de scène - Metal sous QML, Graphique de scène - Vulkan sous QML et Graphique de scène - Direct3D 11 sous QML.

[signal] void QQuickWindow::beforeSynchronizing()

Ce signal est émis avant que le graphe de scène ne soit synchronisé avec l'état QML.

Même si le signal est émis depuis le thread de rendu du graphe de scène, le thread de l'interface graphique est garanti d'être bloqué, comme c'est le cas dans ` QQuickItem::updatePaintNode()` (). Par conséquent, il est possible d'accéder en toute sécurité aux données du thread de l'interface graphique dans un slot ou un lambda connecté à ` Qt::DirectConnection`.

Ce signal peut être utilisé pour effectuer toute préparation nécessaire avant les appels à ` QQuickItem::updatePaintNode()`.

Lors de l’utilisation d’OpenGL, le QOpenGLContext utilisé pour le rendu par le graphe de scène sera lié à ce stade.

void QQuickWindow::beginExternalCommands()

Lorsqu'on combine des commandes graphiques brutes (OpenGL, Vulkan, Metal, etc.) avec le rendu via le graphe de scène, il est nécessaire d'appeler cette fonction avant d'enregistrer les commandes dans le tampon de commandes utilisé par le graphe de scène pour effectuer son passage de rendu principal. Cela permet d'éviter de corrompre l'état.

En pratique, cette fonction est souvent appelée depuis un slot connecté aux signaux « beforeRenderPassRecording() » ou « afterRenderPassRecording() ».

Il n’est pas nécessaire d’appeler cette fonction lors de l’enregistrement de commandes dans le tampon de commandes propre à l’application (tel qu’un `VkCommandBuffer` ou un `MTLCommandBuffer` + `MTLRenderCommandEncoder` créé et géré par l’application, et non récupéré à partir du graphe de scène). Avec les API graphiques qui n’exposent pas de concept natif de tampon de commandes (OpenGL, Direct 3D 11), les fonctions beginExternalCommands() et endExternalCommands() remplacent ensemble la fonction resetOpenGLState() de Qt 5.

L’appel de cette fonction et de ` endExternalCommands()` n’est pas nécessaire dans l’implémentation de ` render()` d’un nœud de rendu ( QSGRenderNode ), car le graphe de scène effectue implicitement les étapes nécessaires pour les nœuds de rendu.

Les objets graphiques natifs (tels que le périphérique graphique, le tampon de commandes ou l'encodeur) sont accessibles via QSGRendererInterface::getResource().

Voir également endExternalCommands() et QQuickOpenGLUtils::resetOpenGLState().

[override virtual protected] void QQuickWindow::closeEvent(QCloseEvent *e)

Réimplémente : QWindow::closeEvent(QCloseEvent *ev).

QSGImageNode *QQuickWindow::createImageNode() const

Crée un nœud d'image simple. Si le graphe de scène n'est pas initialisé, la valeur renvoyée est nulle.

Il s'agit d'une alternative multi-backends à la construction directe d'un ` QSGSimpleTextureNode `.

Voir également QSGImageNode.

QSGNinePatchNode *QQuickWindow::createNinePatchNode() const

Crée un nœud « nine patch ». Si le graphe de scène n'est pas initialisé, la valeur renvoyée est nulle.

QSGRectangleNode *QQuickWindow::createRectangleNode() const

Crée un nœud rectangle simple. Si le graphe de scène n'est pas initialisé, la valeur renvoyée est nulle.

Il s'agit d'une alternative multi-backends à la construction directe d'un ` QSGSimpleRectNode `.

Voir également QSGRectangleNode.

[since 6.7] QSGTextNode *QQuickWindow::createTextNode() const

Crée un nœud de texte. Si le graphe de scène n'est pas initialisé, la valeur renvoyée est nulle.

Cette fonction a été introduite dans Qt 6.7.

Voir aussi QSGTextNode.

QSGTexture *QQuickWindow::createTextureFromImage(const QImage &image, QQuickWindow::CreateTextureOptions options) const

Crée une nouvelle texture ` QSGTexture ` à partir de l’image fournie ` image`. Si l’image possède un canal alpha, la texture correspondante possédera également un canal alpha.

L'appelant de la fonction est chargé de supprimer la texture renvoyée. L'objet de texture natif sous-jacent est alors détruit en même temps que l'QSGTexture.

Lorsque ` options ` contient ` TextureCanUseAtlas`, le moteur peut intégrer l’image dans un atlas de textures. Les textures d’un atlas doivent s’appuyer sur ` QSGTexture::normalizedTextureSubRect()` pour leur géométrie et ne prendront pas en charge ` QSGTexture::Repeat`. Les autres valeurs de ` CreateTextureOption ` sont ignorées.

Lorsque options contient TextureIsOpaque, le moteur créera une texture RVB qui renvoie « false » pour la fonction QSGTexture::hasAlphaChannel(). Les textures opaques seront, dans la plupart des cas, plus rapides à rendre. Lorsque cet indicateur n’est pas activé, la texture disposera d’un canal alpha basé sur le format de l’image.

Lorsque ` options ` contient ` TextureHasMipmaps`, le moteur créera une texture pouvant utiliser le filtrage mipmap. Les textures mipmappées ne peuvent pas figurer dans un atlas.

Définir ` TextureHasAlphaChannel ` sur ` options ` n’a aucun effet pour cette fonction, car la présence d’un canal alpha et le mélange sont activés par défaut. Pour désactiver cette fonctionnalité, définissez ` TextureIsOpaque`.

Lorsque le graphe de scène utilise OpenGL, la texture renvoyée utilisera GL_TEXTURE_2D comme cible de texture et GL_RGBA comme format interne. Avec d’autres API graphiques, le format de texture est généralement RGBA8. Réimplémentez QSGTexture pour créer des textures avec des paramètres différents.

Cette fonction peut être appelée aussi bien depuis le thread principal que depuis le thread de rendu.

Voir également sceneGraphInitialized() et QSGTexture.

QSGTexture *QQuickWindow::createTextureFromImage(const QImage &image) const

[since 6.6] QSGTexture *QQuickWindow::createTextureFromRhiTexture(QRhiTexture *texture, QQuickWindow::CreateTextureOptions options = {}) const

Crée une nouvelle instance de ` QSGTexture ` à partir de l'objet ` texture` fourni.

Utilisez options pour personnaliser les attributs de la texture. Seul l'indicateur TextureHasAlphaChannel est pris en compte par cette fonction. Lorsqu'il est activé, l'QSGTexture résultante est toujours traitée par le moteur de rendu du graphe de scène comme nécessitant un mélange. Pour les textures entièrement opaques, ne pas activer cet indicateur permet d'économiser le coût lié à l'exécution d'un mélange alpha lors du rendu. Ce drapeau n’a aucun lien direct avec l’ format de l’ QRhiTexture, c’est-à-dire qu’il est tout à fait normal de ne pas le définir tout en utilisant un format de texture tel que le format couramment utilisé QRhiTexture::RGBA8.

Le mipmapping n’est pas contrôlé par options, car texture est déjà créé et intègre la présence ou l’absence de mipmaps.

L’objet ` QSGTexture ` renvoyé est propriétaire de l’objet ` QRhiTexture`, ce qui signifie que l’objet ` texture ` est détruit en même temps que l’objet ` QSGTexture` renvoyé.

Si ` texture ` détient ses ressources graphiques natives sous-jacentes (objet de texture OpenGL, image Vulkan, etc.), cela dépend de la manière dont ` QRhiTexture ` a été créé (`QRhiTexture::create()` ou ` QRhiTexture::createFrom()`), et cela n’est ni contrôlé ni modifié par cette fonction.

Cette fonction a été introduite dans Qt 6.6.

Voir également createTextureFromImage(), sceneGraphInitialized() et QSGTexture.

[signal, since 6.11] void QQuickWindow::devicePixelRatioChanged()

Ce signal est émis lorsque le rapport de pixels effectif de l'appareil a été modifié.

Cette fonction a été introduite dans Qt 6.11.

Voir également ` effectiveDevicePixelRatio()`.

qreal QQuickWindow::effectiveDevicePixelRatio() const

Renvoie le rapport de pixels de l'appareil pour cette fenêtre.

Cette fonction diffère de ` QWindow::devicePixelRatio()` en ce qu’elle prend en charge le rendu redirigé via ` QQuickRenderControl ` et ` QQuickRenderTarget`. Lors de l’utilisation d’un ` QQuickRenderControl`, la ` QQuickWindow ` n’est souvent pas entièrement créée, ce qui signifie qu’elle n’est jamais affichée et qu’aucune fenêtre native sous-jacente n’est créée dans le système de fenêtrage. Par conséquent, l'interrogation de propriétés telles que le rapport de pixels de l'appareil ne peut pas donner de résultats corrects. Cette fonction prend en compte à la fois QQuickRenderControl::renderWindowFor() et QQuickRenderTarget::devicePixelRatio(). Lorsqu'aucune redirection n'est active, le résultat est identique à celui de QWindow::devicePixelRatio().

Voir également QQuickRenderControl, QQuickRenderTarget, setRenderTarget() et QWindow::devicePixelRatio().

void QQuickWindow::endExternalCommands()

Lorsqu'on combine des commandes graphiques brutes (OpenGL, Vulkan, Metal, etc.) avec le rendu via le graphe de scène, il est nécessaire d'appeler cette fonction après avoir enregistré les commandes dans le tampon de commandes utilisé par le graphe de scène pour effectuer son passage de rendu principal. Cela permet d'éviter toute corruption de l'état.

En pratique, cette fonction est souvent appelée depuis un slot connecté aux signaux « beforeRenderPassRecording() » ou « afterRenderPassRecording() ».

Il n’est pas nécessaire d’appeler cette fonction lors de l’enregistrement de commandes dans le tampon de commandes propre à l’application (tel qu’un VkCommandBuffer ou un MTLCommandBuffer + MTLRenderCommandEncoder créé et géré par l’application, et non récupéré à partir du graphe de scène). Avec les API graphiques qui n’exposent pas de concept natif de tampon de commandes (OpenGL, Direct 3D 11), les fonctions beginExternalCommands() et endExternalCommands() remplacent ensemble la fonction resetOpenGLState() de Qt 5.

L’appel de cette fonction et de ` beginExternalCommands()` n’est pas nécessaire dans l’implémentation de ` render()` d’un nœud de rendu ( QSGRenderNode ), car le graphe de scène effectue implicitement les étapes nécessaires pour les nœuds de rendu.

Voir également beginExternalCommands() et QQuickOpenGLUtils::resetOpenGLState().

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

Réimplémente : QWindow::event(QEvent *ev).

[override virtual protected] void QQuickWindow::exposeEvent(QExposeEvent *)

Réimplémente : QWindow::exposeEvent(QExposeEvent *ev).

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

Réimplémente : QWindow::focusInEvent(QFocusEvent *ev).

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

Réimplémente : QWindow::focusOutEvent(QFocusEvent *ev).

[signal] void QQuickWindow::frameSwapped()

Ce signal est émis lorsqu'une image a été mise en file d'attente en vue de son affichage. Lorsque la synchronisation verticale est activée, le signal est émis au maximum une fois par intervalle de vsync dans une scène en animation continue.

Ce signal sera émis par le thread de rendu du graphe de scène.

QImage QQuickWindow::grabWindow()

Récupère le contenu de la fenêtre et le renvoie sous forme d'image.

Il est possible d'appeler la fonction `grabWindow()` lorsque la fenêtre n'est pas visible. Pour cela, il faut que la fenêtre soit de type ` created `, qu'elle ait une taille valide et qu'aucune autre instance de ` QQuickWindow ` ne soit en cours de rendu dans le même processus.

[static, since 6.0] QSGRendererInterface::GraphicsApi QQuickWindow::graphicsApi()

Renvoie l'API graphique qui serait utilisée par le graphe de scène s'il était initialisé à ce moment-là.

La méthode standard pour interroger l’API utilisée par le graphe de scène consiste à utiliser ` QSGRendererInterface::graphicsApi()` une fois que le graphe de scène a été initialisé, par exemple lorsque le signal ` sceneGraphInitialized()` est émis ou après celui-ci. Dans ce cas, on obtient le résultat réel et exact, car on sait alors que tout a été initialisé correctement à l’aide de cette API graphique.

Ce n’est pas toujours pratique. Si l’application doit configurer des frameworks externes, ou si elle doit utiliser la fonction ` setGraphicsDevice()` d’une manière qui dépend de la logique de sélection d’API intégrée au graphe de scène, il n’est pas toujours possible de reporter ces opérations jusqu’à ce que le signal ` QQuickWindow ` soit rendu visible ou que la fonction ` QQuickRenderControl::initialize()` ait été appelée.

C’est pourquoi cette fonction statique est fournie en complément de ` setGraphicsApi()` : elle peut être appelée à tout moment, et son résultat reflète l’API que le graphe de scène choisirait s’il était initialisé au moment de l’appel.

Cette fonction a été introduite dans Qt 6.0.

Voir également setGraphicsApi().

[since 6.0] QQuickGraphicsConfiguration QQuickWindow::graphicsConfiguration() const

Renvoie l'QQuickGraphicsConfiguration e passé à la fonction ` setGraphicsConfiguration()`, ou un objet construit par défaut dans le cas contraire.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi setGraphicsConfiguration().

[since 6.0] QQuickGraphicsDevice QQuickWindow::graphicsDevice() const

Renvoie l'QQuickGraphicsDevice e passé à la fonction setGraphicsDevice(), ou un objet construit par défaut dans le cas contraire

Cette fonction a été introduite dans Qt 6.0.

Voir aussi setGraphicsDevice().

const QQuickWindow::GraphicsStateInfo &QQuickWindow::graphicsStateInfo()

Renvoie une référence à une structure ` GraphicsStateInfo ` décrivant certains aspects de l'état interne du RHI, notamment l'état de la mise en mémoire tampon double ou triple du backend (comme les intégrations Vulkan ou Metal). Cela s'applique lorsque les API graphiques sous-jacentes sont Vulkan ou Metal, et que le code de rendu externe souhaite effectuer un double ou un triple buffering de ses propres ressources en constante évolution, telles que les tampons uniformes, afin d'éviter de bloquer le pipeline.

[static] bool QQuickWindow::hasDefaultAlphaBuffer()

Indique s'il faut utiliser la transparence alpha sur les fenêtres nouvellement créées.

Voir aussi setDefaultAlphaBuffer().

[override virtual protected] void QQuickWindow::hideEvent(QHideEvent *)

Réimplémente : QWindow::hideEvent(QHideEvent *ev).

QQmlIncubationController *QQuickWindow::incubationController() const

Renvoie un contrôleur d'incubation qui intercaler l'incubation entre les images de cette fenêtre. QQuickView installe automatiquement ce contrôleur pour vous ; sinon, vous devrez l'installer vous-même à l'aide de QQmlEngine::setIncubationController().

Le contrôleur appartient à la fenêtre et sera détruit lorsque celle-ci sera supprimée.

bool QQuickWindow::isPersistentGraphics() const

Indique si les ressources graphiques essentielles peuvent être libérées pendant la durée de vie de l'QQuickWindow.

Voir également setPersistentGraphics().

bool QQuickWindow::isPersistentSceneGraph() const

Indique si les nœuds et les ressources du graphe de scène peuvent être libérés pendant la durée de vie de cet objet ` QQuickWindow`.

bool QQuickWindow::isSceneGraphInitialized() const

Renvoie « true » si le graphe de scène a été initialisé ; sinon, renvoie « false ».

[override virtual protected] void QQuickWindow::keyPressEvent(QKeyEvent *e)

Réimplémente : QWindow::keyPressEvent(QKeyEvent *ev).

[override virtual protected] void QQuickWindow::keyReleaseEvent(QKeyEvent *e)

Réimplémente : QWindow::keyReleaseEvent(QKeyEvent *ev).

[override virtual protected] void QQuickWindow::mouseDoubleClickEvent(QMouseEvent *event)

Réimplémente : QWindow::mouseDoubleClickEvent(QMouseEvent *ev).

[override virtual protected] void QQuickWindow::mouseMoveEvent(QMouseEvent *event)

Réimplémente : QWindow::mouseMoveEvent(QMouseEvent *ev).

[override virtual protected] void QQuickWindow::mousePressEvent(QMouseEvent *event)

Réimplémente : QWindow::mousePressEvent(QMouseEvent *ev).

[override virtual protected] void QQuickWindow::mouseReleaseEvent(QMouseEvent *event)

Réimplémente : QWindow::mouseReleaseEvent(QMouseEvent *ev).

[slot] void QQuickWindow::releaseResources()

Cette fonction tente de libérer les ressources redondantes actuellement occupées par la scène QML.

L'appel de cette fonction demande au graphe de scène de libérer les ressources graphiques mises en cache, telles que les objets du pipeline graphique, les programmes de shaders ou les données d'image.

De plus, selon la boucle de rendu utilisée, cette fonction peut également entraîner la libération du graphe de scène et de toutes les ressources de rendu liées aux fenêtres. Si cela se produit, le signal « sceneGraphInvalidated() » sera émis, permettant aux utilisateurs de nettoyer leurs propres ressources graphiques. Les fonctions ` setPersistentGraphics()` et ` setPersistentSceneGraph()` peuvent être utilisées pour empêcher cela, si la gestion du nettoyage n’est pas réalisable dans l’application, au prix d’une utilisation plus importante de la mémoire.

Voir également sceneGraphInvalidated(), setPersistentGraphics() et setPersistentSceneGraph().

[since 6.0] QQuickRenderTarget QQuickWindow::renderTarget() const

Renvoie l’ QQuickRenderTarget e passé à la fonction ` setRenderTarget()`, ou un construit par défaut dans le cas contraire

Cette fonction a été introduite dans Qt 6.0.

Voir aussi setRenderTarget().

QSGRendererInterface *QQuickWindow::rendererInterface() const

Renvoie l'interface du moteur de rendu actuel. La valeur est toujours valide et n'est jamais nulle.

Voir également QSGRenderNode et QSGRendererInterface.

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

Réimplémente : QWindow::resizeEvent(QResizeEvent *ev).

[since 6.6] QRhi *QQuickWindow::rhi() const

Renvoie l'objet « QRhi » utilisé par cette fenêtre pour le rendu.

Disponible uniquement lorsque la fenêtre utilise l'API Qt 3D et les abstractions du langage de shading, ce qui signifie que le résultat est toujours nul lorsque l'on utilise l'adaptation « software ».

Le résultat n’est valide que lorsque le rendu a été initialisé, ce qui est indiqué par l’émission du signal ` sceneGraphInitialized()`. Avant ce moment, la valeur renvoyée est nulle. Avec une QQuickWindow à l’écran classique, l’initialisation du graphe de scène se produit généralement lorsque la fenêtre native est affichée (visible) pour la première fois. Lors de l'utilisation de ` QQuickRenderControl`, l'initialisation s'effectue lors de l'appel explicite à ` initialize()`.

En pratique, cette fonction est un raccourci permettant d’interroger l’ QRhi via ` QSGRendererInterface`.

Cette fonction a été introduite dans Qt 6.6.

[signal] void QQuickWindow::sceneGraphAboutToStop()

Ce signal est émis sur le thread de rendu lorsque le graphe de scène est sur le point d'arrêter le rendu. Cela se produit généralement parce que la fenêtre a été masquée.

Les applications peuvent utiliser ce signal pour libérer des ressources, mais doivent être prêtes à les réinstancier rapidement. Le graphe de scène et le contexte graphique ne sont pas libérés à ce moment-là.

Voir également sceneGraphInvalidated().

[static] QString QQuickWindow::sceneGraphBackend()

Renvoie le backend de scénographe Qt Quick demandé.

Voir aussi setSceneGraphBackend().

[signal] void QQuickWindow::sceneGraphError(QQuickWindow::SceneGraphError error, const QString &message)

Ce signal est émis lorsqu’une erreur « error » s’est produite lors de l’initialisation du graphe de scène.

Les applications doivent se connecter à ce signal si elles souhaitent gérer les erreurs, telles que les échecs de création de contexte graphique, de manière personnalisée. Lorsqu’aucun slot n’est connecté au signal, le comportement sera différent : Quick affichera l’ message, ou fera apparaître une boîte de message, puis mettra fin à l’application.

Ce signal sera émis depuis le thread de l'interface graphique.

[signal] void QQuickWindow::sceneGraphInitialized()

Ce signal est émis lorsque le graphe de scène a été initialisé.

Ce signal sera émis par le thread de rendu du graphe de scène.

[signal] void QQuickWindow::sceneGraphInvalidated()

Ce signal est émis lorsque le graphe de scène a été invalidé.

Ce signal implique que le contexte de rendu graphique utilisé a été invalidé et que toutes les ressources utilisateur liées à ce contexte doivent être libérées.

Lors du rendu avec OpenGL, l'QOpenGLContext de cette fenêtre sera liée lorsque cette fonction sera appelée. La seule exception concerne le cas où le contexte OpenGL natif a été détruit hors du contrôle de Qt, par exemple via EGL_CONTEXT_LOST.

Ce signal est émis par le thread de rendu de l’arborescence de scène.

void QQuickWindow::scheduleRenderJob(QRunnable *job, QQuickWindow::RenderStage stage)

La fonction ` job ` est programmée pour s'exécuter lorsque le rendu de cette fenêtre atteint l'stage` spécifiée.

Il s'agit d'une alternative pratique aux signaux équivalents de QQuickWindow pour les tâches « ponctuelles ».

La fenêtre prend en charge la gestion d'job et la supprimera une fois la tâche terminée.

Si le rendu est interrompu avant que job n’ait eu le temps de s’exécuter, la tâche sera exécutée puis supprimée dans le cadre du nettoyage de l’arbre de scène. Si la fenêtre n’est jamais affichée et qu’aucun rendu n’a lieu avant la destruction de QQuickWindow, toutes les tâches en attente seront détruites sans que leur méthode run() ne soit appelée.

Si le rendu s’effectue sur un autre thread, la tâche s’exécutera alors sur le thread de rendu.

Si ` stage ` est ` NoStage`, ` job ` sera exécutée dès que possible, dès que le thread de rendu ne sera pas occupé à rendre une image. Si la fenêtre n’est pas exposée et n’est pas rendable au moment où la tâche est soit postée, soit traitée, celle-ci est supprimée sans que la méthode `run()` ne soit exécutée. Si un moteur de rendu non multithread est utilisé, la méthode run() de la tâche est exécutée de manière synchrone. Lors du rendu avec OpenGL, le contexte OpenGL est remplacé par celui du moteur de rendu avant l’exécution de toute tâche, y compris les tâches de type « NoStage ».

Voir également beforeRendering(), afterRendering(), beforeSynchronizing(), afterSynchronizing(), frameSwapped() et sceneGraphInvalidated().

[static] void QQuickWindow::setDefaultAlphaBuffer(bool useAlpha)

useAlpha Indique s'il faut utiliser la transparence alpha sur les fenêtres nouvellement créées.

Dans toute application devant créer des fenêtres translucides, il est nécessaire de définir cette option sur « true » avant de créer la première instance de ` QQuickWindow`. La valeur par défaut est « false ».

Voir également hasDefaultAlphaBuffer().

[static, since 6.0] void QQuickWindow::setGraphicsApi(QSGRendererInterface::GraphicsApi api)

Demande l'api graphique spécifiée.

Lorsque l’adaptation graphique intégrée par défaut est utilisée, api spécifie quelle API graphique (OpenGL, Vulkan, Metal ou Direct3D) le graphe de scène doit utiliser pour le rendu. De plus, le backend software est également intégré et peut être demandé en définissant api sur QSGRendererInterface::Software.

Contrairement à la fonction ` setSceneGraphBackend()`, qui ne peut être utilisée que pour demander un backend donné (fourni soit de manière intégrée, soit installé sous forme de plugins chargés dynamiquement), cette fonction s’appuie sur le concept de plus haut niveau des API graphiques. Elle couvre les backends fournis avec ` Qt Quick` et dispose donc de valeurs correspondantes dans l’énumération ` QSGRendererInterface::GraphicsApi `.

Lorsque cette fonction n’est pas appelée et que la variable d’environnement équivalente QSG_RHI_BACKEND n’est pas définie non plus, le graphe de scène choisit l’API graphique à utiliser en fonction de la plateforme.

Cette fonction revêt une importance particulière dans les applications qui ne sont préparées que pour le rendu via une API donnée. Par exemple, si l’application effectue un rendu natif via OpenGL ou Vulkan, elle devra s’assurer que Qt Quick effectue également le rendu via OpenGL ou Vulkan. Ces applications sont censées appeler cette fonction dès le début de leur fonction main().

Pour connaître l’API graphique utilisée par le graphe de scène pour le rendu, appelez ` QSGRendererInterface::graphicsApi()` après la méthode ` has initialized` du graphe de scène, ce qui se produit généralement soit lorsque la fenêtre devient visible pour la première fois, soit lorsque ` QQuickRenderControl::initialize()` est appelée.

Pour revenir au comportement par défaut, dans lequel le graphe de scène choisit une API graphique en fonction de la plateforme et d’autres conditions, définissez ` api ` sur ` QSGRendererInterface::Unknown`.

Cette fonction a été introduite dans Qt 6.0.

Voir également graphicsApi().

[since 6.0] void QQuickWindow::setGraphicsConfiguration(const QQuickGraphicsConfiguration &config)

Définit la configuration graphique de cette fenêtre. La variable ` config ` contient divers paramètres pouvant être pris en compte par le graphe de scène lors de l’initialisation des périphériques et contextes graphiques sous-jacents.

Cette configuration supplémentaire, qui spécifie par exemple quelles extensions de périphérique activer pour Vulkan, devient pertinente et essentielle lors de l’intégration de code de rendu graphique natif qui repose sur certaines extensions. Il en va de même lors de l’intégration avec des moteurs 3D ou VR externes, tels qu’OpenXR.

QQuickGraphicsConfiguration Les instances sont implicitement partagées, copiables et peuvent être transmises par valeur.

Cette fonction a été introduite dans Qt 6.0.

Voir également graphicsConfiguration().

[since 6.0] void QQuickWindow::setGraphicsDevice(const QQuickGraphicsDevice &device)

Définit les objets du périphérique graphique pour cette fenêtre. Le graphe de scène utilisera le périphérique existant, le périphérique physique et les autres objets spécifiés par ` device ` au lieu d’en créer de nouveaux.

Cette fonction est très souvent utilisée en combinaison avec ` QQuickRenderControl ` et ` setRenderTarget()`, afin de rediriger le rendu de ` Qt Quick ` vers une texture.

Un objet ` QQuickGraphicsDevice ` construit par défaut ne modifie en rien le comportement par défaut. Dès qu’un objet ` device ` créé via l’une des fonctions d’usine ` QQuickGraphicsDevice `, telles que ` QQuickGraphicsDevice::fromDeviceObjects()`, est transmis, et que le graphe de scène utilise une API graphique correspondante (dans l’exemple de `fromDeviceObjects()`, il s’agirait de Vulkan), le graphe de scène utilisera les objets de périphérique existants (tels que VkPhysicalDevice, VkDevice et l’index de la famille de files d’attente graphiques, dans le cas de Vulkan) encapsulés par QQuickGraphicsDevice. Cela permet d’utiliser le même périphérique, et donc de partager des ressources, telles que les tampons et les textures, entre Qt Quick et les moteurs de rendu natifs.

À titre d’exemple, cette fois-ci avec Direct3D, l’utilisation typique devrait être la suivante :

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

L’aspect essentiel de l’utilisation de cette fonction est de s’assurer que les ressources ou les descripteurs de ressources, tels que ` texture ` dans l’exemple ci-dessus, sont visibles et utilisables à la fois par le moteur de rendu externe et par le moteur de rendu du graphe de scène. Cela nécessite d’utiliser le même périphérique graphique (ou, avec OpenGL, le même contexte OpenGL).

QQuickGraphicsDevice Les instances sont implicitement partagées, copiables et peuvent être transmises par valeur. Elles ne possèdent pas les objets natifs associés (tels que l’ID3D11Device dans l’exemple).

Cette fonction a été introduite dans Qt 6.0.

Voir également graphicsDevice(), QQuickRenderControl, setRenderTarget() et setGraphicsApi().

void QQuickWindow::setPersistentGraphics(bool persistent)

Détermine si les ressources graphiques (périphérique ou contexte graphique, chaîne d'échange, tampons, textures) doivent être conservées et ne peuvent être libérées avant la suppression de la dernière fenêtre, via la fonction ` persistent`. La valeur par défaut est `true`.

Lors de l’appel de ` releaseResources()` ou lorsque la fenêtre est masquée (plus précisément, lorsqu’elle n’est plus rendable), certaines boucles de rendu ont la possibilité de libérer toutes les ressources graphiques, et pas seulement celles mises en cache. Cela peut libérer temporairement de la mémoire, mais cela signifie également que le moteur de rendu devra procéder à une réinitialisation complète, potentiellement coûteuse, des ressources lorsque la fenêtre devra à nouveau être rendue.

Voir également isPersistentGraphics(), setPersistentSceneGraph(), sceneGraphInitialized(), sceneGraphInvalidated() et releaseResources().

void QQuickWindow::setPersistentSceneGraph(bool persistent)

Détermine si les nœuds et les ressources du graphe de scène sont « persistent ». « Persistent » signifie que les nœuds et les ressources ne peuvent pas être libérés. La valeur par défaut est « true ».

Lors de l’appel de la fonction releaseResources(), lorsque la fenêtre est masquée (plus précisément, lorsqu’elle n’est pas rendable), certaines boucles de rendu ont la possibilité de libérer les nœuds du graphe de scène et les ressources graphiques associées. Cela libère temporairement de la mémoire, mais implique également que le graphe de scène devra être reconstruit lors du prochain rendu de la fenêtre.

Voir également isPersistentSceneGraph(), setPersistentGraphics(), sceneGraphInvalidated(), sceneGraphInitialized() et releaseResources().

[since 6.0] void QQuickWindow::setRenderTarget(const QQuickRenderTarget &target)

Définit la cible de rendu de cette fenêtre sur ` target`.

Un ` QQuickRenderTarget ` sert de descripteur opaque pour un objet natif pouvant être rendu, le plus souvent une texture 2D, ainsi que pour les métadonnées associées, telles que la taille en pixels.

Un ` QQuickRenderTarget ` construit par défaut implique qu’il n’y a pas de redirection. En revanche, un ` target` valide, créé via l’une des fonctions d’usine statiques ` QQuickRenderTarget `, permet la redirection du rendu de la scène ` Qt Quick ` : celle-ci ne ciblera plus les tampons de couleur de la surface associée à la fenêtre, mais plutôt les textures ou autres objets graphiques spécifiés dans ` target`.

Par exemple, en supposant que le graphe de scène utilise Vulkan pour le rendu, on peut rediriger sa sortie vers un ` VkImage`. Pour les API graphiques telles que Vulkan, la disposition de l’image doit également être fournie. Les instances ` QQuickRenderTarget ` sont implicitement partagées ; elles sont copiables et peuvent être transmises par valeur. Elles ne possèdent toutefois pas les objets natifs associés (tels que le `VkImage` dans l’exemple).

QQuickRenderTarget rt = QQuickRenderTarget::fromVulkanImage(vulkanImage, VK_IMAGE_LAYOUT_PREINITIALIZED, pixelSize);
quickWindow->setRenderTarget(rt);

Cette fonction est très souvent utilisée en combinaison avec ` QQuickRenderControl ` et un ` QQuickWindow` invisible, afin de rendre le contenu d’ Qt Quick dans une texture, sans créer de fenêtre native à l’écran pour ce ` QQuickWindow`.

Lorsque la cible souhaitée, ou les données associées, telles que la taille, changent, appelez cette fonction avec une nouvelle instance de ` QQuickRenderTarget`. La création d’instances de ` QQuickRenderTarget ` et l’appel de cette fonction sont peu coûteux en ressources, mais sachez que définir une nouvelle ` target ` avec un objet natif différent ou d’autres données peut entraîner des étapes d’initialisation potentiellement coûteuses lorsque le graphe de scène s’apprête à afficher l’image suivante. Ne modifiez donc la cible qu’en cas de nécessité.

Cette fonction a été introduite dans Qt 6.0.

Voir également renderTarget(), QQuickRenderControl, setGraphicsDevice() et setGraphicsApi().

[static] void QQuickWindow::setSceneGraphBackend(const QString &backend)

Demande un graphe de scène « Qt Quick » backend. Les backends peuvent être soit intégrés, soit installés sous forme de plugins chargés dynamiquement.

Voir « Basculer entre les adaptations dans votre application » pour plus d’informations sur la liste des backends. Si ` backend ` n’est pas valide ou si une erreur se produit, la requête est ignorée.

Voir aussi sceneGraphBackend().

[static] void QQuickWindow::setTextRenderType(QQuickWindow::TextRenderType renderType)

Définit le type de rendu par défaut des éléments de type texte dans « Qt Quick » sur « renderType ».

Voir aussi textRenderType().

[override virtual protected] void QQuickWindow::showEvent(QShowEvent *)

Réimplémente : QWindow::showEvent(QShowEvent *ev).

[since 6.6] QRhiSwapChain *QQuickWindow::swapChain() const

Renvoie l'QRhiSwapChain utilisé par cette fenêtre, s'il y en a un.

Cette fonction a été introduite dans Qt 6.6.

[override virtual protected] void QQuickWindow::tabletEvent(QTabletEvent *event)

Réimplémente : QWindow::tabletEvent(QTabletEvent *ev).

[static] QQuickWindow::TextRenderType QQuickWindow::textRenderType()

Renvoie le type de rendu des éléments de type texte dans Qt Quick. La valeur par défaut est QQuickWindow::QtTextRendering.

Voir également setTextRenderType().

[slot] void QQuickWindow::update()

Planifie le rendu d'une nouvelle image par la fenêtre.

L'appel à `QQuickWindow::update()` diffère de celui à ` QQuickItem::update()` en ce sens qu'il déclenche toujours un rafraîchissement, qu'il y ait ou non des modifications dans le graphe de scène sous-jacent.

[override virtual protected] void QQuickWindow::wheelEvent(QWheelEvent *event)

Réimplémente : QWindow::wheelEvent(QWheelEvent *ev).