QWidget

La classe QWidget est la classe de base de tous les objets d'interfaces utilisateur. Plus d'informations...

#include <QWidget>

Voir la position dans l'arbre des classes.

Héritage

Hérite de QObject et de QPaintDevice.

Hérité par Phonon::EffectWidget, Phonon::SeekSlider, Phonon::VideoPlayer, Phonon::VideoWidget, 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 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 :

1. 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::Window comme drapeau de fenêtre) ;
2. 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, setWindowTitle() et 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.

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 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 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 exemples fournis avec Qt utilisent cette approche, qui est aussi détaillée par les 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 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.

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() pour donner des dimensions par défaut raisonnables pour le widget et pour définir la politique de dimensionnement correcte avec 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 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.

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 QWidget::event() ;
• focusInEvent() est appelé quand le widget obtient le focus du clavier (en supposant que vous avez appelé 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 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 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 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. 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 système d'événements.

Groupes de fonctions et propriétés

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

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 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::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::Window), de définir la propriété 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::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::WA_OpaquePaintEvent et la propriété autoFillBackground définie, l'attribut 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.

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.

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::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::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 :

1. Utiliser QT_USE_NATIVE_WINDOWS=1 dans votre environnement ;
2. Définir l'attibut Qt::AA_NativeWindows dans votre application : tous les widgets deviendront des widgets natifs ;
3. Définir l'attribut Qt::WA_NativeWindow dans vos widgets ; le widget lui-même et tous ses parents deviendront natifs (sauf si Qt::WA_DontCreateNativeAncestors est défini) ;
4. Appeler QWidget::winId pour appliquer une fenêtre native (cela implique le 3^e point) ;
5. Définir l'attribut Qt::WA_PaintOnScreen pour appliquer une fenêtre native (cela implique le 3^e 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

enum QWidget::RenderFlag

flags QWidget::RenderFlags

Cette énumération explique comment faire pour réaliser un rendu du widget lors de l'appel de QWidget::render().

Cette énumération a été introduite ou modifiée dans Qt 4.3.

Le type RenderFlags est une définition de type pour QFlags<RenderFlags>. Il stocke une combinaison OR de valeurs RenderFlags.

Propriétés

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::Desktop), il est possible que cela échoue si une autre application est en train de se servir du bureau ; vous pouvez appeler 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 glisser-et-déposer.

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().

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().

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 palette du widget.

De plus, les fenêtres sont toujours remplies avec 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 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::WA_OpaquePaintEvent, Qt::WA_NoSystemBackground et Transparence et double buffering.

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().

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 setSizeIncrement().

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() et geometry().

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(), geometry() et mask().

contextMenuPolicy : Qt::ContextMenuPolicy

Cette propriété détient la manière dont le widget affiche un menu contextuel.

La valeur par défaut est Qt::DefaultContextMenu, qui signifie que le gestionnaire de contextMenuEvent() est appelé. Les autres valeurs sont Qt::NoContextMenu, Qt::PreventContextMenu, Qt::ActionsContextMenu et Qt::CustomContextMenu. Avec 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 : 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 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::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().

Fonctions d'accès

QCursor cursor () const

void setCursor ( const QCursor & )

void unsetCursor ()

Voir aussi QApplication::setOverrideCursor().

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::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 : 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() réfère au widget.

Fonction d'accès

bool hasFocus () const

Voir aussi setFocus(), clearFocus(), setFocusPolicy() et QApplication::focusWidget().

focusPolicy : Qt::FocusPolicy

Cette propriété contrôle la manière dont le widget accepte le focus du clavier.

La politique de focus est Qt::TabFocus si le widget accepte le focus du clavier par tabulation, Qt::ClickFocus si le widget accepte le focus par clic, Qt::StrongFocus si le widget accepte les deux et 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::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.

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(). 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::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 feuille de style.

Note : si les 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 : 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 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(), x(), y() et pos().

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 : 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 et maximized.

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() et maximumSize().

Attention : appeler setGeometry() à l'intérieur de resizeEvent() ou de moveEvent() peut conduire à une boucle infinie.

Regardez la documentation de la 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(), rect(), move(), resize(), moveEvent(), resizeEvent(), minimumSize() et maximumSize().

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 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 écran d'ordinateur avec plusieurs bureaux. Lisez 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, width et size.

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::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::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 : 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 activeWindowQApplication::activeWindow().

layoutDirection : 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::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.

Cette méthode n'affecte plus la direction des layouts de texte depuis Qt 4.7.

Fonctions d'accès

Qt::LayoutDirection layoutDirection () const

void setLayoutDirection ( Qt::LayoutDirection direction )

void unsetLayoutDirection ()

Voir aussi QApplication::layoutDirection.

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().

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, show(), hide(), showNormal() et minimized.

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.

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 et maximumWidth

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, maximumHeight, minimumSize et sizeIncrement.

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.

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 et maximumHeight.

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, show(), hide(), showNormal() et maximized.

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.

Par défaut, cette propriété possède une valeur de  .

Fonctions d'accès

int minimumHeight () const

void setMinimumHeight ( int minh )

Voir aussi minimumSize et minimumWidth.

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, minimumHeight, maximumSize et sizeIncrement.

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() ne soit défini ou que la politique de dimensionnement ne soit à QSizePolicy::Ignore. Si minimumSize() est définie, les dimensions minimales recommandées seront ignorées.

Fonction d'accès

virtual QSize minimumSizeHint () const

Voir aussi QSize::isValid(), resize(), setMinimumSize() et sizePolicy-propsizePolicy().

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.

Par défaut, cette propriété possède une valeur de  .

Fonctions d'accès

int minimumWidth () const

void setMinimumWidth ( int minw )

Voir aussi minimumSize et minimumHeight.

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 et QDialog.

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 : 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 QWidget::windowState() et QWidget::geometry.

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 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(). Enfin, le style détient toujours la possibilité de polissage de la palette si cela est assigné (voir 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::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 feuille de style. Vous pouvez vous référer à l'article Knowledge Base 22 pour plus d'informations.

Attention : ne pas utiliser cette fonction en conjonction avec les 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() et QWidget::font().

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 setGeometry() à l'intérieur d'un moveEvent() peut conduire à une boucle infinie.

Regardez la documentation de la 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, size, x() et y().

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(), height()).

Regardez la documentation de la 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.

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() et 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 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, geometry, minimumSize, maximumSize et resizeEvent().

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(), minimumSizeHint(), sizePolicy(), setMinimumSize() et updateGeometry().

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() pixels et verticalement de sizeIncrement.height(), avec 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, minimumSize et maximumSize.

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() 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().

Fonctions d'accès

QSizePolicy sizePolicy () const

void setSizePolicy ( QSizePolicy )

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

Voir aussi sizeHint(), QLayout, QSizePolicy et updateGeometry().

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 et whatsThis.

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 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 et Qt Style Sheets.

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::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::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 et whatsThis.

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 : 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(), isMinimized(), showEvent() et hideEvent().

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, QWidget::toolTip et QWidget::statusTip.

width : const int

Cette propriété détient la longueur du widget en excluant tout cadre de fenêtre.

Regardez la documentation de la 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 écran d'ordinateur avec plusieurs bureaux. Lisez 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.

Fonctions d'accès

int width () const

Voir aussi geometry, height et size.

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().

Sous Windows et X11 :

• le nom de fichier du chemin spécifié, obtenu à l'aide de QFileInfo::fileName() ;
• un caractère * optionnel, si la propriété 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 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'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 windowTitle et windowIcon.

windowFlags : Qt::WindowFlags

Les drapeaux de fenêtre sont une combinaison d'un type (par exemple Qt::Dialog) et de zéros ou plusieurs indications au système de fenêtrage (par exemple Qt::FramelessWindowHint).

Si le widget est de type Qt::Widget ou Qt::SubWindow, et qu'il devient une fenêtre (Qt::Window, 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::Widget ou une 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::WindowFlags type )

Voir aussi windowType() et l'exemple Window Flags.

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()).

Fonctions d'accès

QIcon windowIcon () const

void setWindowIcon ( const QIcon & icon )

Voir aussi windowIconText et windowTitle.

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 et windowTitle.

windowModality : 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::NonModal.

Cette propriété a été introduite dans Qt 4.1.

Fonctions d'accès

Qt::WindowModality windowModality () const

void setWindowModality ( Qt::WindowModality windowModality )

Voir aussi isWindow(), QWidget::modal et QDialog.

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, l'exemple Application, l'exemple SDI et l'exemple MDI.

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(). 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 : 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. 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, 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, windowIconText, windowModified et windowFilePath.

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 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, y et pos.

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 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, x et pos.

Fonctions membres

QWidget::QWidget ( QWidget * parent = 0, 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 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.

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.

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.

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

Retourne la liste (pouvant être vide) des actions du widget.

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

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(), window() et show().

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.

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

Ajoute les actions actions à la liste d'actions de ce widget.

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

void QWidget::adjustSize ()

Ajuste la taille du widget pour s'adapter à son contenu.

Cette fonction utilise 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() est inférieure à (200, 100) et que la politique de dimensionnement est 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() et childrenRect().

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 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().

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::ToolBarChange, QEvent::ActivationChange, QEvent::EnabledChange, QEvent::FontChange, QEvent::StyleChange, QEvent::PaletteChange, QEvent::WindowTitleChange, QEvent::IconTextChange, QEvent::ModifiedChange, QEvent::MouseTrackingChange, QEvent::ParentChange, QEvent::WindowStateChange, QEvent::LanguageChange, QEvent::LocaleChange, QEvent::LayoutDirectionChange.

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.

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.

void QWidget::clearFocus ()

Reprend le focus d'entrée de clavier depuis le widget.

Si le widget détient un focus actif, un é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 setFocusPolicy().

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

void QWidget::clearMask ()

Retire tout masque défini par setMask().

Voir aussi setMask().

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 caché s'il accepte l'événement de fermeture. S'il ignore l'événement, rien ne se passe. L'implémentation par défaut de QWidget::closeEvent() accepte l'événement de fermeture.

Si le widget détient le drapeau 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() est émis quand la dernière fenêtre principale visible (c'est-à-dire une fenêtre sans parent) avec l'attribut 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.

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, 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 l'exemple Application.

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().

QRect QWidget::contentsRect () const

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

Voir aussi setContentsMargins() et getContentsMargins().

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 du widget est à 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().

void QWidget::create ( 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.

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

Ce signal est émis lorsque la contextMenuPolicy du widget est à Qt::CustomContextMenu et que l'utilisateur a demandé un menu contextuel sur le widget. La position pos est la position de l'événement 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 viewport().

Voir aussi mapToGlobal(), QMenu et contextMenuPolicy.

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.

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 mouvement par glissement.

Regardez la documentation du 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.

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

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

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

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().

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(). Notez que cette fonction est appelée depuis l'implémentation par défaut de 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::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()).

Voir aussi event().

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().

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

Réimplémentation de 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 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), 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() et QObject::timerEvent().

QWidget * QWidget::find ( 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é.

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 setFocusPolicy() à quelque chose d'autre que 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()).

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

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().

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().

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 setFocusPolicy() à quelque chose d'autre que 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()).

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

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().

QWidget * QWidget::focusProxy () const

Retourne le proxy du focus, ou 0 s'il n'y en a pas.

Voir aussi setFocusProxy().

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(), qui retourne le widget ayant le focus dans la fenêtre active.

QFontInfo QWidget::fontInfo () const

Retourne l'information de police pour l'actuelle police du widget. C'est l'équivalent de QFontInto(widget->font()).

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

QFontMetrics QWidget::fontMetrics () const

Retourne les métriques de police pour l'actuelle police du widget. C'est l'équivalent de QFontMetrics(widget->font()).

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

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 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().

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().

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.

void QWidget::grabGesture ( Qt::GestureType gesture, 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.

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().

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 isVisible() retourne false pour un widget, ce widget ne pourra pas appeler grabMouse().

Note aux 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().

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 aux développeurs Mac OS X : regarder la note dans QWidget::grabMouse().

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

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

Ajoute un raccourci au système de raccourcis de Qt qui surveille la séquence key dans le context donné. Si le context est Qt::ApplicationShortcut, le raccourci s'applique à l'application dans son ensemble. Dans le cas contraire, il est local à ce widget, Qt::WidgetShortcut, ou à la fenêtre elle-même, Qt::WindowShortcut.

Si la même séquence de touches (key) a été saisie par d'autres widgets, lorsqu'elle a lieu, un 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 QActions, 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().

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().

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() et QGraphicsScene::addWidget().

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 setEditFocus() et QApplication::keypadNavigationEnabled().

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.

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(), setVisible(), isVisible() et close().

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 isVisible().

Voir aussi visible, event() et QHideEvent.

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().

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

QVariant QWidget::inputMethodQuery ( 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.

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 et actions().

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.

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.

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 isEnabled().

Voir aussi setEnabled() et enabled.

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 !isVisible() au lieu de cette fonction (notez le point d'exclamation).

isHidden() implique !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.

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 à isVisible().

Voir aussi show(), hide() et isVisible().

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 titre de fenêtre.

Une fenêtre peut avoir un 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::Window.

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

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 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 QKeyEvent::accep(). N'appelez pas l'implémentation de base de classe si vous agissez juste sur la touche.

Voir aussi keyReleaseEvent(), setFocusPolicy(), focusInEvent(), focusOutEvent(), event(), QKeyEvent et l'exemple Tetrix.

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 accepter le focus et 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 QKeyEvent::accep() - n'appelez pas l'implémentation de base de classe si vous agissez juste sur la touche.

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

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().

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() et gestion des layout.

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().

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().

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.

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().

Voir aussi QApplication::macEventFilter().

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.

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().

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().

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().

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().

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().

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().

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() et l'exemple Shaped Clock.

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

Réimplémentation de QPaintDevice::metric().

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

m est la métrique à obtenir.

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.

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().

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() 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() 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() au lieu de setToolTip() dans votre implémentation de mouseMoveEvent().

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

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 l'exemple Scribble.

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 l'exemple Scribble.

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().

Voir aussi resizeEvent(), event(), move() et QMoveEvent.

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().

QWidget * QWidget::nextInFocusChain () const

Retourne le widget suivant dans la chaîne de focus du widget.

Voir aussi previousInFocusChain().

void QWidget::overrideWindowFlags ( 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 setWindowFlags().

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

Réimplémentation de 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.

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(). 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(). 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 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::WA_PaintOnScreen doit être défini. Dans le cas contraire, 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 l'exemple Analog Clock.

QWidget * QWidget::parentWidget () const

Retourne le widget parent ou 0 s'il n'y a pas de widget parent.

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().

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().

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().

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.

void QWidget::releaseKeyboard ()

Libère la saisie du clavier.

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

void QWidget::releaseMouse ()

Libère la saisie des entrées de la souris.

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

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::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().

void QWidget::removeAction ( QAction * action )

Retire l'action action depuis la liste d'actions de ce widget.

Voir aussi insertActions(), actions() et insertAction().

void QWidget::render ( QPaintDevice * target, const QPoint & targetOffset = QPoint(), const QRegion & sourceRegion = QRegion(), 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 QWidget::rect() comme région, c'est-à-dire le widget entier.

Assurez-vous que vous appelé 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() ou QGLWidget::renderPixmap().

Cette fonction a été introduite dans Qt 4.3.

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

Il s'agit d'une fonction surchargée.

Rend le widget dans le 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().

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 setUpdatesEnabled().

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.

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.

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.

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().

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(), resize(), QResizeEvent, paintEvent() et l'exemple Scribble.

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 géométrie de la fenêtre pour un aperçu des questions de géométrie avec les fenêtres.

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

Cette fonction a été introduite dans Qt 4.2.

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

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 géométrie de la fenêtre pour un aperçu des questions de géométrie avec les fenêtres.

Utilisez 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() et QMainWindow::restoreState().

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, ou d'utiliser setAttribute(), ou de définir l'attribut 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 transparence et double-buffering.

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.

void QWidget::setAttribute ( 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().

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

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

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

Si role est 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().

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().

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().

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'activation pour plus d'informations.

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

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_Up et 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().

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(), minimumSize(), maximumSize() et 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::SetFixedSize);

Voir aussi maximumSize et minimumSize.

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.

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(), maximumSize() et setFixedSize().

void QWidget::setFocus ( 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 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::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(), setFocusPolicy(), focusWidget(), QApplication::focusWidget(), grabKeyboard(), grabMouse(), Keyboard Focus et QEvent::RequestSoftwareInputPanel.

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 fenêtre active.

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 hasFocus() opèrent sur le proxy de focus.

Voir aussi focusProxy().

void QWidget::setForegroundRole ( 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 du widget utilisée pour dessiner le premier plan.

Si role est 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().

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().

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

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

Voir aussi isHidden().

void QWidget::setInputContext ( QInputContext * context )

Cette fonction définit le contexte d'entrée context sur ce widget.

Qt prend possession du contexte d'entrée donné context.

Voir aussi inputContext().

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 la gestion des layout.

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() 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() et l'exemple Shaped Clock.

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.

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 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 setWindowFlag().

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

Il s'agit d'une fonction surchargée.

Cette fonction prend aussi les drapeaux du widget, f, comme argument.

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().

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().

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() 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() et QApplication::setStyle().

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 setFocusPolicy(), setFocusProxy() et Keyboard Focus.

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().

void QWidget::setWindowState ( 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 : Qt::WindowMinimized, Qt::WindowMaximized, Qt::WindowFullScreen et Qt::WindowActive.

Si la fenêtre n'est pas visible (c'est-à-dire que 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::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::WindowStateChange.

Voir aussi Qt::WindowState et windowState().

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().

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 Utilisé un fichier de design UI dans votre application.

void QWidget::show () [slot]

Affiche le widget ainsi que ses enfants. C'est l'équivalent de setVisible(true).

Voir aussi raise(), showEvent(), hide(), setVisible(), showMinimized(), showMaximized(), showNormal() et isVisible().

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, event() et QShowEvent.

void QWidget::showFullScreen () [slot]

Affiche le widget dans le mode plein écran.

Appeler cette fonction n'affecte que les 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::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 isVisible().

void QWidget::showMaximized () [slot]

Affiche le widget maximisé.

Appeler cette fonction n'affecte que les fenêtres.

Sous X11, cette fonction peut ne pas fonctionner correctement avec quelques gestionnaires de fenêtrage. Regardez la documentation de la géométrie des fenêtres pour plus de détails.

Voir aussi setWindowState(), showNormal(), showMinimized(), show(), hide() et isVisible().

void QWidget::showMinimized () [slot]

Affiche le widget minimisé, comme une icône.

Appeler cette fonction n'affecte que les fenêtres.

Voir aussi showNormal(), showMaximized(), show(), hide(), isVisible() et isMinimized().

void QWidget::showNormal () [slot]

Restaure le widget après qu'il soit maximisé ou minimisé.

Appeler cette fonction n'affecte que les fenêtres.

Voir aussi setWindowState(), showMinimized(), showMaximized(), show(), hide() et isVisible().

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().

QStyle * QWidget::style () const

Voir aussi QWidget::setStyle(), QApplication::setStyle() et QApplication::style().

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 (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 QTabletEvent::ignore(), QTabletEvent::accept(), event() et QTabletEvent.

bool QWidget::testAttribute ( 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().

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().

void QWidget::ungrabGesture ( 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.

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::WA_OpaquePaintEvent est défini, le widget est responsable de la peinture de tous ses pixels avec une couleur opaque.

Voir aussi repaint(), paintEvent(), setUpdatesEnabled() et l'exemple Analog Clock.

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.

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.

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.

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() ou 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é.

void QWidget::updateMicroFocus () [protected slot]

Actualise le micro focus du widget.

Voir aussi QInputContext.

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.

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 (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 QWheelEvent::ignore(), QWheelEvent::accept(), event() et QWheelEvent.

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 QApplication::winEventFilter().

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::WinIdChange sera envoyé au widget après un changement dans l'identifiant du système de fenêtrage.

Voir aussi find().

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().

QString QWidget::windowRole () const

Retourne le rôle de la fenêtre ou une chaîne de caractères vide.

Voir aussi setWindowRole(), windowIcon et windowTitle.

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 : Qt::WindowMinimized, Qt::WindowMaximized, Qt::WindowFullScreen et Qt::WindowActive.

Voir aussi Qt::WindowState et setWindowState().

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().

Qt::WindowType QWidget::windowType () const

Retourne le type de fenêtre de ce widget. Elle est identique à windowFlags() & Qt::WindowType_Mask.

Voir aussi windowFlags().

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() et QWidget::winId().

const QX11Info & QWidget::x11Info () const

Retourne des informations à propos de la configuration de l'affichage X utilisé pour afficher le widget.

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

typedef QWidgetList

Synonyme pour QList<QWidget *>.

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 QWidget::setMaximumSize().

Remerciements

Merci à Louis du Verdier pour la traduction et à Jonathan Courtois, Thibaut Cuvelier ainsi qu'à Jacques Thery pour leur relecture !