Qt GUI Présentation

Le module Qt GUI fournit des classes pour l'intégration au système de fenêtrage, la gestion des événements, l'intégration d'OpenGL et d'OpenGL ES, les graphiques 2D, le traitement d'images de base, les polices 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 des API graphiques OpenGL ES de bas niveau.

Pour les développeurs d'applications créant des interfaces utilisateur, Qt fournit des API de plus haut niveau, comme Qt Quick, qui sont bien plus adaptées que les composants de base disponibles 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 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êtrage et d’autres sources sont traités et distribués. Elle 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 permettant de gérer les événements (QEvent) provenant du système de fenêtrage, tels que les entrées tactiles, l’exposition, le focus, les frappes au clavier et les modifications de géométrie.

Graphiques 2D

Le module Qt GUI contient des classes dédiées aux graphiques 2D, au traitement d’images, aux polices et à la typographie avancée.

Une surface graphique ( QWindow ) créée avec le type de surface « QSurface::RasterSurface » peut être utilisée en combinaison avec QBackingStore et QPainter, l’API de graphisme vectoriel 2D hautement optimisée de Qt. QPainter prend en charge le tracé de lignes, de polygones, de chemins vectoriels, d’images et de texte. Pour plus d’informations, consultez les sections « Système de peinture » et « Exemple de fenêtre raster ».

Qt peut charger et enregistrer des images à l’aide des classes ` QImage ` et ` QPixmap `. Par défaut, Qt 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, consultez la section « Lecture et écriture de fichiers image ».

La typographie dans Qt est gérée par 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 plus bas niveau pour la gestion du texte et des polices peuvent utiliser des classes telles que QRawFont et QGlyphRun.

RHI Graphics

L’interface matérielle de rendu Qt (Qt Rendering Hardware Interface) est une abstraction des 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 une « QWindow », QRhi et les classes associées fournissent une API graphique et de calcul 3D portable et multiplateforme, complétée par un pipeline de conditionnement et de transcompilation des shaders. De cette manière, les applications peuvent é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

Consultez l’exemple « RHI Window » pour découvrir un exemple d’introduction à la création d’une application portable et multiplateforme qui effectue un rendu 3D accéléré sur une carte graphique QWindow à l’aide de QRhi.

Travailler directement avec QWindow est la méthode la plus avancée et souvent la plus flexible de rendu avec l’API QRhi. Il s’agit toutefois de l’approche la plus basique, et elle est limitée dans la mesure où les technologies d’interface utilisateur de Qt, les widgets et Qt Quick, ne sont pas du tout utilisés. Dans de nombreux cas, les applications préféreront 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 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 offre un moyen plus pratique d’intégrer le rendu basé sur QRhi dans l’interface utilisateur d’un widget. Qt Quick fournit son propre ensemble d’outils permettant d’étendre la scène 2D/3D avec un rendu personnalisé basé sur QRhi.

Mathématiques des matrices et vecteurs 3D

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

Intégration d’OpenGL et d’OpenGL ES

QWindow prend en charge le rendu via OpenGL et OpenGL ES, selon les capacités de la plateforme. Le rendu OpenGL est activé en définissant le type de surface de l’objet ` QWindow` sur ` QSurface::OpenGLSurface`, en choisissant les attributs de format avec ` QSurfaceFormat`, puis en créant un ` QOpenGLContext ` pour gérer le contexte OpenGL natif. De plus, Qt propose QOpenGLPaintDevice, qui permet d’utiliser le rendu accéléré OpenGL d’ QPainter, ainsi que des classes de commodité qui simplifient l’écriture du code OpenGL et masquent les complexités liées à la gestion des extensions ainsi que les différences entre OpenGL ES 2 et OpenGL de bureau. Parmi ces classes de commodité figure notamment « QOpenGLFunctions », qui permet à une application d’utiliser toutes les fonctions OpenGL ES 2 sur OpenGL de bureau sans avoir à résoudre manuellement les pointeurs de fonctions OpenGL. Cela facilite le développement multiplateforme d’applications destinées aux appareils mobiles ou embarqués, et fournit des classes qui encapsulent les fonctionnalités natives d’OpenGL dans une API Qt plus simple :

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

Enfin, afin d’assurer une meilleure prise en charge des versions les plus récentes (3.0 et supérieures) d’OpenGL, un mécanisme de encapsulation de fonctions versionnées 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 facilite le développement d’applications de bureau s’appuyant sur des fonctionnalités OpenGL modernes, propres à l’environnement de bureau.

Pour plus d’informations, consultez l’exemple de fenêtre OpenGL.

Une fenêtre OpenGL ( QWindow ) créée à l’aide de la classe ` QSurface::OpenGLSurface ` peut être utilisée en combinaison avec ` QPainter ` et ` QOpenGLPaintDevice ` pour bénéficier de graphismes 2D OpenGL accélérés par le matériel, au prix d’une légère perte de qualité visuelle.

Intégration de Vulkan

Qt GUI prend en charge l’API Vulkan. Les applications Qt nécessitent la présence du SDK LunarG Vulkan.

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

Sous Android, les en-têtes Vulkan ont été ajoutés dans le niveau d'API 24 du NDK.

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

• QVulkanInstance
• QVulkanFunctions
• QVulkanDeviceFunctions

De plus, QVulkanWindow fournit une sous-classe pratique de QWindow qui facilite la mise en route de l’implémentation d’un rendu basé sur Vulkan ciblant un QWindow. L’utilisation de cette classe d’aide est entièrement facultative ; les applications disposant de moteurs de rendu basés sur Vulkan plus avancés peuvent préférer utiliser directement un QWindow de type QSurface::VulkanSurface.

Pour plus d’informations, consultez l’exemple de widget « Hello Vulkan » et l’exemple de triangle « Hello Vulkan ».

Glisser-déposer

Qt GUI prend en charge le glisser-déposer. La présentation du glisser-déposer fournit davantage d’informations.