QWidget Class

Documentation sur les fonctions membres

[explicit] QWidget::QWidget(QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags())

Crée un widget qui est un enfant de ` parent`, dont les indicateurs de widget sont définis sur ` f`.

Si parent est nullptr, le nouveau widget devient une fenêtre. Si parent est un autre widget, ce widget devient une fenêtre enfant à l’intérieur de parent. Le nouveau widget est supprimé lorsque son parent est supprimé.

L’argument des indicateurs de widget, f, est normalement égal à 0, mais il peut être défini pour personnaliser le cadre d’une fenêtre (c’est-à-dire que parent doit être nullptr). Pour personnaliser le cadre, utilisez une valeur composée du OU binaire de n’importe lequel des window flags.

Si vous ajoutez un widget enfant à un widget déjà visible, vous devez afficher explicitement ce widget enfant pour le rendre visible.

Notez que la version X11 de Qt peut ne pas être en mesure de prendre en charge toutes les combinaisons de drapeaux de style sur tous les systèmes. En effet, sous X11, Qt ne peut qu'interroger le gestionnaire de fenêtres, et ce dernier peut passer outre les paramètres de l'application. Sous Windows, Qt peut définir tous les drapeaux de votre choix.

Voir également windowFlags.

[virtual noexcept] QWidget::~QWidget()

Supprime le widget.

Tous les éléments enfants de ce widget sont d'abord supprimés. L'application se ferme si ce widget est le widget principal.

[virtual protected] void QWidget::actionEvent(QActionEvent *event)

Ce gestionnaire d'événements est appelé avec l'event fournie chaque fois que les actions du widget sont modifiées.

Voir également addAction(), insertAction(), removeAction(), actions() et QActionEvent.

QList<QAction *> QWidget::actions() const

Renvoie la liste (éventuellement vide) des actions de ce widget.

Voir également contextMenuPolicy, insertAction() et removeAction().

void QWidget::activateWindow()

Définit le widget de niveau supérieur contenant ce widget comme fenêtre active.

Une fenêtre active est une fenêtre de premier niveau visible sur laquelle se trouve le focus du clavier.

Cette fonction effectue la même opération que lorsque l’on clique avec la souris sur la barre de titre d’une fenêtre de niveau supérieur. Sous X11, le résultat dépend du gestionnaire de fenêtres. Si vous souhaitez vous assurer que la fenêtre soit également placée au premier plan, vous devez également appeler la fonction ` raise()`. Notez que la fenêtre doit être visible, sinon la fonction `activateWindow()` n’a aucun effet.

Sous Windows, si vous appelez cette fonction alors que l’application n’est pas actuellement active, cela ne la rendra pas active. La couleur de l’icône dans la barre des tâches changera simplement pour indiquer que la fenêtre a subi une modification. En effet, Microsoft n’autorise pas une application à interrompre ce que l’utilisateur est en train de faire dans une autre application.

Voir également isActiveWindow(), window() et show().

void QWidget::addAction(QAction *action)

Ajoute l'action « action » à la liste des actions de ce widget.

Tous les QWidgets possèdent une liste d’ QActions. Cependant, celles-ci peuvent être représentées graphiquement de nombreuses façons différentes. L’utilisation par défaut de la liste d’ QAction s (telle que renvoyée par actions()) consiste à créer un contexte QMenu.

Un QWidget ne doit comporter qu'un seul exemplaire de chaque action ; l'ajout d'une action qu'il possède déjà n'entraînera pas la présence de cette même action deux fois dans le widget.

La propriété de action n'est pas transférée à ce QWidget.

Voir également removeAction(), insertAction(), actions() et QMenu.

Ces fonctions pratiques permettent de créer une nouvelle action avec le texte text, l'icône icon et le raccourci shortcut, le cas échéant.

Ces fonctions ajoutent l'action nouvellement créée à la liste des actions du widget, puis la renvoient.

QWidget prend possession de l'QAction renvoyée.

Ces fonctions ont été introduites dans Qt 6.3.

Ces fonctions pratiques créent une nouvelle action avec le texte text, l'icône icon et le raccourci shortcut, le cas échéant.

Le signal ` triggered()` de l’action est connecté comme s’il s’agissait d’un appel à ` QObject::connect` (action, &QAction::triggered, args…), transmettant parfaitement ` args`, y compris un éventuel ` Qt::ConnectionType`.

La fonction ajoute l’action nouvellement créée à la liste des actions du widget et la renvoie.

QWidget prend possession de l’ QAction renvoyée.

Ces fonctions ont été introduites dans Qt 6.3.

Cette fonction pratique crée une nouvelle action avec le texte « text », l'icône « icon » et le raccourci « shortcut », le cas échéant.

Le signal ` triggered()` de l'action est connecté au slot ` member ` de ` receiver`. La fonction ajoute l'action nouvellement créée à la liste des actions du widget et la renvoie.

QWidget prend possession de l’ QAction renvoyé.

Ces fonctions ont été introduites dans Qt 6.3.

void QWidget::addActions(const QList<QAction *> &actions)

Ajoute les actions « actions » à la liste des actions de ce widget.

Voir également removeAction(), QMenu et addAction().

void QWidget::adjustSize()

Ajuste la taille du widget pour qu'il s'adapte à son contenu.

Cette fonction utilise sizeHint() si celle-ci est valide, c'est-à-dire si la largeur et la hauteur de l'indication de taille sont >= 0. Sinon, elle définit la taille comme étant le rectangle enfant qui recouvre tous les widgets enfants (l'union de tous les rectangles des widgets enfants).

Pour les fenêtres, la taille de l'écran est également prise en compte. Si la fonction ` sizeHint()` renvoie une valeur inférieure à (200, 100) et que la politique de taille est définie sur ` expanding`, la fenêtre aura une taille minimale de (200, 100). La taille maximale d'une fenêtre correspond aux deux tiers de la largeur et de la hauteur de l'écran.

Voir également sizeHint() et childrenRect().

QPalette::ColorRole QWidget::backgroundRole() const

Renvoie le rôle d'arrière-plan du widget.

Le rôle d'arrière-plan définit le pinceau de l'palette e du widget qui est utilisé pour afficher l'arrière-plan.

Si aucun rôle d'arrière-plan n'est explicitement défini, le widget hérite du rôle d'arrière-plan de son widget parent.

Voir également ` setBackgroundRole()` et ` foregroundRole()`.

QBackingStore *QWidget::backingStore() const

Renvoie l'QBackingStore e dans laquelle ce widget sera dessiné.

[virtual protected] void QWidget::changeEvent(QEvent *event)

Ce gestionnaire d'événements peut être réimplémenté pour gérer les changements d'état.

L'état modifié lors de cet événement peut être récupéré via l'event fourni.

Les événements de modification incluent : QEvent::ToolBarChange, QEvent::ActivationChange, QEvent::EnabledChange, QEvent::FontChange, QEvent::StyleChange, QEvent::PaletteChange, QEvent::WindowTitleChange, QEvent::IconTextChange, QEvent::ModifiedChange, QEvent::MouseTrackingChange, QEvent::ParentChange, QEvent::WindowStateChange, QEvent::LanguageChange, QEvent::LocaleChange, QEvent::LayoutDirectionChange, QEvent::ReadOnlyChange.

QWidget *QWidget::childAt(int x, int y) const

Renvoie le widget enfant visible situé à la position (x, y) dans le système de coordonnées du widget. S'il n'y a pas de widget enfant visible à la position indiquée, la fonction renvoie nullptr.

QWidget *QWidget::childAt(const QPoint &p) const

Renvoie le widget enfant visible au point p dans le système de coordonnées propre au widget.

[since 6.8] QWidget *QWidget::childAt(const QPointF &p) const

Renvoie le widget enfant visible au point p dans le système de coordonnées propre au widget.

Cette fonction a été introduite dans Qt 6.8.

void QWidget::clearFocus()

Retire le focus du clavier du widget.

Si le widget a le focus actif, un événement « focus out event » est envoyé à ce widget pour lui signaler qu'il a perdu le focus.

Ce widget doit activer le paramètre de focus pour obtenir le focus du clavier ; c'est-à-dire qu'il doit appeler la fonction setFocusPolicy().

Voir également hasFocus(), setFocus(), focusInEvent(), focusOutEvent(), setFocusPolicy() et QApplication::focusWidget().

void QWidget::clearMask()

Supprime tout masque défini par la fonction setMask().

Voir également setMask().

[slot] bool QWidget::close()

Ferme ce widget. Renvoie « true » si le widget a été fermé ; sinon, renvoie « false ».

Il envoie d’abord un événement « QCloseEvent » au widget. Le widget est « hidden » s’il « accepts » l’événement de fermeture. S’il « ignores » l’événement, rien ne se passe. L’implémentation par défaut de ` QWidget::closeEvent()` accepte l’événement de fermeture.

Si le widget est marqué du drapeau « Qt::WA_DeleteOnClose », il est également supprimé. Un événement de fermeture est envoyé au widget, qu’il soit visible ou non.

Le signal QGuiApplication::lastWindowClosed() est émis lorsque la dernière fenêtre principale visible (c’est-à-dire une fenêtre sans parent) pour laquelle l’attribut Qt::WA_QuitOnClose est activé est fermée. Par défaut, cet attribut est activé pour tous les widgets, à l’exception des fenêtres éphémères telles que les écrans de démarrage, les fenêtres d’outils et les menus contextuels.

[virtual protected] void QWidget::closeEvent(QCloseEvent *event)

Ce gestionnaire d'événement est appelé avec l'event on fournie lorsque Qt reçoit une requête de fermeture de fenêtre pour un widget de niveau supérieur provenant du système de fenêtrage.

Par défaut, l'événement est accepté et le widget est fermé. Vous pouvez réimplémenter cette fonction pour modifier la manière dont le widget répond aux demandes de fermeture de fenêtre. Par exemple, vous pouvez empêcher la fermeture de la fenêtre en appelant ` ignore()` à chaque événement.

Les applications à fenêtre principale utilisent généralement des réimplémentations de cette fonction pour vérifier si le travail de l’utilisateur a été enregistré et demander son autorisation avant de fermer la fenêtre.

Voir également event(), hide(), close() et QCloseEvent.

QMargins QWidget::contentsMargins() const

La fonction `contentsMargins` renvoie les marges de contenu du widget.

Voir également setContentsMargins() et contentsRect().

QRect QWidget::contentsRect() const

Renvoie la surface située à l'intérieur des marges du widget.

Voir également setContentsMargins() et contentsMargins().

[virtual protected] void QWidget::contextMenuEvent(QContextMenuEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté dans une sous-classe afin de recevoir les événements du menu contextuel du widget.

Le gestionnaire est appelé lorsque l'contextMenuPolicy du widget est de type « Qt::DefaultContextMenu ».

L'implémentation par défaut ignore l'événement de contexte. Consultez la documentation relative à ` QContextMenuEvent ` pour plus de détails.

Voir également event(), QContextMenuEvent et customContextMenuRequested().

[protected] void QWidget::create(WId window = 0, bool initializeWindow = true, bool destroyOldWindow = true)

Crée une nouvelle fenêtre de widget.

Les paramètres window, initializeWindow et destroyOldWindow sont ignorés dans Qt 5. Veuillez utiliser QWindow::fromWinId() pour créer un QWindow encapsulant une fenêtre externe et le transmettre à QWidget::createWindowContainer() à la place.

Voir également createWindowContainer() et QWindow::fromWinId().

[static] QWidget *QWidget::createWindowContainer(QWindow *window, QWidget *parent = nullptr, Qt::WindowFlags flags = Qt::WindowFlags())

Crée un objet ` QWidget ` permettant d'intégrer ` window ` dans une application basée sur ` QWidget`.

Le conteneur de fenêtre est créé en tant qu’enfant de parent et avec les indicateurs de fenêtre flags.

Une fois la fenêtre intégrée dans le conteneur, ce dernier contrôle la géométrie et la visibilité de la fenêtre. Il n’est pas recommandé d’appeler explicitement les méthodes QWindow::setGeometry(), QWindow::show() ou QWindow::hide() sur une fenêtre intégrée.

Le conteneur prend possession de l'window. La fenêtre peut être retirée du conteneur de fenêtres à l'aide d'un appel à QWindow::setParent().

Le conteneur de fenêtres est associé en tant que fenêtre enfant native à la fenêtre de niveau supérieur dont il est le fils. Lorsqu’un conteneur de fenêtres est utilisé en tant qu’enfant d’une fenêtre de type ` QAbstractScrollArea ` ou ` QMdiArea`, il crée une fenêtre de type ` native window ` pour chaque widget de sa chaîne parentale afin de permettre un empilement et un découpage corrects dans ce cas d’utilisation. La création d’une fenêtre native pour le conteneur de fenêtres permet également un empilement et un découpage corrects. Cette opération doit être effectuée avant l’affichage du conteneur de fenêtres. Les applications comportant de nombreuses fenêtres enfants natives peuvent rencontrer des problèmes de performances.

Le conteneur de fenêtres présente un certain nombre de limitations connues :

• Ordre d'empilement : la fenêtre intégrée s'empilera au sommet de la hiérarchie des widgets sous la forme d'une boîte opaque. L'ordre d'empilement de plusieurs instances de conteneur de fenêtres qui se chevauchent n'est pas défini.
• Intégration du rendu : le conteneur de fenêtre n’interopère pas avec ` QGraphicsProxyWidget`, ` QWidget::render()` ou toute fonctionnalité similaire.
• Gestion du focus ; il est possible de définir n’importe quelle politique de focus pour l’instance du conteneur de fenêtre, et celle-ci déléguera le focus à la fenêtre via un appel à ` QWindow::requestActivate()`. Cependant, le retour à la chaîne de focus normale depuis l’instance ` QWindow ` dépendra de l’implémentation même de l’instance ` QWindow `. De plus, le fait que ` QWindow::requestActivate()` donne effectivement le focus à la fenêtre dépend de la plateforme.

  En cas d’intégration d’une fenêtre basée sur ` Qt Quick `, Qt veillera automatiquement à ce que les pressions sur la touche Tab permettent de passer de la fenêtre QML intégrée à l’extérieur de celle-ci, permettant ainsi au focus de se déplacer vers l’objet focusable suivant ou précédent dans la chaîne des conteneurs de fenêtres.

• L'utilisation d'un grand nombre d'instances de conteneurs de fenêtres dans une application basée sur ` QWidget` peut nuire considérablement aux performances globales de l'application.

[signal] void QWidget::customContextMenuRequested(const QPoint &pos)

Ce signal est émis lorsque la propriété ` contextMenuPolicy ` du widget prend la valeur ` Qt::CustomContextMenu` et que l'utilisateur a demandé l'affichage d'un menu contextuel sur le widget. La position ` pos ` correspond à la position de l'événement de menu contextuel reçu par le widget. En règle générale, cette position est exprimée en coordonnées du widget. La seule exception à cette règle concerne la classe ` QAbstractScrollArea ` et ses sous-classes, qui mappent l'événement de menu contextuel aux coordonnées renvoyées par la méthode ` viewport()`.

Voir également mapToGlobal(), QMenu et contextMenuPolicy.

[protected] void QWidget::destroy(bool destroyWindow = true, bool destroySubWindows = true)

Libère les ressources du système de fenêtrage. Détruit la fenêtre du widget si destroyWindow est vrai.

La fonction `destroy()` s'appelle elle-même de manière récursive pour tous les widgets enfants, en transmettant ` destroySubWindows ` au paramètre ` destroyWindow `. Pour mieux contrôler la destruction des sous-widgets, détruisez-les d'abord de manière sélective.

Cette fonction est généralement appelée depuis le destructeur de ` QWidget `.

[virtual protected] void QWidget::dragEnterEvent(QDragEnterEvent *event)

Ce gestionnaire d'événement est appelé lorsqu'un glissement est en cours et que la souris pénètre dans ce widget. L'événement est transmis via le paramètre ` event `.

Si l'événement est ignoré, le widget ne recevra aucune drag move events.

Consultez la documentation sur le glisser-déposer pour découvrir comment implémenter le glisser-déposer dans votre application.

Voir également QDrag et QDragEnterEvent.

[virtual protected] void QWidget::dragLeaveEvent(QDragLeaveEvent *event)

Ce gestionnaire d'événement est appelé lorsqu'un glisser-déposer est en cours et que la souris quitte ce widget. L'événement est transmis via le paramètre ` event `.

Consultez la documentation sur le glisser-déposer pour découvrir comment implémenter cette fonctionnalité dans votre application.

Voir également QDrag et QDragLeaveEvent.

[virtual protected] void QWidget::dragMoveEvent(QDragMoveEvent *event)

Ce gestionnaire d'événement est appelé lorsqu'un glisser-déposer est en cours et dès qu'une des conditions suivantes se produit : le curseur entre dans ce widget, le curseur se déplace à l'intérieur de ce widget, ou une touche de modification est enfoncée sur le clavier alors que ce widget a le focus. L'événement est transmis via le paramètre ` event `.

Consultez la documentation sur le glisser-déposer pour découvrir comment implémenter le glisser-déposer dans votre application.

Voir également QDrag et QDragMoveEvent.

[virtual protected] void QWidget::dropEvent(QDropEvent *event)

Ce gestionnaire d'événement est appelé lorsque l'élément glissé est déposé sur ce widget. L'événement est transmis via le paramètre ` event `.

Consultez la documentation sur le glisser-déposer pour découvrir comment implémenter cette fonctionnalité dans votre application.

Voir également QDrag et QDropEvent.

WId QWidget::effectiveWinId() const

Renvoie l'identifiant effectif du système de fenêtrage du widget, c'est-à-dire l'identifiant du système de fenêtrage du parent natif.

Si le widget est natif, cette fonction renvoie l’ID du widget natif. Sinon, elle renvoie l’ID de la fenêtre du premier widget parent natif, c’est-à-dire le widget de niveau supérieur qui contient ce widget.

Voir aussi ` nativeParentWidget()`.

void QWidget::ensurePolished() const

Vérifie que le widget et ses éléments enfants ont été mis en forme par QStyle (c'est-à-dire qu'ils disposent d'une police et d'une palette appropriées).

QWidget Appelle cette fonction une fois que le widget a été entièrement construit, mais avant qu’il ne s’affiche pour la toute première fois. Vous pouvez appeler cette fonction si vous souhaitez vous assurer que le widget est « peaufiné » avant d’effectuer une opération ; par exemple, la taille de police correcte peut être nécessaire dans la réimplémentation de la méthode ` sizeHint()` du widget. Notez que cette fonction est appelée depuis l’implémentation par défaut de la méthode ` sizeHint()`.

La finalisation est utile pour l’initialisation finale qui doit avoir lieu après l’appel de tous les constructeurs (aussi bien ceux des classes de base que ceux des sous-classes).

Si vous devez modifier certains paramètres lors de la finition d’un widget, réimplémentez ` event()` et gérez le type d’événement ` QEvent::Polish `.

Remarque : la fonction est déclarée `const` afin de pouvoir être appelée depuis d’autres fonctions `const` (par exemple, ` sizeHint()`).

Voir également event().

[virtual protected] void QWidget::enterEvent(QEnterEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir les événements d'entrée dans le widget, qui sont transmis via le paramètre ` event `.

Un événement est envoyé au widget lorsque le curseur de la souris pénètre dans celui-ci.

Voir également leaveEvent(), mouseMoveEvent() et event().

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

Réimplémente : QObject::event(QEvent *e).

Il s'agit du gestionnaire d'événements principal ; il gère les événements de type « event ». Vous pouvez réimplémenter cette fonction dans une sous-classe, mais nous vous recommandons plutôt d'utiliser l'un des gestionnaires d'événements spécialisés.

Les événements de pression et de relâchement de touche sont traités différemment des autres événements. La fonction event() vérifie si les touches Tab et Maj+Tab ont été enfoncées et tente de déplacer le focus en conséquence. S’il n’y a pas de widget vers lequel déplacer le focus (ou si la touche enfoncée n’est ni Tab ni Maj+Tab), event() appelle la fonction keyPressEvent().

La gestion des événements de souris et de tablette est également un peu particulière : ce n’est que lorsque le widget est en mode « enabled » que la fonction event() appelle les gestionnaires spécialisés tels que mousePressEvent() ; sinon, elle ignore l’événement.

Cette fonction renvoie ` true ` si l’événement a été reconnu, sinon elle renvoie ` false`. Si l’événement reconnu a été accepté (voir QEvent::accepted), tout traitement ultérieur, tel que la propagation de l’événement vers le widget parent, est interrompu.

Voir également closeEvent(), focusInEvent(), focusOutEvent(), enterEvent(), keyPressEvent(), keyReleaseEvent(), leaveEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), mousePressEvent(), mouseReleaseEvent(), moveEvent(), paintEvent(), resizeEvent(), QObject::event() et QObject::timerEvent().

[static] QWidget *QWidget::find(WId id)

Renvoie un pointeur vers le widget dont l'identifiant/le descripteur de fenêtre est id.

Le type d'identifiant de fenêtre dépend du système de fenêtrage sous-jacent ; voir qwindowdefs.h pour la définition exacte. S'il n'existe aucun widget portant cet identifiant, la fonction renvoie nullptr.

[virtual protected] void QWidget::focusInEvent(QFocusEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir les événements de focus clavier (focus reçu) pour le widget. L'événement est transmis via le paramètre ` event `

Un widget doit normalement définir la méthode ` setFocusPolicy()` sur une valeur autre que ` Qt::NoFocus ` pour recevoir les événements de focus. (Notez que le développeur d’applications peut appeler la méthode ` setFocus()` sur n’importe quel widget, même ceux qui n’acceptent normalement pas le focus.)

L’implémentation par défaut met à jour le widget (à l’exception des fenêtres qui ne spécifient pas d’appel à focusPolicy()).

Voir également focusOutEvent(), setFocusPolicy(), keyPressEvent(), keyReleaseEvent(), event() et QFocusEvent.

[protected] bool QWidget::focusNextChild()

Recherche un nouveau widget auquel attribuer le focus du clavier, conformément à Tab, et renvoie true s'il parvient à trouver un nouveau widget, ou false dans le cas contraire.

Voir également focusPreviousChild().

[virtual protected] bool QWidget::focusNextPrevChild(bool next)

Recherche un nouveau widget auquel attribuer le focus du clavier, selon le cas pour les touches Tab et Maj+Tab, et renvoie « true » si elle trouve un nouveau widget, ou « false » dans le cas contraire.

Si ` next ` est vrai, cette fonction effectue une recherche vers l'avant ; si ` next ` est faux, elle effectue une recherche vers l'arrière.

Il peut parfois s’avérer nécessaire de réimplémenter cette fonction. Par exemple, un navigateur web pourrait la réimplémenter pour faire avancer ou reculer son « lien actif actuel », et n’appeler focusNextPrevChild() que lorsqu’il atteint le dernier ou le premier lien de la « page ».

Les widgets enfants appellent focusNextPrevChild() sur leurs widgets parents, mais seule la fenêtre qui contient les widgets enfants décide où rediriger le focus. En réimplémentant cette fonction pour un objet, vous prenez ainsi le contrôle du parcours du focus pour tous les widgets enfants.

Voir également focusNextChild() et focusPreviousChild().

[virtual protected] void QWidget::focusOutEvent(QFocusEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir les événements de focus clavier (perte de focus) pour le widget. L'événement est transmis via le paramètre ` event `.

Un widget doit normalement définir la méthode ` setFocusPolicy()` sur une valeur autre que ` Qt::NoFocus ` pour recevoir les événements de focus. (Notez que le développeur d'applications peut appeler la méthode ` setFocus()` sur n'importe quel widget, même ceux qui n'acceptent normalement pas le focus.)

L’implémentation par défaut met à jour le widget (à l’exception des fenêtres qui ne spécifient pas d’appel à ` focusPolicy()`).

Voir également focusInEvent(), setFocusPolicy(), keyPressEvent(), keyReleaseEvent(), event() et QFocusEvent.

[protected] bool QWidget::focusPreviousChild()

Recherche un nouveau widget auquel attribuer le focus du clavier, conformément à Shift+Tab, et renvoie true s'il parvient à trouver un nouveau widget, ou false dans le cas contraire.

Voir également focusNextChild().

QWidget *QWidget::focusProxy() const

Renvoie le proxy de focus, ou ` nullptr ` s'il n'y a pas de proxy de focus.

Voir aussi setFocusProxy().

QWidget *QWidget::focusWidget() const

Renvoie le dernier enfant de ce widget sur lequel la fonction ` setFocus ` a été appelée. Pour les widgets de niveau supérieur, il s'agit du widget qui recevra le focus si cette fenêtre est activée

Cette méthode n’est pas identique à ` QApplication::focusWidget()`, qui renvoie le widget actif dans la fenêtre actuellement active.

QFontInfo QWidget::fontInfo() const

Renvoie les informations relatives à la police actuellement utilisée par le widget. Équivalent à ` QFontInfo(widget->font())`.

Voir également font(), fontMetrics() et setFont().

QFontMetrics QWidget::fontMetrics() const

Renvoie les métriques de la police actuellement utilisée par le widget. Équivalent à ` QFontMetrics(widget->font())`.

Voir également font(), fontInfo() et setFont().

QPalette::ColorRole QWidget::foregroundRole() const

Renvoie le rôle de premier plan.

Le rôle de premier plan définit la couleur de l'palette du widget qui est utilisée pour dessiner le premier plan.

Si aucun rôle de premier plan n'est explicitement défini, la fonction renvoie un rôle qui contraste avec le rôle d'arrière-plan.

Voir également ` setForegroundRole()` et ` backgroundRole()`.

[invokable] QPixmap QWidget::grab(const QRect &rectangle = QRect(QPoint(0, 0), QSize(-1, -1)))

Affiche le widget dans une image bitmap dont les dimensions sont limitées par l'rectangle. Si le widget comporte des éléments enfants, ceux-ci sont également affichés aux emplacements appropriés.

Si un rectangle dont la taille n’est pas valide est spécifié (valeur par défaut), le widget entier est dessiné.

Voir également ` render()` et ` QPixmap`.

void QWidget::grabGesture(Qt::GestureType gesture, Qt::GestureFlags flags = Qt::GestureFlags())

Abonne le widget à une source gesture donnée, avec des paramètres flags spécifiques.

Voir également ungrabGesture() et QGestureEvent.

void QWidget::grabKeyboard()

Capture les entrées du clavier.

Ce widget reçoit tous les événements clavier jusqu’à ce que la fonction releaseKeyboard() soit appelée ; les autres widgets ne reçoivent alors plus aucun événement clavier. Les événements souris ne sont pas affectés. Utilisez la fonction grabMouse() si vous souhaitez les capturer.

Le widget actif n’est pas affecté, si ce n’est qu’il ne reçoit aucun événement clavier. La fonction ` setFocus()` déplace le focus comme d’habitude, mais le nouveau widget actif ne reçoit les événements clavier qu’après l’appel de ` releaseKeyboard()`.

Si un autre widget capture actuellement les entrées clavier, la capture de ce widget est d’abord libérée.

Voir également releaseKeyboard(), grabMouse(), releaseMouse() et focusWidget().

void QWidget::grabMouse()

Capture les événements de la souris.

Ce widget reçoit tous les événements de souris jusqu’à ce que la fonction ` releaseMouse()` soit appelée ; les autres widgets ne reçoivent alors plus aucun événement de souris. Les événements clavier ne sont pas affectés. Utilisez la fonction ` grabKeyboard()` si vous souhaitez les intercepter.

Il est rarement nécessaire de capturer la souris lors de l’utilisation de Qt, car Qt la capture et la libère de manière appropriée. En particulier, Qt capture la souris lorsqu’un bouton de souris est enfoncé et la conserve jusqu’à ce que le dernier bouton soit relâché.

Voir également releaseMouse(), grabKeyboard() et releaseKeyboard().

void QWidget::grabMouse(const QCursor &cursor)

Capture les événements de la souris et modifie la forme du curseur.

Le curseur prendra la forme cursor (tant que le focus de la souris est capturé) et ce widget sera le seul à recevoir les événements de souris jusqu'à ce que la fonction releaseMouse() soit appelée.

Voir également releaseMouse(), grabKeyboard(), releaseKeyboard() et setCursor().

int QWidget::grabShortcut(const QKeySequence &key, Qt::ShortcutContext context = Qt::WindowShortcut)

Ajoute un raccourci au système de raccourcis de Qt qui surveille la séquence d’ key spécifiée dans l’ context indiquée. Si l’ context est Qt::ApplicationShortcut, le raccourci s’applique à l’application dans son ensemble. Sinon, il est soit local à ce widget ( Qt::WidgetShortcut), soit à la fenêtre elle-même ( Qt::WindowShortcut).

Si la même séquence « key » a été capturée par plusieurs widgets, lorsque la séquence « key » se produit, un événement « QEvent::Shortcut » est envoyé à tous les widgets auxquels elle s’applique dans un ordre non déterministe, mais avec le drapeau « ambiguous » défini sur true.

Voir également releaseShortcut() et setShortcutEnabled().

QGraphicsEffect *QWidget::graphicsEffect() const

La fonction `graphicsEffect` renvoie un pointeur vers l'effet graphique du widget.

Si le widget ne dispose d'aucun effet graphique, la valeur « nullptr » est renvoyée.

Voir aussi ` setGraphicsEffect()`.

QGraphicsProxyWidget *QWidget::graphicsProxyWidget() const

Renvoie le widget proxy correspondant au widget intégré dans une vue graphique ; sinon, renvoie « nullptr ».

Voir également QGraphicsProxyWidget::createProxyForChildWidget() et QGraphicsScene::addWidget().

[virtual] bool QWidget::hasHeightForWidth() const

Renvoie « true » si la hauteur préférée du widget dépend de sa largeur ; sinon, renvoie « false ».

[virtual] int QWidget::heightForWidth(int w) const

Renvoie la hauteur préférée de ce widget, compte tenu de la largeur w.

Si ce widget dispose d'une mise en page, l'implémentation par défaut renvoie la hauteur préférée de la mise en page. S'il n'y a pas de mise en page, l'implémentation par défaut renvoie -1, indiquant que la hauteur préférée ne dépend pas de la largeur.

[slot] void QWidget::hide()

Masque le widget. Cette fonction équivaut à ` setVisible(false)`.

Voir également hideEvent(), isHidden(), show(), setVisible(), isVisible() et close().

[virtual protected] void QWidget::hideEvent(QHideEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir les événements de masquage des widgets. L'événement est transmis via le paramètre « event ».

Les événements de masquage sont envoyés aux widgets immédiatement après leur masquage.

Remarque : un widget reçoit des événements d’affichage et de masquage spontanés lorsque son état de mappage est modifié par le système de fenêtrage, par exemple un événement de masquage spontané lorsque l’utilisateur minimise la fenêtre, et un événement d’affichage spontané lorsque la fenêtre est à nouveau restaurée. Après avoir reçu un événement de masquage spontané, un widget est toujours considéré comme visible au sens de la fonction isVisible().

Voir également visible, event() et QHideEvent.

[override virtual protected] void QWidget::initPainter(QPainter *painter) const

Initialise le stylo, l'arrière-plan et la police de l'painter, en les rendant identiques à ceux du widget fourni. Cette fonction est appelée automatiquement lorsque l' est ouvert sur un QWidget.

[virtual protected] void QWidget::inputMethodEvent(QInputMethodEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté dans une sous-classe afin de recevoir les événements de composition de la méthode de saisie. Ce gestionnaire est appelé lorsque l'état de la méthode de saisie change.

Notez que lors de la création de widgets d’édition de texte personnalisés, l’attribut de fenêtre ` Qt::WA_InputMethodEnabled ` doit être défini explicitement (à l’aide de la fonction ` setAttribute()`) afin de recevoir les événements liés à la méthode de saisie.

L'implémentation par défaut appelle event->ignore(), ce qui rejette l'événement de la méthode de saisie. Consultez la documentation relative à QInputMethodEvent pour plus de détails.

Voir également event() et QInputMethodEvent.

[virtual] QVariant QWidget::inputMethodQuery(Qt::InputMethodQuery query) const

Cette méthode ne s'applique qu'aux widgets de saisie. Elle est utilisée par le système de saisie pour interroger un ensemble de propriétés du widget afin de prendre en charge des opérations complexes, telles que la gestion du texte environnant et les reconversions.

query Spécifie quelle propriété est interrogée.

Voir également inputMethodEvent(), QInputMethodEvent, QInputMethodQueryEvent et inputMethodHints.

void QWidget::insertAction(QAction *before, QAction *action)

Ajoute l'action action à la liste des actions de ce widget, avant l'action before. Elle ajoute l'action à la fin si before est nullptr ou si before n'est pas une action valide pour ce widget.

Un « QWidget » ne doit comporter qu’un seul exemplaire de chaque action.

Voir également removeAction(), addAction(), QMenu, contextMenuPolicy et actions().

void QWidget::insertActions(QAction *before, const QList<QAction *> &actions)

Ajoute l'action actions à la liste des actions de ce widget, avant l'action before. L'action est ajoutée à la fin de la liste si before est nullptr ou si before n'est pas une action valide pour ce widget.

Un « QWidget » ne peut comporter qu’une seule instance de chaque action.

Voir également removeAction(), QMenu, insertAction() et contextMenuPolicy.

bool QWidget::isAncestorOf(const QWidget *child) const

Renvoie ` true ` si ce widget est un parent (ou un grand-parent, et ainsi de suite à n'importe quel niveau) du widget ` child` donné, et si les deux widgets se trouvent dans la même fenêtre ; sinon, renvoie ` false`.

bool QWidget::isEnabledTo(const QWidget *ancestor) const

Renvoie « true » si ce widget devait être activé lorsque « ancestor » est activé ; sinon, renvoie « false ».

C'est le cas si ni le widget lui-même, ni aucun de ses parents jusqu'à ancestor inclus (à l'exclusion de ce dernier) n'ont été explicitement désactivés.

isEnabledTo(0) renvoie « false » si ce widget ou l’un de ses ancêtres a été explicitement désactivé.

Le terme « ancêtre » désigne ici un widget parent situé dans la même fenêtre.

Par conséquent, isEnabledTo(0) s’arrête à la fenêtre de ce widget, contrairement à isEnabled() qui prend également en compte les fenêtres parentes.

Voir également setEnabled() et enabled.

bool QWidget::isHidden() const

Renvoie ` true ` si le widget est masqué, sinon renvoie ` false`.

Un widget masqué ne deviendra visible que lorsque la fonction show() sera appelée sur celui-ci. Il ne s'affichera pas automatiquement lorsque le parent sera affiché.

Pour vérifier la visibilité, utilisez plutôt !isVisible() (notez le point d’exclamation).

isHidden() implique !isVisible(), mais un widget peut être à la fois non visible et non masqué. C'est le cas des widgets qui sont des enfants de widgets non visibles.

Les widgets sont masqués si :

• ils ont été créés en tant que fenêtres indépendantes,
• ils ont été créés en tant qu'enfants de widgets visibles,
• hide() ou setVisible(false) a été appelé.

bool QWidget::isVisibleTo(const QWidget *ancestor) const

Renvoie « true » si ce widget deviendrait visible lorsque « ancestor » est affiché ; sinon, renvoie « false ».

La valeur « true » est renvoyée si ni le widget lui-même, ni aucun de ses parents jusqu’à ancestor (exclu) n’ont été explicitement masqués.

Cette fonction renvoie tout de même « true » si le widget est masqué par d’autres fenêtres à l’écran, mais qu’il pourrait être physiquement visible si celles-ci étaient déplacées.

isVisibleTo(0) est identique à isVisible().

Voir également show(), hide() et isVisible().

bool QWidget::isWindow() const

Renvoie « true » si le widget est une fenêtre indépendante ; sinon, renvoie « false ».

Une fenêtre est un widget qui n’est visuellement le fils d’aucun autre widget et qui possède généralement un cadre et un « window title ».

Une fenêtre peut disposer d’un parent widget. Elle sera alors regroupée avec son parent et supprimée lorsque celui-ci sera supprimé, minimisée lorsque celui-ci sera minimisé, etc. Si le gestionnaire de fenêtres le prend en charge, elle disposera également d’une entrée commune dans la barre des tâches avec son parent.

QDialog Les widgets ` QMainWindow ` sont par défaut des fenêtres, même si un widget parent est spécifié dans le constructeur. Ce comportement est défini par l’indicateur ` Qt::Window `.

Voir également window(), isModal() et parentWidget().

[virtual protected] void QWidget::keyPressEvent(QKeyEvent *event)

Ce gestionnaire d'événements, destiné à l'événement ` event`, peut être réimplémenté dans une sous-classe afin de recevoir les événements de frappe pour le widget.

Un widget doit appeler ` setFocusPolicy()` pour accepter le focus initialement et disposer du focus afin de recevoir un événement de frappe.

Si vous réimplémentez ce gestionnaire, il est très important d’appeler l’implémentation de la classe de base si vous ne traitez pas la touche.

L’implémentation par défaut ferme les widgets contextuels si l’utilisateur appuie sur la séquence de touches définie pour ` QKeySequence::Cancel ` (généralement la touche Échap). Sinon, l’événement est ignoré, afin que le parent du widget puisse l’interpréter.

Notez que la méthode ` QKeyEvent ` commence avec `isAccepted()` == `true` ; vous n’avez donc pas besoin d’appeler ` QKeyEvent::accept()` — veillez simplement à ne pas appeler l’implémentation de la classe parente si vous traitez la touche.

Voir également keyReleaseEvent(), setFocusPolicy(), focusInEvent(), focusOutEvent(), event() et QKeyEvent.

[virtual protected] void QWidget::keyReleaseEvent(QKeyEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté dans une sous-classe afin de recevoir les événements de relâchement de touche pour le widget.

Un widget doit initialement utiliser ` accept focus ` et ` have focus ` afin de recevoir un événement de relâchement de touche.

Si vous réimplémentez ce gestionnaire, il est très important d’appeler l’implémentation de la classe parente si vous ne traitez pas l’événement.

L’implémentation par défaut ignore l’événement, afin que le parent du widget puisse l’interpréter.

Notez que la méthode ` QKeyEvent ` commence avec `isAccepted()` == `true` ; vous n’avez donc pas besoin d’appeler ` QKeyEvent::accept()` — veillez simplement à ne pas appeler l’implémentation de la classe parente si vous traitez la touche.

Voir également keyPressEvent(), QEvent::ignore(), setFocusPolicy(), focusInEvent(), focusOutEvent(), event() et QKeyEvent.

[static] QWidget *QWidget::keyboardGrabber()

Renvoie le widget qui a actuellement le contrôle des entrées clavier.

Si aucun widget de cette application n'est actuellement en train de capturer les entrées clavier, la fonction nullptr est renvoyée.

Voir également ` grabMouse()` et ` mouseGrabber()`.

QLayout *QWidget::layout() const

Renvoie le gestionnaire de mise en page associé à ce widget, ou ` nullptr ` si aucun gestionnaire de mise en page n'est associé.

Le gestionnaire de mise en page définit la géométrie des enfants du widget qui ont été ajoutés à la mise en page.

Voir également setLayout(), sizePolicy() et Gestion de la mise en page.

[virtual protected] void QWidget::leaveEvent(QEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir les événements de sortie du widget, qui sont transmis via le paramètre ` event `.

Un événement de sortie est envoyé au widget lorsque le curseur de la souris quitte le widget.

Voir également enterEvent(), mouseMoveEvent() et event().

[slot] void QWidget::lower()

Place le widget au bas de la pile du widget parent.

Après cet appel, le widget se trouvera visuellement derrière (et sera donc masqué par) tous les widgets frères qui le recouvrent.

Voir également raise() et stackUnder().

[since 6.0] QPointF QWidget::mapFrom(const QWidget *parent, const QPointF &pos) const

Convertit l'pos de coordonnées du widget du système de coordonnées de parent vers le système de coordonnées de ce widget. L'parent ne doit pas être de type « nullptr » et doit être un parent du widget appelant.

Cette fonction a été introduite dans Qt 6.0.

Voir également mapTo(), mapFromParent(), mapFromGlobal() et underMouse().

QPoint QWidget::mapFrom(const QWidget *parent, const QPoint &pos) const

[since 6.0] QPointF QWidget::mapFromGlobal(const QPointF &pos) const

Convertit les coordonnées globales de l'écran pos en coordonnées du widget.

Cette fonction a été introduite dans Qt 6.0.

Voir également mapToGlobal(), mapFrom() et mapFromParent().

QPoint QWidget::mapFromGlobal(const QPoint &pos) const

[since 6.0] QPointF QWidget::mapFromParent(const QPointF &pos) const

Convertit les coordonnées du widget parent ( pos ) en coordonnées du widget.

Equivalent à ` mapFromGlobal()` si le widget n'a pas de parent.

Cette fonction a été introduite dans Qt 6.0.

Voir également mapToParent(), mapFrom(), mapFromGlobal() et underMouse().

QPoint QWidget::mapFromParent(const QPoint &pos) const

[since 6.0] QPointF QWidget::mapTo(const QWidget *parent, const QPointF &pos) const

Convertit l'pos des coordonnées du widget dans le système de coordonnées de parent. L'parent ne doit pas être de type nullptr et doit être le parent du widget appelant.

Cette fonction a été introduite dans Qt 6.0.

Voir également mapFrom(), mapToParent(), mapToGlobal() et underMouse().

QPoint QWidget::mapTo(const QWidget *parent, const QPoint &pos) const

[since 6.0] QPointF QWidget::mapToGlobal(const QPointF &pos) const

Convertit l'pos de coordonnées du widget en coordonnées globales de l'écran. Par exemple, la fonction ` mapToGlobal(QPointF(0,0)) ` renvoie les coordonnées globales du pixel situé en haut à gauche du widget.

Cette fonction a été introduite dans Qt 6.0.

Voir également mapFromGlobal(), mapTo() et mapToParent().

QPoint QWidget::mapToGlobal(const QPoint &pos) const

[since 6.0] QPointF QWidget::mapToParent(const QPointF &pos) const

Convertit les coordonnées du widget pos en coordonnées du widget parent.

Equivalent à ` mapToGlobal()` si le widget n'a pas de parent.

Cette fonction a été introduite dans Qt 6.0.

Voir également mapFromParent(), mapTo(), mapToGlobal() et underMouse().

QPoint QWidget::mapToParent(const QPoint &pos) const

QRegion QWidget::mask() const

Renvoie le masque actuellement défini sur un widget. Si aucun masque n'est défini, la valeur renvoyée sera une région vide.

Voir également setMask(), clearMask() et QRegion::isEmpty().

[override virtual protected] int QWidget::metric(QPaintDevice::PaintDeviceMetric m) const

Réimplémente : ` QPaintDevice::metric(QPaintDevice::PaintDeviceMetric metric) const`.

Implémentation interne de la fonction virtuelle QPaintDevice::metric().

m est la métrique à récupérer.

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

Ce gestionnaire d'événement, destiné à l'événement « event », peut être réimplémenté dans une sous-classe afin de recevoir les événements de double-clic de la souris pour le widget.

L'implémentation par défaut appelle ` mousePressEvent()`.

Voir également mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent(), event() et QMouseEvent.

[static] QWidget *QWidget::mouseGrabber()

Renvoie le widget qui gère actuellement l'entrée de la souris.

Si aucun widget de cette application ne capte actuellement l'entrée de la souris, la fonction nullptr est renvoyée.

Voir également ` grabMouse()` et ` keyboardGrabber()`.

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

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté dans une sous-classe afin de recevoir les événements de déplacement de la souris pour le widget.

Si le suivi de la souris est désactivé, les événements de déplacement de la souris ne se produisent que si un bouton de la souris est enfoncé pendant que la souris est déplacée. Si le suivi de la souris est activé, les événements de déplacement de la souris se produisent même si aucun bouton de la souris n’est enfoncé.

QMouseEvent::position() renvoie la position du curseur de la souris, par rapport à ce widget. Pour les événements de clic et de relâchement, la position est généralement la même que celle du dernier événement de déplacement de la souris, mais elle peut varier si la main de l’utilisateur tremble. Il s’agit d’une caractéristique du système de fenêtrage sous-jacent, et non de Qt.

Si vous souhaitez afficher immédiatement une info-bulle pendant que la souris se déplace (par exemple, pour obtenir les coordonnées de la souris avec ` QMouseEvent::position()` et les afficher sous forme d’info-bulle), vous devez d’abord activer le suivi de la souris comme décrit ci-dessus. Ensuite, pour garantir que l’info-bulle soit mise à jour immédiatement, vous devez appeler ` QToolTip::showText()` au lieu de ` setToolTip()` dans votre implémentation de `mouseMoveEvent()`.

Voir également setMouseTracking(), mousePressEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), event(), QMouseEvent et l’exemple Scribble.

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

Ce gestionnaire d'événement, destiné à l'événement « event », peut être réimplémenté dans une sous-classe afin de recevoir les événements de clic de souris pour le widget.

Si vous créez de nouveaux widgets dans la fonction mousePressEvent(), l’ mouseReleaseEvent() risque de ne pas se terminer là où vous vous y attendez, en fonction du système de fenêtrage sous-jacent (ou du gestionnaire de fenêtres X11), de l’emplacement des widgets et peut-être d’autres facteurs.

L’implémentation par défaut provoque la fermeture des widgets contextuels lorsque vous cliquez en dehors de la fenêtre. Pour les autres types de widgets, elle ne fait rien.

Voir également mouseReleaseEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), event(), QMouseEvent et l’exemple Scribble.

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

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté dans une sous-classe afin de recevoir les événements de relâchement de souris pour le widget.

Voir également mousePressEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), event(), QMouseEvent et l'exemple Scribble.

void QWidget::move(int x, int y)

Cela correspond à la fonction move(QPoint(x, y)).

[virtual protected] void QWidget::moveEvent(QMoveEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir les événements de déplacement du widget, qui sont transmis via le paramètre event. Lorsque le widget reçoit cet événement, il se trouve déjà à sa nouvelle position.

L'ancienne position est accessible via QMoveEvent::oldPos().

Voir également resizeEvent(), event(), move() et QMoveEvent.

[virtual protected] bool QWidget::nativeEvent(const QByteArray &eventType, void *message, qintptr *result)

Ce gestionnaire d'événements spécial peut être réimplémenté dans une sous-classe afin de recevoir les événements natifs de la plateforme identifiés par eventType, qui sont transmis via le paramètre message.

Dans votre réimplémentation de cette fonction, si vous souhaitez empêcher Qt de gérer l’événement, renvoyez true et définissez result. Le paramètre result n’a de sens que sous Windows. Si vous renvoyez false, cet événement natif est renvoyé à Qt, qui le convertit en événement Qt et l’envoie au widget.

Voir aussi QAbstractNativeEventFilter.

QWidget *QWidget::nativeParentWidget() const

Renvoie le parent natif de ce widget, c'est-à-dire le widget ancêtre le plus proche disposant d'un identifiant système, ou nullptr s'il n'a pas de parent natif.

Voir également effectiveWinId().

QWidget *QWidget::nextInFocusChain() const

Renvoie le widget suivant dans la chaîne de focus de ce widget.

Voir aussi previousInFocusChain().

void QWidget::overrideWindowFlags(Qt::WindowFlags flags)

Définit les indicateurs de fenêtre du widget sur « flags », sans en informer le système de fenêtrage.

Voir également ` setWindowFlags()`.

[override virtual] QPaintEngine *QWidget::paintEngine() const

Réimplémente : ` QPaintDevice::paintEngine()` const.

Renvoie le moteur de rendu du widget.

Notez que cette fonction ne doit pas être appelée explicitement par l'utilisateur, car elle est uniquement destinée à être réimplémentée. La fonction est appelée en interne par Qt, et l'implémentation par défaut ne renvoie pas toujours un pointeur valide.

[virtual protected] void QWidget::paintEvent(QPaintEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir les événements de dessin transmis via ` event`.

Un événement de dessin est une demande de rafraîchissement de tout ou partie d’un widget. Il peut se produire pour l’une des raisons suivantes :

• repaint() ou update() a été appelé,
• le widget était masqué et est désormais visible, ou
• pour de nombreuses autres raisons.

De nombreux widgets peuvent simplement rafraîchir l’intégralité de leur surface lorsqu’on leur en fait la demande, mais certains widgets lents doivent optimiser leur comportement en ne rafraîchissant que la zone demandée : ` QPaintEvent::region()`. Cette optimisation de vitesse ne modifie pas le résultat, car le rafraîchissement est limité à cette zone lors du traitement de l’événement. Les classes ` QListView ` et ` QTableView ` procèdent ainsi, par exemple.

Qt tente également d’accélérer le dessin en fusionnant plusieurs événements de dessin en un seul. Lorsque la fonction update() est appelée plusieurs fois ou que le système de fenêtrage envoie plusieurs événements de dessin, Qt fusionne ces événements en un seul événement couvrant une zone plus grande (voir QRegion::united()). La fonction repaint() ne permet pas cette optimisation ; nous vous recommandons donc d’utiliser update() dans la mesure du possible.

Lorsque l’événement de dessin se produit, la région de mise à jour a normalement été effacée ; vous dessinez donc sur l’arrière-plan du widget.

L’arrière-plan peut être défini à l’aide de setBackgroundRole() et setPalette().

Depuis Qt 4.0, la fonction QWidget utilise automatiquement le double tampon pour le dessin ; il n’est donc plus nécessaire d’écrire de code de double tampon dans paintEvent() pour éviter le scintillement.

Voir aussi event(), repaint(), update(), QPainter, QPixmap, QPaintEvent et Analog Clock.

QWidget *QWidget::parentWidget() const

Renvoie le widget parent de ce widget, ou ` nullptr ` s'il n'a pas de widget parent.

QWidget *QWidget::previousInFocusChain() const

La fonction `InFocusChain` renvoie le widget précédent dans la chaîne de focus de ce widget.

Voir également nextInFocusChain().

[slot] void QWidget::raise()

Place ce widget au premier plan de la pile du widget parent.

Après cet appel, le widget apparaîtra visuellement devant tous les widgets frères qui le chevauchent.

Voir également lower() et stackUnder().

void QWidget::releaseKeyboard()

Libère le contrôle du clavier.

Voir également grabKeyboard(), grabMouse() et releaseMouse().

void QWidget::releaseMouse()

Libère la sélection de la souris.

Voir également grabMouse(), grabKeyboard() et releaseKeyboard().

void QWidget::releaseShortcut(int id)

Supprime le raccourci associé à l'id indiquée du système de raccourcis de Qt. Le widget ne recevra plus d'événements « QEvent::Shortcut » pour la séquence de touches du raccourci (à moins qu'il ne dispose d'autres raccourcis utilisant la même séquence de touches).

Voir également grabShortcut() et setShortcutEnabled().

void QWidget::removeAction(QAction *action)

Supprime l'action « action » de la liste des actions de ce widget.

Voir également insertAction() et actions().

void QWidget::render(QPaintDevice *target, const QPoint &targetOffset = QPoint(), const QRegion &sourceRegion = QRegion(), QWidget::RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren))

Affiche l'sourceRegion de ce widget dans l'target en utilisant renderFlags pour déterminer comment l'afficher. L'affichage commence à l'adresse targetOffset dans le target. Par exemple :

QPixmap pixmap(widget->size());
widget->render(&pixmap);

Si sourceRegion est une région nulle, cette fonction utilisera QWidget::rect() comme région, c'est-à-dire l'intégralité du widget.

Veillez à appeler QPainter::end() pour le peintre actif (le cas échéant) du périphérique target avant le rendu. Par exemple :

QPainter painter(this);
...
painter.end();
myWidget->render(this);

void QWidget::render(QPainter *painter, const QPoint &targetOffset = QPoint(), const QRegion &sourceRegion = QRegion(), QWidget::RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren))

Affiche le widget dans la méthode QPainter::device() de l'painter.

Les transformations et les paramètres appliqués à l'painter seront utilisés lors de l'affichage.

Voir également QPainter::device().

[slot] void QWidget::repaint()

Redessine directement le widget en appelant immédiatement la fonction ` paintEvent()`, sauf si les mises à jour sont désactivées ou si le widget est masqué.

Nous vous recommandons de n’utiliser repaint() que si vous avez besoin d’un rafraîchissement immédiat, par exemple pendant une animation. Dans la plupart des cas, update() est préférable, car il permet à Qt d’optimiser la vitesse et de minimiser le scintillement.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        widget, qOverload<>(&QWidget::repaint));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        widget, [receiver = widget]() { receiver->repaint(); });

Voir également update(), paintEvent() et setUpdatesEnabled().

void QWidget::repaint(const QRect &rect)

Cette version redessine un rectangle rect à l'intérieur du widget.

void QWidget::repaint(const QRegion &rgn)

Cette version actualise l'affichage d'une région rgn à l'intérieur du widget.

void QWidget::repaint(int x, int y, int w, int h)

Cette version redessine un rectangle (x, y, w, h) à l'intérieur du widget.

Si w est négative, elle est remplacée par width() - x, et si h est négative, elle est remplacée par height() - y.

void QWidget::resize(int w, int h)

Cela correspond à resize(QSize(w, h)).

[virtual protected] void QWidget::resizeEvent(QResizeEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir les événements de redimensionnement du widget, qui sont transmis via le paramètre ` event `. Lorsque la méthode `resizeEvent()` est appelée, le widget dispose déjà de sa nouvelle géométrie. L'ancienne taille est accessible via la méthode ` QResizeEvent::oldSize()`.

Le widget sera effacé et recevra un événement de dessin immédiatement après le traitement de l’événement de redimensionnement. Aucun dessin ne doit (ni ne devrait) être effectué à l’intérieur de ce gestionnaire.

Voir également moveEvent(), event(), resize(), QResizeEvent, paintEvent() et l’exemple Scribble.

bool QWidget::restoreGeometry(const QByteArray &geometry)

Restaure la géométrie et l'état des widgets de niveau supérieur stockés dans le tableau d'octets geometry. Renvoie true en cas de succès ; sinon, renvoie false.

Si la géométrie restaurée se trouve hors écran, elle sera modifiée pour s’inscrire dans la géométrie d’écran disponible.

Pour restaurer une géométrie enregistrée à l’aide de ` QSettings`, vous pouvez utiliser un code similaire à celui-ci :

QSettings settings("MyCompany", "MyApp");
myWidget->restoreGeometry(settings.value("myWidget/geometry").toByteArray());

Consultez la documentation sur la géométrie des fenêtres pour obtenir un aperçu des problèmes de géométrie liés aux fenêtres.

Utilisez QMainWindow::restoreState() pour restaurer la géométrie ainsi que l’état des barres d’outils et des widgets ancrés.

Voir également ` saveGeometry()`, ` QSettings`, ` QMainWindow::saveState()` et ` QMainWindow::restoreState()`.

QByteArray QWidget::saveGeometry() const

Enregistre la géométrie et l'état actuels des widgets de niveau supérieur.

Pour enregistrer la géométrie à la fermeture de la fenêtre, vous pouvez implémenter un événement de fermeture comme suit :

void MyWidget::closeEvent(QCloseEvent *event)
{
    QSettings settings("MyCompany", "MyApp");
    settings.setValue("geometry", saveGeometry());
    QWidget::closeEvent(event);
}

Consultez la documentation sur la géométrie des fenêtres pour obtenir un aperçu des problèmes de géométrie liés aux fenêtres.

Utilisez ` QMainWindow::saveState()` pour enregistrer la géométrie et l'état des barres d'outils et des widgets ancrés.

Voir également ` restoreGeometry()`, ` QMainWindow::saveState()` et ` QMainWindow::restoreState()`.

QScreen *QWidget::screen() const

Renvoie l'écran sur lequel se trouve le widget.

Voir également setScreen() et windowHandle().

void QWidget::scroll(int dx, int dy)

Fait défiler le widget, y compris ses éléments enfants, de dx pixels vers la droite et de dy vers le bas. Les valeurs dx et dy peuvent être négatives.

Après le défilement, les widgets recevront des événements de dessin pour les zones devant être redessinées. Pour les widgets que Qt identifie comme opaques, cela ne concerne que les parties nouvellement exposées. Par exemple, si un widget opaque est déplacé de 8 pixels vers la gauche, seule une bande de 8 pixels de large située au bord droit doit être mise à jour.

Comme les widgets propagent par défaut le contenu de leurs parents, vous devez définir la propriété ` autoFillBackground `, ou utiliser ` setAttribute()` pour définir l’attribut ` Qt::WA_OpaquePaintEvent `, afin de rendre un widget opaque.

Pour les widgets qui utilisent la propagation du contenu, un défilement entraînera la mise à jour de l’ensemble de la zone de défilement.

Voir également Transparency and Double Buffering.

void QWidget::scroll(int dx, int dy, const QRect &r)

Cette version ne fait défiler que ` r ` et ne déplace pas les éléments enfants du widget.

Si r est vide ou non valide, le résultat est indéfini.

Voir également QScrollArea.

void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on = true)

Définit l'attribut « attribute » sur ce widget si « on » est vrai ; sinon, efface cet attribut.

Voir également testAttribute().

void QWidget::setBackgroundRole(QPalette::ColorRole role)

Définit le rôle d'arrière-plan du widget sur « role ».

Le rôle d'arrière-plan définit le pinceau issu de la propriété « palette » du widget qui est utilisé pour afficher l'arrière-plan.

Si « role » est défini sur « QPalette::NoRole », le widget hérite alors du rôle d’arrière-plan de son parent.

Notez que les styles peuvent choisir librement n’importe quelle couleur de la palette. Vous pouvez modifier la palette ou définir une feuille de style si vous n’obtenez pas le résultat souhaité avec setBackgroundRole().

Voir également ` backgroundRole()` et ` foregroundRole()`.

void QWidget::setBaseSize(int basew, int baseh)

Cela correspond à setBaseSize(QSize(basew, baseh)). Définit la taille de base du widget sur une largeur de basew et une hauteur de baseh.

Voir également baseSize().

void QWidget::setContentsMargins(int left, int top, int right, int bottom)

Définit les marges autour du contenu du widget aux tailles suivantes : left, top, right et bottom. Ces marges sont utilisées par le système de mise en page et peuvent servir aux sous-classes pour spécifier la zone à dessiner (par exemple, en excluant le cadre).

La modification des marges déclenche un événement « resizeEvent() ».

Voir également contentsRect() et contentsMargins().

void QWidget::setContentsMargins(const QMargins &margins)

La fonction `setContentsMargins` définit les marges autour du contenu du widget.

Elle définit les marges autour du contenu du widget selon les valeurs déterminées par ` margins`. Ces marges sont utilisées par le système de mise en page et peuvent servir aux sous-classes pour spécifier la zone à dessiner (par exemple, en excluant le cadre).

La modification des marges déclenche un événement « resizeEvent() ».

Voir également ` contentsRect()` et ` contentsMargins()`.

[slot] void QWidget::setDisabled(bool disable)

Désactive les événements de saisie du widget si la valeur de « disable » est « true » ; dans le cas contraire, active les événements de saisie.

Pour plus d’informations, consultez la documentation relative à ` enabled `.

Voir également isEnabledTo(), QKeyEvent, QMouseEvent et changeEvent().

void QWidget::setFixedHeight(int h)

Définit à la fois la hauteur minimale et maximale du widget sur h sans modifier les largeurs. Fournie à titre de commodité.

Voir également sizeHint(), minimumSize(), maximumSize() et setFixedSize().

void QWidget::setFixedSize(const QSize &s)

Définit à la fois la taille minimale et la taille maximale du widget sur s, ce qui l'empêche ainsi de s'agrandir ou de se réduire.

Cela remplacera les contraintes de taille par défaut définies par QLayout.

Pour supprimer ces contraintes, définissez la taille sur ` QWIDGETSIZE_MAX`.

Sinon, si vous souhaitez que le widget ait une taille fixe en fonction de son contenu, vous pouvez appeler ` QLayout::setSizeConstraint` (QLayout::SetFixedSize) ;

Voir également maximumSize et minimumSize.

void QWidget::setFixedSize(int w, int h)

Définit la largeur du widget sur w et sa hauteur sur h.

void QWidget::setFixedWidth(int w)

Définit à la fois la largeur minimale et maximale du widget à w sans modifier les hauteurs. Fournie à titre pratique.

Voir également sizeHint(), minimumSize(), maximumSize() et setFixedSize().

void QWidget::setFocus(Qt::FocusReason reason)

Attribue le focus du clavier à ce widget (ou à son proxy de focus) si ce widget ou l'un de ses parents est l'active window. L'argument « reason » sera transmis à tout événement de focus envoyé depuis cette fonction ; il sert à expliquer la raison pour laquelle le widget a obtenu le focus. Si la fenêtre n’est pas active, le widget recevra le focus lorsque la fenêtre deviendra active.

Tout d’abord, un événement « focus about to change » est envoyé au widget de focus (le cas échéant) pour lui signaler qu’il est sur le point de perdre le focus. Ensuite, le focus est modifié : un événement « focus out » est envoyé à l’élément qui détenait précédemment le focus, et un événement « focus in » est envoyé au nouvel élément pour lui indiquer qu’il vient de recevoir le focus. (Rien ne se produit si les widgets « focus in » et « focus out » sont identiques.)

La méthode `setFocus()` attribue le focus à un widget quelle que soit sa politique de focus, mais ne libère pas le contrôle du clavier (voir ` grabKeyboard()`).

Sachez que si le widget est masqué, il n’acceptera pas le focus tant qu’il ne sera pas affiché.

Voir également hasFocus(), clearFocus(), focusInEvent(), focusOutEvent(), setFocusPolicy(), focusWidget(), QApplication::focusWidget(), grabKeyboard(), grabMouse(), le focus clavier dans les widgets et QEvent::RequestSoftwareInputPanel.

[slot] void QWidget::setFocus()

Attribue le focus clavier à ce widget (ou à son proxy de focus) si ce widget ou l'un de ses parents est le « active window ».

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        widget, qOverload<>(&QWidget::setFocus));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        widget, [receiver = widget]() { receiver->setFocus(); });

void QWidget::setFocusProxy(QWidget *w)

Définit le proxy de focus du widget sur le widget w. Si w est nullptr, la fonction réinitialise ce widget pour qu’il n’ait plus de proxy de focus.

Certains widgets peuvent « avoir le focus », mais créent un widget enfant, tel que QLineEdit, pour gérer effectivement le focus. Dans ce cas, le widget peut définir la zone de saisie en ligne comme son proxy de focus.

setFocusProxy() définit le widget qui recevra effectivement le focus lorsque « ce widget » l’obtient. S’il existe un proxy de focus, les fonctions setFocus() et hasFocus() agissent sur ce proxy. Si « ce widget » est le widget de focus, alors setFocusProxy() déplace le focus vers le nouveau proxy de focus.

Voir également focusProxy().

void QWidget::setForegroundRole(QPalette::ColorRole role)

Définit le rôle de premier plan du widget sur « role ».

Le rôle de premier plan définit la couleur issue de l'palette du widget qui est utilisée pour dessiner le premier plan.

Si role est QPalette::NoRole, le widget utilise un rôle de premier plan qui contraste avec le rôle d’arrière-plan.

Notez que les styles peuvent choisir librement n’importe quelle couleur de la palette. Vous pouvez modifier la palette ou définir une feuille de style si vous n’obtenez pas le résultat souhaité avec setForegroundRole().

Voir également ` foregroundRole()` et ` backgroundRole()`.

void QWidget::setGeometry(int x, int y, int w, int h)

Cela correspond à `setGeometry(QRect(x, y, w, h))`.

Voir également geometry().

void QWidget::setGraphicsEffect(QGraphicsEffect *effect)

La fonction `setGraphicsEffect` permet de définir l'effet graphique du widget.

Elle définit « effect » comme effet du widget. Si un effet est déjà installé sur ce widget, « QWidget » supprimera l'effet existant avant d'installer le nouvel effet « effect ».

Si « effect » est l’effet installé sur un autre widget, la fonction `setGraphicsEffect()` supprimera cet effet du widget en question et l’installera sur ce widget.

QWidget prend possession de effect.

Voir aussi graphicsEffect().

[slot] void QWidget::setHidden(bool hidden)

Fonction pratique, équivalente à setVisible(!hidden).

Voir également isHidden().

void QWidget::setLayout(QLayout *layout)

Définit le gestionnaire de mise en page de ce widget sur « layout ».

Si un gestionnaire de mise en page est déjà installé sur ce widget, ` QWidget ` ne vous permettra pas d’en installer un autre. Vous devez d’abord supprimer le gestionnaire de mise en page existant (renvoyé par ` layout()`) avant de pouvoir appeler `setLayout()` avec la nouvelle mise en page.

Si ` layout ` est le gestionnaire de mise en page d’un autre widget, la méthode `setLayout()` réattribuera la mise en page à ce widget et en fera son gestionnaire de mise en page.

Exemple :

QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(formWidget);
formWidget->setLayout(layout);

Au lieu d’appeler cette fonction, vous pouvez également passer ce widget au constructeur de la mise en page.

L’ QWidget prendra alors possession de layout.

Voir également ` layout()` et « Gestion des mises en page ».

void QWidget::setMask(const QBitmap &bitmap)

Rend visibles uniquement les pixels du widget pour lesquels le paramètre ` bitmap ` contient un bit à 1 correspondant. Si la région comprend des pixels situés en dehors de la zone de ` rect()` du widget, les éléments de contrôle du système de fenêtrage présents dans cette zone peuvent être visibles ou non, selon la plate-forme.

Notez que cet effet peut être lent si la région est particulièrement complexe.

Le code suivant montre comment une image dotée d’un canal alpha peut être utilisée pour générer un masque pour un widget :

QLabel topLevelLabel;
QPixmap pixmap(":/images/tux.png");
topLevelLabel.setPixmap(pixmap);
topLevelLabel.setMask(pixmap.mask());

L'étiquette affichée par ce code est masquée à l'aide de l'image qu'elle contient, ce qui donne l'impression qu'une image de forme irrégulière est dessinée directement à l'écran.

Les widgets masqués ne reçoivent les événements de souris que sur leurs parties visibles.

Voir également mask(), clearMask() et windowOpacity().

void QWidget::setMask(const QRegion &region)

Permet de ne rendre visibles que les parties du widget qui chevauchent region. Si la région comprend des pixels situés en dehors de la zone rect() du widget, les contrôles du système de fenêtrage présents dans cette zone peuvent être visibles ou non, selon la plate-forme.

Comme QRegion permet de créer des régions d’une complexité arbitraire, les masques de widget peuvent être adaptés aux fenêtres aux formes les plus inhabituelles, et permettent même d’afficher des widgets comportant des trous. Notez que cet effet peut être lent si la région est particulièrement complexe.

Les masques de widget servent à indiquer au système de fenêtrage que l’application ne souhaite pas recevoir d’événements de souris pour les zones situées en dehors du masque. Sur la plupart des systèmes, ils entraînent également un découpage visuel grossier. Pour obtenir des bords de fenêtre lisses, utilisez plutôt un arrière-plan translucide et un rendu anti-crénelage, comme illustré dans l’exemple « Arrière-plan translucide ».

Voir également ` windowOpacity`.

void QWidget::setMaximumSize(int maxw, int maxh)

Cette fonction correspond à setMaximumSize(QSize(maxw, maxh)). Elle définit la largeur maximale à maxw et la hauteur maximale à maxh.

Voir également maximumSize().

void QWidget::setMinimumSize(int minw, int minh)

Cette fonction correspond à setMinimumSize(QSize(minw, minh)). Elle définit la largeur minimale à minw et la hauteur minimale à minh.

Voir aussi minimumSize().

void QWidget::setParent(QWidget *parent)

Définit le parent du widget sur parent et réinitialise les indicateurs de fenêtre. Le widget est déplacé à la position (0, 0) dans son nouveau parent.

Si le nouveau widget parent se trouve dans une fenêtre différente, le widget dont le parent a été modifié et ses enfants sont ajoutés à la fin de l’ tab chain du nouveau widget parent, dans le même ordre interne qu’auparavant. Si l’un des widgets déplacés avait le focus clavier, setParent() appelle la méthode clearFocus() pour ce widget.

Si le nouveau widget parent se trouve dans la même fenêtre que l'ancien parent, la modification du parent ne change ni l'ordre de tabulation ni le focus clavier.

Si le « nouveau » widget parent est l’ancien widget parent, cette fonction ne fait rien.

Voir aussi ` setWindowFlags()`.

void QWidget::setParent(QWidget *parent, Qt::WindowFlags f)

Cette fonction prend également comme argument des indicateurs de widget, f.

void QWidget::setScreen(QScreen *screen)

Définit l'écran sur lequel le widget doit s'afficher : screen.

La définition de l'écran n'a de sens que pour les fenêtres. Si nécessaire, la fenêtre du widget sera recréée sur screen.

Voir également screen() et QWindow::setScreen().

void QWidget::setShortcutAutoRepeat(int id, bool enable = true)

Si la valeur de « enable » est « true », la répétition automatique du raccourci avec l'id spécifiée est activée ; dans le cas contraire, elle est désactivée.

Voir également grabShortcut() et releaseShortcut().

void QWidget::setShortcutEnabled(int id, bool enable = true)

Si la valeur de « enable » est « true », le raccourci associé à l'id on indiquée est activé ; dans le cas contraire, il est désactivé.

Voir également grabShortcut() et releaseShortcut().

void QWidget::setSizeIncrement(int w, int h)

Définit l'incrément de taille x (largeur) sur w et l'incrément de taille y (hauteur) sur h.

Voir également sizeIncrement().

void QWidget::setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical)

Définit la politique de redimensionnement du widget sur horizontal et vertical, avec un étirement standard et sans adaptation de la hauteur à la largeur.

Voir également sizePolicy() et QSizePolicy::QSizePolicy().

void QWidget::setStyle(QStyle *style)

Définit le style de l'interface graphique du widget sur style. La propriété de l'objet de style n'est pas transférée.

Si aucun style n'est défini, le widget utilise alors le style de l'application, QApplication::style().

La définition d’un style pour un widget n’a aucun effet sur les widgets enfants existants ou futurs.

Voir également style(), QStyle, QApplication::style() et QApplication::setStyle().

[static] void QWidget::setTabOrder(QWidget *first, QWidget *second)

Place le widget second après le widget first dans l'ordre de focus.

Cela supprime effectivement le widget second de sa chaîne de focus et l'insère après le widget first.

Notez que, puisque l'ordre de tabulation du widget second est modifié, vous devez organiser la chaîne comme ceci :

setTabOrder(a, b); // a to b
setTabOrder(b, c); // a to b to c
setTabOrder(c, d); // a to b to c to d

etnon pas ainsi :

// WRONG
setTabOrder(c, d); // c to d
setTabOrder(a, b); // a to b AND c to d
setTabOrder(b, c); // a to b to c, but not c to d

Si first ou second dispose d’un proxy de focus, setTabOrder() remplace correctement le proxy.

Voir également setFocusPolicy(), setFocusProxy() et « Focalisation clavier dans les widgets ».

[static, since 6.6] void QWidget::setTabOrder(std::initializer_list<QWidget *> widgets)

Définit l'ordre de tabulation des widgets de la liste « widgets » en appelant la fonction ` QWidget::setTabOrder(QWidget *, QWidget *)` pour chaque paire consécutive de widgets.

Au lieu de configurer chaque paire manuellement comme ceci :

setTabOrder(a, b); // a to b
setTabOrder(b, c); // a to b to c
setTabOrder(c, d); // a to b to c to d

vous pouvez appeler :

setTabOrder({a, b, c, d}); // a to b to c to d

Cet appel ne crée pas de boucle de focus fermée. S’il existe d’autres widgets avec la politique de focus « Qt::TabFocus », appuyer sur la touche Tab lors de l’appel de ` d ` déplacera le focus vers l’un de ces widgets, et non vers ` a`.

Cette fonction a été introduite dans Qt 6.6.

Voir également setFocusPolicy(), setFocusProxy() et le focus clavier dans les widgets.

void QWidget::setWindowFlag(Qt::WindowType flag, bool on = true)

Définit l'indicateur de fenêtre « flag » sur ce widget si la valeur de « on » est vraie ; sinon, il efface cet indicateur.

Voir également setWindowFlags(), windowFlags() et windowType().

void QWidget::setWindowRole(const QString &role)

Définit le rôle de la fenêtre sur « role ». Cela n'a de sens que pour les fenêtres sous X11.

Voir également windowRole().

void QWidget::setWindowState(Qt::WindowStates windowState)

Définit l'état de la fenêtre sur « windowState ». L'état de la fenêtre est une combinaison (via l'opération OR) des valeurs suivantes : « Qt::WindowState » : « Qt::WindowMinimized », « Qt::WindowMaximized », « Qt::WindowFullScreen » et « Qt::WindowActive ».

Si la fenêtre n’est pas visible (c’est-à-dire que isVisible() renvoie false), l’état de la fenêtre prendra effet lorsque show() sera appelé. Pour les fenêtres visibles, le changement est immédiat. Par exemple, pour basculer entre le mode plein écran et le mode normal, utilisez le code suivant :

w->setWindowState(w->windowState() ^ Qt::WindowFullScreen);

Pour restaurer et activer une fenêtre réduite (tout en conservant son état agrandi et/ou plein écran), utilisez ce qui suit :

w->setWindowState((w->windowState() & ~Qt::WindowMinimized) | Qt::WindowActive);

L’appel de cette fonction masquera le widget. Vous devez appeler ` show()` pour rendre le widget à nouveau visible.

Lorsque l’état de la fenêtre change, le widget reçoit un appel à ` changeEvent()` de type ` QEvent::WindowStateChange`.

Voir également Qt::WindowState et windowState().

void QWidget::setupUi(QWidget *widget)

Configure l'interface utilisateur pour l'widget spécifiée.

Voir également Utilisation d’un fichier d’interface utilisateur du Qt Widgets Designer dans votre application.

[slot] void QWidget::show()

Affiche le widget et ses widgets enfants.

Pour les fenêtres enfants, cela revient à appeler ` setVisible(true)`. Sinon, cela revient à appeler ` showFullScreen()`, ` showMaximized()` ou ` setVisible(true)`, selon le comportement par défaut de la plate-forme concernant les indicateurs de fenêtre.