QGraphicsScene

La classe QGraphicsScene fournit une surface pour gérer un grand nombre d'éléments graphiques 2D. Plus d'informations...

#include <QGraphicsScene>

Voir la position dans l'arbre des classes.

Héritage

Hérite de QObject.

Cette classe a été introduite dans Qt 4.2.

Description détaillée

La classe QGraphicsScene fournit une surface pour gérer un grand nombre d'éléments graphiques 2D.

La classe sert de contenant pour les QGraphicsItems. Elle est utilisée en combinaison avec QGraphicsView pour la visualisation graphique d'éléments tels que des lignes, des rectangles, du texte ou même des éléments personnalisés sur une surface 2D. QGraphicsScene fait partie du framework de la vue graphique.

De plus, QGraphicsScene fournit des fonctionnalités qui vous permettent de déterminer efficacement la position des éléments et leur visibilité à l'intérieur d'une zone arbitraire de la scène. Avec le widget QGraphicsView, vous pouvez visualiser la scène entière ou même zoomer à l'intérieur et voir une seule partie de la scène.

Exemple:

 QGraphicsScene scene;
scene.addText("Hello, world!");
 
QGraphicsView view(&scene);
view.show();

Notez que QGraphicsScene n'a pas d'apparence en soit, elle ne fait que gérer des éléments. Vous devez créer un widget QGraphicsView pour visualiser la scène.

Pour ajouter des éléments à la scène, vous commencez par construire un objet QGraphicsScene. Ensuite, vous avez deux options : soit ajouter vos objets QGraphicsItem existants en appelant addItem() ou vous pouvez appeler une des fonctions utilitaires addEllipse(), addLine(), addPath(), addPixmap(), addPolygon(), addRect() ou addText(), qui retournent toutes un pointeur sur le nouvel élément ajouté. Les dimensions des éléments ajoutés avec ces fonctions sont relatives au système de coordonnées de l'élément et la position des éléments est initialisé à (0, 0) dans la scène.

Vous pouvez ensuite visualiser la scène en utilisant QGraphicsView. Quand la scène change (par exemple, quand un élément est déplacé ou transformé) QGraphicsScene émets le signal changed(). Pour retirer un élément, appelez removeItem().

QGraphicsScene utilise un algorithme d'indexation afin de gérer efficacement la position des éléments. Par défaut, un arbre BSP (Binary Space Partitioning) est utilisé, un algorithme adapté pour les grandes scènes où la plupart des éléments restent statiques (c'est-à-dire, ne se déplacent pas). Vous pouvez choisir de désactiver cet index en appelant setItemIndexMethod(). Pour plus d'informations sur les algorithmes d'indexation disponibles, voir la propriété itemIndexMethod.

Le rectangle frontière de la scène est défini en appelant setSceneRect(). Les éléments peuvent être placés à n'importe quelle position sur la scène et la taille de la scène est, par défaut, sans limite. Le rectangle de la scène est uniquement utilisé pour un référencement interne, maintenant l'index de l'élément de la scène. Si le rectangle de la scène n'est pas défini, QGraphicsScene utilisera la zone frontière de tous les éléments, tels que retournés par itemsBoundingRect() en tant que rectangle frontière de la scène. Cependant, itemsBoundingRect() est une fonction qui peut prendre du temps puisqu'elle collecte des informations sur la position de chaque élément de la scène. Pour cette raison, vous devriez toujours définir le rectangle de la scène lorsque vous travaillez avec de grandes scènes.

L'une des plus grandes forces de QGraphicsScene est son habilité à déterminer efficacement la position des éléments. Même avec des millions d'éléments sur la scène, la fonction items() peut déterminer la position d'un élément en quelques millisecondes. Il existe plusieurs surcharges à items() : une qui trouve les éléments à une certaine position, une qui trouve les éléments contenus partiellement ou entièrement dans un polygone ou un rectangle et bien d'autres. La liste des éléments retournés est triée dans l'ordre de la pile, avec le plus haut élément le premier dans la liste. Pour plus de simplicité, il y a également une fonction itemAt() qui retourne le plus haut élément à une position donnée.

QGraphicsScene maintient l'information de sélection de la scène. Pour sélectionner des éléments, appelez setSelectionArea() et pour vider la sélection courante, appelez clearSelection(). Appelez selectedItems() pour obtenir la liste de tous les éléments sélectionnés.

Gestion d'événements et propagation

Une autre responsabilité de QGraphicsScene, c'est de propager les événements venant de QGraphicsView. Pour envoyer un événement à la scène, construisez un événement qui hérite de QEvent et ensuite envoyez-le en utilisant par exemple QApplication::sendEvent(). event() est responsable de la propagation d'événements aux éléments individuels. Certains éléments communs sont gérés par le gestionnaire d'événements. Par exemple, les événements de touche de clavier sont gérés par keyPressEvent() et les événements de souris sont gérés par mousePressEvent().

Les événements de clavier sont délivrés à l'élément qui a le focus. Pour définir l'élément qui a le focus, vous pouvez soit appeler setFocusItem(), soit passer un élément qui accepte le focus ou l'élément lui-même peut appeler QGraphicsItem::setFocus(). Appelez focusItem() pour récupérer l'élément qui a le focus. Pour des raisons de compatibilité avec les widgets, la scène maintient également sa propre information de focus. Par défaut, la scène n'a pas de focus et tous les événements de clavier sont ignorés. Si setFocus() est appelé ou si un élément sur la scène gagne le focus, la scène gagne automatiquement le focus. Si la scène a le focus, hasFocus() retournera true et les événements de clavier seront transférés à l'élément qui a le focus s'il existe. Si la scène perd le focus,(c'est-à-dire, que quelqu'un appelle clearFocus()) alors qu'un élément a le focus, la scène se rappellera de l'information de focus de cet élément et lorsque la scène regagnera le focus, elle s'assurera que le dernier élément qui a eu le focus le récupère.

Pour les effets de survol, QGraphicsScene propage les hover events. Si un élément accepte les événements de survol (voir QGraphicsItem::acceptHoverEvents()), il recevra un événement GraphicsSceneHoverEnter quand la souris entre dans la zone. Lors du déplacement de la souris à l'intérieur de la zone de l'élément, QGraphicsScene enverra des événements GraphicsSceneHoverMove. Quand la souris quitte la zone de l'élément, l'élément recevra un événement GraphicsSceneHoverLeave.

Tous les événements de souris sont délivrés à l'élément courant qui capture la souris (mouse grabber). Un élément devient capteur de la souris pour la scène s'il accepte les événements de souris (voir QGraphicsItem::acceptedMouseButtons()) et qu'il reçoit une pression de souris (mouse press). Il restera le capteur de la souris jusqu'à ce qu'il reçoive un relâchement de la souris lorsqu'aucun autre bouton de la souris n'est pressé. Vous pouvez appeler mouseGrabberItem() pour déterminer quel élément capte actuellement la souris.

Voir aussi QGraphicsItem et QGraphicsView.

Type

enum QGraphicsScene::ItemIndexMethod

Cette enum décrit l'algorithme d'indexation que QGraphicsScene fournit pour gérer les informations de position des éléments dans la scène.

Voir aussi setItemIndexMethod() et bspTreeDepth.

enum QGraphicsScene::SceneLayerflags QGraphicsScene::SceneLayers

Cette enum décrit les couches de rendu dans un QGraphicsScene. Lorsque QGraphicsScene dessine le contenu de la scène, la classe dessine chacune de ces couches séparément, dans l'ordre.

Chaque couche représente un drapeau. Ils peuvent être combinés avec un OU logique lors de l'appel à des fonctions comme invalidate() ou QGraphicsView::invalidateScene().

Cette enum a été introduite ou modifiée dans Qt 4.3.

Le type SceneLayers est un typedef pour QFlags<SceneLayer>. Il contient une combinaison avec l'opérateur logique OU des valeurs de SceneLayer.

Voir aussi invalidate() et QGraphicsView::invalidateScene().

Propriétés

backgroundBrush : QBrush

Cette propriété contient la brosse pour l'arrière-plan de la scène.

Définissez cette propriété pour changer la couleur, le dégradé ou la texture de l'arrière-plan de la scène. La brosse pour l'arrière-plan par défaut est Qt::NoBrush. L'arrière-plan est dessiné avant (derrière) les éléments.

Exemple :

 QGraphicsScene scene;
 QGraphicsView view(&scene);
 view.show();
 
 // un arrière-plan bleu
 scene.setBackgroundBrush(Qt::blue);
 
 // un arrière-plan en dégradé
 QRadialGradient gradient(0, 0, 10);
 gradient.setSpread(QGradient::RepeatSpread);
 scene.setBackgroundBrush(gradient);

QGraphicsScene::render() appelle drawBackground() pour dessiner l'arrière-plan de la scène. Pour un contrôle plus précis de la façon dont l'arrière-plan est dessiné, vous pouvez réimplémenter drawBackground() dans une sous-classe de QGraphicsScene.

Fonctions d'accès

QBrush backgroundBrush () const

void setBackgroundBrush ( const QBrush & brush )

bspTreeDepth : int

La propriété contient la profondeur de l'arbre BSP d'indexation de la QGraphicsScene.

La propriété n'a aucun effet lorsque NoIndex est défini.

Cette valeur détermine la profondeur de l'arbre BSP de la QGraphicsScene. La profondeur affecte directement avec les performances et l'utilisation mémoire de la QGraphicsScene ; ce dernier grossissant exponentiellement avec la profondeur de l'arbre. Avec une profondeur d'arbre optimale, QGraphicsScene peut déterminer instantanément l'emplacement des éléments, même pour les scènes contenant des milliers ou des millions d'éléments. Cela améliore aussi les performances de rendu.

Par défaut, la valeur est 0, ce qui laisse Qt deviner une raisonnable profondeur selon la taille, l'emplacement et le nombre d'éléments dans la scène. Si ces paramètres changent souvent, alors, vous pouvez ressentir un ralentissement comme la QGraphicsScene va redéfinir la profondeur fréquemment. Vous pouvez éviter ce ralentissement potentiel en définissant une profondeur de l'arbre fixe avec cette propriété.

La profondeur de l'arbre et la taille du rectangle de la scène déterminent la granularité du partitionnement de la scène. La taille de chaque segment de la scène est déterminée par l'algorithme suivant :

 QSizeF segmentSize = sceneRect().size() / pow(2, depth - 1);

L'arbre BSP a une taille optimale où chaque segment contient entre 0 et 10 éléments.

Cette propriété a été introduite dans Qt 4.3.

Fonctions d'accès

int bspTreeDepth () const

void setBspTreeDepth ( int depth )

Voir aussi itemIndexMethod.

font : QFont

La propriété contient la police par défaut de la scène.

Cette propriété fournit la police de la scène. La police de la scène se rapporte à QApplication::font.

Si la police de la scène change, soit par le biais de setFont() soit indirectement lorsque la police de l'application change, QGraphicsScene envoie d'abord un événement FontChange pour lui-même puis envoie un événement FontChange à tous les widgets supérieurs dans la scène. Ces éléments répondent en redéfinissant leur propre police à celle de la scène et notifient ensuite à leurs enfants, qui vont aussi notifier à leurs enfants et ainsi de suite jusqu'à ce que tous les éléments aient mis à jour leur police.

Le changement de la police de la scène (directement ou indirectement avec QApplication::setFont()) planifie automatiquement un réaffichage de la scène entière.

Cette propriété a été introduite dans Qt 4.4.

Fonctions d'accès

QFont font () const

void setFont ( const QFont & font )

Voir aussi QWidget::font, QApplication::setFont(), palette et style().

foregroundBrush : QBrush

La propriété contient la brosse pour le premier plan de la scène.

Changez cette propriété pour définir la couleur, le dégradé ou la texture du premier plan de la scène.

Le premier plan est dessiné après (au-dessus) les éléments. La brosse pour le premier plan par défaut est Qt::NoBrush (c'est-à-dire : le premier n'est pas dessiné).

Exemple :

 QGraphicsScene scene;
 QGraphicsView view(&scene);
 view.show();
 
 // un premier plan blanc semi-transparent
 scene.setForegroundBrush(QColor(255, 255, 255, 127));
 
 // un premier plan grille
 scene.setForegroundBrush(QBrush(Qt::lightGray, Qt::CrossPattern));

QGraphicsScene::render() appelle drawForeground() pour dessiner le premier plan de la scène. Pour avoir un contrôle plus précis de la façon dont le premier plan est dessiné, vous pouvez réimplémenter la fonction drawForeground() dans une sous-classe de QGraphicsScene.

Fonctions d'accès

QBrush foregroundBrush () const

void setForegroundBrush ( const QBrush & brush )

itemIndexMethod : ItemIndexMethod

La propriété contient la méthode d'indexation des éléments.

QGraphicsScene applique un algorithme d'indexation à la scène afin d'accélérer les fonctions de découverte des éléments telles que items() et itemAt(). L'indexation est plus efficace pour les scènes statiques (c'est-à-dire : là où les éléments ne bougent pas). Pour les scènes dynamiques ou les scènes avec plusieurs éléments animés, l'indexation peut dépasser la vitesse des accès rapides.

Dans la plupart des cas, la méthode d'indexation par défaut BspTreeIndex suffit. Si votre scène utilise des animations et que vous constatez des ralentissements, vous pouvez désactiver l'indexation en appelant setItemIndexMethod(NoIndex).

Fonctions d'accès

ItemIndexMethod itemIndexMethod () const

void setItemIndexMethod ( ItemIndexMethod method )

Voir aussi bspTreeDepth.

palette : QPalette

La propriété contient la palette par défaut de la scène.

La propriété contient la palette par défaut de la scène. La palette de la scène se rapporte à QApplication::palette.

Si la palette de la scène est modifiée, soit directement par setPalette() soit indirectement lorsque la palette de l'application est modifiée, QGraphicsScene envoie d'abord un événement PaletteChange pour lui-même et envoie ensuite un événement PaletteChange à tous les widgets supérieurs dans la scène. Ces éléments répondent en redéfinissant leur propre palette à celle de la scène et notifient alors à leurs enfants, qui à leur tour notifieront aux leurs et ainsi de suite, jusqu'à que tous les éléments aient eu leur palette mise à jour.

Le changement de la palette de la scène, (directement ou indirectement avec QApplication::setPalette()) planifie automatique un réaffichage de la scène entière.

Cette propriété a été introduite dans Qt 4.4.

Fonctions d'accès

QPalette palette () const

void setPalette ( const QPalette & palette )

Voir aussi QWidget::palette, QApplication::setPalette(), font et style().

sceneRect : QRectF

Cette propriété contient le rectangle de la scène ; le rectangle limitant la scène.

Le rectangle de la scène définit l'extension de la scène. Il est utilisé principalement par QGraphicsView pour déterminer la zone de défilement de la vue et par QGraphicsScene pour gérer l'indexation des éléments.

Si la propriété n'est pas définie ou définie à un QRectF NULL, sceneRect() va retourner le rectangle contenant tous les éléments de la scène depuis que la scène a été créée (c'est-à-dire : un rectangle qui grossit lorsque les éléments sont ajoutés ou déplacés mais qui ne se réduit jamais).

Fonctions d'accès

QRectF sceneRect () const

void setSceneRect ( const QRectF & rect )

void setSceneRect ( qreal x, qreal y, qreal w, qreal h )

Voir aussi width(), height() et QGraphicsView::sceneRect.

stickyFocus : bool

La propriété contient si un clic dans l'arrière-plan de la scène va effacer le focus, ou non.

Dans une QGraphicsScene avec stickyFocus défini à true, le focus ne va pas changer lorsque l'utilisateur clique dans l'arrière-plan de la scène ou sur un élément qui n'accepte pas le focus. Sinon, le focus va être effacé.

Par défaut, cette propriété est définie à false.

Le focus change en réponse à un appui sur la souris. Vous pouvez réimplémenter mousePressEvent() dans une sous-classe de QGraphicsScene pour activer cette propriété selon l'emplacement du clic de l'utilisateur.

Cette propriété a été introduite dans Qt 4.6.

Fonctions d'accès

bool stickyFocus () const

void setStickyFocus ( bool enabled )

Voir aussi clearFocus() et setFocusItem().

Fonctions membres

QGraphicsScene::QGraphicsScene ( QObject * parent = 0 )

Construit un objet QGraphicsScene. Le paramètre parent est passé au constructeur de QObject.

QGraphicsScene::QGraphicsScene ( const QRectF & sceneRect, QObject * parent = 0 )

Construit un objet QGraphicsScene, utilisant sceneRect comme rectangle de scène. Le paramètre parent est passé au constructeur de QObject.

Voir aussi sceneRect.

QGraphicsScene::QGraphicsScene ( qreal x, qreal y, qreal width, qreal height, QObject * parent = 0 )

Construit un objet QGraphicsScene, utilisant le rectangle spécifié par (x, y) et la largeur width et hauteur height donné comme rectangle de scène. Le paramètre parent est passé au constructeur de QObject.

Voir aussi sceneRect.

QGraphicsScene::~QGraphicsScene () [virtual]

Enlève et supprime tous les éléments de la scène avant de détruire la scène. La scène est retirée de la liste globale de scène de l'application et est retirée de toutes les vues associées.

QGraphicsItem * QGraphicsScene::activePanel () const

Retourne le panel actuellement actif ou 0 si aucun panel n'est actif.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi QGraphicsScene::setActivePanel().

QGraphicsWidget * QGraphicsScene::activeWindow () const

Retourne la fenêtre actuellement active ou 0 si aucune fenêtre n'est active.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi QGraphicsScene::setActiveWindow().

QGraphicsEllipseItem * QGraphicsScene::addEllipse ( const QRectF & rect, const QPen & pen = QPen(), const QBrush & brush = QBrush() )

Crée et ajoute un élément ellipse à la scène et retourne un pointeur sur l'élément. La géométrie de l'ellipse est définie par rect. Le stylo et la brosse sont initialisés à pen et brush.

Notez que la géométrie de l'élément est fournie dans l'espace de coordonnées de l'élément et sa position est initialisée à (0, 0).

Si l'élément est visible (c'est-à-dire, QGraphicsItem::isVisible() retourne true), QGraphicsScene va envoyer changed() lorsque le control revient à la boucle événementielle.

Voir aussi addLine(), addPath(), addPixmap(), addRect(), addText(), addItem() et addWidget().

QGraphicsEllipseItem * QGraphicsScene::addEllipse ( qreal x, qreal y, qreal w, qreal h, const QPen & pen = QPen(), const QBrush & brush = QBrush() )

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

Cette fonction a été introduite dans Qt 4.3.

void QGraphicsScene::addItem ( QGraphicsItem * item )

Ajoute ou déplace l'élément et tous ses enfants dans la scène. La scène prend la propriété de l'élément item.

Si l'élément est visible (c'est-à-dire, QGraphicsItem::isVisible() retourne true), QGraphicsScene va émettre changed() une fois que le contrôle sera revenu à la boucle événementielle.

Si l'élément est déjà dans une scène différente, il va être d'abord enleveé de cette ancienne scène puis l'ajouté à cette scène au niveau supérieur.

QGraphicsScene va envoyer une notification ItemSceneChange à l'élément item lors de l'ajout à la scène. Si l'élément n'appartient actuellement à aucune scène, seulement une notification est envoyée. S'il appartient déjà à une scène (c'est-à-dire, s'il est déplacé dans cette scène), QGraphicsScene va envoyer une notification additionnelle signalant que l'élément est enlevé de son ancienne scène.

Si l'élément est un panel, que la scène est active et qu'il n'y a pas de panel actif dans la scène, alors l'élément va être activé.

Voir aussi removeItem(), addEllipse(), addLine(), addPath(), addPixmap(), addRect(), addText(), addWidget() et Sorting.

QGraphicsLineItem * QGraphicsScene::addLine ( const QLineF & line, const QPen & pen = QPen() )

Crée et ajoute un élément ligne dans la scène et retourne un pointeur sur l'élément. La géométrie de la ligne est définie par line et son stylo est initialisé à pen.

Notez que la géométrie de l'élément est fournie dans l'espace de coordonnées de l'élément et sa position est initialisée à (0, 0).

Si l'élément est visible (c'est-à-dire : QGraphicsItem::isVisible() retourne true), QGraphicsScene va émettre changed() une fois que le contrôle sera revenu à la boucle événementielle.

Voir aussi addEllipse(), addPath(), addPixmap(), addRect(), addText(), addItem() et addWidget().

QGraphicsLineItem * QGraphicsScene::addLine ( qreal x1, qreal y1, qreal x2, qreal y2, const QPen & pen = QPen() )

Cette fonction de commodité équivaut à appeler addLine(QLineF(x1, y1, x2, y2), pen).

Cette fonction a été introduite dans Qt 4.3.

QGraphicsPathItem * QGraphicsScene::addPath ( const QPainterPath & path, const QPen & pen = QPen(), const QBrush & brush = QBrush() )

Crée et ajoute un élément chemin dans la scène et retourne un pointeur sur l'élément. La géométrie est définie par path et son stylo et brosse sont initialisés à pen et brush.

Notez que la géométrie de l'élément est fournie dans l'espace de coordonnées de l'élément et sa position est initialisée à (0, 0).

Si l'élément est visible (c'est-à-dire : QGraphicsItem::isVisible() retourne true), QGraphicsScene va émettre changed() une fois que le contrôle sera revenu à la boucle événementielle.

Voir aussi addEllipse(), addLine(), addPixmap(), addRect(), addText(), addItem() et addWidget().

QGraphicsPixmapItem * QGraphicsScene::addPixmap ( const QPixmap & pixmap )

Crée et ajoute un élément pixmap à la scène et retourne un pointeur sur l'élément. Le pixmap est défini par pixmap.

Si l'élément est visible (c'est-à-dire : QGraphicsItem::isVisible() retourne true), QGraphicsScene va émettre changed() une fois que le contrôle sera revenu à la boucle événementielle.

Voir aussi addEllipse(), addLine(), addPath(), addRect(), addText(), addItem() et addWidget().

QGraphicsPolygonItem * QGraphicsScene::addPolygon ( const QPolygonF & polygon, const QPen & pen = QPen(), const QBrush & brush = QBrush() )

Crée et ajoute un élément polygone à la scène et retourne un pointeur sur l'élément. Le polygone est défini par polygon et son stylo et brosse sont initialisés à pen et brush.

Notez que la géométrie de l'élément est fournie dans l'espace de coordonnées de l'élément et sa position est initialisée à (0, 0).

Si l'élément est visible (c'est-à-dire : QGraphicsItem::isVisible() retourne true), QGraphicsScene va émettre changed() une fois que le contrôle sera revenu à la boucle événementielle.

Voir aussi addEllipse(), addLine(), addPath(), addRect(), addText(), addItem() et addWidget().

QGraphicsRectItem * QGraphicsScene::addRect ( const QRectF & rect, const QPen & pen = QPen(), const QBrush & brush = QBrush() )

Crée et ajoute un élément rectangle à la scène et retourne un pointeur sur l'élément. La géométrie du rectangle est définie par rect et ses stylo et brosse sont initialisés à pen et brush.

Notez que la géométrie de l'élément est fournie dans l'espace de coordonnées de l'élément et sa position est initialisée à (0, 0). Par exemple, si un QRect(50, 50, 100, 100) est ajouté, son coin supérieur gauche sera à (50, 50) relativement à l'origine du système de coordonnées des éléments.

Si l'élément est visible (c'est-à-dire : QGraphicsItem::isVisible() retourne true), QGraphicsScene va émettre changed() une fois que le contrôle sera revenu à la boucle événementielle.

Voir aussi addEllipse(), addLine(), addPixmap(), addPixmap(), addText(), addItem() et addWidget().

QGraphicsRectItem * QGraphicsScene::addRect ( qreal x, qreal y, qreal w, qreal h, const QPen & pen = QPen(), const QBrush & brush = QBrush() )

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

Cette fonction a été introduite dans Qt 4.3.

QGraphicsSimpleTextItem * QGraphicsScene::addSimpleText ( const QString & text, const QFont & font = QFont() )

Crée et ajoute un QGraphicsSimpleTextItem à la scène et retourne le pointeur sur l'élément. La chaine de caractères du texte est initialisée à text et sa police de caractères à font.

La position de l'élément est initialisée à (0, 0).

Si l'élément est visible (c'est-à-dire : QGraphicsItem::isVisible() retourne true), QGraphicsScene va émettre changed() une fois que le contrôle retourne à la boucle événementielle.

Voir aussi addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addItem() et addWidget().

QGraphicsTextItem * QGraphicsScene::addText ( const QString & text, const QFont & font = QFont() )

Crée et ajoute un élément texte dans la scène et retourne le pointeur de l'élément. La chaine de caractères du texte est initialisée au texte text et sa police de caractères à font.

La position de l'élément est initialisée à (0, 0).

Si l'élément est visible (c'est-à-dire : QGraphicsItem::isVisible() retourne true), QGraphicsScene va émettre changed() une fois que le contrôle retourne à la boucle événementielle.

Voir aussi addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addItem() et addWidget().

QGraphicsProxyWidget * QGraphicsScene::addWidget ( QWidget * widget, Qt::WindowFlags wFlags = 0 )

Crée un nouveau QGraphicsProxyWidget pour widget, l'ajoute dans la scène et retourne un pointeur sur le proxy. wFlags définit les indicateurs par défaut de la fenêtre pour le proxy embarquant le widget.

La position de l'élément est initialisée à (0, 0).

Si l'élément est visible (c'est-à-dire : QGraphicsItem::isVisible() retourne true), QGraphicsScene va émettre changed() une fois que le contrôle retourne à la boucle événementielle.

Notez que les widgets avec l'attribut Qt::WA_PaintOnScreen défini et ceux qui embarquent une application externe ou un contrôleur ne sont pas supportés. Les exemples sont QGLWidget et QAxWidget.

Voir aussi addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addText(), addSimpleText() et addItem().

void QGraphicsScene::advance () [slot]

Ce slot avance la scène d'une étape, en appelant QGraphicsItem::advance() pour tous les éléments de la scène. Cela est effectué en deux étapes, la première, tous les éléments sont notifiés que la scène va changer, ensuite tous les éléments sont notifiés qu'ils peuvent se déplacer. Dans la première étape, QGraphicsItem::advance() est appelé en passant une valeur de 0 comme argument et 1 est passé durant la deuxième étape.

Voir aussi QGraphicsItem::advance(), QGraphicsItemAnimation et QTimeLine.

void QGraphicsScene::changed ( const QList<QRectF> & region ) [signal]

Ce signal est émis par QGraphicsScene lorsque le contrôle atteint la boucle événementielle, si le contenu de la scène a changé. Le paramètre region contient une liste des rectangles de la scène qui indique les zones qui doivent être changées.

Voir aussi QGraphicsView::updateScene().

void QGraphicsScene::clear () [slot]

Enlève et détruit tous les éléments de la scène mais laisse l'état de la scène inchangé.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi addItem().

void QGraphicsScene::clearFocus ()

Enlève le focus de la scène. Si un élément a le focus lors de l'appel de cette fonction, il va perdre le focus et le regagner lorsque la scène regagnera le focus.

Une scène qui n'a pas le focus ignore les événements de touches.

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

void QGraphicsScene::clearSelection () [slot]

Enlève la sélection courante.

Voir aussi setSelectionArea() et selectedItems().

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

Retourne une liste de tous les éléments qui sont en collision avec item. Les collisions sont déterminées en appelant QGraphicsItem::collidesWithItem(); la détection de collision est déterminée par le mode. Par défaut, tous les éléments dont la forme intersectionne l'élément item ou qui sont contenus dans la forme de l'élément item sont retournés.

Les éléments sont retournés dans l'ordre d'empilement décroissant (c'est-à-dire : le premier élément dans la liste est l'élément le plus haut et le dernier élément est l'élément le plus bas).

Voir aussi items(), itemAt(), QGraphicsItem::collidesWithItem() et Sorting.

void QGraphicsScene::contextMenuEvent ( QGraphicsSceneContextMenuEvent * contextMenuEvent ) [virtual protected]

Ce gestionnaire d'événements, pour l'événement contextMenuEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements du menu contextuel. L'implémentation par défaut transfère l'événement à l'élément le plus haut qui accepte les événements de menu contextuel pour la position de l'événement. Si aucun élément n'accepte les événements de menu contextuel pour cette position, l'événement est ignoré.

Voir aussi QGraphicsItem::contextMenuEvent().

QGraphicsItemGroup * QGraphicsScene::createItemGroup ( const QList<QGraphicsItem *> & items )

Groupe tous les éléments dans items dans un nouveau QGraphicsItemGroup et retourne un pointeur sur ce groupe. Le groupe est créé avec l'ancêtre commun des éléments items comme leur parent et avec la position (0, 0). Les éléments reçoivent tous comme nouveau parent le groupe et leur position et transformation sont converties au groupe. Si items est vide, la fonction va retourner un QGraphicsItemGroup supérieur vide.

QGraphicsScene a la propriété de l'élément groupe ; vous n'avez pas à le détruire. Pour démanteler (dégrouper) un groupe, appelez destroyItemGroup().

Voir aussi destroyItemGroup() et QGraphicsItemGroup::addToGroup().

void QGraphicsScene::destroyItemGroup ( QGraphicsItemGroup * group )

Change le parent de tous les éléments dans le groupe group pour l'élément parent du groupe group, puis retire group de la scène et le détruit. Les positions des éléments et les transformations sont converties du groupe au parent du groupe.

Voir aussi createItemGroup() et QGraphicsItemGroup::removeFromGroup().

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté dans une sous-classe pour recevoir les événements d'entrées lors d'un glisser/déposer pour la scène.

L'implémentation par défaut accepte l'événement et prépare la scène à accepter les événements de glissements.

Voir aussi QGraphicsItem::dragEnterEvent(), dragMoveEvent(), dragLeaveEvent() et dropEvent().

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté dans une sous-classe pour recevoir les événements de départ lors d'un glisser/déposer pour la scène.

Voir aussi QGraphicsItem::dragLeaveEvent(), dragEnterEvent(), dragMoveEvent() et dropEvent().

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté dans une sous-classe pour recevoir les événements de glissement lors d'un glisser/déposer pour la scène.

Voir aussi QGraphicsItem::dragMoveEvent(), dragEnterEvent(), dragLeaveEvent() et dropEvent().

void QGraphicsScene::drawBackground ( QPainter * painter, const QRectF & rect ) [virtual protected]

Dessine le premier plan de la scène painter, avant que les éléments et le premier plan n'aient été dessinés. Réimplémentez cette fonction pour fournir un arrière-plan personnalisé à la scène.

Tous les dessins sont effectués dans l'espace de coordonnées de la scène scene. Le paramètre rect est le rectangle affiché.

Si vous voulez seulement définir une couleur, une texture ou un dégradé pour l'arrière-plan, vous pouvez appeler setBackgroundBrush() à la place.

Voir aussi drawForeground() et drawItems().

void QGraphicsScene::drawForeground ( QPainter * painter, const QRectF & rect ) [virtual protected]

Dessine le premier plan de la scène en utilisant painter, après que l'arrière-plan et que tous les éléments aient été dessinés. Réimplémentez cette fonction pour fournir un premier plan personnalisé à la scène.

Tous les dessins sont effectués dans l'espace de coordonnées de la scène scene. Le paramètre rect est le rectangle affiché.

Si vous voulez seulement définir une couleur, texture ou un dégradé pour le premier plan, vous pouvez appeler setForegroundBrush() à la place.

Voir aussi drawBackground() et drawItems().

void QGraphicsScene::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épôts lors d'un glisser/déposer pour la scène.

Voir aussi QGraphicsItem::dropEvent(), dragEnterEvent(), dragMoveEvent() et dragLeaveEvent().

bool QGraphicsScene::event ( QEvent * event ) [virtual protected]

Reimplémentation de QObject::event().

Exécute l'événement event et le répartit aux gestionnaires d'événements respectifs.

En plus d'appeler le gestionnaire d'événements adéquat, cette fonction est responsable de la conversion des événements de souris en événements de survol lorsqu'il n'y a pas d'élément capturant la souris. Les événements de survol sont livrés directement aux éléments ; il n'y a pas de fonction de commodité pour eux.

Contrairement à QWidget, QGraphicsScene n'a pas les fonctions de commodité enterEvent() et leaveEvent(). Utilisez, à la place, cette fonction pour obtenir ces événements.

Voir aussi contextMenuEvent(), keyPressEvent(), keyReleaseEvent(), mousePressEvent(), mouseMoveEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), focusInEvent() et focusOutEvent().

bool QGraphicsScene::eventFilter ( QObject * watched, QEvent * event ) [virtual protected]

Reimplémentation de QObject::eventFilter().

QGraphicsScene filtre les événements de QApplication pour détecter les changements de palette et de police de caractères.

void QGraphicsScene::focusInEvent ( QFocusEvent * focusEvent ) [virtual protected]

Ce gestionnaire d'événements, pour l'événement focusEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements de gain de focus.

L'implémentation par défaut définit le focus sur la scène puis sur le dernier élément ayant eu le focus.

Voir aussi QGraphicsItem::focusOutEvent().

QGraphicsItem * QGraphicsScene::focusItem () const

Lorsque la scène est active, cette fonction retourne l'élément de la scène ayant actuellement le focus ou 0 s'il n'y a pas d'élément avec le focus. Lorsque la scène est inactive, cette fonction retourne l'élément qui va avoir le focus lorsque la scène redeviendra active.

L'élément ayant le focus reçoit les entrées du clavier lorsque la scène reçoit un événement de touche.

Voir aussi setFocusItem(), QGraphicsItem::hasFocus() et isActive().

bool QGraphicsScene::focusNextPrevChild ( bool next ) [protected slot]

Trouve un nouveau widget à qui donner le focus, tel que la fonction de Tab et Shift+Tab et retourne true si la fonction peut trouver un nouveau widget ou false sinon. Si next est true, cette fonction cherche en avant ; si next est false, la recherche est en arrière.

Vous pouvez réimplémenter cette fonction dans une sous-classe de QGraphicsScene pour fournir un contrôle méticuleux de la façon dont le focus par tabulation est passé dans votre scène. L'implémentation par défaut est basée sur la chaine de focus de tabulation définie par QGraphicsWidget::setTabOrder().

Cette fonction a été introduite dans Qt 4.4.

void QGraphicsScene::focusOutEvent ( QFocusEvent * focusEvent ) [virtual protected]

Ce gestionnaire d'événements, pour l'événement focusEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements de perte de focus.

L'implémentation par défaut retire le focus de l'élément ayant le focus, puis retire le focus de la scène.

Voir aussi QGraphicsItem::focusInEvent().

bool QGraphicsScene::hasFocus () const

Retourne true si la scène a le focus ; sinon retourne false. Si la scène a le focus, elle va transférer les événements de touche de QKeyEvent à l'élément possédant le focus.

Voir aussi setFocus() et setFocusItem().

qreal QGraphicsScene::height () const

Cette fonction de commodité équivaut à appeler sceneRect().height().

Voir aussi width().

void QGraphicsScene::helpEvent ( QGraphicsSceneHelpEvent * helpEvent ) [virtual protected]

Ce gestionnaire d'événements, pour l'événement helpEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements d'aide. Les événements sont du type QEvent::ToolTip, qui sont créés lorsqu'une infobulle est demandée.

L'implémentation par défaut affiche l'infobulle de l'élément le plus haut, c'est-à-dire, l'élément avec la plus haute valeur z, à la position de la souris. Si aucun élément n'a d'infobulle de définie, la fonction ne fait rien.

Voir aussi QGraphicsItem::toolTip() et QGraphicsSceneHelpEvent.

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

Ce gestionnaire d'événements, pour l'événement event, peut être réimplémenté dans une sous-classe pour recevoir les événements de méthodes d'entrées pour la scène.

L'implémentation par défaut transfère l'événement à focusItem(). Si aucun élément n'a le focus ou si l'élément actuellement sous le focus n'accepte pas les méthodes d'entrées, la fonction ne fait rien.

Voir aussi QGraphicsItem::inputMethodEvent().

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

Cette méthode est utilisée par les méthodes d'entrées pour demander une liste de propriétés à la scène afin d'être capable de supporter de complexes opérations de méthodes d'entrée telles que le support pour l'encadrement de texte ou les reconversions.

Le paramètre query spécifie quelle propriété doit être demandée.

Voir aussi QWidget::inputMethodQuery().

void QGraphicsScene::invalidate ( const QRectF & rect = QRectF(), SceneLayers layers = AllLayers ) [slot]

Invalide et planifie un réaffichage des couches layers dans rect de la scène. N'importe quel contenu mis en cache dans les couches layers est inconditionnellement invalidé et réaffiché.

Vous pouvez utiliser cette surcharge de fonction pour notifier à QGraphicsScene des changements sur l'arrière-plan ou sur le premier plan de la scène. La fonction est souvent utilisée pour les scènes possédant des arrière-plans basés sur un système de tuile pour notifier des changements lorsque QGraphicsView a activé CacheBackground.

Exemple :

 QRectF TileScene::rectForTile(int x, int y) const
 {
     // Retourne le rectangle pour la tuile à la position (x, y).
     return QRectF(x * tileWidth, y * tileHeight, tileWidth, tileHeight);
 }
 
 void TileScene::setTile(int x, int y, const QPixmap &pixmap)
 {
     // Définit ou remplace la tuile à la position (x, y) avec pixmap.
     if (x >= 0 && x < numTilesH && y >= 0 && y < numTilesV) {
         tiles[y][x] = pixmap;
         invalidate(rectForTile(x, y), BackgroundLayer);
     }
 }
 
 void TileScene::drawBackground(QPainter *painter, const QRectF &exposed)
 {
     // Dessine toutes les tuiles en intersection avec la zone exposée.
     for (int y = 0; y < numTilesV; ++y) {
         for (int x = 0; x < numTilesH; ++x) {
             QRectF rect = rectForTile(x, y);
             if (exposed.intersects(rect))
                 painter->drawPixmap(rect.topLeft(), tiles[y][x]);
         }
     }
 }

Notez que QGraphicsView supporte actuellement la mise en cache de l'arrière-plan seulement (voir QGraphicsView::CacheBackground). Cette fonction équivaut à appeler update() si toute autre couche que BackgroundLayer est passée.

Voir aussi QGraphicsView::resetCachedContent().

void QGraphicsScene::invalidate ( qreal x, qreal y, qreal w, qreal h, SceneLayers layers = AllLayers )

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

Cette fonction de commodité équivaut à appeler invalidate(QRectF(x, y, w, h), layers);

Cette fonction a été introduite dans Qt 4.3.

bool QGraphicsScene::isActive () const

Retourne true si la scène est active (par exemple : elle est affichée par au moins un QGraphicsView qui est actif) ; sinon retourne false.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi QGraphicsItem::isActive() et QWidget::isActiveWindow().

QGraphicsItem * QGraphicsScene::itemAt ( const QPointF & position, const QTransform & deviceTransform ) const

Retourne le plus haut élément visible à la position spécifiée ou 0 s'il n'y a pas d'éléments à cette position.

deviceTransform est la transformation qui s'applique à la vue et qui est nécessaire si la scène contient des éléments qui ignorent les transformations.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi items(), collidingItems() et Sorting.

QGraphicsItem * QGraphicsScene::itemAt ( qreal x, qreal y, const QTransform & deviceTransform ) const

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

Retourne le plus haut élément à la position spécifiée par (x, y) ou 0 s'il n'y a pas d'élément à cette position.

deviceTransform est la transformation qui s'applique à la vue et qui est nécessaire si la scène contient des éléments qui ignorent les transformations.

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

Cette fonction a été introduite dans Qt 4.6.

QList<QGraphicsItem *> QGraphicsScene::items () const

Retourne une liste de tous les éléments dans la scène dans un ordre d'empilement décroissant.

Voir aussi addItem(), removeItem() et Sorting.

QList<QGraphicsItem *> QGraphicsScene::items ( Qt::SortOrder order ) const

Retourne une liste ordonnée de tous les éléments de la scène. order décide de l'ordre d'empilement.

Voir aussi addItem(), removeItem() et Sorting.

QList<QGraphicsItem *> QGraphicsScene::items ( const QPointF & pos, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform & deviceTransform = QTransform() ) const

Retourne tous les éléments visibles qui, selon le mode, sont à la pos spécifiée, dans une liste triée selon order.

La valeur par défaut pour le mode est Qt::IntersectsItemShape ; tous les éléments qui entrent en intersection de par leur forme avec pos sont retournés.

deviceTransform est la transformation qui s'applique à la vue et qui est nécessaire si la scène contient des éléments qui ignorent les transformations.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi itemAt() et Sorting.

QList<QGraphicsItem *> QGraphicsScene::items ( qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform & deviceTransform = QTransform() ) const

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

Retourne tous les éléments visibles qui, selon le mode, sont dans, ou, en intersection avec le rectangle défini par x, y, w et h, dans une liste triée selon order.

deviceTransform est la transformation qui s'applique à la vue et qui est nécessaire si la scène contient des éléments qui ignorent les transformations.

Cette fonction a été introduite dans Qt 4.6.

QList<QGraphicsItem *> QGraphicsScene::items ( const QRectF & rect, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform & deviceTransform = QTransform() ) const

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

Retourne tous les éléments visibles qui, selon le mode, sont dans, ou, en intersection avec le rect et retourne une liste triée selon order.

La valeur par défaut pour le mode est Qt::IntersectsItemShape ; tous les éléments qui entrent en intersection de par leur forme exacte, ou qui sont contenus par rect sont retournés.

deviceTransform est la transformation qui s'applique à la vue et qui est nécessaire si la scène contient des éléments qui ignorent les transformations.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi itemAt() et Sorting.

QList<QGraphicsItem *> QGraphicsScene::items ( const QPolygonF & polygon, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform & deviceTransform = QTransform() ) const

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

Retourne tous les éléments visibles qui, selon le mode, sont dans, ou, en intersection avec le polygon spécifié et retourne la liste triée selon order.

La valeur par défaut pour le mode est Qt::IntersectsItemShape ; tous les éléments qui entrent en intersection de par leur forme exacte, ou qui sont contenus par polygon sont retournés.

deviceTransform est la transformation qui s'applique à la vue et qui est nécessaire si la scène contient des éléments qui ignorent les transformations.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi itemAt() et Sorting.

QList<QGraphicsItem *> QGraphicsScene::items ( const QPainterPath & path, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform & deviceTransform = QTransform() ) const

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

Retourne tous les éléments visibles qui, selon le mode, sont dans, ou, en intersection avec le path spécifié et retourne une liste triée selon order.

La valeur par défaut pour le mode est Qt::IntersectsItemShape ; tous les éléments qui entrent en intersection de par leur forme exacte, ou qui sont contenus par path sont retournés.

deviceTransform est la transformation qui s'applique à la vue et qui est nécessaire si la scène contient des éléments qui ignorent les transformations.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi itemAt() et Sorting.

QRectF QGraphicsScene::itemsBoundingRect () const

Calcule et retourne le rectangle limitant tous les éléments de la scène. Cette fonction parcourt tous les éléments et, à cause de cela, peut être lente pour les grandes scènes.

Voir aussi sceneRect().

void QGraphicsScene::keyPressEvent ( QKeyEvent * keyEvent ) [virtual protected]

Ce gestionnaire d'événements, pour l'événement keyEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements d'appui sur une touche du clavier. L'implémentation par défaut transfère l'événement à l'élément ayant le focus.

Voir aussi QGraphicsItem::keyPressEvent() et focusItem().

void QGraphicsScene::keyReleaseEvent ( QKeyEvent * keyEvent ) [virtual protected]

Ce gestionnaire d'événements, pour l'événement keyEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements de relâchement de touche du clavier. L'implémentation par défaut transfère l'événement à l'élément ayant le focus.

Voir aussi QGraphicsItem::keyReleaseEvent() et focusItem().

void QGraphicsScene::mouseDoubleClickEvent ( QGraphicsSceneMouseEvent * mouseEvent ) [virtual protected]

Ce gestionnaire d'événements, pour l'événement mouseEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements de double-clic pour la scène.

Si quelqu'un double-clique sur la scène, la scène va d'abord recevoir un événement de clic, suivi d'un événement de relâchement, ensuite, un événement de double-clic et finalement un événement de relâchement. Si l'événement de double-clic est délivré à un élément différent de celui qui a reçu le premier clic (et relâchement), l'événement va être livré comme un événement d'appui sur un bouton de la souris. Sinon, les événements de triple-clic ne sont pas livrés comme des événements de double-clic dans ce cas.

L'implémentation par défaut est similaire à mousePressEvent().

Voir aussi QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseMoveEvent(), QGraphicsItem::mouseReleaseEvent() et QGraphicsItem::setAcceptedMouseButtons().

QGraphicsItem * QGraphicsScene::mouseGrabberItem () const

Retourne l'élément capturant actuellement la souris ou 0 s'il n'y a pas d'élément capturant la souris. L'élément capturant la souris est l'élément qui reçoit tous les événements de souris envoyés à la scène.

Un élément devient un élément de capture lorsqu'il reçoit et accepte un événement de clic et le reste jusqu'à recevoir l'un de ces événements :

• si l'élément reçoit un événement de relâchement de la souris et qu'il n'y a plus d'autre bouton appuyé ;
• si l'élément devient invisible (c'est-à-dire : si quelqu'un appelle item->setVisible(false)) ou s'il devient désactivé (c'est-à-dire : si quelqu'un appelle item->setEnabled(false)) ;
• si l'élément est retiré de la scène.

Si l'élément perd la capture de la souris, la scène va ignorer tous les événements de souris jusqu'à ce qu'un nouvel élément capture la souris (c'est-à-dire : un élément recevant un événement de clic).

void QGraphicsScene::mouseMoveEvent ( QGraphicsSceneMouseEvent * mouseEvent ) [virtual protected]

Ce gestionnaire d'événements, pour l'événement mouseEvent, peut être réimplémenté dans une sous-classe afin de recevoir les événements de déplacement de la souris dans la scène.

L'implémentation par défaut dépend de l'état de capture de la souris. S'il y a un élément capturant la souris, l'événement est envoyé à celui-ci. S'il y a un quelconque élément qui accepte les événements de survol pour cette position, l'événement est converti en événement de survol puis accepté ; sinon il est ignoré.

Voir aussi QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseReleaseEvent(), QGraphicsItem::mouseDoubleClickEvent() et QGraphicsItem::setAcceptedMouseButtons().

void QGraphicsScene::mousePressEvent ( QGraphicsSceneMouseEvent * mouseEvent ) [virtual protected]

Ce gestionnaire d'événements, pour l'événement mouseEvent, peut être réimplémenté dans une sous-classe afin de recevoir les événements de clic de souris pour la scène.

L'implémentation par défaut dépend de l'état de la souris. S'il y a un élément capturant la souris, l'événement est envoyé à celui-ci. Sinon, il est transféré à l'élément supérieur qui accepte les événements de souris pour cette position d'événement dans la scène et cet élément devient immédiatement l'élément capturant la souris.

S'il n'y a pas d'élément à la position donnée sur la scène, la zone de sélection est réinitialisée, les éléments ayant le focus le perdent et l'événement est ignoré.

Voir aussi QGraphicsItem::mousePressEvent() et QGraphicsItem::setAcceptedMouseButtons().

void QGraphicsScene::mouseReleaseEvent ( QGraphicsSceneMouseEvent * mouseEvent ) [virtual protected]

Ce gestionnaire d'événements, pour l'événement mouseEvent, peut être réimplémenté dans une sous-classe afin de recevoir les événements de relâchement de clic de souris pour la scène.

L'implémentation par défaut dépend de l'état de capture de la souris. S'il n'y a pas de capture de souris, les événements sont ignorés. Sinon, s'il y a un élément capturant la souris, l'événement est envoyé à celui-ci. Si ce relâchement de la souris représente le dernier bouton appuyé de la souris, l'élément capturant la souris perd alors la capture de la souris.

Voir aussi QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseMoveEvent(), QGraphicsItem::mouseDoubleClickEvent() et QGraphicsItem::setAcceptedMouseButtons().

void QGraphicsScene::removeItem ( QGraphicsItem * item )

Retire l'élément item et tous ses enfants de la scène. La propriété de l'élément item est transférée à l'appelant (c'est-à-dire : QGraphicsScene ne va pas supprimer l'élément lors de sa destruction).

Voir aussi addItem().

void QGraphicsScene::render ( QPainter * painter, const QRectF & target = QRectF(), const QRectF & source = QRectF(), Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio )

Dessine le rectangle source source de la scène dans la cible target, en utilisant painter. Cette fonction est utile pour capturer le contenu de la scène dans un périphérique de dessin, tel qu'une QImage (par exemple : pour prendre une capture d'écran) ou pour imprimer avec QPrinter. Par exemple :

 QGraphicsScene scene;
 scene.addItem(...
 ...
 QPrinter printer(QPrinter::HighResolution);
 printer.setPaperSize(QPrinter::A4);
 
 QPainter painter(&printer);
 scene.render(&painter);

Si source est un rectangle null, la fonction va utiliser sceneRect() pour déterminer ce qu'il faut dessiner. Si la cible target est un rectangle null, les dimensions du painter vont être utilisées.

Le contenu du rectangle de source va être transformé selon le aspectRatioMode pour correspondre au rectangle cible. Par défaut, le ratio est gardé et la source est mise à l'échelle pour correspondre à target.

Voir aussi QGraphicsView::render().

void QGraphicsScene::sceneRectChanged ( const QRectF & rect ) [signal]

Ce signal est émis par QGraphicsScene chaque fois que le rectangle de la scène change. Le paramètre rect est le nouveau rectangle de la scène.

Voir aussi QGraphicsView::updateSceneRect().

QList<QGraphicsItem *> QGraphicsScene::selectedItems () const

Retourne la liste de tous les éléments actuellement sélectionnés. Les éléments sont retournés sans ordre particulier.

Voir aussi setSelectionArea().

QPainterPath QGraphicsScene::selectionArea () const

Retourne la zone de sélection qui a été précédemment sélectionnée avec setSelectionArea(), ou un QPainterPath vide si aucune zone de sélection n'a été définie.

Voir aussi setSelectionArea().

void QGraphicsScene::selectionChanged () [signal]

Ce signal est émis par QGraphicsScene chaque fois que la sélection change. Vous pouvez appeler selectedItems() pour récupérer la nouvelle liste d'éléments sélectionnés.

La sélection change chaque fois qu'un élément est sélectionné ou désélectionné, qu'une zone de sélection est définie, supprimée ou modifiée, si un élément présélectionné est ajouté à la scène ou si un élément sélectionné est retiré de la scène.

QGraphicsScene émet ce signal seulement une fois par groupe d'opérations de sélection. Par exemple, si vous définissez une zone de sélection, sélectionnez ou désélectionnez un QGraphicsItemGroup ou si vous ajoutez ou retirez de la scène un élément parent de plusieurs éléments sélectionnés, selectionChanged() n'est envoyé qu'une fois : après que l'opération soit complète (au lieu d'être envoyé pour chaque élément).

Cette fonction a été introduite dans Qt 4.3.

Voir aussi setSelectionArea(), selectedItems() et QGraphicsItem::setSelected().

bool QGraphicsScene::sendEvent ( QGraphicsItem * item, QEvent * event )

Envoie un événement event à l'élément item à travers les possibles filtres d'événements.

L'événement n'est envoyé que si l'élément est activé.

Retourne false si l'événement a été filtré ou si l'élément est désactivé. Sinon la valeur de retour est celle retournée par le gestionnaire d'événements.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi QGraphicsItem::sceneEvent() et QGraphicsItem::sceneEventFilter().

void QGraphicsScene::setActivePanel ( QGraphicsItem * item )

Active l'élément item, qui doit être un élément dans la scène. Vous pouvez aussi passer 0 comme élément item, dans ce cas QGraphicsScene va désactiver tout panel actuellement actif.

Si la scène est actuellement inactive, l'élément item va rester inactif tant que la scène ne devient pas active (ou, si l'élément item est 0, aucun élément ne va être activé).

Cette fonction a été introduite dans Qt 4.6.

Voir aussi activePanel(), isActive() et QGraphicsItem::isActive().

void QGraphicsScene::setActiveWindow ( QGraphicsWidget * widget )

Active le widget widget, qui doit être un widget dans la scène. Vous pouvez aussi passer 0 comme widget, dans ce cas QGraphicsScene va désactiver toute fenêtre actuellement active.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi activeWindow() et QGraphicsWidget::isActiveWindow().

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

Définit le focus sur la scène en envoyant un QFocusEvent à la scène, avec comme raison focusReason. Si la scène récupère le focus après l'avoir perdu alors qu'un élément avait le focus, le dernier élément sous le focus va recevoir le focus avec comme raison focusReason.

Si la scène a déjà le focus, la fonction ne fait rien.

Voir aussi hasFocus(), clearFocus() et setFocusItem().

void QGraphicsScene::setFocusItem ( QGraphicsItem * item, Qt::FocusReason focusReason = Qt::OtherFocusReason )

Définit l'élément focus de la scène à l'élément item, avec la raison du focus à focusReason, après avoir retiré le focus sur les éléments qui avaient le focus.

Si l'élément item est 0 ou s'il n'accepte pas le focus (c'est-à-dire : il n'a pas l'indicateur QGraphicsItem::ItemIsFocusable d'activé) ou s'il n'est pas visible ou désactivé, cette fonction retire seulement l'ancien focus.

Si l'élément item n'est pas 0 et que la scène n'a actuellement pas le focus (c'est-à-dire : hasFocus() retourne false), cette fonction va automatiquement appeler setFocus().

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

void QGraphicsScene::setSelectionArea ( const QPainterPath & path, const QTransform & deviceTransform )

Définit la zone de sélection à path. Tous les éléments dans cette zone sont immédiatement sélectionnés et tous les éléments en dehors sont désélectionnés. Vous pouvez récupérer la liste de tous les éléments sélectionnés en appelant selectedItems().

deviceTransform est la transformation qui s'applique à la vue et qui est nécessaire si la scène contient des éléments qui ignorent les transformations.

Pour qu'un élément soit sélectionnable, il doit être marqué comme selectable (QGraphicsItem::ItemIsSelectable).

Cette fonction a été introduite dans Qt 4.6.

Voir aussi clearSelection() et selectionArea().

void QGraphicsScene::setSelectionArea ( const QPainterPath & path, Qt::ItemSelectionMode mode, const QTransform & deviceTransform )

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

Définit la zone de sélection à path en utilisant le mode pour déterminer si les éléments sont inclus dans la zone de sélection.

deviceTransform est la transformation qui s'applique à la vue et qui est nécessaire si la scène contient des éléments qui ignorent les transformations.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi clearSelection() et selectionArea().

void QGraphicsScene::setStyle ( QStyle * style )

Définit ou remplace le style de la scène à style et réaffecte le style à cette scène. Tout style précédemment assigné est supprimé. Le style par défaut de la scène est QApplication::style() et est utilisé comme style par défaut pour tous les éléments QGraphicsWidget dans la scène.

Le changement de style de la scène (directement ou indirectement avec QApplication::setPalette()) va automatiquement mettre à jour le style de tous les widgets dans la scène qui n'ont pas un style explicitement assigné.

Si style est défini à 0, QGraphicsScene retournera à QApplication::style().

Cette fonction a été introduite dans Qt 4.4.

Voir aussi style().

QStyle * QGraphicsScene::style () const

Retourne le style de la scène ou le même que QApplication::style() si la scène n'a pas eu de style assigné explicitement.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi setStyle().

void QGraphicsScene::update ( const QRectF & rect = QRectF() ) [slot]

Planifie un réaffichage de la zone rect de la scène.

Voir aussi sceneRect() et changed().

void QGraphicsScene::update ( qreal x, qreal y, qreal w, qreal h )

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

Cette fonction équivaut à appeler update(QRectF(x, y, w, h));

Cette fonction a été introduite dans Qt 4.3.

QList<QGraphicsView *> QGraphicsScene::views () const

Retourne une liste de toutes les vues qui affichent cette scène.

Voir aussi QGraphicsView::scene().

void QGraphicsScene::wheelEvent ( QGraphicsSceneWheelEvent * wheelEvent ) [virtual protected]

Ce gestionnaire d'événements, pour l'événement wheelEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements de la roulette de souris pour la scène.

Par défaut, l'événement est délivré à l'élément visible le plus haut sous le curseur de souris. S'il est ignoré, l'événement se propage à l'élément en dessous et ainsi de suite jusqu'à l'acceptation de l'événement ou alors il atteint la scène. Si aucun élément n'accepte l'élément, il est ignoré.

Voir aussi QGraphicsItem::wheelEvent().

qreal QGraphicsScene::width () const

Cette fonction de commodité équivaut à appeler sceneRect().width().

Voir aussi height().

Remerciements

Merci à Alexandre Laurent pour la traduction ainsi qu'à Jonathan Courtois pour la traduction et la relecture et à Claude Leloup pour la relecture !