QGraphicsScene Class

Dokumentation zu Mitgliedsfunktionen

QGraphicsScene::QGraphicsScene(QObject *parent = nullptr)

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

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

Erstellt ein `QGraphicsScene`-Objekt und verwendet dabei ` sceneRect ` als 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)

Erstellt ein QGraphicsScene-Objekt unter Verwendung des durch (x, y) angegebenen Rechtecks sowie der angegebenen Werte width und height für das 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 derzeit aktive Panel zurück oder „ nullptr “, falls derzeit kein Panel aktiv ist.

Siehe auch QGraphicsScene::setActivePanel().

QGraphicsWidget *QGraphicsScene::activeWindow() const

Gibt das aktuell aktive Fenster zurück oder „ nullptr “, falls derzeit kein Fenster aktiv ist.

Siehe auch QGraphicsScene::setActiveWindow().

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

Erstellt ein Ellipsen-Element und fügt es der Szene hinzu; gibt den Zeiger auf das Element zurück. Die Geometrie der Ellipse wird durch rect definiert, und ihr Stift sowie ihr Pinsel werden auf pen bzw. brush initialisiert.

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

Ist das Element sichtbar (d. h., „ QGraphicsItem::isVisible()“ gibt „ true “ zurück), löst „ QGraphicsScene “ die Methode „ changed()“ aus, sobald die Kontrolle wieder an die Ereignisschleife zurückgegeben wird.

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 die „ item “ und alle ihre untergeordneten Elemente hinzu oder verschiebt sie in diese Szene. Diese Szene übernimmt die Eigentumsrechte an der „ item “.

Ist das Element sichtbar (d. h., „ QGraphicsItem::isVisible()“ gibt „true“ zurück), löst „ QGraphicsScene “ die Methode „ changed()“ aus, sobald die Kontrolle wieder an die Ereignisschleife zurückgegeben wird.

Befindet sich das Element bereits in einer anderen Szene, wird es zunächst aus seiner alten Szene entfernt und anschließend dieser Szene als Element der obersten Ebene hinzugefügt.

QGraphicsScene sendet „ItemSceneChange“-Benachrichtigungen an „ item “, während das Element der Szene hinzugefügt wird. Gehört das Element derzeit keiner Szene an, wird nur eine Benachrichtigung gesendet. Gehört es bereits zu einer Szene (d. h., es wird in diese Szene verschoben), sendet „ QGraphicsScene “ eine zusätzliche Benachrichtigung, sobald das Element aus seiner vorherigen Szene entfernt wird.

Wenn es sich bei dem Element um ein Panel handelt, die Szene aktiv ist und es in der Szene kein aktives Panel gibt, 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 und fügt es der Szene hinzu; gibt den Zeiger auf das Element 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 ist.

Ist das Element sichtbar (d. h., „ QGraphicsItem::isVisible()“ gibt „ true “ zurück), löst „ QGraphicsScene “ die Methode „ changed()“ aus, sobald die Kontrolle wieder an die Ereignisschleife zurückgegeben wird.

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())

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

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

Ist das Element sichtbar (d. h., „ QGraphicsItem::isVisible()“ gibt „ true “ zurück), löst „ QGraphicsScene “ die Methode „ changed()“ aus, sobald die Kontrolle wieder an die Ereignisschleife zurückgegeben wird.

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

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

Erstellt ein Pixmap-Element und fügt es der Szene hinzu; gibt den Zeiger auf das Element zurück. Die Pixmap wird durch ` pixmap` definiert.

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

Ist das Element sichtbar (d. h., „ QGraphicsItem::isVisible()“ gibt „ true “ zurück), löst „ QGraphicsScene “ die Funktion „ changed()“ aus, sobald die Kontrolle wieder an die Ereignisschleife zurückgegeben wird.

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

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

Erstellt ein Polygon-Element und fügt es der Szene hinzu; gibt den Zeiger auf das Element zurück. Das Polygon wird durch polygon definiert, und sein Stift sowie sein Pinsel werden auf pen bzw. brush initialisiert.

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

Ist das Element sichtbar (d. h., QGraphicsItem::isVisible() gibt true zurück), löst QGraphicsScene das Ereignis changed() aus, sobald die Kontrolle wieder an die Ereignisschleife zurückgegeben wird.

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

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

Erstellt ein Rechteck-Element und fügt es der Szene hinzu; gibt den Zeiger auf das Element zurück. Die Geometrie des Rechtecks wird durch rect definiert, und sein Stift sowie sein Pinsel werden auf pen bzw. brush initialisiert.

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

Ist das Element sichtbar (d. h., „ QGraphicsItem::isVisible()“ gibt „ true “ zurück), sendet „ QGraphicsScene “ „ changed()“ aus, sobald die Kontrolle wieder an die Ereignisschleife zurückgegeben wird.

Siehe auch „ addEllipse()“, „ addLine()“, „ 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 ein „ QGraphicsSimpleTextItem “ und fügt es der Szene hinzu; gibt anschließend den Zeiger auf das Element zurück. Die Textzeichenfolge wird auf „ text “ initialisiert, die Schriftart auf „ font “.

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

Ist das Element sichtbar (d. h., „ QGraphicsItem::isVisible()“ gibt „ true “ zurück), löst „ QGraphicsScene “ die Methode „ changed()“ aus, sobald die Kontrolle wieder an die Ereignisschleife zurückgegeben wird.

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

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

Erstellt ein Textelement und fügt es der Szene hinzu; gibt den Zeiger auf das Element zurück. Die Textzeichenfolge wird auf „ text “ initialisiert, und die Schriftart wird auf „ font “ gesetzt.

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

Ist das Element sichtbar (d. h., „ QGraphicsItem::isVisible()“ gibt „ true “ zurück), löst „ QGraphicsScene “ die Methode „ changed()“ aus, sobald die Kontrolle wieder an die Ereignisschleife zurückgegeben wird.

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

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

Erstellt ein neues „ QGraphicsProxyWidget “ für „ widget “, fügt es der Szene hinzu und gibt einen Zeiger auf den Proxy zurück. „ wFlags “ legt die Standard-Fensterflags für das eingebettete Proxy-Widget fest.

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

Ist das Element sichtbar (d. h., QGraphicsItem::isVisible() gibt true zurück), löst QGraphicsScene die Methode changed() aus, sobald die Kontrolle wieder an die Ereignisschleife zurückgegeben wird.

Beachten Sie, dass Widgets, bei denen das Widget-Attribut ` Qt::WA_PaintOnScreen ` gesetzt ist, sowie Widgets, die eine externe Anwendung oder einen Controller umschließen, nicht unterstützt werden. Beispiele hierfür sind ` QOpenGLWidget ` und `QAxWidget`.

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

[slot] void QGraphicsScene::advance()

Dieser Slot treibt die Szene um einen Schritt voran, indem er für alle Elemente der Szene die Funktion „ QGraphicsItem::advance()“ aufruft. Dies geschieht in zwei Phasen: In der ersten Phase werden alle Elemente darüber informiert, dass sich die Szene ä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 für Animationen auch das Animation Framework verwenden können.

Siehe auch ` QGraphicsItem::advance()` und ` QTimeLine`.

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

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

Siehe auch ` QGraphicsView::updateScene()`.

[slot] void QGraphicsScene::clear()

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

Siehe auch „ addItem()“.

void QGraphicsScene::clearFocus()

Entfernt den Fokus aus der Szene. Wenn beim Aufruf dieser Funktion ein Element den Fokus hat, verliert es diesen und erhält ihn wieder, sobald die Szene den Fokus zurückerhä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 erfolgt über mode. Standardmäßig werden alle Elemente zurückgegeben, deren Form sich mit item schneidet oder die innerhalb der Form von item enthalten sind.

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 Ereignis-Handler 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 an der Position des Ereignisses Kontextmenü-Ereignisse akzeptiert. Wenn an dieser Position kein Element Kontextmenü-Ereignisse akzeptiert, wird das Ereignis ignoriert.

Hinweis: Unter ` items()` finden Sie eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden.

Siehe auch QGraphicsItem::contextMenuEvent().

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

Gruppiert alle Elemente in „ items “ zu einer neuen Gruppe „ QGraphicsItemGroup “ und gibt einen Zeiger auf die Gruppe zurück. Die Gruppe wird mit dem gemeinsamen Vorfahren von ` items ` als übergeordnetem Element und mit der Position (0, 0) erstellt. Alle Elemente werden der Gruppe zugeordnet, und ihre Positionen sowie Transformationen werden auf die Gruppe abgebildet. Ist ` items ` leer, gibt diese Funktion eine leere Gruppe oberster Ebene ` QGraphicsItemGroup` zurück.

QGraphicsScene besitzt das Gruppenelement; Sie müssen es nicht löschen. Um eine Gruppe aufzulösen (zu entgruppieren), rufen Sie „ destroyItemGroup()“ auf.

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

void QGraphicsScene::destroyItemGroup(QGraphicsItemGroup *group)

Weist alle Elemente in „ group “ dem übergeordneten Element „ group “ zu, entfernt anschließend „ 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 übertragen.

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

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

Dieser Ereignis-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 akzeptiert das Ereignis und bereitet die Szene darauf vor, Drag-Move-Ereignisse zu empfangen.

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

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

Dieser Ereignis-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 Ereignis-Handler für das Ereignis „ event “ kann in einer Unterklasse neu implementiert werden, um Drag-Move-Ereignisse für die Szene zu empfangen.

Hinweis: Unter items() finden Sie 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 mithilfe von ` painter`, bevor Elemente und der Vordergrund gezeichnet werden. Implementieren Sie diese Funktion neu, um einen benutzerdefinierten Hintergrund für die Szene bereitzustellen.

Das Zeichnen erfolgt vollständig in Szenenkoordinaten. Der Parameter ` rect ` ist das sichtbare Rechteck.

Wenn Sie lediglich eine Farbe, eine Textur oder einen Farbverlauf für den Hintergrund festlegen möchten, 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 mithilfe von ` painter`, nachdem der Hintergrund und alle Elemente gezeichnet wurden. Implementieren Sie diese Funktion neu, um einen benutzerdefinierten Vordergrund für die Szene bereitzustellen.

Das Zeichnen erfolgt ausschließlich in Szenenkoordinaten. Der Parameter ` rect ` ist das freiliegende Rechteck.

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

Siehe auch ` drawBackground()` und ` drawItems()`.

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

Dieser Ereignis-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)

Implementiert: ` QObject::event(QEvent *e)`.

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

Zusätzlich zum Aufruf der Hilfs-Ereignisbehandler ist diese Funktion dafür zuständig, Mausbewegungsereignisse in Hover-Ereignisse umzuwandeln, wenn kein Maus-Grabber-Element vorhanden ist. Hover-Ereignisse werden direkt an Elemente übermittelt; für sie gibt es keine Hilfsfunktion.

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

Gibt ` true ` zurück, wenn ` event ` erkannt und verarbeitet wurde; andernfalls wird ` false` zurückgegeben.

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

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

Umsetzung von: QObject::eventFilter(QObject *watched, QEvent *event).

QGraphicsScene Filtert die Ereignisse von ` QApplication`, um Änderungen an der Palette und der Schriftart zu erkennen.

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

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

Die Standardimplementierung setzt den Fokus zunächst auf die Szene und anschließend auf das zuletzt fokussierte Element.

Siehe auch ` QGraphicsItem::focusOutEvent()`.

QGraphicsItem *QGraphicsScene::focusItem() const

Wenn die Szene aktiv ist, gibt diese Funktion das aktuell im Fokus stehende Element der Szene zurück oder „ nullptr “, falls derzeit kein Element im Fokus steht. Wenn die Szene inaktiv ist, gibt diese Funktion das Element zurück, das den Eingabefokus erhält, sobald die Szene aktiv wird.

Das Fokus-Element empfängt Tastatureingaben, sobald 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, sobald 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 auf ein anderes wechselt). Sie können dieses Signal abhören, wenn Sie verfolgen möchten, wann andere Elemente den Eingabefokus erhalten. Dies 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 vor der Ausgabe des Signals kein Element den Fokus hatte. ` newFocusItem ` ist ein Zeiger auf das Element, das den Eingabefokus erhalten hat, oder ` nullptr `, wenn der Fokus verloren ging. ` reason ` ist der Grund für die Fokusänderung (wenn beispielsweise die Szene deaktiviert wurde, während ein Eingabefeld den Fokus hatte, würde oldFocusItem auf das Eingabefeld-Element verweisen, newFocusItem wäre nullptr und reason wäre Qt::ActiveWindowFocusReason).

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

Sucht ein neues Widget, dem der Tastaturfokus zugewiesen werden soll, entsprechend den Tasten „Tab“ und „Umschalt+Tab“, und gibt „ true “ zurück, wenn ein neues Widget gefunden wird, andernfalls „false“. Ist „ next “ wahr, sucht diese Funktion vorwärts; ist „ next “ falsch, sucht sie rückwärts.

Sie können diese Funktion in einer Unterklasse von ` QGraphicsScene ` neu implementieren, um eine fein abgestimmte Steuerung darüber zu ermöglichen, wie der Tab-Fokus innerhalb Ihrer Szene weitergegeben wird. Die Standardimplementierung basiert auf der durch ` QGraphicsWidget::setTabOrder()` definierten Tab-Fokus-Kette.

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

Dieser Ereignis-Handler für das Ereignis „ focusEvent “ kann in einer Unterklasse neu implementiert werden, um „Focus-Out“-Ereignisse zu empfangen.

Die Standardimplementierung entfernt den Fokus von jedem Fokuselement und anschließend von 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 Hilfsfunktion entspricht 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 “ und werden erzeugt, 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 an. Wenn für kein Element ein Tooltip festgelegt ist, führt diese Funktion keine Aktion aus.

Hinweis: Unter items() finden Sie 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 Ereignis-Handler für das Ereignis „ event “ kann in einer Unterklasse neu implementiert werden, um Eingabemethode-Ereignisse für die Szene zu empfangen.

Die Standardimplementierung leitet das Ereignis an die Funktion ` focusItem()` weiter. Wenn derzeit kein Element den Fokus hat oder das Element mit dem aktuellen Fokus keine Eingabemethoden akzeptiert, führt diese Funktion keine Aktion aus.

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, um komplexe Eingabemethodenoperationen wie die Unterstützung von umgebendem Text und Rückkonvertierungen zu ermöglichen.

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)

Macht den „ layers “ in „ rect “ der Szene ungültig und veranlasst dessen Neuzeichnung. Alle zwischengespeicherten Inhalte in „ layers “ werden bedingungslos ungültig gemacht und neu gezeichnet.

Sie können diese Funktionsüberladung verwenden, um „ QGraphicsScene “ über Änderungen am Hintergrund oder Vordergrund der Szene zu informieren. Diese Funktion wird häufig bei 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 das Zwischenspeichern des Hintergrunds unterstützt (siehe QGraphicsView::CacheBackground). Diese Funktion entspricht dem Aufruf von „ update()“, wenn eine beliebige Ebene außer „ BackgroundLayer “ übergeben wird.

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

Siehe auch „ QGraphicsView::resetCachedContent()“.

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

Diese Hilfsfunktion entspricht dem Aufruf von `invalidate(QRectF(x, y, w, h), layers);`

bool QGraphicsScene::isActive() const

Gibt „ true “ zurück, wenn die Szene aktiv ist (z. B. wenn sie von mindestens einem aktiven „ QGraphicsView “ betrachtet wird); andernfalls wird „ false “ zurückgegeben.

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

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

Gibt das oberste sichtbare Element an der angegebenen Position ` position` zurück oder ` nullptr `, falls an dieser Position kein Element vorhanden ist.

deviceTransform ist die Transformation, die auf die Ansicht angewendet wird, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

Hinweis: Eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden, finden Sie unter items().

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

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

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

deviceTransform ist die Transformation, die auf die Ansicht angewendet wird, 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: Unter „ items()“ finden Sie eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden.

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

Gibt eine sortierte Liste aller Elemente in der Szene zurück. Die Stapelreihenfolge wird durch „ order “ festgelegt.

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 “ befinden, sortiert nach „ order “. In diesem Fall bezeichnet „sichtbar“ Elemente, für die „isVisible()“ „ true “ zurückgibt, „effectiveOpacity()“ einen Wert größer als 0,0 (was vollständig transparent ist) zurückgibt und das übergeordnete Element das Element nicht ausblendet.

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

deviceTransform ist die Transformation, die auf die Ansicht angewendet wird, 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

Gibt alle sichtbaren Elemente zurück, die – abhängig von ` mode` – sich entweder innerhalb des angegebenen ` path` befinden oder dieses schneiden, und sortiert sie in einer Liste nach ` order`. In diesem Fall bezeichnet „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 sie 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 ist.

deviceTransform ist die Transformation, die auf die Ansicht angewendet wird, 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

Gibt alle sichtbaren Elemente zurück, die – abhängig von ` mode` – sich entweder innerhalb des angegebenen ` polygon` befinden oder dieses schneiden, und sortiert sie in einer Liste nach ` order`. In diesem Fall bezeichnet „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 das Element nicht abschneidet.

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

deviceTransform ist die Transformation, die auf die Ansicht angewendet wird, 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

Gibt alle sichtbaren Elemente zurück, die – abhängig von ` mode` – sich entweder innerhalb des angegebenen ` rect` befinden oder dieses schneiden, und sortiert sie in einer Liste nach ` order`. In diesem Fall bezeichnet „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 das Element nicht abschneidet.

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

deviceTransform ist die Transformation, die auf die Ansicht angewendet wird, 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

Gibt alle sichtbaren Elemente zurück, die – abhängig von ` mode` – sich entweder innerhalb des durch ` x`, ` y`, ` w ` und ` h` definierten Rechtecks befinden oder dieses schneiden, und zwar in einer Liste, die nach ` order` sortiert ist. 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 das Element nicht abschneidet.

deviceTransform ist die Transformation, die auf die Ansicht angewendet wird, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

QRectF QGraphicsScene::itemsBoundingRect() const

Berechnet und gibt den Begrenzungsrahmen aller Elemente in der Szene zurück. Diese Funktion durchläuft nacheinander alle Elemente; daher kann sie bei großen Szenen langsam sein.

Siehe auch „ sceneRect()“.

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

Dieser Ereignishandler für das Ereignis „ keyEvent “ kann in einer Unterklasse neu implementiert werden, um Tastendruckereignisse zu empfangen. Die Standardimplementierung leitet das Ereignis an das Element weiter, das derzeit den Fokus hat.

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

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

Dieser Ereignishandler für das Ereignis „ keyEvent “ kann in einer Unterklasse neu implementiert werden, um Ereignisse beim Loslassen von Tasten zu empfangen. Die Standardimplementierung leitet das Ereignis an das Element mit aktuellem Fokus weiter.

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

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

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

Wenn jemand auf die Szene doppelklickt, erhält die Szene zunächst ein Mausdruck-Ereignis, gefolgt von einem Loslass-Ereignis (d. h. einem Klick), dann ein Doppelklick-Ereignis und schließlich ein Loslass-Ereignis. Wird das Doppelklick-Ereignis an ein anderes Element übermittelt als dasjenige, das den ersten Druck und das Loslassen empfangen hat, wird es als Druckereignis übermittelt. Dreifachklick-Ereignisse werden in diesem Fall jedoch nicht als Doppelklick-Ereignisse übermittelt.

Die Standardimplementierung ähnelt der von ` mousePressEvent()`.

Hinweis: Eine Definition, welche Elemente von dieser Funktion als sichtbar betrachtet werden, finden Sie unter items().

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

QGraphicsItem *QGraphicsScene::mouseGrabberItem() const

Gibt das aktuelle Maus-Grabber-Element zurück oder „ nullptr “, wenn derzeit kein Element die Maus erfasst. Das Maus-Grabber-Element ist das Element, das alle an die Szene gesendeten Mausereignisse empfängt.

Ein Element wird zum Maus-Grabber, wenn es ein Mausklick-Ereignis empfängt und akzeptiert, und bleibt so lange der Maus-Grabber, bis eines der folgenden Ereignisse eintritt:

• Wenn das Element ein Mausloslass-Ereignis empfängt, während keine anderen Tasten gedrückt sind, verliert es den Maus-Grabber-Status.
• Wenn das Element unsichtbar wird (d. h., jemand ruft „ item->setVisible(false) “ auf) oder wenn es deaktiviert wird (d. h., jemand ruft „ item->setEnabled(false) “ auf), verliert es den Maus-Grab.
• Wird das Element aus der Szene entfernt, verliert es den Maus-Grab.

Verliert das Element die Mausfesselung, ignoriert die Szene alle Mausereignisse, bis ein neues Element die Mausfesselung übernimmt (d. h. bis ein neues Element ein Mausdruckereignis empfängt).

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

Dieser Ereignis-Handler 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 Status des Maus-Grabbers ab. Wenn ein Maus-Grabber-Element vorhanden ist, wird das Ereignis an den Maus-Grabber gesendet. Befinden sich an der aktuellen Position Elemente, die Hover-Ereignisse akzeptieren, wird das Ereignis in ein Hover-Ereignis umgewandelt und angenommen; andernfalls wird es ignoriert.

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

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

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

Die Standardimplementierung hängt vom Zustand der Szene ab. Wenn ein Maus-Grabber-Element vorhanden ist, wird das Ereignis an den Maus-Grabber gesendet. Andernfalls wird es an das oberste sichtbare Element weitergeleitet, das Mausereignisse an der im Ereignis angegebenen Position in der Szene akzeptiert, und dieses Element wird umgehend zum Maus-Grabber-Element.

Befindet sich an der angegebenen Position in der Szene kein Objekt, wird der Auswahlbereich zurückgesetzt, jedes Objekt mit Fokus verliert seinen Eingabefokus, und das Ereignis wird anschließend ignoriert.

Hinweis: Unter items() finden Sie 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 Ereignis-Handler für das Ereignis „ mouseEvent “ kann in einer Unterklasse neu implementiert werden, um Mausloslass-Ereignisse für die Szene zu empfangen.

Die Standardimplementierung hängt vom Status des Maus-Grabbers ab. Wenn kein Maus-Grabber vorhanden ist, wird das Ereignis ignoriert. Andernfalls, wenn ein Maus-Grabber-Element vorhanden ist, wird das Ereignis an den Maus-Grabber gesendet. Wenn dieses Mausloslassen die zuletzt gedrückte Maustaste betrifft, verliert das Maus-Grabber-Element daraufhin die Mauskontrolle.

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

void QGraphicsScene::removeItem(QGraphicsItem *item)

Entfernt das Element „ item “ und alle seine untergeordneten Elemente aus der Szene. Die Eigentümerschaft an „ item “ wird an den Aufrufer übertragen (d. h., „ QGraphicsScene “ löscht „ item “ beim Zerstören nicht mehr).

Siehe auch addItem().

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

Rendert das Rechteck ` source ` aus der Szene in ` target` unter Verwendung von ` painter`. Diese Funktion ist nützlich, um den Inhalt der Szene auf einem Zeichen-Device wie beispielsweise einem ` QImage ` zu erfassen (z. B. um einen Screenshot zu erstellen) oder um mit `QPrinter` zu drucken. Beispiel:

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

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

Wenn „ source “ ein Null-Rechteck ist, ermittelt diese Funktion mithilfe von „ sceneRect()“, was gerendert werden soll. Wenn „ target “ ein Null-Rechteck ist, werden die Abmessungen des Zeichen-Geräts von „ painter “ verwendet.

Der Inhalt des Quellrechtecks wird entsprechend aspectRatioMode transformiert, damit er in das Zielrechteck passt. 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 ` immer dann ausgelöst, wenn sich das Szenenrechteck ändert. Der Parameter ` rect ` ist das neue Szenenrechteck.

Siehe auch QGraphicsView::updateSceneRect().

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

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

Siehe auch „ setSelectionArea()“.

QPainterPath QGraphicsScene::selectionArea() const

Gibt den zuvor mit ` setSelectionArea()` festgelegten Auswahlbereich zurück oder, falls kein Auswahlbereich festgelegt wurde, ein leeres ` QPainterPath `.

Siehe auch ` setSelectionArea()`.

[signal] void QGraphicsScene::selectionChanged()

Dieses Signal wird von „ QGraphicsScene “ immer dann ausgelöst, wenn sich die Auswahl ändert. Mit dem Aufruf von „ selectedItems()“ können Sie die neue Liste der ausgewählten Elemente abrufen.

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

QGraphicsScene Bei Gruppenauswahlvorgängen wird dieses Signal nur einmal ausgesendet. Wenn Sie beispielsweise einen Auswahlbereich festlegen, ein ` QGraphicsItemGroup` auswählen oder die Auswahl aufheben oder wenn Sie ein übergeordnetes Element, das mehrere ausgewählte Elemente enthält, zur Szene hinzufügen oder aus ihr entfernen, wird `selectionChanged()` erst nach Abschluss des Vorgangs einmal ausgesendet (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 “, wobei mögliche Ereignisfilter berücksichtigt werden.

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 Ereignis-Handler 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 für „ item “ auch den Wert 0 übergeben; in diesem Fall deaktiviert „ QGraphicsScene “ alle derzeit aktiven Bedienfelder.

Ist die Szene derzeit inaktiv, bleibt „ item “ inaktiv, bis die Szene aktiv wird (oder, falls „ item “ gleich „ nullptr “ ist, 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 für „ widget “ auch den Wert 0 übergeben; in diesem Fall deaktiviert „ QGraphicsScene “ alle derzeit aktiven Fenster.

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 übergeben wird. Wenn die Szene den Fokus wiedererlangt, nachdem sie ihn zuvor verloren hatte, während ein Element den Fokus hatte, erhält das letzte Element, das den Fokus hatte, den Fokus mit „ focusReason “ als Grund.

Wenn die Szene bereits den Fokus hat, führt diese Funktion keine Aktion aus.

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 entfernt wurde, die möglicherweise den Fokus hatten.

Wenn „ item “ gleich „ nullptr “ ist oder wenn dieses Element entweder keinen Fokus annehmen kann (d. h., das Flag „ QGraphicsItem::ItemIsFocusable “ ist nicht aktiviert) oder nicht sichtbar bzw. nicht aktiviert ist, hebt diese Funktion lediglich den Fokus von einem vorherigen Fokuselement auf.

Wenn „item“ 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)

Legt den Auswahlbereich auf „ path “ fest. Alle Elemente innerhalb dieses Bereichs werden sofort ausgewählt, alle Elemente außerhalb werden abgewählt. Die Liste aller ausgewählten Elemente können Sie abrufen, indem Sie „ selectedItems()“ aufrufen.

deviceTransform ist die Transformation, die auf die Ansicht angewendet wird, 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())

Legt den Auswahlbereich auf „ path “ fest und verwendet „ mode “, um festzustellen, ob Elemente im Auswahlbereich enthalten sind.

deviceTransform ist die Transformation, die auf die Ansicht angewendet wird, und muss angegeben werden, wenn die Szene Elemente enthält, die Transformationen ignorieren.

selectionOperation Legt fest, wie mit den aktuell ausgewählten Elementen verfahren werden soll.

Siehe auch „ clearSelection()“ und „ selectionArea()“.

void QGraphicsScene::setStyle(QStyle *style)

Legt den Stil der Szene auf „ style “ fest oder ersetzt ihn und ordnet den Stil dieser Szene neu zu. Jeder zuvor zugewiesene Stil wird gelöscht. Der Stil der Szene ist standardmäßig „ QApplication::style()“ und dient als Standard für alle „ QGraphicsWidget “-Elemente in der Szene.

Das Ändern des Stils – entweder direkt durch Aufruf dieser Funktion oder indirekt durch Aufruf von ` QApplication::setStyle()` – aktualisiert automatisch den Stil aller Widgets in der Szene, denen kein Stil explizit zugewiesen wurde.

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

Siehe auch ` style`().

QStyle *QGraphicsScene::style() const

Gibt den Stil der Szene zurück oder entspricht der Funktion „ QApplication::style()“, falls der Szene kein Stil explizit zugewiesen wurde.

Siehe auch ` setStyle()`.

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

Löst eine Neuzeichnung des Bereichs „ rect “ in der Szene aus.

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

Siehe auch „ sceneRect()“ und „ changed()“.

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

Diese Funktion entspricht 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 Ereignis-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 Cursor weitergeleitet. Wird es ignoriert, wird das Ereignis an das darunterliegende Element weitergeleitet, und so weiter, bis das Ereignis angenommen wird oder die Szene erreicht. Wenn kein Element das Ereignis annimmt, wird es ignoriert.

Hinweis: Unter „ items()“ finden Sie 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()`.