QGraphicsScene Class

Documentation sur les fonctions membres

QGraphicsScene::QGraphicsScene(QObject *parent = nullptr)

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

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

Construit un objet QGraphicsScene, en utilisant sceneRect pour son rectangle de scène. Le paramètre parent est transmis au constructeur de QObject.

Voir aussi sceneRect.

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

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

Voir aussi sceneRect.

[virtual noexcept] QGraphicsScene::~QGraphicsScene()

Retire et supprime tous les éléments de l'objet de scène avant de détruire l'objet de scène. L'objet scène est supprimé de la liste globale des scènes de l'application et de toutes les vues associées.

QGraphicsItem *QGraphicsScene::activePanel() const

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

Voir aussi QGraphicsScene::setActivePanel().

QGraphicsWidget *QGraphicsScene::activeWindow() const

Renvoie la fenêtre active actuelle, 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, et renvoie le pointeur de l'élément. La géométrie de l'ellipse est définie par rect, et son stylo et son pinceau sont initialisés à 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() une fois 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 de commodité équivaut à appeler addEllipse(QRectF(x, y, w, h), pen, brush).

void QGraphicsScene::addItem(QGraphicsItem *item)

Ajoute ou déplace le site item et tous ses enfants dans cette scène. Cette scène devient propriétaire de item.

Si l'élément est visible (c'est-à-dire que QGraphicsItem::isVisible() retourne vrai), QGraphicsScene émettra changed() une fois que le contrôle reviendra à la boucle d'événements.

Si l'élément se trouve déjà dans une scène différente, il sera d'abord supprimé de son ancienne scène, puis ajouté à cette scène en tant que niveau supérieur.

QGraphicsScene enverra des notifications ItemSceneChange à item pendant qu'il est ajouté à la scène. Si l'élément n'appartient pas encore à une scène, une seule notification est envoyée. S'il appartient déjà à une scène (c'est-à-dire qu'il est déplacé vers cette scène), QGraphicsScene enverra une notification d'ajout 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, 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, et renvoie le pointeur de 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 en coordonnées d'é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() une fois 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 de commodité équivaut à 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 chemin à la scène, et renvoie le pointeur de l'élément. La géométrie du chemin est définie par path, et son stylo et son pinceau sont initialisés à 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() une fois 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, et renvoie le pointeur de l'élément. La pixmap est définie 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 que QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra changed() une fois 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 polygone à la scène, et renvoie le pointeur de l'élément. Le polygone est défini par polygon, et son stylo et son pinceau sont initialisés à 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() une fois 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 rectangle à la scène, et renvoie le pointeur de l'élément. La géométrie du rectangle est définie par rect, et son stylo et son pinceau sont initialisés à 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 élément QRect(50, 50, 100, 100) est ajouté, son coin supérieur gauche sera situé à (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 que QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra changed() une fois 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 de commodité é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 QGraphicsSimpleTextItem à la scène, et renvoie le pointeur de l'é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 QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra changed() une fois que le contrôle reviendra à la boucle d'événements.

Voir aussi 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, et renvoie le pointeur de l'é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 QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra changed() une fois que le contrôle reviendra à la boucle d'événements.

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

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

Crée un nouveau QGraphicsProxyWidget pour widget, l'ajoute à la scène et renvoie un pointeur vers le proxy. wFlags définit les drapeaux 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 que QGraphicsItem::isVisible() renvoie true), QGraphicsScene émettra changed() une fois que le contrôle reviendra à la boucle d'événements.

Notez que les widgets dont l'attribut Qt::WA_PaintOnScreen widget est défini et les widgets qui enveloppent une application ou un contrôleur externe ne sont pas pris en charge. Les exemples sont QOpenGLWidget et QAxWidget.

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

[slot] void QGraphicsScene::advance()

Ce slot fait avancer la scène d'un pas, en appelant QGraphicsItem::advance() pour tous les éléments de la scène. Cela se fait en deux phases : dans la première phase, tous les éléments sont informés que la scène est sur le point de changer, et dans la seconde phase, tous les éléments sont informés qu'ils peuvent se déplacer. Dans la première phase, QGraphicsItem::advance() est appelé en passant une valeur de 0 comme argument, et 1 est passé dans la seconde phase.

Notez que vous pouvez également utiliser le cadre 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énement, 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 aussi QGraphicsView::updateScene().

[slot] void QGraphicsScene::clear()

Retire et supprime tous les éléments de la scène, mais laisse l'état de la scène inchangé.

Voir aussi addItem().

void QGraphicsScene::clearFocus()

Supprime le focus de la scène. Si un élément a le focus au moment de l'appel de cette fonction, il le perdra et le regagnera une fois que la scène aura retrouvé le focus.

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

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

[slot] void QGraphicsScene::clearSelection()

Efface la sélection actuelle.

Voir aussi 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éterminée par mode. Par défaut, tous les éléments dont la forme intersecte item ou est contenue dans la forme de item sont renvoyés.

Les éléments sont renvoyés dans l'ordre d'empilement décroissant (c'est-à-dire que le premier élément de 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.

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

Ce gestionnaire d'événement, 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 transmet l'événement à l'élément visible le plus haut qui accepte les événements du menu contextuel à la position de l'événement. Si aucun élément n'accepte les événements du menu contextuel à cette position, l'événement est ignoré.

Remarque : voir items() pour une définition des éléments 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 dans un nouveau QGraphicsItemGroup, et renvoie un pointeur sur le groupe. Le groupe est créé avec l'ancêtre commun de items comme parent, et avec la position (0, 0). Les éléments sont tous référencés dans le groupe, et leurs positions et leurs transformations sont liées au groupe. Si items est vide, cette fonction renverra un niveau supérieur vide QGraphicsItemGroup.

QGraphicsScene La propriété de l'élément de groupe appartient à l'utilisateur ; il n'est pas nécessaire 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 retire group de la scène et enfin le supprime. Les positions et les transformations des éléments sont transférées du groupe au parent du groupe.

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

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

Ce gestionnaire d'événement, pour l'événement event, peut être réimplémenté dans une sous-classe pour recevoir les événements d'entrée par glissement 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 déplacement par glissement.

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

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

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

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

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

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

Remarque : voir items() pour une définition des éléments 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.

Toutes les peintures sont réalisées dans les coordonnées de la scène. Le paramètre rect est le 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, après que l'arrière-plan et tous les éléments ont été dessinés. Réimplémentez cette fonction pour obtenir un premier plan personnalisé pour la scène.

Toutes les peintures sont réalisées dans les coordonnées de la scène. Le paramètre rect est le rectangle exposé.

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

Voir également drawBackground() et drawItems().

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

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

Voir aussi 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 distribue aux gestionnaires d'événements respectifs.

En plus d'appeler les 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'il n'y a pas d'élément de saisie de la souris. Les événements de survol sont transmis directement aux éléments ; il n'y a pas de fonction de commodité pour eux.

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 aussi 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, pour l'événement focusEvent, peut être réimplémenté dans une sous-classe pour recevoir le focus dans les événements.

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

Voir aussi QGraphicsItem::focusOutEvent().

QGraphicsItem *QGraphicsScene::focusItem() const

Lorsque la scène est active, cette fonction renvoie l'élément de focalisation actuel de la scène, ou nullptr si aucun élément n'est actuellement focalisé. Lorsque la scène est inactive, cette fonction renvoie l'élément qui obtiendra le focus d'entrée lorsque la scène sera active.

L'élément au centre de l'attention reçoit une entrée 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 lorsque le focus change dans la scène (c'est-à-dire lorsqu'un élément gagne ou perd le focus d'entrée, 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 gagnent le focus d'entrée. Il est particulièrement utile pour la mise en œuvre de claviers virtuels, de méthodes de saisie et d'éléments de curseur.

oldFocusItem est un pointeur sur l'élément qui avait précédemment le focus, ou 0 si aucun élément n'avait le focus avant l'émission du signal. newFocusItem est un pointeur sur l'élément qui a gagné le focus d'entrée, 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 d'entrée avait le focus, oldFocusItem pointera sur l'élément du champ d'entrée, newFocusItem sera nullptr, et reason sera Qt::ActiveWindowFocusReason.

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

Recherche un nouveau widget auquel donner le focus clavier, comme approprié pour Tab et Shift+Tab, et renvoie true s'il trouve un nouveau widget, ou false s'il ne le trouve pas. 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 finement la manière dont le focus des onglets passe dans votre scène. L'implémentation par défaut est basée sur la chaîne de focus des onglets définie par QGraphicsWidget::setTabOrder().

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

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

L'implémentation par défaut supprime le focus de n'importe quel élément du focus, puis supprime le focus de la scène.

Voir aussi 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 clés de QKeyEvent à tout élément qui a le focus.

Voir aussi setFocus() et setFocusItem().

qreal QGraphicsScene::height() const

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

Voir aussi width().

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

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

L'implémentation par défaut affiche l'infobulle de l'élément visible le plus haut, c'est-à-dire l'élément ayant la valeur z la plus élevée, à la position du curseur de la souris. Si aucun élément n'a de bulle d'aide, cette fonction ne fait rien.

Remarque : voir items() pour une définition des éléments 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énement, pour l'événement event, peut être réimplémenté dans une sous-classe pour recevoir les événements de la méthode d'entrée pour la scène.

L'implémentation par défaut transmet l'événement à focusItem(). Si aucun élément n'est actuellement au centre de l'attention ou si l'élément au centre de l'attention 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 d'entrée pour interroger un ensemble de propriétés de la scène afin de pouvoir prendre en charge des opérations complexes de la méthode d'entrée telles que la prise en charge du texte environnant et des reconversions.

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

Voir aussi QWidget::inputMethodQuery().

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

Invalide et planifie un nouveau dessin de layers dans rect sur la scène. Tout contenu mis en cache dans layers est inconditionnellement invalidé et redessiné.

Vous pouvez utiliser cette surcharge de fonction pour informer QGraphicsScene des modifications apportées à l'arrière-plan ou à l'avant-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 notifier les changements 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 que 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 aussi 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 (c'est-à-dire qu'elle est vue par au moins un QGraphicsView qui est actif) ; sinon, renvoie false.

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

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

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

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.

Remarque : voir items() pour une définition des éléments 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 haut à la position spécifiée par (x, y), ou nullptr s'il n'y a pas d'élément à cette position.

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.

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

Remarque : voir items() pour une définition des éléments 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 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::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const

Renvoie tous les éléments visibles qui, en fonction de mode, se trouvent à l'adresse pos spécifiée dans une liste triée à l'aide de order. Dans ce cas, "visible" définit les éléments pour lesquels : isVisible() renvoie true, effectiveOpacity() renvoie une valeur supérieure à 0,0 (ce qui est totalement transparent) et l'élément parent ne l'écrête pas.

La valeur par défaut de mode est Qt::IntersectsItemShape; tous les éléments dont la forme exacte croise pos 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 aussi 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, en fonction de mode, se trouvent à l'intérieur ou à l'intersection de l'élément spécifié path, dans une liste triée à l'aide de order. Dans ce cas, "visible" définit les éléments pour lesquels : isVisible() renvoie true, effectiveOpacity() renvoie une valeur supérieure à 0,0 (ce qui est totalement transparent) et l'élément parent ne l'écrête pas.

La valeur par défaut de mode est Qt::IntersectsItemShape; tous les éléments dont la forme exacte intersecte 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 aussi 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, en fonction de mode, se trouvent à l'intérieur ou à l'intersection de l'élément spécifié polygon, dans une liste triée à l'aide de order. Dans ce cas, "visible" définit les éléments pour lesquels : isVisible() renvoie true, effectiveOpacity() renvoie une valeur supérieure à 0,0 (ce qui est totalement transparent) et l'élément parent ne l'écrête 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 et doit être fournie si la scène contient des éléments qui ignorent les transformations.

Voir aussi 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, en fonction de mode, se trouvent à l'intérieur ou à l'intersection de l'élément spécifié rect, dans une liste triée à l'aide de order. Dans ce cas, "visible" définit les éléments pour lesquels : isVisible() renvoie true, effectiveOpacity() renvoie une valeur supérieure à 0,0 (ce qui est totalement transparent) et l'élément parent ne l'écrête pas.

La valeur par défaut de mode est Qt::IntersectsItemShape; tous les éléments dont la forme exacte intersecte ou est contenue par rect 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 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

Renvoie tous les éléments visibles qui, en fonction de mode, se trouvent à l'intérieur du rectangle défini par x, y, w et h ou l'intersectent, dans une liste triée à l'aide de order. Dans ce cas, "visible" définit les éléments pour lesquels : isVisible() renvoie true, effectiveOpacity() renvoie une valeur supérieure à 0,0 (ce qui est totalement transparent) et l'élément parent ne l'écrête pas.

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.

QRectF QGraphicsScene::itemsBoundingRect() const

Calcule et renvoie le rectangle de délimitation de tous les éléments de la scène. Cette fonction fonctionne en itérant sur tous les éléments, ce qui peut la rendre lente pour les scènes de grande taille.

Voir également sceneRect().

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

Ce gestionnaire d'événement, pour l'événement keyEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements de pression de touche. L'implémentation par défaut transmet l'événement à l'élément de focalisation actuel.

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

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

Ce gestionnaire d'événement, pour l'événement keyEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements de relâchement des touches. L'implémentation par défaut transmet l'événement à l'élément de focalisation actuel.

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

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

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

Si quelqu'un double-clique sur la scène, celle-ci recevra d'abord un événement de pression de la souris, suivi d'un événement de relâchement (c'est-à-dire un clic), puis d'un événement de double-clic et enfin d'un événement de relâchement. Si l'événement de double-clic concerne un élément différent de celui qui a reçu la première pression et le premier relâchement, il sera transmis en tant qu'événement de pression. Toutefois, les événements de triple clic ne sont pas transmis comme des événements de double clic dans ce cas.

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

Remarque : voir items() pour une définition des éléments 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 actuel de capture de la souris, ou nullptr si aucun élément n'est actuellement en train de capturer la souris. L'élément de capture de 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 capteur de souris lorsqu'il reçoit et accepte un événement de pression de la souris, et il reste le capteur de souris 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 son statut de capteur de souris.
• Si l'élément devient invisible (quelqu'un appelle item->setVisible(false)) ou s'il est désactivé (quelqu'un appelle item->setEnabled(false)), il perd le contrôle de la souris.
• Si l'élément est retiré de la scène, il perd la prise de la souris.

Si l'élément perd sa prise de souris, la scène ignore tous les événements liés à la souris jusqu'à ce qu'un nouvel élément prenne la souris (c'est-à-dire jusqu'à ce qu'un nouvel élément reçoive un événement d'appui sur la souris).

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

Ce gestionnaire d'événement, pour l'événement mouseEvent, peut être réimplémenté dans une sous-classe pour 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 de la souris. S'il y a un élément de saisie de la souris, l'événement est envoyé à la saisie de la souris. S'il existe des éléments qui acceptent les événements de survol à la position actuelle, l'événement est traduit en événement de survol et accepté ; sinon, il est ignoré.

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

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

Ce gestionnaire d'événement, pour l'événement mouseEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements de pression de la 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 de saisie de la souris, l'événement est envoyé à la saisie de la souris. Sinon, il est transmis à l'élément visible le plus haut qui accepte les événements de souris à la position de scène de l'événement, et cet élément devient rapidement l'élément d'accroche de 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, tout élément focalisé perd sa focalisation d'entrée et l'événement est alors ignoré.

Remarque : voir items() pour une définition des éléments 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, pour l'événement mouseEvent, peut être réimplémenté dans une sous-classe pour 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 de la souris. S'il n'y a pas de souris, l'événement est ignoré. Dans le cas contraire, l'événement est envoyé à la souris. Si ce relâchement de la souris représente le dernier bouton enfoncé sur la souris, l'élément "mouse grabber" perd alors la prise de la souris.

Voir aussi 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 transmise à l'appelant (c'est-à-dire que QGraphicsScene ne supprimera plus item lorsqu'il sera détruit).

Voir aussi addItem().

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

Rend le rect 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 peinture, tel que QImage (par exemple, pour faire une capture d'écran), ou pour l'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 nul, cette fonction utilisera sceneRect() pour déterminer ce qu'il faut rendre. Si target est un rectangle nul, les dimensions du périphérique de peinture de painter seront utilisées.

Le contenu du rect source sera transformé selon aspectRatioMode pour s'adapter au rect cible. Par défaut, le rapport hauteur/largeur est conservé et source est mis à l'échelle pour tenir dans target.

Voir également QGraphicsView::render().

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

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

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

QPainterPath QGraphicsScene::selectionArea() const

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

Voir aussi setSelectionArea().

[signal] void QGraphicsScene::selectionChanged()

Ce signal est émis par QGraphicsScene lorsque la sélection change. Vous pouvez appeler selectedItems() pour obtenir la nouvelle liste des é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, effacée ou modifiée, 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 de groupe. Par exemple, si vous définissez une zone de sélection, sélectionnez ou désélectionnez un élément 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 après la fin de l'opération (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 à travers les filtres d'événements possibles.

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énement.

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 0 pour item, auquel 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 nullptr, aucun élément ne sera activé).

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

void QGraphicsScene::setActiveWindow(QGraphicsWidget *widget)

Active widget, qui doit être un widget dans cette scène. Vous pouvez également passer 0 pour widget, auquel cas QGraphicsScene désactivera toute fenêtre actuellement active.

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

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

Fixe le focus sur la scène en envoyant un QFocusEvent à la scène, en passant focusReason comme raison. Si la scène regagne le focus après l'avoir perdu pendant qu'un élément avait le focus, le dernier élément ayant eu le focus recevra le focus avec focusReason comme raison.

Si la scène a déjà le focus, cette 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 de focus de la scène à item, avec le motif de focus focusReason, après avoir retiré le focus de tout élément précédent qui aurait pu avoir le focus.

Si item est nullptr, ou s'il n'accepte pas le focus (c'est-à-dire qu'il n'a pas le drapeau QGraphicsItem::ItemIsFocusable activé), ou s'il n'est pas visible ou pas activé, cette fonction supprime uniquement le focus de tout élément précédent qui avait le focus.

Si l'élément 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 à path. Tous les éléments situés à l'intérieur de cette zone sont immédiatement sélectionnés et tous les éléments situés à l'extérieur ne sont pas sélectionnés. Vous pouvez obtenir la liste de tous les éléments sélectionnés en appelant selectedItems().

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.

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 à path en utilisant 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 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 aussi clearSelection() et selectionArea().

void QGraphicsScene::setStyle(QStyle *style)

Définit ou remplace le style de la scène à style, et reporte le style sur cette scène. Tout style précédemment attribué est supprimé. Le style de la scène est par défaut QApplication::style() et sert de valeur par défaut pour tous les éléments QGraphicsWidget de la scène.

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

Si style est nullptr, QGraphicsScene deviendra QApplication::style().

Voir aussi style().

QStyle *QGraphicsScene::style() const

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

Voir aussi setStyle().

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

Planifie un redessin 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 aussi 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, pour l'événement wheelEvent, peut être réimplémenté dans une sous-classe pour recevoir les événements de la roue de la souris pour la scène.

Par défaut, l'événement est transmis à l'élément visible le plus haut sous le curseur. S'il est ignoré, l'événement se propage à l'élément du 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 une définition des éléments considérés comme visibles par cette fonction.

Voir également QGraphicsItem::wheelEvent().

qreal QGraphicsScene::width() const

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

Voir aussi height().