QGraphicsWidget Class

Documentation des fonctions membres

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

Crée une instance de `QGraphicsWidget`. L'argument facultatif ` parent ` est transmis au constructeur de ` QGraphicsItem`. L'argument facultatif ` wFlags ` spécifie les indicateurs de fenêtre du widget (par exemple, si le widget doit être une fenêtre, un outil, une fenêtre contextuelle, etc.).

[virtual noexcept] QGraphicsWidget::~QGraphicsWidget()

Supprime l'instance de ` QGraphicsWidget `.

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

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

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

void QGraphicsWidget::addAction(QAction *action)

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

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

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

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

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

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

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

void QGraphicsWidget::adjustSize()

Ajuste la taille du widget en fonction de sa taille préférée effective.

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

Voir également effectiveSizeHint() et Qt::MinimumSize.

[override virtual] QRectF QGraphicsWidget::boundingRect() const

Réimplémente : QGraphicsItem::boundingRect() const.

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

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

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

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

[slot] bool QGraphicsWidget::close()

Appelez cette fonction pour fermer le widget.

Renvoie « true » si le widget a été fermé ; sinon, renvoie « false ». Ce slot envoie d’abord un événement « QCloseEvent » au widget, qui peut accepter ou ignorer cet événement. Si l’événement est ignoré, rien ne se passe. S’il est accepté, il appelle la fonction « hide() » sur le widget.

Si le widget dispose de l’attribut « Qt::WA_DeleteOnClose », il sera supprimé.

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

Ce gestionnaire d'événements, destiné à event, peut être réimplémenté dans une sous-classe afin de recevoir les événements de fermeture du widget. L'implémentation par défaut accepte l'événement.

Voir également close() et QCloseEvent.

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

Réimplémente : QGraphicsObject::event(QEvent *ev).

Gère l'event. QGraphicsWidget gère les événements suivants :

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

Réimplémente : QGraphicsItem::focusInEvent(QFocusEvent *event).

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

Recherche un nouveau widget auquel attribuer le focus du clavier, selon que l'on utilise la touche Tab ou Maj+Tab, et renvoie ` true ` si elle trouve un nouveau widget ; renvoie ` false ` dans le cas contraire. Si ` next ` est vrai, cette fonction effectue une recherche vers l'avant ; si ` next ` est faux, elle effectue une recherche vers l'arrière.

Il vous arrivera parfois de vouloir réimplémenter cette fonction afin de fournir une gestion spéciale du focus pour votre widget et ses sous-widgets. Par exemple, un navigateur Web pourrait la réimplémenter pour faire avancer ou reculer le lien actuellement actif, et n’appeler l’implémentation de base que lorsqu’il atteint le dernier ou le premier lien de la page.

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

Voir également ` focusPolicy()`.

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

Réimplémente : QGraphicsItem::focusOutEvent(QFocusEvent *event).

QGraphicsWidget *QGraphicsWidget::focusWidget() const

Si ce widget, l'un de ses enfants ou l'un de ses descendants, a actuellement le focus, cette fonction renvoie un pointeur vers ce widget. Si aucun widget descendant n'a le focus, la valeur « nullptr » est renvoyée.

Voir également QGraphicsItem::focusItem() et QWidget::focusWidget().

[signal] void QGraphicsWidget::geometryChanged()

Ce signal est émis chaque fois que la géométrie est modifiée dans la méthode setGeometry().

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

Réimplémente : ` QGraphicsLayoutItem::getContentsMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const`.

Récupère les marges de contenu du widget. Les marges sont stockées dans left, top, right et bottom, sous forme de pointeurs vers des qreals. Chaque argument peut être omis en passant nullptr.

Voir également setContentsMargins().

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

Récupère les marges du cadre de la fenêtre du widget. Les marges sont stockées dans left, top, right et bottom sous forme de pointeurs vers des qreals. Chaque argument peut être omis en passant nullptr.

Voir également setWindowFrameMargins() et windowFrameRect().

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

Ce gestionnaire d'événements, destiné à event, peut être réimplémenté dans une sous-classe afin de recevoir des notifications concernant les événements QEvent::GrabKeyboard.

Voir également grabKeyboard() et grabMouse().

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

Ce gestionnaire d'événements, destiné à event, peut être réimplémenté dans une sous-classe afin de recevoir des notifications concernant les événements QEvent::GrabMouse.

Voir également grabMouse() et grabKeyboard().

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

Ajoute un raccourci au système de raccourcis de Qt qui surveille la touche spécifiée sequence dans l’ context indiquée. Si l’ context est Qt::ApplicationShortcut, le raccourci s’applique à l’ensemble de l’application. Sinon, il est soit local à ce widget ( Qt::WidgetShortcut), soit à la fenêtre elle-même ( Qt::WindowShortcut). Pour les widgets qui ne font pas partie d’une fenêtre (c’est-à-dire les widgets de niveau supérieur et leurs enfants), Qt::WindowShortcut les raccourcis s’appliquent à la scène.

Si la même combinaison de touches sequence a été capturée par plusieurs widgets, lorsqu’un événement de touche sequence 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 » défini sur true.

Voir également releaseShortcut(), setShortcutEnabled() et QWidget::grabShortcut().

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

Ce gestionnaire d'événements, destiné aux événements « Hide », est déclenché après que le widget a été masqué, par exemple lorsque la méthode `setVisible(false)` a été appelée pour le widget ou l'un de ses ancêtres alors que le widget était auparavant affiché.

Vous pouvez réimplémenter ce gestionnaire d’événements pour détecter quand votre widget est masqué. L’appel de ` QEvent::accept()` ou ` QEvent::ignore()` sur ` event ` n’a aucun effet.

Voir également showEvent(), QWidget::hideEvent() et ItemVisibleChange.

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

Réimplémente : QGraphicsItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event).

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

Réimplémente : QGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event).

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

Remplit un objet d'options de style pour ce widget en fonction de son état actuel, et stocke le résultat dans ` option`. L'implémentation par défaut remplit ` option ` avec les propriétés suivantes.

Les sous-classes de ` QGraphicsWidget ` doivent appeler l'implémentation de base, puis vérifier le type de ` option ` à l'aide de ` qstyleoption_cast<>()` ou tester ` QStyleOption::Type ` avant de stocker les options spécifiques au widget.

Par exemple :

void MyGroupBoxWidget::initStyleOption(QStyleOption *option) const
{
    QGraphicsWidget::initStyleOption(option);
    if (QStyleOptionGroupBox *box = qstyleoption_cast<QStyleOptionGroupBox *>(option)) {
        // Add group box specific state.
        box->text = tr("My Group Box");
        //...
    }
}

Voir également ` QStyleOption::initFrom()`.

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

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

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

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

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

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

Un « QGraphicsWidget » peut comporter au maximum une instance de chaque action.

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

bool QGraphicsWidget::isActiveWindow() const

Renvoie « true » si la fenêtre de ce widget fait partie de la fenêtre active, ou si le widget ne dispose pas de fenêtre mais se trouve dans une scène active (c'est-à-dire une scène qui a actuellement le focus).

La fenêtre active est celle qui contient un widget enfant ayant actuellement le focus, ou celle qui a elle-même le focus.

Voir également QGraphicsScene::activeWindow(), QGraphicsScene::setActiveWindow() et isActive().

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

Réimplémente : QGraphicsItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value).

QGraphicsWidget utilise l’implémentation de base de cette fonction pour détecter et transmettre les événements liés aux changements d’état de l’élément. C’est pourquoi il est très important que les sous-classes appellent l’implémentation de base.

change spécifie le type de changement, et value correspond à la nouvelle valeur.

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

QGraphicsWidget active par défaut l'indicateur ItemSendsGeometryChanges afin de suivre les changements de position.

Voir également QGraphicsItem::itemChange().

QGraphicsLayout *QGraphicsWidget::layout() const

Renvoie la mise en page de ce widget, ou ` nullptr ` si aucune mise en page ne gère actuellement ce widget.

Voir aussi setLayout().

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

Ce gestionnaire d'événements, destiné aux événements « GraphicsSceneMove », est déclenché après le déplacement du widget (c'est-à-dire lorsque sa position locale a changé).

Cet événement n'est déclenché que lorsque l'élément est déplacé localement. L'appel de la méthode ` setTransform()` ou le déplacement de l'un des ancêtres de l'élément n'affecte pas la position locale de ce dernier.

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

Voir également ItemPositionChange et ItemPositionHasChanged.

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

Réimplémente : QGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget).

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

Cette fonction virtuelle est appelée par ` QGraphicsScene ` pour dessiner le cadre de la fenêtre pour les fenêtres utilisant ` painter`, ` option` et ` widget`, en coordonnées locales. L'implémentation de base utilise le style actuel pour afficher le cadre et la barre de titre.

Vous pouvez réimplémenter cette fonction dans une sous-classe de ` QGraphicsWidget ` afin de fournir un rendu personnalisé du cadre de la fenêtre du widget.

Voir également QGraphicsItem::paint().

[virtual protected] void QGraphicsWidget::polishEvent()

Cet événement est transmis à l'élément par la scène à un moment donné après sa construction, mais avant qu'il ne soit affiché ou accessible d'une autre manière via la scène. Vous pouvez utiliser ce gestionnaire d'événements pour effectuer des initialisations de dernière minute du widget qui nécessitent que l'élément soit entièrement construit.

L'implémentation de base ne fait rien.

QRectF QGraphicsWidget::rect() const

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

Voir également setGeometry() et resize().

void QGraphicsWidget::releaseShortcut(int id)

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

Voir également grabShortcut(), setShortcutEnabled() et QWidget::releaseShortcut().

void QGraphicsWidget::removeAction(QAction *action)

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

Voir également insertAction(), actions() et QWidget::removeAction().

void QGraphicsWidget::resize(qreal w, qreal h)

Crée une opération de redimensionnement avec l'width (w) et l'height (h) indiqués. Cette fonction pratique équivaut à appeler resize(QSizeF(w, h)).

Voir également setGeometry() et setTransform().

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

Ce gestionnaire d'événements, destiné aux événements « GraphicsSceneResize », est déclenché après le redimensionnement du widget (c'est-à-dire lorsque sa taille locale a changé). La variable « event » contient à la fois l'ancienne et la nouvelle taille.

Cet événement n'est déclenché que lorsque le widget est redimensionné localement ; l'appel de la méthode setTransform() sur le widget, l'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énement pour détecter quand votre widget a été redimensionné. L’appel de ` QEvent::accept()` ou ` QEvent::ignore()` sur ` event ` n’a aucun effet.

Voir également ` geometry()` et ` setGeometry()`.

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

Réimplémente : QGraphicsItem::sceneEvent(QEvent *event).

QGraphicsWidgetL'implémentation de `sceneEvent()` transmet simplement ` event ` à ` QGraphicsWidget::event()`. Vous pouvez gérer tous les événements de votre widget dans ` event()` ou dans l'une des fonctions de commodité ; vous ne devriez pas avoir à réimplémenter cette fonction dans une sous-classe de ` QGraphicsWidget`.

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

Voir également QGraphicsItem::sceneEvent().

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

Si la valeur de ` on ` est `true`, cette fonction active ` attribute` ; dans le cas contraire, ` attribute ` est désactivé.

Consultez la documentation de la classe QGraphicsWidget pour obtenir la liste complète des attributs pris en charge et connaître leur utilité.

Voir également testAttribute() et QWidget::setAttribute().

void QGraphicsWidget::setContentsMargins(QMarginsF margins)

Définit les marges de contenu du widget sur margins.

Les marges de contenu sont utilisées par la mise en page attribuée pour définir l’emplacement des sous-widgets et des mises en page. Les marges sont particulièrement utiles pour les widgets qui limitent les sous-widgets à une seule partie de leur propre géométrie. Par exemple, une zone de groupe dotée d’une mise en page placera les sous-widgets à l’intérieur de son cadre, mais sous le titre.

La modification des marges de contenu d’un widget déclenchera toujours un appel à la fonction ` update()`, et toute mise en page associée sera automatiquement activée. Le widget recevra alors un événement ` ContentsRectChange `.

Voir également getContentsMargins() et setGeometry().

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

Définit les marges du contenu du widget sur left, top, right et bottom.

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

Cette fonction pratique équivaut à appeler `setGeometry(QRectF( x, y, w, h))`.

Voir également geometry() et resize().

void QGraphicsWidget::setLayout(QGraphicsLayout *layout)

Définit la mise en page de ce widget sur « layout ». Tout gestionnaire de mise en page existant est supprimé avant l'attribution de la nouvelle mise en page. Si « layout » est égal à « nullptr », le widget se retrouve sans mise en page. Les géométries des sous-widgets existants ne sont pas affectées.

Tous les widgets actuellement gérés par layout ou par l’ensemble de ses sous-dispositions sont automatiquement rattachés à cet élément. La disposition est ensuite invalidée, et les géométries des widgets enfants sont ajustées en fonction des propriétés geometry() et contentsMargins() de cet élément. Les enfants qui ne sont pas explicitement gérés par layout ne sont pas affectés par la disposition après son attribution à ce widget.

QGraphicsWidget prend possession de ` layout`.

Voir également layout(), QGraphicsLinearLayout::addItem() et QGraphicsLayout::invalidate().

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

Si enabled est défini sur « true », la répétition automatique du raccourci avec l'id on indiquée est activée ; dans le cas contraire, elle est désactivée.

Voir également grabShortcut(), releaseShortcut() et QWidget::setShortcutAutoRepeat().

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

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

Voir également grabShortcut(), releaseShortcut() et QWidget::setShortcutEnabled().

void QGraphicsWidget::setStyle(QStyle *style)

Définit le style du widget sur « style ». « QGraphicsWidget » ne prend pas possession de « style ».

Si aucun style n’est attribué, ou si style est égal à nullptr, le widget utilisera QGraphicsScene::style() (si cette fonction a été définie). Sinon, le widget utilisera QApplication::style().

Cette fonction définit l'attribut ` Qt::WA_SetStyle ` si ` style ` n'est pas ` nullptr` ; sinon, elle efface cet attribut.

Voir également style().

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

Déplace le widget « second » dans l'anneau des widgets de focus, de sorte que le focus clavier passe du widget « first » au widget « second » lorsque l'on appuie sur la touche Tab.

Notez que, l'ordre de tabulation du widget « second » étant modifié, vous devez organiser la chaîne comme suit :

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

etnon pas ainsi :

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

Si first est nullptr, cela indique que second doit être le premier widget à recevoir le focus de saisie lorsque la scène obtient le focus Tab (c’est-à-dire lorsque l’utilisateur appuie sur la touche Tab pour que le focus passe dans la scène). Si second est nullptr, cela indique que first doit être le premier widget à obtenir le focus lorsque la scène obtient le focus BackTab.

Par défaut, l’ordre de tabulation est défini implicitement en fonction de l’ordre de création des widgets.

Voir également « focusPolicy » et « Keyboard Focus in Widgets ».

void QGraphicsWidget::setWindowFrameMargins(QMarginsF margins)

Définit les marges du cadre de la fenêtre du widget sur margins. Les marges par défaut du cadre sont fournies par le style et dépendent des indicateurs de fenêtre actuels.

Si vous souhaitez dessiner votre propre décoration de fenêtre, vous pouvez définir vos propres marges de cadre pour remplacer les marges par défaut.

Voir également unsetWindowFrameMargins(), getWindowFrameMargins() et windowFrameRect().

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

Définit les marges du cadre de la fenêtre du widget sur left, top, right et bottom.

[override virtual] QPainterPath QGraphicsWidget::shape() const

Réimplémente : QGraphicsItem::shape() const.

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

Ce gestionnaire d'événements, destiné aux événements « Show », est déclenché avant l'affichage du widget, par exemple lorsque la méthode `setVisible(true)` a été appelée pour le widget ou l'un de ses ancêtres alors que le widget était auparavant masqué.

Vous pouvez réimplémenter ce gestionnaire d’événements pour détecter le moment où votre widget est affiché. L’appel de ` QEvent::accept()` ou ` QEvent::ignore()` sur ` event ` n’a aucun effet.

Voir également hideEvent(), QWidget::showEvent() et ItemVisibleChange.

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

Réimplémente : QGraphicsLayoutItem::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const.

QStyle *QGraphicsWidget::style() const

Renvoie un pointeur vers le style du widget. Si aucun style n'a été explicitement attribué à ce widget, c'est le style de la scène qui est renvoyé à la place. À son tour, si aucun style n'a été attribué à la scène, cette fonction renvoie QApplication::style().

Voir également setStyle().

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

Renvoie « true » si l'option « attribute » est activée pour ce widget ; sinon, renvoie « false ».

Voir également setAttribute().

[override virtual] int QGraphicsWidget::type() const

Réimplémente : QGraphicsItem::type() const.

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

Ce gestionnaire d'événements, destiné à event, peut être réimplémenté dans une sous-classe afin de recevoir des notifications concernant les événements QEvent::UngrabKeyboard.

Voir également ungrabKeyboard() et ungrabMouse().

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

Ce gestionnaire d'événements, destiné à event, peut être réimplémenté dans une sous-classe afin de recevoir des notifications concernant les événements QEvent::UngrabMouse.

Voir également ungrabMouse() et ungrabKeyboard().

void QGraphicsWidget::unsetWindowFrameMargins()

Rétablit les marges du cadre de la fenêtre à leur valeur par défaut, telle que définie par le style.

Voir également setWindowFrameMargins(), getWindowFrameMargins() et windowFrameRect().

[override virtual protected] void QGraphicsWidget::updateGeometry()

Réimplémente : QGraphicsLayoutItem::updateGeometry().

Si ce widget est actuellement géré par une mise en page, cette fonction informe la mise en page que les indications de taille du widget ont changé et que la mise en page devra peut-être redimensionner et repositionner le widget en conséquence.

Appelez cette fonction si la méthode ` sizeHint()` du widget a été modifiée.

Voir également QGraphicsLayout::invalidate().

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

Ce gestionnaire d'événements, destiné à ` event`, reçoit les événements liés au cadre de la fenêtre si ce widget est une fenêtre. Son implémentation de base prend en charge les interactions par défaut avec le cadre de la fenêtre, telles que le déplacement, le redimensionnement, etc.

Vous pouvez réimplémenter ce gestionnaire dans une sous-classe de ` QGraphicsWidget ` afin de fournir votre propre prise en charge personnalisée des interactions avec le cadre de la fenêtre.

Renvoie ` true ` si l'événement ` event ` a été détecté et traité ; sinon, renvoie ` false`.

Voir également event().

QRectF QGraphicsWidget::windowFrameGeometry() const

Renvoie la géométrie du widget dans les coordonnées du parent, y compris le cadre de la fenêtre.

Voir également windowFrameRect(), getWindowFrameMargins() et setWindowFrameMargins().

QRectF QGraphicsWidget::windowFrameRect() const

Renvoie le rectangle local du widget, y compris le cadre de la fenêtre.

Voir également windowFrameGeometry(), getWindowFrameMargins() et setWindowFrameMargins().

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

Renvoie la section du cadre de fenêtre située à la position pos, ou Qt::NoSection s'il n'y a pas de section du cadre de fenêtre à cette position.

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

Vous pouvez réimplémenter cette fonction si vous souhaitez personnaliser la manière dont une fenêtre peut être déplacée ou redimensionnée de manière interactive. Par exemple, si vous souhaitez autoriser le redimensionnement d’une fenêtre uniquement à partir du coin inférieur droit, vous pouvez réimplémenter cette fonction pour qu’elle renvoie Qt::NoSection pour toutes les sections, à l’exception de Qt::BottomRightSection.

Voir également windowFrameEvent(), paintWindowFrame() et windowFrameGeometry().

Qt::WindowType QGraphicsWidget::windowType() const

Renvoie le type de fenêtre des widgets.

Voir également windowFlags(), isWindow() et isPanel().