QGraphicsItem

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

#include <QGraphicsItem>

Voir la position dans l'arbre des classes.

Héritage

Hérité par QAbstractGraphicsShapeItem, QGraphicsItemGroup, QGraphicsLineItem, QGraphicsObject et QGraphicsPixmapItem.

Cette classe a été introduite dans Qt 4.2.

Description détaillée

La classe QGraphicsItem est la classe de base pour tous les éléments graphiques de QGraphicsScene.

Elle fournit une fondation légère pour la création de vos propres éléments personnalisés. Cela inclut la définition de la géométrie de l'élément, la détection de collision, l'implémentation de son dessin et les interactions à travers ses gestionnaires d'événements. QGraphicsItem fait partie du framework Graphics View.

Par commodité, Qt fournit un jeu d'éléments graphiques standard pour les formes les plus courantes. Ce sont :

• QGraphicsEllipseItem fournit une ellipse ;
• QGraphicsLineItem fournit une ligne ;
• QGraphicsPathItem fournit un chemin arbitraire ;
• QGraphicsPixmapItem fournit un pixmap ;
• QGraphicsPolygonItem fournit un polygone ;
• QGraphicsRectItem fournit un rectangle ;
• QGraphicsSimpleTextItem fournit un texte simple ;
• QGraphicsTextItem fournit un éditeur de texte avancé.

Toute l'information géométrique d'un élément est basée sur son système de coordonnées local. La position de l'élément, pos(), est la seule fonction qui n'opère pas en coordonnées locales, elle renvoie une position en coordonnées parent. Le système de coordonnées de la vue graphique décrit le système de coordonnées en détails.

Vous pouvez définir si un élément doit être visible (c'est-à-dire dessiner et acceptant les événements) en appelant setVisible(). Cacher un élément cache aussi ses enfants. De la même façon, vous pouvez activer ou désactiver un élément en appelant setEnabled(). Si vous désactivez un élément, tous ses enfants seront également désactivés. Par défaut, les éléments sont visibles et actifs. Pour changer l'état de sélection d'un élément, autorisez d'abord la sélection en activant le drapeau ItemIsSelectable et ensuite appelez setSelected(). Normalement, l'état sélectionné est modifié par la scène en réponse aux interactions utilisateurs.

Pour écrire votre propre élément graphique, vous créez d'abord une classe dérivée de QGraphicsItem et ensuite implémentez ses deux fonctions virtuelles pures : boundingRect(), qui renvoie une estimation de la région occupée par le dessin de l'objet et paint(), qui implémente le dessin lui-même. Par exemple :

 class SimpleItem : public QGraphicsItem
 {
 public:
     QRectF boundingRect() const
     {
         qreal penWidth = 1;
         return QRectF(-10 - penWidth / 2, -10 - penWidth / 2,
                       20 + penWidth, 20 + penWidth);
     }
 
     void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
                QWidget *widget)
     {
         painter->drawRoundedRect(-10, -10, 20, 20, 5, 5);
     }
 };

La fonction boundingRect() a de nombreux usages. QGraphicsScene base son index d'éléments sur boundingRect() et QGraphicsView l'utilise à la fois pour éliminer les objets invisibles et pour déterminer la zone qui doit être recomposée lors du dessin d'éléments superposés. De plus, les mécanismes de détection de collision de QGraphicsItem utilisent boundingRect() pour limiter leur portée. L'algorithme de collision fin de collidesWithItem() est basé sur l'appel de shape(), qui renvoie la frontière précise de l'élément sous la forme d'un QPainterPath.

QGraphicsScene s'attend à ce que les boundingRect() et shape() des éléments restent inchangés tant qu'elle ne reçoit pas de notification. Si vous voulez effectuer un changement quelconque de géométrie sur un élément, vous devez d'abord appeler prepareGeometryChange() pour que QGraphicsScene puisse mettre à jour ses informations.

La détection de collision peut se faire de deux façons :

1. Réimplémenter shape() pour renvoyer la forme précise de l'élément et compter sur collidesWithItem() pour calculer l'intersection forme-forme. Ceci peut être coûteux si les formes sont complexes ;
2. Réimplémenter collidesWithItem() pour fournir votre propre algorithme de collision entre élément et forme.

La fonction contains() peut être appelée pour déterminer si un élément contient un point ou non. Cette fonction peut aussi être réimplémentée par l'élément. Le comportement par défaut de contains() est basé sur l'appel de shape().

Les éléments peuvent contenir d'autres éléments et peuvent aussi être contenus par d'autres éléments. Tous les éléments peuvent avoir un parent et une liste d'enfants. La position de l'élément est en coordonnées parent (c'est-à-dire dans les coordonnées locales du parent), sauf s'il n'a pas de parent. Les parent propagent à la fois leur position et leur transformation à leurs enfants.

Transformations

QGraphicsItem permet l'ajout de transformations projectives à sa position, pos(). La transformation d'un élément peut être modifiée de plusieurs façons. Pour les transformations simples, vous pouvez appeler les fonctions setRotation() ou setScale() ou vous pouvez passer une matrice de transformation quelconque à setTransform(). Vous avez également la possibilité de combiner plusieurs transformations, pour un contrôle de transformation avancé, grâce à setTransformations().

Les transformations d'éléments se propagent de parent à enfant, donc si parent et enfant sont tournés chacun à 90 degrés, la rotation totale de l'enfant sera de 90 degrés. De même, si le parent d'un élément est agrandi à deux fois sa taille, l'enfant doublera aussi de taille. La transformation d'un élément n'affecte pas sa géométrie locale ; toutes les fonctions géométriques (comme contains(), update() et toutes les fonctions de conversion de coordonnées) opèrent toujours en coordonnées locales. Pour plus de commodité, QGraphicsItem fournit les fonctions sceneTransform(), qui renvoie la matrice de transformation totale (incluant sa position et toutes les transformations et positions des parents) et scenePos(), qui renvoie la position en coordonnées de scène. Pour réinitialiser la matrice d'un élément, appelez resetTransform().

Certaines transformations produisent des résultats différents suivant l'ordre dans lequel elles sont effectuées. Par exemple, si vous redimensionnez un élément puis appliquez une rotation, vous pouvez obtenir une transformation différente qu'en effectuant la rotation en premier. Cependant, l'ordre dans lequel vous affectez des propriétés de transformation au QGraphicsItem n'influencera pas la transformation résultante ; QGraphicsItem applique toujours les propriétés dans un ordre prédéfini :

• la transformation de base de l'élément est appliquée (transform()) ;
• la liste de transformations de l'élément est appliquée dans l'ordre (transformations()) ;
• la rotation est effectuée sur l'axe d'origine de la transformation (rotation(), transformOriginPoint()) ;
• l'élément est redimensionné à partir du point d'origine de la transformation (scale(), transformOriginPoint()).

Dessin

La fonction paint() est appelée par QGraphicsView pour dessiner le contenu d'un élément. L'élément ne possède pas de fond ou de remplissage par défaut ; tout ce qui se trouve sous l'élément apparaîtra en transparence dans toutes les zones qui ne seront pas remplies par cette fonction. Vous pouvez appeler update() pour demander une mise à jour de la zone de dessin, en passant éventuellement le rectangle à redessiner. S'il est affiché dans une vue, l'élément sera redessiné, sinon il ne le sera pas ; il n'existe pas d'équivalent à QWidget::repaint() dans QGraphicsItem.

Les éléments sont dessinés par la vue, des parents aux enfants, et en ordre d'empilement ascendant. Vous pouvez définir le niveau d'empilement d'un élément en appelant setZValue() et le tester en appelant zValue(), où les éléments de valeur Z inférieure sont dessinés avant les éléments de valeur Z supérieure. Le niveau d'empilement s'applique aux éléments ayant le même parent ; les parents sont toujours dessinés avant leurs enfants.

Tri

Tous les éléments sont dessinés dans un ordre stable et défini et ce même ordre est utilisé pour déterminer quel élément reçoit les événements de clic de souris en premier. Normalement vous n'avez pas à vous préoccuper du tri, qui suit un ordre « naturel » respectant la structure logique de la scène.

Les éléments enfants sont empilés sur les parents et les éléments de même niveau sont empilés par ordre d'insertion (c'est-à-dire dans l'ordre d'ajout dans la scène ou d'ajout au même parent). Si vous ajoutez l'élément A puis le B, B sera au-dessus de A. Si vous ajoutez ensuite C, l'ordre d'empilement sera A, B, C.

Cet exemple montre l'ordre d'empilement de tous les membres du robot de l'exemple Drag and Drop Robot. Le torse est l'élément racine (tous les autres éléments sont des descendants du torse), donc il est dessiné en premier. La tête est dessinée ensuite, car elle est le premier élément dans la liste des enfants du torse. Le haut du bras gauche est dessiné ensuite. Comme l'avant-bras est l'enfant du haut du bras, l'avant-bras est dessiné, suivi de l'enfant suivant du torse, qui est le haut du bras droit, et ainsi de suite.

Pour les utilisateurs avancés, il existe deux méthodes pour modifier l'ordre de tri des éléments :

• vous pouvez appeler setZValeur() sur un élément pour le placer explicitement au dessus ou au dessous d'autres éléments de même niveau. La valeur Z d'un élément est par défaut 0. Les éléments avec la même valeur Z sont empilés dans l'ordre d'insertion ;
• vous pouvez appeler stackBefore() pour réordonner les enfants. Cela modifiera directement l'ordre d'insertion ;
• vous pouvez activer le drapeau ItemStacksBehindParent pour placer un élément enfant sous son parent.

L'ordre d'empilement relatif de deux éléments de même niveau s'étend aussi à leurs descendants : si un élément est au-dessus d'un autre, tous ses descendants seront également au-dessus des descendants de l'autre.

Événements

QGraphicsItem reçoit les événements de QGraphicsScene à travers la fonction virtuelle sceneEvent(). Pour faciliter leur gestion, cette fonction distribue les événements les plus courants à un ensemble de méthodes :

• contextMenuEvent() traite les événements de menus contextuels ;
• focusInEvent() et focusOutEvent() traitent les événements de prise et de perte de focus ;
• hoverEnterEvent(), hoverMoveEvent() et hoverLeaveEvent() traitent les événements de survol (entrée, déplacement, sortie) ;
• inputMethodEvent() traite les événements de saisie, pour la gestion de l'accessibilité ;
• keyPressEvent() et keyReleaseEvent() traitent les événements clavier (touches appuyées et relâchées) ;
• mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent() et mouseDoubleClickEvent() traitent les événements souris (boutons appuyés et relâchés, déplacements, clic et double-clic).

Vous pouvez filtrer les événements destinés à un autre élément en installant un filtre d'événements. Cette fonctionnalité est différente des filtres d'événements standard de Qt (voir QObject::installEventFilter()), qui ne sont compatibles qu'avec des classes dérivées de QObject. Après avoir installé votre élément comme filtre d'événements pour un autre élément en appelant installSceneEventFilter(), vous recevrez les événements filtrés dans la fonction virtuelle sceneEventFilter(). Vous pouvez supprimer un filtre d'événements d'éléments en appelant removeSceneEventFilter().

Données personnalisées

Il est parfois utile d'enregistrer des données personnalisées dans un élément, qu'il s'agisse d'un élément standard ou personnalisé. Vous pouvez appeler setData() sur tout élément pour enregistrer des données sous la forme d'une paire clé-valeur (la clé étant un entier et la valeur un QVariant). Pour lire les données d'un élément, appelez data(). Cette fonctionnalité n'a pas d'utilité pour Qt lui-même ; elle est fournie uniquement pour le confort de l'utilisateur.

Voir aussi QGraphicsScene, QGraphicsView et Graphics View Framework.

Types membres

enum QGraphicsItem::CacheMode

Cette énumération décrit les modes de cache de QGraphicsItem. Le cache est utilisé pour accélérer le rendu en allouant un tampon de pixels hors écran et en l'utilisant pour le rendu. Ce rendu peut être ensuite réutilisé quand l'élément doit être redessiné. Pour certains types de QPaintDevice, le cache est stocké directement dans la mémoire vidéo, ce qui permet un rendu très rapide.

Cette énumération a été introduite ou modifiée dans Qt 4.4.

Voir aussi QGraphicsItem::setCacheMode().

enum QGraphicsItem::GraphicsItemChange

Cette énumération décrit les changements d'état dont la notification est envoyée par QGraphicsItem::itemChange(). Les notifications sont envoyées au moment du changement d'état et dans certains cas, des ajustements peuvent être faits (pour les détails, voir la documentation de chaque changement).

Note : attention en cas d'appels de fonctions du QGraphicsItem lui-même à l'intérieur de itemChange(), car certains appels peuvent déclencher une récursion indésirable. Par exemple, vous ne pouvez pas appeler setPos() dans itemChange() sur une notification ItemPositionChange, car la fonction setPos() va rappeler itemChange(ItemPositionChange). À la place, vous pouvez demander à itemChange() de renvoyer la position ajustée.

enum QGraphicsItem::GraphicsItemFlag

flags QGraphicsItem::GraphicsItemFlags

Cette énumération décrit les différents drapeaux que vous pouvez activer sur l'élément pour modifier son comportement.

Tous les drapeaux sont désactivés par défaut.

Le type GraphicsItemFlags est un typedef pour QFlags<GraphicsItemFlag>. Il contient une combinaison OU de valeurs GraphicsItemFlag.

enum QGraphicsItem::PanelModality

Cette énumération spécifie le comportement d'un panneau modal. Un panneau modal est un élément bloquant l'accès aux autres panneaux. Notez que les éléments enfants d'un panneau modal ne sont pas bloqués.

Le valeurs sont :

Cette énumération a été introduite ou modifiée dans Qt 4.6.

Voir aussi QGraphicsItem::setPanelModality(), QGraphicsItem::panelModality() et QGraphicsItem::ItemIsPanel.

Fonctions membres

QGraphicsItem::QGraphicsItem ( QGraphicsItem * parent = 0 )

Construit un QGraphicsItem avec l'élément parent donné. L'objet parent renvoyé par QObject::parent() n'est pas modifié.

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

Voir aussi QGraphicsScene::addItem() et setParentItem().

QGraphicsItem::~QGraphicsItem () [virtual]

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

Note : il est plus efficace de retirer l'élément de la QGraphicsScene avant de le détruire.

bool QGraphicsItem::acceptDrops () const

Renvoie vrai si cet élément accepte les événements de glisser-déposer; sinon, renvoie faux. Par défaut, les éléments n'acceptent pas les événements de glisser-déposer ; les éléments sont transparents pour le glisser-déposer.

Voir aussi setAcceptDrops().

bool QGraphicsItem::acceptHoverEvents () const

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

Cette fonction a été introduite dans Qt 4.4.

Voir aussi setAcceptHoverEvents() et setAcceptedMouseButtons().

bool QGraphicsItem::acceptTouchEvents () const

Renvoie vrai si un élément accepte les événements de touché; sinon, renvoie faux. Par défaut, les éléments n'acceptent pas les événements de touché.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setAcceptTouchEvents().

Qt::MouseButtons QGraphicsItem::acceptedMouseButtons () const

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

Si un élément accepte un bouton, il deviendra destinataire de tous les événements souris lorsqu'un événement de clic sera envoyé pour ce bouton. Si l'élément n'accepte pas un bouton, QGraphicsScene transférera les événements souris au premier élément sous lui qui l'accepte.

Voir aussi setAcceptedMouseButtons() et mousePressEvent().

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

Cette fonction virtuelle est appelée deux fois pour chaque élément par le slot QGraphicsScene::advance(). Dans la première phase, tous les éléments sont appelés avec phase == 0, pour indiquer que tous les éléments de la scène sont sur le point d'avancer, puis tous les éléments sont appelés avec phase == 1. Reimplémentez cette fonction pour mettre à jour vos éléments si vous avez besoin d'une animation simple contrôlée par la scène.

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

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

Cette fonction virtuelle pure définit les frontières de l'élément sous forme d'un rectangle ; tous les dessins de l'élément doivent se faire à l'intérieur de ce rectangle. QGraphicsView l'utilise pour déterminer si l'élément doit être redessiné.

Bien que la forme de l'élément soit arbitraire, boundingRect() est toujours un rectangle et n'est pas affecté par les transformations de l'élément.

Si vous voulez changer le rectangle frontière de l'élément, vous devez d'abord appeler prepareGeometryChange(). Cet appel prévient la scène du changement imminent, afin qu'elle puisse changer son index de géométrie ; sinon, la scène ignorera la nouvelle géométrie de l'élément et le résultat sera indéfini (typiquement, des artefacts de rendu subsisteront dans la vue).

Réimplémentez cette fonction afin que QGraphicsView détermine quelles portions de l'élément doivent être éventuellement redessinées.

Note : pour les éléments dessinés avec une brosse ou une bordure large, il faut inclure la moitié de la brosse dans le rectangle frontière. Par contre, il n'est pas nécessaire d'inclure une compensation pour l'antialiasing.

Exemple :

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

Voir aussi boundingRegion(), shape(), contains(), The Graphics View Coordinate System et prepareGeometryChange().

Pour l'animation d'éléments individuels, une alternative à cette fonction est d'utiliser QGraphicsItemAnimation ou un héritage multiple de QObject et QGraphicsItem, et d'animer votre élément en utilisant QObject::startTimer() et QObject::timerEvent().

Voir aussi QGraphicsItemAnimation et QTimeLine.

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

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

La région frontière décrit un contour approximatif du contenu visuel de l'élément. Bien qu'elle soit coûteuse à calculer, elle est plus précise que le rectangle frontière et elle peut aider à éviter de redessiner inutilement un élément lors d'une mise à jour. Ceci est particulièrement efficace pour les élément minces (lignes ou polygones simples par exemple). Vous pouvez ajuster la granularité de la région frontière par setBoundingRegionGranularity(). La granularité par défaut est 0 ; dans ce cas la région frontière est identique au rectangle frontière.

itemToDeviceTransform est la transformation depuis les coordonnées de l'élément vers les coordonnées du dispositif de rendu. Si vous voulez que cette fonction renvoie une QRegion en coordonnées de scène, vous pouvez passer sceneTransform() comme argument.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi boundingRegionGranularity().

qreal QGraphicsItem::boundingRegionGranularity () const

Renvoie la granularité de la région frontière, une valeur dans l'intervalle 0 à 1 (bornes comprises). La valeur par défaut est 0 (c'est-à-dire la granularité minimale où la région frontière est égale au rectangle frontière).

Cette fonction a été introduite dans Qt 4.4.

Voir aussi setBoundingRegionGranularity().

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 le rendu immédiat).

Cette fonction a été introduite dans Qt 4.4.

Voir aussi setCacheMode().

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

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

Les éléments sont triés par ordre d'empilement, qui prend en compte à la fois l'ordre d'insertion et les valeurs-z des éléments.

Cette fonction a été introduite dans Qt 4.4.

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

QRectF QGraphicsItem::childrenBoundingRect () const

Renvoie le rectangle frontière des descendants de l'élément (c'est-à-dire ses enfants, leurs propres enfants, etc.) en coordonnées locales. Le rectangle contiendra tous les descendants. Si l'élément n'a pas d'enfant, la fonction renvoie un QRectF vide.

Le résultat n'inclut pas le rectangle frontière de l'élément lui-même ; il représente seulement l'accumulation des rectangles des descendants. Si vous devez inclure le rectangle frontière de l'élément, ajoutez boundingRect() à childrenBoundingRect() en utilisant QRectF::operator|().

Cette fonction a une complexité linéaire ; elle détermine la taille du résultat en itérant sur tous les descendants.

Voir aussi boundingRect() and sceneBoundingRect().

void QGraphicsItem::clearFocus ()

Retire le focus des entrées clavier à l'élément.

S'il a le focus, un événement de perte de focus est envoyé à l'élément pour le prévenir. Seuls les éléments activant le drapeau ItemIsFocusable ou définissant une autorisation appropriée peuvent accepter le focus clavier.

Voir aussi setFocus(), hasFocus() et QGraphicsWidget::focusPolicy.

QPainterPath QGraphicsItem::clipPath () const

Renvoie le chemin de détourage (clipping) ou un QPainterPath vide si cet élément n'est pas détouré. Le chemin de détourage limite l'apparence et les interactions de l'élément (c'est-à-dire restreint la zone de dessin et la zone pour laquelle l'élément peut recevoir des événements).

Vous pouvez activer le détourage en utilisant les drapeaux ItemClipsToShape ou ItemClipsChildrenToShape. Le chemin de détourage résulte de l'intersection de toutes les formes de détourage des ancêtres de l'élément. Si l'élément active ItemClipsToShape, le détourage final est obtenu par l'intersection avec la forme de l'élément lui-même.

Note : le détourage pénalise les performances de tous les éléments impliqués ; vous devez en règle générale l'éviter autant que possible (par exemple, si vos éléments sont dessinés à l'intérieur des boundingRect() ou shape(), le détourage n'est pas nécessaire).

Cette fonction a été introduite dans Qt 4.5.

Voir aussi isClipped(), shape() et setFlags().

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

Renvoie vrai si cet élément entre en collision avec other ; sinon renvoie faux.

Le mode est appliqué à other et la forme ou le rectangle frontière résultant est comparé à la forme de l'élément. La valeur par défaut de mode est Qt::IntersectsItemShape ; other entre en collision avec cet élément s'il a une intersection, contient ou est contenu par la forme de cet élément (voir Qt::ItemSelectionMode pour les détails).

L'implémentation par défaut est basée sur l'intersection de formes et utilise shape() sur les deux éléments. Étant donné que la complexité des interactions entre formes augmente d'un ordre de grandeur lorsque les formes sont complexes, cette opération peut consommer un temps non négligeable. Vous avez la possibilité de réimplémenter cette fonction dans une classe dérivée de QGraphicsItem pour fournir votre propre algorithme. Ceci vous permet de tirer parti des contraintes naturelles des formers de vos éléments, dans le but d'améliorer les performances de la détection de collision. Par exemple, la collision de deux éléments parfaitement circulaires et non transformés peut être testée très efficacement en comparant leur position et leur rayon.

Notez bien qu'en cas de réimplémentation de cette fonction et d'appel à shape() ou boundingRect() sur other, les coordonnées reçues doivent être converties dans le système de coordonnées de l'élément avant de faire des tests d'intersection.

Voir aussi contains() and shape().

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

Renvoie vrai 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 a une intersection, contient ou est contenu par la forme de cet élément.

Notez que cette fonction vérifie si la forme de l'élément ou son rectangle frontière (suivant mode) est contenu dans path et non si path est contenu dans la forme de l'élément ou son rectangle frontière.

Voir aussi collidesWithItem(), contains() et shape().

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

Renvoie une liste d'éléments entrant 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 leur forme ou leur rectangle frontière est comparée avec la forme de l'élément. La valeur par défaut de mode est Qt::IntersectsItemShape.

Voir aussi collidesWithItem().

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

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

Cette fonction a été introduite dans Qt 4.4.

Voir aussi isAncestorOf().

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

Renvoie vrai si cet élément contient point, qui est en coordonnées locales ; sinon, renvoie faux. Elle est le plus souvent appelée depuis QGraphicsView pour déterminer quel élément est sous le pointeur et pour quelle raison, et 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 classe dérivée pour fournir une autre implémentation, éventuellement plus efficace.

Voir aussi shape(), boundingRect() et collidesWithPath().

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

Ce gestionnaire d'événements peut être réimplémenté dans une classe dérivée pour traiter les événements de menus contextuels. Le paramètre event contient des détails sur l'événement à traiter.

Si vous ignorez l'événement (en appelant QEvent::ignore()), event se propagera aux éléments du dessous. Si aucun élément n'accepte l'événement, il sera ignoré par la scène et se propagera à la vue.

La réponse la plus courante à cet événement est d'ouvrir un QMenu. 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 pointeur de souris pour cet élément. Le pointeur aura cette forme quand il sera sur l'élément. Vous pouvez trouver un ensemble de formes utiles dans la liste de pointeurs prédéfinis.

Un élément éditeur peut utiliser un pointeur en forme de barre :

 item->setCursor(Qt::IBeamCursor);

Si aucun pointeur n'a été défini, le pointeur du parent est utilisé.

Voir aussi setCursor(), hasCursor(), unsetCursor(), QWidget::cursor et QApplication::overrideCursor().

QVariant QGraphicsItem::data ( int key ) const

Renvoie les données personnalisées pour la clé key sous forme de QVariant.

Les données personnalisées sont utiles pour le stockage de propriétés arbitraires dans les éléments. 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 fonction pour stocker des données ; elle est fournie uniquement pour les besoins de l'utilisateur.

Voir aussi setData().

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

Renvoie la matrice de transformation physique de l'élément, en utilisant viewportTransform pour la conversion entre coordonnées de scène et coordonnées physiques. Cette matrice peut être utilisée pour convertir des coordonnées et des formes géométriques depuis le système de coordonnées de l'élément vers le système de coordonnées de la zone d'affichage (ou de n'importe quel autre périphérique). Pour convertir des coordonnées vers l'affichage, vous devrez 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 est identique à la combinaison de la transformation de scène et de la transformation de vue de l'élément, mais elle reconnaît aussi le drapeau ItemIgnoresTransformations. La transformation physique peut être utilisée pour effectuer des conversions de coordonnées précises (et de la détection de collision) pour les éléments non transformables.

Cette fonction a été introduite dans Qt 4.3.

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

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté pour recevoir les événements de début de glisser-déposer pour cet élément. Les événements de début de glisser-déposer sont générés lorsque le pointeur entre dans le périmètre 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épose, en plus de recevoir les événement de glissement et de fin de glissement. Sinon, l'événement sera ignoré et propagé à l'élément du dessous. Si l'événement est accepté, l'élément recevra un événement de glissement avant que le contrôle ne revienne à la boucle d'événements.

L'implémentation la plus courante de dragEnterEvent accepte ou ignore event en fonction des données MIME d?event. Exemple :

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

Les éléments ne reçoivent pas les événements de glisser-déposer par défaut ; pour activer cette fonction, appelezsetAcceptDrops(true).

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

Voir aussi dropEvent(), dragMoveEvent() et dragLeaveEvent().

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté pour recevoir les événements de fin de glissement pour cet élément. Les événements de fin de glissement sont générés lorsque le pointeur sort du périmètre de l'élément. La plupart du temps 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 surbrillance).

Appeler QEvent::ignore() ou QEvent::accept() sur event n'a pas d'effet.

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

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

Voir aussi dragEnterEvent(), dropEvent() et dragMoveEvent().

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté pour recevoir les événements de glissement pour cet élément. Les événements de glissement sont générés lorsque le curseur se déplace dans le périmètre de l'élément. La plupart du temps vous n'aurez pas besoin de réimplémenter cette fonction ; elle est utilisée pour indiquer que seule une partie de l'élément accepte les déposes.

Appeler QEvent::ignore() ou QEvent::accept() sur event détermine si l'élément accepte ou pas les déposes à la position de l'événement. Par défaut, event est accepté, indiquant que l'élément accepte les déposes à cette position.

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

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

Voir aussi dropEvent(), dragEnterEvent() et dragLeaveEvent().

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté pour recevoir les événements de dépose pour cet élément. Les éléments ne peuvent recevoir des événements de dépose que si le dernier événement de glissement a été accepté.

Appeler QEvent::ignore() ou QEvent::accept() sur event n'a pas d'effet.

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

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

Voir aussi dragEnterEvent(), dragMoveEvent() et dragLeaveEvent().

qreal QGraphicsItem::effectiveOpacity () const

Renvoie l'opacité effective de l'élément, dont la valeur varie entre 0.0 (transparent) et 1.0 (opaque). Cette valeur est la combinaison de l'opacité locale de cet élément, de celle de son parent et de ses ancêtres. L'opacité effective détermine le rendu de l'élément. Cette fonction a été introduite dans Qt 4.5.

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 affichée par QGraphicsView, cette fonction tentera de faire défiler la vue pour garder rect visible dans la vue affichée. Si rect est un rectangle null (la valeur par défaut), QGraphicsItem prendra par défaut le rectangle frontière de l'élément. xmargin et ymargin sont le nombre de pixels que QGraphicsView prendra comme marge.

Si le rectangle spécifié ne peut être atteint, le défilement du contenu se fera jusqu'à la plus proche position valide.

Si cet élément n'est pas affiché par une QGraphicsView, cette fonction ne fait rien.

Voir aussi QGraphicsView::ensureVisible().

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

Cette fonction est équivalente à l'appel de ensureVisible(QRectF(x, y, w, h), xmargin, ymargin):

bool QGraphicsItem::filtersChildEvents () const

Renvoie vrai si cet élément filtre les événements de ses enfants (c'est-à-dire que tous les événements destinés à ses enfants lui sont envoyés au lieu d'être envoyés aux enfants) ; sinon, renvoie faux.

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

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setFiltersChildEvents().

GraphicsItemFlags QGraphicsItem::flags () const

Renvoie les drapeaux de l'élément. Les drapeaux décrivent quelles options configurables de l'élément sont actives. Par exemple, si les drapeaux incluent ItemIsFocusable, l'élément accepte le focus pour la saisie.

Par défaut, aucun drapeau n'est actif.

Voir aussi setFlags() et setFlag().

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté pour recevoir les événements de prise de focus 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, ou un de ses enfants ou descendants possède actuellement le focus, la fonction renvoie un pointeur sur cet élément. Si aucun descendant n'a le focus, elle renvoie 0.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi hasFocus(), setFocus() et QWidget::focusWidget().

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté pour recevoir les événements de perte de focus 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 0 s'il n'a pas de proxy de focus.

Cette fonction a été introduite dans Qt 4.6.

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

void QGraphicsItem::grabKeyboard ()

L'élément devient destinataire des entrées clavier.

L'élément recevra toutes les entrées clavier de la scène jusqu'à ce qu'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() ; les entrées clavier reviendront à l'élément quand l'autre élément appellera ungrabKeyboard().

Quand un élément prend les entrées clavier, il reçoit un événement QEvent::GrabKeyboard. Quand il les perd, il reçoit un événement QEvent::UngrabKeyboard. Ces événements peuvent être utilisés pour déterminer si l'élément devient destinataire des entrées clavier par d'autres moyens que par la prise du focus de saisie.

Il n'est quasiment jamais nécessaire de prendre explicitement les entrées clavier avec Qt, car Qt le fait naturellement de façon logique. En particulier, Qt prend le clavier quand l'élément reçoit le focus de saisie et le relâche quand le focus est perdu ou que l'élément est caché.

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

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

Cette fonction a été introduite dans Qt 4.4.

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

void QGraphicsItem::grabMouse ()

L'élément devient destinataire des entrées souris.

L'élément recevra toutes les entrées souris de la scène jusqu'à ce qu'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() ; les entrées souris reviendront à l'élément quand l'autre élément appellera ungrabMouse().

Quand un élément prend les entrées souris, il reçoit un événement QEvent::GrabMouse event. Quand il les perd, il reçoit un événement QEvent::UngrabMouse. Ces événements peuvent être utilisés pour déterminer si l'élément devient destinataire des entrées souris par d'autres moyens que la réception d'événements de boutons de souris.

Il n'est quasiment jamais nécessaire de prendre explicitement les entrées souris avec Qt, car Qt le fait naturellement de façon logique. En particulier, Qt prend les entrées souris quand un bouton est enfoncé et les garde jusqu'à ce que tous les boutons soient relâchés. De même, les widgets Qt::Popup appellent grabMouse() implicitement quand on les affiche et ungrabMouse() quand on les cache.

Notez que seuls les éléments visibles peuvent prendre les entrées souris. Appeler grabMouse() sur un élément invisible n'a pas d'effet.

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

Cette fonction a été introduite dans Qt 4.4.

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 0.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setGraphicsEffect().

QGraphicsItemGroup * QGraphicsItem::group () const

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

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

bool QGraphicsItem::hasCursor () const

Renvoie vrai si un pointeur de souris a été défini pour cet élément ; sinon, renvoie faux.

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

Voir aussi unsetCursor().

bool QGraphicsItem::hasFocus () const

Renvoie vrai si cet élément est actif et si lui-même ou son focus proxy possède le focus pour les entrées clavier ; sinon, renvoie faux.

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 est équivalente à l'appel de setVisible(false).

Voir aussi show() et setVisible().

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

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

Appeler QEvent::ignore() ou QEvent::accept() sur event n'a pas d'effet.

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

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

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

Appeler QEvent::ignore() ou QEvent::accept() sur event n'a pas d'effet.

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

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

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

Appeler QEvent::ignore() ou QEvent::accept() sur event n'a pas d'effet.

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

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

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

Voir aussi inputMethodQuery() et sceneEvent().

Qt::InputMethodHints QGraphicsItem::inputMethodHints () const

Renvoie les indicateurs de méthodes de saisie de cet élément.

Les indicateurs de méthodes de saisie sont pertinents seulement pour les éléments de saisie. Les indicateurs sont utilisés par les méthodes de saisie pour donner des informations sur l'opération. Par exemple, si le drapeau Qt::ImhNumbersOnly est activé, la méthode de saisie peut changer ses composants visuels pour refléter le fait que seuls des nombres sont acceptés.

L'effet peut varier suivant l'implémentation des méthodes de saisie.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setInputMethodHints(), inputMethodQuery() et QInputContext.

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

Cette méthode est pertinente seulement pour les éléments de saisie. Elle est utilisée par les méthodes de saisie pour demander des valeurs de propriétés afin de pouvoir gérer les opérations de saisie complexes, comme la gestion du texte entourant l'élément et les reconversions. query spécifie quelle propriété est demandée.

Voir aussi inputMethodEvent(), QInputMethodEvent et QInputContext.

void QGraphicsItem::installSceneEventFilter ( QGraphicsItem * filterItem )

Installe un filtre d'événements pour cet élément par filterItem, ce qui fera que tous les événements destinés à cet élément passeront 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énements pour cet autre élément. Exemple :

 QGraphicsScene scene;
 QGraphicsEllipseItem *ellipse = scene.addEllipse(QRectF(-10, -10, 20, 20));
 QGraphicsLineItem *line = scene.addLine(QLineF(-10, -10, 20, 20));
 
 line->installSceneEventFilter(ellipse);
 // line's events are filtered by ellipse's sceneEventFilter() function.
 
 ellipse->installSceneEventFilter(line);
 // ellipse's events are filtered by line's sceneEventFilter() function.

Un élément peut seulement filtrer les événements d'éléments de sa scène. Un élément ne peut pas non plus filtrer ses propres événements ; pour ce faire, réimplémentez directement sceneEvent().

Les éléments doivent appartenir à une scène pour définir et utiliser des filtres d'événements de scène.

Voir aussi removeSceneEventFilter(), sceneEventFilter() et sceneEvent().

bool QGraphicsItem::isActive () const

Renvoie vrai si cet élément est actif; sinon renvoie faux.

Un élément peut être actif seulement si sa scène est active. Un élément est actif s'il est le descendant d'un panneau actif ou est lui-même un panneau actif. Les éléments de panneaux inactifs sont inactifs.

Les éléments ne faisant pas partie d'un panneau suivent l'activation de la scène lorsque la scène n'a pas de panneau actif.

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

Cette fonction a été introduite dans Qt 4.6.

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

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

Renvoie vrai si cet élément est un ancêtre de child (c'est-à-dire si cet élément est le parent de child ou un ancêtre de son parent).

Voir aussi parentItem().

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

Renvoie vrai si cet élément est bloqué par un panneau modal, faux sinon. Si blockingPanel est différent de zéro, blockingPanel recevra comme affectation le panneau bloquant cet élément. Si cet élément n'est pas bloqué, blockingPanel ne sera pas modifié par cette fonction.

Cette fonction retourne toujours vrai pour les objets ne faisant pas partie d'une scène.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi panelModality(), setPanelModality() et PanelModality.

bool QGraphicsItem::isClipped () const

Renvoie vrai si cet élément est détouré. Un élément est détouré s'il a activé le drapeau ItemClipsToShape ou si un des ses ancêtres ou lui-même a activé le drapeau ItemClipsChildrenToShape.

Le détourage affecte l'apparence de l'élément (c'est-à-dire son dessin), mais également la réception des événements souris et survol.

Voir aussi clipPath(), shape() et setFlags().

bool QGraphicsItem::isEnabled () const

Renvoie vrai si l'élément est actif; sinon, renvoie faux.

Voir aussi setEnabled().

bool QGraphicsItem::isObscured () const

Renvoie vrai si le rectangle frontière de cet élément est complètement recouvert par la forme opaque d'un élément au dessus de lui (c'est-à-dire avec une valeur Z supérieure à celle de cet élément).

Son implémentation est basée sur l'appel de isObscuredBy(), que vous pouvez réimplémenter pour fournir un algorithme de test de recouvrement personnalisé.

Voir aussi opaqueArea().

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

Cette fonction est équivalente à l'appel de isObscured(QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.3.

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

Il s'agit d'une fonction surchargée.

Renvoie vrai si rect est complètement recouvert par la forme opaque d'un élément au-dessus de lui (c'est-à-dire avec une valeur Z supérieure à celle de cet élément).

Contrairement à la fonction isObscured() par défaut, cette fonction n'appelle pas isObscuredBy().

Cette fonction a été introduite dans Qt 4.3.

Voir aussi opaqueArea().

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

Renvoie vrai si le rectangle frontière de cet élément est complètement recouvert par la forme opaque de item.

L'implémentation de base fait correspondre opaqueArea() de l'élément item dans le système de coordonnées de cet élément et ensuite vérifie si boundingRect() de cet élément est entiérement contenu dans cette forme.

Vous pouvez réimplémenter cette fonction pour fournir un algorithme de test personnalisé pour le recouvrement de cet élément par item .

Voir aussi opaqueArea() et isObscured().

bool QGraphicsItem::isPanel () const

Renvoie vrai si l'élément est un panneau ; sinon renvoie faux.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi QGraphicsItem::panel() et ItemIsPanel.

bool QGraphicsItem::isSelected () const

Renvoie vrai si cet élément est sélectionné ; sinon, renvoie faux.

Les éléments d'un groupe héritent de l'état de sélection du groupe.

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

Voir aussi setSelected() et QGraphicsScene::setSelectionArea().

bool QGraphicsItem::isUnderMouse () const

Renvoie vrai si cet élément est actuellement sous le pointeur de la souris dans une des vues ; sinon, renvoie faux.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi QGraphicsScene::views() et QCursor::pos().

bool QGraphicsItem::isVisible () const

Renvoie vrai si l'élément est visible ; sinon, renvoie faux.

Notez que la visibilité générale de l'élément n'est pas liée au fait qu'il soit réellement affiché dans une QGraphicsView.

Voir aussi setVisible().

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

Renvoie vrai si l'élément est visible pour parent ; sinon, renvoie faux. parent peut être 0, auquel cas cette fonction renvoie le fait que l'élément est visible ou pas pour la scène.

Un élément peut être invisible pours ses ancêtres même si isVisible() est vrai. Si un des ancêtres est caché, l'élément lui-même sera implicitement caché, auquel cas cette fonction renverra faux.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi isVisible() et setVisible().

bool QGraphicsItem::isWidget () const

Renvoie vrai si cet élément est un widget (c'est-à-dire un QGraphicsWidget) ; sinon, renvoie faux.

Cette fonction a été introduite dans Qt 4.4.

bool QGraphicsItem::isWindow () const

Renvoie vrai si cet élément est un QGraphicsWidget fenêtre, sinon renvoie faux.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi QGraphicsWidget::windowFlags().

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

Cette fonction virtuelle est appelée par QGraphicsItem pour notifier les QGraphicsItem personnalisés qu'un paramètre de l'élément change. En réimplémentant cette fonction, vous pouvez réagir au changement et dans certains cas (en fonction de change), des adjustements peuvent être faits.

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.

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

Voir aussi GraphicsItemChange.

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

Renvoie une QTransform qui convertit les coordonnées de cet élément vers other. Si ok n'est pas null et qu'une telle transformation n'existe pas, le booléen pointé par ok sera mis à faux ; sinon il sera mis à vrai.

Cette transformation fournit une alternative aux fonctions mapToItem() ou mapFromItem(), en renvoyant la transformation appropriée afin que vous puissiez convertir les formes et les coordonnées vous-même. Elle permet aussi d'écrire un code plus efficace lors de conversions répétées entre les deux mêmes éléments.

Note : dans de rares circonstances, aucune transformation n'existe pour convertir les coordonnées entre deux objets.

Cette fonction a été introduite dans Qt 4.5.

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

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté pour recevoir les événements de touche enfoncée 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 de touche sont reçus seulement pour les éléments ayant activé le drapeau ItemIsFocusable et qui possèdent le focus pour les entrées clavier.

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

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté pour recevoir les événements de touche relâchée 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 de touche sont reçus seulement pour les éléments ayant activé le drapeau ItemIsFocusable et qui possèdent le focus pour les entrées clavier.

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

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

Convertit le point point, qui est dans le système de coordonnées de item, dans le système de coordonnées de l'élément et renvoie les coordonnées converties.

Si item vaut 0, cette fonction renvoie le même résultat que mapFromScene().

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

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

Convertit le rectangle rect, qui est dans le système de coordonnées de item, dans le système de coordonnées de l'élément et renvoie le rectangle converti sous la forme d'un polygone.

Si item vaut 0, cette fonction renvoie le même résultat que mapFromScene()

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

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

Convertit le polygon polygon, qui est dans le système de coordonnées de item, dans le système de coordonnées de l'élément et renvoie le polygone converti.

Si item vaut 0, cette fonction renvoie le même résultat que mapFromScene().

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

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

Convertit le path path, qui est dans le système de coordonnées de item, dans le système de coordonnées de l'élément et renvoie le chemin converti.

Si item vaut 0, cette fonction renvoie le même résultat que mapFromScene().

Voir aussi itemTransform(), mapFromParent(), mapFromScene(), mapToItem() 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 est équivalente à l'appel de mapFromItem(item, QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.3.

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

Il s'agit d'une fonction surchargée.

Cette fonction est équivalente à l'appel de mapFromItem(item, QPointF(x, y)).

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

Convertit le point point, qui est dans le système de coordonnées du parent de l'élément, dans le système de coordonnées de l'élément et renvoie les coordonnées converties.

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

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

Convertit le rectangle rect, qui est dans le système de coordonnées du parent de l'élément, dans le système de coordonnées de l'élément et renvoie le rectangle converti 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 ( const QPolygonF & polygon ) const

Convertit le polygon polygon, qui est dans le système de coordonnées du parent de l'élément, dans le système de coordonnées de l'élément et renvoie le polygone converti.

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

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

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

Voir aussi mapFromScene(), mapFromItem(), mapToParent() 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 est équivalente à l'appel de mapFromItem(QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.3.

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

Il s'agit d'une fonction surchargée.

Cette fonction est équivalente à l'appel de mapFromParent(QPointF(x, y)).

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

Convertit le point point, qui est dans le système de coordonnées de la scène, dans le système de coordonnées de l'élément et renvoie les coordonnées converties.

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

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

Convertit le rectangle rect, qui est dans le système de coordonnées de la scène, dans le système de coordonnées de l'élément et renvoie le rectangle converti 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 ( const QPolygonF & polygon ) const

Convertit le polygon polygon, qui est dans le système de coordonnées de la scène, dans le système de coordonnées de l'élément et renvoie le polygone converti.

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

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

Convertit le path path, qui est dans le système de coordonnées de la scène, dans le système de coordonnées de l'élément et renvoie le chemin converti.

Voir aussi mapFromParent(), mapFromItem(), mapToScene() 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 est équivalente à l'appel de mapFromScene(QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.3.

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

Il s'agit d'une fonction surchargée.

Cette fonction est équivalente à l'appel de mapFromScene(QPointF(x, y)).

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

Convertit le rectangle rect, qui est dans le système de coordonnées de item, dans le système de coordonnées de l'élément et renvoie le rectangle converti sous forme d'un nouveau rectangle (qui est le rectangle frontière du polygone résultant).

Si item vaut 0, cette fonction renvoie le même résultat que mapRectFromScene().

Cette fonction a été introduite dans Qt 4.5.

Voir aussi 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 est équivalente à l'appel de mapRectFromItem(item, QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.5.

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

Convertit le rectangle rect, qui est dans le système de coordonnées du parent de l'élément, dans le système de coordonnées de l'élément et renvoie le rectangle converti sous forme d'un nouveau rectangle (qui est le rectangle frontière du polygone résultant).

Cette fonction a été introduite dans Qt 4.5.

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 est équivalente à l'appel de mapRectFromParent(QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.5.

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

Convertit le rectangle rect, qui est en coordonnées de scène, dans le système de coordonnées de l'élément et renvoie le rectangle converti sous forme d'un nouveau rectangle (qui est le rectangle frontière du polygone résultant).

Cette fonction a été introduite dans Qt 4.5.

Voir aussi 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 est équivalente à l'appel de mapRectFromScene(QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.5.

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

Convertit le rectangle rect, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de item et renvoie le rectangle converti sous forme d'un nouveau rectangle (qui est le rectangle frontière du polygone résultant).

Si item vaut 0, cette fonction renvoie le même résultat que mapRectToScene().

Cette fonction a été introduite dans Qt 4.5.

Voir aussi 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 est équivalente à l'appel de mapRectToItem(item, QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.5.

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

Convertit le rectangle rect, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de son parent et renvoie le rectangle converti sous forme d'un nouveau rectangle (qui est le rectangle frontière du polygone résultant).

Cette fonction a été introduite dans Qt 4.5.

Voir aussi 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 est équivalente à l'appel de mapRectToParent(QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.5.

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

Convertit le rectangle rect, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de la scène et renvoie le rectangle converti sous forme d'un nouveau rectangle (qui est le rectangle frontière du polygone résultant).

Cette fonction a été introduite dans Qt 4.5.

Voir aussi 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 est équivalente à l'appel de mapRectToScene(QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.5.

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

Convertit le point point, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de item et renvoie les coordonnées converties.

Si item vaut 0, cette fonction renvoie le même résultat que mapToScene().

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

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

Convertit le rectangle rect, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de item et renvoie le rectangle converti sous la forme d'un polygone.

Si item vaut 0, cette fonction renvoie le même résultat 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, const QPolygonF & polygon ) const

Convertit le polygone polygon, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de item et renvoie le polygone converti.

Si item vaut 0, cette fonction renvoie le même résultat que mapToScene().

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

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

Convertit le chemin path, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de item et renvoie le chemin converti.

Si item vaut 0, cette fonction renvoie le même résultat 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 est équivalente à l'appel de mapToItem(item, QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.3.

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

Il s'agit d'une fonction surchargée.

Cette fonction est équivalente à l'appel de mapToItem(item, QPointF(x, y)).

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

Convertit le point point, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de son parent et renvoie les coordonnées converties. Si l'élément n'a pas de parent, point sera converti dans le système de coordonnées de la scène.

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

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

Convertit le rectangle rect, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de son parent et renvoie le rectangle converti sous la forme d'un polygone. Si l'élément n'a pas de parent, rect sera converti dans le système de coordonnées de la scène.

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

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

Convertit le polygon polygon, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de son parent et renvoie le polygone converti. Si l'élément n'a pas de parent, polygon sera converti 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.

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

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

Voir aussi 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 est équivalente à l'appel de mapToParent(QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.3.

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

Il s'agit d'une fonction surchargée.

Cette fonction est équivalente à l'appel de mapToParent(QPointF(x, y)).

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

Convertit le point point, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de la scène et renvoie les coordonnées converties.

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

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

Convertit le rectangle rect, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de la scène et renvoie le rectangle converti sous la forme d'un polygone.

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

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

Convertit le polygon polygon, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de la scène et renvoie le polygone converti.

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

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

Convertit le path path, qui est dans le système de coordonnées de l'élément, vers le système de coordonnées de la scène et renvoie le chemin converti.

Voir aussi 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 est équivalente à l'appel de mapToScene(QRectF(x, y, w, h)).

Cette fonction a été introduite dans Qt 4.3.

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

Il s'agit d'une fonction surchargée.

Cette fonction est équivalente à l'appel de mapToScene(QPointF(x, y)).

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

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

Lorsqu'un élément est double-cliqué, il reçoit d'abord un événement mousePress (touche appuyée), suivi d'un mouseReleaseEvent (touche relâchée, c'est-à-dire un clic), ensuite un double-clic et enfin, un autre mouseReleaseEvent.

Appeler QEvent::ignore() ou QEvent::accept() sur event n'a pas d'effet.

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

Notez qu'un élément ne recevra pas les doubles-clics s'il n'est pas selectable ou movable (dans ce cas les simples clics sont ignorés et bloquent la génération des doubles-clics).

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

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté pour recevoir les événements de déplacement de souris pour cet élément. Si vous recevez cet événement, vous pouvez être certain que cet élément a aussi reçu un événement de bouton appuyé et que cet élément est actuellement le destinataire de tous les événements souris.

Appeler QEvent::ignore() ou QEvent::accept() sur event n'a pas d'effet.

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

Notez que mousePressEvent() décide de l'élément graphique qui recevra les événements souris. Voir la description de mousePressEvent() pour les détails.

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

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté pour recevoir les événements d'appui sur un bouton de souris pour cet élément. Ces événements sont seulement envoyés aux éléments acceptant les événements pour ce bouton. Par défaut, un élément accepte tous les boutons mais vous pouvez changer ce comportement en appelant setAcceptedMouseButtons().

Cet événement détermine quel élément sera destinataire des événements souris suivants (voir QGraphicsScene::mouseGrabberItem()). Si vous ne réimplémentez pas cette fonction, l'événement d'appui se propagera à un éventuel élément de premier niveau situé sous cet élément et aucun autre événement souris ne sera envoyé à cet élément.

Si vous réimplémentez cette fonction, event sera accepté par défaut (voir QEvent::accept()) et cet élément « prendra » la souris. Cela permettra à l'élément de recevoir les futurs événements déplacement, clic et double-clic. Si vous appelez QEvent::ignore() sur event, cet élément ne prendra pas la souris et event se propagera à un élément situé en dessous. Aucun autre événement souris ne sera envoyé à cet élément jusqu'à un prochain événement d'appui de bouton.

L'implémentation par défaut gère les interactions de base de l'élément, comme la sélection et le déplacement. Si vous voulez conserver l'implémentation de base lors de la réimplémentation de cette fonction, appelez QGraphicsItem::mousePressEvent() dans votre réimplémentation.

Si un élément n'est ni movable ni selectable, QEvent::ignore() sera appelé pour cet événement.

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

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté pour recevoir les événements de bouton de souris relâché pour cet élément.

Appeler QEvent::ignore() ou QEvent::accept() sur event n'a pas d'effet.

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

Notez que mousePressEvent() décide de l'élément graphique qui recevra les événements souris. Voir la description mousePressEvent() pour les 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 dy points verticalement. Cette fonction est l'équivalent de l'appel de setPos(pos() + QPointF(dx, dy)).

qreal QGraphicsItem::opacity () const

Renvoie l'opacité locale de l'élément, qui est entre 0.0 (transparent) et 1.0 (opaque). Cette valeur est combinée avec les valeurs des parents et ancêtres dans effectiveOpacity(). L'opacité effective décide du rendu de l'élément.

La propriété opacité décide de l'état du QPainter passé à la fonction paint(). Si l'élément utilise le cache, c'est-à-dire ItemCoordinateCache ou DeviceCoordinateCache, la propriété effective sera appliquée au cache pendant le rendu.

L'opacité par défaut est 1.0 (complètement opaque).

Cette fonction a été introduite dans Qt 4.5.

Voir aussi setOpacity(), paint(), ItemIgnoresParentOpacity et ItemDoesntPropagateOpacityToChildren.

QPainterPath QGraphicsItem::opaqueArea () const [virtual]

Cette fonction virtuelle renvoie une forme représentant la zone dans laquelle cet élément est opaque. Une zone est opaque si elle est remplie en utilisant une brosse ou une couleur opaque (c'est-à-dire non transparente).

Cette fonction est utilisée par isObscuredBy(), qui est appelée par les éléments du dessous pour déterminer s'ils sont masqués par cet élément.

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

Voir aussi isObscuredBy(), isObscured() et shape().

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

Cette fonction, qui est en général appelée par QGraphicsView, dessine le contenu d'un élément en coordonnées locales.

Réimplémentez cette fonction dans une classe dérivée de QGraphicsItem pour fournir une implémentation du dessin de l'élément, en utilisant painter. Le paramètre option contient des options de style pour l'élément, comme son état, la zone exposée et le niveau de détails demandé. L'argument widget est optionnel. S'il est fourni, il pointe sur le widget en train d'être dessiné ; sinon, il est à 0. Pour le dessin en cache, widget est toujours 0.

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

Le QPen du Qpainter a une largeur de 0 par défaut et est initialisé à la brosse QPalette::Text de la palette du périphérique de destination. La brosse est initialisée à QPalette::Window.

Assurez-vous que vos dessins ne débordent pas du cadre du boundingRect() pour éviter des défauts de rendu, étant donné que QGraphicsView ne va pas éliminer ces portions en trop pour vous. En particulier, lorsque QPainter fait le rendu de la bordure d'une forme en utilisant un QPen donné, la moitié de la bordure sera dessinée à l'intérieur et l'autre moitié à l'extérieur de la forme que vous dessinez (par exemple avec une largeur de 2 unités, vous devez dessiner les bordures avec 1 unité à l'intérieur du boundingRect()). QGraphicsItem ne gère pas l'usage de Qpen cosmétiques avec une largeur différente de zéro.

Tous les dessins sont faits 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 0 si cet élément n'a pas de panneau. Si l'élément est un panneau, il se renvoie lui-même, sinon il renverra le panneau le plus proche parmi ses ancêtres.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi isPanel() et ItemIsPanel.

PanelModality QGraphicsItem::panelModality () const

Renvoie la modalité de cet élément.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setPanelModality().

QGraphicsItem * QGraphicsItem::parentItem () const

Renvoie un pointeur sur le parent de cet élément. Si cet élément n'a pas de parent, renvoie 0.

Voir aussi setParentItem() et childItems().

QGraphicsObject * QGraphicsItem::parentObject () const

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

Cette fonction a été introduite dans Qt 4.6.

Voir aussi parentItem() et childItems().

QGraphicsWidget * QGraphicsItem::parentWidget () const

Renvoie un pointeur sur le widget parent de cet élément. Le widget parent est le parent le plus proche de type QWidget.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi parentItem() et childItems().

QPointF QGraphicsItem::pos () const

Renvoie la position de l'élément dans les coordonnées du parent. 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 est celle de son origine (coordonnées locales (0, 0)) dans les coordonnées du parent ; cette fonction renvoie le même résultat que mapToParent(0, 0).

Vous pouvez aussi appeler scenePos() pour déterminer la position de l'élément en coordonnées de scène, indépendamment de son parent.

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

void QGraphicsItem::prepareGeometryChange () [protected]

Prépare l'élément pour un changement de géométrie. Appelez cette fonction avant de modifier le rectangle frontière d'un élément pour que l'index de QGraphicsScene reste à jour.

prepareGeometryChange() appellera update() si nécessaire.

Exemple :

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

Voir aussi boundingRect().

void QGraphicsItem::removeSceneEventFilter ( QGraphicsItem * filterItem )

Supprime un filtre d'événements sur cet élément de filterItem.

Voir aussi installSceneEventFilter().

void QGraphicsItem::resetTransform ()

Réinitialise la matrice de transformation de l'élément à la matrice identité ou toutes les propriétés de transformation à leurs valeurs par défaut. Cette fonction est équivalente à l'appel de setTransform(QTransform()).

Cette fonction a été introduite dans Qt 4.3.

Voir aussi setTransform() et transform().

qreal QGraphicsItem::rotation () const

Renvoie la rotation dans le sens horaire, en degrés, autour de l'axe Z. La valeur par défaut est 0 (pas de rotation).

La rotation est combinée avec scale(), transform() et transformations() pour convertir le système de coordonnées de l'élément vers celui de l'élément parent.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setRotation(), transformOriginPoint() et Transformations.

qreal QGraphicsItem::scale () const

Renvoie le facteur d'échelle de l'élément. Le facteur par défaut est 1.0 (l'élément n'est pas redimensionné).

Ce facteur est combiné avec rotation(), transform() et transformations() pour convertir le système de coordonnées de l'élément vers celui de l'élément parent.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setScale(), rotation() et Transformations.

QGraphicsScene * QGraphicsItem::scene () const

Renvoie la scène courante de l'élément ou 0 si l'élément ne fait pas partie d'une scène.

Pour ajouter un élément à une scène, appelez QGraphicsScene::addItem().

QRectF QGraphicsItem::sceneBoundingRect () const

Renvoie le rectangle frontière de cet élément en coordonnées de scène, en combinant sceneTransform() avec boundingRect().

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

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

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

La fonction renvoie vrai si l'événement a été reconnu et géré ; sinon (par exemple si le type d'événement n'est pas connu), elle renvoie faux.

event est l'événement intercepté.

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

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

La réimplémentation de cette fonction dans une classe dérivée rend possible l'utilisation de cette élément comme filtre d'événements pour les autres éléments, en interceptant tous les événements destinés à ces éléments avant qu'ils ne puissent y répondre.

Les réimplémentations doivent renvoyer true pour empêcher la poursuite du traitement d'un événement en s'assurant qu'il ne sera pas transmis à l'élément surveillé, ou renvoyer false pour que l'événement soit propagé 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. Cette fonction est équivalente à l'appel de mapToScene(0, 0).

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

QTransform QGraphicsItem::sceneTransform () const

Renvoie la matrice de transformation de scène de l'élément. Cette matrice peut être utilisée pour convertir des coordonnées et des formes géométriques depuis le système de coordonnées locales de l'élément vers le système de coordonnées de la scène. Pour convertir depuis 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 renvoie seulement la transformation locale de l'élément, cette fonction inclut la position de l'élément (et de ses parents) et toutes les propriétés de transformation.

Cette fonction a été introduite dans Qt 4.3.

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 null (la valeur par défaut), c'est le rectangle frontière de l'élément qui défilera.

Le défilement est une alternative au fait de simplement redessiner l'élément lorsque son contenu (ou une portion de son contenu) est décalé horizontalement ou verticalement. En fonction de la transformation courante et des capacités du périphérique de rendu, le défilement peut consister uniquement à déplacer des pixels d'un endroit à un autre en utilisant memmove(). Dans la plupart des cas cette opération est plus rapide que d'effectuer un rendu de la zone entière.

Après le défilement, l'élément effectuera une demande de mise à jour pour toutes les zones nouvellement exposées. Si le défilement n'est pas géré (par exemple si vous faites un rendu dans un afficheur OpenGL, qui ne bénéficie pas d'optimisations de défilement), cette fonction est équivalente à l'appel de update(rect).

Note : le défilement est géré seulement si QGraphicsItem::ItemCoordinateCache est activé ; dans tous les autres cas l'appel de cette fonction est équivalent à l'appel de update(rect). Si vous êtes certain que l'élément est opaque et n'est pas recouvert par d'autres éléments, vous pouvez convertir rect en coordonnées d'affichage et faire défiler la zone d'affichage dans la vue.

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

Cette fonction a été introduite dans Qt 4.4.

Voir aussi boundingRect().

void QGraphicsItem::setAcceptDrops ( bool on )

Si on est vrai, cet élément acceptera les événements de glisser-déposer; sinon, il sera 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 aussi acceptDrops().

void QGraphicsItem::setAcceptHoverEvents ( bool enabled )

Si enabled est vrai, cet élément acceptera les événements de survol ; sinon, il les ignorera. Par défaut, les éléments n'acceptent pas les événements de survol.

Les événements de survol sont envoyés si aucun élément n'a « pris » la souris (voir mousePressEvent()). Ils sont envoyés lorsque la souris arrive sur l'élément, quand ils se déplacent sur l'élément et quand ils quittent l'élément. Les événements de survol sont couramment utilisés pour mettre en évidence un élément lorsqu'il est survolé et pour suivre le pointeur de souris pendant ses déplacements sur l'élément (un équivalent de QWidget::mouseTracking).

Les éléments parents reçoivent les événements de début de survol avant leurs enfants et les événements de fin de survol après eux. Cependant, le parent ne reçoit pas de fin de survol lorsque le pointeur arrive sur un enfant ; le parent reste « survolé » lorsque le pointeur quitte sa zone, y compris celle de ses enfants.

Si un élément parent gère les événements de ses enfants, il recevra, lorsque le curseur passe sur ses enfants, les événements de déplacement pendant le survol, de déplacement pendant un glisser-déposer, et de dépose, mais ne recevra pas les début et fin de survol, ni les début et fin de glisser-déposer pour le compte de ses enfants.

Un QGraphicsWidget avec des décorations de fenêtre acceptera les événements de survol indépendamment de la valeur de acceptHoverEvents().

Cette fonction a été introduite dans Qt 4.4.

Voir aussi acceptHoverEvents(), hoverEnterEvent(), hoverMoveEvent() et hoverLeaveEvent().

void QGraphicsItem::setAcceptTouchEvents ( bool enabled )

Si enabled est vrai, cet élément acceptera événements de touché; sinon, il les ignorera. Par défaut, les éléments n'acceptent pas les événements de touché.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi acceptTouchEvents().

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

Définit les boutons de souris acceptés par cet élément.

Par défaut, tous les boutons sont acceptés. Si un élément accepte un bouton, il « prendra » la souris lorsqu'il recevra un événement de bouton enfoncé pour ce bouton, c'est-à-dire qu'il deviendra le destinataire de tous les événements de souris suivants. Si l'élément n'accepte pas le bouton, QGraphicsScene transférera les événements de souris au premier élément en dessous de lui qui l'accepte.

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

Voir aussi 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 est activé. Sinon, le panneau est désactivé.

Si l'élément ne fait pas partie d'une scène active, active déterminera l'état du panneau lorsque la scène deviendra active ou que l'élément sera ajouté à la scène : s'il est vrai, le panneau de l'élément sera alors activé, sinon l'élément restera inactif indépendamment de l'état d'activation de la scène.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi isPanel(), QGraphicsScene::setActivePanel() et QGraphicsScene::isActive().

void QGraphicsItem::setBoundingRegionGranularity ( qreal granularity )

Fixe la granularité de la région frontière à granularity, une valeur entre 0 et 1 (inclus). La valeur par défaut est 0 (c'est-à-dire la granularité la plus basse, pour laquelle la région frontière correspond au rectangle frontière de l'élément).

La granularité est utilisée par boundingRegion() pour calculer la précision que doit avoir la région frontière. La granularité la plus élevée est 1, pour laquelle boundingRegion() renverra le contour le plus précis possible en fonction du périphérique (par exemple, pour un affichage de QGraphicsView, cela donne une région précise au pixel près). La granularité la plus basse est 0. La valeur de granularity décrit le rapport entre la résolution du périphérique de rendu et la résolution de la région frontière (par exemple, une valeur de 0.25 correspond à une région où chaque unité correspond à une unité de 4 × 4 dans le périphérique).

Cette fonction a été introduite dans Qt 4.4.

Voir aussi boundingRegionGranularity().

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

Fixe le mode de cache de l'élément à mode.

L'argument optionnel logicalCacheSize est seulement utilisé par le mode ItemCoordinateCache et décrit la résolution du tampon de cache ; si logicalCacheSize est (100, 100), QGraphicsItem fera rentrer l'élément dans une zone de 100 × 100 pixels en mémoire graphique, indépendamment de 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ée.

La mise en cache peut accélérer le rendu si vos élément passent un temps significatif à se redessiner. Dans certains cas le cache peut aussi ralentir le rendu, en particulier si l'élément met moins de temps à se redessiner que QGraphicsItem n'en met à redessiner depuis le cache. Si le cache est activé, la fonction paint() sera appelée une seule fois pour chaque update() ; pour les requêtes de dessin suivantes, le dessin sera fait depuis le cache. Cette approche fonctionne particulièrement bien avec QGLWidget, qui enregistre le cache sous forme de textures OpenGL.

Notez qu'il peut être nécessaire d'ajuster la limitation de cache de QPixmapCache pour obtenir des performances optimales.

Vous pouvez en lire plus sur les différents modes de cache dans la documentation de CacheMode.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi cacheMode(), CacheMode et QPixmapCache::setCacheLimit().

void QGraphicsItem::setCursor ( const QCursor & cursor )

Définit cursor comme forme courante du pointeur de souris. Le pointeur de souris aura cette forme lorsqu'il sera au-dessus de l'élément. Vous pouvez trouver un ensemble de formes utiles dans la liste de pointeurs prédéfinis.

Un élément éditeur peut utiliser un pointeur en forme de barre :

 item->setCursor(Qt::IBeamCursor);

Si aucun pointeur n'a été défini, le pointeur du parent est utilisé.

Voir aussi cursor(), hasCursor(), unsetCursor(), QWidget::cursor et QApplication::overrideCursor().

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

Affecte la valeur value à la donnée personnalisée de clé key.

Les données personnalisées sont utiles pour le stockage de propriétés arbitraires dans les éléments. Qt n'utilise pas cette fonction pour stocker des données ; elle est fournie uniquement pour les besoins 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 ne reçoivent aucun événement et ne peuvent pas être sélectionnés ni recevoir le focus. Les événements souris sont ignorés ; ils ne sont pas propagés sauf si l'élément est aussi invisible ou qu'il n'accepte pas les événements souris (voir acceptedMouseButtons()). Un élément désactivé ne peut pas « prendre » la souris et, en conséquence, un élément qui devient désactivé alors qu'il a pris la souris va la rendre. De la même façon, un élément désactivé va perdre le focus s'il l'avait.

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, ses enfants seront également désactivés. Si vous activez un élément parent, ses enfants seront activés, sauf si ils ont été explicitement activés (c'est-à-dire que si vous appelez setEnabled(false) sur un enfant, il ne sera pas réactivé si vous désactivez le parent puis le réactivez).

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

Note : si vous installez un filtre d'événements, vous pouvez toujours intercepter les événements avant qu'ils ne soient transmis aux enfants ; ce mécanisme est indépendant de l'état d'activation.

Voir aussi isEnabled().

void QGraphicsItem::setFiltersChildEvents ( bool enabled )

Si enabled est vrai, cet élément va filtrer tous les événements de ses enfants (c'est-à-dire qu'il va recevoir à leur place les événements destinés à ses enfants) ; sinon, si enabled est faux, cet élément ne gérera que ses propres événements. La valeur par défaut est false.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi filtersChildEvents().

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

Si enabled est vrai, le drapeau flag est activé; sinon, il est désactivé.

Voir aussi flags() et setFlags().

void QGraphicsItem::setFlags ( GraphicsItemFlags flags )

Affecte la valeur flags aux drapeaux. Les drapeaux présents dans flags sont activés ; les autres sont désactivés.

Si l'élément a le focus et que flags n'active pas ItemIsFocusable, l'élément va perdre 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 sera automatiquement désélectionné.

Par défaut, aucun drapeau n'est activé (QGraphicsWidget active le drapeau ItemSendsGeometryChanges par défaut pour suivre les changements de position).

Voir aussi flags() et setFlag().

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

Donne le focus à cet élément pour les saisies au clavier. L'argument focusReason sera transmis à tous les événements de focus générés par cette fonction ; il est utilisé pour expliquer la raison pour laquelle le focus est reçu.

Seuls les éléments activés et ayant le drapeau ItemIsFocusable peuvent accepter le focus clavier.

Si cet élément est invisible, inactif, ou non associé à une scène, il ne recevra pas immédiatement le focus. Cependant, il sera enregistré comme l'élément préférentiel pour la prise de focus dans son arbre d'éléments, pour le cas où il deviendrait plus tard visible.

Suite à l'appel de cette fonction, l'élément recevra un événement de prise de focus avec focusReason. Si un autre élément avait le focus, cet élément recevra un événement de perte de focus indiquant qu'il a perdu le focus pour les saisies.

Voir aussi clearFocus(), hasFocus(), focusItem() et focusProxy().

void QGraphicsItem::setFocusProxy ( QGraphicsItem * item )

Affecte la valeur item au proxy de focus.

Si un élément a un proxy de focus, le proxy de focus recevra le focus de saisie lorsque l'élément recevra ce focus. L'élément lui-même possèdera toujours le focus (c'est-à-dire que hasFocus() renverra vrai) mais le le proxy de focus recevra les saisies au clavier.

Un proxy de focus peut lui-même avoir un proxy de focus et ainsi de suite. Dans ce cas, les saisies seront reçues par le proxy de focus à l'extrémité de la chaîne. Le proxy de focus item doit appartenir à la même scène que l'élément.

Cette fonction a été introduite dans Qt 4.6.

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

void QGraphicsItem::setGraphicsEffect ( QGraphicsEffect * effect )

Installe effectcomme effet de l'élément. Si un autre effet est déjà installé, QGraphicsItem supprimera l'effet existant avant d'installer effect.

Si effect est installé sur un autre élément, setGraphicsEffect() le retirera de cet autre élément.

QGraphicsItem devient propriétaire de effect.

Note : cette fonction appliquera l'effet aussi sur les enfants de l'élément.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi graphicsEffect().

void QGraphicsItem::setGroup ( QGraphicsItemGroup * group )

Ajoute cet élément au groupe d'éléments group. Si group est 0, cet élément est retiré du groupe auquel il appartient et ajouté comme enfant du parent du groupe précédent.

Voir aussi group() et QGraphicsScene::createItemGroup().

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

Affecte la valeur hints aux indicateurs de méthode de saisie de l'élément.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi inputMethodHints(), inputMethodQuery() et QInputContext.

void QGraphicsItem::setOpacity ( qreal opacity )

Fixe l'opacité locale de l'élément, qui est entre 0.0 (transparent) et 1.0 (opaque). Cette valeur est combinée avec les valeurs des parents et ancêtres dans effectiveOpacity().

Par défaut, l'opacité se propage de parent à enfant, donc si l'opacité du parent est 0.5 et celle de l'enfant aussi de 0.5, l'opacité effective de l'enfant sera de 0.25.

La propriété opacité décide de l'état du QPainter passé à la fonction paint(). Si l'élément utilise le cache, c'est-à-dire ItemCoordinateCache ou DeviceCoordinateCache, la propriété effective sera appliquée au cache pendant le rendu.

Deux drapeaux affectent la façon dont l'opacité de l'élément est combinée avec celle du parent : ItemIgnoresParentOpacity et ItemDoesntPropagateOpacityToChildren.

Cette fonction a été introduite dans Qt 4.5.

Voir aussi opacity() et effectiveOpacity().

void QGraphicsItem::setPanelModality ( PanelModality panelModality )

Affecte la valeur panelModality à la modalité de cet élément.

Un changement de modalité sur un élément visible prend effet immédiatement.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi panelModality().

void QGraphicsItem::setParentItem ( QGraphicsItem * newParent )

Le parent de cet élément devient newParent. Si cet élément a déjà un parent, il est d'abord retiré au parent précédent. Si newParent est 0, cet élément devient un élément de premier niveau.

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

Appeler cette fonction sur un ancêtre de newParent produira un résultat indéfini.

Voir aussi parentItem() et childItems().

void QGraphicsItem::setPos ( const QPointF & pos )

La position de l'élément prend la valeur pos, cette valeur étant exprimée en coordonnées du parent. Pour les éléments sans parent, pos est en coordonnées de scène.

La position de l'élément est celle de son origine (coordonnées locales (0, 0)) dans les coordonnées du parent.

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

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

Il s'agit d'une fonction surchargée.

Cette fonction est équivalente à l'appel de setPos(QPointF(x, y)).

void QGraphicsItem::setRotation ( qreal angle )

Effectue une rotation de la valeur angle dans le sens horaire, en degrés, autour de l'axe Z. La valeur par défaut est 0 (pas de rotation). Une valeur négative représente une rotation dans le sens anti-horaire. Normalement l'angle de rotation est dans la plage (-360, 360) mais il est aussi possible d'affecter des valeurs en dehors de cette plage (par exemple une rotation de 370 degrés est identique à une rotation de 10 degrés).

La rotation s'effectue autour du point d'origine des transformations, qui est (0, 0) par défaut. Vous pouvez sélectionner une origine de transformation différente en appelant setTransformOriginPoint().

La rotation est combinée avec les scale(), transform() et transformations() de l'élément pour les conversions du système de coordonnées de l'élément vers celui du parent.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi rotation(), setTransformOriginPoint() et Transformations.

void QGraphicsItem::setScale ( qreal factor )

Fixe le facteur d'échelle de l'élément. Le facteur par défaut est 1.0 (l'élément n'est pas redimensionné). Un facteur de 0.0 réduit l'élément à un point. Si vous donnez un facteur négatif, l'élément sera tourné de 180 degrés.

L'élément est redimensionné à partir du point d'origine de transformation, qui est par défaut (0, 0). Vous pouvez sélectionner un point d'origine de transformation différent en appelant setTransformOriginPoint().

Le facteur d'échelle est combiné avec les rotation(), transform() et transformations() de l'élément pour les conversions du système de coordonnées de l'élément vers celui du parent.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi scale(), setTransformOriginPoint() et Transformations Example.

void QGraphicsItem::setSelected ( bool selected )

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

Si l'élément fait partie d'un groupe, l'état de sélection de tout le groupe est modifié par l'appel de cette fonction, car l'état de sélection des éléments d'un groupe est commun à tous ses éléments.

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 soit invisible, soit désactivé, soit non-sélectionnable, la fonction ne fait rien.

Par défaut, les éléments ne peuvent pas être sélectionnés. Pour autoriser la sélection, utilisez le drapeau ItemIsSelectable.

Cette fonction permet de facilement changer l'état de sélection individuel 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 aussi isSelected() et QGraphicsScene::selectedItems().

void QGraphicsItem::setToolTip ( const QString & toolTip )

L'infobulle de l'élément devient toolTip. Si toolTip est vide, l'infobulle est supprimée.

Voir aussi toolTip() et QToolTip.

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

La matrice de transformation de l'élément devient matrix.

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

Pour simplifier l'interaction avec les éléments utilisant une vue transformée, QGraphicsItem fournit des fonctions mapTo... et mapFrom... qui peuvent faire la traduction entre les coordonnées de l'élément et celles de la scène. Par exemple, vous pouvez appeler mapToScene() pour convertir depuis les coordonnées de l'élément vers les coordonnées de scène ou mapFromScene() pour convertir depuis les coordonnées de scène vers les coordonnées de l'élément.

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

Cette fonction a été introduite dans Qt 4.3.

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

void QGraphicsItem::setTransformOriginPoint ( const QPointF & origin )

Affecte la valeur origin au point d'origine de transformation, dans les coordonnées de l'élément.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi transformOriginPoint() et Transformations.

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

Il s'agit d'une fonction surchargée.

Fixe le point d'origine de transformation en coordonnées de l'élément. Cet appel est équivalent à l'appel de setTransformOriginPoint(QPointF(x, y)).

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setTransformOriginPoint() et Transformations.

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

Applique une liste de transformations graphiques (QGraphicsTransform) à cet élément.

Si vous avez simplement besoin d'une rotation ou un redimensionnement, vous devez plutôt appeler setRotation() ou setScale(). Si vous voulez appliquer une transformation arbitraire, appelez setTransform().

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

Les transformations sont combinées avec les rotation(), scale() et transform() de l'élément pour les conversions du système de coordonnées de l'élément vers celui du parent.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi transformations(), scale(), setTransformOriginPoint() et Transformations.

void QGraphicsItem::setVisible ( bool visible )

Si visible est vrai, l'élément devient visible. Sinon, l'élément devient invisible. Les éléments invisibles ne sont pas dessinés et ne reçoivent pas d'événements. En particulier, les événements souris traversent les élément invisibles et sont transmis aux éléments du dessous. Les éléments invisibles sont également non-sélectionnables, ne peuvent pas recevoir le focus, 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 a « pris » la souris (c'est-à-dire alors qu'il reçoit les événements souris), il perdra automatiquement la souris et ne le récupérera pas simplement en le rendant de nouveau visible ; il ne la reprendra que s'il reçoit un nouvel événement de bouton appuyé.

De même, un élément invisible ne peut pas recevoir le focus, donc si un élément a le focus quand il devient invisible, il perdra le focus et ne le récupèrera pas automatiquement s'il devient de nouveau visible.

Si vous cachez le parent d'un élément, tous ses enfants seront également cachés. Si vous montrez un parent, ses enfants vont être visibles aussi, sauf s'ils ont été explicitement cachés (c'est-à-dire que si vous appelez setVisible(false) sur un enfant, il ne redeviendra pas visible si son parent est rendu invisible puis visible).

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

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

void QGraphicsItem::setX ( qreal x )

Affecte x à la coordonnée x de la position de l'élément - équivalent à l'appel de setPos(x, y()).

Cette fonction a été introduite dans Qt 4.6.

Voir aussi x() et setPos().

void QGraphicsItem::setY ( qreal y )

Affecte y à la coordonnée y de la position de l'élément - équivalent à l'appel de setPos(x(), y).

Cette fonction a été introduite dans Qt 4.6.

Voir aussi y(), x() et setPos().

void QGraphicsItem::setZValue ( qreal z )

Affecte z à la valeur Z de l'élément. La valeur Z décide de l'ordre d'empilement des éléments voisins de même niveau (même parent ou sans parent). Un élément de valeur Z élevée sera dessiné au dessus d'un élément de même niveau ayant une valeur Z plus basse.

À valeur Z égale, l'ordre d'insertion déterminera l'ordre d'empilement.

La valeur Z n'affecte pas la taille de l'élément.

La valeur Z par défaut est 0.

Voir aussi zValeur(), Sorting, stackBefore() et ItemStacksBehindParent.

QPainterPath QGraphicsItem::shape () const [virtual]

Renvoie la forme de cet élément sous forme d'un QPainterPath en coordonnées locales. La forme a de nombreux usages, incluant la détection de collision, les tests d'atteinte et dans les fonctions QGraphicsScene::items().

L'implémentation par défaut appelle boundingRect(), qui renvoie une simple forme rectangulaire, mais les classes dérivées peuvent réimplémenter cette fonction pour renvoyer une forme plus précise pour les éléments non-rectangulaires. Par exemple, un élément rond peut renvoyer une forme elliptique pour améliorer la détection de collision :

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

La bordure d'une forme peut varier suivant la largeur et le style du pinceau utilisé pour le dessin. Si vous voulez utiliser cette bordure dans la forme de l'élément, vous pouvez créer une forme à partir du trait grâce à QPainterPathStroker.

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

Voir aussi boundingRect(), contains(), prepareGeometryChange() et QPainterPathStroker.

void QGraphicsItem::show ()

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

Cette fonction est équivalente à l'appel de setVisible(true).

Voir aussi hide() et setVisible().

void QGraphicsItem::stackBefore ( const QGraphicsItem * sibling )

Empile cet élément au-dessus de sibling, qui doit être un élément de même niveau (c'est-à-dire que les deux éléments doivent avoir le même parent ou aucun des deux ne doit avoir de parent). sibling doit avoir la même valeur Z que cet élément, sinon l'appel de cette fonction n'aura pas d'effet.

Par défaut, les éléments de même niveau sont empilés par ordre d'insertion (c'est-à-dire que le premier élément ajouté est dessiné avant un élément ajouté ensuite). Si les valeurs-Z de deux éléments sont différentes, l'élément avec la valeur Z la plus grande est dessiné au dessus. À valeur Z égale, l'ordre d'insertion déterminera l'ordre d'empilement.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setZValue(), ItemStacksBehindParent et Sorting.

QGraphicsObject * QGraphicsItem::toGraphicsObject ()

Renvoie le QGraphicsItem converti en QGraphicsObject si sa classe est réellement QGraphicsObject, 0 sinon.

Cette fonction a été introduite dans Qt 4.6.

const QGraphicsObject * QGraphicsItem::toGraphicsObject () const

Renvoie le QGraphicsItem converti en QGraphicsObject si sa classe est réellement QGraphicsObject, 0 sinon.

Cette fonction a été introduite dans Qt 4.6.

QString QGraphicsItem::toolTip () const

Renvoie l'infobulle de l'élément ou un QString vide si aucune infobulle 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'ancêtre de l'élément dont le parent est 0. Si un élément n'a pas de parent, il renvoie un pointeur vers lui-même (c'est-à-dire qu'un élément de premier niveau est son propre élément de premier niveau).

Voir aussi parentItem().

QGraphicsWidget * QGraphicsItem::topLevelWidget () const

Renvoie le widget de premier niveau de cet élément (c'est-à-dire l'ancêtre de l'élément dont le parent est 0 ou le parent n'est pas un widget) ou 0 si l'élément n'a pas de widget de premier niveau. Si l'élément est son propre widget de premier niveau, il renvoie un pointeur vers lui-même.

Cette fonction a été introduite dans Qt 4.4.

QTransform QGraphicsItem::transform () const

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

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

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

Cette fonction a été introduite dans Qt 4.3.

Voir aussi setTransform() et sceneTransform().

QPointF QGraphicsItem::transformOriginPoint () const

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

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

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setTransformOriginPoint() et Transformations.

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

Renvoie une liste de transformations graphiques s'appliquant actuellement à l'élément.

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

Les transformations sont combinées avec les rotation(), scale() et transform() de l'élément pour les conversions du système de coordonnées de l'élément vers celui du parent.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setTransformations(), scale(), rotation(), transformOriginPoint() et Transformations.

int QGraphicsItem::type () const [virtual]

Renvoie le type de l'élément sous forme d'un entier. Toutes les classes standard dérivées de QGraphicsItem sont associées à une valeur unique ; voir QGraphicsItem::Type. Cette information de type est utilisée par qgraphicsitem_cast() pour différencier 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 de Type égale à la valeur de type de votre élément. Les éléments personnalisés doivent renvoyer une valeur supérieure ou égale à UserType (65536).

Par exemple :

 class CustomItem : public QGraphicsItem
 {
    ...
    enum { Type = UserType + 1 };
 
    int type() const
    {
        // Enable the use of qgraphicsitem_cast avec this item.
        return Type;
    }
    ...
 };

Voir aussi UserType.

void QGraphicsItem::ungrabKeyboard ()

L'élément abandonne les entrées clavier.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi grabKeyboard() et ungrabMouse().

void QGraphicsItem::ungrabMouse ()

L'élément abandonne la réception des événements souris.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi grabMouse() et ungrabKeyboard().

void QGraphicsItem::unsetCursor ()

Réinitialise le pointeur de cet élément.

Voir aussi hasCursor() et setCursor().

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

Envoie une demande de mise à jour de la zone de l'élément couverte par rect. 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 de dessin immédiat ; elle enregistre une demande de dessin qui sera traitée par QGraphicsView lorsque la boucle d'événements aura repris la main. L'élément sera seulement redessiné s'il est visible dans une vue associée.

Un effet secondaire du fait que l'élément soit redessiné est que d'autres éléments ayant une partie commune avec la zone rect devront éventuellement aussi être redessinés.

Si l'élément est invisible (c'est-à-dire que isVisible() renvoie faux), cette fonction ne fait rien.

Voir aussi paint() et boundingRect().

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

Il s'agit d'une fonction surchargée.

Cette fonction est équivalente à l'appel de update(QRectF(x, y, width, height)).

void QGraphicsItem::updateMicroFocus () [protected]

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

Cette fonction a été introduite dans Qt 4.7.

Voir aussi QInputContext.

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

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

Si vous ignorez l'événement (en appelant QEvent::ignore()), event se propagera aux éléments du dessous. 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 aussi sceneEvent().

QGraphicsWidget * QGraphicsItem::window () const

Renvoie la fenêtre de l'élément ou 0 si cet élément n'a pas de fenêtre. Si l'élément est une fenêtre, il se renverra lui-même, sinon il renverra la fenêtre la plus proche parmi ses ancêtres.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi QGraphicsWidget::isWindow().

qreal QGraphicsItem::x () const

Cette fonction est équivalente à l'appel de pos().x().

Voir aussi setX() et y().

qreal QGraphicsItem::y () const

Cette fonction est équivalente à l'appel de pos().y().

Voir aussi setY() et x().

qreal QGraphicsItem::zValue () const

Renvoie la valeur Z de l'élément. La valeur Z décide de l'ordre d'empilement des éléments voisins de même niveau (même parent ou sans parent).

La valeur Z par défaut est 0.

Voir aussi setZValeur(), Sorting, stackBefore() et ItemStacksBehindParent.

Variables membres

const int QGraphicsItem::Type

La valeur de type renvoyée par la fonction type() dans les classes d'éléments graphiques standard de Qt. Toutes ces classes d'éléments graphiques standard de Qt sont associées à une valeur unique de Type, par exemple la valeur renvoyée par QGraphicsPathItem::type() est 2.

 class QGraphicsPathItem : public QAbstractGraphicsShapeItem
 {
  public:
   enum { Type = 2 };
     int type() const { return Type; }
   ...
 };

const int QGraphicsItem::UserType

La plus petite valeur de type autorisée pour les classes d'éléments personnalisés (classes dérivées de QGraphicsItem ou d'autres classes d'éléments standard). Cette valeur est utilisée en conjonction avec une réimplémentation de QGraphicsItem::type() et la déclaration d'une valeur d'énumération Type. Exemple :

 class CustomItem : public QGraphicsItem
 {
    ...
    enum { Type = UserType + 1 };
 
    int type() const
    {
        // Enable the use of qgraphicsitem_cast with this item.
        return Type;
    }
    ...
 };

Note : UserType vaut 65536.

Non-membres

T qgraphicsitem_cast ( QGraphicsItem * item )

Renvoie item converti vers le type T si item est de type T ; sinon, renvoie 0.

Note : pour que cette fonction traite correctement les éléments personnalisés, réimplémentez la fonction type() pour chaque classe dérivée de QGraphicsItem.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi QGraphicsItem::type() et QGraphicsItem::UserType.

Remerciements

Merci à Ilya Diallo pour la traduction et à Thibaut Cuvelier, Jonathan Courtois ainsi qu'à Jacques Thery pour leur relecture !