Qt GUI Vue d'ensemble

Le module Qt GUI fournit des classes pour l'intégration du système de fenêtrage, la gestion des événements, l'intégration d'OpenGL et d'OpenGL ES, les graphiques 2D, l'imagerie de base, les polices de caractères et le texte. Ces classes sont utilisées en interne par les technologies d'interface utilisateur de Qt mais peuvent également être utilisées directement, par exemple pour écrire des applications utilisant les API graphiques OpenGL ES de bas niveau.

Pour les développeurs d'applications qui écrivent des interfaces utilisateur, Qt fournit des API de plus haut niveau, comme Qt Quick, qui sont beaucoup plus adaptées que les facilitateurs trouvés dans le module Qt GUI.

Fenêtres d'application

Les classes les plus importantes du module Qt GUI sont QGuiApplication et QWindow. Une application Qt XML qui souhaite afficher du contenu à l'écran doit les utiliser. QGuiApplication contient la boucle d'événements principale, où tous les événements provenant du système de fenêtres et d'autres sources sont traités et distribués. Il gère également l'initialisation et la finalisation de l'application.

La classe QWindow représente une fenêtre dans le système de fenêtrage sous-jacent. Elle fournit un certain nombre de fonctions virtuelles pour gérer les événements (QEvent) du système de fenêtrage, tels que l'entrée tactile, l'exposition, la mise au point, les frappes de touches et les changements de géométrie.

Graphiques 2D

Le module Qt GUI contient des classes pour les graphiques 2D, l'imagerie, les polices de caractères et la typographie avancée.

Une page QWindow créée avec le type de surface QSurface::RasterSurface peut être utilisée en combinaison avec QBackingStore et QPainter, l'API graphique vectorielle 2D hautement optimisée de Qt. QPainter prend en charge le dessin de lignes, de polygones, de chemins vectoriels, d'images et de texte. Pour plus d'informations, voir l'exemple du système de peinture et de la fenêtre matricielle.

Qt peut charger et enregistrer des images à l'aide des classes QImage et QPixmap. Par défaut, Qt Image Formats prend en charge les formats d'image les plus courants, notamment JPEG et PNG. Les utilisateurs peuvent ajouter la prise en charge de formats supplémentaires via la classe QImageIOPlugin. Pour plus d'informations, voir Lire et écrire des fichiers images.

La typographie dans Qt est réalisée avec QTextDocument, qui utilise l'API QPainter en combinaison avec les classes de polices de Qt, principalement QFont. Les applications qui préfèrent des API de bas niveau pour la gestion du texte et des polices peuvent utiliser des classes comme QRawFont et QGlyphRun.

Graphiques RHI

L'interface matérielle de rendu de Qt est une abstraction pour les API graphiques accélérées par le matériel, telles que, OpenGL, OpenGL ES, Direct3D, Metal et Vulkan.

Au lieu d'utiliser directement OpenGL ou Vulkan pour effectuer le rendu sur un site QWindow, QRhi et les classes correspondantes fournissent une API graphique et de calcul 3D portable et multiplateforme, complétée par un pipeline de conditionnement et de transpilation des shaders. Les applications peuvent ainsi éviter de dépendre directement d'une API 3D unique et, dans certains cas, spécifique à un fournisseur ou à une plateforme.

Vous trouverez ci-dessous une liste des principales classes liées à RHI. Celles-ci sont complétées par un certain nombre de classes et de structures supplémentaires.

• QRhi
• QShader
• QShaderDescription
• QRhiCommandBuffer
• QRhiResourceUpdateBatch
• QRhiBuffer
• QRhiRenderBuffer
• QRhiTexture
• QRhiSampler
• QRhiShadingRateMap
• QRhiTextureRenderTarget
• QRhiShaderResourceBindings
• QRhiGraphicsPipeline
• QRhiComputePipeline
• QRhiSwapChain

Voir l'exemple de fenêtre RHI pour un exemple d'introduction à la création d'une application portable et multiplateforme qui effectue un rendu 3D accéléré sur un site QWindow à l'aide de QRhi.

Travailler directement avec QWindow est la manière la plus avancée et souvent la plus flexible d'effectuer un rendu avec l'API QRhi. Il s'agit toutefois de l'approche la plus basse et la plus limitée dans le sens où les technologies d'interface utilisateur de Qt, les widgets et Qt Quick, ne sont pas du tout utilisées. Dans de nombreux cas, les applications voudront plutôt intégrer le rendu basé sur QRhi dans un widget ou une interface utilisateur basée sur Qt Quick. QWidget Les applications basées sur les widgets peuvent choisir d'intégrer la fenêtre en tant qu'enfant natif dans la hiérarchie des widgets via QWidget::createWindowContainer(), mais dans de nombreux cas, QRhiWidget offrira un outil plus pratique pour intégrer le rendu basé sur QRhi dans l'interface utilisateur d'un widget. Qt Quick fournit son propre ensemble d'outils pour étendre la scène 2D/3D avec un rendu personnalisé basé sur QRhi.

Mathématiques matricielles et vectorielles 3D

Le module Qt GUI contient également quelques classes mathématiques pour faciliter les opérations mathématiques les plus courantes liées aux graphiques 3D. Ces classes comprennent QMatrix4x4, QVector2D, QVector3D, QVector4D, et QQuaternion.

Intégration d'OpenGL et d'OpenGL ES

QWindow prend en charge le rendu à l'aide d'OpenGL et d'OpenGL ES, en fonction de ce que la plateforme prend en charge. Le rendu OpenGL est activé en définissant le type de surface de QWindow à QSurface::OpenGLSurface, en choisissant les attributs de format avec QSurfaceFormat, puis en créant un QOpenGLContext pour gérer le contexte OpenGL natif. En outre, Qt OpenGL dispose de QOpenGLPaintDevice, qui permet l'utilisation du rendu QPainter accéléré par OpenGL, ainsi que des classes de commodité qui simplifient l'écriture du code OpenGL et cachent les complexités de la gestion des extensions et les différences entre OpenGL ES 2 et OpenGL de bureau. Les classes de commodité comprennent QOpenGLFunctions qui permet à une application d'utiliser toutes les fonctions d'OpenGL ES 2 sur OpenGL de bureau sans avoir à résoudre manuellement les pointeurs de fonction OpenGL. Cela permet le développement multiplateforme d'applications ciblant les appareils mobiles ou embarqués, et fournit des classes qui enveloppent les fonctionnalités OpenGL natives dans une API Qt plus simple :

• QOpenGLBuffer
• QOpenGLFramebufferObject
• QOpenGLShaderProgram
• QOpenGLTexture
• QOpenGLDebugLogger
• QOpenGLTimerQuery
• QOpenGLVertexArrayObject

Enfin, pour offrir un meilleur support aux nouvelles versions (3.0 et plus) d'OpenGL, un mécanisme d'enveloppe de fonction versionnée est également disponible : La famille de classes QOpenGLFunction_N_N expose toutes les fonctions d'une version et d'un profil OpenGL donnés, ce qui permet de développer facilement des applications de bureau qui s'appuient sur les fonctionnalités OpenGL modernes, réservées aux ordinateurs de bureau.

Pour plus d'informations, voir l'exemple de fenêtre OpenGL.

Un site QWindow créé avec QSurface::OpenGLSurface peut être utilisé en combinaison avec QPainter et QOpenGLPaintDevice pour obtenir des graphiques 2D accélérés par le matériel OpenGL en sacrifiant une partie de la qualité visuelle.

Intégration de Vulkan

Qt GUI Qt est compatible avec l'API Vulkan. Les applications Qt nécessitent la présence du LunarG Vulkan SDK.

Sous Windows, le SDK définit la variable d'environnement VULKAN_SDK, qui sera détectée par le script configure.

Sur Android, les en-têtes Vulkan ont été ajoutés au niveau API 24 du NDK.

Les principales classes pertinentes pour la prise en charge de Vulkan de bas niveau sont les suivantes :

• QVulkanInstance
• QVulkanFunctions
• QVulkanDeviceFunctions

En outre, QVulkanWindow fournit une sous-classe de commodité de QWindow qui facilite la mise en œuvre du rendu basé sur Vulkan en ciblant un QWindow. L'utilisation de cette classe d'aide est totalement facultative ; les applications avec des moteurs de rendu basés sur Vulkan plus avancés peuvent vouloir utiliser directement un QWindow avec le type QSurface::VulkanSurface.

Pour plus d'informations, voir l'exemple de widget Hello Vulkan et l'exemple de triangle Hello Vulkan.

Glisser-déposer

Qt GUI inclut la prise en charge du glisser-déposer. Pour plus d'informations, consultez l'aperçu de la fonction " glisser-déposer".