QWidget Class

Documentation sur les fonctions membres

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

Construit un widget qui est un enfant de parent, avec les drapeaux de widget fixés à 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 drapeaux de widget, f, est normalement 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 bit à bit de n'importe lequel des arguments window flags.

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

Notez que la version X11 de Qt peut ne pas être en mesure de fournir toutes les combinaisons de drapeaux de style sur tous les systèmes. En effet, sous X11, Qt ne peut que demander au gestionnaire de fenêtres, et ce dernier peut outrepasser les paramètres de l'application. Sous Windows, Qt peut définir tous les drapeaux que vous souhaitez.

Voir aussi windowFlags.

[virtual noexcept] QWidget::~QWidget()

Détruit le widget.

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

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

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

Voir aussi addAction(), insertAction(), removeAction(), actions() et QActionEvent.

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

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

Voir aussi contextMenuPolicy, insertAction(), et removeAction().

void QWidget::activateWindow()

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

Une fenêtre active est une fenêtre de premier niveau visible qui a le focus sur la saisie au clavier.

Cette fonction effectue la même opération qu'un clic de souris sur la barre de titre d'une fenêtre de premier niveau. Sous X11, le résultat dépend du gestionnaire de fenêtres. Si vous voulez vous assurer que la fenêtre est empilée au sommet, vous devez également appeler raise(). Notez que la fenêtre doit être visible, sinon activateWindow() n'a aucun effet.

Sous Windows, si vous appelez cette fonction alors que l'application n'est pas encore active, elle n'en fera pas la fenêtre active. Elle changera la couleur de l'entrée de la barre des tâches pour indiquer que la fenêtre a changé d'une manière ou d'une autre. En effet, Microsoft ne permet pas à une application d'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 ont une liste d'actions QAction. Cependant, ils peuvent être représentés graphiquement de différentes manières. L'utilisation par défaut de la liste QAction (telle que renvoyée par actions()) consiste à créer un contexte QMenu.

Un QWidget ne doit avoir qu'une seule action de chaque type et l'ajout d'une action qu'il possède déjà n'entraînera pas la présence de la 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 de commodité créent 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 et la renvoient.

QWidget prend la propriété de l'action retournée QAction.

Ces fonctions ont été introduites dans Qt 6.3.

Ces fonctions de commodité 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 par 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 la propriété de l'action retournée QAction.

Ces fonctions ont été introduites dans Qt 6.3.

Cette fonction de commodité 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 la propriété de l'action retournée QAction.

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 aussi removeAction(), QMenu, et addAction().

void QWidget::adjustSize()

Ajuste la taille du widget en fonction de son contenu.

Cette fonction utilise sizeHint() s'il est valide, c'est-à-dire si la largeur et la hauteur de l'indice de taille sont >= 0. Sinon, elle fixe la taille au rectangle des enfants qui couvre 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 l'adresse sizeHint() est inférieure à (200, 100) et que la politique de taille est expanding, la fenêtre aura une taille minimale de (200, 100). La taille maximale d'une fenêtre est égale à 2/3 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 la brosse du widget palette qui est utilisée pour rendre l'arrière-plan.

Si aucun rôle d'arrière-plan explicite n'est 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'adresse QBackingStore dans laquelle ce widget sera dessiné.

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

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

L'état modifié dans cet événement peut être récupéré à l'aide de l'adresse event fournie.

Les événements de changement sont les suivants : 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 à 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 spécifié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 du 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 du widget.

Cette fonction a été introduite dans Qt 6.8.

void QWidget::clearFocus()

Prend le focus de l'entrée clavier du widget.

Si le widget a un focus actif, un message focus out event est envoyé à ce widget pour lui indiquer qu'il a perdu le focus.

Ce widget doit activer le réglage du focus pour obtenir le focus de l'entrée clavier, c'est-à-dire qu'il doit appeler setFocusPolicy().

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

void QWidget::clearMask()

Supprime tout masque défini par setMask().

Voir aussi setMask().

[slot] bool QWidget::close()

Ferme ce widget. Retourne true si le widget a été fermé, sinon retourne false.

Il envoie d'abord au widget un message QCloseEvent. 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 possède l'indicateur Qt::WA_DeleteOnClose, il est également supprimé. Un événement de fermeture est délivré au widget, qu'il soit visible ou non.

Le signal QGuiApplication::lastWindowClosed() est émis lorsque la dernière fenêtre primaire visible (c'est-à-dire une fenêtre sans parent) dont l'attribut Qt::WA_QuitOnClose est défini est fermée. Par défaut, cet attribut est défini pour tous les widgets, à l'exception des fenêtres transitoires telles que les écrans d'accueil, 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'adresse event lorsque Qt Widgets reçoit une demande de fermeture de fenêtre pour un widget de niveau supérieur de la part du système de fenêtres.

Par défaut, l'événement est accepté et le widget est fermé. Vous pouvez réimplémenter cette fonction pour modifier la façon 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() sur tous les événements.

Les applications de la 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é sauvegardé et demander la permission avant de fermer.

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

QMargins QWidget::contentsMargins() const

La fonction contentsMargins renvoie les marges du contenu du widget.

Voir aussi setContentsMargins() et contentsRect().

QRect QWidget::contentsRect() const

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

Voir aussi setContentsMargins() et contentsMargins().

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

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

Le gestionnaire est appelé lorsque l'adresse contextMenuPolicy du widget est Qt::DefaultContextMenu.

L'implémentation par défaut ignore l'événement contextuel. Voir la documentation de QContextMenuEvent pour plus de détails.

Voir aussi event(), QContextMenuEvent, et customContextMenuRequested().

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

Crée une nouvelle fenêtre widget.

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

Voir aussi createWindowContainer() et QWindow::fromWinId().

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

Crée une fenêtre QWidget qui permet 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 drapeaux de fenêtre flags.

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

Le conteneur devient propriétaire de window. La fenêtre peut être supprimée du conteneur de fenêtre par un appel à QWindow::setParent().

Le conteneur de fenêtre est attaché en tant que fenêtre enfant native à la fenêtre de niveau supérieur dont il est l'enfant. Lorsqu'un conteneur de fenêtre est utilisé comme enfant d'un QAbstractScrollArea ou d'un QMdiArea, il crée un native window pour chaque widget de sa chaîne parentale afin de permettre un empilement et un écrêtage corrects dans ce cas d'utilisation. La création d'une fenêtre native pour le conteneur de fenêtre permet également un empilement et un écrêtage corrects. Cette opération doit être effectuée avant d'afficher le conteneur de fenêtres. Les applications comportant de nombreuses fenêtres enfant natives peuvent souffrir de 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'empile sur la hiérarchie des widgets sous la forme d'une boîte opaque. L'ordre d'empilement de plusieurs instances de conteneurs de fenêtres qui se chevauchent n'est pas défini.
• Intégration du rendu : le conteneur de fenêtre n'interagit pas avec QGraphicsProxyWidget, QWidget::render() ou une fonctionnalité similaire.
• Gestion du focus ; Il est possible de laisser l'instance de conteneur de fenêtre avoir n'importe quelle politique de focus et elle déléguera le focus à la fenêtre via un appel à QWindow::requestActivate(). Cependant, le retour à la chaîne de focalisation normale à partir de l'instance QWindow dépendra de l'implémentation de l'instance QWindow elle-même. De plus, la question de savoir si QWindow::requestActivate() donne effectivement le focus à la fenêtre dépend de la plate-forme.

  Depuis la version 6.8, en cas d'intégration d'une fenêtre basée sur Qt Quick, les pressions sur les tabulations permettent d'entrer et de sortir de la fenêtre QML intégrée, ce qui permet de déplacer le focus vers l'objet focalisable suivant ou précédent dans la chaîne de conteneurs de la fenêtre.

• L'utilisation de nombreuses instances de conteneurs de fenêtres dans une application basée sur QWidget peut nuire considérablement aux performances globales de l'application.
• Depuis la version 6.7, si window appartient à un widget (c'est-à-dire que window a été reçu en appelant windowHandle()), aucun conteneur ne sera créé. Au lieu de cela, cette fonction renverra le widget lui-même, après avoir été réparti sur parent. Étant donné qu'aucun conteneur ne sera créé, flags sera ignoré. En d'autres termes, si window appartient à un widget, envisagez de répartir ce widget sur parent au lieu d'utiliser cette fonction.

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

Ce signal est émis lorsque l'adresse contextMenuPolicy du widget est Qt::CustomContextMenu et que l'utilisateur a demandé un menu contextuel sur le widget. La position pos est la position de l'événement de menu contextuel que le widget reçoit. Normalement, il s'agit des coordonnées du widget. L'exception à cette règle est QAbstractScrollArea et ses sous-classes qui mappent l'événement de menu contextuel aux coordonnées de viewport().

Voir également mapToGlobal(), QMenu et contextMenuPolicy.

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

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

destroy() s'appelle récursivement pour tous les widgets enfants, en passant destroySubWindows pour le paramètre destroyWindow. Pour mieux contrôler la destruction des sous-fenêtres, il est possible de les détruire sélectivement en premier.

Cette fonction est généralement appelée à partir du destructeur QWidget.

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

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

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

Voir la documentation sur le glisser-déposer pour une vue d'ensemble de la manière de mettre en œuvre 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 déplacement est en cours et que la souris quitte le widget. L'événement est transmis dans le paramètre event.

Voir la documentation sur le glisser-déposer pour une vue d'ensemble de la manière de mettre en œuvre le glisser-déposer dans votre application.

Voir également QDrag et QDragLeaveEvent.

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

Ce gestionnaire d'événement est appelé si un déplacement est en cours et si l'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 appuyée sur le clavier alors que ce widget est au centre de l'attention. L'événement est transmis dans le paramètre event.

Voir la documentation sur le glisser-déposer pour une vue d'ensemble de la manière de mettre en œuvre 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 le drag est déposé sur ce widget. L'événement est transmis dans le paramètre event.

Voir la documentation sur le glisser-déposer pour une vue d'ensemble de la manière de mettre en œuvre le glisser-déposer dans votre application.

Voir également QDrag et QDropEvent.

WId QWidget::effectiveWinId() const

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

Si le widget est natif, cette fonction renvoie l'identifiant du widget natif. Sinon, elle renvoie l'identifiant de 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

S'assure que le widget et ses enfants ont été polis par QStyle (c'est-à-dire qu'ils ont une police et une palette correctes).

QWidget appelle cette fonction après que le widget a été entièrement construit, mais avant qu'il ne soit montré pour la première fois. Vous pouvez appeler cette fonction si vous voulez vous assurer que le widget est poli avant d'effectuer une opération, par exemple, la taille de police correcte peut être nécessaire dans la réimplémentation du widget sizeHint(). Notez que cette fonction est appelée à partir de l'implémentation par défaut de sizeHint().

Le polissage est utile pour l'initialisation finale qui doit avoir lieu après que tous les constructeurs (des classes de base et des sous-classes) ont été appelés.

Si vous avez besoin de modifier certains paramètres lorsqu'un widget est poli, réimplémentez event() et gérez le type d'événement QEvent::Polish.

Remarque : la fonction est déclarée const pour pouvoir être appelée à partir d'autres fonctions constantes (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 pour recevoir les événements d'entrée dans le widget qui sont transmis dans le paramètre event.

Un événement est envoyé au widget lorsque le curseur de la souris entre dans le widget.

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 l'événement event. Vous pouvez réimplémenter cette fonction dans une sous-classe, mais nous vous recommandons d'utiliser plutôt l'un des gestionnaires d'événements spécialisés.

Les événements de pression et de relâchement des touches sont traités différemment des autres événements. event() vérifie la présence de Tab et de Shift+Tab et tente de déplacer le focus de manière appropriée. S'il n'y a pas de widget vers lequel déplacer le focus (ou si la touche pressée n'est pas Tab ou Shift+Tab), event() appelle keyPressEvent().

La gestion des événements liés à la souris et à la tablette est également légèrement particulière : ce n'est que lorsque le widget est enabled que event() appelle les gestionnaires spécialisés tels que mousePressEvent() ; dans le cas contraire, il rejette 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 au widget parent s'arrête.

Voir aussi 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 sur le widget avec l'identifiant de la fenêtre/le manche id.

Le type d'identifiant de fenêtre dépend du système de fenêtre sous-jacent, voir qwindowdefs.h pour la définition réelle. S'il n'y a pas de widget avec cet identifiant, nullptr est renvoyé.

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

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe pour recevoir les événements de mise au point du clavier (mise au point reçue) pour le widget. L'événement est transmis dans le paramètre event

Un widget doit normalement appeler setFocusPolicy() à autre chose que Qt::NoFocus pour recevoir les événements de mise au point. (Le programmeur d'application peut appeler setFocus() sur n'importe quel widget, même ceux qui n'acceptent pas normalement le focus).

L'implémentation par défaut met à jour le widget (sauf pour les fenêtres qui ne spécifient pas de focusPolicy()).

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

[protected] bool QWidget::focusNextChild()

Trouve un nouveau widget auquel donner le focus clavier, comme approprié pour Tab, et renvoie true s'il trouve un nouveau widget, ou false s'il n'en trouve pas.

Voir aussi focusPreviousChild().

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

Recherche un nouveau widget auquel donner le focus clavier, comme approprié pour Tab et Shift+Tab, et renvoie true s'il trouve un nouveau widget, ou false s'il ne le trouve pas.

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

Parfois, vous voudrez réimplémenter cette fonction. Par exemple, un navigateur web peut la réimplémenter pour déplacer son "lien actif actuel" vers l'avant ou vers l'arrière, et appeler focusNextPrevChild() uniquement 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 obtenez ainsi le contrôle du déplacement 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 pour recevoir les événements de focus clavier (focus perdu) pour le widget. Les événements sont transmis dans le paramètre event.

Un widget doit normalement appeler setFocusPolicy() à autre chose que Qt::NoFocus pour recevoir les événements de focus. (Le programmeur d'application peut appeler setFocus() sur n'importe quel widget, même ceux qui n'acceptent pas normalement le focus).

L'implémentation par défaut met à jour le widget (sauf pour les fenêtres qui ne spécifient pas de focusPolicy()).

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

[protected] bool QWidget::focusPreviousChild()

Trouve un nouveau widget auquel donner le focus clavier, comme approprié pour Shift+Tab, et renvoie true s'il trouve un nouveau widget, ou false s'il n'en trouve pas.

Voir aussi 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 setFocus a été appelé. Pour les widgets de niveau supérieur, il s'agit du widget qui obtiendra le focus au cas où cette fenêtre serait activée

Ce n'est pas la même chose que QApplication::focusWidget(), qui renvoie le widget de focus dans la fenêtre actuellement active.

QFontInfo QWidget::fontInfo() const

Renvoie les informations sur la police actuelle du widget. Équivalent à QFontInfo(widget->font()).

Voir aussi font(), fontMetrics(), et setFont().

QFontMetrics QWidget::fontMetrics() const

Renvoie les métriques de la police actuelle du widget. Équivalent à QFontMetrics(widget->font()).

Voir aussi 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 du widget palette qui est utilisée pour dessiner le premier plan.

Si aucun rôle d'avant-plan explicite n'est 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)))

Rend le widget dans une pixmap limitée par l'adresse rectangle. Si le widget a des enfants, ils sont également peints dans les positions appropriées.

Si un rectangle de taille non valide est spécifié (par défaut), le widget entier est peint.

Voir également render() et QPixmap.

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

Abonne le widget à une gesture donnée avec une flags spécifique.

Voir également ungrabGesture() et QGestureEvent.

void QWidget::grabKeyboard()

Saisit les données du clavier.

Ce widget reçoit tous les événements clavier jusqu'à ce que releaseKeyboard() soit appelé ; les autres widgets ne reçoivent aucun événement clavier. Les événements souris ne sont pas affectés. Utilisez grabMouse() si vous voulez les récupérer.

Le widget focus n'est pas affecté, sauf qu'il ne reçoit pas d'événements clavier. setFocus() déplace le focus comme d'habitude, mais le nouveau widget de focus ne reçoit des événements clavier qu'après l'appel de releaseKeyboard().

Si un autre widget est en train de saisir des données au clavier, la saisie de ce widget est relâchée en premier.

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

void QWidget::grabMouse()

Saisit l'entrée de la souris.

Ce widget reçoit tous les événements de la souris jusqu'à ce que releaseMouse() soit appelé ; les autres widgets ne reçoivent aucun événement de la souris. Les événements clavier ne sont pas affectés. Utilisez grabKeyboard() si vous voulez les récupérer.

Il est rarement nécessaire d'attraper la souris lorsque l'on utilise Qt, car Qt l'attrape et la relâche judicieusement. En particulier, Qt saisit la souris lorsqu'un bouton est enfoncé et la garde jusqu'à ce que le dernier bouton soit relâché.

Voir aussi releaseMouse(), grabKeyboard() et releaseKeyboard().

void QWidget::grabMouse(const QCursor &cursor)

Saisit l'entrée de la souris et modifie la forme du curseur.

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

Voir aussi 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 key donnée dans la séquence context donnée. Si context est Qt::ApplicationShortcut, le raccourci s'applique à l'ensemble de l'application. 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é saisie par plusieurs widgets, lorsque la séquence key se produit, un événement QEvent::Shortcut est envoyé à tous les widgets auxquels il s'applique dans un ordre non déterministe, mais avec le drapeau "ambigu" fixé à vrai.

Voir aussi releaseShortcut() et setShortcutEnabled().

QGraphicsEffect *QWidget::graphicsEffect() const

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

Si le widget n'a pas d'effet graphique, nullptr est renvoyé.

Voir également setGraphicsEffect().

QGraphicsProxyWidget *QWidget::graphicsProxyWidget() const

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

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

bool QWidget::hasEditFocus() const

Renvoie true si ce widget a actuellement le focus d'édition, sinon false.

Cette fonctionnalité n'est disponible que dans Qt pour Linux embarqué.

Voir aussi setEditFocus() et QApplication::navigationMode().

[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 pour ce widget, compte tenu de la largeur w.

Si ce widget a une disposition, l'implémentation par défaut renvoie la hauteur préférée de la disposition. S'il n'y a pas de disposition, 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()

Cache le widget. Cette fonction est équivalente à setVisible(false).

Voir aussi 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 pour recevoir les événements de masquage des widgets. L'événement est transmis dans le paramètre event.

Les événements de masquage sont envoyés aux widgets immédiatement après qu'ils ont été masqués.

Remarque : un widget reçoit des événements d'affichage et de masquage spontanés lorsque son statut de mappage est modifié par le système de fenêtres, par exemple un événement de masquage spontané lorsque l'utilisateur réduit la fenêtre, et un événement d'affichage spontané lorsque la fenêtre est rétablie. Après avoir reçu un événement de masquage spontané, un widget est toujours considéré comme visible au sens de 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 painter comme ceux du widget donné. Cette fonction est appelée automatiquement lorsque le peintre est ouvert sur un QWidget.

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

Ce gestionnaire d'événement, pour l'événement event, peut être réimplémenté dans une sous-classe pour recevoir les événements de composition de la méthode d'entrée. 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 de la méthode d'entrée.

L'implémentation par défaut appelle event->ignore(), qui rejette l'événement Input Method. Voir la documentation de QInputMethodEvent pour plus de détails.

Voir également event() et QInputMethodEvent.

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

Cette méthode ne concerne que les widgets de saisie. Elle est utilisée par la méthode de saisie pour interroger un ensemble de propriétés du widget afin de pouvoir prendre en charge des opérations complexes de la méthode de saisie, telles que la prise en charge du texte environnant et des reconversions.

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

Voir aussi inputMethodEvent(), QInputMethodEvent, QInputMethodQueryEvent, et inputMethodHints.

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

Insère l'action action dans la liste des actions de ce widget, avant l'action before. Il ajoute l'action si before est nullptr ou si before n'est pas une action valide pour ce widget.

Un site QWidget ne doit avoir qu'une seule action de chaque type.

Voir aussi removeAction(), addAction(), QMenu, contextMenuPolicy, et actions().

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

Insère l'action actions dans la liste des actions de ce widget, avant l'action before. Il ajoute l'action si before est nullptr ou si before n'est pas une action valide pour ce widget.

Un QWidget peut avoir au maximum une action de chaque type.

Voir aussi 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 jusqu'à 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 est activé si ancestor est activé ; sinon, renvoie false.

C'est le cas si ni le widget lui-même ni aucun de ses parents jusqu'à ancestor n'a été explicitement désactivé.

isEnabledTo(0) renvoie une valeur fausse si ce widget ou l'un de ses ancêtres a été explicitement désactivé.

Le mot "ancêtre" signifie ici un widget parent 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 parentales.

Voir également setEnabled() et enabled.

bool QWidget::isHidden() const

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

Un widget caché ne devient visible que lorsque show() est appelé sur lui. Il ne sera pas automatiquement affiché lorsque le parent est affiché.

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

isHidden() implique !isVisible(), mais un widget peut être non visible et non caché en même temps. C'est le cas des widgets qui sont enfants de widgets qui ne sont pas visibles.

Les widgets sont caché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 devient visible si ancestor est affiché ; sinon, renvoie false.

Le cas vrai se produit si ni le widget lui-même ni aucun parent jusqu'à ancestor n'a été explicitement caché.

Cette fonction renvoie toujours true si le widget est masqué par d'autres fenêtres à l'écran, mais il pourrait être physiquement visible s'il était déplacé.

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 pas visuellement l'enfant d'un autre widget et qui possède généralement un cadre et un window title.

Une fenêtre peut avoir un parent widget. Elle sera alors groupée avec son parent et supprimée lorsque le parent est supprimé, minimisée lorsque le parent est minimisé, etc. Si elle est prise en charge par le gestionnaire de fenêtres, elle aura également une entrée commune dans la barre des tâches avec son parent.

QDialog et QMainWindow sont par défaut des fenêtres, même si un widget parent est spécifié dans le constructeur. Ce comportement est spécifié par l'option Qt::Window.

Voir aussi window(), isModal() et parentWidget().

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

Ce gestionnaire d'événement, pour l'événement event, peut être réimplémenté dans une sous-classe pour recevoir les événements d'appui sur une touche pour le widget.

Un widget doit appeler setFocusPolicy() pour accepter le focus initialement et avoir le focus afin de recevoir un événement d'appui sur une touche.

Si vous réimplémentez ce gestionnaire, il est très important que vous appeliez l'implémentation de la classe de base si vous n'agissez pas sur la touche.

L'implémentation par défaut ferme les fenêtres contextuelles si l'utilisateur appuie sur la séquence de touches pour QKeySequence::Cancel (généralement la touche Echap). Dans le cas contraire, l'événement est ignoré afin que le parent du widget puisse l'interpréter.

Notez que QKeyEvent commence avec isAccepted() == true, vous n'avez donc pas besoin d'appeler QKeyEvent::accept() - il suffit de ne pas appeler l'implémentation de la classe de base si vous agissez sur la touche.

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

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

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

Un widget doit être accept focus initialement et have focus pour recevoir un événement de relâchement de touche.

Si vous réimplémentez ce gestionnaire, il est très important que vous appeliez l'implémentation de la classe de base si vous n'agissez pas sur la clé.

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

Notez que QKeyEvent commence par isAccepted() == true, vous n'avez donc pas besoin d'appeler QKeyEvent::accept() - il suffit de ne pas appeler l'implémentation de la classe de base si vous agissez sur la touche.

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

[static] QWidget *QWidget::keyboardGrabber()

Renvoie le widget qui saisit actuellement le clavier.

Si aucun widget de cette application n'est en train de saisir le clavier, nullptr est renvoyé.

Voir aussi grabMouse() et mouseGrabber().

QLayout *QWidget::layout() const

Renvoie le gestionnaire de disposition installé sur ce widget, ou nullptr si aucun gestionnaire de disposition n'est installé.

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

Voir également setLayout(), sizePolicy() et Gestion de la disposition.

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

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

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

Voir aussi enterEvent(), mouseMoveEvent() et event().

[slot] void QWidget::lower()

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

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

Voir aussi raise() et stackUnder().

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

Traduit les coordonnées du widget pos du système de coordonnées de parent vers le système de coordonnées de ce widget. Le site parent ne doit pas être nullptr et doit être un parent du widget appelant.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi 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

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

Cette fonction a été introduite dans Qt 6.0.

Voir aussi mapToGlobal(), mapFrom() et mapFromParent().

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

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

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

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

Cette fonction a été introduite dans Qt 6.0.

Voir aussi 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

Traduit les coordonnées du widget pos dans le système de coordonnées de parent. parent ne doit pas être nullptr et doit être un parent du widget appelant.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi 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

Traduit les coordonnées du widget pos en coordonnées globales de l'écran. Par exemple, mapToGlobal(QPointF(0,0)) donne les coordonnées globales du pixel supérieur gauche du widget.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi mapFromGlobal(), mapTo() et mapToParent().

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

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

Traduit la coordonnée du widget pos en une coordonnée dans le widget parent.

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

Cette fonction a été introduite dans Qt 6.0.

Voir aussi 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 de retour sera une région vide.

Voir aussi 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 à obtenir.

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

Ce gestionnaire d'événement, pour l'événement event, peut être réimplémenté dans une sous-classe pour recevoir les événements de double clic de 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 est actuellement en train de saisir la souris.

Si aucun widget de cette application n'est en train de saisir la souris, nullptr est renvoyé.

Voir aussi grabMouse() et keyboardGrabber().

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

Ce gestionnaire d'événement, pour l'événement event, peut être réimplémenté dans une sous-classe pour 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 pressé.

QMouseEvent::position() indique la position du curseur de la souris par rapport à ce widget. Pour les événements de pression 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 être différente si la main de l'utilisateur tremble. Il s'agit d'une caractéristique du système de fenêtres sous-jacent, et non de Qt.

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

Voir aussi setMouseTracking(), mousePressEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), event(), QMouseEvent, et Scribble Example.

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

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

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

L'implémentation par défaut permet de fermer les fenêtres contextuelles lorsque vous cliquez en dehors de la fenêtre. Pour les autres types de widgets, elle ne fait rien.

Voir aussi mouseReleaseEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), event(), QMouseEvent, et Scribble Example.

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

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

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

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

Cela correspond à 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 pour recevoir les événements de déplacement du widget qui sont transmis dans le paramètre event. Lorsque le widget reçoit cet événement, il est déjà à sa nouvelle position.

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

Voir aussi 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 pour recevoir les événements de la plate-forme native identifiés par eventType qui sont transmis dans le paramètre message.

Dans votre réimplémentation de cette fonction, si vous souhaitez que l'événement ne soit plus géré par Qt XML, 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 transmis à Qt, qui le traduit 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 suivant qui possède un identifiant système, ou nullptr s'il n'a pas de parent natif.

Voir aussi effectiveWinId().

QWidget *QWidget::nextInFocusChain() const

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

Voir également previousInFocusChain().

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

Définit les drapeaux de fenêtre pour le widget à flags, sans en informer le système de fenêtres.

Voir aussi setWindowFlags().

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

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

Renvoie le moteur de peinture du widget.

Notez que cette fonction ne doit pas être appelée explicitement par l'utilisateur, puisqu'elle n'est destinée qu'à des fins de réimplémentation. La fonction est appelée par Qt en interne, 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 pour recevoir des événements de peinture transmis à event.

Un événement de peinture est une demande de repeindre tout ou partie d'un widget. Il peut se produire pour l'une des raisons suivantes :

• repaint() ou update() a été invoqué,
• le widget était masqué et a été découvert, ou
• pour de nombreuses autres raisons.

De nombreux widgets peuvent simplement repeindre toute leur surface lorsqu'on le leur demande, mais certains widgets lents doivent optimiser leur vitesse en ne peignant que la région demandée : QPaintEvent::region(). Cette optimisation de la vitesse ne change pas le résultat, car la peinture est limitée à cette région pendant le traitement des événements. QListView et QTableView font cela, par exemple.

Qt tente également d'accélérer la peinture en fusionnant plusieurs événements de peinture en un seul. Lorsque update() est appelé plusieurs fois ou que le système de fenêtres envoie plusieurs événements de peinture, Qt fusionne ces événements en un seul événement avec une région plus grande (voir QRegion::united()). La fonction repaint() ne permet pas cette optimisation, c'est pourquoi nous suggérons d'utiliser update() dans la mesure du possible.

Lorsque l'événement de peinture se produit, la région de mise à jour a normalement été effacée, de sorte que vous peignez 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, QWidget met automatiquement en double tampon sa peinture, il n'est donc pas nécessaire d'écrire du code de mise en 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 parent de ce widget, ou nullptr s'il n'a pas de widget parent.

QWidget *QWidget::previousInFocusChain() const

La fonction previousInFocusChain 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 sommet de la pile du widget parent.

Après cet appel, le widget sera visuellement devant tous les widgets frères qui se chevauchent.

Voir également lower() et stackUnder().

void QWidget::releaseKeyboard()

Libère l'emprise du clavier.

Voir aussi grabKeyboard(), grabMouse() et releaseMouse().

void QWidget::releaseMouse()

Libère la saisie de la souris.

Voir aussi grabMouse(), grabKeyboard() et releaseKeyboard().

void QWidget::releaseShortcut(int id)

Supprime le raccourci avec le id donné 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 n'ait d'autres raccourcis avec la même séquence de touches).

Voir aussi grabShortcut() et setShortcutEnabled().

void QWidget::removeAction(QAction *action)

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

Voir aussi insertAction() et actions().

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

Effectue le rendu de sourceRegion de ce widget dans target en utilisant renderFlags pour déterminer le mode de rendu. Le rendu commence à targetOffset dans target. Par exemple, si est une région nulle, cette fonction utilisera () comme région, c'est-à-dire tout le widget :

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 le widget entier.

Veillez à appeler QPainter::end() pour le peintre actif du périphérique target (le cas échéant) avant d'effectuer 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))

Rend le widget dans le painter's QPainter::device().

Les transformations et les paramètres appliqués à painter seront utilisés lors du rendu.

Voir aussi QPainter::device().

[slot] void QWidget::repaint()

Repeint le widget directement en appelant paintEvent() immédiatement, sauf si les mises à jour sont désactivées ou si le widget est caché.

Nous vous conseillons de n'utiliser repaint() que si vous avez besoin d'un repeint 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 aussi update(), paintEvent(), et setUpdatesEnabled().

void QWidget::repaint(const QRect &rect)

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

void QWidget::repaint(const QRegion &rgn)

Cette version repeint une région rgn à l'intérieur du widget.

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

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

Si w est négatif, il est remplacé par width() - x, et si h est négatif, il est remplacé 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 pour recevoir les événements de redimensionnement du widget qui sont passés dans le paramètre event. Lorsque resizeEvent() est appelé, le widget a déjà sa nouvelle géométrie. L'ancienne taille est accessible via QResizeEvent::oldSize().

Le widget sera effacé et recevra un événement de peinture immédiatement après le traitement de l'événement de redimensionnement. Aucun dessin n'a besoin d'être (ou ne devrait être) fait à l'intérieur de ce gestionnaire.

Voir aussi 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 premier niveau 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 est hors écran, elle sera modifiée pour être à l'intérieur de la géométrie disponible à l'écran.

Pour restaurer une géométrie sauvegardée à l'aide de QSettings, vous pouvez utiliser un code comme celui-ci :

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

Voir la documentation sur la géométrie des fenêtres pour une vue d'ensemble des problèmes de géométrie avec les fenêtres.

Utilisez QMainWindow::restoreState() pour restaurer la géométrie et l'état des barres d'outils et des widgets du dock.

Voir aussi saveGeometry(), QSettings, QMainWindow::saveState(), et QMainWindow::restoreState().

QByteArray QWidget::saveGeometry() const

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

Pour sauvegarder la géométrie lorsque la fenêtre se ferme, vous pouvez implémenter un événement de fermeture comme celui-ci :

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

Voir la documentation sur la géométrie des fenêtres pour une vue d'ensemble des problèmes de géométrie avec les fenêtres.

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

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

QScreen *QWidget::screen() const

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

Voir aussi setScreen() et windowHandle().

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

Fait défiler le widget et ses enfants dx pixels vers la droite et 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 peinture pour les zones qui doivent être repeintes. Pour les widgets que Qt Widgets sait être opaques, il s'agit uniquement des 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 sur le bord droit doit être mise à jour.

Étant donné que 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 une 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 enfants du widget.

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

Voir aussi QScrollArea.

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

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

Voir également testAttribute().

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

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

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

Si role est QPalette::NoRole, le widget hérite du rôle d'arrière-plan de son parent.

Notez que les styles sont libres de choisir n'importe quelle couleur dans 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)). Fixe la taille de base du widget à la largeur basew et à la hauteur baseh.

Voir aussi baseSize().

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

Définit les marges autour du contenu du widget pour qu'elles aient les tailles left, top, right, et bottom. Les marges sont utilisées par le système de mise en page et peuvent être utilisées par les sous-classes pour spécifier la zone dans laquelle dessiner (par exemple en excluant le cadre).

La modification des marges déclenche une commande resizeEvent().

Voir également contentsRect() et contentsMargins().

void QWidget::setContentsMargins(const QMargins &margins)

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

Définit les marges autour du contenu du widget pour qu'elles aient les tailles déterminées par margins. Les marges sont utilisées par le système de mise en page et peuvent être utilisées par les sous-classes pour spécifier la zone dans laquelle dessiner (par exemple, en excluant le cadre).

La modification des marges déclenche l'exécution de la fonction resizeEvent().

Voir également contentsRect() et contentsMargins().

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

Désactive les événements de saisie du widget si disable est vrai ; sinon, active les événements de saisie.

Voir la documentation de enabled pour plus d'informations.

Voir aussi isEnabledTo(), QKeyEvent, QMouseEvent, et changeEvent().

void QWidget::setEditFocus(bool enable)

Si enable est vrai, ce widget a le focus d'édition, auquel cas Qt::Key_Up et Qt::Key_Down seront livrés au widget normalement ; sinon, Qt::Key_Up et Qt::Key_Down sont utilisés pour changer le focus.

Cette fonctionnalité n'est disponible que dans Qt pour Linux embarqué.

Voir aussi hasEditFocus() et QApplication::navigationMode().

void QWidget::setFixedHeight(int h)

Définit les hauteurs minimale et maximale du widget à h sans modifier les largeurs. Fourni pour des raisons de commodité.

Voir aussi sizeHint(), minimumSize(), maximumSize() et setFixedSize().

void QWidget::setFixedSize(const QSize &s)

Fixe les tailles minimale et maximale du widget à s, l'empêchant ainsi de grandir ou de rétrécir.

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

Pour supprimer les contraintes, réglez la taille sur QWIDGETSIZE_MAX.

Par ailleurs, 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)

Fixe la largeur du widget à w et la hauteur à h.

void QWidget::setFixedWidth(int w)

Définit la largeur minimale et maximale du widget à w sans modifier les hauteurs. Fourni pour des raisons de commodité.

Voir aussi sizeHint(), minimumSize(), maximumSize() et setFixedSize().

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

Donne le focus de l'entrée clavier à ce widget (ou à son proxy de focus) si ce widget ou l'un de ses parents est le active window. L'argument reason sera passé dans tout événement de focus envoyé par cette fonction, il est utilisé pour donner une explication sur 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 sera active.

Tout d'abord, un événement "focus about to change" est envoyé au widget "focus" (s'il y en a un) pour l'informer qu'il est sur le point de perdre le focus. Ensuite, le focus est changé, un événement focus out est envoyé à l'élément de focus précédent 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).

setFocus() donne le focus à un widget indépendamment de sa politique de focus, mais n'efface pas la saisie au clavier (voir grabKeyboard()).

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

Voir aussi hasFocus(), clearFocus(), focusInEvent(), focusOutEvent(), setFocusPolicy(), focusWidget(), QApplication::focusWidget(), grabKeyboard(), grabMouse(), Keyboard Focus in Widgets, et QEvent::RequestSoftwareInputPanel.

[slot] void QWidget::setFocus()

Donne le focus de l'entrée 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 vers le widget w. Si w est nullptr, la fonction réinitialise ce widget pour qu'il n'ait pas de proxy de focus.

Certains widgets peuvent "avoir le focus", mais créent un widget enfant, tel que QLineEdit, pour gérer le focus. Dans ce cas, le widget peut définir l'édition de ligne comme son proxy de focus.

setFocusProxy() définit le widget qui obtiendra le focus lorsque "ce widget" l'obtiendra. S'il existe un proxy de focus, setFocus() et hasFocus() opèrent sur le proxy de focus. 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 à role.

Le rôle d'avant-plan définit la couleur du widget palette utilisée pour dessiner l'avant-plan.

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

Notez que les styles sont libres de choisir n'importe quelle couleur dans 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 aussi foregroundRole() et backgroundRole().

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

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

Voir aussi geometry().

void QWidget::setGraphicsEffect(QGraphicsEffect *effect)

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

Définit effect comme l'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, setGraphicsEffect() supprimera l'effet du widget et l'installera sur ce widget.

QWidget prend possession de effect.

Voir également graphicsEffect().

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

Fonction de commodité, équivalente à setVisible( !hidden).

Voir aussi isHidden().

void QWidget::setLayout(QLayout *layout)

Définit le gestionnaire de mise en page de ce widget à layout.

Si un gestionnaire de disposition 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 disposition existant (renvoyé par layout()) avant de pouvoir appeler setLayout() avec la nouvelle disposition.

Si layout est le gestionnaire de disposition d'un autre widget, setLayout() répartira la disposition et en fera le gestionnaire de disposition de ce widget.

Exemple :

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

Une alternative à l'appel de cette fonction est de passer ce widget au constructeur du layout.

Le QWidget deviendra propriétaire du layout.

Voir également layout() et Gestion de la disposition.

void QWidget::setMask(const QBitmap &bitmap)

Ne rend visibles que les pixels du widget pour lesquels bitmap a un bit 1 correspondant. Si la région comprend des pixels en dehors de rect() du widget, les contrôles du système de fenêtres dans cette zone peuvent être visibles ou non, en fonction de 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 avec 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 sur l'écran.

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

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

void QWidget::setMask(const QRegion &region)

Ne rend visible que les parties du widget qui se superposent à region. Si la région comprend des pixels en dehors de rect() du widget, les contrôles du système de fenêtres dans cette zone peuvent être visibles ou non, en fonction de la plate-forme.

Étant donné que QRegion permet de créer des régions arbitrairement complexes, les masques de widgets peuvent être adaptés aux fenêtres les moins conventionnelles et permettent même d'afficher des widgets troués. Notez que cet effet peut être lent si la région est particulièrement complexe.

Les masques de widgets sont utilisés pour indiquer au système de fenêtres que l'application ne veut pas d'événements de souris pour les zones situées à l'extérieur du masque. Sur la plupart des systèmes, ils entraînent également un écrêtage visuel grossier. Pour obtenir des bords de fenêtre lisses, utilisez plutôt un arrière-plan translucide et une peinture anticrénelée, comme le montre l'exemple de l'arrière-plan translucide.

Voir aussi windowOpacity.

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

Cette fonction correspond à setMaximumSize(QSize(maxw, maxh)). Fixe la largeur maximale à maxw et la hauteur maximale à maxh.

Voir aussi maximumSize().

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

Cette fonction correspond à setMinimumSize(QSize(minw, minh)). Fixe la largeur minimale à minw et la hauteur minimale à minh.

Voir aussi minimumSize().

void QWidget::setParent(QWidget *parent)

Définit le parent du widget à parent, et réinitialise les drapeaux de la 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 reparenté et ses enfants sont ajoutés à la fin de 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 clearFocus() pour ce widget.

Si le nouveau widget parent se trouve dans la même fenêtre que l'ancien parent, la définition du parent ne modifie pas l'ordre des onglets 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 en argument les drapeaux des widgets, f.

void QWidget::setScreen(QScreen *screen)

Définit l'écran sur lequel le widget doit être affiché à 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 enable est vrai, la répétition automatique du raccourci avec le nom id est activée ; sinon, elle est désactivée.

Voir aussi grabShortcut() et releaseShortcut().

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

Si enable est vrai, le raccourci correspondant à id est activé ; sinon, le raccourci est désactivé.

Voir aussi grabShortcut() et releaseShortcut().

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

Fixe l'incrément de taille x (largeur) à w et l'incrément de taille y (hauteur) à h.

Voir aussi sizeIncrement().

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

Définit la politique de taille du widget à horizontal et vertical, avec un étirement standard et pas de hauteur pour la largeur.

Voir aussi sizePolicy() et QSizePolicy::QSizePolicy().

void QWidget::setStyle(QStyle *style)

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

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

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

Voir aussi 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 des priorités.

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

Notez que puisque l'ordre de tabulation du widget second est modifié, vous devez ordonner une 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

et non comme ceci :

// 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 a un proxy de focus, setTabOrder() remplace correctement le proxy.

Voir également setFocusPolicy(), setFocusProxy() et Keyboard Focus in 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 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 (QWidget *, QWidget *) :

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

L'appel ne crée pas de boucle fermée de mise au point de l'onglet. S'il existe d'autres widgets avec la politique de focalisation Qt::TabFocus, la tabulation sur d déplacera la focalisation sur l'un de ces widgets, et non sur a.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi setFocusPolicy(), setFocusProxy(), et Keyboard Focus in Widgets.

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

Définit l'indicateur de fenêtre flag sur ce widget si on est vrai ; sinon, efface l'indicateur.

Voir aussi setWindowFlags(), windowFlags() et windowType().

void QWidget::setWindowRole(const QString &role)

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

Voir aussi windowRole().

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

Définit l'état de la fenêtre à windowState. L'état de la fenêtre est une combinaison OR de 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 préservant son état maximisé et/ou plein écran), utilisez le code suivant :

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 message changeEvent() de type QEvent::WindowStateChange.

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

void QWidget::setupUi(QWidget *widget)

Configure l'interface utilisateur pour le site widget spécifié.

Voir aussi Utilisation d'un fichier Designer UI dans votre application.

[slot] void QWidget::show()