QGraphicsWidget Class

Documentation des fonctions membres

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

Construit une instance de QGraphicsWidget. L'argument facultatif parent est transmis au constructeur de QGraphicsItem. L'argument facultatif wFlags spécifie les drapeaux 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()

Détruit l'instance QGraphicsWidget.

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

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

Voir aussi 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 ont une liste de QAction, mais ils peuvent être représentés graphiquement de différentes manières. L'utilisation par défaut de la liste QAction (telle que renvoyée par actions()) consiste à créer un contexte QMenu.

Un QGraphicsWidget ne doit avoir qu'une seule action de chaque type et l'ajout d'une action qu'il possède déjà n'entraînera pas la présence de la même action deux fois dans le widget.

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

void QGraphicsWidget::adjustSize()

Ajuste la taille du widget à son indice de taille préférée effective.

Cette fonction est appelée implicitement lorsque l'élément est affiché 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)

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

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

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

[slot] bool QGraphicsWidget::close()

Appeler cette fonction pour fermer le widget.

Retourne true si le widget a été fermé ; sinon, retourne false. Ce slot envoie d'abord un QCloseEvent au widget, qui peut ou non accepter l'événement. Si l'événement est ignoré, il ne se passe rien. Si l'événement est accepté, il renvoie hide() au widget.

Si le widget possède l'attribut Qt::WA_DeleteOnClose, il sera supprimé.

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

Ce gestionnaire d'événements, pour event, peut être réimplémenté dans une sous-classe pour recevoir les événements de fermeture de 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 le site 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 donner le focus clavier, comme approprié pour Tab et Shift+Tab, et renvoie true s'il 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.

Parfois, vous voudrez réimplémenter cette fonction pour fournir une gestion spéciale du focus pour votre widget et ses sous-widgets. Par exemple, un navigateur web peut la réimplémenter pour déplacer son lien actif vers l'avant ou vers l'arrière, 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 focusNextPrevChild() sur leurs widgets parents, mais seule la fenêtre qui contient les widgets enfants décide où rediriger le focus. En réimplémentant cette fonction pour un objet, vous obtenez le contrôle du déplacement 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, un enfant ou un descendant de ce widget a actuellement le focus d'entrée, cette fonction renverra un pointeur vers ce widget. Si aucun widget descendant n'a le focus d'entrée, nullptr est renvoyé.

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

[signal] void QGraphicsWidget::geometryChanged()

Ce signal est émis lorsque la géométrie est modifiée dans 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.

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

Voir aussi setContentsMargins().

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

Obtient 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 qreals. Chaque argument peut être omis en passant nullptr.

Voir aussi setWindowFrameMargins() et windowFrameRect().

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

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

Voir aussi grabKeyboard() et grabMouse().

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

Ce gestionnaire d'événements, pour event, peut être réimplémenté dans une sous-classe pour recevoir des notifications pour les événements QEvent::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 XML qui recherche la touche sequence dans context. Si context est Qt::ApplicationShortcut, le raccourci s'applique à l'ensemble de l'application. Sinon, il est soit local à ce widget, Qt::WidgetShortcut, soit à la fenêtre elle-même, Qt::WindowShortcut. Pour les widgets qui ne font 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 touche sequence a été saisie par plusieurs widgets, lorsque la touche sequence apparaît, un événement QEvent::Shortcut est envoyé à tous les widgets auxquels il s'applique dans un ordre non déterministe, mais avec le drapeau "ambigu" fixé à true.

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

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

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

Vous pouvez réimplémenter ce gestionnaire d'événements pour détecter le moment où votre widget est caché. L'appel à 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'option 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 tester le type de option en utilisant 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->flat = isFlat();
        ...
    }
}

Voir aussi QStyleOption::initFrom().

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

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

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

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

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

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

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

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

bool QGraphicsWidget::isActiveWindow() const

Renvoie true si la fenêtre de ce widget se trouve dans la fenêtre active, ou si le widget n'a 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 la fenêtre qui contient un widget enfant qui a actuellement le focus de saisie, ou qui a elle-même le focus de saisie.

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 attraper et délivrer les événements liés aux changements d'état de l'élément. Pour cette raison, il est très important que les sous-classes 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 transmettre les événements Show et Hide, ItemPositionHasChanged pour transmettre les événements Move et ItemParentChange pour transmettre les événements ParentChange et pour gérer la chaîne de mise au point.

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

Voir également QGraphicsItem::itemChange().

QGraphicsLayout *QGraphicsWidget::layout() const

Renvoie la disposition de ce widget, ou nullptr si aucune disposition ne gère actuellement ce widget.

Voir aussi setLayout().

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

Ce gestionnaire d'événements, pour les événements GraphicsSceneMove, est délivré après que le widget a été déplacé (par exemple, sa position locale a changé).

Cet événement n'est délivré que lorsque l'élément est déplacé localement. L'appel à setTransform() ou le déplacement de l'un 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 le déplacement de votre widget. L'appel à QEvent::accept() ou 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 rendre le cadre et la barre de titre.

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

Voir aussi QGraphicsItem::paint().

[virtual protected] void QGraphicsWidget::polishEvent()

Cet événement est transmis à l'élément par la scène à un moment donné après qu'il a été construit, mais avant qu'il ne soit affiché ou que l'on y accède d'une autre manière par la scène. Vous pouvez utiliser ce gestionnaire d'événement 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 forme de QRectF. Cette fonction est équivalente à QRectF(QPointF(), size()).

Voir également setGeometry() et resize().

void QGraphicsWidget::releaseShortcut(int id)

Supprime le raccourci avec le id donné du système de raccourcis de Qt. Le widget ne recevra plus d'événements QEvent::Shortcut pour la séquence de touches du raccourci (à moins qu'il n'ait d'autres raccourcis avec la même séquence de touches).

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

void QGraphicsWidget::removeAction(QAction *action)

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

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

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

Construit un redimensionnement avec les données width (w) et height (h). Cette fonction de commodité équivaut à appeler resize(QSizeF(w, h)).

Voir aussi setGeometry() et setTransform().

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

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

Cet événement n'est délivré que lorsque le widget est redimensionné localement ; l'appel à setTransform() sur le widget ou sur l'un de ses ancêtres ou de ses vues n'affecte pas la taille locale du widget.

Vous pouvez réimplémenter ce gestionnaire d'événements pour détecter le redimensionnement de votre widget. L'appel à 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() par l'utilisateur transmet simplement event à QGraphicsWidget::event(). Vous pouvez gérer tous les événements de votre widget dans event() ou dans n'importe quelle fonction 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 aussi QGraphicsItem::sceneEvent().

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

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

Voir la documentation de la classe QGraphicsWidget pour une liste complète des attributs pris en charge et de leur fonction.

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

void QGraphicsWidget::setContentsMargins(QMarginsF margins)

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

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

La modification des marges du contenu d'un widget déclenchera toujours un update(), et toute disposition attribuée sera activée automatiquement. 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 à left, top, right et bottom.

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

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

Voir aussi geometry() et resize().

void QGraphicsWidget::setLayout(QGraphicsLayout *layout)

Définit la disposition de ce widget à layout. Tout gestionnaire de disposition existant est supprimé avant que la nouvelle disposition ne soit attribuée. Si layout est nullptr, le widget est laissé sans disposition. Les géométries des sous-bidgets existants ne seront pas affectées.

Tous les widgets qui sont actuellement gérés par layout ou toutes ses sous-calques sont automatiquement orientés vers cet élément. La disposition est alors invalidée et les géométries des widgets enfants sont ajustées en fonction des fonctions 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 qu'elle a été attribuée à ce widget.

QGraphicsWidget prend la propriété de layout.

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

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

Si enabled est vrai, la répétition automatique du raccourci avec le nom id est activée ; sinon, elle est désactivée.

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

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

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

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

void QGraphicsWidget::setStyle(QStyle *style)

Définit le style du widget à style. QGraphicsWidget ne prend pas la propriété de style.

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

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

Voir aussi style().

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

Déplace le widget second autour de l'anneau des widgets de focus de manière à ce que le focus clavier passe du widget first au widget second lorsque la touche Tab est enfoncée.

Notez que puisque l'ordre de tabulation du widget second est modifié, vous devez ordonner une chaîne comme ceci :

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

et non comme ceci :

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

Si first est nullptr, cela indique que second doit être le premier widget à recevoir le focus d'entrée si la scène obtient le focus Tab (c'est-à-dire que l'utilisateur appuie sur Tab pour que le focus passe dans la scène). Si second est nullptr, cela indique que first doit être le premier widget à recevoir le focus si la scène a obtenu le focus BackTab.

Par défaut, l'ordre de tabulation est défini implicitement en utilisant 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 à margins. Les marges du cadre par défaut sont fournies par le style et dépendent des drapeaux de la fenêtre actuelle.

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 à 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, pour les événements Show, est délivré avant que le widget n'ait été affiché, par exemple lorsque setVisible(true) a été appelé pour le widget ou l'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 le moment où votre widget est affiché. L'appel à 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 sur le style du widget. Si ce widget n'a pas de style explicitement assigné, le style de la scène est renvoyé à la place. Si la scène n'a pas de style attribué, cette fonction renvoie QApplication::style().

Voir également setStyle().

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

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

Voir aussi 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, pour event, peut être réimplémenté dans une sous-classe pour recevoir des notifications pour les événements QEvent::UngrabKeyboard.

Voir aussi ungrabKeyboard() et ungrabMouse().

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

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

Voir aussi ungrabMouse() et ungrabKeyboard().

void QGraphicsWidget::unsetWindowFrameMargins()

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

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

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

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

Si ce widget est actuellement géré par un layout, cette fonction notifie au layout que les indices de taille du widget ont changé et que le layout peut avoir besoin de redimensionner et de repositionner le widget en conséquence.

Appeler cette fonction si la valeur de sizeHint() du widget a changé.

Voir également QGraphicsLayout::invalidate().

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

Ce gestionnaire d'événements, pour event, reçoit des événements pour le 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 pour fournir votre propre prise en charge personnalisée de l'interaction avec le cadre de la fenêtre.

Retourne true si event a été reconnu et traité ; sinon, retourne false.

Voir aussi event().

QRectF QGraphicsWidget::windowFrameGeometry() const

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

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

QRectF QGraphicsWidget::windowFrameRect() const

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

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

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

Renvoie la section du cadre de la fenêtre à la position pos, ou Qt::NoSection s'il n'y a pas de section du cadre de la 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 ne voulez autoriser le redimensionnement d'une fenêtre que par le 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 aussi windowFlags(), isWindow() et isPanel().