QGraphicsWidget

La classe QGraphicsWidget est la classe de base pour tous les éléments widget dans une QGraphicsScene. Plus d'informations...

#include <QGraphicsWidget>

Voir la position dans l'arbre des classes.

Héritage

Hérite de QGraphicsObject et QGraphicsLayoutItem.

Hérité par QGraphicsProxyWidget et QGraphicsWebView.

Cette classe a été introduite dans Qt 4.4.

Description détaillée

La classe QGraphicsWidget est la classe de base pour tous les éléments widget dans une QGraphicsScene.

QGraphicsWidget est un élément de base qui étend QGraphicsItem avec des fonctionnalités supplémentaires. Il a de nombreuses similarités avec QWidget :

• fournit une palette, une police et un style() ;
• définit une géométrie ;
• gère des dispositions avec setLayout() et layout() ;
• gère des raccourcis et des actions avec grabShortcut() et insertAction().

Contrairement à QGraphicsItem, QGraphicsWidget n'est pas une classe abstraite ; vous pouvez créer des instances de QGraphicsWidget sans avoir à la dériver. Cette approche est utile pour des widgets dont l'objet est d'organiser des widgets enfants dans un layout.

QGraphicsWidget peut être utilisé comme base pour vos propres éléments personnalisés si vous avez besoin d'une gestion avancée du focus pour les entrées, par exemple le focus et l'activation par tabulation, ou de gérer des dispositions (layout).

Comme QGraphicsWidget ressemble à QWidget et possède une API similaire, il est plus facile de porter un widget depuis QWidget vers QGraphicsWidget, que vers QGraphicsItem.

Note : les widgets basés sur QWidget peuvent être directement intégrés dans une QGraphicsScene en utilisant QGraphicsProxyWidget.

Les différences significatives entre QGraphicsWidget et QWidget sont :

QGraphicsWidget gère un sous-ensemble des attributs des widget Qt, (Qt::WidgetAttribute), comme décrit dans la table ci-dessous. Les attributs non listés dans cette table ne sont pas gérés ou ne sont pas utilisés.

Bien que QGraphicsWidget hérite à la fois de QObject et de QGraphicsItem, il faut utiliser les fonctions fournies par QGraphicsItem, et pas celles de QObject, pour gérer les relations entre parents et enfants. Ces fonctions contrôlent également l'ordre d'empilage des éléments, en plus de leur parenté.

Note : QObject::parent() devrait toujours renvoyer 0 pour les QGraphicsWidgets mais cette règle n'est pas strictement définie.

Voir aussi QGraphicsProxyWidget, QGraphicsItem et Widgets et Layouts.

Propriétés

autoFillBackground : bool

Cette propriété correspond à l'activation du remplissage automatique de l'arrière-plan du widget.

Si elle est activée, cette propriété fera que Qt remplira l'arrière-plan du widget avant d'invoquer la méthode paint(). La couleur utilisée est celle du rôle QPalette::Window de la palette du widget.

De plus, les widgets de type Windows (fenêtres) sont toujours remplis avec QPalette::Window, sauf si les attributs WA_OpaquePaintEvent ou WA_NoSystemBackground sont activés.

Par défaut, cette propriété est ‹false›.

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

Fonctions d'accès

bool autoFillBackground () const

void setAutoFillBackground ( bool enabled )

Voir aussi Qt::WA_OpaquePaintEvent et Qt::WA_NoSystemBackground.

focusPolicy : Qt::FocusPolicy

Cette propriété spécifie la façon dont le widget accepte le focus clavier.

La règle de gestion du focus est Qt::TabFocus si le widget accepte le focus clavier par tabulation, Qt::ClickFocus si le widget accepte le focus par clic, Qt::StrongFocus s'il accepte les deux et Qt::NoFocus (la valeur par défaut) s'il n'accepte pas le focus.

Vous devez activer le focus clavier du widget s'il traite les événements clavier. Cette activation est généralement faite depuis le constructeur du widget. Par exemple, le constructeur de QLineEdit appelle setFocusPolicy(Qt::StrongFocus).

Si vous activez une règle de gestion du focus (c'est-à-dire, autre que Qt::NoFocus), QGraphicsWidget activera automatiquement le drapeau ItemIsFocusable. Spécifier Qt::NoFocus pour un widget désactivera le drapeau ItemIsFocusable, et si le widget possède le focus clavier, il le perdra automatiquement.

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é contient la police de caractères du widget.

Cette propriété fournit la police du widget.

QFont est composé de propriétés de police explicitement définies et de propriétés héritées implicitement du parent du widget. Par conséquent, font() peut renvoyer une police différente de celle définie par setFont(). Cette organisation vous permet de définir des entrées particulières dans une police sans affecter les entrées héritées de la police.

Quand la police d'un widget change, il résout ses entrées avec son widget parent. Si le widget n'a pas de widget parent, il résout ses entrées avec la scène. Le widget s'envoie ensuite à lui-même un événement FontChange et notifie à ses descendants afin qu'ils puissent également résoudre leur police.

Par défaut, cette propriété contient la police par défaut de l'application.

Fonctions d'accès

QFont font () const

void setFont ( const QFont & font )

Voir aussi QApplication::font(), QGraphicsScene::font et QFont::resolve().

geometry : QRectF

Cette propriété contient la géométrie du widget.

Définit rect comme géométrie de l'élément. La position et la taille de l'élément sont modifiées suite à l'appel de cette fonction. L'élément est d'abord déplacé, puis redimensionné.

Un effet secondaire de l'appel de cette fonction est que le widget recevra un événement de déplacement et un événement de redimensionnement. De plus, si le widget est associé à une disposition (layout), la disposition va s'activer.

Fonctions d'accès

virtual void setGeometry ( const QRectF & rect )

void setGeometry ( qreal x, qreal y, qreal w, qreal h )

Signal de notification :

void geometryChanged ()

Voir aussi geometry() et resize().

layout : QGraphicsLayout *

Cette propriété contient la disposition associée au widget.

Un éventuel gestionnaire de disposition préexistant sera supprimé avant l'ajout de la nouvelle disposition. Si layout vaut 0, le widget n'aura plus de disposition associée. Les géométries des sous-widgets existants ne seront pas affectées.

QGraphicsWidget devient propriétaire de layout.

Tous les widgets actuellement gérés par layout ou une de ses sous-dispositions deviennent automatiquement des enfants de cet élément. La disposition est alors invalidée et les géométries des widgets enfants sont ajustées en fonction de la geometry() et des contentsMargins() de cet élément. Les enfants qui ne sont pas explicitement gérés par layout restent indépendants de layout après qu'il ait été affecté à ce widget.

Si aucune disposition n'est affectée à ce widget, layout() renverra 0.

Fonctions d'accès

QGraphicsLayout * layout () const

void setLayout ( QGraphicsLayout * layout )

layoutDirection : Qt::LayoutDirection

Cette propriété contient la direction de la disposition pour ce widget.

Cette propriété modifie l'attribut Qt::WA_RightToLeft de ce widget et de tous ses descendants. Il active aussi l'attribut Qt::WA_SetLayoutDirection.

La direction de la disposition détermine l'ordre dans lequel le gestionnaire de disposition place horizontalement les sous-widgets de ce widget. La valeur par défaut dépend de la langue et de la localisation de l'application et est typiquement dans la même direction que celle de lecture et d'écriture des mots. Avec Qt::LeftToRight, les sous-widgets sont placés de la gauche du widget vers la droite. Qt::RightToLeft fait le contraire, les widgets sont placés depuis le bord droit vers la gauche.

Les sous-widgets héritent leur direction de disposition du parent. Les widgets de premier niveau héritent leur direction de disposition de QGraphicsScene::layoutDirection. Si vous changez la direction par un appel de setLayoutDirection(), le widget s'enverra à lui-même un événement LayoutDirectionChange et propagera ensuite la nouvelle direction à tous ses descendants.

Fonctions d'accès

Qt::LayoutDirection layoutDirection () const

void setLayoutDirection ( Qt::LayoutDirection direction )

void unsetLayoutDirection ()

Voir aussi QWidget::layoutDirection et QApplication::layoutDirection.

maximumSize : const QSizeF

Cette propriété contient la taille maximale du widget.

Voir aussi setMaximumSize(), maximumSize(), minimumSize et preferredSize.

minimumSize : const QSizeF

Cette propriété contient la taille minimale du widget.

Voir aussi setMinimumSize(), minimumSize(), preferredSize et maximumSize.

palette : QPalette

Cette propriété contient la palette du widget.

La palette fournit des couleurs et des brosses pour des groupes de couleurs (par exemple, QPalette::Button) et pour les états (par exemple, QPalette::Inactive), définissant approximativement l'apparence générale du widget et de ses enfants.

QPalette comprend des groupes de couleurs ayant été définis explicitement et des groupes hérités implicitement depuis le parent du widget. En conséquence, palette() peut renvoyer une palette différente de celle qui a été spécifiée par setPalette(). Cette organisation vous permet de définir des entrées particulières dans une palette sans affecter les entrées héritées de la palette.

Quand la palette d'un widget change, il résout ses entrées avec son widget parent. Si le widget n'a pas de widget parent, il résout ses entrées avec la scène. Le widget s'envoie ensuite à lui-même un événement PaletteChange et notifie à ses descendants afin qu'ils puissent également résoudre leur palette.

Par défaut, cette propriété contient la palette par défaut de l'application.

Fonctions d'accès

QPalette palette () const

void setPalette ( const QPalette & palette )

Voir aussi QApplication::palette(), QGraphicsScene::palette et QPalette::resolve().

preferredSize : const QSizeF

Cette propriété contient la taille préférée du widget.

Voir aussi setPreferredSize(), preferredSize(), minimumSize et maximumSize.

size : QSizeF

Cette propriété contient la taille du widget.

L'appel de resize() redimensionne le widget à une taille size bornée par minimumSize() et maximumSize(). Cette propriété affecte seulement la largeur et la hauteur du widget (c'est-à-dire ses bords inférieur et droit) ; la position du widget et son coin supérieur gauche ne sont pas affectés.

Le redimensionnement d'un widget déclenche un envoi immédiat au widget d'un événement GraphicsSceneResize avec les tailles nouvelle et ancienne du widget. Si le widget est associé à une disposition (layout) au moment de l'événement, la disposition va s'activer et va automatiquement mettre à jour la géométrie des widgets enfants.

Cette propriété n'affecte pas la disposition du widget parent. Si le widget lui-même est géré par la disposition du parent (par exemple, si une disposition a été affectée au widget parent), cette disposition ne s'activera pas.

Par défaut, cette propriété contient une taille avec une largeur et une hauteur à zéro.

Fonctions d'accès

QSizeF size () const

void resize ( const QSizeF & size )

void resize ( qreal w, qreal h )

Signal de notification :

void geometryChanged ()

Voir aussi setGeometry(), QGraphicsSceneResizeEvent et QGraphicsLayout.

sizePolicy : const QSizePolicy

Cette propriété contient les règles de taille pour le widget.

Voir aussi sizePolicy(), setSizePolicy() et QWidget::sizePolicy().

windowFlags : Qt::WindowFlags

Cette propriété contient les drapeaux de fenêtre du widget.

Les drapeaux de fenêtre sont une combinaison d'un type de fenêtre (par exemple, Qt::Dialog) et de plusieurs drapeaux donnant des indications sur le comportement de la fenêtre. Ce comportement est dépendant de la plateforme.

Par défaut, cette propriété ne contient pas de drapeau de fenêtre.

Les fenêtres sont des panneaux. Si vous activez le drapeau Qt::Window, le drapeau ItemIsPanel sera activé automatiquement. Si vous désactivez le drapeau Qt::Window, le drapeau ItemIsPanel sera également désactivé. Notez que le drapeau ItemIsPanel peut être activé indépendamment de Qt::Window.

Fonctions d'accès

Qt::WindowFlags windowFlags () const

void setWindowFlags ( Qt::WindowFlags wFlags )

Voir aussi isWindow() et isPanel().

windowTitle : QString

Cette propriété contient le titre de la fenêtre.

Cette propriété est uniquement utilisée pour les fenêtres.

Par défaut, si aucun titre n'a été spécifié, cette propriété contient une chaîne vide.

Fonctions d'accès

QString windowTitle () const

void setWindowTitle ( const QString & title )

Fonctions membres

QGraphicsWidget::QGraphicsWidget ( QGraphicsItem * parent = 0, Qt::WindowFlags wFlags = 0 )

Construit une instance de QGraphicsWidget. L'argument optionnel parent est passé au constructeur de QGraphicsItem. L'argument optionnel wFlags spécifie les drapeaux de fenêtre du widget (par exemple, si le widget doit être une fenêtre, une barre d'outils, une popup, etc.).

QGraphicsWidget::~QGraphicsWidget ()

Détruit l'instance de QGraphicsWidget.

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

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

Cette fonction a été introduite dans Qt 4.5.

Voir aussi insertAction(), removeAction(), QWidget::actions(), QAction::associatedWidgets() et QAction::associatedGraphicsWidgets().

void QGraphicsWidget::addAction ( QAction * action )

Ajoute l'action à la liste des actions du widget.

Tous les QGraphicsWidgets possèdent une liste de QAction, cependant elles peuvent être représentées graphiquement de différentes façons. L'usage par défaut de la liste des QAction (telle que renvoyée par actions()) est de créer un QMenu contextuel.

Un QGraphicsWidget ne doit posséder qu'un seul exemplaire de chaque action et l'ajout d'une action qu'il possède déjà ne causera pas la duplication de cette action.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi removeAction(), insertAction(), actions() et QWidget::addAction().

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

Ajoute les actions à la liste des actions du widget.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi removeAction(), QMenu, addAction() et QWidget::addActions().

void QGraphicsWidget::adjustSize ()

Ajuste la taille du widget à sa taille préférée effective.

Cette fonction est appelée implicitement lorsque l'élément est affiché pour la première fois.

Voir aussi effectiveSizeHint() et Qt::MinimumSize.

QRectF QGraphicsWidget::boundingRect () const [virtual]

Réimplémentation de QGraphicsItem::boundingRect().

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

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

event permet de connaître l'état qui a été changé dans cet événement.

Les événements de changement incluent : QEvent::ActivationChange, QEvent::EnabledChange, QEvent::FontChange, QEvent::StyleChange, QEvent::PaletteChange, QEvent::ParentChange, QEvent::LayoutDirectionChange et QEvent::ContentsRectChange.

bool QGraphicsWidget::close () [slot]

Appelez cette fonction pour fermer le widget.

Renvoie true si le widget a été fermé ; sinon renvoie false. Cette fonction va d'abord envoyer un événement QCloseEvent au widget, qui peut accepter ou non l'événement. Si l'événement a été ignoré, rien ne se passe. Si l'événement a été accepté, le widget va être masqué.

Si l'attribut Qt::WA_DeleteOnClose du widget est activé, le widget sera supprimé.

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

Ce gestionnaire d'événements, pour event, peut être réimplémenté dans une classe dérivée pour traiter les événements de fermeture du widget. L'implémentation par défaut accepte l'événement.

Voir aussi close() et QCloseEvent.

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

Réimplémentation de QObject::event().

Traite l'événement event. QGraphicsWidget gère les événements suivants.

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

Réimplémentation de QGraphicsItem::focusInEvent().

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

Trouve un nouveau widget auquel donner le focus clavier, pour la touche Tab ou pour Shift+Tab, et renvoie true si elle a trouvé un nouveau widget ; renvoie false sinon. Si next vaut true, cette fonction cherche en avant ; si next vaut false, elle cherche en arrière.

Vous aurez parfois besoin de réimplémenter cette fonction pour définir une gestion spéciale du focus pour votre widget et ses sous-widgets. Par exemple, un navigateur web pourrait la réimplémenter pour déplacer le lien actif vers l'avant ou vers l'arrière et n'appeler l'implémentation qu'en atteignant le premier ou le dernier lien de la page.

Les widgets enfants appellent focusNextPrevChild() sur leur widget parent mais seule la fenêtre contenant les widgets enfants décide d'où rediriger le focus. En réimplémentant cette fonction pour un objet, vous prenez le contrôle de la traversée du focus pour tous les widgets enfants.

Voir aussi focusPolicy().

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

Réimplémentation de QGraphicsItem::focusOutEvent().

QGraphicsWidget * QGraphicsWidget::focusWidget () const

Si ce widget, un enfant ou un descendant de ce widget possède actuellement le focus de saisie, cette fonction renverra un pointeur vers ce widget. Si aucun widget descendant ne possède le focus, elle renvoie 0.

Voir aussi QGraphicsItem::focusItem() et QWidget::focusWidget().

void QGraphicsWidget::geometryChanged () [signal]

Ce signal est émis à chaque fois que la géométrie est changée dans setGeometry().

void QGraphicsWidget::getContentsMargins ( qreal * left, qreal * top, qreal * right, qreal * bottom ) const [virtual]

Réimplémentation de QGraphicsLayoutItem::getContentsMargins().

Donne les marges du contenu du widget. Les marges sont enregistrées dans left, top, right et bottom, qui sont des pointeurs vers des flottants. Chaque argument peut être « omis » en passant 0.

Voir aussi setContentsMargins().

void QGraphicsWidget::getWindowFrameMargins ( qreal * left, qreal * top, qreal * right, qreal * bottom ) const

Donne les marges de la bordure de fenêtre du widget. Les marges sont enregistrées dans left, top, right et bottom, qui sont des pointeurs vers des flottants. Chaque argument peut être « omis » en passant 0.

Voir aussi setWindowFrameMargins() et windowFrameRect().

void QGraphicsWidget::grabKeyboardEvent ( QEvent * event ) [virtual protected]

Ce gestionnaire d'événements, pour event, peut être réimplémenté dans une classe dérivée pour recevoir les notifications pour les événements Qt::GrabKeyboard.

Voir aussi grabKeyboard() et grabMouse().

void QGraphicsWidget::grabMouseEvent ( QEvent * event ) [virtual protected]

Ce gestionnaire d'événements, pour event, peut être réimplémenté dans une classe dérivée pour recevoir les notifications pour les événements Qt::GrabMouse.

Voir aussi grabMouse() et grabKeyboard().

int QGraphicsWidget::grabShortcut ( const QKeySequence & sequence, Qt::ShortcutContext context = Qt::WindowShortcut )

Ajoute un raccourci au système de raccourcis de Qt attaché à la séquence de touches sequence dans le contexte context donné. Si le contexte est Qt::ApplicationShortcut, le raccourci s'applique à l'application entière. Sinon, il est soit local à ce widget (Qt::WidgetShortcut) ou à la fenêtre elle-même (Qt::WindowShortcut). Pour les widgets ne faisant pas partie d'une fenêtre (c'est-à-dire, les widgets de premier niveau et leurs enfants), les raccourcis Qt::WindowShortcut s'appliquent à la scène.

Si la même séquence de touches a été capturée par plusieurs widgets, lorsque la séquence se produit, un événement QEvent::Shortcut est envoyé à tous les widgets auxquels il s'applique, dans un ordre non déterministe mais avec le drapeau ambiguous mis à true.

Attention : vous ne devriez pas avoir à utiliser cette fonction ; à la place, créez des QAction avec les séquences de raccourci que vous souhaitez (si vous voulez des options de menu et des boutons de barre d'outils équivalents) ou créez des QShortcuts si vous avez juste besoin des séquences de touches. QAction et QShortcut gèrent toutes les deux le filtrage des événements pour vous et fournissent des signaux qui sont déclenchés lorsque l'utilisateur déclenche la séquence de touches, donc sont beaucoup plus faciles à utiliser que cette fonction de bas niveau.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi releaseShortcut(), setShortcutEnabled() et QWidget::grabShortcut().

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

Ce gestionnaire d'événements, pour les événements Hide, est transmis après que le widget ait été caché, par exemple si setVisible(false) a été appelé pour ce widget ou un de ses ancêtres alors que le widget était précédemment visible.

Vous pouvez réimplémenter ce gestionnaire d'événements pour détecter le masquage de votre widget. L'appel de QEvent::accept() ou QEvent::ignore() sur event n'a pas d'effet.

Voir aussi showEvent(), QWidget::hideEvent() et ItemVisibleChange.

void QGraphicsWidget::hoverLeaveEvent ( QGraphicsSceneHoverEvent * event ) [virtual protected]

Réimplémentation de QGraphicsItem::hoverLeaveEvent().

void QGraphicsWidget::hoverMoveEvent ( QGraphicsSceneHoverEvent * event ) [virtual protected]

Réimplémentation de QGraphicsItem::hoverMoveEvent().

void QGraphicsWidget::initStyleOption ( QStyleOption * option ) const [virtual protected]

Renseigne un objet option de style pour ce widget basé sur son état courant et enregistre le résultat dans option. L'implémentation par défaut renseigne option avec les propriétés suivantes.

Les classes dérivées de QGraphicsWidget doivent appeler l'implémentation de base et ensuite tester le type d'option en utilisant qstyleoption_cast<>() ou tester QStyleOption::Type avant d'enregistrer des options spécifiques au widget.

Par exemple :

 void MyGroupBoxWidget::initStyleOption(QStyleOption *option) const
 {
     QGraphicsWidget::initStyleOption(option);
     if (QStyleOptionGroupBox *box = qstyleoption_cast<QStyleOptionGroupBox *>(option)) {
         // Ajout de l'état spécifique à la GroupBox.
         box->flat = isFlat();
         ...
     }
 }

Voir aussi QStyleOption::initFrom().

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

Insère l'action action à la liste des actions de ce widget, avant l'action before. Ajoute l'action même si before est 0 ou si before n'est pas une action valide pour ce widget.

Un QGraphicsWidget ne doit posséder qu'un exemplaire de chaque action.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi removeAction(), addAction(), QMenu, actions() et QWidget::insertActions().

void QGraphicsWidget::insertActions ( QAction * before, QList<QAction *> actions )

Insère les actions action à la liste des actions de ce widget, avant l'action before. Ajoute l'action même si before est 0 ou si before n'est pas une action valide pour ce widget.

Un QGraphicsWidget ne doit posséder qu'un exemplaire de chaque action.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi removeAction(), QMenu, insertAction() et QWidget::insertActions().

bool QGraphicsWidget::isActiveWindow () const

Renvoie true si la fenêtre de ce widget est dans la fenêtre active ou si le widget n'a pas de fenêtre mais est dans une scène active (c'est-à-dire une scène qui possède actuellement le focus).

La fenêtre active est la fenêtre qui, soit contient un widget enfant possédant actuellement le focus de saisie, soit possède elle-même le focus de saisie.

Voir aussi QGraphicsScene::activeWindow(), QGraphicsScene::setActiveWindow() et isActive().

QVariant QGraphicsWidget::itemChange ( GraphicsItemChange change, const QVariant & value ) [virtual protected]

Réimplémentation de QGraphicsItem::itemChange().

QGraphicsWidget utilise l'implémentation de base de cette fonction pour capturer et transmettre les événements liés aux changements d'état dans l'élément. Pour cette raison, il est très important que les classes dérivées appellent l'implémentation de base.

change spécifie le type de changement et value est la nouvelle valeur.

Par exemple, QGraphicsWidget utilise ItemVisibleChange pour envoyer les événements Show et Hide, ItemPositionHasChanged pour envoyer les événements Move et ItemParentChange à la fois pour envoyer les événements ParentChange et pour gérer la chaîne de focus.

QGraphicsWidget active le drapeau ItemSendsGeometryChanges par défaut afin de suivre les changements de position.

Voir aussi QGraphicsItem::itemChange().

void QGraphicsWidget::moveEvent ( QGraphicsSceneMoveEvent * event ) [virtual protected]

Ce gestionnaire d'événements, pour les événements GraphicsSceneMove], est appelé après un déplacement du widget (par exemple, si sa position locale a changé). Cet événement est transmis seulement si l'élément est déplacé localement. L'appel de [[qgraphicsitem::setTransform|setTransform() ou le déplacement des ancêtres de l'élément n'affecte pas la position locale de l'élément.

Vous pouvez réimplémenter ce gestionnaire d'événements pour détecter si votre widget est déplacé. L'appel de QEvent::accept() ou QEvent::ignore() sur event n'a pas d'effet.

Voir aussi ItemPositionChange et ItemPositionHasChanged.

void QGraphicsWidget::paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget = 0 ) [virtual]

Réimplémentation de QGraphicsItem::paint().

void QGraphicsWidget::paintWindowFrame ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget = 0 ) [virtual]

Cette fonction virtuelle est appelée par QGraphicsScene pour le dessin de la bordure des fenêtres en utilisant painter, option et widget, en coordonnées locales. L'implémentation de base utilise le style courant pour le rendu de la bordure et de la barre de titre.

Vous pouvez réimplémenter cette fonction dans une classe dérivée de QGraphicsWidget pour fournir un rendu personnalisé de la bordure de fenêtre du widget.

Voir aussi QGraphicsItem::paint().

void QGraphicsWidget::polishEvent () [virtual protected]

Cet événement est transmis à l'élément par la scène après qu'il ait été construit mais avant qu'il ait été affiché ou accédé à travers la scène. Vous pouvez utiliser ce gestionnaire d'événements pour des initialisations finales du widget nécessitant une construction complète de l'élément.

L'implémentation de base ne fait rien.

QRectF QGraphicsWidget::rect () const

Renvoie le rectangle local de l'élément sous forme d'un QRectF. Cette fonction est équivalente à QRectF(QPointF(), size()).

Voir aussi setGeometry() et resize().

void QGraphicsWidget::releaseShortcut ( int id )

Retire le raccourci possédant l'identifiant id donné du système de raccourcis de Qt. Le widget ne recevra plus d'événements QEvent::Shortcut pour la séquence de touches de l'événement (sauf s'il possède d'autres raccourcis sur la même séquence).

Attention : vous ne devriez pas avoir à utiliser cette fonction étant donné que le système de raccourcis de Qt retire automatiquement les raccourcis quand leur widget parent est détruit. Il est préférable d'utiliser QAction ou QShortcut pour gérer les raccourcis, étant donné qu'ils sont plus faciles à utiliser que cette fonction de bas niveau. Notez également que cette opération est coûteuse.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi grabShortcut(), setShortcutEnabled() et QWidget::releaseShortcut().

void QGraphicsWidget::removeAction ( QAction * action )

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

Cette fonction a été introduite dans Qt 4.5.

Voir aussi insertAction(), actions(), insertAction() et QWidget::removeAction().

void QGraphicsWidget::resizeEvent ( QGraphicsSceneResizeEvent * event ) [virtual protected]

Ce gestionnaire d'événements, pour les événements GraphicsSceneResize, est appelé après que le widget ait été redimensionné (c'est-à-dire, que sa taille locale ait changé). event contient à la fois l'ancienne et la nouvelle taille.

Cet événement n'est envoyé que si le widget est redimensionné localement ; l'appel de setTransform() sur le widget ou un de ses ancêtres ou sa vue, n'affecte pas la taille locale du widget.

Vous pouvez réimplémenter ce gestionnaire d'événements pour détecter les redimensionnements de vos widgets. L'appel de QEvent::accept() ou QEvent::ignore() sur event n'a pas d'effet.

Voir aussi geometry() et setGeometry().

bool QGraphicsWidget::sceneEvent ( QEvent * event ) [virtual protected]

Réimplémentation de QGraphicsItem::sceneEvent().

L'implémentation de sceneEvent() par QGraphicsWidget passe simplement event à QGraphicsWidget::event(). Vous pouvez traiter tous les événements de votre widget dans event() ou dans une des fonctions utilitaires apparentées ; vous ne devriez pas avoir à réimplémenter cette fonction dans une classe dérivée de QGraphicsWidget.

Voir aussi QGraphicsItem::sceneEvent().

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

Si on vaut true, cette fonction active attribute ; sinon attribute est désactivé.

Voir la documentation de la classe QGraphicsWidget pour une liste complète des attributs qui sont gérés et de ceux qui ne le sont pas.

Voir aussi testAttribute() et QWidget::setAttribute().

void QGraphicsWidget::setContentsMargins ( qreal left, qreal top, qreal right, qreal bottom )

Fixe les valeurs de marge de contenu du widget à left, top, right et bottom.

Les marges de contenu sont utilisées par la disposition (layout) affectée au widget pour définir le placement des sous-widgets et dispositions. Les marges sont particulièrement utiles pour les widgets qui contraignent leurs sous-widgets à n'occuper qu'une portion de leur propre géométrie. Par exemple, une boîte de groupement (group box) avec une disposition va placer les sous-widgets dans son cadre mais sous le titre.

Le changement des marges de contenu d'un widget déclenchera systématiquement un update() et une disposition affectée sera automatiquement activée. Le widget recevra alors un événement ContentsRectChange.

Voir aussi getContentsMargins() et setGeometry().

void QGraphicsWidget::setShortcutAutoRepeat ( int id, bool enabled = true )

Si enabled vaut true, la répétition automatique du raccourci ayant l'indentifiant id est activée ; sinon elle est désactivée.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi grabShortcut(), releaseShortcut() et QWidget::setShortcutAutoRepeat().

void QGraphicsWidget::setShortcutEnabled ( int id, bool enabled = true )

Si enabled vaut true, le raccourci ayant l'indentifiant id est activé ; sinon il est désactivé.

Attention : vous ne devriez pas avoir à utiliser cette fonction étant donné que le système de raccourcis de Qt active/désactive automatiquement les raccourcis quand leur widget devient visible/invisible ou obtient/perd le focus. Il est préférable d'utiliser QAction ou QShortcut pour gérer les raccourcis, étant donné qu'ils sont plus faciles à utiliser que cette fonction de bas niveau.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi grabShortcut(), releaseShortcut() et QWidget::setShortcutEnabled().

void QGraphicsWidget::setStyle ( QStyle * style )

Spécifie style comme style du widget. QGraphicsWidget ne devient pas propriétaire de style.

Si aucun style n'est affecté ou si style vaut 0, le widget utilisera QGraphicsScene::style() (s'il a été défini). Sinon le widget utilisera QApplication::style().

Cette fonction active l'attribut Qt::WA_SetStyle si style est différent de 0 ; sinon il désactive l'attribut.

Voir aussi style().

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

Déplace le widget second dans la liste circulaire des focus des widgets afin que le focus clavier se déplace du widget first au widget second lorsque la touche de tabulation est appuyée.

Notez qu'étant donné que l'ordre de tabulation du widget second est modifié, vous devez ordonner une chaîne de cette façon :

 setTabOrder(a, b); // a => b
 setTabOrder(b, c); // a => b => c
 setTabOrder(c, d); // a => b => c => d

et non de cette façon :

 // FAUX
 setTabOrder(c, d); // c => d
 setTabOrder(a, b); // a => b ET c => d
 setTabOrder(b, c); // a => b => c mais pas c => d

Si first vaut 0, cela indique que second devrait être le premier widget à recevoir le focus de saisie lorsque la scène obtient le focus par tabulation (c'est-à-dire, lorsque l'utilisateur utilise Tab et qu'en conséquence le focus est donné à la scène). Si second vaut 0, cela indique que first doit être le premier widget à obtenir le focus lorsque la scène obtient le focus par tabulation arrière.

Par défaut, l'ordre de tabulation est défini implicitement par l'ordre de création des widgets.

Voir aussi focusPolicy et Keyboard Focus.

void QGraphicsWidget::setWindowFrameMargins ( qreal left, qreal top, qreal right, qreal bottom )

Spécifie left, top, right et bottom comme marges de bordure de fenêtre du widget. Les marges de bordure par défaut sont fournies par le style et dépendent des drapeaux de fenêtre par défaut.

Si vous souhaitez dessiner vos propres décorations de fenêtre, vous pouvez définir vos propres marges de bordure en remplacement des marges par défaut.

Voir aussi unsetWindowFrameMargins(), getWindowFrameMargins() et windowFrameRect().

QPainterPath QGraphicsWidget::shape () const [virtual]

Réimplémentation de QGraphicsItem::shape().

void QGraphicsWidget::showEvent ( QShowEvent * event ) [virtual protected]

Ce gestionnaire d'événements, pour les événements Show, est appelé avant que le widget ait été affiché, par exemple si setVisible(true) a été appelé pour ce widget ou un de ses ancêtres alors que le widget était précédemment caché.

Vous pouvez réimplémenter ce gestionnaire d'événements pour détecter que votre widget devient visible. L'appel de QEvent::accept() ou QEvent::ignore() sur event n'a pas d'effet.

Voir aussi hideEvent(), QWidget::showEvent() et ItemVisibleChange.

QSizeF QGraphicsWidget::sizeHint ( Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const [virtual protected]

Réimplémentation de QGraphicsLayoutItem::sizeHint().

QStyle * QGraphicsWidget::style () const

Renvoie un pointeur vers le style du widget. Si ce widget n'a pas de style explicitement spécifié, la fonction renvoie le style de la scène, et si la scène n'a pas non plus de style explicitement spécifié, elle renvoie QApplication::style().

Voir aussi setStyle().

bool QGraphicsWidget::testAttribute ( Qt::WidgetAttribute attribute ) const

Renvoie true si attribute est activé pour ce widget ; sinon, renvoie false.

Voir aussi setAttribute().

int QGraphicsWidget::type () const [virtual]

Réimplémentation de QGraphicsItem::type().

void QGraphicsWidget::ungrabKeyboardEvent ( QEvent * event ) [virtual protected]

Ce gestionnaire d'événements, pour event, peut être réimplémenté dans une classe dérivée pour recevoir les notifications des événements Qt::UngrabKeyboard.

Voir aussi ungrabKeyboard() et ungrabMouse().

void QGraphicsWidget::ungrabMouseEvent ( QEvent * event ) [virtual protected]

Ce gestionnaire d'événements, pour event, peut être réimplémenté dans une classe dérivée pour recevoir les notifications des événements Qt::UngrabMouse.

Voir aussi ungrabMouse() et ungrabKeyboard().

void QGraphicsWidget::unsetWindowFrameMargins ()

Réinitialise les marges de bordure de la fenêtre à la valeur par défaut, fournie par le style.

Voir aussi setWindowFrameMargins(), getWindowFrameMargins() et windowFrameRect().

void QGraphicsWidget::updateGeometry () [virtual protected]

Réimplémentation de QGraphicsLayoutItem::updateGeometry().

Si ce widget est actuellement géré par une disposition (layout), cette fonction notifie la disposition que les indications de taille du widget ont changé et que la disposition peut devoir redimensionner et repositionner le widget en conséquence.

Appelez cette fonction si le sizeHint() du widget a changé.

Voir aussi QGraphicsLayout::invalidate().

bool QGraphicsWidget::windowFrameEvent ( QEvent * event ) [virtual protected]

Ce gestionnaire d'événements, pour event, reçoit les événements pour la bordure de fenêtre si le widget est une fenêtre. Son implémentation de base gère les interactions de fenêtre par défaut comme le déplacement, le redimensionnement, etc.

Vous pouvez réimplémenter ce gestionnaire dans une classe dérivée de QGraphicsWidget pour fournir votre propre gestion de l'interaction avec la bordure de fenêtre.

Renvoie true si event a été reconnu et traité ; sinon, renvoie false.

Voir aussi event().

QRectF QGraphicsWidget::windowFrameGeometry () const

Renvoie la géométrie du widget en coordonnées du parent en incluant une éventuelle bordure.

Voir aussi windowFrameRect(), getWindowFrameMargins() et setWindowFrameMargins().

QRectF QGraphicsWidget::windowFrameRect () const

Renvoie le rectangle local du widget, incluant une éventuelle bordure.

Voir aussi windowFrameGeometry(), getWindowFrameMargins() et setWindowFrameMargins().

Qt::WindowFrameSection QGraphicsWidget::windowFrameSectionAt ( const QPointF & pos ) const [virtual protected]

Renvoie la section de bordure de fenêtre à la position pos ou Qt::NoSection s'il n'existe pas de section de bordure de fenêtre à cette position.

Cette fonction est utilisée dans l'implémentation de base de QGraphicsWidget pour l'interaction avec les bordures de fenêtre.

Vous pouvez réimplémenter cette fonction si vous désirez modifier la façon dont une fenêtre peut être interactivement déplacée ou redimensionnée. Par exemple, si vous ne voulez autoriser le redimensionnement que depuis le coin inférieur droit, vous pouvez réimplémenter cette fonction pour renvoyer Qt::NoSection pour toutes les sections sauf Qt::BottomRightSection.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi windowFrameEvent(), paintWindowFrame() et windowFrameGeometry().

Qt::WindowType QGraphicsWidget::windowType () const

Renvoie le type de fenêtre du widget.

Voir aussi windowFlags(), isWindow() et isPanel().

Remerciements

Merci à Ilya Diallo pour la traduction ainsi qu'à Jonathan Courtois et Claude Leloup pour leur relecture !