QGraphicsItem Class

Documentation des fonctions membres

[explicit] QGraphicsItem::QGraphicsItem(QGraphicsItem *parent = nullptr)

Crée un QGraphicsItem à partir de l'élément parent fourni. Cette fonction ne modifie pas l'objet parent renvoyé par la fonction QObject::parent().

Si parent est de type nullptr, vous pouvez ajouter l'élément à une scène en appelant QGraphicsScene::addItem(). L'élément deviendra alors un élément de niveau supérieur.

Voir également QGraphicsScene::addItem() et setParentItem().

[virtual noexcept] QGraphicsItem::~QGraphicsItem()

Supprime l'QGraphicsItem et tous ses éléments enfants. Si cet élément est actuellement associé à une scène, il sera retiré de la scène avant d'être supprimé.

bool QGraphicsItem::acceptDrops() const

Renvoie « true » si cet élément peut accepter les événements de glisser-déposer ; sinon, renvoie « false ». Par défaut, les éléments n'acceptent pas les événements de glisser-déposer ; ils sont transparents à ces événements.

Voir également setAcceptDrops().

bool QGraphicsItem::acceptHoverEvents() const

Renvoie « true » si un élément accepte les événements de survol (QGraphicsSceneHoverEvent) ; sinon, renvoie « false ». Par défaut, les éléments n'acceptent pas les événements de survol.

Voir également setAcceptHoverEvents() et setAcceptedMouseButtons().

bool QGraphicsItem::acceptTouchEvents() const

Renvoie true si un élément accepte touch events; sinon, renvoie false. Par défaut, les éléments n'acceptent pas les événements tactiles.

Voir également setAcceptTouchEvents().

Qt::MouseButtons QGraphicsItem::acceptedMouseButtons() const

Renvoie les boutons de souris pour lesquels cet élément accepte les événements de souris. Par défaut, tous les boutons de souris sont acceptés.

Si un élément accepte un bouton de souris, il devient l'élément « mouse grabber » lorsqu'un événement de clic est déclenché pour ce bouton. Toutefois, si l'élément n'accepte pas ce bouton, QGraphicsScene transmettra les événements de souris au premier élément situé en dessous de lui qui l'accepte.

Voir également setAcceptedMouseButtons() et mousePressEvent().

[virtual] void QGraphicsItem::advance(int phase)

Cette fonction virtuelle est appelée deux fois pour tous les éléments par le slot QGraphicsScene::advance(). Dans un premier temps, tous les éléments sont appelés avec phase == 0, ce qui indique que les éléments de la scène sont sur le point d’avancer, puis tous les éléments sont appelés avec phase == 1. Réimplémentez cette fonction pour mettre à jour votre élément si vous avez besoin d’une animation simple contrôlée par la scène.

L'implémentation par défaut ne fait rien.

Cette fonction est destinée aux animations. Une alternative consiste à hériter plusieurs fois de ` QObject ` et ` QGraphicsItem ` et à utiliser le framework d’animation.

Voir également QGraphicsScene::advance() et QTimeLine.

[pure virtual] QRectF QGraphicsItem::boundingRect() const

Cette fonction purement virtuelle définit les limites extérieures de l'élément sous la forme d'un rectangle ; tout tracé doit se limiter à l'intérieur du rectangle englobant de l'élément. La méthode ` QGraphicsView ` utilise cette fonction pour déterminer si l'élément doit être redessiné.

Bien que la forme de l’élément puisse être arbitraire, le rectangle de délimitation est toujours rectangulaire et n’est pas affecté par la transformation de l’élément.

Si vous souhaitez modifier le rectangle de délimitation de l’élément, vous devez d’abord appeler la fonction prepareGeometryChange(). Cela signale à la scène le changement imminent, afin qu’elle puisse mettre à jour son index de géométrie des éléments ; sinon, la scène ne tiendra pas compte de la nouvelle géométrie de l’élément, et les résultats seront indéfinis (en général, des artefacts de rendu subsistent dans la vue).

Réimplémentez cette fonction pour permettre à QGraphicsView de déterminer quelles parties du widget, le cas échéant, doivent être redessinées.

Remarque : pour les formes qui dessinent un contour ou un trait, il est important d’inclure la moitié de la largeur du trait dans le rectangle de délimitation. Il n’est toutefois pas nécessaire de tenir compte de l’anticrénelage.

Exemple :

QRectF CircleItem::boundingRect() const
{
    qreal penWidth = 1;
    return QRectF(-radius - penWidth / 2, -radius - penWidth / 2,
                  diameter + penWidth, diameter + penWidth);
}

Voir également boundingRegion(), shape(), contains(), Le système de coordonnées de la vue graphique et prepareGeometryChange().

QRegion QGraphicsItem::boundingRegion(const QTransform &itemToDeviceTransform) const

Renvoie la région englobante de cet élément. L'espace de coordonnées de la région renvoyée dépend de ` itemToDeviceTransform`. Si vous passez une ` QTransform ` d'identité en paramètre, cette fonction renverra une région en coordonnées locales.

La région englobante décrit les contours approximatifs du contenu visuel de l’élément. Bien que son calcul soit coûteux, elle est également plus précise que la fonction ` boundingRect()` et peut permettre d’éviter un rafraîchissement inutile lors de la mise à jour d’un élément. Elle s’avère particulièrement efficace pour les éléments fins (par exemple, des lignes ou des polygones simples). Vous pouvez ajuster la granularité de la région englobante en appelant la fonction ` setBoundingRegionGranularity()`. La granularité par défaut est 0 ; dans ce cas, la région englobante de l’élément correspond à son rectangle englobant.

itemToDeviceTransform est la transformation des coordonnées de l’élément en coordonnées de l’appareil. Si vous souhaitez que cette fonction renvoie une ` QRegion ` dans les coordonnées de la scène, vous pouvez passer ` sceneTransform()` en argument.

Voir également boundingRegionGranularity().

qreal QGraphicsItem::boundingRegionGranularity() const

Renvoie la granularité de la région englobante de l'élément ; une valeur comprise entre 0 et 1 inclus. La valeur par défaut est 0 (c'est-à-dire la granularité la plus faible, où la région englobante correspond au rectangle englobant de l'élément).

Voir également ` setBoundingRegionGranularity()`.

QGraphicsItem::CacheMode QGraphicsItem::cacheMode() const

Renvoie le mode de mise en cache de cet élément. Le mode par défaut est « NoCache » (c'est-à-dire que la mise en cache est désactivée et que tout le dessin est immédiat).

Voir également ` setCacheMode()`.

QList<QGraphicsItem *> QGraphicsItem::childItems() const

Renvoie une liste des éléments enfants de cet élément.

Les éléments sont triés selon leur ordre de superposition. Ce tri tient compte à la fois de l'ordre d'insertion des éléments et de leurs valeurs Z.

Voir également setParentItem(), zValue() et Sorting.

QRectF QGraphicsItem::childrenBoundingRect() const

Renvoie le rectangle englobant des descendants de cet élément (c'est-à-dire ses enfants, les enfants de ceux-ci, etc.) en coordonnées locales. Ce rectangle contiendra tous les descendants après leur conversion en coordonnées locales. Si l'élément n'a pas d'enfants, cette fonction renvoie un objet vide ` QRectF`.

Cela n'inclut pas le rectangle englobant de cet élément lui-même ; cette fonction renvoie uniquement le rectangle englobant cumulé de ses descendants. Si vous avez besoin d'inclure le rectangle englobant de cet élément, vous pouvez ajouter boundingRect() à childrenBoundingRect() à l'aide de QRectF::operator|().

Cette fonction a une complexité linéaire ; elle détermine la taille du rectangle englobant renvoyé en parcourant tous les descendants.

Voir également ` boundingRect()` et ` sceneBoundingRect()`.

void QGraphicsItem::clearFocus()

Retire le focus clavier de l'élément.

S'il a le focus, un événement « focus out event » est envoyé à cet élément pour l'informer qu'il est sur le point de perdre le focus.

Seuls les éléments qui activent l’indicateur « ItemIsFocusable », ou les widgets qui définissent une politique de focus appropriée, peuvent accepter le focus clavier.

Voir également setFocus(), hasFocus() et QGraphicsWidget::focusPolicy.

QPainterPath QGraphicsItem::clipPath() const

Renvoie le chemin de découpe de cet élément, ou un objet ` QPainterPath ` vide si cet élément n'est pas découpé. Le chemin de découpe définit les limites de l'apparence et de l'interaction de l'élément (c'est-à-dire qu'il restreint la zone dans laquelle l'élément peut s'afficher et recevoir des événements).

Vous pouvez activer le découpage en définissant les indicateurs ` ItemClipsToShape ` ou ` ItemClipsChildrenToShape `. Le tracé de découpage de l'élément est calculé en intersectant toutes les formes de ses ancêtres de découpage. Si l'élément définit ` ItemClipsToShape`, le découpage final est intersecté avec la forme propre à l'élément.

Voir également isClipped(), shape() et setFlags().

[virtual] bool QGraphicsItem::collidesWithItem(const QGraphicsItem *other, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

Renvoie true si cet élément entre en collision avec other; sinon, renvoie false.

La fonction mode est appliquée à other, puis la forme ou le rectangle englobant ainsi obtenu est comparé à la forme de cet élément. La valeur par défaut de mode est Qt::IntersectsItemShape; other entre en collision avec cet élément s’il le recoupe, s’il le contient ou s’il est contenu par la forme de cet élément (voir Qt::ItemSelectionMode pour plus de détails).

L’implémentation par défaut repose sur l’intersection des formes et appelle la fonction shape() sur les deux éléments. La complexité de l’intersection entre des formes arbitraires augmentant d’un ordre de grandeur lorsque les formes sont complexes, cette opération peut s’avérer particulièrement chronophage. Vous avez la possibilité de réimplémenter cette fonction dans une sous-classe de ` QGraphicsItem ` afin de fournir un algorithme personnalisé. Cela vous permet de tirer parti des contraintes naturelles inhérentes aux formes de vos propres éléments, afin d’améliorer les performances de la détection de collision. Par exemple, la collision entre deux éléments parfaitement circulaires non transformés peut être déterminée très efficacement en comparant leurs positions et leurs rayons.

Gardez à l’esprit que lorsque vous réimplémentez cette fonction et que vous appelez ` shape()` ou ` boundingRect()` sur ` other`, les coordonnées renvoyées doivent être mises en correspondance avec le système de coordonnées de cet élément avant que toute intersection puisse avoir lieu.

Voir également contains() et shape().

[virtual] bool QGraphicsItem::collidesWithPath(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

Renvoie « true » si cet élément entre en collision avec « path ».

La collision est déterminée par mode. La valeur par défaut de mode est Qt::IntersectsItemShape; path entre en collision avec cet élément s’il le recoupe, le contient ou est contenu par la forme de cet élément.

Notez que cette fonction vérifie si la forme de l’élément ou son rectangle englobant (selon la valeur de ` mode`) est contenue dans ` path`, et non si ` path ` est contenue dans la forme ou le rectangle englobant de l’élément.

Voir également collidesWithItem(), contains() et shape().

QList<QGraphicsItem *> QGraphicsItem::collidingItems(Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

Renvoie une liste de tous les éléments qui entrent en collision avec cet élément.

La détection des collisions s'effectue en appliquant la fonction ` mode ` aux éléments comparés à cet élément ; en d'autres termes, la forme ou le rectangle englobant de chaque élément est comparé à la forme de cet élément. La valeur par défaut de ` mode ` est ` Qt::IntersectsItemShape`.

Voir également ` collidesWithItem()`.

QGraphicsItem *QGraphicsItem::commonAncestorItem(const QGraphicsItem *other) const

Renvoie l'élément ancêtre commun le plus proche de cet élément et de other, ou nullptr si l'un des deux éléments other est nullptr, ou s'il n'y a pas d'ancêtre commun.

Voir également isAncestorOf().

[virtual] bool QGraphicsItem::contains(const QPointF &point) const

Renvoie ` true ` si cet élément contient ` point`, qui est exprimé en coordonnées locales ; sinon, la fonction renvoie `false`. Elle est le plus souvent appelée depuis ` QGraphicsView ` pour déterminer quel élément se trouve sous le curseur ; c'est pourquoi l'implémentation de cette fonction doit être aussi légère que possible.

Par défaut, cette fonction appelle ` shape()`, mais vous pouvez la réimplémenter dans une sous-classe afin de fournir une implémentation (peut-être plus efficace).

Voir également shape(), boundingRect() et collidesWithPath().

[virtual protected] void QGraphicsItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)

Ce gestionnaire d'événements peut être réimplémenté dans une sous-classe pour traiter les événements du menu contextuel. Le paramètre ` event ` contient des informations détaillées sur l'événement à traiter.

Si vous ignorez l’événement (par exemple, en appelant ` QEvent::ignore()`), ` event ` se propagera à tous les éléments situés sous cet élément. Si aucun élément n’accepte l’événement, celui-ci sera ignoré par la scène et se propagera à la vue.

Il est courant d’ouvrir une fenêtre « QMenu » en réponse à la réception d’un événement de menu contextuel. Exemple :

void CustomItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
    QMenu menu;
    QAction *removeAction = menu.addAction("Remove");
    QAction *markAction = menu.addAction("Mark");
    QAction *selectedAction = menu.exec(event->screenPos());
    // ...
}

L'implémentation par défaut ignore l’événement.

Voir également sceneEvent().

QCursor QGraphicsItem::cursor() const

Renvoie la forme actuelle du curseur pour l'élément. Le curseur de la souris prendra cette forme lorsqu'il se trouvera au-dessus de cet élément. Consultez la documentation « list of predefined cursor objects » pour découvrir toute une gamme de formes utiles.

Un élément d’éditeur peut souhaiter utiliser un curseur en forme de « I » :

item->setCursor(Qt::IBeamCursor);

Si aucun curseur n'a été défini, c'est celui de l'élément sous-jacent qui est utilisé.

Voir également setCursor(), hasCursor(), unsetCursor(), QWidget::cursor et QGuiApplication::overrideCursor().

QVariant QGraphicsItem::data(int key) const

Renvoie les données personnalisées de cet élément pour la clé « key » sous la forme d’un objet « QVariant ».

Les données personnalisées d'un élément sont utiles pour stocker des propriétés arbitraires dans n'importe quel élément. Exemple :

static const int ObjectName = 0;

QGraphicsItem *item = scene.itemAt(100, 50, transform);
if (item->data(ObjectName).toString().isEmpty()) {
    if (qgraphicsitem_cast<CustomItem *>(item))
        item->setData(ObjectName, "Custom");
}

Qt n'utilise pas cette fonctionnalité pour stocker des données ; elle est fournie uniquement pour la commodité de l'utilisateur.

Voir également ` setData()`

QTransform QGraphicsItem::deviceTransform(const QTransform &viewportTransform) const

Renvoie la matrice de transformation de l'appareil de cet élément, en utilisant viewportTransform pour effectuer la conversion des coordonnées de la scène en coordonnées de l'appareil. Cette matrice peut être utilisée pour convertir les coordonnées et les formes géométriques du système de coordonnées local de cet élément vers le système de coordonnées de la fenêtre d'affichage (ou de n'importe quel appareil). Pour convertir les coordonnées à partir de la fenêtre d'affichage, vous devez d'abord inverser la matrice renvoyée.

Exemple :

QGraphicsRectItem rect;
rect.setPos(100, 100);

rect.deviceTransform(view->viewportTransform()).map(QPointF(0, 0));
// returns the item's (0, 0) point in view's viewport coordinates

rect.deviceTransform(view->viewportTransform()).inverted().map(QPointF(100, 100));
// returns view's viewport's (100, 100) coordinate in item coordinates

Cette fonction revient à combiner la transformation de scène de cet élément avec la transformation de la fenêtre d'affichage, mais elle prend également en charge l'indicateur « ItemIgnoresTransformations ». La transformation du périphérique peut être utilisée pour effectuer une conversion précise des coordonnées (et la détection de collisions) pour les éléments non transformables.

Voir également transform(), setTransform(), scenePos(), Le système de coordonnées de la vue graphique et itemTransform().

[virtual protected] void QGraphicsItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté pour recevoir les événements «drag enter» concernant cet élément. Les événements «drag enter» sont générés lorsque le curseur pénètre dans la zone de l'élément.

En acceptant l’événement (c’est-à-dire en appelant ` QEvent::accept()`), l’élément acceptera les événements « drop », en plus de recevoir les événements « drag move » et « drag leave ». Dans le cas contraire, l’événement sera ignoré et se propagera à l’élément situé en dessous. Si l’événement est accepté, l’élément recevra un événement « drag move » avant que le contrôle ne revienne à la boucle d’événements.

Une implémentation courante de `dragEnterEvent` accepte ou ignore ` event ` en fonction des données MIME associées dans ` event`. Exemple :

CustomItem::CustomItem()
{
    setAcceptDrops(true);
    //...
}

void CustomItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
{
    event->setAccepted(event->mimeData()->hasFormat("text/plain"));
}

Par défaut, les éléments ne reçoivent pas d’événements de glisser-déposer ; pour activer cette fonctionnalité, appelez ` setAcceptDrops(true)`.

L’implémentation par défaut ne fait rien.

Voir également dropEvent(), dragMoveEvent() et dragLeaveEvent().

[virtual protected] void QGraphicsItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté pour recevoir les événements «drag leave» concernant cet élément. Les événements «drag leave» sont générés lorsque le curseur quitte la zone de l'élément. La plupart du temps, vous n'aurez pas besoin de réimplémenter cette fonction, mais cela peut s'avérer utile pour réinitialiser l'état de votre élément (par exemple, la mise en surbrillance).

L'appel de ` QEvent::ignore()` ou ` QEvent::accept()` sur ` event ` n'a aucun effet.

Par défaut, les éléments ne reçoivent pas d’événements de glisser-déposer ; pour activer cette fonctionnalité, appelez setAcceptDrops(true).

L’implémentation par défaut ne fait rien.

Voir également dragEnterEvent(), dropEvent() et dragMoveEvent().

[virtual protected] void QGraphicsItem::dragMoveEvent(QGraphicsSceneDragDropEvent *event)

Ce gestionnaire d'événements, destiné à l'événement event, peut être réimplémenté pour recevoir les événements de déplacement par glisser-déposer concernant cet élément. Les événements de déplacement par glisser-déposer sont générés lorsque le curseur se déplace à l'intérieur de la zone de l'élément. La plupart du temps, vous n'aurez pas besoin de réimplémenter cette fonction ; elle sert à indiquer que seules certaines parties de l'élément peuvent accepter des déposes.

L'appel de ` QEvent::ignore()` ou de ` QEvent::accept()` sur ` event ` permet d'activer ou de désactiver la possibilité pour l'élément d'accepter des déposes à la position indiquée par l'événement. Par défaut, ` event ` est accepté, ce qui indique que l'élément autorise les déposes à la position spécifiée.

Par défaut, les éléments ne reçoivent pas d'événements de glisser-déposer ; pour activer cette fonctionnalité, appelez setAcceptDrops(true).

L'implémentation par défaut ne fait rien.

Voir également dropEvent(), dragEnterEvent() et dragLeaveEvent().

[virtual protected] void QGraphicsItem::dropEvent(QGraphicsSceneDragDropEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté pour recevoir les événements de dépôt (drop) concernant cet élément. Les éléments ne peuvent recevoir d'événements de dépôt que si le dernier événement de déplacement par glissement a été accepté.

L'appel de ` QEvent::ignore()` ou ` QEvent::accept()` sur ` event ` n'a aucun effet.

Par défaut, les éléments ne reçoivent pas d’événements de glisser-déposer ; pour activer cette fonctionnalité, appelez setAcceptDrops(true).

L’implémentation par défaut ne fait rien.

Voir également dragEnterEvent(), dragMoveEvent() et dragLeaveEvent().

qreal QGraphicsItem::effectiveOpacity() const

Renvoie l'opacité effective de cet élément, comprise entre 0,0 (transparent) et 1,0 (opaque). Cette valeur résulte de la combinaison de l'opacité locale de cet élément et des opacités de son parent et de ses ancêtres. L'opacité effective détermine la manière dont l'élément est affiché.

Voir également opacity(), setOpacity(), paint(), ItemIgnoresParentOpacity et ItemDoesntPropagateOpacityToChildren.

void QGraphicsItem::ensureVisible(const QRectF &rect = QRectF(), int xmargin = 50, int ymargin = 50)

Si cet élément fait partie d’une scène visualisée par un « QGraphicsView », cette fonction pratique tentera de faire défiler la vue afin de s’assurer que « rect » soit visible dans la fenêtre d’affichage de la vue. Si « rect » est un rectangle nul (valeur par défaut), « QGraphicsItem » prendra par défaut le rectangle englobant de l’élément. « xmargin » et « ymargin » correspondent au nombre de pixels que la vue doit utiliser pour les marges.

Si le rectangle spécifié est inaccessible, le contenu est déplacé vers la position valide la plus proche.

Si cet élément n’est pas affiché par une instance de ` QGraphicsView`, cette fonction ne fait rien.

Voir également QGraphicsView::ensureVisible().

void QGraphicsItem::ensureVisible(qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50)

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

bool QGraphicsItem::filtersChildEvents() const

Renvoie « true » si cet élément filtre les événements enfants (c'est-à-dire que tous les événements destinés à l'un de ses enfants sont envoyés à cet élément) ; sinon, la valeur « false » est renvoyée.

La valeur par défaut est `false` ; les événements enfants ne sont pas filtrés.

Voir également setFiltersChildEvents().

QGraphicsItem::GraphicsItemFlags QGraphicsItem::flags() const

Renvoie les indicateurs de cet élément. Ces indicateurs précisent quelles fonctionnalités configurables de l'élément sont activées et lesquelles ne le sont pas. Par exemple, si les indicateurs incluent « ItemIsFocusable », l'élément peut recevoir le focus.

Par défaut, aucun indicateur n’est activé.

Voir également setFlags() et setFlag().

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

Ce gestionnaire d'événement, destiné à l'événement « event », peut être réimplémenté pour obtenir le focus lors des événements liés à cet élément. L'implémentation par défaut appelle la méthode ` ensureVisible()`.

Voir également focusOutEvent(), sceneEvent() et setFocus().

QGraphicsItem *QGraphicsItem::focusItem() const

Si cet élément, ou l'un de ses enfants ou descendants, détient actuellement le focus, cette fonction renvoie un pointeur vers cet élément. Si aucun descendant ne détient le focus, la valeur « nullptr » est renvoyée.

Voir également hasFocus(), setFocus() et QWidget::focusWidget().

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

Ce gestionnaire d'événements, destiné à l'événement event, peut être réimplémenté afin de recevoir les événements de perte de focus pour cet élément. L'implémentation par défaut ne fait rien.

Voir également focusInEvent(), sceneEvent() et setFocus().

QGraphicsItem *QGraphicsItem::focusProxy() const

Renvoie le proxy de focus de cet élément, ou « nullptr » si celui-ci ne dispose pas de proxy de focus.

Voir également setFocusProxy(), setFocus() et hasFocus().

void QGraphicsItem::grabKeyboard()

Capture les entrées du clavier.

L'élément recevra toutes les entrées clavier de la scène jusqu'à ce que l'un des événements suivants se produise :

• L'élément devient invisible
• L'élément est supprimé de la scène
• L'élément est supprimé
• L’élément appelle la méthode ungrabKeyboard()
• Un autre élément appelle la méthode ` ungrabKeyboard()` ; l'élément récupérera le contrôle du clavier lorsque l'autre élément appellera la méthode ` ()`.

Lorsqu'un élément obtient le contrôle du clavier, il reçoit un événement « QEvent::GrabKeyboard ». Lorsqu'il perd le contrôle du clavier, il reçoit un événement « QEvent::UngrabKeyboard ». Ces événements peuvent être utilisés pour détecter quand votre élément obtient ou perd le contrôle du clavier par d'autres moyens que l'obtention du focus d'entrée.

Il n’est pratiquement jamais nécessaire de s’approprier explicitement le clavier dans Qt, car Qt s’en charge de manière intelligente. En particulier, Qt s’approprie le clavier lorsque votre élément obtient le focus d’entrée, et le libère lorsque votre élément perd le focus d’entrée, ou lorsque l’élément est masqué.

Notez que seuls les éléments visibles peuvent verrouiller le clavier. L’appel de la fonction `grabKeyboard()` sur un élément invisible n’a aucun effet.

Les événements clavier ne sont pas affectés.

Voir également ungrabKeyboard(), grabMouse() et setFocus().

void QGraphicsItem::grabMouse()

Capture les événements de la souris.

Cet élément recevra tous les événements de souris de la scène jusqu’à ce que l’un des événements suivants se produise :

• L'élément devient invisible
• L'élément est supprimé de la scène
• L'élément est supprimé
• L'élément appelle la fonction ` ungrabMouse()`
• Un autre élément appelle la méthode `grabMouse()` ; l'élément récupérera le contrôle de la souris lorsque l'autre élément appellera la méthode ` ungrabMouse()`.

Lorsqu’un élément obtient le contrôle de la souris, il reçoit un événement « QEvent::GrabMouse ». Lorsqu’il perd le contrôle de la souris, il reçoit un événement « QEvent::UngrabMouse ». Ces événements peuvent être utilisés pour détecter quand votre élément obtient ou perd le contrôle de la souris par d’autres moyens que la réception d’événements de boutons de souris.

Il n’est presque jamais nécessaire de capturer explicitement la souris dans Qt, car Qt se charge de la capturer et de la relâcher de manière intelligente. En particulier, Qt capture la souris lorsque vous appuyez sur un bouton de la souris, et la maintient capturée jusqu’à ce que vous relâchiez le dernier bouton de la souris. De plus, les widgets de type « Qt::Popup » appellent implicitement la fonction grabMouse() lorsqu’ils sont affichés, et ungrabMouse() lorsqu’ils sont masqués.

Notez que seuls les éléments visibles peuvent capturer les entrées de la souris. L'appel de la fonction grabMouse() sur un élément invisible n'a aucun effet.

Les événements clavier ne sont pas affectés.

Voir également QGraphicsScene::mouseGrabberItem(), ungrabMouse() et grabKeyboard().

QGraphicsEffect *QGraphicsItem::graphicsEffect() const

Renvoie un pointeur vers l'effet de cet élément s'il en possède un ; sinon, renvoie nullptr.

Voir aussi setGraphicsEffect().

QGraphicsItemGroup *QGraphicsItem::group() const

Renvoie un pointeur vers le groupe d'éléments de cet élément, ou nullptr si cet élément n'appartient à aucun groupe.

Voir également setGroup(), QGraphicsItemGroup et QGraphicsScene::createItemGroup().

bool QGraphicsItem::hasCursor() const

Renvoie ` true ` si cet élément dispose d'un curseur défini ; sinon, la valeur `false` est renvoyée.

Par défaut, aucun curseur n'est défini pour les éléments. La fonction cursor() renvoie un curseur standard en forme de flèche.

Voir également unsetCursor().

bool QGraphicsItem::hasFocus() const

Renvoie « true » si cet élément est actif et si lui-même ou son « focus proxy » a le focus du clavier ; sinon, renvoie « false ».

Voir également focusItem(), setFocus(), QGraphicsScene::setFocusItem() et isActive().

void QGraphicsItem::hide()

Masque l'élément (les éléments sont visibles par défaut).

Cette fonction pratique équivaut à l'appel de ` setVisible(false)`.

Voir également show() et setVisible().

[virtual protected] void QGraphicsItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté pour recevoir les événements de survol de cet élément. L'implémentation par défaut appelle la fonction ` update()` ; sinon, elle ne fait rien.

L'appel de ` QEvent::ignore()` ou de ` QEvent::accept()` sur ` event ` n'a aucun effet.

Voir également hoverMoveEvent(), hoverLeaveEvent(), sceneEvent() et setAcceptHoverEvents().

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

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté pour recevoir les événements de sortie de survol (hover leave) pour cet élément. L'implémentation par défaut appelle la fonction ` update()` ; sinon, elle ne fait rien.

L'appel de ` QEvent::ignore()` ou de ` QEvent::accept()` sur ` event ` n'a aucun effet.

Voir également hoverEnterEvent(), hoverMoveEvent(), sceneEvent() et setAcceptHoverEvents().

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

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté pour recevoir les événements de déplacement au survol de cet élément. L'implémentation par défaut ne fait rien.

L'appel de ` QEvent::ignore()` ou ` QEvent::accept()` sur ` event ` n'a aucun effet.

Voir également hoverEnterEvent(), hoverLeaveEvent(), sceneEvent() et setAcceptHoverEvents().

[virtual protected] void QGraphicsItem::inputMethodEvent(QInputMethodEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté afin de recevoir les événements liés à la méthode de saisie pour cet élément. L'implémentation par défaut ignore cet événement.

Voir également ` inputMethodQuery()` et ` sceneEvent()`.

Qt::InputMethodHints QGraphicsItem::inputMethodHints() const

Renvoie les indications actuelles relatives à la méthode de saisie de cet élément.

Les indications relatives à la méthode de saisie ne concernent que les éléments de saisie. Elles sont utilisées par la méthode de saisie pour indiquer comment celle-ci doit fonctionner. Par exemple, si l'indicateur Qt::ImhNumbersOnly est activé, la méthode de saisie peut modifier ses composants visuels pour indiquer que seuls des chiffres peuvent être saisis.

L'effet peut varier selon les implémentations de la méthode de saisie.

Voir également setInputMethodHints() et inputMethodQuery().

[virtual protected] QVariant QGraphicsItem::inputMethodQuery(Qt::InputMethodQuery query) const

Cette méthode ne concerne que les éléments de saisie. Elle est utilisée par la méthode de saisie pour interroger un ensemble de propriétés de l'élément afin de prendre en charge des opérations complexes de la méthode de saisie, telles que la gestion du texte environnant et les reconversions. La méthode ` query ` spécifie quelle propriété est interrogée.

Voir également inputMethodEvent() et QInputMethodEvent.

void QGraphicsItem::installSceneEventFilter(QGraphicsItem *filterItem)

Installe un filtre d'événements pour cet élément sur filterItem, ce qui fait que tous les événements liés à cet élément passent d'abord par la fonction sceneEventFilter() de filterItem.

Pour filtrer les événements d’un autre élément, installez cet élément en tant que filtre d’événements pour cet autre élément. Exemple :

QGraphicsScene scene;
QGraphicsEllipseItem *ellipse = scene.addEllipse(QRectF(-10, -10, 20, 20));
QGraphicsLineItem *line = scene.addLine(QLineF(-10, -10, 20, 20));

line->installSceneEventFilter(ellipse);
// line's events are filtered by ellipse's sceneEventFilter() function.

ellipse->installSceneEventFilter(line);
// ellipse's events are filtered by line's sceneEventFilter() function.

Un élément ne peut filtrer que les événements d'autres éléments de la même scène. De plus, un élément ne peut pas filtrer ses propres événements ; à la place, vous pouvez réimplémenter directement la fonction sceneEvent().

Les éléments doivent appartenir à une scène pour que les filtres d’événements de scène puissent être installés et utilisés.

Voir également removeSceneEventFilter(), sceneEventFilter() et sceneEvent().

bool QGraphicsItem::isActive() const

Renvoie ` true ` si cet élément est actif ; sinon, renvoie ` false`.

Un élément ne peut être actif que si la scène est active. Un élément est actif s'il est un panneau actif ou s'il en est un descendant. Les éléments des panneaux non actifs ne sont pas actifs.

Les éléments qui ne font pas partie d’un panneau suivent l’activation de la scène lorsque celle-ci ne comporte aucun panneau actif.

Seuls les éléments actifs peuvent obtenir le focus de saisie.

Voir également QGraphicsScene::isActive(), QGraphicsScene::activePanel(), panel() et isPanel().

bool QGraphicsItem::isAncestorOf(const QGraphicsItem *child) const

Renvoie « true » si cet élément est un ancêtre de « child » (c'est-à-dire si cet élément est le parent de « child », ou l'un des ancêtres du parent de « child »).

Voir également parentItem().

bool QGraphicsItem::isBlockedByModalPanel(QGraphicsItem **blockingPanel = nullptr) const

Renvoie « true » si cet élément est masqué par un panneau modal, « false » dans le cas contraire. Si « blockingPanel » est différent de zéro, « blockingPanel » sera défini sur le panneau modal qui masque cet élément. Si cet élément n’est pas masqué, « blockingPanel » ne sera pas défini par cette fonction.

Cette fonction renvoie toujours « false » pour les éléments qui ne se trouvent pas dans une scène.

Voir également panelModality(), setPanelModality() et PanelModality.

bool QGraphicsItem::isClipped() const

Renvoie « true » si cet élément est rogné. Un élément est rogné soit si le drapeau « ItemClipsToShape » est activé, soit si lui-même ou l’un de ses ancêtres a activé le drapeau « ItemClipsChildrenToShape ».

Le rognage affecte l’apparence de l’élément (c’est-à-dire son affichage), ainsi que la transmission des événements de souris et de survol.

Voir également clipPath(), shape() et setFlags().

bool QGraphicsItem::isEnabled() const

Renvoie « true » si l'élément est activé ; sinon, la valeur « false » est renvoyée.

Voir également setEnabled().

bool QGraphicsItem::isObscured(const QRectF &rect = QRectF()) const

Renvoie « true » si « rect » est entièrement masqué par la forme opaque de l'un des éléments en collision situés au-dessus de lui (c'est-à-dire dont la valeur Z est supérieure à celle de cet élément).

Voir également opaqueArea().

bool QGraphicsItem::isObscured(qreal x, qreal y, qreal w, qreal h) const

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

[virtual] bool QGraphicsItem::isObscuredBy(const QGraphicsItem *item) const

Renvoie true si le rectangle englobant de cet élément est entièrement masqué par la forme opaque de item.

L'implémentation de base transpose la fonction opaqueArea() de item dans le système de coordonnées de cet élément, puis vérifie si la fonction boundingRect() de cet élément est entièrement contenue dans la forme transposée.

Vous pouvez réimplémenter cette fonction afin de fournir un algorithme personnalisé permettant de déterminer si cet élément est masqué par item.

Voir également opaqueArea() et isObscured().

bool QGraphicsItem::isPanel() const

Renvoie « true » si l'élément est un panneau ; sinon, renvoie « false ».

Voir également QGraphicsItem::panel() et ItemIsPanel.

bool QGraphicsItem::isSelected() const

Renvoie « true » si cet élément est sélectionné ; sinon, renvoie « false ».

Les éléments appartenant à un groupe héritent de l'état de sélection de ce groupe.

Les éléments ne sont pas sélectionnés par défaut.

Voir également setSelected() et QGraphicsScene::setSelectionArea().

bool QGraphicsItem::isUnderMouse() const

Renvoie « true » si cet élément se trouve actuellement sous le curseur de la souris dans l'une des vues ; sinon, la valeur « false » est renvoyée.

Voir également QGraphicsScene::views() et QCursor::pos().

bool QGraphicsItem::isVisible() const

Renvoie « true » si l'élément est visible ; sinon, la valeur « false » est renvoyée.

Notez que la visibilité générale de l'élément n'a aucun rapport avec le fait qu'il soit ou non effectivement visualisé par un QGraphicsView.

Voir également setVisible().

bool QGraphicsItem::isVisibleTo(const QGraphicsItem *parent) const

Renvoie ` true ` si l'élément est visible dans ` parent` ; sinon, renvoie `false`. ` parent ` peut être ` nullptr`, auquel cas cette fonction indique si l'élément est visible dans la scène ou non.

Un élément peut ne pas être visible pour ses ancêtres même si isVisible() est vrai. Il peut également être visible pour ses ancêtres même si isVisible() est faux. Si un ancêtre quelconque est masqué, l'élément lui-même sera implicitement masqué, auquel cas cette fonction renverra false.

Voir également isVisible() et setVisible().

bool QGraphicsItem::isWidget() const

Renvoie « true » si cet élément est un widget (c'est-à-dire « QGraphicsWidget ») ; sinon, renvoie « false ».

bool QGraphicsItem::isWindow() const

Renvoie « true » si l'élément est une fenêtre « QGraphicsWidget », sinon renvoie « false ».

Voir également QGraphicsWidget::windowFlags().

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

Cette fonction virtuelle est appelée par QGraphicsItem afin d’informer les éléments personnalisés qu’une partie de l’état de l’élément a changé. En réimplémentant cette fonction, vous pouvez réagir à un changement et, dans certains cas (en fonction de change), effectuer des ajustements.

change est le paramètre de l'élément qui change. value est la nouvelle valeur ; le type de cette valeur dépend de change.

Exemple :

QVariant Component::itemChange(GraphicsItemChange change, const QVariant &value)
{
    if (change == ItemPositionChange && scene()) {
        // value is the new position.
        QPointF newPos = value.toPointF();
        QRectF rect = scene()->sceneRect();
        if (!rect.contains(newPos)) {
            // Keep the item inside the scene rect.
            newPos.setX(qMin(rect.right(), qMax(newPos.x(), rect.left())));
            newPos.setY(qMin(rect.bottom(), qMax(newPos.y(), rect.top())));
            return newPos;
        }
    }
    return QGraphicsItem::itemChange(change, value);
}

L’implémentation par défaut ne fait rien et renvoie value.

Remarque : certaines fonctions QGraphicsItem ne peuvent pas être appelées dans une réimplémentation de cette fonction ; voir la documentation de GraphicsItemChange pour plus de détails.

Voir également GraphicsItemChange.

QTransform QGraphicsItem::itemTransform(const QGraphicsItem *other, bool *ok = nullptr) const

Renvoie une transformation de type ` QTransform ` qui mappe les coordonnées de cet élément vers ` other`. Si ` ok ` n'est pas nul et s'il n'existe pas de transformation de ce type, la valeur booléenne pointée par ` ok ` sera définie sur `false` ; dans le cas contraire, elle sera définie sur `true`.

Cette transformation offre une alternative aux fonctions mapToItem() ou mapFromItem(), en renvoyant la transformation appropriée afin que vous puissiez mapper vous-même les formes et les coordonnées. Elle vous aide également à écrire un code plus efficace lorsque vous effectuez des mappages répétés entre les deux mêmes éléments.

Voir également mapToItem(), mapFromItem() et deviceTransform().

[virtual protected] void QGraphicsItem::keyPressEvent(QKeyEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté afin de recevoir les événements de frappe de touche pour cet élément. L'implémentation par défaut ignore cet événement. Si vous réimplémentez ce gestionnaire, l'événement sera accepté par défaut.

Notez que les événements de touche ne sont reçus que pour les éléments qui ont activé l'indicateur ` ItemIsFocusable ` et qui ont le focus de saisie du clavier.

Voir également keyReleaseEvent(), setFocus(), QGraphicsScene::setFocusItem() et sceneEvent().

[virtual protected] void QGraphicsItem::keyReleaseEvent(QKeyEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté afin de recevoir les événements de relâchement de touche pour cet élément. L'implémentation par défaut ignore cet événement. Si vous réimplémentez ce gestionnaire, l'événement sera accepté par défaut.

Notez que les événements de touche ne sont reçus que pour les éléments qui ont activé l'indicateur ` ItemIsFocusable ` et qui ont le focus de saisie au clavier.

Voir également keyPressEvent(), setFocus(), QGraphicsScene::setFocusItem() et sceneEvent().

QPainterPath QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPainterPath &path) const

Convertit le chemin path, qui se trouve dans le système de coordonnées de item, dans le système de coordonnées de cet élément, puis renvoie le chemin converti.

Si item est égal à nullptr, cette fonction renvoie le même résultat que mapFromScene().

Voir également itemTransform(), mapFromParent(), mapFromScene(), mapToItem() et « Le système de coordonnées de la vue graphique ».

QPointF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPointF &point) const

Convertit le point point, qui se trouve dans le système de coordonnées de item, dans le système de coordonnées de cet élément, et renvoie la coordonnée convertie.

Si item est égal à nullptr, cette fonction renvoie le même résultat que mapFromScene().

Voir également itemTransform(), mapFromParent(), mapFromScene(), transform(), mapToItem() et « Le système de coordonnées de la vue graphique ».

QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPolygonF &polygon) const

Convertit le polygone polygon, qui se trouve dans le système de coordonnées de item, dans le système de coordonnées de cet élément, puis renvoie le polygone converti.

Si ` item ` est égal à ` nullptr`, cette fonction renvoie le même résultat que ` mapFromScene()`.

Voir également itemTransform(), mapToItem(), mapFromParent(), transform() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QRectF &rect) const

Convertit le rectangle rect, qui se trouve dans le système de coordonnées de item, dans le système de coordonnées de cet élément, et renvoie le rectangle converti sous forme de polygone.

Si item est égal à nullptr, cette fonction renvoie le même résultat que mapFromScene()

Voir également itemTransform(), mapToItem(), mapFromParent(), transform() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

Cette fonction pratique revient à appeler `mapFromItem(item, QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapFromItem(const QGraphicsItem *item, qreal x, qreal y) const

Cette fonction de commodité équivaut à appeler `mapFromItem(item, QPointF(x, y))`.

QPainterPath QGraphicsItem::mapFromParent(const QPainterPath &path) const

Convertit le chemin path, qui se trouve dans le système de coordonnées du parent de cet élément, dans le système de coordonnées de cet élément, et renvoie le chemin converti.

Voir également mapFromScene(), mapFromItem(), mapToParent() et Le système de coordonnées de la vue graphique.

QPointF QGraphicsItem::mapFromParent(const QPointF &point) const

Convertit le point point, qui se trouve dans le système de coordonnées du parent de cet élément, dans le système de coordonnées de cet élément, et renvoie la coordonnée convertie.

Voir également mapFromItem(), mapFromScene(), transform(), mapToParent() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapFromParent(const QPolygonF &polygon) const

Effectue la mise en correspondance du polygone polygon, qui se trouve dans le système de coordonnées du parent de cet élément, avec le système de coordonnées de cet élément, puis renvoie le polygone mis en correspondance.

Voir également mapToParent(), mapToItem(), transform() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapFromParent(const QRectF &rect) const

Convertit le rectangle rect, qui se trouve dans le système de coordonnées du parent de cet élément, dans le système de coordonnées de cet élément, et renvoie le rectangle converti sous forme de polygone.

Voir également mapToParent(), mapFromItem(), transform() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapFromParent(qreal x, qreal y, qreal w, qreal h) const

Cette fonction pratique revient à appeler mapFromItem(QRectF(x, y, w, h)).

QPointF QGraphicsItem::mapFromParent(qreal x, qreal y) const

Cette fonction pratique revient à appeler `mapFromParent(QPointF(x, y))`.

QPainterPath QGraphicsItem::mapFromScene(const QPainterPath &path) const

Convertit le chemin path, qui se trouve dans le système de coordonnées de la scène de cet élément, dans le système de coordonnées de cet élément, puis renvoie le chemin converti.

Voir également mapFromParent(), mapFromItem(), mapToScene() et Le système de coordonnées de la vue graphique.

QPointF QGraphicsItem::mapFromScene(const QPointF &point) const

Convertit le point point, qui se trouve dans le système de coordonnées de la scène de cet élément, dans le système de coordonnées de cet élément, puis renvoie la coordonnée convertie.

Voir également mapFromItem(), mapFromParent(), transform(), mapToScene() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapFromScene(const QPolygonF &polygon) const

Effectue une mise en correspondance du polygone polygon, qui se trouve dans le système de coordonnées de la scène de cet élément, avec le système de coordonnées de cet élément, puis renvoie le polygone mis en correspondance.

Voir également mapToScene(), mapFromParent(), transform() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapFromScene(const QRectF &rect) const

Convertit le rectangle rect, qui se trouve dans le système de coordonnées de la scène de cet élément, dans le système de coordonnées de cet élément, et renvoie le rectangle converti sous forme de polygone.

Voir également mapToScene(), mapFromItem(), transform() et « Le système de coordonnées de la vue graphique ».

QPolygonF QGraphicsItem::mapFromScene(qreal x, qreal y, qreal w, qreal h) const

Cette fonction pratique revient à appeler `mapFromScene(QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapFromScene(qreal x, qreal y) const

Cette fonction pratique équivaut à appeler `mapFromScene(QPointF(x, y))`.

QRectF QGraphicsItem::mapRectFromItem(const QGraphicsItem *item, const QRectF &rect) const

Convertit le rectangle rect, qui se trouve dans le système de coordonnées de item, dans le système de coordonnées de cet élément, et renvoie le rectangle converti sous la forme d’un nouveau rectangle (c’est-à-dire le rectangle englobant du polygone résultant).

Si item est égal à nullptr, cette fonction renvoie le même résultat que mapRectFromScene().

Voir également itemTransform(), mapToParent(), mapToScene(), mapFromItem() et « Le système de coordonnées de la vue graphique ».

QRectF QGraphicsItem::mapRectFromItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

Cette fonction pratique revient à appeler `mapRectFromItem(item, QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectFromParent(const QRectF &rect) const

Converte le rectangle rect, qui se trouve dans le système de coordonnées du parent de cet élément, dans le système de coordonnées de cet élément, et renvoie le rectangle converti sous la forme d'un nouveau rectangle (c'est-à-dire le rectangle englobant du polygone résultant).

Voir également itemTransform(), mapToParent(), mapToScene(), mapFromItem() et Le système de coordonnées de la vue graphique.

QRectF QGraphicsItem::mapRectFromParent(qreal x, qreal y, qreal w, qreal h) const

Cette fonction pratique revient à appeler `mapRectFromParent(QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectFromScene(const QRectF &rect) const

Convertit le rectangle rect, exprimé en coordonnées de scène, dans le système de coordonnées de cet élément, et renvoie le rectangle converti sous la forme d’un nouveau rectangle (c’est-à-dire le rectangle englobant du polygone résultant).

Voir également itemTransform(), mapToParent(), mapToScene(), mapFromItem() et Le système de coordonnées de la vue graphique.

QRectF QGraphicsItem::mapRectFromScene(qreal x, qreal y, qreal w, qreal h) const

Cette fonction pratique revient à appeler mapRectFromScene(QRectF(x, y, w, h)).

QRectF QGraphicsItem::mapRectToItem(const QGraphicsItem *item, const QRectF &rect) const

Cette fonction effectue une mise en correspondance entre le rectangle rect, qui se trouve dans le système de coordonnées de cet élément, et le système de coordonnées de item, puis renvoie le rectangle ainsi mis en correspondance sous la forme d’un nouveau rectangle (c’est-à-dire le rectangle englobant du polygone résultant).

Si item est égal à nullptr, cette fonction renvoie le même résultat que mapRectToScene().

Voir également itemTransform(), mapToParent(), mapToScene(), mapFromItem() et Le système de coordonnées de la vue graphique.

QRectF QGraphicsItem::mapRectToItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

Cette fonction pratique revient à appeler `mapRectToItem(item, QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectToParent(const QRectF &rect) const

Converti le rectangle rect, qui se trouve dans le système de coordonnées de cet élément, dans le système de coordonnées de son parent, et renvoie le rectangle converti sous la forme d’un nouveau rectangle (c’est-à-dire le rectangle englobant du polygone résultant).

Voir également itemTransform(), mapToParent(), mapToScene(), mapFromItem() et Le système de coordonnées de la vue graphique.

QRectF QGraphicsItem::mapRectToParent(qreal x, qreal y, qreal w, qreal h) const

Cette fonction pratique revient à appeler `mapRectToParent(QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectToScene(const QRectF &rect) const

Convertit le rectangle rect, qui se trouve dans le système de coordonnées de cet élément, dans le système de coordonnées de la scène, et renvoie le rectangle converti sous la forme d’un nouveau rectangle (c’est-à-dire le rectangle englobant du polygone résultant).

Voir également itemTransform(), mapToParent(), mapToScene(), mapFromItem() et Le système de coordonnées de la vue graphique.

QRectF QGraphicsItem::mapRectToScene(qreal x, qreal y, qreal w, qreal h) const

Cette fonction pratique revient à appeler `mapRectToScene(QRectF(x, y, w, h))`.

QPainterPath QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPainterPath &path) const

Convertit le chemin path, qui appartient au système de coordonnées de cet élément, dans le système de coordonnées de item, puis renvoie le chemin converti.

Si item est égal à nullptr, cette fonction renvoie le même résultat que mapToScene().

Voir également itemTransform(), mapToParent(), mapToScene(), mapFromItem() et Le système de coordonnées de la vue graphique.

QPointF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPointF &point) const

Convertit le point point, qui se trouve dans le système de coordonnées de cet élément, dans le système de coordonnées de item, puis renvoie la coordonnée convertie.

Si item est égal à nullptr, cette fonction renvoie le même résultat que mapToScene().

Voir également itemTransform(), mapToParent(), mapToScene(), transform(), mapFromItem() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPolygonF &polygon) const

Cette fonction effectue une mise en correspondance entre le polygone polygon, qui se trouve dans le système de coordonnées de cet élément, et le système de coordonnées de item, puis renvoie le polygone mis en correspondance.

Si item est égal à nullptr, cette fonction renvoie le même résultat que mapToScene().

Voir également itemTransform(), mapToParent(), mapToScene(), mapFromItem() et « Le système de coordonnées de la vue graphique ».

QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QRectF &rect) const

Cette fonction effectue une mise en correspondance du rectangle rect, situé dans le système de coordonnées de cet élément, avec le système de coordonnées de item, puis renvoie le rectangle mis en correspondance sous la forme d’un polygone.

Si item est égal à nullptr, cette fonction renvoie le même résultat que mapToScene().

Voir également itemTransform(), mapToParent(), mapToScene(), mapFromItem() et « Le système de coordonnées de la vue graphique ».

QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

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

QPointF QGraphicsItem::mapToItem(const QGraphicsItem *item, qreal x, qreal y) const

Cette fonction de commodité équivaut à appeler `mapToItem(item, QPointF(x, y))`.

QPainterPath QGraphicsItem::mapToParent(const QPainterPath &path) const

Convertit le chemin path, qui se trouve dans le système de coordonnées de cet élément, dans le système de coordonnées de son parent, puis renvoie le chemin converti. Si l'élément n'a pas de parent, path sera converti dans le système de coordonnées de la scène.

Voir également mapToScene(), mapToItem(), mapFromParent() et Le système de coordonnées de la vue graphique.

QPointF QGraphicsItem::mapToParent(const QPointF &point) const

Convertit le point point, qui se trouve dans le système de coordonnées de cet élément, dans le système de coordonnées de son parent, puis renvoie la coordonnée convertie. Si l'élément n'a pas de parent, point sera converti dans le système de coordonnées de la scène.

Voir également mapToItem(), mapToScene(), transform(), mapFromParent() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapToParent(const QPolygonF &polygon) const

Effectue la mise en correspondance du polygone polygon, qui se trouve dans le système de coordonnées de cet élément, avec le système de coordonnées de son parent, puis renvoie le polygone mis en correspondance. Si l'élément n'a pas de parent, polygon sera mis en correspondance avec le système de coordonnées de la scène.

Voir également mapToScene(), mapToItem(), mapFromParent() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapToParent(const QRectF &rect) const

Converti le rectangle rect, qui se trouve dans le système de coordonnées de cet élément, dans le système de coordonnées de son parent, puis renvoie le rectangle converti sous forme de polygone. Si l'élément n'a pas de parent, rect sera converti dans le système de coordonnées de la scène.

Voir également mapToScene(), mapToItem(), mapFromParent() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapToParent(qreal x, qreal y, qreal w, qreal h) const

Cette fonction pratique revient à appeler `mapToParent(QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapToParent(qreal x, qreal y) const

Cette fonction pratique équivaut à appeler `mapToParent(QPointF(x, y))`.

QPainterPath QGraphicsItem::mapToScene(const QPainterPath &path) const

Effectue la mise en correspondance du chemin path, qui se trouve dans le système de coordonnées de cet élément, avec le système de coordonnées de la scène, puis renvoie le chemin mis en correspondance.

Voir également mapToParent(), mapToItem(), mapFromScene() et Le système de coordonnées de la vue graphique.

QPointF QGraphicsItem::mapToScene(const QPointF &point) const

Convertit le point point, qui se trouve dans le système de coordonnées de cet élément, dans le système de coordonnées de la scène, et renvoie la coordonnée convertie.

Voir également mapToItem(), mapToParent(), transform(), mapFromScene() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapToScene(const QPolygonF &polygon) const

Effectue la mise en correspondance du polygone polygon, qui se trouve dans le système de coordonnées de cet élément, avec le système de coordonnées de la scène, puis renvoie le polygone mis en correspondance.

Voir également mapToParent(), mapToItem(), mapFromScene() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapToScene(const QRectF &rect) const

Convertit le rectangle rect, qui se trouve dans le système de coordonnées de cet élément, dans le système de coordonnées de la scène, et renvoie le rectangle converti sous forme de polygone.

Voir également mapToParent(), mapToItem(), mapFromScene() et Le système de coordonnées de la vue graphique.

QPolygonF QGraphicsItem::mapToScene(qreal x, qreal y, qreal w, qreal h) const

Cette fonction pratique revient à appeler `mapToScene(QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapToScene(qreal x, qreal y) const

Cette fonction pratique équivaut à appeler `mapToScene(QPointF(x, y))`.

[virtual protected] void QGraphicsItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)

Ce gestionnaire d'événements, destiné à l'événement event, peut être réimplémenté pour recevoir les événements de double-clic de la souris sur cet élément.

Lorsqu'on double-clique sur un élément, celui-ci reçoit d'abord un événement de pression de la souris, suivi d'un événement de relâchement (c'est-à-dire un clic), puis d'un événement de double-clic, et enfin d'un événement de relâchement.

L'appel de ` QEvent::ignore()` ou ` QEvent::accept()` sur ` event ` n'a aucun effet.

L'implémentation par défaut appelle ` mousePressEvent()`. Si vous souhaitez conserver l'implémentation de base lors de la réimplémentation de cette fonction, appelez `QGraphicsItem::mouseDoubleClickEvent()` dans votre réimplémentation.

Notez qu’un élément ne recevra pas d’événements de double-clic s’il n’est ni de type « selectable » ni de type « movable » (les clics simples de souris sont ignorés dans ce cas, ce qui empêche la génération de doubles clics).

Voir également mousePressEvent(), mouseMoveEvent(), mouseReleaseEvent() et sceneEvent().

[virtual protected] void QGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté pour recevoir les événements de déplacement de la souris concernant cet élément. Si vous recevez cet événement, vous pouvez être certain que cet élément a également reçu un événement de clic de souris et qu'il est l'élément actuellement sélectionné par la souris.

L'appel de ` QEvent::ignore()` ou ` QEvent::accept()` sur ` event ` n'a aucun effet.

L'implémentation par défaut gère les interactions de base avec les éléments, telles que la sélection et le déplacement. Si vous souhaitez conserver l'implémentation de base lors de la réimplémentation de cette fonction, appelez QGraphicsItem::mouseMoveEvent() dans votre réimplémentation.

Veuillez noter que la fonction mousePressEvent() détermine quel élément graphique reçoit les événements de souris. Reportez-vous à la description de mousePressEvent() pour plus de détails.

Voir également mousePressEvent(), mouseReleaseEvent(), mouseDoubleClickEvent() et sceneEvent().

[virtual protected] void QGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté afin de recevoir les événements de clic de souris pour cet élément. Les événements de clic de souris ne sont transmis qu'aux éléments qui acceptent le bouton de souris sur lequel on a cliqué. Par défaut, un élément accepte tous les boutons de souris, mais vous pouvez modifier ce comportement en appelant la fonction « setAcceptedMouseButtons()».

L'événement de clic de souris détermine quel élément doit devenir le « mouse grabber » (voir QGraphicsScene::mouseGrabberItem()). Si vous ne réimplémentez pas cette fonction, l'événement de clic se propagera à tout élément situé au premier plan sous cet élément, et aucun autre événement de souris ne sera transmis à cet élément.

Si vous réimplémentez cette fonction, event sera accepté par défaut (voir QEvent::accept()), et cet élément deviendra alors le « mouse grabber ». Cela permet à l’élément de recevoir les futurs événements de déplacement, de relâchement et de double-clic. Si vous appelez QEvent::ignore() sur event, cet élément perdra le « mouse grab », et event se propagera à tout élément situé au premier plan en dessous. Aucun autre événement de souris ne sera transmis à cet élément, sauf si un nouvel événement de pression de souris est reçu.

L’implémentation par défaut gère les interactions de base avec les éléments, telles que la sélection et le déplacement. Si vous souhaitez conserver l’implémentation de base lors de la réimplémentation de cette fonction, appelez QGraphicsItem::mousePressEvent() dans votre réimplémentation.

L'événement est QEvent::ignore()d pour les éléments qui ne sont ni movable ni selectable.

Voir également mouseMoveEvent(), mouseReleaseEvent(), mouseDoubleClickEvent() et sceneEvent().

[virtual protected] void QGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté pour recevoir les événements de relâchement de la souris concernant cet élément.

L'appel de ` QEvent::ignore()` ou ` QEvent::accept()` sur ` event ` n'a aucun effet.

L'implémentation par défaut gère les interactions de base avec les éléments, telles que la sélection et le déplacement. Si vous souhaitez conserver l'implémentation de base lors de la réimplémentation de cette fonction, appelez QGraphicsItem::mouseReleaseEvent() dans votre réimplémentation.

Veuillez noter que la fonction mousePressEvent() détermine quel élément graphique reçoit les événements de souris. Reportez-vous à la description de la fonction mousePressEvent() pour plus de détails.

Voir également mousePressEvent(), mouseMoveEvent(), mouseDoubleClickEvent() et sceneEvent().

void QGraphicsItem::moveBy(qreal dx, qreal dy)

Déplace l'élément de dx points horizontalement et de dy point verticalement. Cette fonction équivaut à appeler setPos(pos() + QPointF(dx, dy)).

qreal QGraphicsItem::opacity() const

Renvoie l’opacité locale de cet élément, comprise entre 0,0 (transparent) et 1,0 (opaque). Cette valeur est combinée à celles du parent et des ancêtres dans la fonction ` effectiveOpacity()`. L’opacité effective détermine la manière dont l’élément est affiché et influe également sur sa visibilité lorsqu’elle est interrogée par des fonctions telles que ` QGraphicsView::items()`.

La propriété d’opacité détermine l’état du « painter » transmis à la fonction paint(). Si l’élément est mis en cache, c’est-à-dire via ItemCoordinateCache ou DeviceCoordinateCache, la propriété effective sera appliquée au cache de l’élément lors de son rendu.

L’opacité par défaut est 1,0 ; entièrement opaque.

Voir également setOpacity(), paint(), ItemIgnoresParentOpacity et ItemDoesntPropagateOpacityToChildren.

[virtual] QPainterPath QGraphicsItem::opaqueArea() const

Cette fonction virtuelle renvoie une forme représentant la zone où cet élément est opaque. Une zone est opaque si elle est remplie à l'aide d'un pinceau ou d'une couleur opaque (c'est-à-dire non transparente).

Cette fonction est utilisée par ` isObscuredBy()` (), qui est appelée par les éléments sous-jacents pour déterminer s’ils sont masqués par cet élément.

L'implémentation par défaut renvoie un ` QPainterPath` vide, indiquant que cet élément est entièrement transparent et ne masque aucun autre élément.

Voir également isObscuredBy(), isObscured() et shape().

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

Cette fonction, généralement appelée par ` QGraphicsView`, dessine le contenu d'un élément dans le système de coordonnées local.

Réimplémentez cette fonction dans une sous-classe de ` QGraphicsItem ` pour fournir l’implémentation de l’affichage de l’élément, en utilisant ` painter`. Le paramètre ` option ` fournit des options de style pour l’élément, telles que son état, sa zone exposée et ses indications de niveau de détail. L’argument ` widget ` est facultatif. S’il est fourni, il pointe vers le widget sur lequel le dessin est effectué ; sinon, il vaut 0. Pour le dessin mis en cache, ` widget ` est toujours égal à 0.

void RoundRectItem::paint(QPainter *painter,
                          const QStyleOptionGraphicsItem *option,
                          QWidget *widget)
{
    painter->drawRoundedRect(-10, -10, 20, 20, 5, 5);
}

Le stylo du peintre a une largeur de 0 par défaut, et il est initialisé avec le pinceau « QPalette::Text » issu de la palette du périphérique de dessin. Le pinceau est initialisé avec « QPalette::Window ».

Veillez à limiter tout dessin à l’intérieur des limites de ` boundingRect()` afin d’éviter les artefacts de rendu (car ` QGraphicsView ` ne découpe pas automatiquement le dessin pour vous). En particulier, lorsque QPainter dessine le contour d’une forme à l’aide d’un QPen attribué, la moitié du contour sera dessinée à l’extérieur et l’autre moitié à l’intérieur de la forme que vous dessinez (par exemple, avec une largeur de stylo de 2 unités, vous devez dessiner les contours à 1 unité à l’intérieur de boundingRect()). QGraphicsItem ne prend pas en charge l’utilisation de stylos cosmétiques dont la largeur est différente de zéro.

Tout le dessin s'effectue en coordonnées locales.

Voir également setCacheMode(), QPen::width(), Coordonnées des éléments et ItemUsesExtendedStyleOption.

QGraphicsItem *QGraphicsItem::panel() const

Renvoie le panneau de l'élément, ou nullptr si cet élément ne possède pas de panneau. Si l'élément est un panneau, la fonction renvoie l'élément lui-même. Sinon, elle renvoie l'ancêtre le plus proche qui soit un panneau.

Voir également isPanel() et ItemIsPanel.

QGraphicsItem::PanelModality QGraphicsItem::panelModality() const

Renvoie la modalité associée à cet élément.

Voir également setPanelModality().

QGraphicsItem *QGraphicsItem::parentItem() const

Renvoie un pointeur vers l'élément parent de cet élément. Si cet élément n'a pas de parent, la valeur « nullptr » est renvoyée.

Voir également setParentItem() et childItems().

QGraphicsObject *QGraphicsItem::parentObject() const

Renvoie un pointeur vers le parent de l'élément, converti en ` QGraphicsObject`. Renvoie ` nullptr ` si l'élément parent n'est pas un ` QGraphicsObject`.

Voir également parentItem() et childItems().

QGraphicsWidget *QGraphicsItem::parentWidget() const

Renvoie un pointeur vers le widget parent de l'élément. Le widget parent de l'élément est l'élément parent le plus proche qui soit un widget.

Voir également parentItem() et childItems().

QPointF QGraphicsItem::pos() const

Renvoie la position de l'élément dans le système de coordonnées du parent. Si l'élément n'a pas de parent, sa position est indiquée dans le système de coordonnées de la scène.

La position de l'élément décrit son origine (coordonnée locale (0, 0)) dans les coordonnées du parent ; cette fonction renvoie le même résultat que ` mapToParent(0, 0)`.

Pour plus de commodité, vous pouvez également appeler ` scenePos()` pour déterminer la position de l’élément dans les coordonnées de la scène, quel que soit son parent.

Voir également x(), y(), setPos(), transform() et Le système de coordonnées de la vue graphique.

[protected] void QGraphicsItem::prepareGeometryChange()

Prépare l'élément à un changement de géométrie. Appelez cette fonction avant de modifier le rectangle de délimitation d'un élément afin de maintenir à jour l'index de ` QGraphicsScene`.

La fonction prepareGeometryChange() appellera la fonction update() si nécessaire.

Exemple :

void CircleItem::setRadius(qreal newRadius)
{
    if (radius != newRadius) {
        prepareGeometryChange();
        radius = newRadius;
    }
}

Voir également ` boundingRect()`.

void QGraphicsItem::removeSceneEventFilter(QGraphicsItem *filterItem)

Supprime un filtre d'événement associé à cet élément de filterItem.

Voir également installSceneEventFilter().

void QGraphicsItem::resetTransform()

Réinitialise la matrice de transformation de cet élément à la matrice identité ou toutes les propriétés de transformation à leurs valeurs par défaut. Cela revient à appeler la méthode setTransform(QTransform()).

Voir également setTransform() et transform().

qreal QGraphicsItem::rotation() const

Renvoie la rotation dans le sens des aiguilles d'une montre, en degrés, autour de l'axe Z. La valeur par défaut est 0 (c'est-à-dire que l'élément n'est pas pivoté).

La rotation est combinée aux propriétés scale(), transform() et transformations() de l'élément afin de mapper le système de coordonnées de l'élément à celui de son élément parent.

Voir également setRotation(), transformOriginPoint() et Transformations.

qreal QGraphicsItem::scale() const

Renvoie le facteur d'échelle de l'élément. Le facteur d'échelle par défaut est 1,0 (c'est-à-dire que l'élément n'est pas mis à l'échelle).

L'échelle est combinée aux fonctions ` rotation()`, ` transform()` et ` transformations()` de l'élément pour mapper le système de coordonnées de l'élément à celui de l'élément parent.

Voir également setScale(), rotation() et Transformations.

QGraphicsScene *QGraphicsItem::scene() const

Renvoie la scène actuelle de l'élément, ou ` nullptr ` si l'élément n'est pas enregistré dans une scène.

Pour ajouter ou déplacer un élément dans une scène, appelez la fonction QGraphicsScene::addItem().

QRectF QGraphicsItem::sceneBoundingRect() const

Renvoie le rectangle de délimitation de cet élément en coordonnées de scène, en combinant la fonction sceneTransform() avec la fonction boundingRect().

Voir également boundingRect() et Le système de coordonnées de la vue graphique.

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

Cette fonction virtuelle reçoit les événements liés à cet élément. Réimplémentez cette fonction pour intercepter les événements avant qu’ils ne soient transmis aux gestionnaires d’événements spécialisés : contextMenuEvent(), focusInEvent(), focusOutEvent(), hoverEnterEvent(), hoverMoveEvent(), hoverLeaveEvent(), keyPressEvent(), keyReleaseEvent(), mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent() et mouseDoubleClickEvent().

Renvoie « true » si l'événement a été reconnu et traité ; dans le cas contraire (par exemple, si le type d'événement n'a pas été reconnu), la valeur « false » est renvoyée.

event est l'événement intercepté.

[virtual protected] bool QGraphicsItem::sceneEventFilter(QGraphicsItem *watched, QEvent *event)

Filtre les événements de l'élément watched. event correspond à l'événement filtré.

La réimplémentation de cette fonction dans une sous-classe permet à l’élément d’être utilisé comme filtre d’événements pour d’autres éléments, en interceptant tous les événements envoyés à ces derniers avant qu’ils ne puissent y répondre.

Les réimplémentations doivent renvoyer « true » pour empêcher le traitement ultérieur d’un événement donné, garantissant ainsi qu’il ne sera pas transmis à l’élément surveillé, ou renvoyer « false » pour indiquer que l’événement doit être propagé plus loin par le système d’événements.

Voir également ` installSceneEventFilter()`.

QPointF QGraphicsItem::scenePos() const

Renvoie la position de l'élément dans les coordonnées de la scène. Cela revient à appeler la fonction ` mapToScene(0, 0)`.

Voir également pos(), sceneTransform() et « Le système de coordonnées de la vue graphique ».

QTransform QGraphicsItem::sceneTransform() const

Renvoie la matrice de transformation de scène de cet élément. Cette matrice peut être utilisée pour mapper les coordonnées et les formes géométriques du système de coordonnées local de cet élément vers le système de coordonnées de la scène. Pour mapper les coordonnées à partir de la scène, vous devez d'abord inverser la matrice renvoyée.

Exemple :

QGraphicsRectItem rect;
rect.setPos(100, 100);

rect.sceneTransform().map(QPointF(0, 0));
// returns QPointF(100, 100);

rect.sceneTransform().inverted().map(QPointF(100, 100));
// returns QPointF(0, 0);

Contrairement à la fonction ` transform()`, qui ne renvoie que la transformation locale d’un élément, cette fonction inclut la position de l’élément (et de ses éventuels parents), ainsi que toutes les propriétés de transformation.

Voir également transform(), setTransform(), scenePos(), Le système de coordonnées de la vue graphique et Transformations.

void QGraphicsItem::scroll(qreal dx, qreal dy, const QRectF &rect = QRectF())

Fait défiler le contenu de ` rect ` via ` dx` et ` dy`. Si ` rect ` est un rectangle nul (valeur par défaut), c'est le rectangle de délimitation de l'élément qui est fait défiler.

Le défilement offre une alternative rapide au simple redessin lorsque le contenu de l’élément (ou certaines parties de celui-ci) est décalé verticalement ou horizontalement. En fonction de la transformation en cours et des capacités du périphérique de dessin (c’est-à-dire la fenêtre d’affichage), cette opération peut consister simplement à déplacer des pixels d’un emplacement à un autre à l’aide de `memmove()`. Dans la plupart des cas, cela est plus rapide que de redessiner la zone entière.

Après le défilement, l’élément émettra une mise à jour pour les zones nouvellement exposées. Si le défilement n’est pas pris en charge (par exemple, si vous effectuez un rendu dans une fenêtre d’affichage OpenGL, qui ne bénéficie pas des optimisations de défilement), cette fonction équivaut à appeler update(rect).

Remarque : le défilement n’est pris en charge que lorsque l’option « QGraphicsItem::ItemCoordinateCache » est activée ; dans tous les autres cas, l’appel de cette fonction équivaut à l’appel de update(rect). Si vous êtes certain que l’élément est opaque et qu’il n’est pas recouvert par d’autres éléments, vous pouvez mapper les coordonnées de l’ rect e aux coordonnées de la fenêtre d’affichage et faire défiler cette dernière.

QTransform xform = item->deviceTransform(view->viewportTransform());
QRect deviceRect = xform.mapRect(rect).toAlignedRect();
view->viewport()->scroll(dx, dy, deviceRect);

Voir également boundingRect().

void QGraphicsItem::setAcceptDrops(bool on)

Si la propriété on a la valeur « true », cet élément acceptera les événements de glisser-déposer ; dans le cas contraire, il sera transparent pour ces événements. Par défaut, les éléments n'acceptent pas les événements de glisser-déposer.

Voir également acceptDrops().

void QGraphicsItem::setAcceptHoverEvents(bool enabled)

Si la propriété « enabled » est définie sur « true », cet élément acceptera les événements de survol ; dans le cas contraire, il les ignorera. Par défaut, les éléments n'acceptent pas les événements de survol.

Les événements de survol sont déclenchés lorsqu'aucun élément ne détient actuellement le contrôle de la souris. Ils sont envoyés lorsque le curseur de la souris entre dans un élément, lorsqu'il se déplace à l'intérieur de celui-ci et lorsqu'il en sort. Les événements de survol sont couramment utilisés pour mettre en surbrillance un élément lorsque le curseur y pénètre, et pour suivre le curseur de la souris lorsqu'il survole l'élément (équivalent à QWidget::mouseTracking).

Les éléments parents reçoivent les événements « hover enter » avant leurs enfants, et les événements « hover leave » après leurs enfants. Le parent ne reçoit toutefois pas d’événement « hover leave » si le curseur pénètre dans un enfant ; le parent reste en état « hover » jusqu’à ce que le curseur quitte sa zone, y compris les zones de ses enfants.

Si un élément parent gère les événements de ses enfants, il recevra les événements « hover move », « drag move » et « drop » lorsque le curseur traverse ses enfants, mais il ne recevra pas les événements « hover enter » et « hover leave », ni les événements « drag enter » et « drag leave » au nom de ses enfants.

Un élément « QGraphicsWidget » doté de décorations de fenêtre acceptera les événements « hover » quelle que soit la valeur de la fonction « acceptHoverEvents() ».

Voir également les fonctions ` acceptHoverEvents()`, ` hoverEnterEvent()`, ` hoverMoveEvent()` et ` hoverLeaveEvent()`.

void QGraphicsItem::setAcceptTouchEvents(bool enabled)

Si la propriété enabled a la valeur « true », cet élément acceptera les événements touch events; dans le cas contraire, il les ignorera. Par défaut, les éléments n'acceptent pas les événements tactiles.

Voir également acceptTouchEvents().

void QGraphicsItem::setAcceptedMouseButtons(Qt::MouseButtons buttons)

Définit l’ buttons s de la souris pour lesquelles cet élément accepte les événements de souris.

Par défaut, tous les boutons de souris sont acceptés. Si un élément accepte un bouton de souris, il devient l'élément « mouse grabber » lorsqu'un événement de clic sur ce bouton est déclenché. Cependant, si l'élément n'accepte pas le bouton de souris, QGraphicsScene transmettra les événements de souris au premier élément situé en dessous de lui qui l'accepte.

Pour désactiver les événements de souris pour un élément (c'est-à-dire le rendre transparent aux événements de souris), appelez setAcceptedMouseButtons(Qt::NoButton).

Voir également acceptedMouseButtons() et mousePressEvent().

void QGraphicsItem::setActive(bool active)

Si la propriété « active » est définie sur « true » et que la scène est active, le panneau de cet élément sera activé. Dans le cas contraire, le panneau sera désactivé.

Si l'élément ne fait pas partie d'une scène active, la propriété ` active ` déterminera ce qu'il adviendra du panneau lorsque la scène deviendra active ou que l'élément sera ajouté à la scène. Si elle est définie sur `true`, le panneau de l'élément sera activé soit lorsque l'élément sera ajouté à la scène, soit lorsque la scène sera activée. Dans le cas contraire, l'élément restera inactif, quel que soit l'état d'activation de la scène.

Voir également isPanel(), QGraphicsScene::setActivePanel() et QGraphicsScene::isActive().

void QGraphicsItem::setBoundingRegionGranularity(qreal granularity)

Définit la granularité de la région englobante sur granularity; une valeur comprise entre 0 et 1 inclus. La valeur par défaut est 0 (c'est-à-dire la granularité la plus faible, où la région englobante correspond au rectangle englobant de l'élément).

La granularité est utilisée par la méthode ` boundingRegion()` pour calculer le niveau de précision requis pour la région englobante de l’élément. La granularité maximale atteignable est 1 ; dans ce cas, la méthode ` boundingRegion()` renvoie le contour le plus fin possible pour le périphérique concerné (par exemple, pour une fenêtre d’affichage de type « QGraphicsView », cela donne une région englobante au pixel près). La granularité la plus faible possible est 0. La valeur de granularity décrit le rapport entre la résolution de l’appareil et celle de la zone de délimitation (par exemple, une valeur de 0,25 fournira une zone où chaque bloc correspond à 4x4 unités de l’appareil / pixels).

Voir également boundingRegionGranularity().

void QGraphicsItem::setCacheMode(QGraphicsItem::CacheMode mode, const QSize &logicalCacheSize = QSize())

Définit le mode de mise en cache de l'élément sur « mode ».

L’argument facultatif « logicalCacheSize » n’est utilisé que par le mode « ItemCoordinateCache » et décrit la résolution du tampon de cache ; si « logicalCacheSize » vaut (100, 100), « QGraphicsItem » adaptera l’élément à une taille de 100x100 pixels dans la mémoire graphique, quelle que soit la taille logique de l’élément lui-même. Par défaut, « QGraphicsItem » utilise la taille renvoyée par « boundingRect() ». Pour tous les modes de mise en cache autres que ItemCoordinateCache, logicalCacheSize est ignoré.

La mise en cache peut accélérer le rendu si votre élément passe un temps considérable à se redessiner. Dans certains cas, la mise en cache peut également ralentir le rendu, en particulier lorsque l'élément passe moins de temps à se redessiner que n'en passe ` QGraphicsItem ` à le redessiner à partir du cache.

Lorsque la mise en cache est activée, la fonction ` paint()` d’un élément dessine généralement dans un cache pixmap hors écran ; pour toute demande de rafraîchissement ultérieure, le framework Graphics View effectuera le rafraîchissement à partir du cache. Cette approche fonctionne particulièrement bien avec `QGLWidget`, qui stocke l’intégralité du cache sous forme de textures OpenGL.

Notez que la limite de cache de ` QPixmapCache` peut devoir être modifiée pour obtenir des performances optimales.

Vous trouverez plus d’informations sur les différents modes de mise en cache dans la documentation d’ CacheMode.

Voir également cacheMode(), CacheMode et QPixmapCache::setCacheLimit().

void QGraphicsItem::setCursor(const QCursor &cursor)

Définit la forme actuelle du curseur pour l'élément sur cursor. Le curseur de la souris prendra cette forme lorsqu'il se trouvera au-dessus de cet élément. Consultez la page list of predefined cursor objects pour découvrir toute une gamme de formes utiles.

Un élément d'éditeur peut souhaiter utiliser un curseur en « I » :

item->setCursor(Qt::IBeamCursor);

Si aucun curseur n’a été défini, c’est celui de l’élément sous-jacent qui est utilisé.

Voir également cursor(), hasCursor(), unsetCursor(), QWidget::cursor et QGuiApplication::overrideCursor().

void QGraphicsItem::setData(int key, const QVariant &value)

Définit les données personnalisées de cet élément pour la clé « key » sur « value ».

Les données personnalisées d'un élément sont utiles pour stocker des propriétés arbitraires pour n'importe quel élément. Qt n'utilise pas cette fonctionnalité pour stocker des données ; elle est fournie uniquement pour la commodité de l'utilisateur.

Voir également data().

void QGraphicsItem::setEnabled(bool enabled)

Si la valeur de « enabled » est « true », l'élément est activé ; dans le cas contraire, il est désactivé.

Les éléments désactivés sont visibles, mais ils ne reçoivent aucun événement et ne peuvent ni recevoir le focus ni être sélectionnés. Les événements de souris sont ignorés ; ils ne sont pas propagés, sauf si l'élément est également invisible ou s'il n'accepte pas les événements de souris (voir acceptedMouseButtons()). Un élément désactivé ne peut pas devenir le « mouse grabber » ; par conséquent, un élément perd le « grab » s’il est désactivé alors qu’il détient le « grab », tout comme il perd le focus s’il le détenait au moment de sa désactivation.

Les éléments désactivés sont généralement affichés en gris (voir QPalette::Disabled).

Si vous désactivez un élément parent, tous ses enfants seront également désactivés. Si vous activez un élément parent, tous ses enfants seront activés, à moins qu'ils n'aient été explicitement désactivés (c'est-à-dire que si vous appelez setEnabled(false) sur un enfant, celui-ci ne sera pas réactivé si son parent est désactivé, puis réactivé).

Les éléments sont activés par défaut.

Voir également ` isEnabled()`.

void QGraphicsItem::setFiltersChildEvents(bool enabled)

Si enabled est défini sur « true », cet élément est configuré pour filtrer tous les événements destinés à l’ensemble de ses enfants (c’est-à-dire que tous les événements destinés à l’un de ses enfants sont redirigés vers cet élément) ; dans le cas contraire, si enabled est défini sur « false », cet élément ne gère que ses propres événements. La valeur par défaut est « false ».

Voir également filtersChildEvents().

void QGraphicsItem::setFlag(QGraphicsItem::GraphicsItemFlag flag, bool enabled = true)

Si la valeur de enabled est « true », l'indicateur d'élément flag est activé ; dans le cas contraire, il est désactivé.

Voir également flags() et setFlags().

void QGraphicsItem::setFlags(QGraphicsItem::GraphicsItemFlags flags)

Définit les indicateurs de l'élément sur flags. Tous les indicateurs figurant dans flags sont activés ; tous ceux qui ne figurent pas dans flags sont désactivés.

Si l'élément avait le focus et que flags n'active pas ItemIsFocusable, l'élément perd son focus à la suite de l'appel de cette fonction. De même, si l'élément était sélectionné et que flags n'active pas ItemIsSelectable, l'élément est automatiquement désélectionné.

Par défaut, aucun indicateur n’est activé. (La fonction `QGraphicsWidget ` active par défaut l’indicateur ` ItemSendsGeometryChanges ` afin de suivre les changements de position.)

Voir également flags() et setFlag().

void QGraphicsItem::setFocus(Qt::FocusReason focusReason = Qt::OtherFocusReason)

Attribue le focus clavier à cet élément. L'argument « focusReason » sera transmis à tout message « focus event » généré par cette fonction ; il sert à expliquer la raison pour laquelle l'élément a obtenu le focus.

Seuls les éléments activés qui ont activé l’indicateur « ItemIsFocusable » peuvent recevoir le focus du clavier.

Si cet élément n’est pas visible, n’est pas actif ou n’est pas associé à une scène, il n’obtiendra pas immédiatement le focus. Cependant, il sera enregistré comme élément de focus préféré pour sa sous-arborescence d’éléments, s’il venait à devenir visible ultérieurement.

À la suite de l’appel de cette fonction, cet élément recevra une notification « focus in event » avec le message « focusReason ». Si un autre élément détient déjà le focus, celui-ci recevra d’abord une notification « focus out event » indiquant qu’il a perdu le focus de saisie.

Voir également clearFocus(), hasFocus(), focusItem() et focusProxy().

void QGraphicsItem::setFocusProxy(QGraphicsItem *item)

Définit le proxy de focus de l'élément sur item.

Si un élément dispose d’un proxy de focus, ce dernier recevra le focus d’entrée lorsque l’élément obtiendra le focus d’entrée. L’élément lui-même conservera le focus (c’est-à-dire que la fonction hasFocus() renverra « true »), mais seul le proxy de focus recevra les entrées clavier.

Un proxy de focus peut lui-même avoir un proxy de focus, et ainsi de suite. Dans ce cas, les entrées clavier seront gérées par le proxy de focus le plus externe.

Le proxy de focus item doit appartenir à la même scène que cet élément.

Voir également focusProxy(), setFocus() et hasFocus().

void QGraphicsItem::setGraphicsEffect(QGraphicsEffect *effect)

Définit « effect » comme effet de l'élément. Si un effet est déjà associé à cet élément, la méthode « QGraphicsItem » supprimera l'effet existant avant d'installer le nouvel effet « effect ». Vous pouvez supprimer un effet existant en appelant la méthode « setGraphicsEffect(nullptr) ».

Si effect est l’effet installé sur un autre élément, la méthode setGraphicsEffect() supprimera l’effet de cet élément et l’installera sur le présent élément.

QGraphicsItem prend possession de ` effect`.

Voir également graphicsEffect().

void QGraphicsItem::setGroup(QGraphicsItemGroup *group)

Ajoute cet élément au groupe d'éléments group. Si group vaut nullptr, cet élément est retiré de tout groupe actuel et ajouté en tant qu'enfant du parent du groupe précédent.

Voir également group() et QGraphicsScene::createItemGroup().

void QGraphicsItem::setInputMethodHints(Qt::InputMethodHints hints)

Définit les conseils relatifs à la méthode de saisie actuelle de cet élément sur « hints ».

Voir également inputMethodHints() et inputMethodQuery().

void QGraphicsItem::setOpacity(qreal opacity)

Définit l'opacity locale de cet élément, comprise entre 0,0 (transparent) et 1,0 (opaque). L'opacité locale de l'élément est combinée à celles de ses parents et ancêtres pour former l'effectiveOpacity().

Par défaut, l’opacité se propage du parent vers l’enfant ; ainsi, si l’opacité d’un parent est de 0,5 et que celle de l’enfant est également de 0,5, l’opacité effective de l’enfant sera de 0,25.

La propriété d'opacité détermine l'état du « painter » transmis à la fonction ` paint()`. Si l'élément est mis en cache, c'est-à-dire si ` ItemCoordinateCache ` ou ` DeviceCoordinateCache` est activé, la propriété effective sera appliquée au cache de l'élément lors de son rendu.

Deux indicateurs d’élément influencent la manière dont l’opacité de l’élément est combinée avec celle de son parent : ItemIgnoresParentOpacity et ItemDoesntPropagateOpacityToChildren.

Voir également opacity(), effectiveOpacity() et setVisible().

void QGraphicsItem::setPanelModality(QGraphicsItem::PanelModality panelModality)

Définit la modalité de cet élément sur « panelModality ».

La modification de la modalité d'un élément visible prend effet immédiatement.

Voir également panelModality().

void QGraphicsItem::setParentItem(QGraphicsItem *newParent)

Définit l'élément parent de cet élément sur newParent. Si cet élément possède déjà un parent, il est d'abord supprimé de son parent précédent. Si newParent vaut 0, cet élément devient un élément de niveau supérieur.

Notez que cela ajoute implicitement cet élément graphique à la scène du parent. Vous ne devez pas ajouter vous-même l'élément add à la scène.

Le comportement lors de l’appel de cette fonction sur un élément qui est un ancêtre de newParent est indéfini.

Voir également ` parentItem()` et ` childItems()`.

void QGraphicsItem::setPos(const QPointF &pos)

Définit la position de l'élément à pos, qui est exprimée dans les coordonnées du parent. Pour les éléments sans parent, pos est exprimée dans les coordonnées de la scène.

La position de l’élément décrit son origine (coordonnée locale (0, 0)) dans le système de coordonnées du parent.

Voir également pos(), scenePos() et Le système de coordonnées de la vue graphique.

void QGraphicsItem::setPos(qreal x, qreal y)

Cette fonction de commodité équivaut à appeler setPos(QPointF(x, y)).

void QGraphicsItem::setRotation(qreal angle)

Définit l'angle de rotation dans le sens des aiguilles d'une montre, en degrés, autour de l'axe Z. La valeur par défaut est 0 (c'est-à-dire que l'élément n'est pas pivoté). L'attribution d'une valeur négative entraînera une rotation dans le sens inverse des aiguilles d'une montre. Normalement, l’angle de rotation est compris entre -360 et 360, mais il est également possible d’attribuer des valeurs en dehors de cette plage (par exemple, une rotation de 370 degrés équivaut à une rotation de 10 degrés).

L’élément est pivoté autour de son point d’origine de transformation, qui est par défaut (0, 0). Vous pouvez sélectionner une autre origine de transformation en appelant la méthode setTransformOriginPoint().

La rotation est combinée aux fonctions ` scale()`, ` transform()` et ` transformations()` de l’élément afin de mapper le système de coordonnées de l’élément à celui de l’élément parent.

Voir également rotation(), setTransformOriginPoint() et Transformations.

void QGraphicsItem::setScale(qreal factor)

Définit l'factor de mise à l'échelle de l'élément. Le facteur d'échelle par défaut est 1,0 (c'est-à-dire que l'élément n'est pas mis à l'échelle). Un facteur d'échelle de 0,0 réduira l'élément à un simple point. Si vous indiquez un facteur d'échelle négatif, l'élément sera inversé et reflété (c'est-à-dire pivoté de 180 degrés).

L'élément est mis à l'échelle autour de son point d'origine de transformation, qui est par défaut (0, 0). Vous pouvez sélectionner une autre origine de transformation en appelant la méthode ` setTransformOriginPoint()`.

La mise à l’échelle est combinée aux fonctions ` rotation()`, ` transform()` et ` transformations()` de l’élément afin de mapper le système de coordonnées de l’élément à celui de l’élément parent.

Voir également scale(), setTransformOriginPoint() et l’exemple de transformations.

void QGraphicsItem::setSelected(bool selected)

Si la propriété « selected » est définie sur « true » et que cet élément est sélectionnable, il est sélectionné ; dans le cas contraire, il n'est pas sélectionné.

Si l'élément fait partie d'un groupe, cette fonction inverse l'état de sélection de l'ensemble du groupe. Si le groupe est sélectionné, tous les éléments du groupe sont également sélectionnés ; si le groupe n'est pas sélectionné, aucun élément du groupe n'est sélectionné.

Seuls les éléments visibles, activés et sélectionnables peuvent être sélectionnés. Si selected est vrai et que cet élément est invisible, désactivé ou non sélectionnable, cette fonction n'a aucun effet.

Par défaut, les éléments ne peuvent pas être sélectionnés. Pour activer la sélection, activez l’indicateur ` ItemIsSelectable `.

Cette fonction est fournie à titre de commodité, permettant de basculer individuellement l’état de sélection d’un élément. Cependant, une méthode plus courante pour sélectionner des éléments consiste à appeler ` QGraphicsScene::setSelectionArea()`, qui appellera cette fonction pour tous les éléments visibles, activés et sélectionnables situés dans une zone spécifiée de la scène.

Voir également isSelected() et QGraphicsScene::selectedItems().

void QGraphicsItem::setToolTip(const QString &toolTip)

Définit l'info-bulle de l'élément sur toolTip. Si toolTip est vide, l'info-bulle de l'élément est effacée.

Voir également toolTip() et QToolTip.

void QGraphicsItem::setTransform(const QTransform &matrix, bool combine = false)

Définit la matrice de transformation actuelle de l'élément sur matrix.

Si combine est vrai, alors matrix est combiné avec la matrice actuelle ; sinon, matrix remplace la matrice actuelle. combine est faux par défaut.

Pour simplifier l’interaction avec les éléments utilisant une vue transformée, QGraphicsItem fournit les fonctions mapTo... et mapFrom... qui permettent de convertir les coordonnées des éléments en coordonnées de la scène, et inversement. Par exemple, vous pouvez appeler mapToScene() pour mapper une coordonnée d’élément vers une coordonnée de la scène, ou mapFromScene() pour mapper des coordonnées de la scène vers des coordonnées d’élément.

La matrice de transformation est combinée avec les fonctions rotation(), scale() et transformations() de l'élément pour former une transformation combinée qui mappe le système de coordonnées de l'élément vers celui de son parent.

Voir également transform(), setRotation(), setScale(), setTransformOriginPoint(), Le système de coordonnées de la vue graphique et Transformations.

void QGraphicsItem::setTransformOriginPoint(const QPointF &origin)

Définit le point d'origin e de la transformation dans les coordonnées de l'élément.

Voir également ` transformOriginPoint()` et ` Transformations`.

void QGraphicsItem::setTransformOriginPoint(qreal x, qreal y)

Définit le point d'origine de la transformation dans les coordonnées de l'élément. Cela équivaut à appeler la fonction setTransformOriginPoint(QPointF(x, y)).

Voir également setTransformOriginPoint() et Transformations.

void QGraphicsItem::setTransformations(const QList<QGraphicsTransform *> &transformations)

Définit une liste d'transformations graphiques (QGraphicsTransform) qui s'appliquent actuellement à cet élément.

Si vous souhaitez simplement faire pivoter ou mettre à l'échelle un élément, vous devriez plutôt appeler ` setRotation()` ou ` setScale()`. Si vous souhaitez définir une transformation arbitraire sur un élément, vous pouvez appeler ` setTransform()`.

QGraphicsTransform Cette méthode permet d’appliquer et de contrôler une chaîne d’opérations de transformation individuelles sur un élément. Elle est particulièrement utile dans les animations, où chaque opération de transformation doit être interpolée indépendamment ou de manière différente.

Les transformations sont combinées avec les méthodes ` rotation()` (), ` scale()` () et ` transform()` () de l’élément afin de faire correspondre le système de coordonnées de l’élément à celui de son élément parent.

Voir également les méthodes transformations(), scale(), setTransformOriginPoint() et Transformations.

void QGraphicsItem::setVisible(bool visible)

Si visible est vrai, l'élément est rendu visible. Dans le cas contraire, l'élément est rendu invisible. Les éléments invisibles ne sont pas affichés et ne reçoivent aucun événement. En particulier, les événements de souris traversent les éléments invisibles et sont transmis à tout élément pouvant se trouver derrière. Les éléments invisibles ne peuvent pas non plus être sélectionnés, ils ne peuvent pas recevoir le focus et ne sont pas détectés par les fonctions de localisation des éléments d'QGraphicsScene.

Si un élément devient invisible alors qu’il a la souris en main (c’est-à-dire qu’il reçoit des événements de souris), il perdra automatiquement le contrôle de la souris, et ce contrôle ne sera pas rétabli en rendant l’élément à nouveau visible ; il doit recevoir un nouveau clic de souris pour récupérer le contrôle de la souris.

De même, un élément invisible ne peut pas avoir le focus ; ainsi, si l’élément a le focus lorsqu’il devient invisible, il le perdra, et ce focus ne sera pas rétabli simplement en rendant l’élément à nouveau visible.

Si vous masquez un élément parent, tous ses enfants seront également masqués. Si vous affichez un élément parent, tous ses enfants seront affichés, à moins qu’ils n’aient été explicitement masqués (c’est-à-dire que si vous appelez setVisible(false) sur un enfant, celui-ci ne sera pas réaffiché même si son parent est masqué, puis à nouveau affiché).

Les éléments sont visibles par défaut ; il n’est pas nécessaire d’appeler setVisible() sur un nouvel élément.

Voir également isVisible(), show(), hide() et setOpacity().

void QGraphicsItem::setX(qreal x)

Définit les coordonnées x de la position de l'élément. Équivaut à l'appel de setPos(x, y()).

Voir également x() et setPos().

void QGraphicsItem::setY(qreal y)

Définit les coordonnées y de la position de l'élément. Équivalent à l'appel de ` setPos` (`x()`, `y`).

Voir également y(), x() et setPos().

void QGraphicsItem::setZValue(qreal z)

Définit la valeur Z de l'élément sur z. La valeur Z détermine l'ordre d'empilement des éléments frères (voisins). Un élément frère dont la valeur Z est élevée sera toujours affiché par-dessus un autre élément frère dont la valeur Z est inférieure.

Si vous réinitialisez la valeur Z, c'est l'ordre d'insertion de l'élément qui déterminera son ordre de superposition.

La valeur Z n'a aucune incidence sur la taille de l'élément.

La valeur Z par défaut est 0.

Voir également zValue(), Sorting, stackBefore() et ItemStacksBehindParent.

[virtual] QPainterPath QGraphicsItem::shape() const

Renvoie la forme de cet élément sous la forme d’un objet ` QPainterPath ` en coordonnées locales. Cette forme est utilisée à de nombreuses fins, notamment pour la détection des collisions, les tests de collision et les fonctions ` QGraphicsScene::items()`.

L'implémentation par défaut appelle ` boundingRect()` pour renvoyer une simple forme rectangulaire, mais les sous-classes peuvent réimplémenter cette fonction afin de renvoyer une forme plus précise pour les éléments non rectangulaires. Par exemple, un élément rond peut choisir de renvoyer une forme elliptique pour une meilleure détection des collisions. Par exemple :

QPainterPath RoundItem::shape() const
{
    QPainterPath path;
    path.addEllipse(boundingRect());
    return path;
}

Le contour d’une forme peut varier en fonction de la largeur et du style du stylo utilisé lors du dessin. Si vous souhaitez inclure ce contour dans la forme de l’élément, vous pouvez créer une forme à partir du trait à l’aide de QPainterPathStroker.

Cette fonction est appelée par les implémentations par défaut de ` contains()` et ` collidesWithPath()`.

Voir également boundingRect(), contains(), prepareGeometryChange() et QPainterPathStroker.

void QGraphicsItem::show()

Affiche l'élément (les éléments sont visibles par défaut).

Cette fonction pratique équivaut à appeler setVisible(true).

Voir également hide() et setVisible().

void QGraphicsItem::stackBefore(const QGraphicsItem *sibling)

Place cet élément avant « sibling », ce qui signifie qu'il sera affiché derrière l'élément frère. En d'autres termes, l'élément frère apparaîtra visuellement par-dessus cet élément.

Les deux éléments doivent être frères (c'est-à-dire qu'ils doivent partager le même élément parent, ou être tous deux des éléments de niveau supérieur). L'élément sibling doit avoir la même valeur Z que cet élément, sinon l'appel de cette fonction n'aura aucun effet.

Par défaut, tous les éléments frères sont empilés selon leur ordre d’insertion (c’est-à-dire que le premier élément ajouté est affiché avant le suivant). Si les valeurs Z de deux éléments sont différentes, l’élément ayant la valeur Z la plus élevée est affiché par-dessus. Lorsque les valeurs Z sont identiques, c’est l’ordre d’insertion qui détermine l’ordre d’empilement.

Voir également setZValue(), ItemStacksBehindParent et Sorting.

QGraphicsObject *QGraphicsItem::toGraphicsObject()

Renvoie l'élément graphique converti en ` QGraphicsObject`, si la classe est effectivement un objet graphique ; sinon, renvoie 0.

const QGraphicsObject *QGraphicsItem::toGraphicsObject() const

Renvoie l'élément graphique converti en ` QGraphicsObject` si la classe est effectivement un objet graphique ; sinon, renvoie 0.

QString QGraphicsItem::toolTip() const

Renvoie l'info-bulle de l'élément, ou un objet ` QString ` vide si aucune info-bulle n'a été définie.

Voir également setToolTip() et QToolTip.

QGraphicsItem *QGraphicsItem::topLevelItem() const

Renvoie l'élément de niveau supérieur de cet élément. L'élément de niveau supérieur est l'ancêtre le plus haut placé de l'élément dont le parent est nullptr. Si un élément n'a pas de parent, son propre pointeur est renvoyé (c'est-à-dire qu'un élément de niveau supérieur est son propre élément de niveau supérieur).

Voir aussi parentItem().

QGraphicsWidget *QGraphicsItem::topLevelWidget() const

Renvoie un pointeur vers le widget de niveau supérieur de l'élément (c'est-à-dire l'ancêtre de l'élément dont le parent est nullptr, ou dont le parent n'est pas un widget), ou nullptr si cet élément ne possède pas de widget de niveau supérieur. Si l'élément est lui-même son propre widget de niveau supérieur, cette fonction renvoie un pointeur vers l'élément lui-même.

QTransform QGraphicsItem::transform() const

Renvoie la matrice de transformation de cet élément.

La matrice de transformation est combinée avec les fonctions ` rotation()`, ` scale()` et ` transformations()` de l'élément pour former une transformation combinée de l'élément.

La matrice de transformation par défaut est une matrice identité.

Voir également setTransform() et sceneTransform().

QPointF QGraphicsItem::transformOriginPoint() const

Renvoie le point d'origine de la transformation dans les coordonnées de l'élément.

La valeur par défaut est QPointF(0,0).

Voir également setTransformOriginPoint() et Transformations.

QList<QGraphicsTransform *> QGraphicsItem::transformations() const

Renvoie une liste des transformations graphiques actuellement appliquées à cet élément.

QGraphicsTransform Cette fonction permet d’appliquer et de contrôler une chaîne d’opérations de transformation individuelles sur un élément. Elle est particulièrement utile dans les animations, où chaque opération de transformation doit être interpolée indépendamment ou différemment.

Les transformations sont combinées avec les méthodes rotation(), scale() et transform() de l’élément afin de faire correspondre le système de coordonnées de l’élément à celui de l’élément parent.

Voir également setTransformations(), scale(), rotation(), transformOriginPoint() et Transformations.

[virtual] int QGraphicsItem::type() const

Renvoie le type d'un élément sous forme d'entier. Toutes les classes d'éléments graphiques standard sont associées à une valeur unique ; voir QGraphicsItem::Type. Ces informations de type sont utilisées par la fonction qgraphicsitem_cast() pour distinguer les différents types.

L'implémentation par défaut (dans ` QGraphicsItem`) renvoie ` UserType`.

Pour pouvoir utiliser qgraphicsitem_cast() avec un élément personnalisé, réimplémentez cette fonction et déclarez une valeur d’énumération Type égale au type de votre élément personnalisé. Les éléments personnalisés doivent renvoyer une valeur supérieure ou égale à UserType (65536).

Par exemple :

class Item : public QGraphicsItem
{
public:
   enum { Type = UserType + 1 };

   int type() const override
   {
       // Enable the use of qgraphicsitem_cast with this item.
       return Type;
   }
   //...
};

Voir également UserType.

void QGraphicsItem::ungrabKeyboard()

Libère le verrouillage du clavier.

Voir également grabKeyboard() et ungrabMouse().

void QGraphicsItem::ungrabMouse()

Libère la sélection de la souris.

Voir également grabMouse() et ungrabKeyboard().

void QGraphicsItem::unsetCursor()

Supprime le curseur de cet élément.

Voir également hasCursor() et setCursor().

void QGraphicsItem::update(const QRectF &rect = QRectF())

Planifie un rafraîchissement de la zone couverte par rect dans cet élément. Vous pouvez appeler cette fonction chaque fois que votre élément doit être rafraîchi, par exemple s'il change d'apparence ou de taille.

Cette fonction ne provoque pas de rafraîchissement immédiat ; elle planifie plutôt une demande de rafraîchissement qui sera traitée par QGraphicsView une fois que le contrôle aura atteint la boucle d’événements. L’élément ne sera rafraîchi que s’il est visible dans une vue associée.

En raison du rafraîchissement de l’élément, d’autres éléments qui chevauchent la zone rect peuvent également être rafraîchis.

Si l’élément est invisible (c’est-à-dire si isVisible() renvoie false), cette fonction ne fait rien.

Voir également paint() et boundingRect().

void QGraphicsItem::update(qreal x, qreal y, qreal width, qreal height)

Cette fonction de commodité équivaut à appeler `update(QRectF(x, y, width, height))`.

[protected] void QGraphicsItem::updateMicroFocus()

Met à jour le micro-focus de l'élément.

Voir également QInputMethod.

[virtual protected] void QGraphicsItem::wheelEvent(QGraphicsSceneWheelEvent *event)

Ce gestionnaire d'événement, destiné à l'événement event, peut être réimplémenté afin de recevoir les événements de molette pour cet élément. Si vous réimplémentez cette fonction, la valeur event sera acceptée par défaut.

Si vous ignorez l’événement (par exemple, en appelant ` QEvent::ignore()`), celui-ci se propagera à tous les éléments situés sous cet élément. Si aucun élément n’accepte l’événement, celui-ci sera ignoré par la scène et se propagera à la vue (par exemple, la barre de défilement verticale de la vue).

L’implémentation par défaut ignore l’événement.

Voir également sceneEvent().

QGraphicsWidget *QGraphicsItem::window() const

Renvoie la fenêtre de l'élément, ou ` nullptr ` si cet élément ne possède pas de fenêtre. Si l'élément est une fenêtre, la fonction renvoie l'élément lui-même. Sinon, elle renvoie l'ancêtre le plus proche qui soit une fenêtre.

Voir aussi QGraphicsWidget::isWindow().

qreal QGraphicsItem::x() const

Cette fonction pratique équivaut à appeler ` pos()`.x().

Voir également setX() et y().

qreal QGraphicsItem::y() const

Cette fonction pratique équivaut à appeler pos().y().

Voir également setY() et x().

qreal QGraphicsItem::zValue() const

Renvoie la valeur Z de l'élément. La valeur Z influe sur l'ordre de superposition des éléments frères (voisins).

La valeur Z par défaut est 0.

Voir également setZValue(), Sorting, stackBefore() et ItemStacksBehindParent.