QGraphicsItem Class

Documentation des fonctions membres

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

Construit un QGraphicsItem avec l'élément parent donné. Il ne modifie pas l'objet parent renvoyé par QObject::parent().

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

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

[virtual noexcept] QGraphicsItem::~QGraphicsItem()

Détruit le site QGraphicsItem et tous ses 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 des é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 ; les éléments sont transparents au glisser-déposer.

Voir aussi 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 aussi 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 la souris sont acceptés.

Si un élément accepte un bouton de souris, il deviendra l'élément de saisie de la souris lorsqu'un événement de pression de la souris sera délivré pour ce bouton de souris. Toutefois, si l'élément n'accepte pas le bouton, QGraphicsScene transmettra les événements de souris au premier élément inférieur qui les 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 simple animation 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 cadre d'animation.

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

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

Cette fonction virtuelle pure définit les limites extérieures de l'élément sous la forme d'un rectangle ; toute peinture doit être limitée à l'intérieur du rectangle de délimitation de l'élément. 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 prepareGeometryChange(). Cela permet de notifier la scène du changement imminent, afin qu'elle puisse mettre à jour l'index géométrique de l'élément ; sinon, la scène ne sera pas au courant de la nouvelle géométrie de l'élément, et les résultats ne seront pas définis (typiquement, des artefacts de rendu sont laissés à l'intérieur de 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 peignent un contour ou un trait, il est important d'inclure la moitié de la largeur du stylo dans le rectangle de délimitation. Il n'est cependant pas nécessaire de compenser 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 délimitée pour cet élément. L'espace de coordonnées de la région renvoyée dépend de itemToDeviceTransform. Si vous passez une identité QTransform en paramètre, cette fonction renverra une région de coordonnées locales.

La région délimitée décrit un contour grossier du contenu visuel de l'élément. Bien qu'elle soit coûteuse à calculer, elle est également plus précise que boundingRect() et permet d'éviter de repeindre inutilement un élément lorsqu'il est mis à jour. Cette méthode est particulièrement efficace pour les éléments fins (par exemple, les lignes ou les polygones simples). Vous pouvez régler la granularité de la région délimitée en appelant setBoundingRegionGranularity(). La granularité par défaut est 0 ; dans ce cas, la région de délimitation de l'élément est la même que son rectangle de délimitation.

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

Voir aussi boundingRegionGranularity().

qreal QGraphicsItem::boundingRegionGranularity() const

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

Voir également setBoundingRegionGranularity().

QGraphicsItem::CacheMode QGraphicsItem::cacheMode() const

Renvoie le mode de cache pour cet élément. Le mode par défaut est NoCache (c'est-à-dire que le cache est désactivé et que toute la peinture est immédiate).

Voir aussi setCacheMode().

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

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

Les éléments sont triés par ordre d'empilement. Cet ordre tient compte à la fois de l'ordre d'insertion des éléments et de leur valeur Z.

Voir aussi setParentItem(), zValue() et Sorting.

QRectF QGraphicsItem::childrenBoundingRect() const

Renvoie le rectangle de délimitation des descendants de cet élément (c'est-à-dire ses enfants, leurs enfants, etc.) en coordonnées locales. ) en coordonnées locales. Le rectangle contiendra tous les descendants après qu'ils aient été mis en correspondance avec les coordonnées locales. Si l'élément n'a pas d'enfants, cette fonction renvoie un QRectF vide.

Cela n'inclut pas le rectangle de délimitation de l'élément ; la fonction renvoie uniquement le rectangle de délimitation cumulé de ses descendants. Si vous devez inclure le rectangle de délimitation de cet élément, vous pouvez ajouter boundingRect() à childrenBoundingRect() à l'aide de QRectF::operator|().

Cette fonction est d'une complexité linéaire ; elle détermine la taille du rectangle de délimitation retourné en itérant à travers tous les descendants.

Voir également boundingRect() et sceneBoundingRect().

void QGraphicsItem::clearFocus()

Prend le focus de la saisie clavier de l'élément.

S'il a le focus, un message 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 définissent le drapeau ItemIsFocusable ou les widgets qui définissent une politique de mise au point appropriée peuvent accepter la mise au point du clavier.

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

QPainterPath QGraphicsItem::clipPath() const

Renvoie le chemin de clip de cet élément, ou une adresse QPainterPath vide si l'élément n'est pas clippé. Le chemin d'accès limite l'apparence et l'interaction de l'élément (c'est-à-dire qu'il restreint la zone à l'intérieur de laquelle l'élément peut dessiner et pour laquelle il peut recevoir des événements).

Vous pouvez activer l'écrêtage en définissant les drapeaux ItemClipsToShape ou ItemClipsChildrenToShape. La trajectoire d'écrêtage de l'élément est calculée en intersectant toutes les formes des ancêtres de l'écrêtage. Si l'élément définit ItemClipsToShape, le clip final est intersecté avec la propre forme de l'élément.

Voir aussi 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 valeur de mode est appliquée à other, et la forme ou le rectangle de délimitation qui en résulte est ensuite 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 coupe, contient ou est contenu par la forme de cet élément (voir Qt::ItemSelectionMode pour plus de détails).

L'implémentation par défaut est basée sur l'intersection des formes et appelle shape() sur les deux éléments. Comme la complexité de l'intersection arbitraire d'une forme et d'une autre croît d'un ordre de grandeur lorsque les formes sont complexes, cette opération peut prendre beaucoup de temps. 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 d'utiliser des contraintes naturelles dans les formes de vos propres objets, afin d'améliorer les performances de la détection des collisions. Par exemple, la collision de deux objets parfaitement circulaires non transformés peut être déterminée très efficacement en comparant leurs positions et leurs rayons.

N'oubliez pas 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 qu'une 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 coupe, contient ou est contenu par la forme de cet élément.

Notez que cette fonction vérifie si la forme ou le rectangle de délimitation de l'élément (en fonction de mode) est contenu dans path, et non si path est contenu dans la forme ou le rectangle de délimitation 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 façon dont les collisions sont détectées est déterminée en appliquant mode aux éléments qui sont comparés à cet élément, c'est-à-dire que la forme ou le rectangle de délimitation de chaque élément est vérifié par rapport à 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'ancêtre commun le plus proche de cet élément et de other, ou nullptr si other est nullptr, ou s'il n'y a pas d'ancêtre commun.

Voir aussi isAncestorOf().

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

Renvoie true si cet élément contient point, qui est en coordonnées locales ; sinon, elle renvoie false. Elle est le plus souvent appelée à partir de QGraphicsView pour déterminer quel élément se trouve sous le curseur, et pour cette raison, 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 pour fournir une implémentation (peut-être plus efficace).

Voir aussi 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 détails sur l'événement à traiter.

Si vous ignorez l'événement (c'est-à-dire en appelant QEvent::ignore()), event se propagera à tout élément situé sous cet élément. Si aucun élément n'accepte l'événement, il sera ignoré par la scène et se propagera à la vue.

Il est courant d'ouvrir un site 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 aussi 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 sera au-dessus de l'élément. Voir le site list of predefined cursor objects pour une gamme de formes utiles.

Un élément de l'éditeur peut vouloir utiliser un curseur en forme de poutre en I :

item->setCursor(Qt::IBeamCursor);

Si aucun curseur n'a été défini, le curseur de l'élément situé en dessous 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 forme de 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);
if (item->data(ObjectName).toString().isEmpty()) {
    if (qgraphicsitem_cast<ButtonItem *>(item))
        item->setData(ObjectName, "Button");
}

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

Voir aussi setData().

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

Renvoie la matrice de transformation du périphérique de cet élément, en utilisant viewportTransform pour passer des coordonnées de la scène à celles du périphérique. Cette matrice peut être utilisée pour faire correspondre des coordonnées et des formes géométriques du système de coordonnées local de cet élément au système de coordonnées de la fenêtre de visualisation (ou de n'importe quel périphérique). Pour appliquer les coordonnées de la fenêtre de visualisation, 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 de visualisation, mais elle comprend également le drapeau ItemIgnoresTransformations. La transformation de l'appareil peut être utilisée pour effectuer un mappage précis des coordonnées (et une détection des collisions) pour les éléments non transformables.

Voir aussi 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énement, pour l'événement event, peut être réimplémenté pour recevoir les événements de glisser-déposer pour cet élément. Les événements d'entrée par glissement sont générés lorsque le curseur entre 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 de dépôt, en plus de recevoir les événements de déplacement par glissement et de sortie par glissement. Dans le cas contraire, l'événement est ignoré et se propage à l'élément situé en dessous. Si l'événement est accepté, l'élément recevra un événement de déplacement par glissement 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énement, pour l'événement event, peut être réimplémenté pour recevoir les événements de sortie par glissement pour cet élément. Ces événements sont générés lorsque le curseur quitte la zone de l'élément. Le plus souvent, vous n'aurez pas besoin de réimplémenter cette fonction, mais elle peut être utile pour réinitialiser l'état de votre élément (par exemple, la mise en surbrillance).

Appeler 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 fonction, 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énement, pour l'événement event, peut être réimplémenté pour recevoir les événements de déplacement par glissement pour cet élément. Les événements de déplacement par glissement sont générés lorsque le curseur se déplace à l'intérieur de la zone de l'élément. Le plus souvent, vous n'aurez pas besoin de réimplémenter cette fonction ; elle est utilisée pour indiquer que seules certaines parties de l'élément peuvent accepter des déposes.

L'appel à QEvent::ignore() ou QEvent::accept() sur event permet de déterminer si l'élément accepte ou non les chutes à la position de l'événement. Par défaut, event est accepté, ce qui indique que l'élément autorise les chutes à 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énement, pour l'événement event, peut être réimplémenté pour recevoir les événements de chute de cet élément. Les éléments ne peuvent recevoir des événements de dépôt que si le dernier événement de déplacement par glissement a été accepté.

L'appel à 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, qui est comprise entre 0,0 (transparent) et 1,0 (opaque). Cette valeur est une combinaison de l'opacité locale de l'élément et des opacités de ses parents et ancêtres. L'opacité effective détermine la manière dont l'élément est rendu.

Voir aussi 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 QGraphicsView, cette fonction de commodité tentera de faire défiler la vue pour s'assurer que rect est visible à l'intérieur de la fenêtre de visualisation de la vue. Si rect est un rectangle nul (par défaut), QGraphicsItem prendra par défaut le rectangle de délimitation de l'élément. xmargin et ymargin sont le nombre de pixels que la vue doit utiliser pour les marges.

Si le rectangle spécifié ne peut être atteint, le contenu est défilé jusqu'à la position valide la plus proche.

Si cet élément n'est pas visualisé par un 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 de commodité équivaut à appeler ensureVisible(QRectF(x, y, w, h), xmargin, ymargin).

bool QGraphicsItem::filtersChildEvents() const

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

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 drapeaux de cet élément. Les drapeaux décrivent les fonctionnalités configurables de l'élément qui sont activées ou non. Par exemple, si les drapeaux incluent ItemIsFocusable, l'élément peut accepter le focus de saisie.

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, pour l'événement event, peut être réimplémenté pour recevoir le focus dans les événements pour cet élément. L'implémentation par défaut appelle ensureVisible().

Voir aussi focusOutEvent(), sceneEvent() et setFocus().

QGraphicsItem *QGraphicsItem::focusItem() const

Si cet élément, un enfant ou un descendant de cet élément a actuellement le focus d'entrée, cette fonction renvoie un pointeur sur cet élément. Si aucun descendant n'a le focus d'entrée, nullptr est renvoyé.

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

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

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

Voir aussi focusInEvent(), sceneEvent() et setFocus().

QGraphicsItem *QGraphicsItem::focusProxy() const

Renvoie le proxy de focus de cet élément, ou nullptr si cet élément n'a pas de proxy de focus.

Voir aussi setFocusProxy(), setFocus() et hasFocus().

void QGraphicsItem::grabKeyboard()

Saisit l'entrée 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 retiré de la scène
• L'élément est supprimé
• L'élément appelle ungrabKeyboard()
• Un autre élément appelle grabKeyboard() ; l'élément reprend la main sur le clavier lorsque l'autre élément appelle ungrabKeyboard().

Lorsqu'un élément obtient la saisie du clavier, il reçoit un événement QEvent::GrabKeyboard. Lorsqu'il perd la prise de clavier, il reçoit un événement QEvent::UngrabKeyboard. Ces événements peuvent être utilisés pour détecter si votre élément gagne ou perd l'accès au clavier par d'autres moyens que l'accès au focus d'entrée.

Il n'est presque jamais nécessaire de saisir explicitement le clavier dans Qt, car Qt le saisit et le relâche judicieusement. En particulier, Qt saisit le clavier lorsque votre élément gagne le focus d'entrée, et le relâche lorsque votre élément perd le focus d'entrée, ou lorsque l'élément est caché.

Notez que seuls les éléments visibles peuvent saisir le clavier. Appeler grabKeyboard() sur un élément invisible n'a aucun effet.

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

Voir aussi ungrabKeyboard(), grabMouse() et setFocus().

void QGraphicsItem::grabMouse()

Saisit l'entrée de la souris.

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

• l'élément devient invisible
• L'élément est retiré de la scène
• L'élément est supprimé
• L'élément appelle ungrabMouse()
• Un autre élément appelle grabMouse() ; l'élément récupère la souris lorsque l'autre élément appelle ungrabMouse().

Lorsqu'un élément récupère la souris, il reçoit un événement QEvent::GrabMouse. Lorsqu'il perd la prise de la souris, il reçoit un événement QEvent::UngrabMouse. Ces événements peuvent être utilisés pour détecter si votre élément obtient ou perd la prise de la souris par d'autres moyens que la réception d'événements liés au bouton de la souris.

Il n'est presque jamais nécessaire d'attraper explicitement la souris dans Qt, car Qt l'attrape et la relâche de manière sensée. En particulier, Qt saisit la souris lorsque vous appuyez sur un bouton de la souris, et maintient la souris saisie jusqu'à ce que vous relâchiez le dernier bouton de la souris. En outre, les widgets Qt::Popup appellent implicitement grabMouse() lorsqu'ils sont affichés et ungrabMouse() lorsqu'ils sont cachés.

Notez que seuls les éléments visibles peuvent saisir la souris. L'appel à grabMouse() sur un élément invisible n'a aucun effet.

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

Voir aussi QGraphicsScene::mouseGrabberItem(), ungrabMouse() et grabKeyboard().

QGraphicsEffect *QGraphicsItem::graphicsEffect() const

Renvoie un pointeur sur l'effet de cet élément s'il en a un, sinon nullptr.

Voir aussi setGraphicsEffect().

QGraphicsItemGroup *QGraphicsItem::group() const

Renvoie un pointeur sur le groupe d'éléments de cet élément, ou nullptr si cet élément n'est pas membre d'un groupe.

Voir aussi setGroup(), QGraphicsItemGroup, et QGraphicsScene::createItemGroup().

bool QGraphicsItem::hasCursor() const

Renvoie true si cet élément a un curseur défini ; sinon, false est renvoyé.

Par défaut, les éléments n'ont pas de curseur défini. cursor() renvoie un curseur standard avec une flèche pointée.

Voir aussi unsetCursor().

bool QGraphicsItem::hasFocus() const

Renvoie true si l'élément est actif et que l'élément ou son focus proxy est au centre de l'attention du clavier ; sinon, renvoie false.

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

void QGraphicsItem::hide()

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

Cette fonction de commodité équivaut à appeler setVisible(false).

Voir aussi show() et setVisible().

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

Ce gestionnaire d'événement, pour l'événement event, peut être réimplémenté pour recevoir les événements d'entrée au survol pour cet élément. L'implémentation par défaut appelle update() ; sinon, elle ne fait rien.

L'appel à QEvent::ignore() ou 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énement, pour 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 update() ; sinon, elle ne fait rien.

L'appel à QEvent::ignore() ou 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énement, pour l'événement event, peut être réimplémenté pour recevoir les événements de déplacement en survol de cet élément. L'implémentation par défaut ne fait rien.

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

Voir aussi hoverEnterEvent(), hoverLeaveEvent(), sceneEvent() et setAcceptHoverEvents().

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

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

Voir également inputMethodQuery() et sceneEvent().

Qt::InputMethodHints QGraphicsItem::inputMethodHints() const

Renvoie les indications de la méthode de saisie actuelle de cet élément.

Les indications de méthode de saisie ne sont pertinentes que pour les éléments de saisie. Les indices sont utilisés par la méthode de saisie pour indiquer comment elle doit fonctionner. Par exemple, si le drapeau Qt::ImhNumbersOnly est activé, la méthode de saisie peut modifier ses composants visuels pour indiquer que seuls des nombres peuvent être saisis.

L'effet peut varier d'une implémentation de la méthode de saisie à l'autre.

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 pouvoir prendre en charge des opérations complexes de la méthode de saisie, telles que la prise en charge du texte environnant et des reconversions. query précise 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, de sorte que tous les événements de 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 comme filtre d'événement pour l'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 des autres éléments de la même scène. De même, 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 la 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 s'agit d'un panneau actif ou d'un descendant d'un panneau actif. 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 n'a pas de panneau actif.

Seuls les éléments actifs peuvent obtenir le focus d'entrée.

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

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

Renvoie true si cet élément est bloqué par un panneau modal, false sinon. Si blockingPanel est différent de zéro, blockingPanel sera défini sur le panneau modal qui bloque cet élément. Si cet élément n'est pas bloqué, blockingPanel ne sera pas défini par cette fonction.

Cette fonction renvoie toujours false pour les éléments qui ne font pas partie d'une scène.

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

bool QGraphicsItem::isClipped() const

Renvoie true si cet élément est coupé. Un élément est coupé s'il a activé l'indicateur ItemClipsToShape ou si l'un de ses ancêtres a activé l'indicateur ItemClipsChildrenToShape.

L'écrêtage affecte l'apparence de l'élément (c.-à-d. la peinture), ainsi que les événements liés à la souris et au survol.

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

bool QGraphicsItem::isEnabled() const

Renvoie true si l'élément est activé ; sinon, il renvoie false.

Voir également setEnabled().

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

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

Voir aussi opaqueArea().

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

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

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

Renvoie true si le rectangle de délimitation de cet élément est complètement masqué par la forme opaque de item.

L'implémentation de base fait correspondre la forme opaqueArea() de item au système de coordonnées de cet élément, puis vérifie si la forme boundingRect() de cet élément est entièrement contenue dans la forme mise en correspondance.

Vous pouvez réimplémenter cette fonction pour 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, il renvoie false.

Les éléments qui font partie d'un groupe héritent de l'état sélectionné du 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, il renvoie false.

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

bool QGraphicsItem::isVisible() const

Renvoie true si l'élément est visible ; sinon, il renvoie false.

Notez que la visibilité générale de l'élément n'est pas liée au fait qu'il soit ou non visualisé par QGraphicsView.

Voir également setVisible().

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

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

Un élément peut ne pas être visible par 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 est caché, l'élément lui-même sera implicitement caché, 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 aussi QGraphicsWidget::windowFlags().

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

Cette fonction virtuelle est appelée par QGraphicsItem pour notifier aux éléments personnalisés qu'une partie de l'état de l'élément change. En réimplémentant cette fonction, vous pouvez réagir à un changement et, dans certains cas (en fonction de change), des ajustements peuvent être effectués.

change est le paramètre de l'élément qui change. value est la nouvelle valeur ; le type de la 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 GraphicsItemChange pour plus de détails.

Voir aussi GraphicsItemChange.

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

Renvoie un QTransform qui fait correspondre les coordonnées de cet élément à other. Si ok n'est pas nul, et s'il n'existe pas de transformation de ce type, le booléen pointé par ok sera mis à faux ; sinon, il sera mis à vrai.

Cette transformation constitue 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 permet également d'écrire un code plus efficace lorsque vous mettez en correspondance plusieurs fois les deux mêmes éléments.

Voir aussi mapToItem(), mapFromItem() et deviceTransform().

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

Ce gestionnaire d'événement, pour l'événement event, peut être réimplémenté pour recevoir les événements d'appui sur une touche pour cet élément. L'implémentation par défaut ignore l'événement. Si vous réimplémentez ce gestionnaire, l'événement sera accepté par défaut.

Notez que les événements liés aux touches ne sont reçus que pour les éléments pour lesquels l'indicateur ItemIsFocusable a été activé et pour lesquels l'attention est portée sur la saisie au clavier.

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

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

Ce gestionnaire d'événement, pour l'événement event, peut être réimplémenté pour recevoir les événements de déblocage des touches pour cet élément. L'implémentation par défaut ignore l'événement. Si vous réimplémentez ce gestionnaire, l'événement sera accepté par défaut.

Notez que les événements liés aux touches ne sont reçus que pour les éléments pour lesquels l'indicateur ItemIsFocusable a été activé et pour lesquels la saisie au clavier est privilégiée.

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

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

Transpose 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, et renvoie le chemin transposé.

Si item est nullptr, cette fonction renvoie la même chose 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

Transpose 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 transposée.

Si item est nullptr, cette fonction renvoie la même chose 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

Met en correspondance le polygone polygon, qui se trouve dans le système de coordonnées de item, avec le système de coordonnées de cet élément, et renvoie le polygone mis en correspondance.

Si item est nullptr, cette fonction renvoie la même chose 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

Transpose 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 transposé sous la forme d'un polygone.

Si item est nullptr, cette fonction renvoie la même chose 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 de commodité équivaut à 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

Transpose 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 transposé.

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

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

Mapper 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 renvoyer la coordonnée mappée.

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

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

Mappe le polygone polygon, qui se trouve dans le système de coordonnées du parent de cet élément, au système de coordonnées de cet élément, et renvoie le polygone mappé.

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

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

Mappe le rectangle rect, qui se trouve dans le système de coordonnées du parent de cet élément, au système de coordonnées de cet élément, et renvoie le rectangle mappé sous la forme d'un polygone.

Voir aussi 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 de commodité équivaut à appeler mapFromItem(QRectF(x, y, w, h)).

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

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

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

Transpose 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, et renvoie le chemin transposé.

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

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

Met en correspondance le point point, 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, et renvoie la coordonnée mise en correspondance.

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

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

Mappe le polygone polygon, 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 polygone mappé.

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

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

Mappe le rectangle rect, qui se trouve dans le système de coordonnées de la scène de cet élément, au système de coordonnées de cet élément, et renvoie le rectangle mappé sous la forme d'un polygone.

Voir aussi 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 de commodité équivaut à appeler mapFromScene(QRectF(x, y, w, h)).

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

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

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

Transpose 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 transposé en tant que nouveau rectangle (c'est-à-dire le rectangle de délimitation du polygone résultant).

Si item est nullptr, cette fonction renvoie la même chose 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 de commodité équivaut à appeler mapRectFromItem(item, QRectF(x, y, w, h)).

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

Transpose 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 transposé sous la forme d'un nouveau rectangle (c'est-à-dire le rectangle de délimitation du polygone résultant).

Voir aussi 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 de commodité équivaut à appeler mapRectFromParent(QRectF(x, y, w, h)).

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

Mappe le rectangle rect, qui est en coordonnées de scène, au système de coordonnées de cet élément, et renvoie le rectangle mappé en tant que nouveau rectangle (c'est-à-dire le rectangle de délimitation 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 de commodité équivaut à appeler mapRectFromScene(QRectF(x, y, w, h)).

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

Transpose 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 item, et renvoie le rectangle transposé en tant que nouveau rectangle (c'est-à-dire le rectangle de délimitation du polygone résultant).

Si item est nullptr, cette fonction renvoie la même chose 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 de commodité équivaut à appeler mapRectToItem(item, QRectF(x, y, w, h)).

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

Transpose 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 transposé sous la forme d'un nouveau rectangle (c'est-à-dire le rectangle de délimitation 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 de commodité équivaut à appeler mapRectToParent(QRectF(x, y, w, h)).

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

Mappe le rectangle rect, qui se trouve dans le système de coordonnées de cet élément, au système de coordonnées de la scène, et renvoie le rectangle mappé sous la forme d'un nouveau rectangle (c'est-à-dire le rectangle de délimitation 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 de commodité équivaut à appeler mapRectToScene(QRectF(x, y, w, h)).

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

Transpose 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 item, et renvoie le chemin transposé.

Si item est nullptr, cette fonction renvoie la même chose 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

Transpose 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, et renvoie la coordonnée transposée.

Si item est nullptr, cette fonction renvoie la même chose 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

Transpose le polygone polygon, qui se trouve dans le système de coordonnées de cet élément, dans le système de coordonnées de item, et renvoie le polygone transposé.

Si item est nullptr, cette fonction renvoie la même chose 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

Transpose 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 item, et renvoie le rectangle transposé sous la forme d'un polygone.

Si item est nullptr, cette fonction renvoie la même chose que mapToScene().

Voir aussi 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 de commodité é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

Mappe le chemin path, qui se trouve dans le système de coordonnées de cet élément, au système de coordonnées de son parent, et renvoie le chemin mappé. Si l'élément n'a pas de parent, path sera mappé 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

Mapper le point point, qui se trouve dans le système de coordonnées de cet élément, au système de coordonnées de son parent, et renvoyer la coordonnée mappée. Si l'élément n'a pas de parent, point sera mappé 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

Mappe le polygone polygon, 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 polygone mappé. Si l'élément n'a pas de parent, polygon sera mappé dans le système de coordonnées de la scène.

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

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

Transpose 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 transposé sous la forme d'un polygone. Si l'élément n'a pas de parent, rect sera mappé 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 de commodité équivaut à appeler mapToParent(QRectF(x, y, w, h)).

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

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

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

Transpose 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 la scène, et renvoie le chemin transposé.

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

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

Met en correspondance le point point, 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, et renvoie la coordonnée mise en correspondance.

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

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

Met en correspondance le 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, et renvoie le polygone mis en correspondance.

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

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

Mappe le rectangle rect, qui se trouve dans le système de coordonnées de cet élément, au système de coordonnées de la scène, et renvoie le rectangle mappé sous la forme d'un 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 de commodité équivaut à appeler mapToScene(QRectF(x, y, w, h)).

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

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

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

Ce gestionnaire d'événement, pour l'événement event, peut être réimplémenté pour recevoir les événements de double-clic de la souris pour 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 de 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 lorsque vous réimplémentez 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 selectable ni movable (les simples clics de souris sont ignorés dans ce cas, ce qui empêche la génération de doubles clics).

Voir aussi mousePressEvent(), mouseMoveEvent(), mouseReleaseEvent() et sceneEvent().

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

Ce gestionnaire d'événement, pour l'événement event, peut être réimplémenté pour recevoir les événements de déplacement de la souris pour 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 pression de la souris et qu'il est le capteur de souris actuel.

Appeler 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 lorsque vous réimplémentez cette fonction, appelez QGraphicsItem::mouseMoveEvent() dans votre réimplémentation.

Veuillez noter que mousePressEvent() détermine l'élément graphique qui reçoit les événements de la souris. Voir la description de mousePressEvent() pour plus de détails.

Voir aussi mousePressEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), et sceneEvent().

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

Ce gestionnaire d'événement, pour l'événement event, peut être réimplémenté pour recevoir les événements de pression de la souris pour cet élément. Les événements de pression de la souris ne sont délivrés qu'aux éléments qui acceptent le bouton de la souris pressé. Par défaut, un élément accepte tous les boutons de la souris, mais vous pouvez changer cela en appelant setAcceptedMouseButtons().

L'événement de pression de la souris détermine l'élément qui doit devenir le capteur de souris (voir QGraphicsScene::mouseGrabberItem()). Si vous ne réimplémentez pas cette fonction, l'événement d'appui se propagera à tout élément supérieur situé 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 sera alors le capteur de souris. 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 la prise de la souris et event se propagera à tout élément supérieur situé en dessous. Aucun autre événement de souris ne sera transmis à cet élément, à moins qu'un nouvel événement de pression de la souris ne soit 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 lorsque vous réimplémentez 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énement, pour l'événement event, peut être réimplémenté pour recevoir les événements de relâchement de la souris pour cet élément.

L'appel à 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 lorsque vous réimplémentez cette fonction, appelez QGraphicsItem::mouseReleaseEvent() dans votre réimplémentation.

Veuillez noter que mousePressEvent() détermine l'élément graphique qui reçoit les événements de la souris. Voir la description de mousePressEvent() pour plus de détails.

Voir aussi mousePressEvent(), mouseMoveEvent(), mouseDoubleClickEvent() et sceneEvent().

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

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

qreal QGraphicsItem::opacity() const

Renvoie l'opacité locale de cet élément, qui est comprise entre 0,0 (transparent) et 1,0 (opaque). Cette valeur est combinée avec les valeurs du parent et de l'ancêtre dans effectiveOpacity(). L'opacité effective détermine la manière dont l'élément est rendu et affecte également sa visibilité lorsqu'il est interrogé par des fonctions telles que QGraphicsView::items().

La propriété d'opacité détermine l'état du peintre transmis à la fonction paint(). Si l'élément est mis en cache, c'est-à-dire 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 de 1,0, c'est-à-dire qu'elle est totalement 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 qu'elle n'est pas 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 une valeur vide QPainterPath, indiquant que cet élément est totalement 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, qui est généralement appelée par QGraphicsView, peint le contenu d'un élément en coordonnées locales.

Réimplémentez cette fonction dans une sous-classe de QGraphicsItem pour fournir l'implémentation de la peinture 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 indices de niveau de détail. L'argument widget est facultatif. S'il est fourni, il pointe vers le widget sur lequel la peinture est appliquée ; sinon, il vaut 0. Pour la peinture en cache, widget vaut toujours 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 son stylo est initialisé à la brosse QPalette::Text de la palette du dispositif de peinture. La brosse est initialisée à QPalette::Window.

Veillez à limiter toute peinture à l'intérieur des limites de boundingRect() pour éviter les artefacts de rendu (car QGraphicsView n'écrête pas le peintre pour vous). En particulier, lorsque QPainter rend le contour d'une forme en utilisant un QPen assigné, la moitié du contour sera dessinée à l'extérieur et l'autre moitié à l'intérieur de la forme que vous rendez (par exemple, avec une largeur de stylo de 2 unités, vous devez dessiner des contours d'une unité à l'intérieur de boundingRect()). QGraphicsItem ne prend pas en charge l'utilisation de stylos cosmétiques d'une largeur non nulle.

Toutes les peintures sont réalisées en coordonnées locales.

Voir aussi setCacheMode(), QPen::width(), Item Coordinates, et ItemUsesExtendedStyleOption.

QGraphicsItem *QGraphicsItem::panel() const

Renvoie le panneau de l'élément, ou nullptr si l'élément n'a pas de panneau. Si l'élément est un panneau, il se renvoie lui-même. Sinon, il renverra l'ancêtre le plus proche qui est un panneau.

Voir aussi isPanel() et ItemIsPanel.

QGraphicsItem::PanelModality QGraphicsItem::panelModality() const

Renvoie la modalité de cet élément.

Voir aussi setPanelModality().

QGraphicsItem *QGraphicsItem::parentItem() const

Renvoie un pointeur sur l'élément parent de cet élément. Si cet élément n'a pas de parent, nullptr est renvoyé.

Voir aussi setParentItem() et childItems().

QGraphicsObject *QGraphicsItem::parentObject() const

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

Voir aussi parentItem() et childItems().

QGraphicsWidget *QGraphicsItem::parentWidget() const

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

Voir aussi parentItem() et childItems().

QPointF QGraphicsItem::pos() const

Renvoie la position de l'élément en coordonnées parentales. Si l'élément n'a pas de parent, sa position est donnée en coordonnées de 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 la même chose que mapToParent(0, 0).

Par 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 pour que l'index de QGraphicsScene soit à jour.

La fonction prepareGeometryChange() appellera update() si cela est 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 sur cet élément à partir de filterItem.

Voir aussi installSceneEventFilter().

void QGraphicsItem::resetTransform()

Réinitialise la matrice de transformation de cet élément à la matrice d'identité ou toutes les propriétés de transformation à leurs valeurs par défaut. Cela équivaut à appeler 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 tourné).

La rotation est combinée avec les fonctions scale(), transform() et transformations() de l'élément pour faire correspondre le système de coordonnées de l'élément à celui de l'é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 de 1,0 (c'est-à-dire que l'élément n'est pas mis à l'échelle).

L'échelle est combinée avec les facteurs rotation(), transform() et transformations() de l'élément pour faire correspondre le système de coordonnées de l'élément à 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 stocké dans une scène.

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

QRectF QGraphicsItem::sceneBoundingRect() const

Renvoie le rectangle de délimitation de cet élément en coordonnées de scène, en combinant sceneTransform() et 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 relatifs à cet élément. Réimplémentez cette fonction pour intercepter les événements avant qu'ils ne soient envoyés aux gestionnaires d'événements spécialisés contextMenuEvent(), focusInEvent(), focusOutEvent(), hoverEnterEvent(), hoverMoveEvent(), hoverLeaveEvent(), keyPressEvent(), keyReleaseEvent(), mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent() et mouseDoubleClickEvent().

Retourne true si l'événement a été reconnu et traité ; sinon (par exemple, si le type d'événement n'a pas été reconnu), false est retourné.

event est l'événement intercepté.

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

Filtre les événements pour l'élément watched. event est l'événement filtré.

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

Les réimplémentations doivent renvoyer true pour empêcher le traitement ultérieur d'un événement donné, garantissant 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 aussi installSceneEventFilter().

QPointF QGraphicsItem::scenePos() const

Renvoie la position de l'élément en coordonnées de scène. Cela équivaut à appeler 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 la scène de cet élément. Cette matrice peut être utilisée pour faire correspondre des coordonnées et des formes géométriques du système de coordonnées local de cet élément au système de coordonnées de la scène. Pour faire correspondre des coordonnées 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 à transform(), qui ne renvoie que la transformation locale d'un élément, cette fonction inclut la position de l'élément (et de ses parents éventuels) et toutes les propriétés de transformation.

Voir aussi 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 par dx, dy. Si rect est un rectangle nul (par défaut), le rectangle de délimitation de l'élément est déroulé.

Le défilement constitue une alternative rapide au simple redécoupage lorsque le contenu de l'élément (ou de certaines parties de l'élément) est déplacé verticalement ou horizontalement. En fonction de la transformation actuelle et des capacités du dispositif de peinture (c'est-à-dire la fenêtre), cette opération peut consister à déplacer simplement des pixels d'un endroit à un autre à l'aide de memmove(). Dans la plupart des cas, cette opération est plus rapide que le rendu de 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 le rendu dans une fenêtre OpenGL, qui ne bénéficie pas de l'optimisation du défilement), cette fonction équivaut à appeler update(rect).

Remarque : le défilement n'est pris en charge que lorsque QGraphicsItem::ItemCoordinateCache est activé ; dans tous les autres cas, appeler cette fonction équivaut à appeler update(rect). Si vous savez avec certitude que l'élément est opaque et n'est pas recouvert par d'autres éléments, vous pouvez faire correspondre les coordonnées de rect à celles de la fenêtre et faire défiler la fenêtre.

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 on est vrai, cet élément accepte les événements de glisser-déposer ; sinon, il est transparent pour les événements de glisser-déposer. 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 enabled est vrai, 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élivrés lorsqu'il n'y a pas d'élément d'accroche de la souris en cours. Ils sont envoyés lorsque le curseur de la souris entre dans un élément, lorsqu'il se déplace à l'intérieur de l'élément et lorsque le curseur quitte l'élément. Les événements de survol sont généralement utilisés pour mettre en évidence un élément lorsqu'il est saisi 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 d'entrée au survol avant leurs enfants, et les événements de sortie après leurs enfants. Cependant, le parent ne reçoit pas d'événement de sortie de survol si le curseur entre dans un enfant ; le parent reste "survolé" 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 des enfants, il recevra les événements de déplacement en survol, de déplacement par glissement et de dépôt lorsque le curseur passe par ses enfants, mais il ne recevra pas les événements d'entrée et de sortie en survol, ni les événements d'entrée et de sortie par glissement pour le compte de ses enfants.

Un site QGraphicsWidget avec des décorations de fenêtre acceptera les événements de survol quelle que soit la valeur de acceptHoverEvents().

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

void QGraphicsItem::setAcceptTouchEvents(bool enabled)

Si enabled est vrai, cet élément acceptera touch events; sinon, 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'adresse buttons pour laquelle cet élément accepte les événements de souris.

Par défaut, tous les boutons de la souris sont acceptés. Si un élément accepte un bouton de souris, il devient l'élément de saisie de la souris lorsqu'un événement de pression de la souris est délivré pour ce bouton. Toutefois, si l'élément n'accepte pas le bouton de la souris, QGraphicsScene transmettra les événements de la souris au premier élément inférieur qui les accepte.

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

Voir également acceptedMouseButtons() et mousePressEvent().

void QGraphicsItem::setActive(bool active)

Si active est vrai et que la scène est active, le panneau de cet élément sera activé. Dans le cas contraire, le panneau est désactivé.

Si l'élément ne fait pas partie d'une scène active, active décidera de ce qu'il adviendra du panneau lorsque la scène deviendra active ou que l'élément sera ajouté à la scène. Si la valeur est vraie, le panneau de l'élément sera activé lorsque l'élément sera ajouté à la scène ou lorsque la scène sera activée. Sinon, l'élément restera inactif indépendamment de 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 délimitée à granularity; une valeur comprise entre 0 et 1. La valeur par défaut est 0 (c'est-à-dire la granularité la plus faible, où la région délimitée correspond au rectangle de délimitation de l'élément).

La granularité est utilisée par boundingRegion() pour calculer la finesse de la région délimitée de l'élément. La granularité la plus élevée possible est 1, où boundingRegion() renvoie le contour le plus fin possible pour le périphérique concerné (par exemple, pour une fenêtre de visualisation QGraphicsView, cela donne une région délimitée au pixel près). La plus petite granularité possible est 0. La valeur de granularity décrit le rapport entre la résolution du périphérique et la résolution de la région délimitée (par exemple, une valeur de 0,25 permet d'obtenir une région dans laquelle chaque morceau correspond à 4x4 unités de périphérique / pixels).

Voir également boundingRegionGranularity().

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

Définit le mode de cache de l'élément à 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 est (100, 100), QGraphicsItem adaptera l'élément à 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 de boundingRect(). Pour tous les modes de cache autres que ItemCoordinateCache, logicalCacheSize est ignoré.

La mise en cache peut accélérer le rendu si votre élément passe beaucoup de temps à se redessiner. Dans certains cas, le cache peut également ralentir le rendu, en particulier lorsque l'élément passe moins de temps à se redessiner que QGraphicsItem à se 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 de pixmap hors écran ; pour toute demande de repeint ultérieure, le cadre de la vue graphique redessine à partir du cache. Cette approche fonctionne particulièrement bien avec QGLWidget, qui stocke tout le cache sous forme de textures OpenGL.

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

Vous pouvez en savoir plus sur les différents modes de cache dans la documentation de 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 à cursor. Le curseur de la souris prendra cette forme lorsqu'il sera au-dessus de l'élément. Voir le site list of predefined cursor objects pour une série de formes utiles.

Un élément de l'éditeur peut vouloir utiliser un curseur en forme de poutre en I :

item->setCursor(Qt::IBeamCursor);

Si aucun curseur n'a été défini, le curseur de l'élément situé en dessous 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 à 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 aussi data().

void QGraphicsItem::setEnabled(bool enabled)

Si enabled est vrai, l'élément est activé ; sinon, il est désactivé.

Les éléments désactivés sont visibles, mais ils ne reçoivent aucun événement et ne peuvent pas être sélectionnés. Les événements liés à la 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 liés à la souris (voir acceptedMouseButtons()). Un élément désactivé ne peut pas devenir le capteur de souris et, par conséquent, un élément perd le capteur s'il devient désactivé lorsqu'il saisit la souris, tout comme il perd le focus s'il avait le focus lorsqu'il était désactivé.

Les éléments désactivés sont traditionnellement dessinés avec des couleurs grisées (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, sauf s'ils ont été explicitement désactivés (c'est-à-dire que si vous appelez setEnabled(false) sur un enfant, il 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 vrai, cet élément est configuré pour filtrer tous les événements de tous ses enfants (c'est-à-dire que tous les événements destinés à l'un de ses enfants sont envoyés à cet élément) ; sinon, si enabled est faux, cet élément ne traitera 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 enabled est vrai, l'indicateur d'élément flag est activé ; sinon, il est désactivé.

Voir également flags() et setFlags().

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

Définit les drapeaux de l'élément à flags. Tous les drapeaux figurant dans flags sont activés ; tous les drapeaux ne figurant 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 le 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 drapeau n'est activé. (QGraphicsWidget active l'indicateur ItemSendsGeometryChanges par défaut afin de suivre les changements de position).

Voir également flags() et setFlag().

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

Donne à cet élément le focus sur les entrées clavier. L'argument focusReason sera passé dans tout focus event généré par cette fonction ; il est utilisé pour donner une explication sur la raison pour laquelle l'élément a obtenu le focus.

Seuls les éléments activés qui définissent l'indicateur ItemIsFocusable peuvent accepter le focus 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 d'entrée. Toutefois, il sera enregistré en tant qu'élément de focalisation préféré pour son sous-arbre d'éléments, s'il devient visible par la suite.

À la suite de l'appel de cette fonction, cet élément recevra un message focus in event avec focusReason. Si un autre élément a déjà le focus, cet élément recevra d'abord un message focus out event indiquant qu'il a perdu le focus d'entrée.

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

void QGraphicsItem::setFocusProxy(QGraphicsItem *item)

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

Si un élément a un proxy de focus, le proxy de focus recevra le focus d'entrée lorsque l'élément obtiendra le focus d'entrée. L'élément lui-même aura toujours le focus (c'est-à-dire que hasFocus() renverra true), mais seul le proxy de focus recevra l'entrée clavier.

Un proxy de focus peut lui-même avoir un proxy de focus, et ainsi de suite. Dans ce cas, l'entrée clavier sera gérée 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 l'effet de l'élément. Si un effet est déjà installé sur cet élément, QGraphicsItem supprimera l'effet existant avant d'installer le nouvel effet effect. Vous pouvez supprimer un effet existant en appelant setGraphicsEffect(nullptr).

Si effect est l'effet installé sur un autre élément, setGraphicsEffect() supprimera l'effet de l'élément et l'installera sur cet é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 est nullptr, cet élément est supprimé de tout groupe en cours 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 indices de la méthode d'entrée actuelle de cet élément à hints.

Voir aussi inputMethodHints() et inputMethodQuery().

void QGraphicsItem::setOpacity(qreal opacity)

Définit l'opacité locale de cet élément opacity, entre 0.0 (transparent) et 1.0 (opaque). L'opacité locale de l'élément est combinée avec les opacités des parents et des ancêtres dans la valeur effectiveOpacity().

Par défaut, l'opacité se propage du parent à l'enfant, de sorte que 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 peintre transmis à la fonction paint(). Si l'élément est mis en cache, c'est-à-dire ItemCoordinateCache ou DeviceCoordinateCache, la propriété effective sera appliquée au cache de l'élément lors du rendu.

Il existe deux indicateurs d'élément qui affectent la manière dont l'opacité de l'élément est combinée avec celle du parent : ItemIgnoresParentOpacity et ItemDoesntPropagateOpacityToChildren.

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

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

Définit la modalité de cet élément à 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 à newParent. Si cet élément a déjà un parent, il est d'abord supprimé du parent précédent. Si newParent vaut 0, cet élément devient un élément de premier niveau.

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

Le comportement lors de l'appel de cette fonction sur un élément qui est un ancêtre de newParent n'est pas défini.

Voir également parentItem() et childItems().

void QGraphicsItem::setPos(const QPointF &pos)

Fixe la position de l'élément à pos, qui est en coordonnées parentales. Pour les éléments sans parent, pos correspond aux 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.

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 la rotation dans le sens des aiguilles d'une montre angle, 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 tourné). L'attribution d'une valeur négative entraîne la rotation de l'élément 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 origine de transformation différente en appelant setTransformOriginPoint().

La rotation est combinée avec les fonctions scale(), transform() et transformations() de l'élément pour faire correspondre 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'échelle factor de l'élément. Le facteur d'échelle par défaut est de 1,0 (c'est-à-dire que l'élément n'est pas mis à l'échelle). Un facteur d'échelle de 0,0 réduit l'élément à un seul point. Si vous indiquez un facteur d'échelle négatif, l'élément sera retourné et reflété (c'est-à-dire qu'il subira une rotation 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 origine de transformation différente en appelant setTransformOriginPoint().

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

Voir également scale(), setTransformOriginPoint() et Exemple de transformation.

void QGraphicsItem::setSelected(bool selected)

Si selected est vrai et que cet élément est sélectionnable, il est sélectionné ; sinon, il est désélectionné.

Si l'élément fait partie d'un groupe, l'état de sélection de l'ensemble du groupe est modifié par cette fonction. Si le groupe est sélectionné, tous les éléments du groupe sont également sélectionnés, et 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 ne fait rien.

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 pour des raisons de commodité, car elle permet de basculer individuellement l'état de sélection d'un élément. Cependant, une façon plus courante de sélectionner des éléments est d'appeler QGraphicsScene::setSelectionArea(), qui appellera cette fonction pour tous les éléments visibles, activés et sélectionnables à l'intérieur d'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 à toolTip. Si toolTip est vide, l'info-bulle de l'élément est effacée.

Voir aussi toolTip() et QToolTip.

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

Définit la matrice de transformation actuelle de l'élément à 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 d'effectuer la conversion entre les coordonnées des éléments et celles de la scène. Par exemple, vous pouvez appeler mapToScene() pour convertir les coordonnées d'un élément en coordonnées de la scène, ou mapFromScene() pour convertir les coordonnées de la scène en coordonnées de l'élément.

La matrice de transformation est combinée avec les transformations rotation(), scale() et transformations() de l'élément en une transformation combinée qui fait correspondre le système de coordonnées de l'élément à 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 origin pour la transformation en coordonnées de l'élément.

Voir aussi 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 setTransformOriginPoint(QPointF(x, y)).

Voir aussi setTransformOriginPoint() et Transformations.

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

Définit une liste de graphiques transformations (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 permet d'appliquer et de contrôler une chaîne d'opérations de transformation individuelles sur un élément. C'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 éléments rotation(), scale() et transform() pour faire correspondre le système de coordonnées de l'élément à l'élément parent.

Voir également 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 peints et ne reçoivent aucun événement. En particulier, les événements liés à la souris traversent les éléments invisibles et sont transmis à tout élément situé derrière. Les éléments invisibles ne sont pas non plus sélectionnables, ils ne peuvent pas prendre le focus d'entrée et ne sont pas détectés par les fonctions de localisation d'éléments de QGraphicsScene.

Si un élément devient invisible alors qu'il est saisi par la souris (c'est-à-dire alors qu'il reçoit des événements souris), il perd automatiquement la saisie de la souris, et la saisie n'est pas rétablie en rendant l'élément visible à nouveau ; il doit recevoir une nouvelle pression de la souris pour retrouver la saisie de la souris.

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

Si vous cachez un élément parent, tous ses enfants seront également cachés. Si vous affichez un élément parent, tous ses enfants seront affichés, sauf s'ils ont été explicitement cachés (c'est-à-dire que si vous appelez setVisible(false) sur un enfant, il ne sera pas réaffiché même si son parent est caché, puis réaffiché).

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

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

void QGraphicsItem::setX(qreal x)

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

Voir aussi x() et setPos().

void QGraphicsItem::setY(qreal y)

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

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

void QGraphicsItem::setZValue(qreal z)

Définit la valeur Z de l'élément à z. La valeur Z détermine l'ordre d'empilement des éléments frères et sœurs (voisins). Un élément frère ayant une valeur Z élevée sera toujours dessiné au-dessus d'un autre élément frère ayant une valeur Z plus faible.

Si vous rétablissez la valeur Z, l'ordre d'insertion de l'élément déterminera son ordre d'empilement.

La valeur Z n'affecte en rien 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 forme de QPainterPath en coordonnées locales. La 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 forme rectangulaire simple, mais les sous-classes peuvent réimplémenter cette fonction pour renvoyer une forme plus précise pour les objets non rectangulaires. Par exemple, un objet rond peut choisir de renvoyer une forme elliptique pour une meilleure détection des collisions. Par exemple, une forme elliptique peut être renvoyée pour un objet rond afin de mieux détecter les collisions :

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 de commodité équivaut à appeler setVisible(true).

Voir aussi hide() et setVisible().

void QGraphicsItem::stackBefore(const QGraphicsItem *sibling)

Empile cet élément avant sibling, ce qui signifie que cet élément sera dessiné derrière l'élément frère. En d'autres termes, l'élément frère apparaîtra visuellement au-dessus de 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). Le site sibling doit avoir la même valeur Z que cet élément, sinon l'appel à cette fonction n'aura aucun effet.

Par défaut, tous les éléments frères sont empilés par ordre d'insertion (c'est-à-dire que le premier élément que vous ajoutez est dessiné 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 dessiné au-dessus. Lorsque les valeurs Z sont identiques, l'ordre d'insertion 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 en fait un objet graphique, 0 sinon.

const QGraphicsObject *QGraphicsItem::toGraphicsObject() const

Renvoie l'élément graphique converti en QGraphicsObject, si la classe est en fait un objet graphique, 0 sinon.

QString QGraphicsItem::toolTip() const

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

Voir aussi setToolTip() et QToolTip.

QGraphicsItem *QGraphicsItem::topLevelItem() const

Renvoie l'élément de premier niveau de cet élément. L'élément de premier niveau est l'élément ancêtre le plus élevé 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 premier niveau est son propre élément de premier niveau).

Voir également parentItem().

QGraphicsWidget *QGraphicsItem::topLevelWidget() const

Renvoie un pointeur sur le widget de premier niveau 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 n'a pas de widget de premier niveau. Si l'élément est son propre widget de premier niveau, cette fonction renvoie un pointeur sur 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 transformations de l'élément rotation(), scale() et transformations() en une transformation combinée pour l'élément.

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

Voir aussi setTransform() et sceneTransform().

QPointF QGraphicsItem::transformOriginPoint() const

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

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

Voir aussi setTransformOriginPoint() et Transformations.

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

Renvoie une liste des transformations graphiques qui s'appliquent actuellement à cet élément.

QGraphicsTransform permet d'appliquer et de contrôler une chaîne d'opérations de transformation individuelles sur un élément. C'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 éléments rotation(), scale() et transform() pour faire correspondre le système de coordonnées de l'élément à 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 la forme d'un int. Toutes les classes d'éléments graphiques standard sont associées à une valeur unique ; voir QGraphicsItem::Type. Ces informations sur le type sont utilisées par qgraphicsitem_cast() pour faire la distinction entre les types.

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

Pour permettre l'utilisation de qgraphicsitem_cast() avec un élément personnalisé, réimplémentez cette fonction et déclarez une valeur Type enum é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, les éléments personnalisés doivent renvoyer une valeur supérieure ou égale à (65536) :

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

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

Voir aussi UserType.

void QGraphicsItem::ungrabKeyboard()

Libère l'emprise du clavier.

Voir aussi grabKeyboard() et ungrabMouse().

void QGraphicsItem::ungrabMouse()

Libère la saisie de la souris.

Voir également grabMouse() et ungrabKeyboard().

void QGraphicsItem::unsetCursor()

Efface le curseur de cet élément.

Voir aussi hasCursor() et setCursor().

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

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

Cette fonction ne provoque pas une peinture immédiate ; elle planifie plutôt une demande de peinture qui est traitée par QGraphicsView une fois que le contrôle atteint la boucle d'événements. L'élément ne sera redessiné que s'il est visible dans une vue associée.

Si l'élément est repeint, les autres éléments qui chevauchent la zone rect peuvent également être repeints.

Si l'élément est invisible (c'est-à-dire que 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 la micro-focalisation de l'élément.

Voir aussi QInputMethod.

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

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

Si vous ignorez l'événement (c'est-à-dire en appelant QEvent::ignore()), il se propagera à tout élément situé sous cet élément. Si aucun élément n'accepte l'événement, il 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 l'élément n'a pas de fenêtre. Si l'élément est une fenêtre, il se renvoie lui-même. Sinon, il renvoie l'ancêtre le plus proche qui est une fenêtre.

Voir aussi QGraphicsWidget::isWindow().

qreal QGraphicsItem::x() const

Cette fonction de commodité équivaut à appeler pos().x().

Voir aussi setX() et y().

qreal QGraphicsItem::y() const

Cette fonction de commodité équivaut à appeler pos().y().

Voir aussi setY() et x().

qreal QGraphicsItem::zValue() const

Renvoie la valeur Z de l'élément. La valeur Z affecte l'ordre d'empilement des éléments frères (voisins).

La valeur Z par défaut est 0.

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