Sur cette page

QQuickWidget Class

La classe QQuickWidget fournit un widget permettant d'afficher une interface utilisateur Qt Quick. Plus d'informations...

En-tête : #include <QQuickWidget>
CMake : find_package(Qt6 REQUIRED COMPONENTS QuickWidgets)
target_link_libraries(mytarget PRIVATE Qt6::QuickWidgets)
qmake : QT += quickwidgets
Héritages : QWidget

Types publics

enum ResizeMode { SizeViewToRootObject, SizeRootObjectToView }
enum Status { Null, Ready, Loading, Error }

Propriétés

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'une enveloppe de commodité pour QQuickWindow qui chargera et affichera automatiquement une scène QML lorsqu'on lui donne 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 QQuickWidget::Error. Les erreurs sont disponibles via QQuickWidget::errors().

QQuickWidget gère également le dimensionnement de la vue et de l'objet racine. Par défaut, resizeMode est SizeViewToRootObject, ce qui chargera le composant et le redimensionnera à la taille de la vue. Alternativement, resizeMode peut être défini à SizeRootObjectToView, ce qui redimensionnera la vue à la taille de l'objet racine.

Considérations sur les performances

QQuickWidget est une alternative à l'utilisation de QQuickView et QWidget::createWindowContainer(). Les restrictions sur l'ordre d'empilement ne s'appliquent pas, ce qui fait de QQuickWidget une alternative plus flexible, se comportant davantage comme un widget ordinaire.

Toutefois, les avantages susmentionnés se font au détriment des performances :

  • Contrairement à QQuickWindow et QQuickView, QQuickWidget implique au moins une passe de rendu supplémentaire ciblant un tampon de couleur hors écran, typiquement une texture 2D, suivie du dessin d'un quad de texture. Cela signifie une charge accrue, en particulier pour le traitement des fragments du GPU.
  • L'utilisation de QQuickWidget désactive la boucle de rendu threadée sur toutes les plateformes. Cela signifie que certains des avantages du rendu threadé, 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 réduit les performances et peut entraîner des problèmes de rendu. L'objectif principal de QQuickWidget est de rendre des scènes rapides sans fenêtre native séparée, c'est pourquoi il faut toujours éviter de faire de QQuickWidget un widget natif.

Support de l'API graphique

QQuickWidget est fonctionnel avec toutes les API graphiques 3D supportées par Qt Quick, ainsi qu'avec le backend software. D'autres backends, par exemple OpenVG, ne sont cependant pas compatibles et toute tentative de construction d'un QQuickWidget entraînera des problèmes.

Le remplacement de l'API graphique par défaut de la plate-forme se fait de la même manière qu'avec QQuickWindow et QQuickView: soit en appelant QQuickWindow::setGraphicsApi() avant de construire le premier QQuickWidget, soit en définissant la variable d'environnement QSG_RHI_BACKEND.

Remarque : une fenêtre de premier niveau ne peut utiliser qu'une seule API graphique pour le rendu. Par exemple, si vous essayez de placer un QQuickWidget utilisant Vulkan et un QOpenGLWidget dans la hiérarchie des widgets de la même fenêtre de premier niveau, des problèmes se produiront et l'un des widgets n'effectuera pas le rendu attendu.

Graphique de scène et persistance du contexte

QQuickWidget honore 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 laisser les nœuds du graphe de scène et d'autres ressources Qt Quick liées à la scène être libérés lorsque le widget devient caché. Par défaut, la persistance est activée, comme pour QQuickWindow.

Lorsqu'il fonctionne avec OpenGL, QQuickWindow offre la possibilité de désactiver les contextes OpenGL persistants. Ce paramètre est actuellement ignoré par QQuickWidget et le contexte est toujours persistant. Le contexte OpenGL n'est donc pas détruit lorsque l'on cache le widget. Le contexte n'est détruit que lorsque le widget est détruit ou lorsque le widget est réparti dans la hiérarchie des enfants d'un autre widget de niveau supérieur. Cependant, certaines applications, en particulier celles qui ont leurs propres ressources graphiques en raison de l'exécution d'un rendu OpenGL personnalisé dans la scène Qt Quick, peuvent souhaiter désactiver ce dernier car elles ne sont peut-être pas prêtes à gérer la perte du contexte lors du déplacement d'un QQuickWidget dans une autre fenêtre. Ces applications peuvent définir l'attribut QCoreApplication::AA_ShareOpenGLContexts. Pour une discussion sur les détails de l'initialisation et du nettoyage des ressources, reportez-vous à la documentation QOpenGLWidget.

Note : QQuickWidget offre un contrôle moins fin sur son contexte OpenGL interne que QOpenGLWidget, et il y a des différences subtiles, notamment le fait que la désactivation du graphe de scène persistant conduira à la destruction du contexte lors d'un changement de fenêtre, indépendamment de la présence de QCoreApplication::AA_ShareOpenGLContexts.

Limitations

Placer d'autres widgets en dessous et rendre le QQuickWidget transparent ne conduira pas aux résultats escomptés : les widgets en dessous ne seront pas visibles. En effet, dans la pratique, le QQuickWidget est dessiné avant tous les autres widgets ordinaires, non OpenGL, et les solutions de type transparent ne sont donc pas réalisables. D'autres types d'agencement, comme la superposition de widgets sur le QQuickWidget, fonctionneront comme prévu.

Lorsque cela est absolument nécessaire, cette limitation peut être surmontée en définissant l'attribut Qt::WA_AlwaysStackOnTop sur le QQuickWidget. Sachez toutefois que cela rompt l'ordre d'empilement. Par exemple, il ne sera pas possible d'avoir d'autres widgets par-dessus le QQuickWidget. Il ne faut donc l'utiliser que dans les situations où un QQuickWidget semi-transparent avec d'autres widgets visibles en dessous est nécessaire.

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, il faut procéder de manière traditionnelle : Définissez Qt::WA_TranslucentBackground sur la fenêtre de niveau supérieur, demandez un canal alpha et changez la couleur claire du Scenegraph Qt Quick en Qt::transparent via setClearColor().

Gestion de la touche de tabulation

Lorsque l'on appuie sur la touche [TAB], l'élément à l'intérieur du QQuickWidget est mis en avant. Si cet élément peut gérer la pression de la touche [TAB], le focus changera en conséquence à l'intérieur de l'élément, sinon le widget suivant dans la chaîne de focus obtient le focus.

Voir également Exposer les attributs des types C++ à QML, Qt Quick Exemple de widgets, et QQuickView.

Documentation sur les types de membres

enum QQuickWidget::ResizeMode

Cette énumération indique comment redimensionner la vue.

ConstanteValeurDescription
QQuickWidget::SizeViewToRootObject0La vue est redimensionnée en fonction de l'élément racine dans le QML.
QQuickWidget::SizeRootObjectToView1La vue redimensionne automatiquement l'élément racine en fonction de la taille de la vue.

enum QQuickWidget::Status

Spécifie l'état de chargement du site QQuickWidget.

ConstanteValeurDescription de l'état de chargement
QQuickWidget::Null0Ce site QQuickWidget n'a pas d'ensemble de sources.
QQuickWidget::Ready1Ce site QQuickWidget a chargé et créé le composant QML.
QQuickWidget::Loading2Ce site QQuickWidget est en train de charger des données de réseau.
QQuickWidget::Error3Une ou plusieurs erreurs se sont produites. Appelez errors() pour obtenir une liste des erreurs.

Documentation sur les propriétés

resizeMode : ResizeMode

Détermine si la vue doit redimensionner le contenu de la fenêtre.

Si cette propriété vaut SizeViewToRootObject (valeur par défaut), la vue se redimensionne à la taille de l'élément racine dans le QML.

Si cette propriété vaut SizeRootObjectToView, la vue redimensionne automatiquement l'élément racine à la taille de la vue.

Indépendamment de cette propriété, le sizeHint de la vue est la taille initiale de l'élément racine. Notez cependant que, puisque QML peut se charger dynamiquement, cette taille peut 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.

Veillez à ce que l'URL fournie soit complète et correcte, en particulier, utilisez QUrl::fromLocalFile() pour charger 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 est inchangée par rapport à la valeur actuelle.

Fonctions d'accès :

QUrl source() const
void setSource(const QUrl &url)

[read-only] status : Status

L'adresse actuelle du composant status.

Fonctions d'accès :

QQuickWidget::Status status() const

Signal du notificateur :

void statusChanged(QQuickWidget::Status status)

Fonction membre Documentation

[explicit] QQuickWidget::QQuickWidget(QWidget *parent = nullptr)

Construit un QQuickWidget avec 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)

Construit un QQuickWidget avec l'objet QML engine donné comme enfant de parent.

Remarque : le QQuickWidget n'est pas propriétaire de l'objet engine; il incombe à l'appelant de détruire le moteur. Si l'objet engine est supprimé avant la vue, status() renverra QQuickWidget::Error.

[explicit] QQuickWidget::QQuickWidget(const QUrl &source, QWidget *parent = nullptr)

Construit un QQuickWidget avec un moteur QML par défaut et le QML source donné comme 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)

Construit 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 aussi loadFromModule.

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

Détruit le site 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 sur le site 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. Si 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 actuel de la surface.

Si le widget n'a pas encore été affiché, le format demandé est renvoyé.

Voir également setFormat().

QImage QQuickWidget::grabFramebuffer() const

Effectue le rendu d'une trame et la relit dans une image.

Remarque : il s'agit d'une opération potentiellement 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é à la taille de la vue. Cette fonction renvoie la taille de l'objet racine avant qu'il ne soit redimensionné.

[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 soutenu par un fichier QML, source sera défini en conséquence. Pour les types définis dans C++, source sera vide.

Si source a été défini avant l'appel de cette méthode, il sera effacé.

Si vous appelez cette méthode plusieurs fois avec les mêmes uri et typeName, le composant QML sera réinstancié.

Cette fonction a été introduite dans Qt 6.9.

Voir aussi 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 le hors-écran QQuickWindow qui est utilisé par ce widget pour piloter le rendu Qt Quick. Ceci est utile si vous voulez utiliser les API QQuickWindow qui ne sont pas actuellement exposées par QQuickWidget, par exemple en vous connectant au signal QQuickWindow::beforeRendering() afin de dessiner du contenu OpenGL natif sous le propre rendu de Qt Quick.

Attention : Utilisez la valeur de retour de cette fonction avec prudence. En particulier, n'essayez jamais d'afficher le site QQuickWindow, et soyez très prudent lorsque vous utilisez d'autres API réservées à QWindow.

Attention : La fenêtre hors écran peut être supprimée (et recréée) pendant la durée de vie de QQuickWidget, en particulier lorsque le widget est déplacé vers un 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 du contexte. Chaque composant QML est instancié dans un contexte QQmlContext. Les contextes QQmlContext sont essentiels 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 QQmlEngine.

QQuickItem *QQuickWidget::rootObject() const

Renvoie la racine de la vue item. Peut être nullptr si setSource() n'a pas été appelé, s'il a été appelé avec un code QtQuick erroné ou si l'élément racine est autrement indéfini.

[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 devraient se connecter à ce signal si elles souhaitent gérer les erreurs, comme les échecs de création de contexte OpenGL, d'une manière personnalisée. Si aucun slot n'est connecté au signal, le comportement sera différent : Quick imprimera le message message, ou affichera une boîte de message, et mettra fin à l'application.

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

Voir aussi QQuickWindow::sceneGraphError().

void QQuickWidget::setClearColor(const QColor &color)

Définit la couleur claire color. Par défaut, il s'agit d'une couleur opaque.

Pour obtenir une couleur semi-transparente QQuickWidget, appelez cette fonction avec color défini à Qt::transparent, définissez l'attribut de widget Qt::WA_TranslucentBackground sur la fenêtre de niveau supérieur et demandez un canal alpha via setFormat().

Voir également QQuickWindow::setColor().

void QQuickWidget::setFormat(const QSurfaceFormat &format)

Définit la surface format pour le contexte et la surface hors écran utilisés par ce widget.

Cette fonction est appelée 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 prises en charge automatiquement et il n'est pas nécessaire de les demander explicitement.

Voir aussi 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 avoir appelé QQuickWidget::setSource().

Note : Vous ne pouvez utiliser cette fonction que pour initialiser les propriétés de premier niveau.

Remarque : Cette fonction doit toujours être appelée avant setSource, car elle n'a aucun effet une fois que le composant est devenu Ready.

Cette fonction a été introduite dans Qt 6.9.

Voir aussi QQmlComponent::createWithInitialProperties().

[slot] void QQuickWidget::setSource(const QUrl &url)

Définit la source à url, charge le composant QML et l'instancie.

Assurez-vous que l'URL fournie est complète et correcte ; en particulier, utilisez QUrl::fromLocalFile() pour charger un fichier à partir du système de fichiers local.

Si vous appelez cette méthode plusieurs fois avec la même URL, le composant QML sera réinstancié.

Note : Fonction de définition de la propriété source.

Voir également source().

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

Réimplémente : QWidget::showEvent(QShowEvent *event).

QUrl QQuickWidget::source() const

Renvoie l'URL de la source, si elle est définie.

Remarque : fonction Getter pour la propriété source.

Voir également setSource().

[signal] void QQuickWidget::statusChanged(QQuickWidget::Status status)

Ce signal est émis lorsque l'adresse status du composant est modifiée.

Note : Signal de notification pour la propriété status.

[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.