QQuickWidget Class
La classe QQuickWidget fournit un widget permettant d'afficher une interface utilisateur de type « Qt Quick ». En savoir plus...
| En-tête : | #include <qquickwidget.h> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS QuickWidgets) target_link_libraries(mytarget PRIVATE Qt6::QuickWidgets) |
| qmake : | QT += quickwidgets |
| Hérite de : | QWidget |
Types publics
| enum | ResizeMode { SizeViewToRootObject, SizeRootObjectToView } |
| enum | Status { Null, Ready, Loading, Error } |
Propriétés
- resizeMode : ResizeMode
- source : QUrl
- status : Status
Fonctions publiques
| QQuickWidget(QWidget *parent = nullptr) | |
| QQuickWidget(QQmlEngine *engine, QWidget *parent) | |
| QQuickWidget(const QUrl &source, QWidget *parent = nullptr) | |
(since 6.9) | QQuickWidget(QAnyStringView uri, QAnyStringView typeName, QWidget *parent = nullptr) |
| virtual | ~QQuickWidget() override |
| QQmlEngine * | engine() const |
| QList<QQmlError> | errors() const |
| QSurfaceFormat | format() const |
| QImage | grabFramebuffer() const |
| QSize | initialSize() const |
| QQuickWindow * | quickWindow() const |
| QQuickWidget::ResizeMode | resizeMode() const |
| QQmlContext * | rootContext() const |
| QQuickItem * | rootObject() const |
| void | setClearColor(const QColor &color) |
| void | setFormat(const QSurfaceFormat &format) |
| void | setResizeMode(QQuickWidget::ResizeMode) |
| QUrl | source() const |
| QQuickWidget::Status | status() const |
Emplacements publics
(since 6.9) void | loadFromModule(QAnyStringView uri, QAnyStringView typeName) |
(since 6.9) void | setInitialProperties(const QVariantMap &initialProperties) |
| void | setSource(const QUrl &url) |
Signaux
| void | sceneGraphError(QQuickWindow::SceneGraphError error, const QString &message) |
| void | statusChanged(QQuickWidget::Status status) |
Fonctions protégées réimplémentées
| virtual void | dragEnterEvent(QDragEnterEvent *e) override |
| virtual void | dragLeaveEvent(QDragLeaveEvent *e) override |
| virtual void | dragMoveEvent(QDragMoveEvent *e) override |
| virtual void | dropEvent(QDropEvent *e) override |
| virtual bool | event(QEvent *e) override |
| virtual void | focusInEvent(QFocusEvent *event) override |
| virtual bool | focusNextPrevChild(bool next) override |
| virtual void | focusOutEvent(QFocusEvent *event) override |
| virtual void | hideEvent(QHideEvent *) override |
| virtual void | keyPressEvent(QKeyEvent *e) override |
| virtual void | keyReleaseEvent(QKeyEvent *e) override |
| virtual void | mouseDoubleClickEvent(QMouseEvent *e) override |
| virtual void | mouseMoveEvent(QMouseEvent *e) override |
| virtual void | mousePressEvent(QMouseEvent *e) override |
| virtual void | mouseReleaseEvent(QMouseEvent *e) override |
| virtual void | paintEvent(QPaintEvent *event) override |
| virtual void | showEvent(QShowEvent *) override |
| virtual void | wheelEvent(QWheelEvent *e) override |
Description détaillée
Il s'agit d'un wrapper pratique pour la méthode ` QQuickWindow `, qui charge et affiche automatiquement une scène QML lorsqu'on lui fournit l'URL du fichier source principal. Vous pouvez également instancier vos propres objets à l'aide de ` QQmlComponent ` et les placer dans un `QQuickWidget` configuré manuellement.
Utilisation typique :
QQuickWidget *view = new QQuickWidget;
view->setSource(QUrl::fromLocalFile("myqmlfile.qml"));
view->show();Pour recevoir les erreurs liées au chargement et à l’exécution de QML avec QQuickWidget, vous pouvez vous connecter au signal ` statusChanged()` et surveiller l’événement ` QQuickWidget::Error`. Les erreurs sont disponibles via ` QQuickWidget::errors()`.
QQuickWidget gère également le redimensionnement de la vue et de l’objet racine. Par défaut, le paramètre ` resizeMode ` est défini sur ` SizeViewToRootObject`, ce qui charge le composant et le redimensionne à la taille de la vue. Il est également possible de définir le paramètre ` resizeMode ` sur ` SizeRootObjectToView `, ce qui redimensionnera la vue à la taille de l’objet racine.
Considérations relatives aux performances
QQuickWidget constitue une alternative à l’utilisation de ` QQuickView ` et ` QWidget::createWindowContainer()`. Les restrictions relatives à l’ordre d’empilement ne s’appliquent pas, ce qui fait de QQuickWidget l’alternative la plus flexible, se comportant davantage comme un widget ordinaire.
Cependant, les avantages mentionnés ci-dessus se font au détriment des performances :
- Contrairement à QQuickWindow et QQuickView, QQuickWidget implique au moins un passage de rendu supplémentaire ciblant un tampon de couleur hors écran, généralement une texture 2D, suivi du tracé d’un quadrilatère de texture. Cela se traduit par une charge accrue, en particulier pour le traitement des fragments par le GPU.
- L’utilisation de QQuickWidget désactive la boucle de rendu multithread sur toutes les plateformes. Cela signifie que certains des avantages du rendu multithread, par exemple les classes Animator et les animations pilotées par vsync, ne seront pas disponibles.
Remarque : évitez d’appeler ` winId()` sur un `QQuickWidget`. Cette fonction déclenche la création d’une fenêtre native, ce qui entraîne une baisse des performances et peut provoquer des anomalies de rendu. L’objectif premier de `QQuickWidget` est de rendre des scènes Quick sans fenêtre native distincte ; il faut donc toujours éviter d’en faire un widget natif.
Prise en charge des API graphiques
QQuickWidget fonctionne avec toutes les API graphiques 3D prises en charge par ` Qt Quick`, ainsi qu’avec le backend ` software `. Les autres backends, tels qu’OpenVG, ne sont toutefois pas compatibles et toute tentative de création d’un QQuickWidget entraînera des problèmes.
La redéfinition de l’API graphique par défaut de la plateforme s’effectue de la même manière qu’avec QQuickWindow et QQuickView: soit en appelant QQuickWindow::setGraphicsApi() dès le début, avant de créer le premier QQuickWidget, soit en définissant la variable d’environnement QSG_RHI_BACKEND.
Remarque : une fenêtre de niveau supérieur ne peut utiliser qu’une seule API graphique pour le rendu. Par exemple, si vous tentez de placer un QQuickWidget utilisant Vulkan et un QOpenGLWidget dans la hiérarchie des widgets de la même fenêtre de niveau supérieur, des problèmes surviendront et l’un des widgets ne s’affichera pas comme prévu.
Graphique de scène et persistance du contexte
QQuickWidget respecte la méthode ` QQuickWindow::isPersistentSceneGraph()`, ce qui signifie que les applications peuvent décider – en appelant ` QQuickWindow::setPersistentSceneGraph()` sur la fenêtre renvoyée par la fonction ` quickWindow()` – de libérer les nœuds du graphe de scène et les autres ressources liées à la scène ` Qt Quick ` dès que le widget est masqué. Par défaut, la persistance est activée, tout comme avec ` QQuickWindow`.
Lorsqu’il fonctionne avec OpenGL, QQuickWindow offre également la possibilité de désactiver la persistance des contextes OpenGL. Ce paramètre est actuellement ignoré par QQuickWidget et le contexte est toujours persistant. Le contexte OpenGL n’est donc pas détruit lorsque le widget est masqué. Le contexte n’est détruit que lorsque le widget est détruit ou lorsqu’il est replacé dans la hiérarchie des enfants d’un autre widget de niveau supérieur. Cependant, certaines applications, en particulier celles qui disposent de leurs propres ressources graphiques en raison d’un rendu OpenGL personnalisé dans la scène d’ Qt Quick, peuvent souhaiter désactiver cette fonctionnalité, car elles ne sont pas forcément préparées à gérer la perte du contexte lors du déplacement d’un QQuickWidget vers une autre fenêtre. Ces applications peuvent définir l’attribut QCoreApplication::AA_ShareOpenGLContexts. Pour plus de détails sur l’initialisation et la libération des ressources, consultez la documentation relative à l’interface de programmation « QOpenGLWidget ».
Remarque : QQuickWidget offre un contrôle moins fin sur son contexte OpenGL interne qu’ QOpenGLWidget, et il existe des différences subtiles, notamment le fait que la désactivation du graphe de scène persistant entraîne la destruction du contexte lors d’un changement de fenêtre, indépendamment de la présence de QCoreApplication::AA_ShareOpenGLContexts.
Limites
Placer d’autres widgets en dessous et rendre le QQuickWidget transparent ne donnera pas les résultats escomptés : les widgets situés en dessous ne seront pas visibles. En effet, dans la pratique, le QQuickWidget est dessiné avant tous les autres widgets classiques (non OpenGL) ; les solutions de type « transparence » ne sont donc pas envisageables. D'autres types de mise en page, comme le fait de placer des widgets par-dessus le QQuickWidget, fonctionneront comme prévu.
En cas d’absolue nécessité, cette limitation peut être contournée en définissant l’attribut ` Qt::WA_AlwaysStackOnTop ` sur le `QQuickWidget`. Sachez toutefois que cela perturbe l’ordre d’empilement. Par exemple, il ne sera pas possible d’avoir d’autres widgets superposés au QQuickWidget ; cette option ne doit donc être utilisée que dans les situations où un QQuickWidget semi-transparent, laissant apparaître d’autres widgets en dessous, est requis.
Cette limitation ne s’applique que lorsqu’il y a d’autres widgets sous le QQuickWidget à l’intérieur de la même fenêtre. Pour rendre la fenêtre semi-transparente, avec d’autres applications et le bureau visibles en arrière-plan, on procède de manière traditionnelle : définissez l’attribut ` Qt::WA_TranslucentBackground ` sur la fenêtre de niveau supérieur, demandez un canal alpha, puis modifiez la couleur de transparence (clear color) du Scenegraph de l’ Qt Quick pour la définir sur ` Qt::transparent ` via la fonction ` setClearColor()`.
Voir également «Exposition des attributs des types C++ vers QML », « Exemple de widgets d’Qt Quick » et « QQuickView ».
Documentation sur les types de membres
enum QQuickWidget::ResizeMode
Cette énumération définit la manière de redimensionner la vue.
| Constante | Valeur | Description |
|---|---|---|
QQuickWidget::SizeViewToRootObject | 0 | La vue redimensionne l'élément racine dans le QML. |
QQuickWidget::SizeRootObjectToView | 1 | La vue redimensionnera automatiquement l’élément racine à la taille de la vue. |
enum QQuickWidget::Status
Indique l'état de chargement de l'QQuickWidget.
| Constante | Valeur | Description |
|---|---|---|
QQuickWidget::Null | 0 | Cette QQuickWidget n'a pas de source définie. |
QQuickWidget::Ready | 1 | Cette QQuickWidget a chargé et créé le composant QML. |
QQuickWidget::Loading | 2 | Cette instance d'QQuickWidget est en train de charger des données réseau. |
QQuickWidget::Error | 3 | Une ou plusieurs erreurs se sont produites. Appelez la méthode errors() pour récupérer la liste des erreurs. |
Documentation des propriétés
resizeMode : ResizeMode
Détermine si la vue doit redimensionner le contenu de la fenêtre.
Si cette propriété est définie sur « SizeViewToRootObject » (valeur par défaut), la vue s’adapte à la taille de l’élément racine dans le QML.
Si cette propriété est définie sur ` SizeRootObjectToView`, la vue redimensionnera automatiquement l’élément racine à la taille de la vue.
Quelle que soit la valeur de cette propriété, la propriété `sizeHint` de la vue correspond à la taille initiale de l’élément racine. Notez toutefois que, le QML pouvant se charger de manière dynamique, cette taille est susceptible de changer.
Fonctions d'accès :
| QQuickWidget::ResizeMode | resizeMode() const |
| void | setResizeMode(QQuickWidget::ResizeMode) |
Voir également ` initialSize()`.
source : QUrl
Cette propriété contient l'URL de la source du composant QML.
Assurez-vous que l'URL fournie est complète et correcte ; en particulier, utilisez QUrl::fromLocalFile() lorsque vous chargez un fichier à partir du système de fichiers local.
Remarque : la définition d'une URL source entraînera l'instanciation du composant QML, même si l'URL reste inchangée par rapport à la valeur actuelle.
Fonctions d'accès :
[read-only] status : Status
status s actuelles du composant.
Fonctions d'accès :
| QQuickWidget::Status | status() const |
Signal de notification :
| void | statusChanged(QQuickWidget::Status status) |
Documentation des fonctions membres
[explicit] QQuickWidget::QQuickWidget(QWidget *parent = nullptr)
Crée un QQuickWidget doté d'un moteur QML par défaut, en tant qu'enfant de parent.
La valeur par défaut de ` parent ` est ` nullptr`.
QQuickWidget::QQuickWidget(QQmlEngine *engine, QWidget *parent)
Crée un QQuickWidget avec l'engine QML spécifié en tant qu'enfant de parent.
Remarque : le QQuickWidget ne prend pas possession de l'engine donné ; il incombe à l'appelant de détruire le moteur. Si l'engine est supprimé avant la vue, la fonction status() renverra QQuickWidget::Error.
[explicit] QQuickWidget::QQuickWidget(const QUrl &source, QWidget *parent = nullptr)
Crée un QQuickWidget avec un moteur QML par défaut et l'source QML spécifiée, en tant qu'enfant de parent.
La valeur par défaut de ` parent ` est ` nullptr`.
[explicit, since 6.9] QQuickWidget::QQuickWidget(QAnyStringView uri, QAnyStringView typeName, QWidget *parent = nullptr)
Crée un QQuickWidget avec l'élément spécifié par uri et typeName, et le parent parent. La valeur par défaut de parent est nullptr.
Cette fonction a été introduite dans Qt 6.9.
Voir également loadFromModule.
[override virtual noexcept] QQuickWidget::~QQuickWidget()
Supprime l'QQuickWidget.
[override virtual protected] void QQuickWidget::dragEnterEvent(QDragEnterEvent *e)
Réimplémente : QWidget::dragEnterEvent(QDragEnterEvent *event).
[override virtual protected] void QQuickWidget::dragLeaveEvent(QDragLeaveEvent *e)
Réimplémente : QWidget::dragLeaveEvent(QDragLeaveEvent *event).
[override virtual protected] void QQuickWidget::dragMoveEvent(QDragMoveEvent *e)
Réimplémente : QWidget::dragMoveEvent(QDragMoveEvent *event).
[override virtual protected] void QQuickWidget::dropEvent(QDropEvent *e)
Réimplémente : QWidget::dropEvent(QDropEvent *event).
QQmlEngine *QQuickWidget::engine() const
Renvoie un pointeur vers l’ QQmlEngine utilisé pour l’instanciation des composants QML.
QList<QQmlError> QQuickWidget::errors() const
Renvoie la liste des erreurs survenues lors de la dernière opération de compilation ou de création. Lorsque le statut n'est pas « Error », une liste vide est renvoyée.
Voir également status.
[override virtual protected] bool QQuickWidget::event(QEvent *e)
Réimplémente : QWidget::event(QEvent *event).
[override virtual protected] void QQuickWidget::focusInEvent(QFocusEvent *event)
Réimplémente : QWidget::focusInEvent(QFocusEvent *event).
[override virtual protected] bool QQuickWidget::focusNextPrevChild(bool next)
Réimplémente : QWidget::focusNextPrevChild(bool next).
[override virtual protected] void QQuickWidget::focusOutEvent(QFocusEvent *event)
Réimplémente : QWidget::focusOutEvent(QFocusEvent *event).
QSurfaceFormat QQuickWidget::format() const
Renvoie le format réel de la surface.
Si le widget n'a pas encore été affiché, le format demandé est renvoyé.
Voir également setFormat().
QImage QQuickWidget::grabFramebuffer() const
Affiche une image et la réimporte dans un fichier image.
Remarque : cette opération peut s'avérer coûteuse.
[override virtual protected] void QQuickWidget::hideEvent(QHideEvent *)
Réimplémente : QWidget::hideEvent(QHideEvent *event).
QSize QQuickWidget::initialSize() const
Renvoie la taille initiale de l'objet racine.
Si resizeMode est SizeRootObjectToView, l'objet racine sera redimensionné pour s'adapter à la taille de la vue. Cette fonction renvoie la taille de l'objet racine avant son redimensionnement.
[override virtual protected] void QQuickWidget::keyPressEvent(QKeyEvent *e)
Réimplémente : QWidget::keyPressEvent(QKeyEvent *event).
[override virtual protected] void QQuickWidget::keyReleaseEvent(QKeyEvent *e)
Réimplémente : QWidget::keyReleaseEvent(QKeyEvent *event).
[slot, since 6.9] void QQuickWidget::loadFromModule(QAnyStringView uri, QAnyStringView typeName)
Charge le composant QML identifié par uri et typeName. Si le composant est associé à un fichier QML, source sera défini en conséquence. Pour les types définis dans C++, source sera vide.
Si une valeur source avait été définie avant l’appel de cette méthode, elle sera effacée.
L'appel répété de cette méthode avec les mêmes uri et typeName entraînera la réinstanciation du composant QML.
Cette fonction a été introduite dans Qt 6.9.
Voir également setSource, QQmlComponent::loadFromModule et QQmlApplicationEngine::loadFromModule.
[override virtual protected] void QQuickWidget::mouseDoubleClickEvent(QMouseEvent *e)
Réimplémente : QWidget::mouseDoubleClickEvent(QMouseEvent *event).
[override virtual protected] void QQuickWidget::mouseMoveEvent(QMouseEvent *e)
Réimplémente : QWidget::mouseMoveEvent(QMouseEvent *event).
[override virtual protected] void QQuickWidget::mousePressEvent(QMouseEvent *e)
Réimplémente : QWidget::mousePressEvent(QMouseEvent *event).
[override virtual protected] void QQuickWidget::mouseReleaseEvent(QMouseEvent *e)
Réimplémente : QWidget::mouseReleaseEvent(QMouseEvent *event).
[override virtual protected] void QQuickWidget::paintEvent(QPaintEvent *event)
Réimplémente : QWidget::paintEvent(QPaintEvent *event).
QQuickWindow *QQuickWidget::quickWindow() const
Renvoie l'QQuickWindow hors écran utilisé par ce widget pour piloter le rendu de Qt Quick. Cela s'avère utile si vous souhaitez utiliser des API QQuickWindow qui ne sont pas actuellement exposées par QQuickWidget, par exemple pour vous connecter au signal QQuickWindow::beforeRendering() afin de dessiner du contenu OpenGL natif sous le rendu propre à Qt Quick.
Avertissement : utilisez la valeur de retour de cette fonction avec prudence. En particulier, ne tentez jamais d’afficher la fenêtre hors écran ( QQuickWindow), et soyez très prudent lorsque vous utilisez d’autres API réservées à la fenêtre hors écran ( QWindow).
Avertissement : la fenêtre hors écran peut être supprimée (puis recréée) au cours du cycle de vie de l’ QQuickWidget, notamment lorsque le widget est déplacé vers une autre QQuickWindow. Si vous avez besoin de savoir quand la fenêtre a été remplacée, connectez-vous à son signal destroyed().
QQmlContext *QQuickWidget::rootContext() const
Cette fonction renvoie la racine de la hiérarchie de contextes. Chaque composant QML est instancié dans un ` QQmlContext`. Les ` QQmlContext` sont indispensables pour transmettre des données aux composants QML. En QML, les contextes sont organisés de manière hiérarchique et cette hiérarchie est gérée par l'` QQmlEngine`.
QQuickItem *QQuickWidget::rootObject() const
Renvoie l'item de la racine de la vue. Peut prendre la valeur « nullptr » lorsque la fonction setSource() n'a pas été appelée, si celle-ci a été appelée avec un code QtQuick défectueux ou si l'élément racine n'est pas défini pour une autre raison.
[signal] void QQuickWidget::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 OpenGL, 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.
Voir également ` QQuickWindow::sceneGraphError()` ().
void QQuickWidget::setClearColor(const QColor &color)
Définit la couleur « clear » color. Par défaut, il s'agit d'une couleur opaque.
Pour obtenir une QQuickWidget semi-transparente, appelez cette fonction en définissant color sur Qt::transparent, définissez l'attribut Qt::WA_TranslucentBackground du widget sur la fenêtre de niveau supérieur, puis demandez un canal alpha via setFormat().
Voir également QQuickWindow::setColor().
void QQuickWidget::setFormat(const QSurfaceFormat &format)
Définit l'format de surface pour le contexte et la surface hors écran utilisés par ce widget.
Appelez cette fonction lorsqu'il est nécessaire de demander un contexte pour une version ou un profil OpenGL donné. Les tailles des tampons de profondeur, de stencil et d'alpha sont gérées automatiquement ; il n'est donc pas nécessaire de les demander explicitement.
Voir également ` QWindow::setFormat()`, ` QWindow::format()` et ` format()`.
[slot, since 6.9] void QQuickWidget::setInitialProperties(const QVariantMap &initialProperties)
Définit les propriétés initiales initialProperties avec lesquelles le composant QML est initialisé après l'appel de la fonction QQuickWidget::setSource().
Remarque : vous ne pouvez utiliser cette fonction que pour initialiser les propriétés de niveau supérieur.
Remarque : cette fonction doit toujours être appelée avant ` setSource`, car elle n'a plus aucun effet une fois que le composant est devenu ` Ready`.
Cette fonction a été introduite dans Qt 6.9.
Voir également ` QQmlComponent::createWithInitialProperties()`.
[slot] void QQuickWidget::setSource(const QUrl &url)
Définit la source sur url, charge le composant QML et l'instancie.
Assurez-vous que l’URL fournie est complète et correcte ; en particulier, utilisez QUrl::fromLocalFile() lorsque vous chargez un fichier à partir du système de fichiers local.
Appeler cette méthode plusieurs fois avec la même URL entraînera la réinstanciation du composant QML.
Remarque : fonction de définition (setter ) pour la propriété source.
Voir aussi source().
[override virtual protected] void QQuickWidget::showEvent(QShowEvent *)
Réimplémente : QWidget::showEvent(QShowEvent *event).
QUrl QQuickWidget::source() const
Renvoie l'URL source, si elle est définie.
Remarque : fonctiongetter pour la propriété source.
Voir aussi setSource().
[signal] void QQuickWidget::statusChanged(QQuickWidget::Status status)
Ce signal est émis lorsque l'status de courant du composant change.
Remarque : signalde notification pour l'status de la propriété.
[override virtual protected] void QQuickWidget::wheelEvent(QWheelEvent *e)
Réimplémente : QWidget::wheelEvent(QWheelEvent *event).
© 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.