QGraphicsScene Class

Documentation des fonctions membres

QGraphicsScene::QGraphicsScene(QObject *parent = nullptr)

Crée un objet `QGraphicsScene`. Le paramètre ` parent ` est transmis au constructeur de ` QObject`.

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

Crée un objet `QGraphicsScene` en utilisant ` sceneRect ` comme rectangle de scène. Le paramètre ` parent ` est transmis au constructeur de ` QObject`.

Voir également sceneRect.

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

Crée un objet `QGraphicsScene` en utilisant le rectangle spécifié par (x, y), ainsi que les paramètres ` width ` et ` height ` fournis pour son rectangle de scène. Le paramètre ` parent ` est transmis au constructeur de ` QObject`.

Voir également sceneRect.

[virtual noexcept] QGraphicsScene::~QGraphicsScene()

Supprime tous les éléments de l'objet « scène » avant de détruire ce dernier. L'objet « scène » est retiré de la liste globale des scènes de l'application, ainsi que de toutes les vues associées.

QGraphicsItem *QGraphicsScene::activePanel() const

Renvoie le panneau actuellement actif, ou ` nullptr ` si aucun panneau n'est actif.

Voir aussi QGraphicsScene::setActivePanel().

QGraphicsWidget *QGraphicsScene::activeWindow() const

Renvoie la fenêtre actuellement active, ou ` nullptr ` si aucune fenêtre n'est active.

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, puis renvoie le pointeur vers cet élément. La géométrie de l'ellipse est définie par rect, et son stylo ainsi que son pinceau sont initialisés respectivement à pen et brush.

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

Si l’élément est visible (c’est-à-dire que QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra changed() dès que le contrôle reviendra à la boucle d’événements.

Voir également 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 pratique équivaut à appeler addEllipse(QRectF(x, y, w, h), pen, brush).

void QGraphicsScene::addItem(QGraphicsItem *item)

Ajoute ou déplace l'item et tous ses éléments enfants vers cette scène. Cette scène devient propriétaire de l'item.

Si l’élément est visible (c’est-à-dire si la fonction ` QGraphicsItem::isVisible()` renvoie `true`), ` QGraphicsScene ` émettra l’événement ` changed()` dès que le contrôle reviendra à la boucle d’événements.

Si l’élément se trouve déjà dans une autre scène, il sera d’abord retiré de son ancienne scène, puis ajouté à cette scène en tant qu’élément de niveau supérieur.

QGraphicsScene enverra des notifications ItemSceneChange à item pendant son ajout à la scène. Si l’élément n’appartient pas actuellement à une scène, une seule notification est envoyée. S’il appartient déjà à une scène (c’est-à-dire s’il est déplacé vers cette scène), QGraphicsScene enverra une notification supplémentaire lorsque l’élément sera retiré de sa scène précédente.

Si l’élément est un panneau, que la scène est active et qu’il n’y a pas de panneau actif dans la scène, alors l’élément sera activé.

Voir également 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 de ligne à la scène, puis renvoie le pointeur vers cet é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 en coordonnées de l’élément, et que sa position est initialisée à (0, 0).

Si l’élément est visible (c’est-à-dire si QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra changed() dès que le contrôle reviendra à la boucle d’événements.

Voir également 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 pratique revient à appeler `addLine(QLineF(x1, y1, x2, y2), pen)`.

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

Crée et ajoute un élément de tracé à la scène, puis renvoie le pointeur vers cet élément. La géométrie du tracé est définie par path, et son stylo ainsi que son pinceau sont initialisés respectivement à pen et brush.

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

Si l’élément est visible (c’est-à-dire que QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra changed() dès que le contrôle reviendra à la boucle d’événements.

Voir également 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, puis renvoie le pointeur vers cet élément. Le pixmap est défini par pixmap.

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

Si l’élément est visible (c’est-à-dire si la fonction ` QGraphicsItem::isVisible()` renvoie ` true`), la fonction ` QGraphicsScene ` émettra un événement ` changed()` dès que le contrôle reviendra à la boucle d’événements.

Voir également 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 polygonal à la scène, puis renvoie le pointeur vers cet élément. Le polygone est défini par polygon, et son stylo ainsi que son pinceau sont initialisés respectivement à pen et brush.

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

Si l’élément est visible (c’est-à-dire que QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra changed() dès que le contrôle reviendra à la boucle d’événements.

Voir également 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 rectangulaire à la scène, puis renvoie le pointeur vers cet élément. La géométrie du rectangle est définie par rect, et son stylo ainsi que son pinceau sont initialisés respectivement à pen et brush.

Notez que la géométrie de l'élément est fournie en coordonnées de l'élément, et que sa position est initialisée à (0, 0). Par exemple, si un QRect(50, 50, 100, 100) est ajouté, son coin supérieur gauche se trouvera à (50, 50) par rapport à l’origine dans le système de coordonnées de l’élément.

Si l’élément est visible (c’est-à-dire si la fonction ` QGraphicsItem::isVisible()` renvoie ` true`), ` QGraphicsScene ` émettra un événement ` changed()` dès que le contrôle reviendra à la boucle d’événements.

Voir également addEllipse(), addLine(), 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 pratique équivaut à appeler addRect(QRectF(x, y, w, h), pen, brush).

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

Crée et ajoute un élément « QGraphicsSimpleTextItem » à la scène, puis renvoie le pointeur vers cet élément. La chaîne de texte est initialisée à « text », et sa police est initialisée à « font ».

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

Si l’élément est visible (c’est-à-dire que la fonction QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra l’événement changed() dès que le contrôle reviendra à la boucle d’événements.

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

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

Crée et ajoute un élément de texte à la scène, puis renvoie le pointeur vers cet élément. La chaîne de texte est initialisée à « text », et sa police est initialisée à « font ».

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

Si l’élément est visible (c’est-à-dire si QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra changed() dès que le contrôle reviendra à la boucle d’événements.

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

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

Crée un nouveau proxy QGraphicsProxyWidget pour widget, l'ajoute à la scène et renvoie un pointeur vers ce proxy. wFlags définit les indicateurs de fenêtre par défaut pour le widget proxy d'intégration.

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

Si l'élément est visible (c'est-à-dire si QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra changed() dès que le contrôle reviendra à la boucle d'événements.

Notez que les widgets pour lesquels l’attribut « Qt::WA_PaintOnScreen » est défini, ainsi que ceux qui encapsulent une application ou un contrôleur externe, ne sont pas pris en charge. Citons par exemple QOpenGLWidget et QAxWidget.

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

[slot] void QGraphicsScene::advance()

Cet emplacement fait avancer la scène d'une étape, en appelant la fonction QGraphicsItem::advance() pour tous les éléments présents sur la scène. Cela se déroule en deux phases : lors de la première phase, tous les éléments sont informés que la scène est sur le point de changer, et lors de la seconde phase, tous les éléments sont informés qu'ils peuvent se déplacer. Au cours de la première phase, la méthode ` QGraphicsItem::advance()` est appelée avec la valeur 0 en argument, tandis que la valeur 1 est transmise lors de la deuxième phase.

Notez que vous pouvez également utiliser le framework d’animation pour les animations.

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

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

Ce signal est émis par ` QGraphicsScene ` lorsque le contrôle atteint la boucle d'événements, si le contenu de la scène change. Le paramètre ` region ` contient une liste de rectangles de scène indiquant la zone qui a été modifiée.

Voir également QGraphicsView::updateScene().

[slot] void QGraphicsScene::clear()

Supprime tous les éléments de la scène, mais laisse par ailleurs l'état de la scène inchangé.

Voir aussi addItem().

void QGraphicsScene::clearFocus()

Retire le focus de la scène. Si un élément a le focus au moment où cette fonction est appelée, il le perdra, puis le récupérera dès que la scène aura à nouveau le focus.

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

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

[slot] void QGraphicsScene::clearSelection()

Efface la sélection actuelle.

Voir également setSelectionArea() et selectedItems().

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

Renvoie une liste de tous les éléments qui entrent en collision avec item. Les collisions sont déterminées en appelant QGraphicsItem::collidesWithItem() ; la détection des collisions est définie par mode. Par défaut, tous les éléments dont la forme coupe item ou qui sont contenus dans la forme de item sont renvoyés.

Les éléments sont renvoyés par ordre d’empilement décroissant (c’est-à-dire que le premier élément de la liste est celui situé tout en haut, et le dernier élément est celui situé tout en bas).

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

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

Ce gestionnaire d'événements, destiné à l'événement « contextMenuEvent », peut être réimplémenté dans une sous-classe afin de recevoir des événements de menu contextuel. L'implémentation par défaut transmet l'événement à l'élément visible le plus en haut qui accepte les événements de menu contextuel à la position de l'événement. Si aucun élément n'accepte les événements de menu contextuel à cette position, l'événement est ignoré.

Remarque : voir items() pour savoir quels éléments sont considérés comme visibles par cette fonction.

Voir également QGraphicsItem::contextMenuEvent().

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

Regroupe tous les éléments de ` items ` au sein d'un nouveau groupe ` QGraphicsItemGroup` et renvoie un pointeur vers ce groupe. Le groupe est créé avec comme parent l’ancêtre commun de items, et avec la position (0, 0). Tous les éléments sont rattachés au groupe, et leurs positions ainsi que leurs transformations sont mappées sur le groupe. Si items est vide, cette fonction renvoie un QGraphicsItemGroup de niveau supérieur vide.

QGraphicsScene est propriétaire de l’élément du groupe ; vous n’avez pas besoin de le supprimer. Pour démanteler (dégrouper) un groupe, appelez destroyItemGroup().

Voir également destroyItemGroup() et QGraphicsItemGroup::addToGroup().

void QGraphicsScene::destroyItemGroup(QGraphicsItemGroup *group)

Réaffecte tous les éléments de group à l'élément parent de group, puis supprime group de la scène, avant de le supprimer définitivement. Les positions et les transformations des éléments sont transférées du groupe vers son parent.

Voir également createItemGroup() et QGraphicsItemGroup::removeFromGroup().

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

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté dans une sous-classe afin de recevoir les événements «drag enter» pour la scène.

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

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

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

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté dans une sous-classe afin de recevoir les événements de sortie de glissement pour la scène.

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

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

Ce gestionnaire d'événements, destiné à l'événement « event », peut être réimplémenté dans une sous-classe afin de recevoir les événements de déplacement par glissement de la scène.

Remarque : voir ` items()` pour savoir quels éléments sont considérés comme visibles par cette fonction.

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

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

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

Tout le dessin s'effectue dans les coordonnées de la scène. Le paramètre ` rect ` correspond au rectangle exposé.

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

Voir également ` drawForeground()` et ` drawItems()`.

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

Dessine le premier plan de la scène à l'aide de ` painter`, une fois que l'arrière-plan et tous les éléments ont été dessinés. Réimplémentez cette fonction pour définir un premier plan personnalisé pour la scène.

Tout le dessin s'effectue dans les coordonnées de la scène. Le paramètre rect correspond au rectangle exposé.

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

Voir également drawBackground() et drawItems().

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

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

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

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

Réimplémente : QObject::event(QEvent *e).

Traite l'événement event et le transmet aux gestionnaires d'événements correspondants.

Outre l’appel des gestionnaires d’événements de commodité, cette fonction est chargée de convertir les événements de déplacement de la souris en événements de survol lorsqu’aucun élément de capture de souris n’est présent. Les événements de survol sont transmis directement aux éléments ; il n’existe pas de fonction de commodité pour ceux-ci.

Contrairement à ` QWidget`, ` QGraphicsScene ` ne dispose pas des fonctions de commodité ` enterEvent()` et ` leaveEvent()`. Utilisez cette fonction pour obtenir ces événements à la place.

Renvoie ` true ` si ` event ` a été reconnu et traité ; sinon, renvoie ` false`.

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

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

Réimplémente : QObject::eventFilter(QObject *watched, QEvent *event).

QGraphicsScene Filtre les événements de ` QApplication` pour détecter les changements de palette et de police.

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

Ce gestionnaire d'événement, destiné à l'événement « focusEvent », peut être réimplémenté dans une sous-classe afin de recevoir le focus lors d'événements.

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

Voir également ` QGraphicsItem::focusOutEvent()`.

QGraphicsItem *QGraphicsScene::focusItem() const

Lorsque la scène est active, cette fonction renvoie l'élément actuellement sélectionné dans la scène, ou ` nullptr ` si aucun élément n'est actuellement sélectionné. Lorsque la scène est inactive, cette fonction renvoie l'élément qui sera sélectionné dès que la scène deviendra active.

L'élément sélectionné reçoit les entrées clavier lorsque la scène reçoit un événement de touche.

Voir également setFocusItem(), QGraphicsItem::hasFocus() et isActive().

[signal] void QGraphicsScene::focusItemChanged(QGraphicsItem *newFocusItem, QGraphicsItem *oldFocusItem, Qt::FocusReason reason)

Ce signal est émis par ` QGraphicsScene ` chaque fois que le focus change dans la scène (c'est-à-dire lorsqu'un élément obtient ou perd le focus de saisie, ou lorsque le focus passe d'un élément à un autre). Vous pouvez vous connecter à ce signal si vous avez besoin de savoir quand d'autres éléments obtiennent le focus d'entrée. Cela s'avère particulièrement utile pour implémenter des claviers virtuels, des méthodes de saisie et des éléments de curseur.

oldFocusItem est un pointeur vers l'élément qui détenait précédemment le focus, ou 0 si aucun élément ne détenait le focus avant l'émission du signal. newFocusItem est un pointeur vers l'élément qui a obtenu le focus de saisie, ou nullptr si le focus a été perdu. reason est la raison du changement de focus (par exemple, si la scène a été désactivée alors qu’un champ de saisie avait le focus, oldFocusItem pointerait vers l’élément du champ de saisie, newFocusItem serait nullptr, et reason serait Qt::ActiveWindowFocusReason.

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

Recherche un nouveau widget auquel attribuer le focus du clavier, selon le cas pour les touches Tab et Maj+Tab, et renvoie ` true ` si elle trouve un nouveau widget, ou `false` dans le cas contraire. Si ` next ` est vrai, cette fonction effectue une recherche vers l’avant ; si ` next ` est faux, elle effectue une recherche vers l’arrière.

Vous pouvez réimplémenter cette fonction dans une sous-classe de ` QGraphicsScene ` afin de contrôler de manière plus précise la manière dont le focus du tabulation se déplace au sein de votre scène. L’implémentation par défaut repose sur la chaîne de focus du tabulation définie par ` QGraphicsWidget::setTabOrder()` ().

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

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

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

Voir également ` QGraphicsItem::focusInEvent()`.

bool QGraphicsScene::hasFocus() const

Renvoie « true » si la scène a le focus ; sinon, renvoie « false ». Si la scène a le focus, elle transmettra les événements de touche provenant de « QKeyEvent » à tout élément ayant le focus.

Voir également setFocus() et setFocusItem().

qreal QGraphicsScene::height() const

Cette fonction pratique revient à appeler sceneRect().height().

Voir également width().

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

Ce gestionnaire d'événements, destiné à l'événement « helpEvent », peut être réimplémenté dans une sous-classe afin de recevoir des événements d'aide. Ces événements sont de type « QEvent::ToolTip » et sont créés lorsqu'une info-bulle est demandée.

L'implémentation par défaut affiche l'info-bulle de l'élément visible le plus en haut, c'est-à-dire celui qui possède la valeur z la plus élevée, à la position du curseur de la souris. Si aucun élément ne dispose d'une info-bulle, cette fonction ne fait rien.

Remarque : voir ` items()` pour savoir quels éléments sont considérés comme visibles par cette fonction.

Voir également QGraphicsItem::toolTip() et QGraphicsSceneHelpEvent.

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

Ce gestionnaire d'événements, destiné à l'événement ` event`, peut être réimplémenté dans une sous-classe afin de recevoir les événements liés aux méthodes de saisie pour la scène.

L'implémentation par défaut transmet l'événement à la fonction focusItem(). Si aucun élément n'a actuellement le focus ou si l'élément ayant le focus n'accepte pas les méthodes de saisie, cette fonction ne fait rien.

Voir également ` QGraphicsItem::inputMethodEvent()`.

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

Cette méthode est utilisée par les méthodes de saisie pour interroger un ensemble de propriétés de la scène afin de pouvoir prendre en charge des opérations complexes, telles que la gestion du texte environnant et les reconversions.

Le paramètre ` query ` spécifie la propriété à interroger.

Voir également QWidget::inputMethodQuery().

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

Invalide et planifie un rafraîchissement de l’ layers dans rect sur la scène. Tout contenu mis en cache dans layers est invalidé sans condition et rafraîchi.

Vous pouvez utiliser cette surcharge de fonction pour signaler à QGraphicsScene les modifications apportées à l’arrière-plan ou au premier plan de la scène. Cette fonction est couramment utilisée pour les scènes dont l’arrière-plan est constitué de tuiles, afin de signaler les modifications lorsque QGraphicsView a activé CacheBackground.

Exemple :

QRectF TileScene::rectForTile(int x, int y) const
{
    // Return the rectangle for the tile at position (x, y).
    return QRectF(x * tileWidth, y * tileHeight, tileWidth, tileHeight);
}

void TileScene::setTile(int x, int y, const QPixmap &pixmap)
{
    // Sets or replaces the tile at position (x, y) with 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)
{
    // Draws all tiles that intersect the exposed area.
    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 qu’ QGraphicsView ne prend actuellement en charge que la mise en cache de l’arrière-plan (voir QGraphicsView::CacheBackground). Cette fonction équivaut à appeler update() si une couche autre que BackgroundLayer est transmise.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        graphicsScene, qOverload(&QGraphicsScene::invalidate));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        graphicsScene, [receiver = graphicsScene](const QRectF &rect, QGraphicsScene::SceneLayers layers) { receiver->invalidate(rect, layers); });

Voir également ` QGraphicsView::resetCachedContent()`.

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

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

bool QGraphicsScene::isActive() const

Renvoie ` true ` si la scène est active (par exemple, si elle est visualisée par au moins une instance ` QGraphicsView ` active) ; sinon, renvoie ` false`.

Voir également QGraphicsItem::isActive() et QWidget::isActiveWindow().

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

Renvoie l'élément visible situé tout en haut à l'position spécifiée, ou nullptr s'il n'y a aucun élément à cette position.

deviceTransform est la transformation qui s'applique à la vue ; elle doit être fournie si la scène contient des éléments qui ignorent les transformations.

Remarque : voir items() pour savoir quels éléments sont considérés comme visibles par cette fonction.

Voir également items(), collidingItems() et Sorting.

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

Renvoie l'élément visible le plus en avant à la position spécifiée par (x, y), ou nullptr s'il n'y a aucun élément à cette position.

deviceTransform est la transformation qui s'applique à la vue ; elle doit être fournie si la scène contient des éléments qui ignorent les transformations.

Cette fonction pratique équivaut à l'appel de ` itemAt(QPointF(x, y), deviceTransform)`.

Remarque : voir items() pour savoir quels éléments sont considérés comme visibles par cette fonction.

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

Renvoie une liste ordonnée de tous les éléments présents dans la scène. L'ordre d'empilement est déterminé par ` order `.

Voir également addItem(), removeItem() et Sorting.

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

Renvoie tous les éléments visibles qui, selon la propriété « mode », se trouvent à l’ pos spécifiée, sous la forme d’une liste triée selon la propriété « order ». Dans ce cas, le terme « visible » désigne les éléments pour lesquels : la méthode `isVisible()` renvoie ` true`, la méthode `effectiveOpacity()` renvoie une valeur supérieure à 0,0 (ce qui correspond à une transparence totale) et l’élément parent ne les recoupe pas.

La valeur par défaut de ` mode ` est ` Qt::IntersectsItemShape` ; tous les éléments dont la forme exacte recoupe ` pos ` sont renvoyés.

deviceTransform est la transformation qui s'applique à la vue ; elle doit être fournie si la scène contient des éléments qui ignorent les transformations.

Voir également itemAt() et Sorting.

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

Renvoie tous les éléments visibles qui, selon la propriété ` mode`, se trouvent soit à l'intérieur de l'élément spécifié ` path`, soit en intersection avec celui-ci, sous la forme d'une liste triée selon la propriété ` order`. Dans ce cas, le terme « visible » désigne les éléments pour lesquels : la méthode `isVisible()` renvoie ` true`, la méthode `effectiveOpacity()` renvoie une valeur supérieure à 0,0 (ce qui correspond à une transparence totale) et l'élément parent ne les masque pas.

La valeur par défaut de ` mode ` est ` Qt::IntersectsItemShape` ; tous les éléments dont la forme exacte recoupe ou est contenue par ` path ` sont renvoyés.

deviceTransform est la transformation qui s’applique à la vue, et doit être fournie si la scène contient des éléments qui ignorent les transformations.

Voir également itemAt() et Sorting.

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

Renvoie tous les éléments visibles qui, selon la propriété « mode », se trouvent soit à l’intérieur de l’élément spécifié « polygon », soit en intersection avec celui-ci, sous la forme d’une liste triée selon la propriété « order ». Dans ce cas, le terme « visible » désigne les éléments pour lesquels : la méthode « isVisible() » renvoie « true », la méthode « effectiveOpacity() » renvoie une valeur supérieure à 0,0 (ce qui correspond à une transparence totale) et l’élément parent ne les recoupe pas.

La valeur par défaut de ` mode ` est ` Qt::IntersectsItemShape` ; tous les éléments dont la forme exacte intersecte ou est contenue par ` polygon ` sont renvoyés.

deviceTransform est la transformation qui s’applique à la vue ; elle doit être fournie si la scène contient des éléments qui ignorent les transformations.

Voir également itemAt() et Sorting.

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

Renvoie tous les éléments visibles qui, selon la propriété ` mode`, se trouvent soit à l'intérieur de la zone spécifiée par ` rect`, soit en intersection avec celle-ci, sous la forme d'une liste triée selon la propriété ` order`. Dans ce cas, le terme « visible » désigne les éléments pour lesquels : la méthode `isVisible()` renvoie ` true`, la méthode `effectiveOpacity()` renvoie une valeur supérieure à 0,0 (ce qui correspond à une transparence totale) et l'élément parent ne les recoupe pas.

La valeur par défaut de ` mode ` est ` Qt::IntersectsItemShape` ; tous les éléments dont la forme exacte recoupe ou est contenue par ` rect ` sont renvoyés.

deviceTransform est la transformation qui s’applique à la vue ; elle doit être fournie si la scène contient des éléments qui ignorent les transformations.

Voir également 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

Renvoie tous les éléments visibles qui, selon mode, se trouvent soit à l'intérieur, soit en intersection avec le rectangle défini par x, y, w et h, sous la forme d'une liste triée selon order. Dans ce cas, « visible » désigne les éléments pour lesquels : isVisible() renvoie true, effectiveOpacity() renvoie une valeur supérieure à 0,0 (ce qui correspond à une transparence totale) et l’élément parent ne les recoupe pas.

deviceTransform Il s'agit de la transformation qui s'applique à la vue ; elle doit être fournie si la scène contient des éléments qui ignorent les transformations.

QRectF QGraphicsScene::itemsBoundingRect() const

Calcule et renvoie le rectangle englobant de tous les éléments de la scène. Cette fonction parcourt tous les éléments ; de ce fait, elle peut s'avérer lente pour les scènes volumineuses.

Voir également sceneRect().

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

Ce gestionnaire d'événements, destiné à l'événement « keyEvent », peut être réimplémenté dans une sous-classe afin de recevoir les événements de frappe. L'implémentation par défaut transmet l'événement à l'élément actuellement sélectionné.

Voir également ` QGraphicsItem::keyPressEvent()` et ` focusItem()`.

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

Ce gestionnaire d'événements, destiné à l'événement « keyEvent », peut être réimplémenté dans une sous-classe afin de recevoir les événements de relâchement de touche. L'implémentation par défaut transfère l'événement à l'élément actuellement sélectionné.

Voir également ` QGraphicsItem::keyReleaseEvent()` et ` focusItem()`.

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

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

Si un utilisateur double-clique sur la scène, celle-ci recevra d’abord un événement de pression de souris, suivi d’un événement de relâchement (c’est-à-dire un clic), puis d’un événement de double-clic, et enfin d’un événement de relâchement. Si l’événement de double-clic est transmis à un élément différent de celui qui a reçu les premiers événements d’enclenchement et de relâchement, il sera traité comme un événement d’enclenchement. Cependant, les événements de triple-clic ne sont pas traités comme des événements de double-clic dans ce cas.

L’implémentation par défaut est similaire à celle de mousePressEvent().

Remarque : voir items() pour savoir quels éléments sont considérés comme visibles par cette fonction.

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

QGraphicsItem *QGraphicsScene::mouseGrabberItem() const

Renvoie l’élément « mouse grabber » actuel, ou la valeur « nullptr » si aucun élément ne contrôle actuellement la souris. L’élément « mouse grabber » est celui qui reçoit tous les événements de souris envoyés à la scène.

Un élément devient « mouse grabber » lorsqu’il reçoit et accepte un événement de clic de souris, et il conserve ce statut jusqu’à ce que l’un des événements suivants se produise :

• Si l’élément reçoit un événement de relâchement de la souris alors qu’aucun autre bouton n’est enfoncé, il perd le contrôle de la souris.
• Si l’élément devient invisible (c’est-à-dire si quelqu’un appelle la méthode ` item->setVisible(false)`), ou s’il est désactivé (c’est-à-dire si quelqu’un appelle la méthode ` item->setEnabled(false)`), il perd le contrôle de la souris.
• Si l’élément est supprimé de la scène, il perd le contrôle de la souris.

Si l’élément perd le contrôle de la souris, la scène ignorera tous les événements de souris jusqu’à ce qu’un nouvel élément prenne le contrôle de la souris (c’est-à-dire jusqu’à ce qu’un nouvel élément reçoive un événement de clic de souris).

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

Ce gestionnaire d'événement, destiné à 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 pour la scène.

L'implémentation par défaut dépend de l'état du « mouse grabber ». S'il existe un élément « mouse grabber », l'événement est envoyé à celui-ci. S'il existe des éléments acceptant les événements de survol à la position actuelle, l'événement est converti en événement de survol et accepté ; sinon, il est ignoré.

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

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

Ce gestionnaire d'événements, destiné à 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 scène. S’il existe un élément « mouse grabber », l’événement est envoyé à celui-ci. Sinon, il est transmis à l’élément visible le plus en haut qui accepte les événements de souris à la position de la scène indiquée par l’événement, et cet élément devient alors immédiatement l’élément « mouse grabber ».

S’il n’y a aucun élément à la position donnée sur la scène, la zone de sélection est réinitialisée, tout élément ayant le focus perd ce dernier, et l’événement est alors ignoré.

Remarque : voir items() pour savoir quels éléments sont considérés comme visibles par cette fonction.

Voir également QGraphicsItem::mousePressEvent() et QGraphicsItem::setAcceptedMouseButtons().

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

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

L'implémentation par défaut dépend de l'état du « mouse grabber ». S'il n'y a pas de « mouse grabber », l'événement est ignoré. Sinon, s'il existe un élément « mouse grabber », l'événement est envoyé à celui-ci. Si ce relâchement de souris correspond au dernier bouton enfoncé, l'élément « mouse grabber » perd alors le contrôle de la souris.

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

void QGraphicsScene::removeItem(QGraphicsItem *item)

Supprime l'élément item et tous ses enfants de la scène. La propriété de item est transférée à l'appelant (c'est-à-dire que QGraphicsScene ne supprimera plus item lors de sa destruction).

Voir également addItem().

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

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

QGraphicsScene scene;
scene.addItem(someItem);
//...
QPrinter printer(QPrinter::HighResolution);
printer.setPageSize(QPageSize::A4);

QPainter painter(&printer);
scene.render(&painter);

Si ` source ` est un rectangle nul, cette fonction utilisera ` sceneRect()` pour déterminer ce qu’il faut afficher. Si ` target ` est un rectangle nul, les dimensions du périphérique de dessin de ` painter` seront utilisées.

Le contenu du rectangle source sera transformé selon aspectRatioMode afin de s’adapter au rectangle cible. Par défaut, le rapport d’aspect est conservé, et source est mis à l’échelle pour s’adapter à target.

Voir également QGraphicsView::render().

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

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

Voir également QGraphicsView::updateSceneRect().

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

Renvoie une liste de tous les éléments actuellement sélectionnés. Les éléments sont renvoyés sans ordre particulier.

Voir également setSelectionArea().

QPainterPath QGraphicsScene::selectionArea() const

Renvoie la zone de sélection précédemment définie à l'aide de la fonction setSelectionArea(), ou un objet QPainterPath vide si aucune zone de sélection n'a été définie.

Voir également la fonction setSelectionArea().

[signal] void QGraphicsScene::selectionChanged()

Ce signal est émis par ` QGraphicsScene ` chaque fois que la sélection change. Vous pouvez appeler ` selectedItems()` pour obtenir la nouvelle liste des éléments sélectionnés.

La sélection change dès qu’un élément est sélectionné ou désélectionné, qu’une zone de sélection est définie, effacée ou modifiée d’une quelconque manière, qu’un élément présélectionné est ajouté à la scène ou qu’un élément sélectionné est supprimé de la scène.

QGraphicsScene émet ce signal une seule fois pour les opérations de sélection groupée. Par exemple, si vous définissez une zone de sélection, sélectionnez ou désélectionnez un ` QGraphicsItemGroup`, ou si vous ajoutez ou supprimez de la scène un élément parent contenant plusieurs éléments sélectionnés, `selectionChanged()` n’est émis qu’une seule fois une fois l’opération terminée (au lieu d’une fois pour chaque élément).

Voir également setSelectionArea(), selectedItems() et QGraphicsItem::setSelected().

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

Envoie l'événement event à l'élément item en passant par les filtres d'événements éventuels.

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

Renvoie false si l'événement a été filtré ou si l'élément est désactivé. Sinon, renvoie la valeur renvoyée par le gestionnaire d'événements.

Voir également QGraphicsItem::sceneEvent() et QGraphicsItem::sceneEventFilter().

void QGraphicsScene::setActivePanel(QGraphicsItem *item)

Active « item », qui doit être un élément de cette scène. Vous pouvez également passer la valeur 0 pour « item » ; dans ce cas, « QGraphicsScene » désactivera tout panneau actuellement actif.

Si la scène est actuellement inactive, ` item ` reste inactif jusqu’à ce que la scène devienne active (ou, si ` item ` est égal à ` nullptr`, aucun élément ne sera activé).

Voir également activePanel(), isActive() et QGraphicsItem::isActive().

void QGraphicsScene::setActiveWindow(QGraphicsWidget *widget)

Active la fonction « widget », qui doit correspondre à un widget présent dans cette scène. Vous pouvez également passer la valeur 0 à « widget » ; dans ce cas, « QGraphicsScene » désactivera toute fenêtre actuellement active.

Voir également activeWindow() et QGraphicsWidget::isActiveWindow().

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

Met la scène au premier plan en lui envoyant une commande « QFocusEvent », en indiquant « focusReason » comme motif. Si la scène retrouve le focus après l’avoir perdu alors qu’un élément était au premier plan, ce dernier élément recevra à nouveau le focus avec le motif « focusReason ».

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

Voir également hasFocus(), clearFocus() et setFocusItem().

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

Définit l'élément actif de la scène sur item, avec comme motif d'activation focusReason, après avoir retiré le focus de tout élément précédent qui aurait pu être actif.

Si item est nullptr, ou s’il n’accepte pas le focus (c’est-à-dire que l’indicateur QGraphicsItem::ItemIsFocusable n’est pas activé), ou s’il n’est pas visible ou n’est pas activé, cette fonction se contente de retirer le focus de tout élément précédemment sélectionné.

Si `item` n’est pas ` nullptr`, et que la scène n’a pas actuellement le focus (c’est-à-dire que ` hasFocus()` renvoie ` false`), cette fonction appellera automatiquement ` setFocus()`.

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

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

Définit la zone de sélection sur path. Tous les éléments situés à l'intérieur de cette zone sont immédiatement sélectionnés, tandis que tous ceux situés à l'extérieur sont désélectionnés. Vous pouvez obtenir la liste de tous les éléments sélectionnés en appelant la fonction selectedItems().

deviceTransform est la transformation qui s'applique à la vue ; elle doit être fournie si la scène contient des éléments qui ignorent les transformations.

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

Voir également clearSelection() et selectionArea().

void QGraphicsScene::setSelectionArea(const QPainterPath &path, Qt::ItemSelectionOperation selectionOperation = Qt::ReplaceSelection, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, const QTransform &deviceTransform = QTransform())

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

deviceTransform est la transformation qui s'applique à la vue ; elle doit être fournie si la scène contient des éléments qui ignorent les transformations.

selectionOperation détermine ce qu’il faut faire avec les éléments actuellement sélectionnés.

Voir également clearSelection() et selectionArea().

void QGraphicsScene::setStyle(QStyle *style)

Définit ou remplace le style de la scène par « style » et réaffecte ce style à cette scène. Tout style précédemment attribué est supprimé. Le style par défaut de la scène est « QApplication::style() » et sert de style par défaut pour tous les éléments de type « QGraphicsWidget » présents dans la scène.

La modification du style, que ce soit directement en appelant cette fonction ou indirectement en appelant ` QApplication::setStyle()`, mettra automatiquement à jour le style de tous les widgets de la scène auxquels aucun style n’a été explicitement attribué.

Si style est égal à nullptr, QGraphicsScene reviendra à QApplication::style().

Voir également style().

QStyle *QGraphicsScene::style() const

Renvoie le style de la scène, ou la même valeur que QApplication::style() si aucun style n'a été explicitement attribué à la scène.

Voir également setStyle().

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

Planifie un rafraîchissement de la zone rect sur la scène.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        graphicsScene, qOverload(&QGraphicsScene::update));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        graphicsScene, [receiver = graphicsScene](const QRectF &rect) { receiver->update(rect); });

Voir également ` sceneRect()` et ` changed()`.

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

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

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

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

Voir aussi QGraphicsView::scene().

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

Ce gestionnaire d'événement, destiné à l'événement « wheelEvent », peut être réimplémenté dans une sous-classe afin de recevoir les événements liés à la molette de la souris pour la scène.

Par défaut, l’événement est transmis à l’élément visible situé le plus en haut sous le curseur. S’il est ignoré, l’événement se propage à l’élément situé en dessous, et ainsi de suite jusqu’à ce que l’événement soit accepté ou qu’il atteigne la scène. Si aucun élément n’accepte l’événement, celui-ci est ignoré.

Remarque : voir items() pour savoir quels éléments sont considérés comme visibles par cette fonction.

Voir également QGraphicsItem::wheelEvent().

qreal QGraphicsScene::width() const

Cette fonction pratique équivaut à appeler ` sceneRect()`.width().

Voir également height().