QGraphicsScene Class

Dokumentation der Mitgliedsfunktionen

QGraphicsScene::QGraphicsScene(QObject *parent = nullptr)

Konstruiert ein QGraphicsScene-Objekt. Der Parameter parent wird an den Konstruktor von QObject übergeben.

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

Konstruiert ein QGraphicsScene-Objekt unter Verwendung von sceneRect für sein Szenenrechteck. Der Parameter parent wird an den Konstruktor von QObject übergeben.

Siehe auch sceneRect.

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

Konstruiert ein QGraphicsScene-Objekt unter Verwendung des durch (x, y) angegebenen Rechtecks und der angegebenen width und height für sein Szenenrechteck. Der Parameter parent wird an den Konstruktor von QObject übergeben.

Siehe auch sceneRect.

[virtual noexcept] QGraphicsScene::~QGraphicsScene()

Entfernt und löscht alle Elemente aus dem Szenenobjekt, bevor das Szenenobjekt zerstört wird. Das Szenenobjekt wird aus der globalen Szenenliste der Anwendung entfernt und aus allen zugehörigen Ansichten entfernt.

QGraphicsItem *QGraphicsScene::activePanel() const

Gibt das aktuell aktive Panel zurück, oder nullptr, wenn kein Panel aktiv ist.

Siehe auch QGraphicsScene::setActivePanel().

QGraphicsWidget *QGraphicsScene::activeWindow() const

Gibt das aktuell aktive Fenster zurück, oder nullptr, wenn kein Fenster aktiv ist.

Siehe auch QGraphicsScene::setActiveWindow().

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

Erzeugt ein Ellipsenelement, fügt es der Szene hinzu und gibt den Elementzeiger zurück. Die Geometrie der Ellipse wird durch rect definiert, und ihr Stift und Pinsel werden auf pen und brush initialisiert.

Beachten Sie, dass die Geometrie des Elements in Elementkoordinaten angegeben wird und seine Position auf (0, 0) initialisiert wird.

Wenn das Element sichtbar ist (d.h. QGraphicsItem::isVisible() gibt true zurück), gibt QGraphicsScene changed () aus, sobald die Kontrolle zur Ereignisschleife zurückkehrt.

Siehe auch addLine(), addPath(), addPixmap(), addRect(), addText(), addItem(), und addWidget().

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

Diese Komfortfunktion entspricht dem Aufruf von addEllipse(QRectF(x, y, w, h), pen, brush).

void QGraphicsScene::addItem(QGraphicsItem *item)

Fügt dieser Szene den item und alle seine untergeordneten Elemente hinzu oder verschiebt sie. Diese Szene übernimmt die Kontrolle über item.

Wenn das Element sichtbar ist (d. h. QGraphicsItem::isVisible() gibt true zurück), gibt QGraphicsScene changed () aus, sobald die Kontrolle zur Ereignisschleife zurückkehrt.

Befindet sich das Element bereits in einer anderen Szene, wird es zunächst aus seiner alten Szene entfernt und dann als oberste Ebene zu dieser Szene hinzugefügt.

QGraphicsScene sendet ItemSceneChange-Benachrichtigungen an item, während es der Szene hinzugefügt wird. Wenn das Objekt noch nicht zu einer Szene gehört, wird nur eine Benachrichtigung gesendet. Wenn es bereits zu einer Szene gehört (d.h. es wird in diese Szene verschoben), sendet QGraphicsScene eine Hinzufügungsbenachrichtigung, wenn das Element aus seiner vorherigen Szene entfernt wird.

Handelt es sich bei dem Element um ein Paneel, ist die Szene aktiv und es gibt kein aktives Paneel in der Szene, dann wird das Element aktiviert.

Siehe auch removeItem(), addEllipse(), addLine(), addPath(), addPixmap(), addRect(), addText(), addWidget(), und Sorting.

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

Erstellt ein Linienelement, fügt es der Szene hinzu und gibt den Elementzeiger zurück. Die Geometrie der Linie wird durch line definiert, und ihr Stift wird auf pen initialisiert.

Beachten Sie, dass die Geometrie des Elements in Elementkoordinaten angegeben wird und seine Position auf (0, 0) initialisiert wird.

Wenn das Element sichtbar ist (d.h. QGraphicsItem::isVisible() gibt true zurück), gibt QGraphicsScene changed () aus, sobald die Kontrolle zur Ereignisschleife zurückkehrt.

Siehe auch addEllipse(), addPath(), addPixmap(), addRect(), addText(), addItem(), und addWidget().

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

Diese Komfortfunktion entspricht dem Aufruf von addLine(QLineF(x1, y1, x2, y2), pen).

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

Erzeugt ein Pfadelement, fügt es der Szene hinzu und gibt den Zeiger des Elements zurück. Die Geometrie des Pfades wird durch path definiert, und sein Stift und Pinsel werden auf pen und brush initialisiert.

Beachten Sie, dass die Geometrie des Elements in Elementkoordinaten angegeben wird und seine Position auf (0, 0) initialisiert wird.

Wenn das Element sichtbar ist (d.h. QGraphicsItem::isVisible() gibt true zurück), gibt QGraphicsScene changed () aus, sobald die Kontrolle zur Ereignisschleife zurückkehrt.

Siehe auch addEllipse(), addLine(), addPixmap(), addRect(), addText(), addItem(), und addWidget().

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

Erzeugt ein Pixmap-Element, fügt es der Szene hinzu und gibt den Zeiger des Elements zurück. Das Pixmap wird durch pixmap definiert.

Beachten Sie, dass die Geometrie des Elements in Elementkoordinaten angegeben wird und seine Position auf (0, 0) initialisiert wird.

Wenn das Element sichtbar ist (d. h. QGraphicsItem::isVisible() gibt true zurück), gibt QGraphicsScene changed () aus, sobald die Kontrolle zur Ereignisschleife zurückkehrt.

Siehe auch addEllipse(), addLine(), addPath(), addRect(), addText(), addItem(), und addWidget().

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

Erzeugt ein Polygonelement, fügt es der Szene hinzu und gibt den Zeiger des Elements zurück. Das Polygon wird durch polygon definiert, und sein Stift und Pinsel werden auf pen und brush initialisiert.

Beachten Sie, dass die Geometrie des Elements in Elementkoordinaten angegeben wird und seine Position auf (0, 0) initialisiert wird.

Wenn das Element sichtbar ist (d.h. QGraphicsItem::isVisible() gibt true zurück), gibt QGraphicsScene changed () aus, sobald die Kontrolle zur Ereignisschleife zurückkehrt.

Siehe auch addEllipse(), addLine(), addPath(), addRect(), addText(), addItem(), und addWidget().

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

Erzeugt ein Rechteck, fügt es der Szene hinzu und gibt den Zeiger des Elements zurück. Die Geometrie des Rechtecks wird durch rect definiert, und sein Stift und Pinsel werden auf pen und brush initialisiert.

Beachten Sie, dass die Geometrie des Elements in Elementkoordinaten angegeben wird und seine Position auf (0, 0) initialisiert wird. Wenn zum Beispiel ein QRect(50, 50, 100, 100) hinzugefügt wird, befindet sich seine linke obere Ecke bei (50, 50), bezogen auf den Ursprung im Koordinatensystem des Elements.

Wenn das Element sichtbar ist (d. h. QGraphicsItem::isVisible() gibt true zurück), gibt QGraphicsScene changed () aus, sobald die Kontrolle zur Ereignisschleife zurückkehrt.

Siehe auch addEllipse(), addLine(), addPixmap(), addPixmap(), addText(), addItem(), und addWidget().

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

Diese Komfortfunktion entspricht dem Aufruf von addRect(QRectF(x, y, w, h), pen, brush).

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

Erstellt eine QGraphicsSimpleTextItem, fügt sie der Szene hinzu und gibt den Zeiger des Elements zurück. Die Textzeichenkette wird mit text initialisiert, und die Schriftart wird mit font initialisiert.

Die Position des Elements wird auf (0, 0) initialisiert.

Wenn das Element sichtbar ist (d. h. QGraphicsItem::isVisible() gibt true zurück), gibt QGraphicsScene changed () aus, sobald die Kontrolle zur Ereignisschleife zurückkehrt.

Siehe auch addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addItem(), und addWidget().

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

Erzeugt ein Textelement, fügt es der Szene hinzu und gibt den Zeiger auf das Element zurück. Die Textzeichenkette wird mit text initialisiert, und die Schriftart wird mit font initialisiert.

Die Position des Elements wird auf (0, 0) initialisiert.

Wenn das Element sichtbar ist (d. h. QGraphicsItem::isVisible() gibt true zurück), gibt QGraphicsScene changed () aus, sobald die Kontrolle zur Ereignisschleife zurückkehrt.

Siehe auch addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addItem(), und addWidget().

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

Erzeugt ein neues QGraphicsProxyWidget für widget, fügt es der Szene hinzu und gibt einen Zeiger auf den Proxy zurück. wFlags setzt die Standard-Fensterflags für das einbettende Proxy-Widget.

Die Position des Elements wird auf (0, 0) initialisiert.

Wenn das Element sichtbar ist (d.h. QGraphicsItem::isVisible() gibt true zurück), gibt QGraphicsScene changed () aus, sobald die Kontrolle zur Ereignisschleife zurückkehrt.

Beachten Sie, dass Widgets mit dem Qt::WA_PaintOnScreen Widget-Attribut und Widgets, die eine externe Anwendung oder einen Controller umschließen, nicht unterstützt werden. Beispiele sind QOpenGLWidget und QAxWidget.

Siehe auch addEllipse(), addLine(), addPixmap(), addPixmap(), addRect(), addText(), addSimpleText(), und addItem().

[slot] void QGraphicsScene::advance()

Dieser Slot schaltet die Szene um einen Schritt weiter, indem er QGraphicsItem::advance() für alle Elemente der Szene aufruft. Dies geschieht in zwei Phasen: In der ersten Phase werden alle Elemente darüber informiert, dass sich die Szene verändern wird, und in der zweiten Phase werden alle Elemente darüber informiert, dass sie sich bewegen können. In der ersten Phase wird QGraphicsItem::advance() mit dem Wert 0 als Argument aufgerufen, in der zweiten Phase wird der Wert 1 übergeben.

Beachten Sie, dass Sie auch das Animation Framework für Animationen verwenden können.

Siehe auch QGraphicsItem::advance() und QTimeLine.

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

Dieses Signal wird von QGraphicsScene ausgegeben, wenn die Steuerung die Ereignisschleife erreicht, wenn sich der Inhalt der Szene ändert. Der Parameter region enthält eine Liste von Szenenrechtecken, die den geänderten Bereich angeben.

Siehe auch QGraphicsView::updateScene().

[slot] void QGraphicsScene::clear()

Entfernt und löscht alle Elemente aus der Szene, lässt aber ansonsten den Zustand der Szene unverändert.

Siehe auch addItem().

void QGraphicsScene::clearFocus()

Entfernt den Fokus aus der Szene. Wenn ein Element den Fokus hat, wenn diese Funktion aufgerufen wird, verliert es den Fokus und erhält ihn wieder, sobald die Szene wieder den Fokus erhält.

Eine Szene, die keinen Fokus hat, ignoriert Tastenereignisse.

Siehe auch hasFocus(), setFocus(), und setFocusItem().

[slot] void QGraphicsScene::clearSelection()

Löscht die aktuelle Auswahl.

Siehe auch setSelectionArea() und selectedItems().

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

Gibt eine Liste aller Elemente zurück, die mit item kollidieren. Kollisionen werden durch den Aufruf von QGraphicsItem::collidesWithItem() ermittelt; die Kollisionserkennung wird durch mode bestimmt. Standardmäßig werden alle Elemente zurückgegeben, deren Form item schneidet oder innerhalb der Form von item enthalten ist.

Die Elemente werden in absteigender Stapelreihenfolge zurückgegeben (d. h. das erste Element in der Liste ist das oberste Element und das letzte Element ist das unterste Element).

Siehe auch items(), itemAt(), QGraphicsItem::collidesWithItem(), und Sorting.

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

Dieser Eventhandler für das Ereignis contextMenuEvent kann in einer Unterklasse neu implementiert werden, um Kontextmenüereignisse zu empfangen. Die Standardimplementierung leitet das Ereignis an das oberste sichtbare Element weiter, das Kontextmenüereignisse an der Position des Ereignisses annimmt. Wenn keine Elemente an dieser Position Kontextmenüereignisse akzeptieren, wird das Ereignis ignoriert.

Hinweis: Siehe items() für eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden.

Siehe auch QGraphicsItem::contextMenuEvent().

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

Fasst alle Elemente in items in einer neuen QGraphicsItemGroup zusammen und gibt einen Zeiger auf die Gruppe zurück. Die Gruppe wird mit dem gemeinsamen Vorfahren von items als Elternteil und mit der Position (0, 0) erstellt. Die Elemente werden alle in die Gruppe repariert, und ihre Positionen und Transformationen werden auf die Gruppe abgebildet. Wenn items leer ist, gibt diese Funktion eine leere oberste Ebene QGraphicsItemGroup zurück.

QGraphicsScene Die Funktion hat das Eigentum am Gruppenelement; Sie brauchen es nicht zu löschen. Um eine Gruppe aufzulösen, rufen Sie destroyItemGroup() auf.

Siehe auch destroyItemGroup() und QGraphicsItemGroup::addToGroup().

void QGraphicsScene::destroyItemGroup(QGraphicsItemGroup *group)

Setzt alle Elemente in group auf das übergeordnete Element von group zurück, entfernt dann group aus der Szene und löscht es schließlich. Die Positionen und Transformationen der Elemente werden von der Gruppe auf das übergeordnete Element der Gruppe abgebildet.

Siehe auch createItemGroup() und QGraphicsItemGroup::removeFromGroup().

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

Dieser Event-Handler für das Ereignis event kann in einer Unterklasse neu implementiert werden, um Drag-Enter-Ereignisse für die Szene zu empfangen.

Die Standardimplementierung nimmt das Ereignis an und bereitet die Szene auf die Annahme von Drag-Move-Ereignissen vor.

Siehe auch QGraphicsItem::dragEnterEvent(), dragMoveEvent(), dragLeaveEvent(), und dropEvent().

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

Dieser Event-Handler für das Ereignis event kann in einer Unterklasse neu implementiert werden, um Drag Leave-Ereignisse für die Szene zu empfangen.

Siehe auch QGraphicsItem::dragLeaveEvent(), dragEnterEvent(), dragMoveEvent(), und dropEvent().

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

Dieser Event-Handler für das Ereignis event kann in einer Unterklasse neu implementiert werden, um Drag-Move-Ereignisse für die Szene zu empfangen.

Hinweis: Siehe items() für eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden.

Siehe auch QGraphicsItem::dragMoveEvent(), dragEnterEvent(), dragLeaveEvent(), und dropEvent().

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

Zeichnet den Hintergrund der Szene unter Verwendung von painter, bevor Elemente und der Vordergrund gezeichnet werden. Implementieren Sie diese Funktion neu, um einen eigenen Hintergrund für die Szene zu erstellen.

Alle Zeichnungen werden in Szenenkoordinaten durchgeführt. Der Parameter rect ist das sichtbare Rechteck.

Wenn Sie nur eine Farbe, eine Textur oder einen Farbverlauf für den Hintergrund definieren wollen, können Sie stattdessen setBackgroundBrush() aufrufen.

Siehe auch drawForeground() und drawItems().

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

Zeichnet den Vordergrund der Szene mit painter, nachdem der Hintergrund und alle Elemente gezeichnet wurden. Implementieren Sie diese Funktion neu, um einen eigenen Vordergrund für die Szene zu erstellen.

Alle Zeichnungen werden in Szenenkoordinaten durchgeführt. Der Parameter rect ist das sichtbare Rechteck.

Wenn Sie nur eine Farbe, eine Textur oder einen Farbverlauf für den Vordergrund definieren wollen, können Sie stattdessen setForegroundBrush() aufrufen.

Siehe auch drawBackground() und drawItems().

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

Dieser Event-Handler für das Ereignis event kann in einer Unterklasse neu implementiert werden, um Drop-Ereignisse für die Szene zu empfangen.

Siehe auch QGraphicsItem::dropEvent(), dragEnterEvent(), dragMoveEvent(), und dragLeaveEvent().

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

Reimplements: QObject::event(QEvent *e).

Verarbeitet das Ereignis event und gibt es an die entsprechenden Ereignisbehandler weiter.

Zusätzlich zum Aufruf der Komfort-Ereignishandler ist diese Funktion für die Umwandlung von Mausbewegungsereignissen in Hover-Ereignisse verantwortlich, wenn es kein Mausgrabber-Element gibt. Hover-Ereignisse werden direkt an Elemente geliefert; es gibt keine Komfortfunktion für sie.

Im Gegensatz zu QWidget verfügt QGraphicsScene nicht über die Komfortfunktionen enterEvent() und leaveEvent(). Verwenden Sie stattdessen diese Funktion, um diese Ereignisse zu erhalten.

Gibt true zurück, wenn event erkannt und verarbeitet wurde; andernfalls gibt sie false zurück.

Siehe auch contextMenuEvent(), keyPressEvent(), keyReleaseEvent(), mousePressEvent(), mouseMoveEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), focusInEvent(), und focusOutEvent().

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

Reimplements: QObject::eventFilter(QObject *watched, QEvent *event).

QGraphicsScene filtert die Ereignisse von QApplication, um Paletten- und Schriftartwechsel zu erkennen.

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

Dieser Event-Handler für das Ereignis focusEvent kann in einer Unterklasse neu implementiert werden, um den Fokus bei Ereignissen zu erhalten.

Die Standardimplementierung setzt den Fokus auf die Szene und dann auf das letzte Fokuselement.

Siehe auch QGraphicsItem::focusOutEvent().

QGraphicsItem *QGraphicsScene::focusItem() const

Wenn die Szene aktiv ist, gibt diese Funktion das aktuelle Fokuselement der Szene zurück, oder nullptr, wenn kein Element derzeit den Fokus hat. Wenn die Szene inaktiv ist, gibt diese Funktion das Element zurück, das den Eingabefokus erhält, wenn die Szene aktiv wird.

Das Fokuselement erhält Tastatureingaben, wenn die Szene ein Tastenereignis empfängt.

Siehe auch setFocusItem(), QGraphicsItem::hasFocus(), und isActive().

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

Dieses Signal wird von QGraphicsScene ausgegeben, wenn sich der Fokus in der Szene ändert (d. h. wenn ein Element den Eingabefokus erhält oder verliert oder wenn der Fokus von einem Element zu einem anderen übergeht). Sie können sich mit diesem Signal verbinden, wenn Sie verfolgen müssen, wann andere Elemente den Eingabefokus erhalten. Es ist besonders nützlich für die Implementierung von virtuellen Tastaturen, Eingabemethoden und Cursor-Elementen.

oldFocusItem ist ein Zeiger auf das Element, das zuvor den Fokus hatte, oder 0, wenn kein Element den Fokus hatte, bevor das Signal ausgegeben wurde. newFocusItem ist ein Zeiger auf das Element, das den Eingabefokus erhalten hat, oder nullptr, wenn der Fokus verloren wurde. reason ist der Grund für die Fokusänderung (z. B. wenn die Szene deaktiviert wurde, während ein Eingabefeld den Fokus hatte, würde oldFocusItem auf das Eingabefeldelement zeigen, newFocusItem wäre nullptr und reason wäre Qt::ActiveWindowFocusReason.

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

Findet ein neues Widget, dem der Tastaturfokus gegeben werden soll, wie es für Tab und Shift+Tab angemessen ist, und gibt true zurück, wenn es ein neues Widget findet, oder false, wenn es nicht gefunden wird. Wenn next wahr ist, sucht diese Funktion vorwärts; wenn next falsch ist, sucht sie rückwärts.

Sie können diese Funktion in einer Unterklasse von QGraphicsScene neu implementieren, um eine feinkörnige Kontrolle darüber zu erhalten, wie der Fokus der Registerkarte innerhalb Ihrer Szene weitergegeben wird. Die Standardimplementierung basiert auf der durch QGraphicsWidget::setTabOrder() definierten Tabulator-Fokuskette.

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

Dieser Event-Handler für das Ereignis focusEvent kann in einer Unterklasse neu implementiert werden, um Ereignisse zum Entfernen des Fokus zu empfangen.

Die Standardimplementierung entfernt den Fokus von jedem Fokuselement und entfernt dann den Fokus aus der Szene.

Siehe auch QGraphicsItem::focusInEvent().

bool QGraphicsScene::hasFocus() const

Gibt true zurück, wenn die Szene den Fokus hat; andernfalls wird false zurückgegeben. Wenn die Szene den Fokus hat, leitet sie Tastenereignisse von QKeyEvent an jedes Element weiter, das den Fokus hat.

Siehe auch setFocus() und setFocusItem().

qreal QGraphicsScene::height() const

Diese Komfortfunktion ist gleichbedeutend mit dem Aufruf von sceneRect().height().

Siehe auch width().

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

Dieser Ereignisbehandler für das Ereignis helpEvent kann in einer Unterklasse neu implementiert werden, um Hilfeereignisse zu empfangen. Die Ereignisse sind vom Typ QEvent::ToolTip, die erzeugt werden, wenn ein Tooltip angefordert wird.

Die Standardimplementierung zeigt den Tooltip des obersten sichtbaren Elements, d. h. des Elements mit dem höchsten z-Wert, an der Position des Mauszeigers. Wenn für kein Element ein Tooltip gesetzt ist, führt diese Funktion nichts aus.

Hinweis: Siehe items() für eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden.

Siehe auch QGraphicsItem::toolTip() und QGraphicsSceneHelpEvent.

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

Dieser Eventhandler für das Ereignis event kann in einer Unterklasse neu implementiert werden, um Eingabemethodenereignisse für die Szene zu empfangen.

Die Standardimplementierung leitet das Ereignis an focusItem() weiter. Wenn kein Element derzeit den Fokus hat oder das aktuelle Fokuselement keine Eingabemethoden akzeptiert, tut diese Funktion nichts.

Siehe auch QGraphicsItem::inputMethodEvent().

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

Diese Methode wird von Eingabemethoden verwendet, um eine Reihe von Eigenschaften der Szene abzufragen, damit komplexe Eingabemethodenoperationen wie Unterstützung für umgebenden Text und Umrechnungen unterstützt werden können.

Der Parameter query gibt an, welche Eigenschaft abgefragt wird.

Siehe auch QWidget::inputMethodQuery().

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

Invalidiert und plant ein erneutes Zeichnen von layers in rect in der Szene. Alle zwischengespeicherten Inhalte in layers werden bedingungslos ungültig gemacht und neu gezeichnet.

Sie können diese Funktionsüberladung verwenden, um QGraphicsScene über Änderungen des Hintergrunds oder des Vordergrunds der Szene zu informieren. Diese Funktion wird üblicherweise für Szenen mit kachelbasierten Hintergründen verwendet, um Änderungen zu melden, wenn QGraphicsView CacheBackground aktiviert hat.

Beispiel:

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]);
        }
    }
}

Beachten Sie, dass QGraphicsView derzeit nur die Zwischenspeicherung des Hintergrunds unterstützt (siehe QGraphicsView::CacheBackground). Diese Funktion ist äquivalent zum Aufruf von update(), wenn eine andere Ebene als BackgroundLayer übergeben wird.

Siehe auch QGraphicsView::resetCachedContent().

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

Dies ist eine überladene Funktion.

Diese Komfortfunktion ist gleichbedeutend mit dem Aufruf von invalidate(QRectF(x, y, w, h), layers);

bool QGraphicsScene::isActive() const

Gibt true zurück, wenn die Szene aktiv ist (d. h. sie wird von mindestens einem QGraphicsView betrachtet, der aktiv ist); andernfalls wird false zurückgegeben.

Siehe auch QGraphicsItem::isActive() und QWidget::isActiveWindow().

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

Liefert das oberste sichtbare Element an der angegebenen Position position oder nullptr, wenn es keine Elemente an dieser Position gibt.

deviceTransform ist die Transformation, die für die Ansicht gilt, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

Hinweis: Siehe items() für eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden.

Siehe auch items(), collidingItems(), und Sorting.

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

Dies ist eine überladene Funktion.

Gibt das oberste sichtbare Element an der durch (x, y) angegebenen Position zurück, oder nullptr, wenn es an dieser Position keine Elemente gibt.

deviceTransform ist die Transformation, die für die Ansicht gilt, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

Diese Komfortfunktion entspricht dem Aufruf von itemAt(QPointF(x, y), deviceTransform).

Hinweis: Siehe items() für eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden.

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

Gibt eine geordnete Liste aller Objekte in der Szene zurück. order bestimmt die Stapelreihenfolge.

Siehe auch addItem(), removeItem(), und Sorting.

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

Gibt alle sichtbaren Elemente zurück, die sich, abhängig von mode, an der angegebenen pos in einer nach order sortierten Liste befinden. In diesem Fall definiert "sichtbar" Elemente, für die: isVisible() den Wert true zurückgibt, effectiveOpacity() einen Wert größer als 0,0 (was vollständig transparent ist) zurückgibt und das übergeordnete Element es nicht abschneidet.

Der Standardwert für mode ist Qt::IntersectsItemShape; alle Elemente, deren exakte Form sich mit pos überschneidet, werden zurückgegeben.

deviceTransform ist die Transformation, die für die Ansicht gilt, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

Siehe auch itemAt() und Sorting.

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

Dies ist eine überladene Funktion.

Gibt alle sichtbaren Elemente zurück, die sich je nach mode entweder innerhalb des angegebenen path befinden oder sich mit diesem überschneiden, und zwar in einer nach order sortierten Liste. In diesem Fall definiert "sichtbar" Elemente, für die: isVisible() den Wert true zurückgibt, effectiveOpacity() einen Wert größer als 0.0 zurückgibt (was vollständig transparent ist) und das übergeordnete Element es nicht abschneidet.

Der Standardwert für mode ist Qt::IntersectsItemShape; es werden alle Elemente zurückgegeben, deren exakte Form sich mit path überschneidet oder von diesem enthalten wird.

deviceTransform ist die Transformation, die für die Ansicht gilt, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

Siehe auch itemAt() und Sorting.

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

Dies ist eine überladene Funktion.

Gibt alle sichtbaren Elemente zurück, die sich je nach mode entweder innerhalb des angegebenen polygon befinden oder sich mit diesem überschneiden, und zwar in einer nach order sortierten Liste. In diesem Fall definiert "sichtbar" Elemente, für die: isVisible() den Wert true zurückgibt, effectiveOpacity() einen Wert größer als 0.0 zurückgibt (was vollständig transparent ist) und das übergeordnete Element es nicht abschneidet.

Der Standardwert für mode ist Qt::IntersectsItemShape; es werden alle Elemente zurückgegeben, deren exakte Form sich mit polygon überschneidet oder von diesem enthalten wird.

deviceTransform ist die Transformation, die für die Ansicht gilt, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

Siehe auch itemAt() und Sorting.

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

Dies ist eine überladene Funktion.

Gibt alle sichtbaren Elemente zurück, die sich je nach mode entweder innerhalb des angegebenen rect befinden oder sich mit diesem überschneiden, und zwar in einer nach order sortierten Liste. In diesem Fall definiert "sichtbar" Elemente, für die: isVisible() den Wert true zurückgibt, effectiveOpacity() einen Wert größer als 0.0 zurückgibt (was vollständig transparent ist) und das übergeordnete Element es nicht abschneidet.

Der Standardwert für mode ist Qt::IntersectsItemShape; es werden alle Elemente zurückgegeben, deren exakte Form sich mit rect überschneidet oder von diesem enthalten wird.

deviceTransform ist die Transformation, die für die Ansicht gilt, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

Siehe auch itemAt() und Sorting.

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

Dies ist eine überladene Funktion.

Gibt alle sichtbaren Elemente zurück, die sich, abhängig von mode, entweder innerhalb des durch x, y, w und h definierten Rechtecks befinden oder dieses schneiden, und zwar in einer nach order sortierten Liste. In diesem Fall definiert "sichtbar" Elemente, für die: isVisible() den Wert true zurückgibt, effectiveOpacity() einen Wert größer als 0,0 zurückgibt (was vollständig transparent ist) und das übergeordnete Element es nicht beschneidet.

deviceTransform ist die Transformation, die für die Ansicht gilt, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

QRectF QGraphicsScene::itemsBoundingRect() const

Berechnet und liefert das Begrenzungsrechteck aller Elemente in der Szene. Diese Funktion arbeitet durch Iteration über alle Elemente und kann daher bei großen Szenen langsam sein.

Siehe auch sceneRect().

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

Dieser Event-Handler für das Ereignis keyEvent kann in einer Unterklasse neu implementiert werden, um Tastendruck-Ereignisse zu empfangen. Die Standardimplementierung leitet das Ereignis an das aktuelle Fokuselement weiter.

Siehe auch QGraphicsItem::keyPressEvent() und focusItem().

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

Dieser Event-Handler für das Ereignis keyEvent kann in einer Unterklasse neu implementiert werden, um Ereignisse zum Loslassen von Tasten zu empfangen. Die Standardimplementierung leitet das Ereignis an das aktuelle Fokuselement weiter.

Siehe auch QGraphicsItem::keyReleaseEvent() und focusItem().

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

Dieser Event-Handler für das Ereignis mouseEvent kann in einer Unterklasse neu implementiert werden, um Maus-Doppelklick-Ereignisse für die Szene zu empfangen.

Wenn jemand einen Doppelklick auf die Szene ausführt, empfängt die Szene zuerst ein Mausdruck-Ereignis, gefolgt von einem Loslass-Ereignis (d. h. einem Klick), dann ein Doppelklick-Ereignis und schließlich ein Loslass-Ereignis. Wenn das Doppelklick-Ereignis an ein anderes Element als das, das das erste Drücken und Loslassen erhalten hat, gesendet wird, wird es als Druckereignis gesendet. Dreifachklick-Ereignisse werden in diesem Fall jedoch nicht als Doppelklick-Ereignisse ausgelöst.

Die Standardimplementierung ist ähnlich wie mousePressEvent().

Hinweis: Siehe items() für eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden.

Siehe auch QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseMoveEvent(), QGraphicsItem::mouseReleaseEvent(), und QGraphicsItem::setAcceptedMouseButtons().

QGraphicsItem *QGraphicsScene::mouseGrabberItem() const

Gibt das aktuelle Mousegrabber-Element zurück, oder nullptr, wenn kein Element die Maus greift. Das Mausgrabber-Element ist das Element, das alle Mausereignisse empfängt, die an die Szene gesendet werden.

Ein Element wird zum Mausgrabber, wenn es ein Mausdruckereignis empfängt und annimmt, und es bleibt Mausgrabber, bis eines der folgenden Ereignisse eintritt:

• Wenn das Element ein Mausfreigabe-Ereignis empfängt, während keine anderen Tasten gedrückt sind, verliert es die Mausbelegung.
• Wenn das Element unsichtbar wird (z. B. wenn jemand item->setVisible(false) aufruft) oder wenn es deaktiviert wird (z. B. wenn jemand item->setEnabled(false) aufruft), verliert es den Mausgriff.
• Wenn der Gegenstand aus der Szene entfernt wird, verliert er den Mauszeiger.

Wenn der Gegenstand seinen Mausgriff verliert, ignoriert die Szene alle Mausereignisse, bis ein neuer Gegenstand die Maus ergreift (d. h. bis ein neuer Gegenstand ein Mausdruckereignis erhält).

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

Dieser Eventhandler für das Ereignis mouseEvent kann in einer Unterklasse neu implementiert werden, um Mausbewegungsereignisse für die Szene zu empfangen.

Die Standardimplementierung hängt vom Zustand des Mausgrabbers ab. Wenn ein Mausgrabber-Element vorhanden ist, wird das Ereignis an den Mausgrabber gesendet. Wenn es an der aktuellen Position Elemente gibt, die Hover-Ereignisse akzeptieren, wird das Ereignis in ein Hover-Ereignis übersetzt und akzeptiert; andernfalls wird es ignoriert.

Siehe auch QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseReleaseEvent(), QGraphicsItem::mouseDoubleClickEvent(), und QGraphicsItem::setAcceptedMouseButtons().

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

Dieser Eventhandler für das Ereignis mouseEvent kann in einer Unterklasse neu implementiert werden, um Mausdruckereignisse für die Szene zu empfangen.

Die Standardimplementierung hängt vom Zustand der Szene ab. Wenn ein Mausgrabber-Element vorhanden ist, wird das Ereignis an den Mausgrabber gesendet. Andernfalls wird es an das oberste sichtbare Element weitergeleitet, das Mausereignisse an der Szenenposition des Ereignisses annimmt, und dieses Element wird sofort zum Mausgrabber-Element.

Befindet sich an der angegebenen Position in der Szene kein Element, wird der Auswahlbereich zurückgesetzt, ein beliebiges Fokuselement verliert seinen Eingabefokus, und das Ereignis wird dann ignoriert.

Hinweis: Siehe items() für eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden.

Siehe auch QGraphicsItem::mousePressEvent() und QGraphicsItem::setAcceptedMouseButtons().

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

Dieser Event-Handler für das Ereignis mouseEvent kann in einer Unterklasse neu implementiert werden, um Mausfreigabe-Ereignisse für die Szene zu empfangen.

Die Standardimplementierung hängt vom Zustand des Mausgrabbers ab. Wenn kein Mausgrabber vorhanden ist, wird das Ereignis ignoriert. Andernfalls, wenn ein Mausgrabber vorhanden ist, wird das Ereignis an den Mausgrabber gesendet. Wenn diese Mausfreigabe die letzte gedrückte Maustaste darstellt, verliert das Mausgreifer-Element den Mausgriff.

Siehe auch QGraphicsItem::mousePressEvent(), QGraphicsItem::mouseMoveEvent(), QGraphicsItem::mouseDoubleClickEvent(), und QGraphicsItem::setAcceptedMouseButtons().

void QGraphicsScene::removeItem(QGraphicsItem *item)

Entfernt das Element item und alle seine Kinder aus der Szene. Der Besitz von item wird an den Aufrufer weitergegeben (d.h. QGraphicsScene wird item nicht mehr löschen, wenn es zerstört wird).

Siehe auch addItem().

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

Rendert das source Rect aus der Szene in target, unter Verwendung von painter. Diese Funktion ist nützlich, um den Inhalt der Szene auf ein Malgerät wie QImage zu übertragen (z.B. um einen Screenshot zu machen) oder um mit QPrinter zu drucken. Ein Beispiel:

QGraphicsScene scene;
scene.addItem(...
...
QPrinter printer(QPrinter::HighResolution);
printer.setPaperSize(QPrinter::A4);

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

Wenn source ein Null-Rect ist, verwendet diese Funktion sceneRect(), um zu bestimmen, was gerendert werden soll. Wenn target ein Null-Rect ist, werden die Abmessungen des Malgeräts von painter verwendet.

Der Inhalt des Quell-Rects wird gemäß aspectRatioMode transformiert, um in das Ziel-Rect zu passen. Standardmäßig wird das Seitenverhältnis beibehalten, und source wird so skaliert, dass es in target passt.

Siehe auch QGraphicsView::render().

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

Dieses Signal wird von QGraphicsScene ausgegeben, wenn sich das Szenenrechteck ändert. Der Parameter rect ist das neue Szenerechteck.

Siehe auch QGraphicsView::updateSceneRect().

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

Gibt eine Liste aller aktuell ausgewählten Elemente zurück. Die Elemente werden in keiner bestimmten Reihenfolge zurückgegeben.

Siehe auch setSelectionArea().

QPainterPath QGraphicsScene::selectionArea() const

Gibt den Auswahlbereich zurück, der zuvor mit setSelectionArea() festgelegt wurde, oder einen leeren QPainterPath, wenn kein Auswahlbereich festgelegt wurde.

Siehe auch setSelectionArea().

[signal] void QGraphicsScene::selectionChanged()

Dieses Signal wird von QGraphicsScene ausgegeben, wenn sich die Auswahl ändert. Sie können selectedItems() aufrufen, um die neue Liste der ausgewählten Elemente zu erhalten.

Die Auswahl ändert sich immer dann, wenn ein Element ausgewählt oder abgewählt wird, wenn ein Auswahlbereich gesetzt, gelöscht oder anderweitig geändert wird, wenn ein vorausgewähltes Element zur Szene hinzugefügt wird oder wenn ein ausgewähltes Element aus der Szene entfernt wird.

QGraphicsScene gibt dieses Signal nur einmal für Gruppenauswahloperationen aus. Wenn Sie z.B. einen Auswahlbereich setzen, ein QGraphicsItemGroup auswählen oder abwählen, oder wenn Sie ein übergeordnetes Element, das mehrere ausgewählte Elemente enthält, zur Szene hinzufügen oder aus ihr entfernen, wird selectionChanged() nur einmal nach Abschluss der Operation ausgegeben (anstatt einmal für jedes Element).

Siehe auch setSelectionArea(), selectedItems(), und QGraphicsItem::setSelected().

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

Sendet das Ereignis event an das Element item durch mögliche Ereignisfilter.

Das Ereignis wird nur gesendet, wenn das Element aktiviert ist.

Gibt false zurück, wenn das Ereignis gefiltert wurde oder wenn das Element deaktiviert ist. Andernfalls wird der Wert zurückgegeben, der vom Ereignishandler zurückgegeben wurde.

Siehe auch QGraphicsItem::sceneEvent() und QGraphicsItem::sceneEventFilter().

void QGraphicsScene::setActivePanel(QGraphicsItem *item)

Aktiviert item, das ein Element in dieser Szene sein muss. Sie können auch 0 für item übergeben. In diesem Fall deaktiviert QGraphicsScene alle derzeit aktiven Elemente.

Wenn die Szene derzeit inaktiv ist, bleibt item inaktiv, bis die Szene aktiv wird (oder, ir item ist nullptr, wird kein Element aktiviert).

Siehe auch activePanel(), isActive(), und QGraphicsItem::isActive().

void QGraphicsScene::setActiveWindow(QGraphicsWidget *widget)

Aktiviert widget, das ein Widget in dieser Szene sein muss. Sie können auch 0 für widget übergeben. In diesem Fall wird QGraphicsScene jedes derzeit aktive Fenster deaktivieren.

Siehe auch activeWindow() und QGraphicsWidget::isActiveWindow().

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

Setzt den Fokus auf die Szene, indem ein QFocusEvent an die Szene gesendet wird, wobei focusReason als Grund angegeben wird. Wenn die Szene den Fokus wiedererlangt, nachdem sie ihn zuvor verloren hat, während ein Element den Fokus hatte, erhält das zuletzt fokussierte Element den Fokus mit focusReason als Grund.

Wenn die Szene bereits den Fokus hat, bewirkt diese Funktion nichts.

Siehe auch hasFocus(), clearFocus(), und setFocusItem().

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

Setzt das Fokuselement der Szene auf item, mit dem Fokusgrund focusReason, nachdem der Fokus von allen vorherigen Elementen, die den Fokus hatten, entfernt wurde.

Wenn item nullptr ist, oder wenn es entweder keinen Fokus akzeptiert (d.h. das Flag QGraphicsItem::ItemIsFocusable ist nicht aktiviert), oder nicht sichtbar oder nicht aktiviert ist, entfernt diese Funktion nur den Fokus von allen vorherigen Fokus-Elementen.

Wenn das Element nicht nullptr ist und die Szene derzeit keinen Fokus hat (d.h. hasFocus() gibt false zurück), ruft diese Funktion automatisch setFocus() auf.

Siehe auch focusItem(), hasFocus(), und setFocus().

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

Setzt den Auswahlbereich auf path. Alle Elemente innerhalb dieses Bereichs werden sofort ausgewählt, und alle Elemente außerhalb sind nicht ausgewählt. Sie können die Liste aller ausgewählten Elemente erhalten, indem Sie selectedItems() aufrufen.

deviceTransform ist die Transformation, die für die Ansicht gilt, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

Damit ein Element ausgewählt werden kann, muss es als auswählbar markiert sein (QGraphicsItem::ItemIsSelectable).

Siehe auch clearSelection() und selectionArea().

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

Dies ist eine überladene Funktion.

Setzt den Auswahlbereich auf path und verwendet mode, um festzustellen, ob Elemente im Auswahlbereich enthalten sind.

deviceTransform ist die Transformation, die für die Ansicht gilt, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

selectionOperation bestimmt, was mit den aktuell ausgewählten Elementen geschehen soll.

Siehe auch clearSelection() und selectionArea().

void QGraphicsScene::setStyle(QStyle *style)

Setzt oder ersetzt den Stil der Szene auf style und repariert den Stil für diese Szene. Alle zuvor zugewiesenen Stile werden gelöscht. Der Stil der Szene ist standardmäßig auf QApplication::style() eingestellt und dient als Standard für alle QGraphicsWidget Elemente in der Szene.

Eine Änderung des Stils, entweder direkt durch Aufruf dieser Funktion oder indirekt durch Aufruf von QApplication::setStyle(), aktualisiert automatisch den Stil für alle Widgets in der Szene, denen nicht explizit ein Stil zugewiesen wurde.

Wenn style nullptr ist, wird QGraphicsScene auf QApplication::style() zurückgesetzt.

Siehe auch style().

QStyle *QGraphicsScene::style() const

Gibt den Stil der Szene zurück, oder dasselbe wie QApplication::style(), wenn der Szene nicht explizit ein Stil zugewiesen worden ist.

Siehe auch setStyle().

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

Plant eine Neuzeichnung des Bereichs rect auf der Szene.

Siehe auch sceneRect() und changed().

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

Dies ist eine überladene Funktion.

Diese Funktion ist gleichbedeutend mit dem Aufruf von update(QRectF(x, y, w, h));

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

Gibt eine Liste aller Ansichten zurück, die diese Szene anzeigen.

Siehe auch QGraphicsView::scene().

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

Dieser Event-Handler für das Ereignis wheelEvent kann in einer Unterklasse neu implementiert werden, um Mausrad-Ereignisse für die Szene zu empfangen.

Standardmäßig wird das Ereignis an das oberste sichtbare Element unter dem Mauszeiger übermittelt. Wird es ignoriert, wird das Ereignis an das darunter liegende Element weitergegeben, und zwar so lange, bis das Ereignis akzeptiert wird oder die Szene erreicht. Wenn keine Elemente das Ereignis akzeptieren, wird es ignoriert.

Hinweis: Siehe items() für eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden.

Siehe auch QGraphicsItem::wheelEvent().

qreal QGraphicsScene::width() const

Diese Komfortfunktion entspricht dem Aufruf von sceneRect().width().

Siehe auch height().