===== QWidget ======
La classe QWidget est la classe de base de tous les objets d'interfaces utilisateur. [[#Description détaillée|Plus d'informations...]]
==== Héritage ====
Hérite de [[QObject]] et de [[QPaintDevice]].
Hérité par [[phonon#EffectWidget|Phonon::EffectWidget]], [[phonon#SeekSlider|Phonon::SeekSlider]], [[phonon#VideoPlayer|Phonon::VideoPlayer]], [[phonon#VideoWidget|Phonon::VideoWidget]], [[phonon#VolumeSlider|Phonon::VolumeSlider]], [[Q3ComboBox]], [[Q3DataBrowser]], [[Q3DataView]], [[Q3DateTimeEdit]], [[Q3DateTimeEditBase]], [[Q3DockArea]], [[Q3Header]], [[Q3MainWindow]], [[QAbstractButton]], [[QAbstractSlider]], [[QAbstractSpinBox]], [[QAxWidget]], [[QCalendarWidget]], [[QComboBox]], [[QDesignerActionEditorInterface]], [[QDesignerFormWindowInterface]], [[QDesignerObjectInspectorInterface]], [[QDesignerPropertyEditorInterface]], [[QDesignerWidgetBoxInterface]], [[QDesktopWidget]], [[QDialog]], [[QDialogButtonBox]], [[QDockWidget]], [[QFocusFrame]], [[QFrame]], [[QGLWidget]], [[QGroupBox]], [[QHelpSearchQueryWidget]], [[QHelpSearchResultWidget]], [[QLineEdit]], [[QMacCocoaViewContainer]], [[QMacNativeWidget]], [[QMainWindow]], [[QMdiSubWindow]], [[QMenu]], [[QMenuBar]], [[QPrintPreviewWidget]], [[QProgressBar]], [[QRubberBand]], [[QSizeGrip]], [[QSplashScreen]], [[QSplitterHandle]], [[QStatusBar]], [[QSvgWidget]], [[QTabBar]], [[QTabWidget]], [[QToolBar]], [[QWebInspector]], [[QWebView]], [[QWizardPage]], [[QWorkspace]], [[QWSEmbedWidget]], [[QX11EmbedContainer]] et par [[QX11EmbedWidget]].
==== Description détaillée ====
La classe QWidget est la classe de base de tous les objets d'interface utilisateur.
Le widget est l'atome de l'interface utilisateur : il reçoit des événements de souris, de clavier et d'autres depuis le système de fenêtrage, et peint une représentation de lui-même à l'écran. Tous les widgets sont rectangulaires et sont triés dans un z-ordre. Un widget est coupé par son parent et par les widgets se trouvant devant lui.
Un widget qui n'est pas embarqué dans un widget parent est appelé une fenêtre. Habituellement, les fenêtres ont un cadre et une barre de titre, bien qu'il soit aussi possible de créer une fenêtre sans de telles décorations en utilisant [[qt#WindowType-enum|les drapeaux de fenêtre]] adaptés. Dans Qt, [[QMainWindow]] et les différentes sous-classes de [[QDialog]], sont les types de fenêtres les plus communs.
Tout constructeur de widgets accepte un ou deux arguments standards :
- ''QWidget *parent = 0'' est le parent du nouveau widget. Si c'est 0 (la valeur par défaut), le nouveau widget sera une fenêtre. Si ce n'est pas le cas, il sera un enfant de ''parent'' et limité par la géométrie de ''parent'' (à moins que vous ne spécifiez [[qt#WindowType-enum|Qt::Window]] comme drapeau de fenêtre) ;
- ''Qt::WindowFlags f = 0'' (si disponible) définit les drapeaux de fenêtre ; la valeur par défaut est adaptée à quasiment tous les widgets mais, pour obtenir par exemple, une fenêtre sans système de cadre, vous devrez utiliser des drapeaux spéciaux.
QWidget détient un bon nombre de fonctions membres, mais certaines d'entre elles ont peu de fonctionnalités directes ; par exemple, QWidget a une propriété de police mais ne l'utilise jamais lui-même. Il existe beaucoup de sous-classes qui fournissent une réelle fonctionnalité, telle que [[QLabel]], [[QPushButton]], [[QListWidget]] et [[QTabWidget]].
=== Haut niveau et widgets enfants ===
Un widget sans widget parent est toujours une fenêtre indépendante (widget de haut niveau). Pour ceux-ci, [[#windowTitle-prop|setWindowTitle()]] et [[#windowIcon-prop|setWindowIcon()]] définissent respectivement la barre de titre et l'icône.
Les widgets n'étant pas des fenêtres sont des widgets enfants, affichés dans leur widget parent. La plupart des widgets dans Qt sont principalement utiles en tant que widgets enfants. Par exemple, il est possible d'afficher un bouton en tant que fenêtre de haut niveau, mais la majorité des gens préfèrent mettre leurs boutons à l'intérieur d'autres widgets, tels que [[QDialog]].
{{ http://qt.developpez.com/doc/4.6/images/parent-child-widgets.png |}}
Le schéma ci-dessus affiche un widget [[QGroupBox]] contenant différents widgets enfants dans un layout fourni par [[QGridLayout]]. Les contours des widgets enfants [[QLabel]] ont été dessinés pour indiquer leurs dimensions complètes.
Si vous voulez utiliser un QWidget pour contenir des widgets enfants, vous devrez habituellement ajouter un layout au QWidget parent. Voir les classes de [[layout|gestion de layouts]] pour plus d'informations.
=== Widgets composés ===
Est appelé //composé// un widget utilisé en tant que conteneur pour regrouper un nombre de widgets enfants. Les widgets composés peuvent être créés en même temps qu'un widget avec les propriétés visuelles requises -- un [[QFrame]], par exemple -- et peuvent recevoir des widgets enfants, ordinairement gérés par un layout. Le schéma ci-dessus affiche un widget composé ayant été créé en utilisant [[designer-manual#qt-designer|Qt Designer]].
Les widgets composés peuvent aussi être créés par la réalisation d'une sous-classe d'un widget standard, tel que QWidget ou [[QFrame]], et par l'ajout du layout et des enfants nécessaires dans le constructeur de la sous-classe. Un bon nombre des [[examples|exemples fournis avec Qt]] utilisent cette approche, qui est aussi détaillée par les [[tutorials|tutoriels]] de Qt.
=== Widgets personnalisés et peinture ===
Depuis que QWidget est une sous-classe de [[QPaintDevice]], des sous-classes peuvent être utilisées pour afficher un contenu personnalisé qui serait composé par l'utilisation d'une série d'opérations de peinture avec une instance de la classe [[QPainter]]. Cette approche contraste celle du style canvas, utilisée par [[graphicsview#graphics-view|le framework de vues graphiques]] où les éléments sont ajoutés dans une scène par l'application et sont rendus par le framework lui-même.
Chaque widget exécute toutes les opérations de peinture au sein de sa fonction [[#paintEvent()]], qui est appelée soit lorsque le widget doit être redessiné, soit en tant que résultat d'une quelconque modification externe ou encore quand cela est demandé par l'application.
[[widgets-analogclock|L'exemple Horloge analogique]] montre comment un simple widget peut gérer les événements de peinture.
=== Dimensions conseillées et politiques de dimensionnement ===
Lors de l'implémentation d'un nouveau widget, il est presque toujours utile de réimplémenter [[#sizeHint-prop|sizeHint()]] pour donner des dimensions par défaut raisonnables pour le widget et pour définir la politique de dimensionnement correcte avec [[#sizePolicy-prop|setSizePolicy()]].
Par défaut, les widgets composés qui ne fournissent pas une indication de taille sont dimensionnés selon les besoins en espace de leurs widgets enfants.
La politique de dimensionnement vous laisse fournir un bon comportement par défaut au système de gestion de layout, pour que les autres widgets puissent contenir et gérer les vôtres facilement. La politique de dimensionnement par défaut indique que les dimensions conseillées représentent les dimensions favorites du widget, et cela est la plupart du temps amplement suffisant pour beaucoup de widgets.
**Note :** la taille des widgets de haut niveau est limitée aux deux tiers de la hauteur et de la largeur du bureau. Vous pouvez [[#size-prop|redimensionner]] le widget manuellement si ces limites ne sont pas appropriées.
=== Événements ===
Les widgets réagissent aux événements typiquement causés par les actions de l'utilisateur. Qt délivre les événements aux widgets par l'appel de fonctions de gestion d'événements avec des instances de sous-classes de [[QEvent]], contenant des informations concernant chaque événement.
Si votre widget contient uniquement des widgets enfants, vous n'aurez probablement pas besoin d'implémenter un gestionnaire d'événements. Si vous voulez détecter un clic à l'intérieur d'un widget enfant, vous pouvez appeler la fonction [[#underMouse()]] de l'enfant à l'intérieur de la fonction [[#mousePressEvent()]] du widget.
[[widgets-scribble|L'exemple Scribble]] implémente un large ensemble d'événements pour gérer les mouvements de la souris, les appuis sur les boutons et les redimensionnements de fenêtres.
Vous aurez besoin de fournir le comportement et le contenu à vos propres widgets, voici un bref aperçu des événements appropriés à QWidget, en commençant par les plus communs :
* [[#paintEvent()]] est appelé à chaque fois que le widget nécessite d'être repeint ; tout widget affichant un contenu personnalisé doit l'implémenter ; la peinture par l'utilisation d'un [[QPainter]] peut uniquement avoir lieu dans un [[#paintEvent()]] ou dans une fonction appelée par un [[#paintEvent()]] ;
* [[#resizeEvent()]] est appelé quand un widget vient d'être redimensionné ;
* [[#mousePressEvent()]] est appelé quand un bouton de la souris est pressé pendant que le curseur de la souris est présent à l'intérieur du widget ou quand le widget a saisi la souris en utilisant [[#grabMouse()]] ; la pression de la souris sans son relâchement est effectivement la même chose que l'appel de [[#grabMouse()]] ;
* [[#mouseReleaseEvent()]] est appelé quand un bouton de la souris est relâché ; un widget reçoit des événements de relâchement de la souris quand il a reçu un événement d'enfoncement en correspondance ; cela signifie que, si l'utilisateur enfonce le bouton de la souris à l'intérieur de //votre// widget puis déplace la souris autre part avant de relâcher le bouton, //votre// widget reçoit malgré tout l'événement de relâchement ; il existe une exception : si un menu surgissant apparaît quand le bouton de la souris est maintenu enfoncé, ce menu surgissant dérobe immédiatement les événements de la souris ;
* [[#mouseDoubleClickEvent()]] est appelé quand l'utilisateur double-clique sur le widget ; si l'utilisateur effectue cette action, le widget reçoit un événement d'enfoncement, un événement de relâchement et, au final, cet événement au lieu d'un second événement d'enfoncement (quelques événements de mouvement de la souris sont aussi reçus si la souris n'est pas maintenue de manière stabilisée durant cette opération) ; il est //impossible// de distinguer un clic en provenance d'un double-clic avant que le second clic soit arrivé, c'est une des raisons pour lesquelles la plupart des livres de GUI recommandent que les doubles-clics soient une extension d'un simple clic, plutôt que de déclencher une action différente.
Les widgets qui acceptent les entrées du clavier nécessitent la réimplémentation de quelques gestionnaires d'événements supplémentaires :
* [[#keyPressEvent()]] est appelé à chaque fois qu'une touche est enfoncée et une nouvelle fois quand une touche est restée maintenue suffisamment longtemps pour que cela se répète automatiquement ; les touches **Tab** et **Shift+Tab** sont uniquement passées au widget si elles ne sont pas utilisées par le mécanisme de changement de focus ; pour forcer ces touches à être traitées par votre widget, vous devez réimplémenter [[#event|QWidget::event()]] ;
* [[#focusInEvent()]] est appelé quand le widget obtient le focus du clavier (en supposant que vous avez appelé [[#focusPolicy-prop|setFocusPolicy())]] ; les widgets à bon comportement indiquent qu'ils possèdent le focus du clavier de façon claire mais discrète ;
* [[#focusOutEvent()]] est appelé quand le widget perd le focus du clavier.
Il est possible que vous ayez besoin de réimplémenter aussi quelques gestionnaires d'événements moins communs :
* [[#mouseMoveEvent()]] est appelé chaque fois que la souris se déplace avec l'un de ses boutons maintenu enfoncé, cela peut être utile durant des opérations de glisser-déposer ; si vous appelez [[#mouseTracking-prop|setMouseTracking(true)]], vous obtiendrez les événements de mouvement de la souris même si aucun bouton n'est maintenu ; voir aussi le guide du [[dnd|glissé-déposé]] ;
* [[#keyReleaseEvent()]] est appelé chaque fois qu'une touche est relâchée et tant qu'elle est maintenue enfoncée (si la touche est automatiquement répétitive) ; dans ce cas, le widget recevra une paire d'événements de relâchement de touche pour chaque répétition ; les touches **Tab** et **Shift+Tab** sont uniquement passées au widget si elles ne sont pas utilisées par le mécanisme de changement de focus ; pour forcer ces touches à être traitées par votre widget, vous devez réimplémenter [[#event|QWidget::event()]] ;
* [[#wheelEvent()]] est appelé chaque fois que l'utilisateur tourne la molette de la souris quand le widget détient le focus ;
* [[#enterEvent()]] est appelé quand la souris entre dans l'espace de l'écran du widget, cela inclut l'espace de l'écran détenu par tout enfant de ce widget ;
* [[#leaveEvent()]] est appelé quand la souris quitte l'espace de l'écran du widget ; si la souris entre dans un widget enfant, cela ne causera pas un [[#leaveEvent()]] ;
* [[#moveEvent()]] est appelé quand le widget a été déplacé, relativement à son parent ;
* [[#closeEvent()]] est appelé quand l'utilisateur ferme le widget (ou quand [[#close()]] est appelé).
Il existe également quelques événements obscurs décrits dans la documentation de [[QEvent#type-enum|QEvent::Type]]. Pour gérer ces événements, vous devrez réimplémenter [[#event()]] directement.
L'implémentation par défaut de [[#event()]] gère **Tab** et **Shift+Tab** (pour déplacer le focus du clavier) et passe la plupart des autres événements à l'un des gestionnaires spécialisés décrits ci-dessus.
Les événements et le mécanisme utilisés pour les fournir sont détaillés dans le document [[eventsandfilters|Les événements et les filtres d'événements]].
=== Groupes de fonctions et propriétés ===
^ Contexte ^ Fonctions et propriétés ^
| Fonctions de fenêtre | [[#show()]], [[#hide()]], [[#raise()]], [[#lower()]], [[#close()]]. |
| Fenêtres de haut niveau | [[#windowModified-prop|windowModified]], [[#windowTitle-prop|windowTitle]], [[#windowIcon-prop|windowIcon]], [[#windowIconText-prop|windowIconText]], [[#isActiveWindow-prop|isActiveWindow]], [[#activateWindow()]], [[#minimized-prop|minimized]], [[#showMinimized()]], [[#maximized-prop|maximized]], [[#showMaximized()]], [[#fullScreen-prop|fullScreen]], [[#showFullScreen()]], [[#showNormal()]]. |
| Contenus de fenêtre | [[#update()]], [[#repaint()]], [[#scroll()]]. |
| Géométrie | [[#pos-prop|pos]], [[#x-prop|x()]], [[#y-prop|y()]], [[#rect-prop|rect]], [[#size-prop|size]], [[#width-prop|width()]], [[#height-prop|height()]], [[#pos-prop|move()]], [[#size-prop|resize()]], [[#sizePolicy-prop|sizePolicy]], [[#sizeHint-prop|sizeHint()]], [[#minimumSizeHint-prop|minimumSizeHint()]], [[#updateGeometry()]], [[#layout()]], [[#frameGeometry-prop|frameGeometry]], [[#geometry-prop|geometry]], [[#childrenRect-prop|childrenRect]], [[#childrenRegion-prop|childrenRegion]], [[#adjustSize()]], [[#mapFromGlobal()]], [[#mapToGlobal()]], [[#mapFromParent()]], [[#mapToParent()]], [[#maximumSize-prop|maximumSize]], [[#minimumSize-prop|minimumSize]], [[#sizeIncrement-prop|sizeIncrement]], [[#baseSize-prop|baseSize]], [[#setFixedSize()]]. |
| Mode | [[#visible-prop|visible]], [[#isVisibleTo()]], [[#enabled-prop|enabled]], [[#isEnabledTo()]], [[#modal-prop|modal]], [[#isWindow()]], [[#mouseTracking-prop|mouseTracking]], [[#updatesEnabled-prop|updatesEnabled]], [[#visibleRegion()]]. |
| Ergonomie | [[#style()]], [[#setStyle()]], [[#styleSheet-prop|styleSheet]], [[#cursor-prop|cursor]], [[#font-prop|font]], [[#palette-prop|palette]], [[#backgroundRole()]], [[#setBackgroundRole()]], [[#fontInfo()]], [[#fontMetrics()]]. |
| Fonctions de focus du clavier | [[#focus-prop|focus]], [[#focusPolicy-prop|focusPolicy]], [[#setFocus()]], [[#clearFocus()]], [[#setTabOrder()]], [[#setFocusProxy()]], [[#focusNextChild()]], [[#focusPreviousChild()]]. |
| Saisie de la souris et du clavier | [[#grabMouse()]], [[#releaseMouse()]], [[#grabKeyboard()]], [[#releaseKeyboard()]], [[#mouseGrabber()]], [[#keyboardGrabber()]]. |
| Gestionnaires d'événements | [[#event()]], [[#mousePressEvent()]], [[#mouseReleaseEvent()]], [[#mouseDoubleClickEvent()]], [[#mouseMoveEvent()]], [[#keyPressEvent()]], [[#keyReleaseEvent()]], [[#focusInEvent()]], [[#focusOutEvent()]], [[#wheelEvent()]], [[#enterEvent()]], [[#leaveEvent()]], [[#paintEvent()]], [[#moveEvent()]], [[#resizeEvent()]], [[#closeEvent()]], [[#dragEnterEvent()]], [[#dragMoveEvent()]], [[#dragLeaveEvent()]], [[#dropEvent()]], [[#childEvent()]], [[#showEvent()]], [[#hideEvent()]], [[#customEvent()]], [[#changeEvent()]]. |
| Fonctions système | [[#parentWidget()]], [[#window()]], [[#setParent()]], [[#winId()]], [[#find()]], [[#metric()]]. |
| Aide interactive | [[#setToolTip-prop|setToolTip()]], [[#setWhatsThis-prop|setWhatsThis()]]. |
=== Feuilles de styles de widgets ===
En plus des styles standards de widgets de chaque plateforme, les widgets peuvent aussi être stylisés selon des règles spécifiées dans une [[#styleSheet-prop|feuille de style]]. Cette fonction vous autorise à personnaliser l'apparence de widgets spécifiques pour fournir des repères visuels aux utilisateurs à propos de leurs buts. Par exemple, un bouton peut être stylisé d'une façon particulière afin d'indiquer qu'il exécute une action destructive.
L'utilisation des feuilles de style est décrite de manière plus détaillée dans [[stylesheet|les feuilles de style de Qt]].
=== Transparence et double buffering ===
Depuis Qt 4.0, QWidget utilise automatiquement le bouble-buffer sur ses peintures, afin qu'il n'y ait pas besoin d'écrire un code de double-buffering dans [[#paintEvent()]] pour éviter les scintillements.
Depuis Qt 4.1, l'attribut de widget [[qt#WidgetAttribute-enum|Qt::WA_ContentsPropagated]] est devenu obsolète. À la place, le contenu des widgets parents est propagé par défaut sur chacun de leurs enfants tant que [[Qt#WidgetAttribute-enum|Qt::WA_PaintOnScreen]] n'est pas défini. Les widgets personnalisés peuvent être écrits pour profiter de cette propriété en actualisant des régions irrégulières (pour créer des widgets enfants non rectangles) ou en peignant avec des couleurs ayant une transparence alpha inférieure au maximum. Le schéma suivant montre comment les attributs et les propriétés d'un widget personnalisé peuvent être adaptés pour réaliser des effets différents.
{{ http://qt.developpez.com/doc/4.6/images/propagation-custom.png |}}
Dans le schéma ci-dessus, un widget enfant rectangulaire, semi-transparent, avec une zone supprimée est construit et ajouté à un widget parent (un [[QLabel]] affichant une pixmap). Puis, différentes propriétés et attributs de widgets sont définis pour réaliser différents effets :
* le widget de gauche n'a pas de propriétés additionnelles ni d'attributs de widget définis, cet état par défaut convenant à la plupart des widgets personnalisés utilisant la transparence, de forme irrégulière, ou ne peignant pas la totalité de leur zone avec une brosse opaque ;
* le widget au centre a la propriété [[#autoFillBackground-prop|autoFillBackground]] définie, cette propriété est utilisée avec des widgets personnalisés s'appuyant sur un arrière-plan par défaut et/ou ne peignant pas sur totalité de leur zone avec une brosse opaque ;
* le widget de droite a l'attribut de widget [[qt#WidgetAttribute-enum|Qt::WA_OpaquePaintEvent]] défini : cela indique que le widget peindra sur l'ensemble de sa zone avec des couleurs opaques ; la zone du widget va au début être //non initialisée//, représentée dans le schéma avec une grille de diagonales rouges qui brillent à travers la zone surpeinte ; l'attribut ''Qt::WA_OpaquePaintArea'' est très utile pour les widgets qui ont besoin de peindre rapidement leur propre contenu spécialisé et ne nécessitant pas par défaut un arrière-plan rempli.
Pour actualiser rapidement des widgets personnalisés avec de simples couleurs d'arrière-plan, tels que les widgets utilisant le traçage en temps réel ou encore les widgets graphiques, il est préférable de définir une couleur d'arrière-plan adaptée (en utilisant [[#setBackgroundRole()]] avec le modèle [[qpalette#ColorRole-enum|QPalette::Window]]), de définir la propriété [[#autoFillBackground-prop|autoFillBackground]] et d'implémenter uniquement les fonctions de dessin nécessaires dans le [[#paintEvent()]] du widget.
Pour actualiser rapidement des widgets peignant constamment sur la totalité de leurs zones avec un contenu opaque (par exemple, les widgets de vidéo en streaming), il vaut mieux définir le [[qt#WidgetAttribute-enum|Qt::WA_OpaquePaintEvent]] des widgets, évitant toute utilisation de ressources non nécessaires par la peinture de leur arrière-plan.
Si un widget détient l'attribut de widget [[qt#WidgetAttribute-enum|Qt::WA_OpaquePaintEvent]] //et// la propriété [[#autoFillBackground-prop|autoFillBackground]] définie, l'attribut [[Qt#WidgetAttribute-enum|Qt::WA_OpaquePaintEvent]] devient prioritaire. Selon vos besoins, vous devrez choisir l'un ou l'autre d'entre eux.
Depuis Qt 4.1, le contenu des widgets parents est aussi propagé sur des widgets standards de Qt. Cela peut mener à des résultats inattendus si le widget parent est décoré d'une manière non standard, comme le montre le schéma ci-dessous.
{{ http://qt.developpez.com/doc/4.6/images/propagation-standard.png |}}
L'étendue pour personnaliser le comportement de la peinture des widgets standards de Qt, sans recourir à des sous-classes, est légèrement inférieure à ce qui est possible pour les widgets personnalisés. Généralement, l'apparence désirée d'un widget standard peut être atteinte en définissant sa propriété [[#autoFillBackground-prop|autoFillBackground]].
=== Création de fenêtres translucides ===
Depuis Qt 4.5, il est devenu possible de créer des fenêtres contenant des zones transparentes dans des systèmes de fenêtrage supportant cette composition.
Pour activer cette fonctionnalité dans un widget de haut niveau, définissez son attribut [[Qt#WidgetAttribute-enum|Qt::WA_TranslucentBackground]] avec [[#setAttribute()]] et garantissez que son arrière-plan soit peint à l'aide de couleurs non opaques dans les zones auxquelles vous souhaitez une transparence partielle.
Notes pour les plateformes :
* **X11** : cette propriété repose sur l'utilisation d'un serveur X supportant l'ARGB visuel et un gestionnaire de composition de fenêtres ;
* **Windows** : le widget nécessite la définition du drapeau de fenêtre [[qt#WindowType-enum|Qt::FramelessWindowHint]] pour que la transparence puisse fonctionner.
=== Widgets natifs versus widgets étrangers ===
Introduits dans Qt 4.4, les widgets étrangers sont des widgets inconnus du système de fenêtrage. Ils n'ont pas de gestion de fenêtres natives associées. Cette fonctionnalité accélère de manière significative la peinture du widget, son redimensionnement et élimine les scintillements.
Si vous avez besoin de l'ancien comportement avec des fenêtres natives, vous pouvez choisir l'une des options suivantes :
- Utiliser ''QT_USE_NATIVE_WINDOWS=1'' dans votre environnement ;
- Définir l'attibut [[qt#ApplicationAttribute-enum|Qt::AA_NativeWindows]] dans votre application : tous les widgets deviendront des widgets natifs ;
- Définir l'attribut [[qt#WidgetAttribute-enum|Qt::WA_NativeWindow]] dans vos widgets ; le widget lui-même et tous ses parents deviendront natifs (sauf si [[qt#WidgetAttribute-enum|Qt::WA_DontCreateNativeAncestors]] est défini) ;
- Appeler QWidget::winId pour appliquer une fenêtre native (cela implique le 3e point) ;
- Définir l'attribut [[qt#WidgetAttribute-enum|Qt::WA_PaintOnScreen]] pour appliquer une fenêtre native (cela implique le 3e point).
=== Les touches programmables ===
Depuis Qt 4.6, les touches programmables sont souvent des touches physiques d'un appareil qui ont un libellé correspondant ou une autre représentation visuelle à l'écran, et qui sont généralement situées à côté de leur équivalent physique. Elles se trouvent le plus souvent sur des plateformes de téléphone portable. Dans les interfaces tactiles modernes, il est aussi possible d'avoir des touches programmables qui ne correspondent pas à des touches physiques. Les touches programmables diffèrent des autres libellés à l'écran dans le sens où elles sont contextuelles.
Dans Qt, les touches programmables contextuelles sont ajoutées à un widget par l'appel de [[#addAction]] et sont passées à un ''QAction'' avec, défini dessus, le modèle de touche programmable. Lorsque le widget contenant l'action de la touche programmable détient le focus, sa touche programmable devrait apparaître sur l'interface utilisateur. Les touches programmables sont découvertes par le passage de la hiérarchie du widget de manière à ce qu'il soit possible de définir un unique ensemble de touches programmables, tout le temps présent par l'appel de [[#addAction]] pour un widget de haut niveau donné.
Sur quelques plateformes, ce concept s'imbrique avec [[QMenuBar]] de façon que les actions de la barre de menu puissent apparaître sur l'une des touches programmables si aucune touche programmable n'est trouvée et que le widget de haut niveau est un [[QMainWindow]] contenant la [[QMenuBar]].
**Note :** actuellement, les touches programmables sont uniquement supportées par la plateforme Symbian.
Voir aussi [[QEvent]], [[QPainter]], [[QGridLayout]], [[QBoxLayout]], [[#addAction()]], [[QAction]] et [[QMenuBar]].
==== Type ====
=== RenderFlag-enum ===
''enum QWidget::RenderFlag''
''flags QWidget::RenderFlags''
Cette énumération explique comment faire pour réaliser un rendu du widget lors de l'appel de [[#render()|QWidget::render()]].
^ Constante ^ Valeur ^ Description ^
| ''QWidget::DrawWindowBackground'' | 0x1 | Si vous activez cette option, l'arrière-plan du widget est rendu à l'intérieur de la cible même si [[#autoFillBackground-prop|autoFillBackground]] n'est pas défini. Par défaut, cette propriété est activée. |
| ''QWidget::DrawChildren'' | 0x2 | Si vous activez cette option, les enfants du widget sont rendus récursivement dans la cible. Par défaut, cette option est activée. |
| ''QWidget::IgnoreMask'' | 0x4 | Si vous activez cette option, le [[#mask()|QWidget::mask()]] du widget est ignoré lors du rendu dans la cible. Par défaut, cette option est désactivée. |
Cette énumération a été introduite dans Qt 4.3.
Le type ''RenderFlags'' est une définition de type pour ''[[QFlags]]''. Il stocke une combinaison OR de valeurs ''RenderFlags''.
==== Propriétés ====
=== acceptDrops-prop ===
''acceptDrops : bool''
Cette propriété contrôle si les événements de déposition sont activés pour ce widget.
Définir cette propriété à ''true'' annonce au système qu'il est //possible// que ce widget puisse accepter les dépositions.
Si ce widget est le bureau (si [[#windowType()]] vaut [[qt#WindowType-enum|Qt::Desktop]]), il est possible que cela échoue si une autre application est en train de se servir du bureau ; vous pouvez appeler [[#acceptDrops-prop|acceptDrops()]] pour tester si cela se produit.
**Attention :** ne modifiez pas cette propriété en gestionnaire d'événement de glisser-déposer.
Par défaut, cette propriété vaut ''false''.
== Fonctions d'accès ==
''bool acceptDrops () const''
''void setAcceptDrops ( bool on )''
Voir aussi [[dnd|glisser-et-déposer]].
=== accessibleDescription-prop ===
''accessibleDescription : [[QString]]''
Cette propriété possède la description du widget telle qu'elle est vue par les technologies d'assistance.
Par défaut, cette propriété contient une chaîne de caractères vide.
== Fonctions d'accès ==
''QString accessibleDescription () const''
''void setAccessibleDescription ( const QString & description )''
Voir aussi [[qaccessibleinterface#text|QAccessibleInterface::text()]].
=== accessibleName-prop ===
''accessibleName : [[QString]]''
Cette propriété contient le nom du widget tel qu'il est vu par les technologies d'assistance.
Cette propriété est utilisée par les clients dit "accessibles" pour identifier, trouver ou communiquer le widget à ces types de clients.
Par défaut, cette propriété contient une chaîne de caractères vide.
== Fonctions d'accès ==
''QString accessibleName () const''
''void setAccessibleName ( const QString & name )''
Voir aussi [[qaccessibleinterface#text|QAccessibleInterface::text()]].
=== autoFillBackground-prop ===
''autoFillBackground : bool''
Cette propriété contrôle si l'arrière-plan du widget est rempli automatiquement.
Si elle est activée, cette propriété produira le remplissage de l'arrière-plan du widget par Qt avant d'appeler l'événement de peinture. La couleur utilisée est définie par la couleur ''[[QPalette]]::Window'' depuis la [[qpalette|palette]] du widget.
De plus, les fenêtres sont toujours remplies avec [[qpalette#ColorRole-enum|QPalette::Window]], à moins que les attributs ''WA_OpaquePaintEvent'' ou ''WA_NoSystemBackground'' ne soient définis.
Cette propriété ne peut pas être désactivée (c'est-à-dire être mise à ''false'') si un parent du widget a un gradient statique pour son arrière-plan.
**Attention :** utilisez cette propriété avec prudence lorsqu'elle est en liaison avec les [[stylesheet|feuilles de styles de Qt]]. Quand un widget possède une feuille de style avec un arrière-plan ou une image de bordure valide, cette propriété est automatiquement désactivée.
Par défaut, cette propriété est ''false''.
Cette propriété a été introduite dans Qt 4.1.
== Fonctions d'accès ==
''bool autoFillBackground () const''
''void setAutoFillBackground ( bool enabled )''
Voir aussi [[qt#WidgetAttribute-enum|Qt::WA_OpaquePaintEvent]], [[qt#WidgetAttribute-enum|Qt::WA_NoSystemBackground]] et [[#Transparence et double buffering]].
=== baseSize-prop ===
''baseSize : [[QSize]]''
Cette propriété détient les dimensions de base du widget.
Les dimensions de base du widget sont utilisées pour calculer une taille appropriée au widget dans le cas où celui-ci définirait [[#sizeIncrement-prop|sizeIncrement()]].
Par défaut, pour un widget venant d'être créé, cette propriété a ses dimensions de longueur et de largeur à zéro.
== Fonctions d'accès ==
''QSize baseSize () const''
''void setBaseSize ( const QSize & )''
''void setBaseSize ( int basew, int baseh )''
Voir aussi [[#sizeIncrement-prop|setSizeIncrement()]].
=== childrenRect-prop ===
''childrenRect : const [[QRect]]''
Cette propriété détient le rectangle de délimitation des enfants du widget.
Les widgets cachés sont exclus.
Par défaut, pour un widget sans enfant, cette propriété contient un rectangle de longueur et de largeur zéro situé à l'origine.
== Fonctions d'accès ==
''QRect childrenRect () const''
Voir aussi [[#childrenRegion-prop|childrenRegion()]] et [[geometry-prop|geometry()]].
=== childrenRegion-prop ===
''childrenRegion : const [[QRegion]]''
Cette propriété détient la zone combinée occupée par les enfants du widget.
Les widgets cachés sont exclus.
Par défaut, pour un widget sans enfant, cette propriété contient une zone vide.
== Fonctions d'accès ==
''QRegion childrenRegion () const''
Voir aussi [[childrenRect-prop|childrenRect()]], [[geometry-prop|geometry()]] et [[#mask()]].
=== contextMenuPolicy-prop ===
''contextMenuPolicy : [[qt#ContextMenuPolicy-enum|Qt::ContextMenuPolicy]]''
Cette propriété détient la manière dont le widget affiche un menu contextuel.
La valeur par défaut est [[qt#ContextMenuPolicy-enum|Qt::DefaultContextMenu]], qui signifie que le gestionnaire de [[#contextMenuEvent|contextMenuEvent()]] est appelé. Les autres valeurs sont [[qt#ContextMenuPolicy-enum|Qt::NoContextMenu]], [[qt#ContextMenuPolicy-enum|Qt::PreventContextMenu]], [[qt#ContextMenuPolicy-enum|Qt::ActionsContextMenu]] et [[qt#ContextMenuPolicy-enum|Qt::CustomContextMenu]]. Avec [[qt#ContextMenuPolicy-enum|Qt::CustomContextMenu]], le signal [[#customContextMenuRequested()]] est émis.
== Fonctions d'accès ==
''Qt::ContextMenuPolicy contextMenuPolicy () const''
''void setContextMenuPolicy ( Qt::ContextMenuPolicy policy )''
Voir aussi [[#contextMenuEvent()]], [[#customContextMenuRequested()]] et [[#actions()]].
=== cursor-prop ===
''cursor : QCursor''
Cette propriété détient la forme du curseur pour ce widget.
Le curseur de la souris s'attribuera cette forme quand il sera au-dessus du widget. Regardez la [[qt#CursorShape-enum|liste des curseurs prédéfinis]] pour voir une gamme de formes utiles.
Un éditeur peut utiliser un curseur I-beam :
setCursor(Qt::IBeamCursor);
Si aucun curseur n'a été défini, ou après avoir appelé unsetCursor(), le curseur du parent est utilisé.
Par défaut, cette propriété contient un curseur avec la forme [[qt#CursorShape-enum|Qt::ArrowCursor]].
Certaines implémentations de fenêtre sous-jacente permettent de rétablir le curseur s'il sort de la zone d'un widget, même si la souris est appuyée. Si vous voulez avoir un curseur défini pour tous les widgets, même en dehors de la fenêtre, envisager [[qapplication#setOverrideCursor|QApplication::setOverrideCursor()]].
== Fonctions d'accès ==
''QCursor cursor () const''
''void setCursor ( const QCursor & )''
''void unsetCursor ()''
Voir aussi [[qapplication#setOverrideCursor|QApplication::setOverrideCursor()]].
=== enabled-prop ===
''enabled : bool''
Cette propriété contrôle si le widget est activé.
Un widget activé gère les événements du clavier et de la souris ; un widget désactivé ne le fait pas.
Quelques widgets s'affichent différemment quand ils sont désactivés. Par exemple un bouton peut dessiner son libellé grisé. Si vos widgets ont besoin de connaître le moment où ils deviennent actifs ou inactifs, vous pouvez utiliser la fonction [[#changeEvent()]] avec le type [[qevent#Type-enum|QEvent::EnabledChange]].
Désactiver un widget désactive implicitement ses enfants. Activer respectivement un widget active tous les widgets enfants à moins qu'ils aient été explicitement désactivés.
Par défaut, cette propriété est ''true''.
== Fonctions d'accès ==
''bool isEnabled () const''
''void setEnabled ( bool )''
Voir aussi [[#isEnabledTo()]], [[QKeyEvent]], [[QMouseEvent]] et [[#changeEvent()]].
=== focus-prop ===
''focus : const bool''
Cette propriété contrôle si le widget (ou son proxy de focus) détient le focus du clavier.
Par défaut, cette propriété est ''false''.
**Note :** obtenir la valeur de cette propriété est effectivement équivalent à chercher si [[qapplication#focusWidget|QApplication::focusWidget()]] réfère au widget.
== Fonction d'accès ==
''bool hasFocus () const''
Voir aussi [[#setFocus()]], [[#clearFocus()]], [[#focusPolicy-prop|setFocusPolicy()]] et [[qapplication#focusWidget|QApplication::focusWidget()]].
=== focusPolicy-prop ===
''focusPolicy : [[qt#FocusPolicy-enum|Qt::FocusPolicy]]''
Cette propriété contrôle la manière dont le widget accepte le focus du clavier.
La politique de focus est [[qt#FocusPolicy-enum|Qt::TabFocus]] si le widget accepte le focus du clavier par tabulation, [[qt#FocusPolicy-enum|Qt::ClickFocus]] si le widget accepte le focus par clic, [[qt#FocusPolicy-enum|Qt::StrongFocus]] si le widget accepte les deux et [[qt#FocusPolicy-enum|Qt::NoFocus]] (par défaut) s'il n'accepte pas du tout le focus.
Vous devez activer le focus du clavier pour un widget s'il traite les événements de clavier. Cela est normalement fait depuis le constructeur du widget. Par exemple, le constructeur de [[QLineEdit]] appelle setFocusPolicy([[qt#FocusPolicy-enum|Qt::StrongFocus]]).
Si le widget détient un focus de proxy, alors la politique de focus lui sera propagée.
== Fonctions d'accès ==
''Qt::FocusPolicy focusPolicy () const''
''void setFocusPolicy ( Qt::FocusPolicy policy )''
Voir aussi [[#focusInEvent()]], [[#focusOutEvent()]], [[#keyPressEvent()]], [[#keyReleaseEvent()]] et [[#enabled-prop|enabled]].
=== font-prop ===
''font : [[QFont]]''
Cette propriété contrôle la police actuellement définie pour le widget.
Cette propriété décrit la police du widget demandée. La police est utilisée par le style du widget lors du rendu des composants standards et est disponible comme un moyen de veiller à ce que les widgets personnalisés puissent maintenir une cohérence avec l'ergonomie de la plateforme native. Il est commun que différentes plateformes ou différents styles définissent des polices différentes pour une application.
Quand vous assignez une nouvelle police à un widget, les propriétés en provenance de cette police sont combinées avec la police par défaut du widget pour former la police finale du widget. Vous pouvez appeler [[#fontInfo()]] pour obtenir une copie de la police finale du widget. Celle-ci est aussi utilisée pour initialiser la police de [[QPainter]].
La valeur par défaut dépend de l'environnement du système. [[QApplication]] maintient une police système/thème qui sert en tant que valeur par défaut de tous les widgets. Elle peut aussi être spéciale pour certains types de widgets. Vous pouvez aussi vous-même définir des polices par défaut en passant une police personnalisée et le nom d'un widget à [[qapplication#setFont|QApplication::setFont()]]. Enfin, la police est comparée avec la base de données des polices de Qt pour trouver la meilleure correspondance.
[[QWidget]] propage des propriétés explicites de police du parent à l'enfant. Si vous modifiez une propriété spécifique d'une police et que vous assignez cette police à un widget, cette propriété se propagera à tous les enfants du widget, écrasant n'importe quelle valeur par défaut du système pour cette propriété. Notez que ces polices ne se propagent pas par défaut aux fenêtres (voir [[#isWindow()]]) sans que l'attribut [[qt#WidgetAttribute-enum|Qt::WA_WindowPropagation]] ne soit activé.
La propagation de police de [[QWidget]] est similaire à la propagation de sa palette.
Le style actuel, utilisé pour créer un rendu du contenu de tous les widgets standards de Qt, est libre de choisir d'utiliser la police du widget ou, dans quelques cas, de l'ignorer (partiellement ou entièrement). En particulier, certains styles, comme GTK, Mac, Windows XP et Vista, appliquent des modifications spéciales à la police du widget pour s'harmoniser avec l'ergonomie de la plateforme native. Pour cela, l'assignement de propriétés à une police de widget ne permet pas de garantir le changement de l'apparence du widget. Dans ce cas, vous pouvez choisir d'utiliser une [[#styleSheet-prop|feuille de style]].
**Note :** si les [[stylesheet|feuilles de styles Qt]] sont utilisées sur le même widget que setFont(), les feuilles de style prendront la priorité s'il y a conflit de paramètres.
== Fonctions d'accès ==
''const QFont & font () const''
''void setFont ( const QFont & )''
Voir aussi [[#fontInfo()]] et [[#fontMetrics()]].
=== frameGeometry-prop ===
''frameGeometry : const [[QRect]]''
Cette propriété détient la géométrie du widget par rapport à son parent, incluant le cadre de la fenêtre.
Regardez la documentation de la [[application-windows#window-geometry|géométrie des fenêtres]] pour un aperçu des questions de géométrie avec les fenêtres.
Par défaut, cette propriété contient une valeur dépendant de la plateforme de l'utilisateur et des dimensions de l'écran.
== Fonctions d'accès ==
''QRect frameGeometry () const''
Voir aussi [[#geometry-prop|geometry()]], [[#x-prop|x()]], [[#y-prop|y()]] et [[#pos-prop|pos()]].
=== frameSize-prop ===
''frameSize : const [[QSize]]''
Cette propriété détient les dimensions du widget en incluant tout cadre de la fenêtre.
Par défaut, cette propriété contient une valeur dépendante de la plateforme de l'utilisateur et des dimensions de l'écran.
== Fonction d'accès ==
''QSize frameSize () const''
=== fullScreen-prop ===
''fullScreen : const bool''
Cette propriété contrôle si le widget est affiché en plein écran.
Un widget affiché en plein écran occupe la zone entière de l'écran et n'affiche pas les décorations de fenêtre, comme la barre de titre.
Par défaut, cette propriété est ''false''.
== Fonction d'accès ==
''bool isFullScreen () const''
Voir aussi [[#windowState()]], [[#minimized-prop|minimized]] et [[#maximized-prop|maximized]].
=== geometry-prop ===
''geometry : [[QRect]]''
Cette propriété détient la géométrie du widget relative à son parent en excluant le cadre de la fenêtre.
Lors d'une modification de la géométrie, le widget, s'il est visible, reçoit immédiatement un événement de mouvement ([[#moveEvent()]]) et/ou un événement de redimensionnement ([[#resizeEvent()]]). Si le widget n'est pas actuellement visible, il recevra les événements avant d'être affiché.
La composante de dimension est ajustée si elle se trouve en dehors de l'écart défini par [[#minimumSize-prop|minimumSize()]] et [[#maximumSize-prop|maximumSize()]].
**Attention :** appeler setGeometry() à l'intérieur de [[#resizeEvent()]] ou de [[#moveEvent()]] peut conduire à une boucle infinie.
Regardez la documentation de la [[application-windows#window-geometry|géométrie des fenêtres]] pour un aperçu des questions de géométrie avec les fenêtres.
Par défaut, cette propriété contient une valeur dépendant de la plateforme de l'utilisateur et des dimensions de l'écran.
== Fonctions d'accès ==
''const QRect & geometry () const''
''void setGeometry ( int x, int y, int w, int h )''
''void setGeometry ( const QRect & )''
Voir aussi [[frameGeometry-prop|frameGeometry()]], [[rect-prop|rect()]], [[#pos-prop|move()]], [[#size-prop|resize()]], [[#moveEvent()]], [[#resizeEvent()]], [[#minimumSize-prop|minimumSize()]] et [[#maximumSize-prop|maximumSize()]].
=== height-prop ===
''height : const int''
Cette propriété détient la hauteur du widget en excluant tout cadre de la fenêtre.
Regardez la documentation de la [[application-windows#window-geometry|géométrie des fenêtres]] pour un aperçu des questions de géométrie avec les fenêtres.
**Note :** ne pas utiliser cette fonction pour trouver la hauteur d'un écran sur un [[qdesktopwidget|écran d'ordinateur avec plusieurs bureaux]]. Lisez [[qdesktopwidget#screen-geometry|cette note]] pour plus de détails.
Par défaut, cette propriété contient une valeur dépendant de la plateforme de l'utilisateur et des dimensions de l'écran.
== Fonction d'accès ==
''int height () const''
Voir aussi [[#geometry-prop|geometry]], [[#width-prop|width]] et [[#size-prop|size]].
=== inputMethodHints-prop ===
''inputMethodHints : Qt::InputMethodHints''
Cette propriété détient les conseils de la méthode de saisie spécifique au widget.
Elle est pertinente uniquement pour les widgets de saisie. Elle est utilisée par la méthode de saisie pour récupérer des conseils sur la façon dont elle devrait fonctionner. Par exemple, si le drapeau [[qt#InputMethodHint-enum|Qt::ImhFormattedNumbersOnly]] est défini, la méthode de saisie peut changer ses composants visuels afin de ne permettre que la saisie des chiffres.
** Note: ** les drapeaux ne sont que des indications, de sorte que l'implémentation de la méthode de saisie est libre de les ignorer. Si vous voulez être sûr qu'un certain type de caractères sont entrés, vous devez également définir un [[QValidator]] sur le widget.
La valeur par défaut est [[qt#InputMethodHint-enum|Qt::ImhNone]].
Cette propriété a été introduite dans Qt 4.6.
== Fonctions d'accès ==
''Qt::InputMethodHints inputMethodHints () const''
''void setInputMethodHints ( Qt::InputMethodHints hints )''
Voir aussi [[#inputMethodQuery()]] et [[QInputContext]].
=== isActiveWindow-prop ===
''isActiveWindow : const bool''
Cette propriété contrôle si la fenêtre du widget est la fenêtre active.
La fenêtre active est la fenêtre qui contient le widget ayant le focus du clavier (il est possible que la fenêtre ait tout de même le focus si il n'y a aucun widget ou qu'aucun d'entre eux n'accepte le focus du clavier).
Lorsque des fenêtres surgissantes sont visibles, cette propriété est ''true'' pour la fenêtre active //et// pour la fenêtre surgissante.
Par défaut, cette propriété est ''false''.
== Fonction d'accès ==
''bool isActiveWindow () const''
Voir aussi [[#activateWindow()]] et [[qapplication#activeWindowQApplication::activeWindow()]].
=== layoutDirection-prop ===
''layoutDirection : [[qt#LayoutDirection-enum|Qt::LayoutDirection]]''
Cette propriété détient la direction du layout pour ce widget.
Par défaut, cette propriété est définie sur [[qt#LayoutDirection-enum|Qt::LeftToRight]].
Quand la direction du layout est définie sur un widget, elle se propage à tous les enfants de ce widget mais pas à un enfant qui est une fenêtre et pas à un enfant pour lequel setLayoutDirection() a été explicitement appelée. De plus, les widgets enfants qui ont été ajoutés //après// que setLayoutDirection() ait été appelée pour le parent n'hériteront pas de la direction du layout de ce dernier.
== Fonctions d'accès ==
''Qt::LayoutDirection layoutDirection () const''
''void setLayoutDirection ( Qt::LayoutDirection direction )''
''void unsetLayoutDirection ()''
Voir aussi [[qapplication#layoutDirection-prop|QApplication::layoutDirection]].
=== locale-prop ===
''locale : [[QLocale]]''
Cette propriété détient la localisation du widget.
Tant qu'aucune localisation spéciale ne sera définie, ce sera la localisation parente ou, si ce widget est un widget de haut niveau, la localisation par défaut.
Si le widget affiche des dates ou des nombres, ils seront formatés en utilisant la localisation du widget.
Cette propriété a été introduite dans Qt 4.3.
== Fonctions d'accès ==
''QLocale locale () const''
''void setLocale ( const QLocale & locale )''
''void unsetLocale ()''
Voir aussi [[QLocale]] et [[qlocale#setDefault|QLocale::setDefault()]].
=== maximized-prop ===
''maximized : const bool''
Cette propriété contrôle si ce widget est maximisé.
Cette propriété n'est valable que pour les fenêtres.
**Note :** en raison de limitations de certains systèmes de fenêtrage, cette propriété ne rend pas toujours les résultats attendus (par exemple, si un utilisateur de X11 maximise la fenêtre par le biais d'un gestionnaire de fenêtres, Qt ne dispose d'aucun moyen de distinguer cette méthode par rapport aux autres méthodes de redimensionnement). Il est prévu que le protocole de gestion des fenêtres évolue.
Par défaut, cette propriété est ''false''.
== Fonction d'accès ==
''bool isMaximized () const''
Voir aussi [[#windowState()]], [[#showMaximized()]], [[#visible-prop|visible]], [[#show()]], [[#hide()]], [[#showNormal()]] et [[#minimized-prop|minimized]].
=== maximumHeight-prop ===
''maximumHeight : int''
Cette propriété contient la hauteur maximale en pixels du widget.
Cette propriété correspond à la hauteur détenue par la propriété [[#maximumSize-prop|maximumSize]].
Par défaut, cette propriété contient une valeur de ''16777215''.
**Note :** la définition de la macro ''QWIDGETSIZE_MAX'' limite les dimensions maximales des widgets.
== Fonctions d'accès ==
''int maximumHeight () const''
''void setMaximumHeight ( int maxh )''
Voir aussi [[#maximumSize-prop|maximumSize]] et [[#maximumWidth-prop|maximumWidth]]
=== maximumSize-prop ===
''maximumSize : [[QSize]]''
Cette propriété contient les dimensions maximales en pixels du widget.
Le widget ne peut être redimensionné à une taille plus importante que les dimensions maximales du widget.
**Note :** la définition de la macro ''QWIDGETSIZE_MAX'' limite les dimensions maximales des widgets.
== Fonctions d'accès ==
''QSize maximumSize () const''
''void setMaximumSize ( const QSize & )''
''void setMaximumSize ( int maxw, int maxh )''
Voir aussi [[#maximumWidth-prop|maximumWidth]], [[#maximumHeight-prop|maximumHeight]], [[#minimumSize-prop|minimumSize]] et [[#sizeIncrement-prop|sizeIncrement]].
=== maximumWidth-prop ===
''maximumWidth : int''
Cette propriété contient la longueur maximale en pixels du widget.
Cette propriété correspond à la longueur détenue par la propriété [[#maximumSize-prop|maximumSize]].
Par défaut, cette propriété contient une valeur de ''16777215''.
**Note :** La définition de la macro ''QWIDGETSIZE_MAX'' limite les dimensions maximales des widgets.
== Fonctions d'accès ==
''int maximumWidth () const''
''void setMaximumWidth ( int maxw )''
Voir aussi [[#maximumSize-prop|maximumSize]] et [[#maximumHeight-prop|maximumHeight]].
=== minimized-prop ===
''minimized : const bool''
Cette propriété contrôle si le widget est minimisé (iconifié).
Cette propriété n'est valable que pour les fenêtres.
Par défaut, cette propriété est ''false''.
== Fonction d'accès ==
''bool isMinimized () const''
Voir aussi [[#showMinimized()]], [[#visible-prop|visible]], [[#show()]], [[#hide()]], [[#showNormal()]] et [[#maximized-prop|maximized]].
=== minimumHeight-prop ===
''minimumHeight : int''
Cette propriété contient la hauteur minimale en pixels du widget.
Cette propriété correspond à la hauteur détenue par la propriété [[#minimumSize-prop|minimumSize]].
Par défaut, cette propriété possède une valeur de ''0''.
== Fonctions d'accès ==
''int minimumHeight () const''
''void setMinimumHeight ( int minh )''
Voir aussi [[#minimumSize-prop|minimumSize]] et [[#minimumWidth-prop|minimumWidth]].
=== minimumSize-prop ===
''minimumSize : [[QSize]]''
Cette propriété détient les dimensions minimales du widget.
Le widget ne peut être redimmensionné à une taille inférieure aux dimensions minimales du widget. Les dimensions du widget sont définies de force à la taille minimale si la taille actuelle en est inférieure.
Les dimensions minimales fixées par cette fonction passeront outre les dimensions minimales définies par [[QLayout]]. Pour ne plus définir les dimensions minimales, utilisez la valeur ''[[QSize]](0, 0)''.
Par défaut, cette propriété contient des dimensions avec zéro en longueur et en largeur.
== Fonctions d'accès ==
''QSize minimumSize () const''
''void setMinimumSize ( const QSize & )''
''void setMinimumSize ( int minw, int minh )''
Voir aussi [[#minimumWidth-prop|minimumWidth]], [[#minimumHeight-prop|minimumHeight]], [[#maximumSize-prop|maximumSize]] et [[#sizeIncrement-prop|sizeIncrement]].
=== minimumSizeHint-prop ===
''minimumSizeHint : const [[QSize]]''
Cette propriété contient les dimensions minimales recommandées pour le widget.
Si la valeur de cette propriété est une taille invalide, aucune dimension minimale n'est recommandée.
L'implémentation par défaut de minimumSizeHint() retourne des dimensions invalides s'il n'y a pas de layout pour ce widget, et retourne les dimensions minimales du layout dans le cas contraire. La majorité des widgets de Qt réimplémentent minimumSizeHint().
[[QLayout]] ne redimensionnera jamais un widget à une dimension inférieure à la taille minimum recommandée sans que [[#minimumSize-prop|minimumSize()]] ne soit défini ou que la politique de dimensionnement ne soit à QSizePolicy::Ignore. Si [[#minimumSize-prop|minimumSize()]] est définie, les dimensions minimales recommandées seront ignorées.
== Fonction d'accès ==
''virtual QSize minimumSizeHint () const''
Voir aussi [[qsize#isValid|QSize::isValid()]], [[size-prop|resize()]], [[#minimumSize-prop|setMinimumSize()]] et [[#sizePolicy-propsizePolicy()]].
=== minimumWidth-prop ===
''minimumWidth : int''
Cette propriété détient la longueur minimale en pixels du widget.
Cette propriété correspond à la longueur détenue par la propriété [[#minimumSize-prop|minimumSize]].
Par défaut, cette propriété possède une valeur de ''0''.
== Fonctions d'accès ==
''int minimumWidth () const''
''void setMinimumWidth ( int minw )''
Voir aussi [[#minimumSize-prop|minimumSize]] et [[#minimumHeight-prop|minimumHeight]].
=== modal-prop ===
''modal : const bool''
Cette propriété contrôle si le widget est un widget modal.
Cette propriété n'a de sens que pour les fenêtres. Un widget modal empêche les widgets de toutes les autres fenêtres d'obtenir une quelconque entrée.
Par défaut, cette propriété est ''false''.
== Fonction d'accès ==
''bool isModal () const''
Voir aussi [[#isWindow()]], [[#windowModality-prop|windowModality]] et [[QDialog]].
=== mouseTracking-prop ===
''mouseTracking : bool''
Cette propriété contrôle si le suivi de la souris est activé pour le widget.
Si le suivi de la souris est désactivé (par défaut), le widget reçoit uniquement les événements de mouvement de souris quand au moins un bouton de la souris est pressé pendant qu'elle se déplace.
Si le suivi de la souris est activé, le widget reçoit les événements de mouvements de souris même si aucun bouton n'est pressé.
== Fonctions d'accès ==
''bool hasMouseTracking () const''
''void setMouseTracking ( bool enable )''
Voir aussi [[#mouseMoveEvent()]].
=== normalGeometry-prop ===
''normalGeometry : const [[QRect]]''
Cette propriété détient la géométrie du widget comme elle apparaîtra quand il sera affiché en tant que widget de haut niveau en mode normal (ni maximisé, ni en plein écran).
Pour les widgets enfants, cette propriété détient toujours un rectangle vide.
Par défaut, cette propriété contient un rectangle vide.
== Fonctions d'accès ==
''QRect normalGeometry () const''
Voir aussi [[#windowState|QWidget::windowState()]] et [[#geometry-prop|QWidget::geometry]].
=== palette-prop ===
''palette : [[QPalette]]''
Cette propriété détient la palette du widget.
Cette propriété décrit la palette du widget. La palette est utilisée par le style du widget lors du rendu des composants standards et est disponible en tant que moyen de veiller à ce que les widgets personnalisés puissent maintenir une cohérence avec l'ergonomie de la plateforme native. Il est fréquent que différentes plateformes ou différents styles aient des palettes différentes.
Quand vous assignez une nouvelle palette à un widget, les rôles des couleurs depuis cette palette sont combinés avec la palette par défaut du widget pour former la palette finale du widget. La palette d'entrée pour l'arrière-plan du widget est utilisé pour en remplir l'arrière-plan (voir [[#autoFillBackground-prop|QWidget::autoFillBackground]]). Le rôle du premier plan est d'initialiser le pinceau de [[QPainter]].
La valeur par défaut dépend du système d'exploitation. [[QApplication]] maintient un rapport de palette système/thème servant comme valeur par défaut à tous les widgets. Il peut aussi y avoir des palettes ayant une valeur par défaut spéciale pour certains types de widgets (par exemple, sous Windows XP ou Vista, toutes les classes dérivant de [[QMenuBar]] détiennent une palette par défaut particulière). Vous pouvez aussi définir vous-même des palettes spéciales pour des widgets en passant une palette personnalisée et le nom d'un widget à la fonction [[qapplication#setPalette|QApplication::setPalette()]]. Enfin, le style détient toujours la possibilité de polissage de la palette si cela est assigné (voir [[qstyle#polish|QStyle::polish()]]).
[[QWidget]] propage les rôles explicites de la palette du parent à l'enfant. Si vous assignez une brosse ou une couleur à un rôle particulier sur une palette et que vous assignez cette palette à un widget, le rôle va se propager à tous les widgets enfants, ne tenant pas compte des valeurs par défaut de ce rôle. Notez que les palettes ne se propagent pas aux fenêtres (voir [[#isWindow()]]) à moins que l'attribut [[qt#WidgetAttribute-enum|Qt::WA_WindowPropagation]] soit activé.
La propagation de la palette de [[QWidget]] est similaire à la propagation de sa police.
Le style actuel, qui est utilisé pour faire un rendu du contenu des widgets standards de Qt, est libre de choisir les couleurs et les brosses à partir de la palette du widget, ou dans quelques cas, d'ignorer la palette (partiellement ou complètement). En particulier, certains styles comme le style GTK, le style Mac et le style Windows XP et Vista, dépendent d'API tierces pour rendre le contenu des widgets, et ces styles ne suivent pas la palette. C'est pourquoi, l'assignement des rôles à une palette ne garantit pas de changer l'apparence du widget. Dans ce cas, vous pouvez choisir d'utiliser une [[#styleSheet-prop|feuille de style]]. Vous pouvez vous référer à [[http://qt.nokia.com/developer/knowledgebase/22|l'article Knowledge Base 22]] pour plus d'informations.
**Attention :** ne pas utiliser cette fonction en conjonction avec les [[stylesheet|feuilles de style Qt]]. Lors de l'utilisation de feuilles de style, la palette d'un widget peut être personnalisée en utilisant ''"color"'', ''"background-color"'', ''"selection-color"'', ''"selection-background-color"'' et ''"alternate-background-color"''.
== Fonctions d'accès ==
''const QPalette & palette () const''
''void setPalette ( const QPalette & )''
Voir aussi [[qapplication#palette|QApplication::palette()]] et [[#font-prop|QWidget::font()]].
=== pos-prop ===
''pos : [[QPoint]]''
Cette propriété détient la position du widget à l'intérieur de son widget parent.
Si le widget est une fenêtre, la position est celle du widget dans le bureau, en incluant son cadre.
Lors du changement de position, si le widget est visible, il reçoit immédiatement un événement de mouvement ([[#moveEvent()]]). Si le widget n'est pas actuellement visible, il recevra l'événement avant d'être affiché.
Par défaut, cette propriété contient une position se référant à l'origine.
**Attention :** appeler move() ou [[#geometry-prop|setGeometry()]] à l'intérieur d'un [[#moveEvent()]] peut conduire à une boucle infinie.
Regardez la documentation de la [[application-windows.html#window-geometry|géométrie de la fenêtre]] pour un aperçu des questions de géométrie avec les fenêtres.
== Fonctions d'accès ==
''QPoint pos () const''
''void move ( int x, int y )''
''void move ( const QPoint & )''
Voir aussi [[#frameGeometry-prop|frameGeometry]], [[#size-prop|size]], [[#x-prop|x()]] et [[#y-prop|y()]].
=== rect-prop ===
''rect : const [[QRect]]''
Cette propriété détient la géométrie interne du widget, en excluant tout cadre de la fenêtre.
La propriété rect est l'équivalent de [[QRect]](0, 0, [[#width-prop|width()]], [[#height-prop|height()]]).
Regardez la documentation de la [[application-windows.html#window-geometry|géométrie de la fenêtre]] pour un aperçu des questions de géométrie avec les fenêtres.
Par défaut, cette propriété contient une valeur qui dépend de la plateforme de l'utilisateur et de la géométrie de son écran.
== Fonction d'accès ==
''QRect rect () const''
Voir aussi [[#size-prop|size]].
=== size-prop ===
''size : [[QSize]]''
Cette propriété détient les dimensions du widget en excluant tout cadre de la fenêtre.
Si le widget est visible lorsqu'il est redimensionné, il reçoit immédiatement un événement de redimensionnement ([[#resizeEvent()]]). Si le widget n'est pas actuellement visible, il recevra l'événement avant d'être affiché.
Les dimensions sont ajustées si elles se trouvent en dehors de l'écart entre [[#minimumSize-prop|minimumSize()]] et [[#maximumSize-prop|maximumSize()]].
Par défaut, cette propriété contient une valeur qui dépend de la plateforme de l'utilisateur et de la géométrie de son écran.
**Attention :** appeler resize() ou [[#geometry-prop|setGeometry()]] à l'intérieur d'un [[#resizeEvent()]] peut conduire à une boucle infinie.
**Note :** définir les dimensions à ''QSize(0, 0)'' entraînera un non-affichage du widget à l'écran. Cela s'applique aussi aux fenêtres.
== Fonctions d'accès ==
''QSize size () const''
''void resize ( int w, int h )''
''void resize ( const QSize & )''
Voir aussi [[#pos-prop|pos]], [[#geometry-prop|geometry]], [[#minimumSize-prop|minimumSize]], [[#maximumSize-prop|maximumSize]] et [[#resizeEvent()]].
=== sizeHint-prop ===
''sizeHint : const [[QSize]]''
Cette propriété détient les dimensions recommandées du widget.
Si la valeur de cette propriété est une taille invalide, aucune dimension n'est recommandée.
L'implémentation par défaut de sizeHint() retourne des dimensions invalides s'il n'y a pas de layout pour ce widget et retourne les dimensions préférées du layout dans le cas contraire.
== Fonctions d'accès ==
''virtual QSize sizeHint () const''
Voir aussi [[qsize#isValid|QSize::isValid()]], [[#minimumSizeHint-prop|minimumSizeHint()]], [[sizePolicy-prop|sizePolicy()]], [[#minimumSize-prop|setMinimumSize()]] et [[#updateGeometry()]].
=== sizeIncrement-prop ===
''sizeIncrement : [[QSize]]''
Cette propriété contrôle l'augmentation des dimensions du widget.
Quand l'utilisateur redimensionne une fenêtre, les dimensions se déplaceront horizontalement de sizeIncrement().[[#width-prop|width()]] pixels et verticalement de sizeIncrement.[[#height-prop|height()]], avec [[#baseSize-prop|baseSize()]] comme base. Les dimensions recommandées du widget sont des entiers non négatifs ''i'' et ''j'' :
width = baseSize().width() + i * sizeIncrement().width();
height = baseSize().height() + j * sizeIncrement().height();
Notez que même si vous pouvez définir la taille d'incrémentation pour tous les widgets, elle n'affecte que les fenêtres.
**Attention :** l'augmentation de taille n'a aucun effet sous Windows et peut ne pas être respectée par le gestionnaire de fenêtres sous X11.
== Fonctions d'accès ==
''QSize sizeIncrement () const''
''void setSizeIncrement ( const QSize & )''
''void setSizeIncrement ( int w, int h )''
Voir aussi [[#size-prop|size]], [[#minimumSize-prop|minimumSize]] et [[#maximumSize-prop|maximumSize]].
=== sizePolicy-prop ===
''sizePolicy : [[QSizePolicy]]''
Cette propriété détient le comportement par défaut du layout du widget.
S'il y a un [[QLayout]] qui gère les enfants du widget, la politique de dimension spécifiée par ce layout est utilisée. S'il n'y a pas de tel [[QLayout]], le résultat de cette fonction est utilisé.
La politique par défaut est ''Preferred/Preferred'', qui signifie que le widget peut être librement redimensionné même s'il est préférable de le dimensionner à la taille que [[#sizeHint-prop|sizeHint()]] retourne. Les widgets de type bouton définissent la taille de police, afin de préciser qu'ils peuvent s'étendre horizontalement, mais sont fixés verticalement. La même chose s'applique à des lignes éditables (telles que [[QLineEdit]], [[QSpinBox]] ou [[QComboBox]]) et à d'autres widgets orientés horizontalement (comme [[QProgressBar]]). Les [[QToolButton]] sont normalement carrés, ils permettent donc une augmentation dans les deux directions. Les widgets supportant différentes directions (comme [[QSlider]], [[QScrollBar]] ou [[QHeader]]) spécifient l'augmentation dans la direction respective seulement. Les widgets pouvant fournir des barres de défilement (souvent des sous-classes de [[QScrollArea]]) tendent à indiquer qu'ils peuvent utiliser de l'espace additionnel et qu'ils peuvent faire avec moins que [[#sizeHint-prop|sizeHint()]].
== Fonctions d'accès ==
''QSizePolicy sizePolicy () const''
''void setSizePolicy ( QSizePolicy )''
''void setSizePolicy ( QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical )''
Voir aussi [[#sizeHint-prop|sizeHint()]], [[QLayout]], [[QSizePolicy]] et [[#updateGeometry()]].
=== statusTip-prop ===
''statusTip : [[QString]]''
Cette propriété détient le statut d'astuce du widget.
Par défaut, cette propriété contient une chaîne de caractères vide.
== Fonctions d'accès ==
''QString statusTip () const''
''void setStatusTip ( const QString & )''
Voir aussi [[#toolTip-prop|toolTip]] et [[#whatsThis-prop|whatsThis]].
=== styleSheet-prop ===
''styleSheet : [[QString]]''
Cette propriété détient la feuille de style du widget.
La feuille de style contient une description textuelle des personnalisations pour le style du widget, comme décrit dans le document les [[stylesheet|feuilles de style Qt]].
Depuis Qt 4.5, les feuilles de style sont complètement supportées sous Mac OS X.
**Attention :** les feuilles de style de Qt sont actuellement non supportées par les sous-classes personnalisées de [[QStyle]]. Ce problème sera traité dans une future version.
Cette propriété a été introduite dans Qt 4.2.
== Fonctions d'accès ==
''QString styleSheet () const''
''void setStyleSheet ( const QString & styleSheet )''
Voir aussi [[#setStyle()]], [[qapplication#styleSheet-prop|QApplication::styleSheet]] et [[stylesheet|Qt Style Sheets]].
=== toolTip-prop ===
''toolTip : [[QString]]''
Cette propriété détient l'info-bulle du widget.
Notez que par défaut, les info-bulles sont uniquement affichées pour les widgets enfants de la fenêtre active. Vous pouvez changer ce comportement en définissant l'attribut [[qt#WidgetAttribute-enum|Qt::WA_AlwaysShowToolTips]] sur la fenêtre et non sur le widget avec l'info-bulle.
Si vous voulez contrôler le comportement d'une info-bulle, vous pouvez intercepter la fonction [[#event()]] et attraper l'événement [[qevent#Type-enum|QEvent::ToolTip]] (par exemple, si vous voulez personnaliser la zone sur laquelle l'info-bulle sera affichée).
Par défaut, cette fonction contient une chaîne de caractères vide.
== Fonctions d'accès ==
''QString toolTip () const''
''void setToolTip ( const QString & )''
Voir aussi [[QToolTip]], [[#statusTip-prop|statusTip]] et [[#whatsThis-prop|whatsThis]].
=== updatesEnabled-prop ===
''updatesEnabled : bool''
Cette propriété contrôle si les actualisations sont activées.
Un widget pouvant s'actualiser reçoit des événements de peinture et dispose d'un système en arrière-plan, contrairement à un widget désactivé. Cela implique aussi que l'appel de [[#update()]] et de [[#repaint()]] n'a pas d'effet si les actualisations sont désactivées.
Par défaut, cette propriété est ''true''.
setUpdatesUnabled() est normalement utilisée pour désactiver les actualisations pour une courte durée, par exemple, pour éviter les scintillements de l'écran lors de longs chargements. Dans Qt, les widgets ne génèrent normalement pas de scintillement de l'écran, mais sous X11, il est possible que le serveur efface des zones de l'écran lorsque des widgets deviennent cachés avant d'être remplacés par d'autres widgets. Désactiver les actualisations résout ce problème.
Exemple :
setUpdatesEnabled(false);
bigVisualChanges();
setUpdatesEnabled(true);
Désactiver un widget désactive implicitement tous ses enfants. Activer un widget active tous les widgets enfants //à l'exception// des widgets de haut niveau ou ceux qui ont été explicitement désactivés. Activer de nouveau les actualisations appelle implicitement [[#update()]] sur le widget.
== Fonctions d'accès ==
''bool updatesEnabled () const''
''void setUpdatesEnabled ( bool enable )''
Voir aussi [[#paintEvent()]].
=== visible-prop ===
''visible : bool''
Cette propriété contrôle si le widget est visible.
Appeler setVisible(true) ou [[#show()]] définit le widget à un statut visible si la totalité de ses widgets parents jusqu'à la fenêtre sont visibles. Si un ancêtre n'est pas visible, le widget ne deviendra pas visible jusqu'à ce que tous ses ancêtres soient affichés. Si sa taille ou sa position ont changé, Qt garantit qu'un widget recevra les événements de mouvement et de redimensionnement juste avant d'être affiché. Si le widget n'a pas encore été redimensionné, Qt ajustera les dimensions du widget à une valeur par défaut pratique en utilisant [[#adjustSize()]].
Appeler setVisible(false) ou [[#hide()]] cache explicitement un widget. Un widget explicitement caché ne deviendra jamais visible, même si la totalité de ses ancêtres deviennent visibles, à moins que vous ne l'affichiez.
Un widget reçoit les événements d'affichage et de masquage lorsque son statut de visibilité change. Entre l'événement d'affichage et l'événement de masquage, il n'est pas nécessaire de gaspiller des cycles de CPU pour la préparation ou l'affichage d'informations à l'utilisateur. Une application vidéo, par exemple, pourrait simplement cesser de générer de nouvelles frames.
Un widget qui se trouve être masqué par d'autres fenêtres à l'écran est considéré comme visible. La même chose s'applique aux fenêtres iconifiées et aux fenêtres existantes dans un autre bureau virtuel (sous les plateformes supportant ce concept). Un widget reçoit spontanément les événements d'affichage et de masquage quand la cartographie de son statut est changée par le système de fenêtrage, tel qu'un événement spontané de masquage lorsque l'utilisateur minimise la fenêtre, et un événement spontané d'affichage lorsque la fenêtre est de nouveau restaurée.
La plupart du temps, vous n'aurez pas besoin de réimplémenter la fonction setVisible(). Si vous avez besoin de changer des paramètres avant qu'un widget ne soit affiché, utilisez plutôt [[#showEvent()]]. Si vous avez besoin de faire des initialisations retardées, utilisez l'événement de polissage livré par la fonction [[#event()]].
== Fonctions d'accès ==
''bool isVisible () const''
''virtual void setVisible ( bool visible )''
Voir aussi [[#show()]], [[#hide()]], [[#isHidden()]], [[#isVisibleTo()]], [[#minimized-prop|isMinimized()]], [[#showEvent()]] et [[#hideEvent()]].
=== whatsThis-prop ===
''whatsThis : [[QString]]''
Cette propriété contient le texte d'aide //Whats's This// du widget.
Par défaut, cette fonction contient une chaîne de caractères vide.
== Fonctions d'accès ==
''QString whatsThis () const''
''void setWhatsThis ( const QString & )''
Voir aussi [[QWhatsThis]], [[#toolTip-prop|QWidget::toolTip]] et [[#statusTip-prop|QWidget::statusTip]].
=== width-prop ===
''width : const int''
Cette propriété détient la longueur du widget en excluant tout cadre de fenêtre.
Regardez la documentation de la [[application-windows.html#window-geometry|géométrie de la fenêtre]] pour un aperçu des questions de géométrie avec les fenêtres.
**Note :** ne pas utiliser cette fonction pour trouver la longueur d'un écran sur un [[qdesktopwidget|écran d'ordinateur avec plusieurs bureaux]]. Lisez cette [[qdesktopwidget#screen-geometry|note]] pour plus de détails.
Par défaut, cette propriété contient une valeur dépendant de la plateforme de l'utilisateur et des dimensions de l'écran.
== Fonctions d'accès ==
''int width () const''
Voir aussi [[#geometry-prop|geometry]], [[#height-prop|height]] et [[#size-prop|size]].
=== windowFilePath-prop ===
''windowFilePath : [[QString]]''
Cette propriété contient le chemin du fichier associé avec le widget.
Cette propriété n'est valable que pour les fenêtres. Elle associe un chemin de fichier à la fenêtre. Si vous définissez ce chemin, mais que vous n'avez pas défini le titre de la fenêtre, Qt définit le titre de la fenêtre de manière à ce qu'elle contienne une chaîne de caractères créée à l'aide des composants suivants :
Sous Mac OS X :
* le nom de fichier du chemin spécifié, obtenu à l'aide de [[qfileinfo#fileName|QFileInfo::fileName()]].
Sous Windows et X11 :
* le nom de fichier du chemin spécifié, obtenu à l'aide de [[qfileinfo#fileName|QFileInfo::fileName()]] ;
* un caractère ''*'' optionnel, si la propriété [[#windowModified-prop|windowModified]] a été définie ;
* le caractère Unicode ''0x2014'', encadré des deux côtés par des espaces ;
* le nom de l'application, obtenu à partir de la propriété de l'application [[qcoreapplication#applicationName-prop|applicationName]].
Si le titre de la fenêtre est défini quelque part, alors il est pris en priorité et sera affiché à la place de la chaîne de caractères contenant le chemin du fichier.
De plus, sous Mac OS X, cette propriété détient l'avantage supplémentaire de définir l'[[http://developer.apple.com/documentation/UserExperience/Conceptual/OSXHIGuidelines/XHIGWindows/chapter_17_section_3.html|icône proxy]] de la fenêtre, en supposant que le chemin de fichier existe.
Si aucun chemin de fichier n'est défini, cette propriété contient une chaîne de caractères vide.
Cette propriété a été introduite dans Qt 4.4.
== Fonctions d'accès ==
''QString windowFilePath () const''
''void setWindowFilePath ( const [[QString]] & filePath )''
Voir aussi [[qwidget#windowTitle-prop|windowTitle]] et [[#windowIcon-prop|windowIcon]].
=== windowFlags-prop ===
''windowFlags : [[qt#WindowType-enum|Qt::WindowFlags]]''
Les drapeaux de fenêtre sont une combinaison d'un type (par exemple [[qt#WindowType-enum|Qt::Dialog]]) et de zéros ou plusieurs indications au système de fenêtrage (par exemple [[qt#WindowType-enum|Qt::FramelessWindowHint]]).
Si le widget est de type [[qt#WindowType-enum|Qt::Widget]] ou [[qt#WindowType-enum|Qt::SubWindow]], et qu'il devient une fenêtre ([[qt#WindowType-enum|Qt::Window]], [[qt#WindowType-enum|Qt::Dialog]], etc.), il sera placé à la position (0, 0) du bureau. Si le widget est une fenêtre et qu'il devient un [[qt#WindowType-enum|Qt::Widget]] ou une [[qt#WindowType-enum|Qt::SubWindow]], il sera placé à la position (0, 0) de manière relative à son widget parent.
**Note :** cette fonction appelle [[#setParent()]] lors d'un changement de drapeau pour une fenêtre, poussant le widget a être masqué. Vous devez appeler [[#show()]] pour rendre le widget de nouveau visible.
== Fonctions d'accès ==
''Qt::WindowFlags windowFlags () const''
''void setWindowFlags ( [[qt#WindowType-enum|Qt::WindowFlags]] type )''
Voir aussi [[#windowType()]] et [[widgets-windowflags|l'exemple Window Flags]].
=== windowIcon-prop ===
''windowIcon : [[QIcon]]''
Cette propriété détient l'icône du widget.
Cette propriété n'est valable que pour les fenêtres. Si aucune icône n'a été définie, windowIcon() retourne l'icône de l'application ([[qapplication#windowIcon-prop|QApplication::windowIcon()]]).
== Fonctions d'accès ==
''QIcon windowIcon () const''
''void setWindowIcon ( const [[QIcon]] & icon )''
Voir aussi [[#windowIconText-prop|windowIconText]] et [[#windowTitle-prop|windowTitle]].
=== windowIconText-prop ===
''windowIconText : [[QString]]''
Cette propriété détient le texte iconique du widget.
Cette propriété n'est valable que pour les fenêtres. Si aucune icône n'a été définie, cette fonction retourne une chaîne de caractères vide.
== Fonctions d'accès ==
''QString windowIconText () const''
''void setWindowIconText ( const [[QString]] & )''
Voir aussi [[#windowIcon-prop|windowIcon]] et [[#windowTitle-prop|windowTitle]].
=== windowModality-prop ===
''windowModality : [[qt#WindowModality-enum|Qt::WindowModality]]''
Cette propriété contrôle quelles fenêtres sont bloquées par le widgtet modal.
Cette propriété n'est valable que pour les fenêtres. Un widget modal empêche les widgets de toutes les autres fenêtres d'obtenir toute entrée. La valeur de cette propriété contrôle quelles fenêtres sont bloquées lorsque le widget est visible. Changer cette propriété tant que la fenêtre est visible n'a aucun effet, vous devez tout d'abord passer le widget par [[#hide()]], puis de nouveau par [[#show()]].
Par défaut, cette propriété est à [[qt#WindowModality-enum|Qt::NonModal]].
Cette propriété a été introduite dans Qt 4.1.
== Fonctions d'accès ==
''[[qt#WindowModality-enum|Qt::WindowModality]] windowModality () const''
''void setWindowModality ( [[qt#WindowModality-enum|Qt::WindowModality]] windowModality )''
Voir aussi [[#isWindow()]], [[#modal-prop|QWidget::modal]] et [[QDialog]].
=== windowModified-prop ===
''windowModified : bool''
Cette propriété contrôle si le document affiché dans la fenêtre détient des modifications non enregistrées.
Une fenêtre modifiée est une fenêtre dont le contenu a été modifié mais n'a pas été sauvegardé sur un disque. Ce drapeau aura différents effets selon la plateforme. Sous Mac OS X, le bouton de fermeture aura un aspect modifié ; sous les autres plateformes, le titre de la fenêtre contiendra un astérisque ''*''.
Le titre de la fenêtre doit contenir un paramètre fictif ''[*]'', qui indiquera l'emplacement où le '*' devra apparaître. Normalement, il pourra apparaître juste après le nom du fichier (par exemple ''document1.txt[*] - Éditeur de texte''). Si la fenêtre n'est pas modifiée, le paramètre fictif est simplement retiré.
Notez que si un widget est défini comme étant modifié, tous ses ancêtres seront aussi définis comme étant modifiés. Cependant, si vous appelez ''setWindowModified(false)'' sur le widget, cela ne se propagera pas à son parent car d'autres enfants du parent peuvent être modifiés.
== Fonctions d'accès ==
''bool isWindowModified () const''
''void setWindowModified ( bool )''
Voir aussi [[#windowTitle-prop|windowTitle]], [[mainwindows-application|l'exemple Application]], [[mainwindows-sdi|l'exemple SDI]] et [[mainwindows-mdi|l'exemple MDI]].
=== windowOpacity-prop ===
''windowOpacity : double''
Cette propriété détient le niveau d'opacité de la fenêtre.
L'écart valide d'opacité est de 1.0 (complètement opaque) à 0.0 (complètement transparent).
Par défaut, la valeur de cette propriété est 1.0.
Cette caractéristique est disponible sous les plateformes Linux embarqué, Mac OS X, Windows et X11 supportant l'extension Composite.
Cette caractéristique n'est pas disponible sous Windows CE.
Notez que sous X11, vous devez avoir un gestionnaire composite en marche et l'atome ''_NET_WM_WINDOW_OPACITY'', spécifique à X11 nécessite d'être supporté par le gestionnaire de fenêtrage que vous utilisez.
**Attention :** modifier cette propriété de opaque à transparent, peut aboutir à un besoin d'appel à un événement de peinture, avant que la fenêtre ne soit affichée correctement. Cela affecte principalement l'usage de [[qpixmap#grabWindow|QPixmap::grabWindow()]]. Notez aussi que les actualisations et redimensionnements de fenêtres semi-transparentes seront sensiblement plus lents que pour des fenêtres opaques.
== Fonctions d'accès ==
''qreal windowOpacity () const''
''void setWindowOpacity ( qreal level )''
Voir aussi [[#setMask()]].
=== windowTitle-prop ===
''windowTitle : [[QString]]''
Cette propriété contient le titre de la fenêtre (légende).
Cette propriété n'est valable que pour les widgets de haut niveau, tels que les fenêtres et les boîtes de dialogue. Si aucune légende n'a été définie, le titre se base sur le [[#windowFilePath-prop|windowFilePath]]. Si aucun des deux n'est défini, alors le titre est une chaîne de caractères vide.
Si vous utilisez le mécanisme [[#windowModified-prop|windowModified]], le titre de la fenêtre doit contenir un paramètre fictif ''[*]'', qui indiquera l'emplacement où le ''*'' devra apparaître. Normalement, il pourra apparaître juste après le nom du fichier (par exemple ''document1.txt[*] - Éditeur de texte''). Si la fenêtre n'est pas modifiée, le paramètre fictif est simplement retiré.
== Fonctions d'accès ==
''[[QString]] windowTitle () const''
''void setWindowTitle ( const [[QString]] & )''
Voir aussi [[#windowIcon-prop|windowIcon]], [[#windowIconText-prop|windowIconText]], [[#windowModified-prop|windowModified]] et [[#windowFilePath-prop|windowFilePath]].
=== x-prop ===
''x : const int''
Cette propriété détient les coordonnées ''x'' du widget, relatives à son parent en incluant le cadre de la fenêtre.
Regardez la documentation de la [[application-windows.html#window-geometry|géométrie de la fenêtre]] pour un aperçu des questions de géométrie avec les fenêtres.
Par défaut, cette propriété a pour valeur 0.
== Fonctions d'accès ==
''int x () const''
Voir aussi [[#frameGeometry-prop|frameGeometry]], [[#y-prop|y]] et [[#pos-prop|pos]].
=== y-prop ===
''y : const int''
Cette propriété détient les coordonnées ''y'' du widget, relatives à son parent en incluant le cadre de la fenêtre.
Regardez la documentation de la [[application-windows.html#window-geometry|géométrie de la fenêtre]] pour un aperçu des questions de géométrie avec les fenêtres.
Par défaut, cette propriété a pour valeur 0.
== Fonctions d'accès ==
''int y () const''
Voir aussi [[#frameGeometry-prop|frameGeometry]], [[#x-prop|x]] et [[#pos-prop|pos]].
==== Fonctions membres ====
=== QWidget() ===
''QWidget::QWidget ( QWidget * parent = 0, [[qt#WindowType-enum|Qt::WindowFlags]] f = 0 )''
Construit un widget enfant de ''parent'', avec les drapeaux de widgets ''f''.
Si ''parent'' est défini par 0, le nouveau widget devient une fenêtre. Si ''parent'' est un autre widget, ce widget deviendra une fenêtre enfant située à l'intérieur de ''parent''. Le nouveau widget est détruit lorsque son ''parent'' est détruit.
L'argument des drapeaux de widgets, ''f'', vaut normalement 0, mais peut être défini afin de personnaliser le cadre de la fenêtre (c'est-à-dire que ''parent'' doit être à 0). Pour personnaliser le cadre, utilisez une valeur composée de bit à bit OU par n'importe quels [[qt#WindowType-enum|drapeaux de fenêtre]].
Si vous ajoutez un widget enfant à un widget déjà visible, vous devez afficher explicitement l'enfant pour le rendre visible.
Notez qu'il est possible que les versions X11 de Qt ne puissent pas livrer toutes les combinaisons du style de drapeaux sur tous les systèmes. C'est pour cela que sous X11, Qt peut uniquement demander ces informations au gestionnaire de fenêtrage, et celui-ci peut passer outre les paramètres de l'application. Sous Windows, Qt peut définir n'importe quels drapeaux désirés.
Voir aussi [[#windowFlags-prop|windowFlags]].
=== ~QWidget() ===
''QWidget::~QWidget ()''
Détruit le widget.
Tous les enfants du widgets sont détruits en premier. L'application se termine si ce widget est le widget principal.
=== actionEvent() ===
''void QWidget::actionEvent ( [[QActionEvent]] * event ) [virtual protected]''
Le gestionnaire d'événements est appelé avec l'''event'' donné chaque fois que les actions du widget subissent des modifications.
Voir aussi [[#addAction()]], [[#insertAction()]], [[#removeAction()]], [[#actions()]] et [[QActionEvent]].
=== actions() ===
''[[QList]]<[[QAction]] *> QWidget::actions () const''
Retourne la liste (pouvant être vide) des actions du widget.
Voir aussi [[#contextMenuPolicy-prop|contextMenuPolicy]], [[#insertAction()]] et [[#removeAction()]].
=== activateWindow() ===
''void QWidget::activateWindow ()''
Définit le widget de haut niveau contenant ce widget en tant que fenêtre active.
Une fenêtre active est une fenêtre de haut niveau visible qui détient le focus d'entrée du clavier.
Cette fonction réalise la même opération que lorsque vous cliquez avec la souris sur la barre de titre d'une fenêtre de haut niveau. Sous X11, le résultat dépend du gestionnaire de fenêtrage. Si vous souhaitez vous assurer que la fenêtre est également placée au-dessus, vous devrez aussi appeler [[#raise()]]. Notez que la fenêtre doit être visible, dans le cas contraire, activateWindow() n'aura aucun effet.
Sous Windows, si vous appelez cette fonction alors que l'application n'est pas actuellement celle qui est active, alors ce widget ne deviendra pas la fenêtre active. Elle modifiera la couleur des entrées de la barre des tâches pour indiquer que la fenêtre a, en quelque sorte, été modifiée. C'est ainsi car Microsoft ne permet pas qu'une application interrompe ce que l'utilisateur est couramment en train de faire dans une autre application.
Voir aussi [[#isActiveWindow-prop|isActiveWindow()]], [[#window()]] et [[#show()]].
=== addAction() ===
''void QWidget::addAction ( [[QAction]] * action )''
Ajoute l'action ''action'' à la liste d'actions de ce widget.
Tous les QWidget détiennent une liste de [[QAction]]. Cependant, elles peuvent être représentées graphiquement de différentes manières. L'utilisation par défaut d'une liste de [[QAction]] (comme retournée par [[#actions()]]) est de créer un [[QMenu]] contextuel.
Un [[QWidget]] ne devrait posséder qu'une fois chaque action, ainsi l'ajout d'action qu'elle posséderait ne changera rien.
L'appartenance d'''action'' n'est pas transférée à ce [[QWidget]].
Voir aussi [[#removeAction()]], [[#insertAction()]], [[#actions()]] et QMenu.
=== addActions() ===
''void QWidget::addActions ( [[QList]]<[[QAction]] *> actions )''
Ajoute les actions ''actions'' à la liste d'actions de ce widget.
Voir aussi [[#removeAction()]], [[QMenu]] et [[#addAction()]].
=== adjustSize() ===
''void QWidget::adjustSize ()''
Ajuste la taille du widget pour s'adapter à son contenu.
Cette fonction utilise [[#sizeHint-prop|sizeHint()]] s'il est valide, c'est-à-dire si les indications de taille, de longueur et de largeur sont supérieures ou égales à 0. Dans le cas contraire, elle définit les dimensions du rectangle enfant couvrant la totalité des widgets enfants (l'union de tous les widgets enfants rectangulaires).
Pour les fenêtres, les dimensions de l'écran sont aussi prises en compte. Si [[#sizeHint-prop|sizeHint()]] est inférieure à (200, 100) et que la politique de dimensionnement est [[qsizepolicy#Policy-enum|expanding]], la fenêtre sera au moins de (200, 100). Les dimensions maximales d'une fenêtre sont de 2/3 de la longueur et de la largeur de l'écran.
Voir aussi [[#sizeHint-prop|sizeHint()]] et [[#childrenRect-prop|childrenRect()]].
=== backgroundRole() ===
''[[qpalette#ColorRole-enum|QPalette::ColorRole]] QWidget::backgroundRole () const''
Retourne le rôle d'arrière-plan du widget.
Le rôle d'arrière-plan définit la brosse depuis la [[#palette-prop|palette]] du widget qui est utilisée pour effectuer un rendu de l'arrière-plan.
Si aucun rôle d'arrière-plan n'est défini, le widget hérite du rôle d'arrière-plan de son widget parent.
Voir aussi [[#setBackgroundRole()]] et [[#foregroundRole()]].
=== changeEvent() ===
''void QWidget::changeEvent ( [[QEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements peut être réimplémenté pour gérer les changements de statut.
Le statut en changement dans cette fonction événement peut être récupéré par le biais de l'événement ''event''.
Les événements de changement incluent : [[qevent#Type-enum|QEvent::ToolBarChange]], [[qevent#Type-enum|QEvent::ActivationChange]], [[qevent#Type-enum|QEvent::EnabledChange]], [[qevent#Type-enum|QEvent::FontChange]], [[qevent#Type-enum|QEvent::StyleChange]], [[qevent#Type-enum|QEvent::PaletteChange]], [[qevent#Type-enum|QEvent::WindowTitleChange]], [[qevent#Type-enum|QEvent::IconTextChange]], [[qevent#Type-enum|QEvent::ModifiedChange]], [[qevent#Type-enum|QEvent::MouseTrackingChange]], [[qevent#Type-enum|QEvent::ParentChange]], [[qevent#Type-enum|QEvent::WindowStateChange]], [[qevent#Type-enum|QEvent::LanguageChange]], [[qevent#Type-enum|QEvent::LocaleChange]], [[qevent#Type-enum|QEvent::LayoutDirectionChange]].
=== childAt() ===
''QWidget * QWidget::childAt ( int x, int y ) const''
Retourne 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écifique, cette fonction retourne 0.
=== childAt() ===
''QWidget * QWidget::childAt ( const [[QPoint]] & p ) const''
Il s'agit d'une fonction membre surchargée.
Retourne le widget enfant visible au point ''p'' dans le système de coordonnées du widget.
=== clearFocus() ===
''void QWidget::clearFocus ()''
Reprend le focus d'entrée de clavier depuis le widget.
Si le widget détient un focus actif, un [[#focusOutEvent|événement de perte de focus]] est envoyé à ce widget pour lui indiquer qu'il est sur le point de perdre le focus.
Ce widget doit activer les paramètres de focus de façon à obtenir le focus d'entrée de clavier, c'est-à-dire qu'il doit appeler [[#focusPolicy-prop|setFocusPolicy()]].
Voir aussi [[#focus-prop|hasFocus()]], [[#setFocus()]], [[#focusInEvent()]], [[#focusOutEvent()]], [[#focusPolicy-prop|setFocusPolicy()]] et [[qapplication#focusWidget|QApplication::focusWidget()]].
=== clearMask() ===
''void QWidget::clearMask ()''
Retire tout masque défini par [[#setMask()]].
Voir aussi [[#setMask()]].
=== close() ===
''bool QWidget::close () [slot]''
Ferme le widget. Retourne ''true'' si le widget a été fermé ; dans le cas contraire retourne ''false''.
Tout d'abord elle envoie au widget un [[QCloseEvent]]. Le widget est [[#hide|caché]] s'il [[qevent#accept|accepte]] l'événement de fermeture. S'il [[qevent#ignore|ignore]] l'événement, rien ne se passe. L'implémentation par défaut de [[qwidget#closeEvent|QWidget::closeEvent()]] accepte l'événement de fermeture.
Si le widget détient le drapeau [[qt#WidgetAttribute-enum|Qt::WA_DeleteOnClose]], le widget est également supprimé. Un événement de fermeture est livré au widget, peu importe si le widget est visible ou non.
Le signal [[qapplication#lastWindowClosed|QApplication::lastWindowClosed()]] est émis quand la dernière fenêtre principale visible (c'est-à-dire une fenêtre sans parent) avec l'attribut [[qt#WidgetAttribute-enum|Qt::WA_QuitOnClose]] défini est fermée. Par défaut, cet attribut est défini pour toutes les fenêtres exceptées les fenêtre fugitives telles que les fenêtres d'attentes, fenêtres d'outils et les menus surgissants.
=== closeEvent() ===
''void QWidget::closeEvent ( [[QCloseEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements est appelé avec l'''event'' donné lorsque Qt reçoit une requête de fermeture du widget de haut niveau depuis le système de fenêtrage.
Par défaut, l'événement est accepté et la fenêtre est fermée. Vous pouvez réimplémenter cette fonction pour modifier la façon de répondre du widget envers les requêtes de fermeture. Par exemple, vous pouvez empêcher la fenêtre d'être fermée par l'appel de [[#ignore()]] sur tous les événements.
Les fenêtres principales d'applications utilisent généralement des réimplémentations de cette fonction afin de vérifier que le travail de l'utilisateur a bien été sauvegardé et de demander la permission avant la fermeture. Par exemple, [[mainwindows-application|l'exemple Application]] utilise une fonction pour déterminer si, oui ou non, la fenêtre doit être fermée :
void MainWindow::closeEvent(QCloseEvent *event)
{
if (maybeSave())
{
writeSettings();
event->accept();
}
else
{
event->ignore();
}
}
Voir aussi [[#event()]], [[#hide()]], [[#close()]], [[QCloseEvent]] et [[mainwindows-application|l'exemple Application]].
=== contentsMargins() ===
''[[QMargins]] QWidget::contentsMargins () const''
Cette fonction retourne les marges de contenu du widget.
Cette fonction a été introduite dans Qt 4.6.
Voir aussi [[#getContentsMargins()]], [[#setContentsMargins()]] et [[#contentsRect()]].
=== contentsRect() ===
''[[QRect]] QWidget::contentsRect () const''
Retourne la zone située à l'intérieur des marges du widget.
Voir aussi [[#setContentsMargins()]] et [[#getContentsMargins()]].
=== contextMenuEvent() ===
''void QWidget::contextMenuEvent ( [[QContextMenuEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements, pour l'événement ''event'', peut être réimplémenté dans une sous-classe afin de recevoir les événements de menus contextuels du widget.
Le gestionnaire est appelé lorsque la [[#contextMenuPolicy-prop|contextMenuPolicy]] du widget est à [[qt#ContextMenuPolicy-enum|Qt::DefaultContextMenu]].
L'implémentation par défaut ignore les événements contextuels. Regardez la documentation de [[QContextMenuEvent]] pour plus de détails.
Voir aussi [[#event()]], [[QContextMenuEvent]] et [[#customContextMenuRequested()]].
=== create() ===
''void QWidget::create ( [[#WId-typedef|WId]] window = 0, bool initializeWindow = true, bool destroyOldWindow = true ) [protected]''
Crée un nouveau widget fenêtré si ''window'' est à 0, dans le cas contraire, définit la fenêtre du widget à ''window''.
Initialise la fenêtre (définit la géométrie, etc.) si ''initializeWindow'' est ''true''. S'il est ''false'', aucune initialisation n'est réalisée. Ce paramètre n'est valable que si ''window'' est une fenêtre valide.
Détruit l'ancienne fenêtre si ''destroyOldWindow'' est ''true''. S'il est ''false'', vous êtes responsable de la destruction de la fenêtre (en utilisant le code natif de la plateforme).
Le constructeur de [[QWidget]] appelle create(0, true, true) pour créer une fenêtre pour ses widgets.
=== customContextMenuRequested() ===
''void QWidget::customContextMenuRequested ( const [[QPoint]] & pos ) [signal]''
Ce signal est émis lorsque la [[#contextMenuPolicy-prop|contextMenuPolicy]] du widget est à [[qt#ContextMenuPolicy-enum|Qt::CustomContextMenu]] et que l'utilisateur a demandé un menu contextuel sur le widget. La position ''pos'' est la position de l'événement du menu contextuel que le widget reçoit. A priori, elle se trouve dans les coordonnées du widget. L'exception à la règle est [[QAbstractScrollArea]] ainsi que ses sous-classes qui placent l'événement de menu contextuel aux coordonnées du [[qabstractscrollarea#viewport|viewport()]].
Voir aussi [[#mapToGlobal()]], [[QMenu]] et [[#contextMenuPolicy-prop|contextMenuPolicy]].
=== destroy() ===
''void QWidget::destroy ( bool destroyWindow = true, bool destroySubWindows = true ) [protected]''
Libère les ressources système utilisées par la fenêtre. Détruit la fenêtre si ''destroyWindow'' est ''true''.
destroy() s'appelle lui-même récursivement pour tous les widgets enfants, en passant ''destroySubWindows'' en tant que paramètre ''destroyWindow''. Pour avoir un meilleur contrôle de la destruction des widgets enfants, détruisez-les d'abord sélectivement.
Cette fonction est couramment appelée depuis le destructeur de [[QWidget]].
=== dragEnterEvent() ===
''void QWidget::dragEnterEvent ( [[QDragEnterEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements est appelé lorsqu'un glissement est en cours et que la souris entre dans ce widget. L'événement est passé dans le paramètre ''event''.
Si l'événement est ignoré, le widget ne recevra aucun événement de [[#dragMoveEvent|mouvement par glissement]].
Regardez la documentation du [[dnd|glisser-déposer]] pour avoir un aperçu de la façon de fournir du glisser-et-déposer dans votre application.
Voir aussi [[QDrag]] et [[QDragEnterEvent]].
=== dragLeaveEvent() ===
''void QWidget::dragLeaveEvent ( [[QDragLeaveEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements est appelé lorsqu'un glissement est en cours et que la souris quitte ce widget. L'événement est passé dans le paramètre ''event''.
Regardez la documentation du [[dnd|glisser-déposer]] pour avoir un aperçu de la façon de fournir du glisser-et-déposer dans votre application.
Voir aussi [[QDrag]] et [[QDragLeaveEvent]].
=== dragMoveEvent() ===
''void QWidget::dragMoveEvent ( [[QDragMoveEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements est appelé si un glissement est en cours et quand l'une des conditions suivantes se produit : le curseur entre dans ce widget, il se déplace à l'intérieur de ce widget, ou une touche de modification est enfoncée lorsque le widget détient le focus. L'événement est passé dans le paramètre ''event''.
Regardez la documentation du [[dnd|glisser-déposer]] pour avoir un aperçu de la façon de fournir du glisser-et-déposer dans votre application.
Voir aussi [[QDrag]] et [[QDragMoveEvent]].
=== dropEvent() ===
''void QWidget::dropEvent ( [[QDropEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements est appelé lorsque l'élément glissé est déposé dans ce widget. L'événement est passé dans le paramètre ''event''.
Regardez la documentation du [[dnd|glisser-déposer]] pour avoir un aperçu de la façon de fournir du glisser-et-déposer dans votre application.
Voir aussi [[QDrag]] et [[QDropEvent]].
=== effectiveWinId() ===
''[[#WId-typedef|WId]] QWidget::effectiveWinId () const''
Retourne l'identifiant valide du système de fenêtrage du widget, c'est-à-dire l'identifiant natif parent du système de fenêtrage.
Si le widget est natif, cette fonction retourne l'ID native du widget, mais dans le cas contraire, c'est l'ID de fenêtre du premier parent natif, cela signifie que le widget de haut niveau qui contient ce widget, est retourné.
**Note :** nous vous recommandons de ne pas enregistrer cette valeur car elle est susceptible de changer à l'exécution.
Cette fonction a été introduite dans Qt 4.4.
Voir aussi [[#nativeParentWidget()]].
=== ensurePolished() ===
''void QWidget::ensurePolished () const''
Assure que le widget a été poli par [[QStyle]] (c'est-à-dire qu'il détient une police et une palette appropriées).
[[QWidget]] appelle cette fonction après avoir été complètement construit mais juste avant d'avoir été affiché 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 pourrait être nécessaire dans la réimplémentation de [[#sizeHint-prop|sizeHint()]]. Notez que cette fonction //est// appelée depuis l'implémentation par défaut de [[#sizeHint-prop|sizeHint()]].
Le polissage est utile pour l'initialisation finale qui doit se produire après que tous les constructeurs (depuis les classes de base aussi bien que depuis les sous-classes) ont été appelés.
Si vous avez besoin de modifier des paramètres lorsqu'un widget est poli, réimplémentez [[#event()]] et gérez l'événement de type [[qevent#Type-enum|QEvent::Polish]].
**Note :** la fonction est déclarée const de sorte qu'elle puisse être appelée depuis d'autres fonctions const (par exemple, [[#sizeHint-prop|sizeHint()]]).
Voir aussi [[#event()]].
=== enterEvent() ===
''void QWidget::enterEvent ( [[QEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements peut être réimplémenté dans des sous-classes afin de recevoir des événements d'entrée passés dans le paramètre ''event''.
Un événement est envoyé au widget lorsque le curseur de la souris entre dans celui-ci.
Voir aussi [[#leaveEvent()]], [[#mouseMoveEvent()]] et [[#event()]].
=== event() ===
''bool QWidget::event ( [[QEvent]] * event ) [virtual protected]''
Réimplémentation de [[qobject#event|QObject::event()]].
C'est le gestionnaire principal d'événements ; il gère l'événement ''event''. Vous pouvez réimplémenter cette fonction dans une sous-classe, mais nous recommandons d'utiliser un autre des gestionnaires d'événements spécialisés au lieu de cela.
Les événements de touches pressées et relachées sont traités différemment depuis d'autres événements. event() contrôle **Tab** et **Shift+Tab** et tente de déplacer le focus correctement. S'il n'y a pas de widget où déplacer le focus (ou si la touche enfoncée n'est pas **Tab** ou **Shift+Tab**), event() appelle [[#keyPressEvent()]].
La gestion de la souris et de la tablette est aussi légèrement différente : uniquement lorsque le widget est [[#enabled-prop|activé]], la fonction event() appellera un gestionnaire spécialisé tel que [[#mousePressEvent()]] ; dans le cas contraire elle rejettera l'événement.
Cette fonction retourne ''true'' si l'événement a été reconnu, sinon elle retourne ''false''. Si l'événement reconnu a été accepté (voir [[qevent#accepted-prop|QEvent::accepted]]), tout autre traitement comme la propagation d'événements au widget parent s'arrête.
Voir aussi [[#closeEvent()]], [[#focusInEvent()]], [[#focusOutEvent()]], [[#enterEvent()]], [[#keyPressEvent()]], [[#keyReleaseEvent()]], [[#leaveEvent()]], [[#mouseDoubleClickEvent()]], [[#mouseMoveEvent()]], [[#mousePressEvent()]], [[#mouseReleaseEvent()]], [[#moveEvent()]], [[#paintEvent()]], [[#resizeEvent()]], [[qobject#event|QObject::event()]] et [[qobject#timerEvent|QObject::timerEvent()]].
=== find() ===
''QWidget * QWidget::find ( [[#WId-typedef|WId]] id ) [static]''
Retourne un pointeur sur le widget avec l'identifiant/le gestionnaire de fenêtre ''id''.
Le type d'identifiant de fenêtre dépend du système de fenêtre sous-jacent, regardez ''qwindowdefs.h'' pour la définition actuelle. S'il n'y a pas de widget référant à cet identifiant, 0 est retourné.
=== focusInEvent() ===
''void QWidget::focusInEvent ( [[QFocusEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements peut être réimplémenté dans des sous-classes afin de recevoir des événements de focus de clavier(focus reçu) pour le widget. L'événement est passé par le paramètre ''event''.
Un widget doit normalement définir [[#focusPolicy-prop|setFocusPolicy()]] à quelque chose d'autre que [[qt#FocusPolicy-enum|Qt::NoFocus]] de manière à recevoir les événements de focus. Notez que le programmeur de l'application peut appeler [[#setFocus()]] sur tout widget, même ceux qui n'acceptent normalement pas le focus.
L'implémentation par défaut actualise le widget (à l'exception des fenêtres qui ne spécifient pas une [[#focusPolicy-prop|focusPolicy()]]).
Voir aussi [[#focusOutEvent()]], [[#focusPolicy-prop|setFocusPolicy()]], [[#keyPressEvent()]], [[#keyReleaseEvent()]], [[#event()]] et [[QFocusEvent]].
=== focusNextChild() ===
''bool QWidget::focusNextChild () [protected]''
Trouve un nouveau widget auquel donner le focus du clavier, comme approprié pour **Tab** et retourne ''true'' s'il peut en trouver un, sinon retourne ''false''.
Voir aussi [[#focusPreviousChild()]].
=== focusNextPrevChild() ===
''bool QWidget::focusNextPrevChild ( bool next ) [virtual protected]''
Trouve un nouveau widget auquel donner le focus du clavier, comme approprié pour **Tab** et **Shift+Tab**, et retourne ''true'' s'il peut en trouver un, sinon retourne ''false''.
Si ''next'' est ''true'', cette fonction recherche vers l'avant, sinon elle recherche vers l'arrière.
Quelquefois, vous aurez envie de réimplémenter cette fonction. Par exemple, un navigateur Web pourrait la réimplémenter afin de déplacer son "lien actif actuel" vers l'avant ou l'arrière, et appeler focusNextPrevChild() seulement lorsqu'il atteint le dernier ou le premier lien sur la "page".
Les widgets enfants appellent focusNextPrevChild() sur leurs widgets parents, mais c'est uniquement la fenêtre qui contient les widgtets enfants décide où rediriger le focus. Par réimplémentation de cette fonction pour un objet, vous gagnez aussi le contrôle du focus traversal pour tous les widgets enfants.
Voir aussi [[#focusNextChild()]] et [[#focusPreviousChild()]].
=== focusOutEvent() ===
''void QWidget::focusOutEvent ( [[QFocusEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir des événements de focus du clavier(focus perdu) pour le widget. L'événement est passé par le paramètre ''event''.
Un widget doit normalement définir [[#focusPolicy-prop|setFocusPolicy()]] à quelque chose d'autre que [[qt#FocusPolicy-enum|Qt::NoFocus]] de manière à recevoir les événements de focus. Notez que le programmeur de l'application peut appeler [[#setFocus()]] sur tout widget, même ceux qui n'acceptent normalement pas le focus.
L'implémentation par défaut actualise le widget (excepté pour les fenêtres qui ne spécifient pas une [[#focusPolicy-prop|focusPolicy()]]).
Voir aussi [[#focusInEvent()]], [[#focusPolicy-prop|setFocusPolicy()]], [[#keyPressEvent()]], [[#keyReleaseEvent()]], [[#event()]] et [[QFocusEvent]].
=== focusPreviousChild() ===
''bool QWidget::focusPreviousChild () [protected]''
Trouve un nouveau widget auquel donner le focus de clavier, comme approprié pour **Shift+Tab** et retourne ''true'' s'il peut en trouver un, sinon retourne ''false''.
Voir aussi [[#focusNextChild()]].
=== focusProxy() ===
''QWidget * QWidget::focusProxy () const''
Retourne le proxy du focus, ou 0 s'il n'y en a pas.
Voir aussi [[setFocusProxy()]].
=== focusWidget() ===
''QWidget * QWidget::focusWidget () const''
Retourne le dernier enfant de ce widget sur lequel setFocus a été appelé. Pour les widgets de haut-niveau, c'est le widget qui recevra le focus dans le cas où cette fenêtre s'activerait.
Ce n'est pas la même chose que [[qapplication#focusWidget|QApplication::focusWidget()]], qui retourne le widget ayant le focus dans la fenêtre active.
=== fontInfo() ===
''[[QFontInfo]] QWidget::fontInfo () const''
Retourne l'information de police pour l'actuelle police du widget. C'est l'équivalent de [[QFontInto]](widget->[[#font-prop|font()]]).
Voir aussi [[#font-prop|font()]], [[#fontMetrics()]] et [[#font-prop|setFont()]].
=== fontMetrics() ===
''[[QFontMetrics]] QWidget::fontMetrics () const''
Retourne les métriques de police pour l'actuelle police du widget. C'est l'équivalent de [[QFontMetrics]](widget->[[#font-prop|font()]]).
Voir aussi [[#font-prop|font()]], [[#fontInfo()]] et [[#font-prop|setFont()]].
=== foregroundRole() ===
''[[qpalette#ColorRole-enum|QPalette::ColorRole]] QWidget::foregroundRole () const''
Retourne le rôle du premier plan.
Le rôle du premier plan définit la couleur depuis la [[#palette-prop|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 retourne un rôle qui diffère du rôle de fond.
Voir aussi [[#setForegroundRole()]] et [[#backgroundRole()]].
=== getContentsMargins() ===
''void QWidget::getContentsMargins ( int * left, int * top, int * right, int * bottom ) const''
Retourne les marges du contenu du widget pour ''left'', ''top'', ''right'' et ''bottom''.
Voir aussi [[#setContentsMargins()]] et [[#contentsRect()]].
=== getDC() ===
''HDC QWidget::getDC () const [virtual]''
Retourne le gestionnaire du système de fenêtrage du widget, pour un accès de bas niveau. L'utilisation de cette fonction n'est pas portable.
Un HDC saisi avec getDC() doit être libéré avec [[#releaseDC()]].
**Attention :** l'utilisation de cette fonction n'est pas portable.
=== grabGesture() ===
''void QWidget::grabGesture ( [[qt#GestureType-enum|Qt::GestureType]] gesture, [[qt#GestureFlag-enum|Qt::GestureFlags]] flags = Qt::GestureFlags() )''
Inscrit le widget à un geste donné avec des drapeaux spécifiques.
Cette fonction a été introduite dans Qt 4.6.
Voir aussi [[#ungrabGesture()]] et [[QGestureEvent]].
=== grabKeyboard() ===
''void QWidget::grabKeyboard ()''
Saisit les entrées du clavier.
Ce widget reçoit la totalité des événements du clavier jusqu'à ce que [[#releaseKeyboard()]] soit appelé ; les autres widgets n'obtiennent aucun événement de ce type. Les événements de la souris ne sont pas affectés, utilisez [[#grabMouse()]] si vous voulez les saisir.
Le widget ayant le focus n'est pas affecté, sauf s'il ne reçoit pas d'événements du clavier. [[#setFocus()]] déplace le focus comme d'habitude, mais un nouveau widget l'ayant ne reçoit les événements du clavier qu'après que [[#releaseKeyboard()]] soit appelé.
Si un widget différent est actuellement en train de recevoir des saisies du clavier, ces saisies sont d'abord libérées.
Voir aussi [[#releaseKeyboard()]], [[#grabMouse()]], [[#releaseMouse()]] et [[#focusWidget()]].
=== grabMouse() ===
''void QWidget::grabMouse ()''
Saisit les entrées de la souris.
Ce widget reçoit les événements de la souris jusqu'à ce que [[#releaseMouse()]] soit appelé ; les autres widgets n'obtiennent pas un seul événement de ce type. Les événements du clavier ne sont pas affectés, utilisez [[#grabMouse()]] si vous voulez les saisir.
**Attention :** des bugs dans les applications de saisie de la souris verrouillent très souvent le terminal. Utilisez cette fonction avec une extrême prudence, et envisagez d'utiliser l'option de la ligne de commande ''-nograb'' pendant le déboguage.
Il n'est, la plupart du temps, pas nécessaire de saisir les événements de la souris lors d'utilisation de Qt, comme Qt saisit et libère cela sensiblement. En particulier, Qt saisit les événements de la souris lorsqu'un bouton de la souris est enfoncé et le garde jusqu'à ce qu'il soit relâché.
**Note :** seuls les widgets visibles peuvent saisir les entrées de la souris. Si [[#visible-prop|isVisible()]] retourne ''false'' pour un widget, ce widget ne pourra pas appeler grabMouse().
**Note :** (développeurs Mac OS X) pour Cocoa, appeler grabMouse() sur un widget fonctionne uniquement lorsque la souris est à l'intérieur du cadre du widget. Pour Carbon, cela marche également en dehors du cadre du widget, comme pour Windows et X11.
Voir aussi [[#releaseMouse()]], [[#grabKeyboard()]] et [[#releaseKeyboard()]].
=== grabMouse() ===
''void QWidget::grabMouse ( const QCursor & cursor )''
Cette fonction est une surcharge de [[#grabMouse()]].
Saisit les entrées de la souris et change la forme du curseur.
Le curseur endossera 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é.
**Attention :** la saisie les événements de la souris peut verrouiller le terminal.
**Note :** (développeurs Mac OS X) regarder la note dans [[#grabMouse|QWidget::grabMouse()]].
Voir aussi [[#releaseMouse()]], [[#grabKeyboard()]], [[#releaseKeyboard()]] et [[#setCursor()]].
=== grabShortcut() ===
''int QWidget::grabShortcut ( const [[QKeySequence]] & key, [[qt#ShortcutContext-enum|Qt::ShortcutContext]] context = Qt::WindowShortcut )''
Ajoute un raccourci au système de raccourcis de Qt qui surveille la séquence ''key'' dans le ''context'' donné. Si le ''context'' est [[qt#ShortcutContext-enum|Qt::ApplicationShortcut]], le raccourci s'applique à l'application dans son ensemble. Dans le cas contraire, il est local à ce widget, [[qt#ShortcutContext-enum|Qt::WidgetShortcut]], ou à la fenêtre elle-même, [[qt#ShortcutContext-enum|Qt::WindowShortcut]].
Si la même séquence de touches (''key'') a été saisie par d'autres widgets, lorsqu'elle a lieu, un [[qevent#Type-enum|QEvent::Shortcut]] est envoyé à tous les widgets auxquels il s'applique, dans un ordre non déterministe, mais avec le drapeau "ambigu" défini à ''true''.
**Attention :** vous ne devez normalement pas avoir besoin d'utiliser cette fonction ; au lieu de cela, créez des [[QAction]]s, avec la séquence de touches de raccourci dont vous avez besoin (si vous voulez aussi des options de menu équivalentes et des boutons de barre d'outils), ou créez des [[QShortcut]] si vous n'avez besoin que de ces séquences de touches. [[QAction]] et [[QShortcut]] gèrent totalement l'événement filtrant pour vous, et fournissent des signaux qui sont déclenchés lorsque l'utilisateur envoie la séquence de touches, donc il est bien plus simple de vous servir de cela plutôt que de cette fonction de bas niveau.
Voir aussi [[#releaseShortcut()]] et [[#setShortcutEnabled()]].
=== graphicsEffect() ===
''QGraphicsEffect * QWidget::graphicsEffect () const''
Cette fonction retourne un pointeur sur l'effet graphique du widget.
Si le widget n'a pas d'effet graphique, 0 est retourné.
Cette fonction a été introduite dans Qt 4.6.
Voir aussi [[#setGraphicsEffect()]].
=== graphicsProxyWidget() ===
''[[QGraphicsProxyWidget]] * QWidget::graphicsProxyWidget () const''
Retourne le widget proxy pour le widget embarqué correspondant dans une vue graphique ; sinon retourne 0.
Cette fonction a été introduite dans Qt 4.5.
Voir aussi [[qgraphicsproxywidget#createProxyForChildWidget|QGraphicsProxyWidget::createProxyForChildWidget()]] et [[qgraphicsscene#addWidget|QGraphicsScene::addWidget()]].
=== hasEditFocus() ===
''bool QWidget::hasEditFocus () const''
Retourne ''true'' si le widget détient actuellement le focus ; sinon ''false''.
Cette propriété est uniquement disponible dans Qt pour Linux embarqué.
Voir aussi [[qwidget#setEditFocus|setEditFocus()]] et [[qapplication#keypadNavigationEnabled|QApplication::keypadNavigationEnabled()]].
=== heightForWidth() ===
''int QWidget::heightForWidth ( int w ) const [virtual]''
Retourne la hauteur privilégiée pour ce widget, en donnant la longueur ''w''.
Si ce widget possède un layout, l'implémentation par défaut retourne la hauteur privilégiée du layout. S'il n'y a pas de layout, l'implémentation par défaut retourne -1, indiquant que la hauteur privilégiée ne dépend pas de la longueur.
=== hide() ===
''void QWidget::hide () [slot]''
Masque le widget. Cette fonction est l'équivalent de setVisible(false).
**Note :** si vous travaillez avec [[QDialog]] ou une de ses sous-classes et que vous invoquez ensuite la fonction [[#show()]], la boîte de dialogue sera affichée dans sa position originale.
Voir aussi [[#hideEvent()]], [[#isHidden()]], [[#show()]], [[#visible-prop|setVisible()]], [[#visible-prop|isVisible()]] et [[#close()]].
=== hideEvent() ===
''void QWidget::hideEvent ( [[QHideEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe afin de recevoir les événements de masquage de widgets. Cet événement est passé dans le paramètre ''event''.
Les événements de masquage sont envoyés immédiatement aux widgets après qu'ils soient masqués.
**Note :** un widget reçoit spontanément les événements d'affichage et de masquage lorsque son statut de repérage est changé par le système de fenêtrage, par exemple, un événement spontané de masquage lorsque l'utilisateur minimise la fenêtre, et un événement spontané d'affichage lorsque la fenêtre est de nouveau restaurée. Après la réception d'événements spontanés de masquage, un widget est encore considéré visible dans le sens de [[#visible-prop|isVisible()]].
Voir aussi [[#visible-prop|visible]], [[#event()]] et [[QHideEvent]].
=== inputContext() ===
''[[QInputContext]] * QWidget::inputContext ()''
Cette fonction retourne le [[QInputContext]] pour ce widget. Par défaut le contexte d'entrée est hérité depuis les widgets parents. Les widgets de haut niveau sont hérités depuis [[QApplication]].
Vous pouvez ignorer cela et définir un contexte d'entrée spécial à ce widget par l'utilisation de la méthode [[#setInputContext()]].
Voir aussi [[#setInputContext()]].
=== inputMethodEvent() ===
''void QWidget::inputMethodEvent ( [[QInputMethodEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements, pour l'événement ''event'', peut être réimplémenté dans une sous-classe pour recevoir les événements de méthode d'entrée. Ce gestionnaire est appelé lorsque le statut de la méthode d'entrée change.
Notez que lors de la création de widgets d'édition de texte, l'attribut de fenêtre [[qt#WidgetAttribute-enum|Qt::WA_InputMethodEnabled]] doit être défini explicitement (en utilisant la fonction [[#setAttribut()]]) dans le but de recevoir des événements de méthode d'entrée.
L'implémentation par défaut appelle event->ignore(), qui rejette l'événement de méthode d'entrée. Regardez la documentation de [[QInputMethodEvent]] pour plus de détails.
Voir aussi [[#event()]] et [[QInputMethodEvent]].
=== inputMethodQuery() ===
''[[QVariant]] QWidget::inputMethodQuery ( [[qt#InputMethodQuery-enum|Qt::InputMethodQuery]] query ) const [virtual]''
Cette méthode est seulement appropriée pour des widgets d'entrée. Elle est utilisée par la méthode d'entrée pour enquérir un ensemble de propriétés du widget dans l'objectif de supporter des opérations de méthodes d'entrée complexes comme le support pour le texte et les reconversions environnantes.
''query'' spécifie quelle propriété est requise.
Voir aussi [[#inputMethodEvent()]], [[QInputMethodEvent]], [[QInputContext]] et [[#inputMethodHints-prop|inputMethodHints]].
=== insertAction() ===
''void QWidget::insertAction ( [[QAction]] * before, [[QAction]] * action )''
Insère l'action ''action'' à la liste d'actions du widget, avant l'action ''before''. Cette fonction ajoute l'action si ''before'' est 0 ou si ''before'' n'est pas une action valide pour ce widget.
Un [[QWidget]] devrait uniquement avoir une seule fois chaque action.
Voir aussi [[#removeAction()]]]], [[#addAction()]], [[QMenu]], [[#contextMenuPolicy-prop|contextMenuPolicy]] et [[#actions()]].
=== insertActions() ===
''void QWidget::insertActions ( [[QAction]] * before, [[QList]]<[[QAction]] *> actions )''
Insère les actions ''actions'' à la liste d'actions de ce widget, avant l'action ''before''. Cette fonction ajoute les actions si ''before'' est 0 ou si ''before'' n'est pas une action valide pour ce widget.
Un [[QWidget]] peut avoir au plus une seule fois chaque action.
Voir aussi [[#removeAction()]], [[QMenu]], [[#insertAction()]] et [[#contextMenuPolicy-prop|contextMenuPolicy]].
=== isAncestorOf() ===
''bool QWidget::isAncestorOf ( const QWidget * child ) const''
Retourne ''true'' si le widget est un widget parent, (ou grand-parent et ainsi à tous les niveaux), de l'enfant ''child'' donné, et si les deux widgets sont à l'intérieur de la même fenêtre ; sinon retourne ''false''.
=== isEnabledTo() ===
''bool QWidget::isEnabledTo ( QWidget * ancestor ) const''
Retourne ''true'' si ce widget pourrait devenir activé si ''ancestor'' l'est ; sinon retourne ''false''.
C'est le cas si, ni le widget lui-même ni tout parent, mais excluant ''ancestor'', ont été explicitement désactivés.
isEnableTo(0) est l'équivalent de [[#enabled-prop|isEnabled()]].
Voir aussi [[#enabled-prop|setEnabled()]] et [[#enabled-prop|enabled]].
=== isHidden() ===
''bool QWidget::isHidden () const''
Retourne ''true'' si le widget est masqué, sinon retourne ''false''.
Un widget caché ne deviendra visible que lorsque [[#show()]] sera appelé dessus. Il ne sera pas automatiquement affiché quand le parent le sera.
Pour vérifier la visibilité, utilisez ![[#visible-prop|isVisible()]] au lieu de cette fonction (notez le point d'exclamation).
isHidden() implique ![[#visible-prop|isVisible()]], mais un widget peut ne pas être visible ni masqué au même moment. C'est le cas pour les widgets qui sont enfants de widgets non visibles.
Les widgets sont masqués si :
* ils ont été créés comme des fenêtres indépendantes ;
* ils ont été créés comme des enfants de widgets visibles ;
* [[#hide()]] ou setVisible(false) ont été appelés.
=== isVisibleTo() ===
''bool QWidget::isVisibleTo ( QWidget * ancestor ) const''
Retourne ''true'' si le widget pourrait devenir visible si ''ancestor'' est affiché ; sinon retourne ''false''.
Le cas ''true'' a lieu si, ni le widget lui-même ni son parent, mais excluant ''ancestor'', ont été explicitement masqués.
Cette fonction retournera toujours ''true'' si le widget est recouvert par une autre fenêtre à l'écran, mais peut être physiquement visible, si elle devait être déplacée.
isVisible(0) est identique à [[#visible-prop|isVisible()]].
Voir aussi [[#show()]], [[#hide()]] et [[#visible-prop|isVisible()]].
=== isWindow() ===
''bool QWidget::isWindow () const''
Retourne ''true'' si le widget est une fenêtre indépendante ; sinon retourne ''false''.
Une fenêtre est un widget qui n'est pas visuellement l'enfant d'un autre widget et qui a habituellement un cadre et un [[#windowTitle-prop|titre de fenêtre]].
Une fenêtre peut avoir un [[#parentWidget|widget parent]]. Elle sera alors groupée avec son parent et supprimée quand le parent sera supprimé, minimisée lorsque le parent sera minimisé, etc. Si cela est supporté par le gestionnaire de fenêtrage, elle aura de même une entrée dans la barre de tâches avec son parent.
Les widgets [[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 le drapeau [[qt#WindowType-enum|Qt::Window]].
Voir aussi [[#window()]], [[#modal-prop|isModal()]] et [[#parentWidget()]].
=== keyPressEvent() ===
''void QWidget::keyPressEvent ( [[QKeyEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements, pour l'événement ''event'', peut être réimplémenté dans des sous-classes pour recevoir des événements d'enfoncement de touche pour le widget.
Un widget doit définir [[#focusPolicy-prop|setFocusPolicy()]] pour accepter initialement le focus dans le but de recevoir des événements d'enfoncement de touche.
Si vous réimplémentez ce gestionnaire, il est très important que vous appeliez l'implémentation de base de la classe si vous n'agissez pas sur la touche.
L'implémentation par défaut ferme les widgets surgissants si l'utilisateur presse ''Echap''. Dans le cas contraire, l'événement sera ignoré, de sorte que le parent du widget puisse l'interpréter.
Notez que [[QKeyEvent]] débute avec isAccepted() == true, donc vous n'aurez pas à appeler [[qevent#accept|QKeyEvent::accep()]]. N'appelez pas l'implémentation de base de classe si vous agissez juste sur la touche.
Voir aussi [[#keyReleaseEvent()]], [[#focusPolicy-prop|setFocusPolicy()]], [[#focusInEvent()]], [[#focusOutEvent()]], [[#event()]], [[QKeyEvent]] et [[widgets-tetrix|l'exemple Tetrix]].
=== keyReleaseEvent() ===
''void QWidget::keyReleaseEvent ( [[QKeyEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements, pour l'événement ''event'', peut être réimplémenté dans des sous-classes pour recevoir des événements de relâchement de touche pour le widget.
Un widget doit initilement [[#focusPolicy-prop|accepter le focus]] et [[#focus-prop|détenir le focus]] afin de recevoir les événements de relâchement de touche.
Si vous réimplémentez ce gestionnaire, il est très important que vous appeliez l'implémentation de base de la classe si vous n'agissez pas sur la touche.
L'implémentation par défaut ignore l'événement, de sorte que le widget parent puisse l'interpréter.
Notez que [[QKeyEvent]] débute avec isAccepted() == true, donc vous n'aurez pas à appeler [[qevent#accept|QKeyEvent::accep()]] - n'appelez pas l'implémentation de base de classe si vous agissez juste sur la touche.
Voir aussi [[#keyPressEvent()]], [[qevent#ignore|QKeyEvent::ignore()]], [[#focusPolicy-prop|setFocusPolicy()]], [[#focusInEvent()]], [[#focusOutEvent()]], [[#event()]] et [[QKeyEvent]].
=== keyboardGrabber() ===
''QWidget * QWidget::keyboardGrabber () [static]''
Retourne le widget qui est actuellement en train recevoir la saisie d'entrée du clavier.
Si aucun widget dans cette application n'est actuellement en train de recevoir la saisie du clavier, 0 est retourné.
Voir aussi [[#grabMouse()]] et [[#mouseGrabber()]].
=== layout() ===
''[[QLayout]] * QWidget::layout () const''
Retourne le gestionnaire de layout qui est installé sur ce widget, ou 0 si aucun gestionnaire de layout n'est installé.
Le gestionnaire de layout définit la géométrie des enfants du widget ayant été ajoutés au layout.
Voir aussi [[#setLayout()]], [[#sizePolicy-prop|sizePolicy()]] et [[layout|gestion des layout]].
=== leaveEvent() ===
''void QWidget::leaveEvent ( [[QEvent]] * event ) [virtual protected]''
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 passés par le paramètre ''event''.
Un événement de départ est envoyé au widget lorsque le curseur de la souris quitte le widget.
Voir aussi [[#enterEvent()]], [[#mouseMoveEvent()]] et [[#event()]].
=== lower() ===
''void QWidget::lower () [slot]''
Abaisse le widget au bas de la pile du widget parent.
Après cet appel le widget sera visuellement derrière (et donc recouvert par) tout widget enfant de même parent superposant.
Voir aussi [[#raise()]] et [[#stackUnder()]].
=== macCGHandle() ===
''[[qt#HANDLE-typedef|Qt::HANDLE]] QWidget::macCGHandle () const''
Retourne le gestionnaire de CoreGraphics du widget. Utiliser cette fonction n'est pas portable. Cette fonction retournera 0 si aucun contexte de peinture ne peut être établi, ou si le gestionnaire ne peut être créé.
**Attention :** cette fonction est seulement disponible sous Mac OS X.
=== macEvent() ===
''bool QWidget::macEvent ( EventHandlerCallRef caller, EventRef event ) [virtual protected]''
Ce gestionnaire d'événements spécial peut être réimplémenté dans une sous-classe pour recevoir les événements natifs de Macintosh.
Les paramètres sont quelque peu différents, selon que Qt est compilé sous Carbon ou Cocoa. Sous Carbon, ''caller'' et ''event'' sont les EventHandlerCallRef et EventRef qui correspondent aux gestionnaires d'événements de Carbon étant installés. Sous Cocoa, ''caller'' est toujours 0 et l'EventRef est l'EventRef généré depuis le NSEvent.
Dans votre réimplémentation de cette fonction, si vous souhaitez stopper le fait que les événements sont gérés par Qt, retournez ''true''. Si vous retournez ''false'', cet événement natif est repassé à Qt, qui le traduit dans un événement de Qt et l'envoie au widget.
**Attention :** cette fonction n'est pas portable.
**Attention :** cette fonction n'est pas appelée dans Qt jusqu'à Qt 4.4. Si vous avez besoin de la compatibilité avec les versions antérieures de Qt, considérez plutôt [[qapplication#macEventFilter|QApplication::macEventFilter()]].
Voir aussi [[qapplication#macEventFilter|QApplication::macEventFilter()]].
=== macQDHandle() ===
''[[qt#HANDLE-typedef|Qt::HANDLE]] QWidget::macQDHandle () const''
Retourne le gestionnaire de QuickDraw du widget. Utiliser cette fonction n'est pas portable. Cette fonction retournera 0 si QuickDraw n'est pas supporté, ou si le gestionnaire ne peut être créé.
**Attention :** cette fonction est seulement disponible sous Mac OS X.
=== mapFrom() ===
''[[QPoint]] QWidget::mapFrom ( QWidget * parent, const [[QPoint]] & pos ) const''
Traduit les coordonnées ''pos'' depuis le système de coordonnées de ''parent'' à celui du widget. Le ''parent'' ne doit pas être 0 et doit être un parent du widget appelé.
Voir aussi [[#mapTo()]], [[#mapFromParent()]], [[#mapFromGlobal()]] et [[#underMouse()]].
=== mapFromGlobal() ===
''[[QPoint]] QWidget::mapFromGlobal ( const [[QPoint]] & pos ) const''
Traduit les coordonnées globales ''pos'' de l'écran aux coordonnées du widget.
Voir aussi [[#mapToGlobal()]], [[#mapFrom()]] et [[#mapFromParent()]].
=== mapFromParent() ===
''[[QPoint]] QWidget::mapFromParent ( const [[QPoint]] & pos ) const''
Traduit les coordonnées ''pos'' du widget parent aux coordonnées du widget.
Il s'agit de la même chose que [[#mapFromGlobal()]] si le widget n'a pas de parent.
Voir aussi [[#mapToParent()]], [[#mapFrom()]], [[#mapFromGlobal()]] et [[#underMouse()]].
=== mapTo() ===
''[[QPoint]] QWidget::mapTo ( QWidget * parent, const [[QPoint]] & pos ) const''
Traduit les coordonnées ''pos'' du widget au système de coordonnées de ''parent''. Le ''parent'' ne doit pas être 0 et doit être un parent du widget appelé.
Voir aussi [[#mapFrom()]], [[#mapToParent()]], [[#mapToGlobal()]] et [[#underMouse()]].
=== mapToGlobal() ===
''[[QPoint]] QWidget::mapToGlobal ( const [[QPoint]] & pos ) const''
Traduit les coordonnées ''pos'' du widget aux coordonnées globales de l'écran. Par exemple, ''mapToGlobal(QPoint(0,0))'' devrait donner les coordonnées du pixel en haut à gauche du widget.
Voir aussi [[#mapFromGlobal()]], [[#mapTo()]] et [[#mapToParent()]].
=== mapToParent() ===
''[[QPoint]] QWidget::mapToParent ( const [[QPoint]] & pos ) const''
Traduit les coordonnées ''pos'' du widget aux coordonnées dans le widget parent.
Il s'agit de la même chose que [[#mapToGlobal()]] si le widget n'a pas de parent.
Voir aussi [[#mapFromParent()]], [[#mapTo()]], [[#mapToGlobal()]] et [[#underMouse()]].
=== mask() ===
''[[QRegion]] QWidget::mask () const''
Retourne le masque actuellement défini sur le widget. Si aucun masque n'est défini, la valeur de retour est une région vide.
Voir aussi [[#setMask()]], [[#clearMask()]], [[qregion#isEmpty|QRegion::isEmpty()]] et [[widgets-shapedclock|l'exemple Shaped Clock]].
=== metric() ===
''int QWidget::metric ( [[PaintDeviceMetric]] m ) const [virtual protected]''
Réimplémentation de [[qpaintdevice#metric|QPaintDevice::metric()]].
Implémentation interne de la fonction virtuelle [[qpaintdevice#metric|QPaintDevice::metric()]].
''m'' est la métrique à obtenir.
=== mouseDoubleClickEvent() ===
''void QWidget::mouseDoubleClickEvent ( [[QMouseEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements, pour l'événement ''event'', peut être réimplémenté dans une sous-classe pour recevoir les événements de double-clic pour le widget.
L'implémentation par défaut génère un événement normal d'appui sur la souris.
**Note :** le widget recevra également un événement d'appui et de relâchement en plus de l'événement double-clic. Il est du devoir du développeur de vérifier que l'application interprète correctement ces événements.
Voir aussi [[#mousePressEvent()]], [[#mouseReleaseEvent()]], [[#mouseMoveEvent()]], [[#event()]] et [[QMouseEvent]].
=== mouseGrabber() ===
''QWidget * QWidget::mouseGrabber () [static]''
Retourne le widget actuellement en train de saisir les entrées de la souris.
Si aucun widget dans cette application n'est en train de saisir les entrées de la souris, 0 est retourné.
Voir aussi [[#grabMouse()]] et [[#keyboardGrabber()]].
=== mouseMoveEvent() ===
''void QWidget::mouseMoveEvent ( [[QMouseEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements, pour l'événement ''event'', peut être réimplémenté dans une sous-classe pour recevoir les événements de mouvement de la souris pour le widget.
Si le suivi de la souris est désactivé, les événements de mouvement de la souris n'ont lieu que si un bouton est enfoncé lors du déplacement de celle-ci. Si le suivi de la souris est activé, ils ont lieu même si aucun bouton de la souris n'est enfoncé.
[[qmouseevent#pos|QMouseEvent::pos()]] signale la position du curseur de la souris relative à ce widget. Pour des événements d'appui et de relâchement, la position est généralement la même que la position du dernier événement de mouvement de la souris, mais peut être différent si la main de l'utilisateur tremble. C'est une propriété du système de fenêtrage sous-jacent et non de Qt.
Si vous voulez afficher immédiatement une info-bulle, pendant que la souris est en mouvement (par exemple pour obtenir les coordonnées de la souris avec [[qmouseevent#pos|QMouseEvent::pos()]] et les afficher dans une info-bulle), vous devez tout d'abord activer le suivi de la souris comme décrit ci-dessus puis, pour vous assurer que l'info-bulle est actualisée immédiatement, vous devez appeler [[qtooltip#showText|QToolTip::showText()]] au lieu de [[#toolTip-prop|setToolTip()]] dans votre implémentation de mouseMoveEvent().
Voir aussi [[#mouseTracking-prop|setMouseTracking()]], [[#mousePressEvent()]], [[#mouseReleaseEvent()]], [[#mouseDoubleClickEvent()]], [[#event()]], [[QMouseEvent]] et [[widgets-scribble|l'exemple Scribble]].
=== mousePressEvent() ===
''void QWidget::mousePressEvent ( [[QMouseEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements, pour l'événement ''event'', peut être réimplémenté dans une sous-classe pour recevoir les événements d'appui de souris pour le widget.
Si vous créez de nouveaux widgets dans l'événement mousePressEvent(), le [[#mouseReleaseEvent()]] ne pourra peut être pas finir là où vous vous y attendiez, cela dépendant du système de fenêtrage sous-jacent (ou du gestionnaire de fenêtre de X11), de l'emplacement du widget ou autres.
L'implémentation par défaut implémente la fermeture des widgets surgissants lorsque vous cliquez à l'extérieur de la fenêtre. Pour d'autres types de widgets, cela n'a aucune action.
Voir aussi [[#mouseReleaseEvent()]], [[#mouseDoubleClickEvent()]], [[#mouseMoveEvent()]], [[#event()]], [[QMouseEvent]] et [[widgets-scribble|l'exemple Scribble]].
=== mouseReleaseEvent() ===
''void QWidget::mouseReleaseEvent ( [[QMouseEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements, 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 [[widgets-scribble|l'exemple Scribble]].
=== moveEvent() ===
''void QWidget::moveEvent ( [[QMoveEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe pour recevoir les événements de mouvement de widget qui sont passés dans le paramètre ''event''. Lorsque le widget reçoit cet événement, il est déjà à la nouvelle position.
L'ancienne position est accessible à travers [[qmoveevent#oldPos|QMoveEvent::oldPos()]].
Voir aussi [[#resizeEvent()]], [[#event()]], [[#pos-prop|move()]] et [[QMoveEvent]].
=== nativeParentWidget() ===
''QWidget * QWidget::nativeParentWidget () const''
Retourne le parent natif du widget, c'est-à-dire le widget ancêtre suivant ayant un identifiant système, ou 0 s'il n'a pas de parent natif.
Cette fonction a été introduite dans Qt 4.4.
Voir aussi [[#effectiveWinId()]].
=== nextInFocusChain() ===
''QWidget * QWidget::nextInFocusChain () const''
Retourne le widget suivant dans la chaîne de focus du widget.
Voir aussi [[#previousInFocusChain()]].
=== overrideWindowFlags() ===
''void QWidget::overrideWindowFlags ( [[qt#WindowType-enum|Qt::WindowFlags]] flags )''
Définit les drapeaux de fenêtre pour le widget à ''flags'', ''sans'' le transmettre au système de fenêtrage.
**Attention :** n'utilisez pas cette fonction sans savoir réellement ce que vous êtes en train de faire.
Voir aussi [[#windowFlags-prop|setWindowFlags()]].
=== paintEngine() ===
''[[QPaintEngine]] * QWidget::paintEngine () const [virtual]''
Réimplémentation de [[qpaintdevice#paintEngine|QPaintDevice::paintEngine()]].
Retourne le moteur de peinture.
Notez que cette fonction ne devrait pas être appelée explicitement par l'utilisateur, puisqu'elle est faite uniquement pour être réimplémentée. La fonction est appelée par Qt de façon interne et l'implémentation par défaut peut ne pas toujours retourner un pointeur valide.
=== paintEvent() ===
''void QWidget::paintEvent ( [[QPaintEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe pour recevoir les événements de peinture passés dans ''event''.
Un événement de peinture est une requête pour repeindre toutes les parties du widget. Il peut se produire pour l'une des raisons suivantes :
* [[#repaint()]] ou [[#update()]] a été appelé ;
* le widget était recouvert et a maintenant été découvert ;
* ou beaucoup d'autres raisons.
Beaucoup de widgets peuvent simplement repeindre leur surface entière lorsqu'une demande est faite, mais quelques widgets lents nécessitent d'être optimisés en peignant uniquement la région demandée : [[qpaintevent#region|QPaintEvent::region()]]. Cette optimisation rapide ne change pas le résultat, comme la peinture est fixée à cette région durant le traitement de l'événement. [[QListView]] et [[QTableView]] font cela, par exemple.
Qt tente également d'accélérer la peinture par le fusionnement de multiples événements de peinture dans un seul. Lorsque [[#update()]] est appelé plusieurs fois ou lorsque le système de fenêtrage envoie plusieurs événements de peinture, Qt fusionne ces événements dans un événement avec une région plus large (voir [[qregion#united|QRegion::united()]]. La fonction [[#repaint()]] ne permet pas cette optimisation, donc il est suggéré d'utiliser [[#update()]] au possible.
Lorsque des événements de peinture ont lieu, la région d'actualisation a normalement été effacée, donc vous peignez sur l'arrière-plan du widget.
L'arrière-plan peut être défini par l'utilisation de [[#setBackgroundRole()]] et de [[#palette-prop|setPalette()]].
Depuis Qt 4.0, les peintures de [[QWidget]] sont automatiquement double-bufferisées, donc il n'y a aucun besoin d'écrire du code de double-buffer dans paintEvent() pour éviter des scintillements.
**Note pour les plateformes X11 :** il est possible de basculer le double-buffering global par l'appel de ''qt_x11_set_global_double_buffer()''. Par exemple :
...
extern void qt_x11_set_global_double_buffer(bool);
qt_x11_set_global_double_buffer(false);
...
**Note :** généralement, vous devriez vous abstenir d'appeler [[#update()]] ou [[#repaint()]] **à l'intérieur** de paintEvent(). Par exemple, appeler [[#update()]] ou [[#repaint()]] sur des enfants à l'intérieur de paintEvent() à pour résultat un comportement indéfini : le widget peut ou non recevoir un événement de peinture.
**Attention :** si vous utilisez un moteur de peinture personnalisé sans soutien de mémoire de Qt, [[qt#WidgetAttribute-enum|Qt::WA_PaintOnScreen]] doit être défini. Dans le cas contraire, [[#paintEngine|QWidget::paintEngine()]] ne sera jamais appelé ; le soutien de mémoire sera utilisé au lieu de cela.
Voir aussi [[#event()]], [[#repaint()]], [[#update()]], [[QPainter]], [[QPixmap]], [[QPaintEvent]] et [[widgets-analogclock|l'exemple Analog Clock]].
=== parentWidget() ===
''QWidget * QWidget::parentWidget () const''
Retourne le widget parent ou 0 s'il n'y a pas de widget parent.
=== previousInFocusChain() ===
''QWidget * QWidget::previousInFocusChain () const''
Cette fonction retourne le widget précédent, dans la chaîne de focus des widgets.
Cette fonction a été introduite dans Qt 4.6.
Voir aussi [[#nextInFocusChain()]].
=== qwsEvent() ===
''bool QWidget::qwsEvent ( [[QWSEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements spécial peut être réimplémenté dans une sous-classe, pour recevoir les événements Qt natifs pour Linux embarqué, qui sont passés dans le paramètre ''event''.
Dans la réimplémentation de cette fonction, si vous souhaitez stopper le fait que les événements sont gérés par Qt, retournez ''true''. Si vous retournez ''false'', cet événement natif est repassé à Qt, qui le traduit dans un événement de Qt et l'envoie au widget.
**Attention :** cette fonction n'est pas portable.
Voir aussi [[qapplication#qwsEventFilter|QApplication::qwsEventFilter()]].
=== raise() ===
''void QWidget::raise () [slot]''
Élève ce widget en haut de la pile du widget parent.
Après cet appel, le widget sera visuellement devant tout widget enfant de même parent superposant.
**Note :** lors de l'utilisation de [[#activateWindow()]], vous pouvez appeler cette fonction pour vous assurer que le widget est situé en haut de la pile.
Voir aussi [[#lower()]] et [[#stackUnder()]].
=== releaseDC() ===
''void QWidget::releaseDC ( HDC hdc ) const [virtual]''
Libère le HDC ''hdc'' acquit par un précédent appel à [[#getDC()]].
**Attention :** utiliser cette fonction n'est pas portable.
=== releaseKeyboard() ===
''void QWidget::releaseKeyboard ()''
Libère la saisie du clavier.
Voir aussi [[#grabKeyboard()]], [[#grabMouse()]] et [[#releaseMouse()]].
=== releaseMouse() ===
''void QWidget::releaseMouse ()''
Libère la saisie des entrées de la souris.
Voir aussi [[#grabMouse()]], [[#grabKeyboard()]] et [[#releaseMouse()]].
=== releaseShortcut() ===
''void QWidget::releaseShortcut ( int id )''
Retire le raccourci à l'''id'' donnée depuis le système de raccourcis de Qt. Le widget ne recevra plus d'événements [[qevent#Type-enum|QEvent::Shortcut]] pour la séquence de touches (à moins qu'il ait un autre raccourci ayant la même séquence de touches).
**Attention :** vous ne devriez normalement pas avoir besoin d'utiliser cette fonction depuis que le système de raccourcis de Qt retire automatiquement les raccourcis lorsque le parent du widget est détruit. Il est préférable d'utiliser [[QAction]] ou [[QShortcut]] pour gérer les raccourcis, puisqu'ils sont plus simples à utiliser que cette fonction de bas-niveau. Notez aussi que c'est une opération coûteuse.
Voir aussi [[#grabShortcut()]] et [[#setShortcutEnabled()]].
=== removeAction() ===
''void QWidget::removeAction ( [[QAction]] * action )''
Retire l'action ''action'' depuis la liste d'actions de ce widget.
Voir aussi [[#insertActions()]], [[#actions()]] et [[#insertAction()]].
=== render() ===
''void QWidget::render ( [[QPaintDevice]] * target, const [[QPoint]] & targetOffset = QPoint(), const [[QRegion]] & sourceRegion = QRegion(), [[#RenderFlag-enum|RenderFlags]] renderFlags = RenderFlags( DrawWindowBackground | DrawChildren ) )''
Rend la région source ''sourceRegion'' de ce widget dans la cible ''target'' en utilisant le drapeau ''renderFlag'' pour déterminer la manière d'effectuer le rendu. Le rendu commence au point ''targetOffset'' dans la cible ''target''. Par exemple :
QPixmap pixmap(widget->size());
widget->render(&pixmap);
Si sourceRegion est une région nulle, cette fonction utilisera [[#rect-prop|QWidget::rect()]] comme région, c'est-à-dire le widget entier.
Assurez-vous que vous appelé [[qpainter#end|QPainter::end()]] pour le pinceau actif du dispositif de la cible ''target'' (s'il y en a) avant d'effectuer le rendu. Par exemple :
QPainter painter(this);
...
painter.end();
myWidget->render(this);
**Note :** pour obtenir le contenu d'un widget OpenGL, utilisez plutôt [[qglwidget#grabFrameBuffer|QGLWidget::grabFrameBuffer()]] ou [[qglwidget#renderPixmap|QGLWidget::renderPixmap()]].
Cette fonction a été introduite dans Qt 4.3.
=== render() ===
''void QWidget::render ( [[QPainter]] * painter, const [[QPoint]] & targetOffset = QPoint(), const [[QRegion]] & sourceRegion = QRegion(), [[#RenderFlag-enum|RenderFlags]] renderFlags = RenderFlags( DrawWindowBackground | DrawChildren ) )''
Il s'agit d'une fonction surchargée.
Rend le widget dans le [[qpainter#device|QPainter::device()]] du ''painter''.
Les transformations et les configurations appliquées au ''painter'' seront utilisées lors du rendu.
**Note :** le ''painter'' doit être actif. Sous Mac OS X, le widget sera rendu dans une [[QPixmap]] puis dessiné par le ''painter''.
Voir aussi [[qpainter#device|QPainter::device()]].
=== repaint() ===
''void QWidget::repaint () [slot]''
Repeint le widget directement par l'appel immédiat de [[#paintEvent()]], sauf si les actualisations sont désactivées ou si le widget est masqué.
Il vous est suggéré d'utiliser uniquement repaint() si vous avez besoin de repeindre immédiatement, par exemple durant une animation. Dans la plupart des cas, [[#update()]] est mieux, puisqu'il permet à Qt d'optimiser la vitesse et de minimiser les scintillements.
**Attention :** si vous appelez repaint() dans une fonction pouvant être appelée elle-même depuis [[#paintEvent()]], vous pourrez obtenir une récursion infinie. La fonction [[#update()]] ne cause jamais de récursion.
Voir aussi [[#update()]], [[#paintEvent()]] et [[#updatesEnabled-prop|setUpdatesEnabled()]].
=== repaint() ===
''void QWidget::repaint ( int x, int y, int w, int h )''
Il s'agit d'une fonction surchargée.
Cette version repeint un rectangle à 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''.
=== repaint() ===
''void QWidget::repaint ( const [[QRect]] & rect )''
Il s'agit d'une fonction surchargée.
Cette version repeint le rectangle ''rect'' à l'intérieur du widget.
=== repaint() ===
''void QWidget::repaint ( const [[QRegion]] & rgn )''
Il s'agit d'une fonction surchargée.
Cette version repeint la région ''rgn'' à l'intérieur du widget.
=== resizeEvent() ===
''void QWidget::resizeEvent ( [[QResizeEvent]] * event ) [virtual protected]''
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''. Quand resizeEvent() est appelé, le widget a déjà sa nouvelle géométrie. Les anciennes dimensions sont accessibles par le biais de [[qresizeevent#oldSize|QResizeEvent::oldSize()]].
Le widget sera effacé et recevra immédiatement un événement de peinture après la réalisation 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()]], [[#size-prop|resize()]], [[QResizeEvent]], [[#paintEvent()]] et [[widgets-scribble|l'exemple Scribble]].
=== restoreGeometry() ===
''bool QWidget::restoreGeometry ( const [[QByteArray]] & geometry )''
Restaure la géométrie et l'état du widget de haut niveau stockés dans le tableau d'octets ''geometry''. Retourne ''true'' si elle réussit ; dans le cas contraire retourne ''false''.
Si la géométrie est en dehors de l'écran, elle sera modifiée afin d'être à l'intérieur de celui-ci.
Pour restaurer la géométrie sauvegardée en utilisant [[QSettings]], vous pouvez utiliser le code suivant :
QSettings settings("MyCompany", "MyApp");
myWidget->restoreGeometry(settings.value("myWidget/geometry").toByteArray());
Regardez la documentation de la [[application-windows#window-geometry|géométrie de la fenêtre]] pour un aperçu des questions de géométrie avec les fenêtres.
Utilisez [[qmainwindow#restoreState|QMainWindow::restoreState()]] pour restaurer la géométrie et l'état des barres d'outils et des widgets docks.
Cette fonction a été introduite dans Qt 4.2.
Voir aussi [[#saveGeometry()]], [[QSettings]], [[qmainwindow#saveState|QMainWindow::saveState()]] et [[qmainwindow#restoreState|QMainWindow::restoreState()]].
=== saveGeometry() ===
''[[QByteArray]] QWidget::saveGeometry () const''
Sauvegarde la géométrie actuelle et l'état pour des widgets de haut niveau.
Pour sauvegarder la géométrie lorsque la fenêtre se ferme, vous pouvez implémenter un événement de fermeture :
void MyWidget::closeEvent(QCloseEvent *event)
{
QSettings settings("MyCompany", "MyApp");
settings.setValue("geometry", saveGeometry());
QWidget::closeEvent(event);
}
Regardez la documentation de la [[application-windows#window-geometry|géométrie de la fenêtre]] pour un aperçu des questions de géométrie avec les fenêtres.
Utilisez [[qmainwindow#saveState|QMainWindow::saveState()]] pour sauvegarder la géométrie et l'état des barres d'outils et des widgets docks.
Cette fonction a été introduite dans Qt 4.2.
Voir aussi [[#restoreGeometry()]], [[qmainwindow#saveState|QMainWindow::saveState()]] et [[qmainwindow#restoreState|QMainWindow::restoreState()]].
=== scroll() ===
''void QWidget::scroll ( int dx, int dy )''
Fait défiler le widget incluant ses enfants de ''dx'' pixels à droite et de ''dy'' pixels vers le bas. ''dx'' ainsi que ''dy'' peuvent être négatifs.
Après le défilement, les widgets recevront un événement de peinture pour les zones ayant besoin d'être repeintes. Pour les widgets que Qt reconnaît comme opaques, il s'agit uniquement des nouvelles parties exposées. Par exemple, si un widget opaque est défilé de huit pixels vers la gauche, seulement une bande de huit pixels de large au rebord droit à besoin d'être actualisée.
Depuis que les widget propagent le contenu de leurs parents par défaut, vous avez besoin de définir la propriété [[#autoFillBackground-prop|autoFillBackground]], ou d'utiliser [[#setAttribute()]], ou de définir l'attribut [[qt#WidgetAttribute-enum|Qt::WA_OpaquePaintEvent]], pour faire un widget opaque.
Pour les widgets utilisant la propagation de contenu, un défilement causera une actualisation de la zone entière de défilement.
Voir aussi [[#transparency-and-double-buffering|transparence et double-buffering]].
=== scroll() ===
''void QWidget::scroll ( int dx, int dy, const [[QRect]] & r )''
Il s'agit d'une fonction surchargée.
Cette version ne défile que d'une région ''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]].
=== setAttribute() ===
''void QWidget::setAttribute ( [[qt#WidgetAttribute-enum|Qt::WidgetAttribute]] attribute, bool on = true )''
Définit l'attribut ''attribute'' sur ce widget si ''on'' est ''true'' ; sinon cela efface l'attribut.
Voir aussi [[#testAttribute()]].
=== setBackgroundRole() ===
''void QWidget::setBackgroundRole ( [[qpalette#ColorRole-enum|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 depuis la [[#palette-prop|palette]] du widget utilisée pour rendre l'arrière-plan.
Si ''role'' est [[qpalette#ColorRole-enum|QPalette::NoRole]], alors 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 de la palette. Vous pouvez modifier la palette ou définir une feuille de styles si vous ne réussissez pas à obtenir le résultat que vous désirez avec setBackgroundRole().
Voir aussi [[#backgroundRole()]] et [[#foregroundRole()]].
=== setContentsMargins() ===
''void QWidget::setContentsMargins ( int left, int top, int right, int bottom )''
Définit les marges autour du contenu du widget afin d'avoir les dimensions ''left'', ''top'', ''right'' et ''bottom''. Les marges sont utilisées par le système de layout et peuvent être utilisées par des sous-classes pour spécifier la zone dans laquelle dessiner (par exemple à l'exclusion du cadre).
Changer les marges déclenchera un [[#resizeEvent()]].
Voir aussi [[#contentsMargins]], [[#contentsRect()]] et [[#getContentsMargins()]].
=== setContentsMargins() ===
''void QWidget::setContentsMargins ( const [[QMargins]] & margins )''
Il s'agit d'une fonction surchargée.
Cette fonction définit les marges autour du contenu du widget.
Définir les marges autour du contenu du widget afin d'avoir les dimensions déterminées par les marges. Les marges sont utilisées par le système de layout et peuvent être utilisées par des sous-classes pour spécifier la zone dans laquelle dessiner (par exemple à l'exclusion du cadre).
Changer les marges déclenchera un [[#resizeEvent()]].
Cette fonction a été introduite dans Qt 4.6.
Voir aussi [[#contentsRect()]] et [[#getContentsMargins()]].
=== setDisabled() ===
''void QWidget::setDisabled ( bool disable ) [slot]''
Désactive les événements d'entrée du widget si ''disable'' est ''true'' ; sinon cela les active.
Voir la documentations de l'[[#enabled-prop|activation]] pour plus d'informations.
Voir aussi [[#isEnabledTo()]], [[QKeyEvent]], [[QMouseEvent]] et [[#changeEvent]].
=== setEditFocus() ===
''void QWidget::setEditFocus ( bool enable )''
Si ''enable'' est ''true'', cette fonction fait en sorte que le widget ait le focus d'édition, dans ce cas, Qt::Key_Up et Qt::Key_Down seront délivrés au widget normalement ; dans le cas contraire, [[qt#Key-enum|Qt::Key_Up]] et [[qt#Key-enum|Qt::Key_Down]] seront utilisées pour changer le focus.
Cette propriété n'est disponible que sous Linux embarqué et Qt pour Symbian.
Voir aussi [[#hasEditFocus()]] et [[qapplication#keypadNavigationEnabled|QApplication::keypadNavigationEnabled()]].
=== setFixedHeight() ===
''void QWidget::setFixedHeight ( int h )''
Définit la hauteur minimale et maximale du widget à ''h'' sans changer les longueurs. Prévue pour plus de commodité.
Voir aussi [[#sizeHint-prop|sizeHint()]], [[#minimumSize-prop|minimumSize()]], [[#maximumSize-prop|maximumSize()]] et [[#setFixedSize()]].
=== setFixedSize() ===
''void QWidget::setFixedSize ( const [[QSize]] & s )''
Définit les dimensions minimales et maximales du widget à ''s'', empêchant de ce fait toute augmentation ou diminution.
Cela passera outre les dimensions par défaut définies par [[QLayout]].
Pour retirer ces contraintes, définissez la taille à [[#QWIDGETSIZE_MAX]].
Alternativement, si vous voulez que le widget ait des dimensions fixes basées sur son contenu, vous pouvez appeler QLayout::setSizeConstraint([[qlayout#SizeConstraint-enum|QLayout::SetFixedSize]]);
Voir aussi [[#maximumSize-prop|maximumSize]] et [[#minimumSize-prop|minimumSize]].
=== setFixedSize() ===
''void QWidget::setFixedSize ( int w, int h )''
Il s'agit d'une fonction surchargée.
Définit la longueur du widget à ''w'' et la hauteur à ''h''.
=== setFixedWidth() ===
''void QWidget::setFixedWidth ( int w )''
Définit la longueur minimale et maximale du widget à ''w'' sans changer les longueurs. Prévue pour plus de commodité.
Voir aussi [[#sizeHint()]], [[#minimumSize-prop|minimumSize()]], [[#maximumSize-prop|maximumSize()]] et [[#setFixedSize()]].
=== setFocus() ===
''void QWidget::setFocus ( [[qt#FocusReason-enum|Qt::FocusReason]] reason )''
Donne le focus d'entrée de clavier à ce widget (ou son proxy de focus) si lui ou un de ses parents est la [[#isActiveWindow-prop|fenêtre active]]. L'argument ''reason'' sera passé dans tout événement de focus envoyé depuis cette fonction. Il est utilisé pour donner une explication de ce qui causerait le don du focus au widget. Si la fenêtre n'est pas active, le widget se verra donner le focus quand la fenêtre deviendra active.
Tout d'abord, un événement de sortie de focus est envoyé au widget ayant le focus (s'il y en a) afin de lui dire qu'il est sur le point de le perdre. Puis un événement d'entrée de focus est envoyé à ce widget pour lui dire qu'il vient de le recevoir. Rien ne se passe si le widget recevant le focus est le même que widget le perdant.
**Note :** sur plateforme embarquée, setFocus() n'entraînera par l'ouverture d'un panneau de saisie par la méthode d'entrée. Si vous voulez que cela arrive, vous devez envoyer un événement [[qevent#Type-enum|QEvent::RequestSoftwareInputPanel]] au widget lui-même.
setFocus() donne le focus à un widget sans se soucier de son focus de clavier, mais n'efface pas la saisie du clavier (voir [[#grabKeyboard()]]).
Soyez averti que si le widget est caché, il n'acceptera pas le focus jusqu'à ce qu'il soit affiché.
**Attention :** si vous appelez setFocus() dans une fonction pouvant elle-même être appelée depuis [[#focusOutEvent()]] ou [[#focusInEvent()]], vous pourrez obtenir une récursion infinie.
Voir aussi [[#hasFocus()]], [[#clearFocus()]], [[#focusInEvent()]], [[#focusOutEvent()]], [[#focusPolicy-prop|setFocusPolicy()]], [[#focusWidget()]], [[qapplication#focusWidget|QApplication::focusWidget()]], [[#grabKeyboard()]], [[#grabMouse()]], [[focus|Keyboard Focus]] et [[qevent#Type-enum|QEvent::RequestSoftwareInputPanel]].
=== setFocus() ===
''void QWidget::setFocus () [slot]''
Il s'agit d'une fonction surchargée.
Donne le focus d'entrée du clavier à ce widget (ou son proxy de focus) si le widget ou l'un de ses parents est la [[#isActiveWindow-prop|fenêtre active]].
=== setFocusProxy() ===
''void QWidget::setFocusProxy ( QWidget * w )''
Définit le proxy de focus du widget au widget ''w''. Si ''w'' est 0, la fonction réinitialise ce widget pour n'avoir aucun proxy de focus.
Quelques widgets peuvent "détenir le focus", mais créer un widget enfant, tel que [[QLineEdit]], pour gérer actuellement le focus. S'il y a un proxy de focus, [[#setFocus()]] et [[#focus-prop|hasFocus()]] opèrent sur le proxy de focus.
Voir aussi [[#focusProxy()]].
=== setForegroundRole() ===
''void QWidget::setForegroundRole ( [[qpalette#ColorRole-enum|QPalette::ColorRole]] role )''
Définit le rôle de premier plan du widget à ''role''.
Le rôle de premier plan définit la couleur depuis la [[#palette-prop|palette]] du widget utilisée pour dessiner le premier plan.
Si ''role'' est [[qpalette#ColorRole-enum|QPalette::NoRole]], le widget utilise un rôle de premier plan qui diffère du rôle d'arrière plan.
Notez que les styles sont libres de choisir n'importe quelle couleur de la palette. Vous pouvez modifier la palette ou définir une feuille de styles si vous ne réussissez pas à obtenir le résultat que vous désirez avec setForegroundRole().
Voir aussi [[#foregroundRole()]] et [[#backgroundRole()]].
=== setGraphicsEffect() ===
''void QWidget::setGraphicsEffect ( [[QGraphicsEffect]] * effect )''
Cette fonction permet de définir l'effet graphique du widget.
Définit ''effect'' comme effet du widget. S'il y a déjà un effet installé sur ce widget, [[QWidget]] supprimera l'effet existant avant d'installer le nouveau.
Si ''effect'' est déjà installé sur un widget différent, setGraphicsEffect() supprimera l'effet du widget et l'installera sur celui-ci.
[[QWidget]] prend possession de l'effet.
**Note :** cette fonction appliquera l'effet sur ce widget et tous ses enfants.
Cette fonction a été introduite dans Qt 4.6.
Voir aussi [[#graphicsEffect()]].
=== setHidden() ===
''void QWidget::setHidden ( bool hidden ) [slot]''
Fonction de commodité, équivalente à setVisible(!''hidden'').
Voir aussi [[#isHidden()]].
=== setInputContext() ===
''void QWidget::setInputContext ( [[QInputContext]] * context )''
Cette fonction définit le contexte d'entrée ''context'' sur ce widget.
Voir aussi [[#inputContext()]].
=== setLayout() ===
''void QWidget::setLayout ( [[QLayout]] * layout )''
Définit le gestionnaire de layout pour ce widget à ''layout''.
S'il y a déjà un gestionnaire de layout installé, [[QWidget]] ne vous laissera pas en installer un autre. Vous devrez tout d'abord supprimer le gestionnaire de layout existant (retourné par [[#layout()]]) avant d'appeler setLayout() avec le nouveau layout.
Si ''layout'' est le gestionnaire de layout d'un autre widget, setLayout() redéfinira le parent du layout et en fera le gestionnaire de layout de ce widget.
Exemple :
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(formWidget);
setLayout(layout);
Une alternative à l'appel de cette fonction est de passer ce widget au constructeur du layout.
Le [[QWidget]] aura la possession du ''layout''.
Voir aussi [[#layout()]] et [[layout|la gestion des layout]].
=== setMask() ===
''void QWidget::setMask ( const [[QBitmap]] & bitmap )''
Entraîne seulement les pixels du widget pour lequel ''bitmap'' a un correspondant d'un bit à être visible. Si la région inclut des pixels à l'extérieur du [[rect-prop|rect()]] du widget, le contrôle du système de fenêtrage dans cette zone peut être ou non visible, en fonction de la plateforme.
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());
Le libellé affiché par ce code est masqué en utilisant l'image qu'il contient, donnant l'apparence qu'une image de forme irrégulière est en train d'être dessinée directement à l'écran.
Les widgets masqués reçoivent les événements de souris uniquement sur les portions visibles.
Voir aussi [[#mask()]], [[#clearMask()]], [[#windowOpacity-prop|windowOpacity()]] et [[widgets-shapedclock|l'exemple Shaped Clock]].
=== setMask() ===
''void QWidget::setMask ( const [[QRegion]] & region )''
Il s'agit d'une fonction surchargée.
Entraîne seulement les parties du widget qui superposent ''region'' a être visibles. Si la région inclut des pixels à l'extérieur du rect() du widget, le contrôle du système de fenêtrage dans cette zone peut être visible ou non, en fonction de la plateforme.
Notez que cet effet peut être lent si la région est particulièrement complexe.
Voir aussi [[#windowOpacity-prop|windowOpacity]].
=== setParent() ===
''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 parent est une fenêtre différente, le widget ayant obtenu un nouveau parent et ses enfants sont ajoutés à la fin de [[#focusPolicy-prop|la chaîne de tabulation]] du nouveau widget parent, dans le même ordre interne qu'avant. Si un des widgets déplacés détient le focus du clavier, setParent() appelle [[#clearFocus()]] pour ce widget.
Si le nouveau widget parent est dans la même fenêtre que l'ancien parent, la définition du parent ne change pas l'ordre de tabulation ou le focus de clavier.
Si le "nouveau" widget parent est l'ancien widget parent, cette fonction n'a aucune action.
**Note :** le widget devient invisible en tant que partie du changement de son parent, même s'il était visible auparavant. Vous devez appeler [[#show()]] pour rendre de nouveau le widget visible.
**Attention :** il est très peu probable que vous puissiez avoir besoin de cette fonction. Si vous avez un widget qui change son contenu de manière dynamique, il est bien plus simple d'utiliser [[QStackedWidget]].
Voir aussi [[#windowFlags-prop|setWindowFlag()]].
=== setParent() ===
''void QWidget::setParent ( QWidget * parent, [[qt#WindowType-enum|Qt::WindowFlags]] f )''
Il s'agit d'une fonction surchargée.
Cette fonction prend aussi les drapeaux du widget, ''f'', comme argument.
=== setShortcutAutoRepeat() ===
''void QWidget::setShortcutAutoRepeat ( int id, bool enable = true )''
Si ''enable'' est ''true'', la répétition automatique du raccourci avec l'''id'' donnée est activée ; dans le cas contraire elle est désactivée.
Cette fonction a été introduite dans Qt 4.2.
Voir aussi [[#grabShortcut()]] et [[#releaseShortcut()]].
=== setShortcutEnabled() ===
''void QWidget::setShortcutEnabled ( int id, bool enable = true )''
Si ''enable'' est ''true'', le raccourci à l'''id'' donnée est activé ; dans le cas contraire, il est désactivé.
**Attention :** vous ne devriez normalement pas avoir besoin de vous servir de cette fonction, vu que le système de raccourcis de Qt active/désactive les raccourcis automatiquement quand les widgets deviennent cachés/visibles et obtiennent ou perdent le focus. Il est préférable d'utiliser [[QAction]] ou [[QShortcut]] pour gérer les raccourcis, puisqu'ils sont plus simples à utiliser que cette fonction de bas niveau.
Voir aussi [[#grabShortcut()]] et [[#releaseShortcut()]].
=== setStyle() ===
''void QWidget::setStyle ( [[QStyle]] * style )''
Définit le style de GUI du widget à ''style''. Le propriétaire de l'objet de style n'est pas transféré.
Si aucun style n'est défini, le widget utilise le style de l'application, [[qapplication#style|QApplication::style()]] au lieu de cela.
Configurer un style de widget n'a aucun effet sur les widgets enfants existants ou sur les futurs widgets.
**Attention :** cette fonction est particulièrement utile pour faire des démonstrations, lorsque vous voulez montrer les capacités de style de Qt. Les applications réelles devraient l'éviter et utiliser à la place un style de GUI conforme.
**Attention :** les feuilles de style de Qt ne sont actuellement pas supportées pour les sous-classes personnalisées de [[QStyle]]. Il est prévu de corriger cela dans une version future.
Voir aussi [[#style()]], [[QStyle]], [[qapplication#style|QApplication::style()]] et [[qapplication#setStyle|QApplication::setStyle()]].
=== setTabOrder() ===
''void QWidget::setTabOrder ( QWidget * first, QWidget * second ) [static]''
Met le ''second'' widget après le ''first'' widget dans l'ordre de focus.
Notez que depuis que l'ordre de tabulation du ''second'' widget est changé, vous devez ordonner la chaîne comme ceci :
setTabOrder(a, b); // "a" à "b"
setTabOrder(b, c); // "a" à "b" à "c"
setTabOrder(c, d); // "a" à "b" à "c" à "d"
Et ''non'' comme cela :
// FAUX
setTabOrder(c, d); // "c" à "d"
setTabOrder(a, b); // "a" à "b" ET "c" à "d"
setTabOrder(b, c); // "a" à "b" to "c", mais pas "c" à "d"
Si ''first'' ou ''second'' a un proxy de focus, setTabOrder() substitue le proxy.
Voir aussi [[#focusPolicy-prop|setFocusPolicy()]], [[#setFocusProxy()]] et [[focus|Keyboard Focus]].
=== setWindowRole() ===
''void QWidget::setWindowRole ( const [[QString]] & role )''
Définit le rôle de la fenêtre à ''role''. Cette propriété n'est valable que pour les fenêtres sous X11.
Voir aussi [[#windowRole()]].
=== setWindowState() ===
''void QWidget::setWindowState ( [[qt#WindowState-enum|Qt::WindowStates]] windowState )''
Définit l'état de la fenêtre à ''windowState''. L'état de la fenêtre est une combination OR de [[qt#WindowState-enum|Qt::WindowState]] : [[qt#WindowState-enum|Qt::WindowMinimized]], [[qt#WindowState-enum|Qt::WindowMaximized]], [[qt#WindowState-enum|Qt::WindowFullScreen]] et [[qt#WindowState-enum|Qt::WindowActive]].
Si la fenêtre n'est pas visible (c'est-à-dire que [[#visible-prop|isVisible()]] retourne ''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 plein écran et le mode normal, utilisez le code suivant :
w->setWindowState(w->windowState() ^ Qt::WindowFullScreen);
Pour restaurer et activer une fenêtre minimisée (tout en préservant son état maximisé et/ou son état de plein écran), utilisez le code suivant :
w->setWindowState(w->windowState() & ~Qt::WindowMinimized | Qt::WindowActive);
Appeler cette fonction masquera le widget. Vous devez appeler [[#show()]] pour rendre de nouveau le widget visible.
**Note :** dans quelques systèmes [[qt#WindowState-enum|Qt::WindowActivate]] n'est pas immédiat et peut être ignoré dans certains cas.
Lorsque l'état de la fenêtre change, le widget reçoit un [[#changeEvent()]] de type [[qevent#Type-enum|QEvent::WindowStateChange]].
Voir aussi [[qt#WindowState-enum|Qt::WindowState]] et [[#windowState()]].
=== setWindowSurface() ===
''void QWidget::setWindowSurface ( [[QWindowSurface]] * surface )''
**Cette fonction est en développement et est susceptible de changer.**
Définit la surface de fenêtre pour être la ''surface'' spécifiée. Le [[QWidget]] prend possession de la ''surface''. Le widget lui-même est supprimé.
Cette fonction a été introduite dans Qt 4.2.
Voir aussi [[#windowSurface()]].
=== setupUi() ===
''void QWidget::setupUi ( QWidget * widget )''
Définit l'interface utilisateur pour le widget spécifié.
**Note :** cette fonction est disponible pour les widgets qui dérivent d'une description d'interface utilisateur créée avec uic.
Voir aussi [[designer-using-a-ui-file|Utilisé un fichier de design UI dans votre application]].
=== show() ===
''void QWidget::show () [slot]''
Affiche le widget ainsi que ses enfants. C'est l'équivalent de setVisible(true).
Voir aussi [[#raise()]], [[#showEvent()]], [[#hide()]], [[#visible-prop|setVisible()]], [[#showMinimized()]], [[#showMaximized()]], [[#showNormal()]] et [[#visible-prop|isVisible()]].
=== showEvent() ===
''void QWidget::showEvent ( [[QShowEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe pour recevoir les événements d'affichage du widget qui sont passés dans le paramètre ''event''.
Les événements d'affichage non-spontanés sont envoyés immédiatement aux widgets avant d'être affichés. Les événements spontanés d'affichage de fenêtre sont délivrés après.
**Note :** un widget reçoit spontanément les événements d'affichage et de masquage lorsque son statut est changé par le système de fenêtrage, par exemple, un événement spontané de masquage lorsque l'utilisateur minimise la fenêtre, et un événement spontané d'affichage lorsque la fenêtre est de nouveau restaurée. Après le reçu d'un événement spontané de masquage, un widget est encore considéré visible dans le sens de isVisible().
Voir aussi [[#visible-prop|visible]], [[#event()]] et [[QShowEvent]].
=== showFullScreen() ===
''void QWidget::showFullScreen () [slot]''
Affiche le widget dans le mode plein écran.
Appeler cette fonction n'affecte que les [[#isWindow|fenêtres]].
Pour revenir du mode plein écran, appelez [[#showNormal()]].
Le mode plein écran marche bien sous Windows, mais a certains problèmes sous X. Ces problèmes sont dus aux limitations du protocole ICCCM qui spécifie la communication entre les clients d'X11 et le gestionnaire de fenêtrage. ICCCM ne comprend simplement pas le concept de fenêtres non décorées en plein écran. Par conséquent, le mieux que nous pouvons faire est de demander une fenêtre sans bordures et de la redimensionner pour remplir l'écran en entier. Dépendant du système de fenêtrage, cela peut ou non fonctionner. La fenêtre sans bordures est demandée en utilisant l'indice MOTIF, qui est au moins supporté par pratiquement tous les gestionnaires de fenêtres modernes.
Une alternative serait d'éviter entièrement le gestionnaire de fenêtres et de créer une fenêtre avec le drapeau [[qt#WindowType-enum|Qt::X11BypassWindowManagerHint]]. Elle possède d'autres problèmes importants, comme un focus de clavier complètement cassé et des effets très étranges sur les modifications du bureau ou lorsque l'utilisateur ouvre d'autres fenêtres.
Les gestionnaires de fenêtrage de X11 qui suivent les spécifications modernes post-ICCCM supportent proprement le mode de plein écran.
Voir aussi [[#showNormal()]], [[#showMaximized()]], [[#show()]], [[#hide()]] et [[#visible-prop|isVisible()]].
=== showMaximized() ===
''void QWidget::showMaximized () [slot]''
Affiche le widget maximisé.
Appeler cette fonction n'affecte que les [[#isWindow|fenêtres]].
Sous X11, cette fonction peut ne pas fonctionner correctement avec quelques gestionnaires de fenêtrage. Regardez la documentation de la [[application-windows#window-geometry|géométrie des fenêtres]] pour plus de détails.
Voir aussi [[#setWindowState()]], [[#showNormal()]], [[#showMinimized()]], [[#show()]], [[#hide()]] et [[#visible-prop|isVisible()]].
=== showMinimized() ===
''void QWidget::showMinimized () [slot]''
Affiche le widget minimisé, comme une icône.
Appeler cette fonction n'affecte que les [[#isWindow|fenêtres]].
Voir aussi [[#showNormal()]], [[#showMaximized()]], [[#show()]], [[#hide()]], [[#visible-prop|isVisible()]] et [[#minimized-prop|isMinimized()]].
=== showNormal() ===
''void QWidget::showNormal () [slot]''
Restaure le widget après qu'il soit maximisé ou minimisé.
Appeler cette fonction n'affecte que les [[#isWindow|fenêtres]].
Voir aussi [[#setWindowState()]], [[#showMinimized()]], [[#showMaximized()]], [[#show()]], [[#hide()]] et [[#visible-prop|isVisible()]].
=== stackUnder() ===
''void QWidget::stackUnder ( QWidget * w )''
Place le widget sous ''w'' dans la pile du widget parent.
Pour que cela fonctionne, le widget lui-même et w doivent être des enfants de même parent.
Voir aussi [[#raise()]] et [[#lower()]].
=== style() ===
''[[QStyle]] * QWidget::style () const''
Voir aussi [[#setStyle|QWidget::setStyle()]], [[qapplication#setStyle|QApplication::setStyle()]] et [[qapplication#style|QApplication::style()]].
=== tabletEvent() ===
''void QWidget::tabletEvent ( [[QTabletEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements, pour l'événement ''event'', peut être réimplémenté dans une sous-classe pour recevoir les événements de tablette pour le widget.
Si vous réimplémentez ce gestionnaire, il est très important que vous ignoriez ([[qtabletevent|ignore()]]) l'événement si vous ne le gérez pas et que de cette façon, le parent du widget puisse l'interpréter.
L'implémentation par défaut ignore l'événement.
Voir aussi [[qevent#ignore|QTabletEvent::ignore()]], [[qevent#accept|QTabletEvent::accept()]], [[#event()]] et [[QTabletEvent]].
=== testAttribute() ===
''bool QWidget::testAttribute ( [[qt#WidgetAttribute-enum|Qt::WidgetAttribute]] attribute ) const''
Retourne ''true'' si l'attribut ''attribute'' est défini sur ce widget ; dans le cas contraire, retourne ''false''.
Voir aussi [[#setAttribute()]].
=== underMouse() ===
''bool QWidget::underMouse () const''
Retourne ''true'' si le widget est en dessous du curseur de la souris ; dans le cas contraire retourne ''false''.
Cette valeur n'est pas actualisée proprement durant des opérations de glissement-déposition.
Voir aussi [[#enterEvent()]] et [[#leaveEvent()]].
=== ungrabGesture() ===
''void QWidget::ungrabGesture ( [[qt#GestureType-enum|Qt::GestureType]] gesture )''
Désinscrit le widget à type de ''gesture'' donné.
Cette fonction a été introduite dans Qt 4.6.
Voir aussi [[#grabGesture()]] et [[QGestureEvent]].
=== update() ===
''void QWidget::update () [slot]''
Actualise le widget, à moins que les actualisations soient désactivées ou que le widget soit masqué.
Cette fonction n'entraîne pas une action de peinture immédiate ; au lieu de cela elle programme un événement de peinture pour le traitement lorsque Qt retourne à la boucle d'événements principale. Cela permet à Qt d'optimiser, pour plus de rapidité et pour moins de scintillements, qu'un appel de [[#repaint()]] entraînent.
Appeler update() plusieurs fois résulte normalement à un seul appel de [[#paintEvent()]].
Qt efface normalement la zone du widget avant l'appel de [[#paintEvent()]]. Si l'attribut de widget [[qt#WidgetAttribute-enum|Qt::WA_OpaquePaintEvent]] est défini, le widget est responsable de la peinture de tous ses pixels avec une couleur opaque.
Voir aussi [[#repaint()]], [[#paintEvent()]], [[#updatesEnabled-prop|setUpdatesEnabled()]] et [[widgets-analogclock|l'exemple Analog Clock]].
=== update() ===
''void QWidget::update ( int x, int y, int w, int h )''
Il s'agit d'une fonction surchargée.
Cette version actualise un rectangle (''x'', ''y'', ''w'', ''h'') à l'intérieur du widget.
=== update() ===
''void QWidget::update ( const [[QRect]] & rect )''
Il s'agit d'une fonction surchargée.
Cette version actualise un rectangle ''rect'' l'intérieur du widget.
=== update() ===
''void QWidget::update ( const [[QRegion]] & rgn )''
Il s'agit d'une fonction surchargée.
Cette version repeint une région ''rgn'' à l'intérieur du widget.
=== updateGeometry() ===
''void QWidget::updateGeometry ()''
Notifie le système de layout que ce widget a changé et peut nécessiter un changement de géométrie.
Appelez cette fonction si [[#sizeHint-prop|sizeHint()]] ou [[#sizePolicy-prop|sizePolicy()]] a changé.
Pour des widgets explicitement masqués, updateGeometry() est ineffectif. Le système de layout sera notifié aussitôt que le widget sera affiché.
=== updateMicroFocus() ===
''void QWidget::updateMicroFocus () [protected slot]''
Actualise le micro focus du widget.
Voir aussi [[QInputContext]].
=== visibleRegion() ===
''[[QRegion]] QWidget::visibleRegion () const''
Retourne la région non recouverte où les événements de peinture peuvent avoir lieu.
Pour les widgets visibles, c'est une approximation de la zone non couverte par d'autres widgets ; sinon, c'est une région vide.
La fonction [[#repaint()]] appelle cette fonction si nécessaire, donc en général vous n'aurez pas besoin de l'appeler.
=== wheelEvent() ===
''void QWidget::wheelEvent ( [[QWheelEvent]] * event ) [virtual protected]''
Ce gestionnaire d'événements, pour l'événement ''event'', peut être réimplémenté dans une sous-classe pour recevoir les événements de molette pour le widget.
Si vous réimplémentez ce gestionnaire, il est très important que vous ignoriez ([[qwheelevent|ignore()]]) l'événement si vous ne le gérez pas et que de cette façon, le parent du widget puisse l'interpréter.
L'implémentation par défaut ignore l'événement.
Voir aussi [[qevent#ignore|QWheelEvent::ignore()]], [[qevent#accept|QWheelEvent::accept()]], [[#event()]] et [[QWheelEvent]].
=== winEvent() ===
''bool QWidget::winEvent ( MSG * message, long * result ) [virtual protected]''
Ce gestionnaire d'événements spécial peut être réimplémenté dans une sous-classe pour recevoir les événements natifs de Windows qui sont passés par le paramètre ''message''.
Dans la réimplémentation de cette fonction, si vous souhaitez stopper le fait que les événements sont gérés par Qt, retournez ''true'' et définissez ''result'' à la valeur que la procédure de fenêtre devrait retourne. Si vous retournez ''false'', cet événement natif est repassé à Qt, qui traduit l'événement dans un événement de Qt et l'envoie au widget.
**Attention :** cette fonction n'est pas portable.
Voir aussi [[qcoreapplication#winEventFilter|QApplication::winEventFilter()]].
=== winId() ===
''[[#WId-typedef|WId]] QWidget::winId () const''
Retourne l'identifiant du système de fenêtrage du widget.
En principe cette fonction est portable, mais si vous l'utilisez vous êtes probablement sur le point de faire quelque chose de non portable. Soyez prudent.
Si un widget est non natif (alien) et que winId() est appelé dessus, à ce widget sera fourni un traitement natif.
Sous Mac OS X, le type retourné dépend du framework de Qt qui est lié. Si Qt est en train d'utiliser Carbon, le {WId} est actuellement un HIViewRef. Si Qt est en train d'utiliser Cocoa, {WId} est un pointeur sur un NSView.
Cette valeur peut changer en cours d'exécution. Un événement avec le type [[qevent#Type-enum|QEvent::WinIdChange]] sera envoyé au widget après un changement dans l'identifiant du système de fenêtrage.
Voir aussi [[#find()]].
=== window() ===
''QWidget * QWidget::window () const''
Retourne la fenêtre pour ce widget, c'est-à-dire le widget ancêtre suivant qui a (ou pourrait avoir) un cadre du système de fenêtrage.
Si le widget est une fenêtre, le widget lui-même est retourné.
L'usage typique est le changement du titre de la fenêtre :
aWidget->window()->setWindowTitle("Nouveau titre de fenêtre");
Voir aussi [[#isWindow()]].
=== windowRole() ===
''[[QString]] QWidget::windowRole () const''
Retourne le rôle de la fenêtre ou une chaîne de caractères vide.
Voir aussi [[#setWindowRole()]], [[#windowIcon-prop|windowIcon]] et [[#windowTitle-prop|windowTitle]].
=== windowState() ===
''[[qt#WindowState-enum|Qt::WindowStates]] QWidget::windowState () const''
Retourne l'état actuel de la fenêtre. L'état de la fenêtre est une combination OR de [[qt#WindowState-enum|Qt::WindowState]] : [[qt#WindowState-enum|Qt::WindowMinimized]], [[qt#WindowState-enum|Qt::WindowMaximized]], [[qt#WindowState-enum|Qt::WindowFullScreen]] et [[qt#WindowState-enum|Qt::WindowActive]].
Voir aussi [[qt#WindowState-enum|Qt::WindowState]] et [[#setWindowState|setWindowState()]].
=== windowSurface() ===
''[[QWindowSurface]] * QWidget::windowSurface () const''
**Cette fonction est en développement et est susceptible de changer.**
Retourne la QWindowSurface dans laquelle le widget sera dessiné.
Cette fonction a été introduite dans Qt 4.2.
Voir aussi [[#setWindowSurface()]].
=== windowType() ===
''[[qt#WindowType-enum|Qt::WindowType]] QWidget::windowType () const''
Retourne le type de fenêtre de ce widget. Elle est identique à [[#windowFlags-prop|windowFlags()]] & [[qt#WindowType-enum|Qt::WindowType_Mask]].
Voir aussi [[#windowFlags-prop|windowFlags()]].
=== x11Event() ===
''bool QWidget::x11Event ( XEvent * event ) [virtual protected]''
Ce gestionnaire d'événements spécial peut être réimplémenté dans une sous-classe pour recevoir les événements natifs de X11 qui sont passés dans le paramètre ''event''.
Dans la réimplémentation de cette fonction, si vous souhaitez stopper le fait que les événements sont gérés par Qt, retournez ''true''. Si vous retournez ''false'', cet événement natif est repassé à Qt, qui le traduit dans un événement de Qt et l'envoie au widget.
**Note :** les événements ne sont délivrés au gestionnaire d'événements que si le widget est natif.
**Attention :** cette fonction n'est pas portable.
Voir aussi [[qapplication#x11EventFilter|QApplication::x11EventFilter()]] et [[#winId|QWidget::winId()]].
=== x11Info() ===
''const [[QX11Info]] & QWidget::x11Info () const''
Retourne des informations à propos de la configuration de l'affichage X utilisé pour afficher le widget.
=== x11PictureHandle() ===
''[[qt#HANDLE-typedef|Qt::HANDLE]] QWidget::x11PictureHandle () const''
Retourne le gestionnaire X11 Picture du widget pour le support XRender. Utiliser cette fonction n'est pas portable. Cette fonction retourne 0, si le support XRender n'est pas compilé dans Qt, si l'extension XRender n'est pas supportée dans l'affichage de X11 ou si la gestion ne peut être créer.
==== En relation mais non membres de la classe ====
=== QWidgetList-typedef ===
''typedef QWidgetList''
Synonyme pour [[QList]]<[[QWidget]] *>.
=== WId-typedef ===
''typedef WId''
Identificateur dépendant de fenêtre de plateforme.
==== Macro ====
=== QWIDGETSIZE_MAX ===
''QWIDGETSIZE_MAX''
Définit les dimensions maximales pour un objet [[QWidget]].
Les dimensions maximales autorisées pour un widget est [[QSize]](QWIDGETSIZE_MAX, QWIDGETSIZE_MAX), c'est-à-dire [[QSize]](16777215,16777215).
Voir aussi [[#maximumSize-prop|QWidget::setMaximumSize()]].
==== Remerciements ====
Merci à pour la traduction et à , ainsi qu'à pour leur relecture !