QGraphicsItem Class

Dokumentation zu Mitgliedsfunktionen

[explicit] QGraphicsItem::QGraphicsItem(QGraphicsItem *parent = nullptr)

Erstellt ein `QGraphicsItem` mit dem angegebenen ` parent `-Element. Das von ` QObject::parent()` zurückgegebene übergeordnete Objekt wird dabei nicht verändert.

Wenn parent gleich nullptr ist, können Sie das Element durch Aufruf von QGraphicsScene::addItem() zu einer Szene hinzufügen. Das Element wird dann zu einem Element der obersten Ebene.

Siehe auch „ QGraphicsScene::addItem()“ und „ setParentItem()“.

[virtual noexcept] QGraphicsItem::~QGraphicsItem()

Löscht das „ QGraphicsItem “ und alle seine untergeordneten Elemente. Wenn dieses Element derzeit einer Szene zugeordnet ist, wird es vor dem Löschen aus der Szene entfernt.

bool QGraphicsItem::acceptDrops() const

Gibt „ true “ zurück, wenn dieses Element Drag-and-Drop-Ereignisse akzeptieren kann; andernfalls wird „ false “ zurückgegeben. Standardmäßig akzeptieren Elemente keine Drag-and-Drop-Ereignisse; sie sind für Drag-and-Drop-Vorgänge transparent.

Siehe auch setAcceptDrops().

bool QGraphicsItem::acceptHoverEvents() const

Gibt „ true “ zurück, wenn ein Element Hover-Ereignisse akzeptiert (QGraphicsSceneHoverEvent); andernfalls wird „ false “ zurückgegeben. Standardmäßig akzeptieren Elemente keine Hover-Ereignisse.

Siehe auch „ setAcceptHoverEvents()“ und „ setAcceptedMouseButtons()“.

bool QGraphicsItem::acceptTouchEvents() const

Gibt „ true “ zurück, wenn ein Element „ touch events “ akzeptiert; andernfalls wird „ false “ zurückgegeben. Standardmäßig akzeptieren Elemente keine Touch-Ereignisse.

Siehe auch setAcceptTouchEvents().

Qt::MouseButtons QGraphicsItem::acceptedMouseButtons() const

Gibt die Maustasten zurück, für die dieses Element Mausereignisse akzeptiert. Standardmäßig werden alle Maustasten akzeptiert.

Wenn ein Element eine Maustaste akzeptiert, wird es zum „Mouse Grabber“-Element, sobald ein Mausklick-Ereignis für diese Maustaste ausgelöst wird. Akzeptiert das Element die Taste jedoch nicht, leitet „ QGraphicsScene “ die Mausereignisse an das erste darunterliegende Element weiter, das die Taste akzeptiert.

Siehe auch „ setAcceptedMouseButtons()“ und „ mousePressEvent()“.

[virtual] void QGraphicsItem::advance(int phase)

Diese virtuelle Funktion wird vom Slot ` QGraphicsScene::advance()` zweimal für alle Objekte aufgerufen. In der ersten Phase werden alle Objekte mit ` phase == 0` aufgerufen, was anzeigt, dass die Objekte in der Szene kurz vor dem Weitergehen stehen, und anschließend werden alle Objekte mit ` phase == 1` aufgerufen. Implementieren Sie diese Funktion neu, um Ihr Objekt zu aktualisieren, wenn Sie eine einfache, szenengesteuerte Animation benötigen.

Die Standardimplementierung führt keine Aktion aus.

Diese Funktion ist für Animationen vorgesehen. Eine Alternative besteht darin, mehrfach von ` QObject ` und ` QGraphicsItem ` zu erben und das Animations-Framework zu verwenden.

Siehe auch QGraphicsScene::advance() und QTimeLine.

[pure virtual] QRectF QGraphicsItem::boundingRect() const

Diese rein virtuelle Funktion definiert die äußeren Begrenzungen des Elements als Rechteck; alle Zeichenvorgänge müssen auf den Bereich innerhalb des Begrenzungsrechtecks des Elements beschränkt sein. „ QGraphicsView “ verwendet dies, um festzustellen, ob das Element neu gezeichnet werden muss.

Obwohl die Form des Elements beliebig sein kann, ist das Begrenzungsrechteck immer rechteckig und wird von der Transformation des Elements nicht beeinflusst.

Wenn Sie das Begrenzungsrechteck des Elements ändern möchten, müssen Sie zunächst ` prepareGeometryChange()` aufrufen. Dadurch wird die Szene über die bevorstehende Änderung informiert, sodass sie ihren Elementgeometrie-Index aktualisieren kann; andernfalls ist der Szene die neue Geometrie des Elements nicht bekannt, und die Ergebnisse sind undefiniert (in der Regel bleiben Rendering-Artefakte in der Ansicht zurück).

Implementieren Sie diese Funktion neu, damit ` QGraphicsView ` feststellen kann, welche Teile des Widgets gegebenenfalls neu gezeichnet werden müssen.

Hinweis: Bei Formen, die einen Umriss oder eine Kontur zeichnen, ist es wichtig, die Hälfte der Stiftbreite in das Begrenzungsrechteck einzubeziehen. Eine Kompensation für Antialiasing ist jedoch nicht erforderlich.

Beispiel:

QRectF CircleItem::boundingRect() const
{
    qreal penWidth = 1;
    return QRectF(-radius - penWidth / 2, -radius - penWidth / 2,
                  diameter + penWidth, diameter + penWidth);
}

Siehe auch boundingRegion(), shape(), contains(), Das Koordinatensystem der Grafikansicht und prepareGeometryChange().

QRegion QGraphicsItem::boundingRegion(const QTransform &itemToDeviceTransform) const

Gibt den Begrenzungsbereich für dieses Element zurück. Der Koordinatenraum des zurückgegebenen Bereichs hängt von ` itemToDeviceTransform` ab. Wenn Sie als Parameter eine Identitäts QTransform übergeben, gibt diese Funktion einen lokalen Koordinatenbereich zurück.

Der Begrenzungsbereich beschreibt einen groben Umriss der visuellen Inhalte des Elements. Die Berechnung ist zwar rechenintensiv, aber präziser als boundingRect(), und sie kann dazu beitragen, unnötiges Neuzeichnen bei der Aktualisierung eines Elements zu vermeiden. Dies ist besonders effizient bei dünnen Elementen (z. B. Linien oder einfachen Polygonen). Sie können die Granularität für den Begrenzungsbereich durch Aufruf von ` setBoundingRegionGranularity()` anpassen. Die Standardgranularität ist 0; dabei entspricht der Begrenzungsbereich des Elements seinem Begrenzungsrechteck.

itemToDeviceTransform ist die Transformation von Elementkoordinaten in Gerätekoordinaten. Wenn Sie möchten, dass diese Funktion einen „ QRegion “ in Szenenkoordinaten zurückgibt, können Sie „ sceneTransform()“ als Argument übergeben.

Siehe auch ` boundingRegionGranularity()`.

qreal QGraphicsItem::boundingRegionGranularity() const

Gibt die Granularität des Begrenzungsbereichs des Elements zurück; ein Wert zwischen 0 und 1 (einschließlich). Der Standardwert ist 0 (d. h. die niedrigste Granularität, bei der der Begrenzungsbereich dem Begrenzungsrechteck des Elements entspricht).

Siehe auch „ setBoundingRegionGranularity()“.

QGraphicsItem::CacheMode QGraphicsItem::cacheMode() const

Gibt den Cache-Modus für dieses Element zurück. Der Standardmodus ist „ NoCache “ (d. h., der Cache ist deaktiviert und alle Zeichnungsvorgänge erfolgen sofort).

Siehe auch ` setCacheMode()`.

QList<QGraphicsItem *> QGraphicsItem::childItems() const

Gibt eine Liste der untergeordneten Elemente dieses Elements zurück.

Die Elemente sind nach ihrer Stapelreihenfolge sortiert. Dabei werden sowohl die Einfügereihenfolge der Elemente als auch ihre Z-Werte berücksichtigt.

Siehe auch setParentItem(), zValue() und Sorting.

QRectF QGraphicsItem::childrenBoundingRect() const

Gibt das Begrenzungsrechteck der Nachkommen dieses Elements (d. h. seiner Kinder, deren Kinder usw.) in lokalen Koordinaten zurück. Das Rechteck umfasst alle Nachkommen, nachdem diese in lokale Koordinaten abgebildet wurden. Wenn das Element keine Kinder hat, gibt diese Funktion ein leeres „ QRectF “ zurück.

Das eigene Begrenzungsrechteck dieses Elements wird dabei nicht berücksichtigt; es wird lediglich das kumulierte Begrenzungsrechteck seiner Nachkommen zurückgegeben. Wenn Sie das Begrenzungsrechteck dieses Elements einbeziehen möchten, können Sie boundingRect() mithilfe von QRectF::operator|() zu childrenBoundingRect() hinzufügen.

Diese Funktion hat lineare Komplexität; sie ermittelt die Größe des zurückgegebenen Begrenzungsrechtecks durch Iteration über alle Nachkommen.

Siehe auch ` boundingRect()` und ` sceneBoundingRect()`.

void QGraphicsItem::clearFocus()

Entzieht dem Element den Fokus für Tastatureingaben.

Wenn es den Fokus hat, wird ein „ focus out event “ an dieses Element gesendet, um ihm mitzuteilen, dass es den Fokus verlieren wird.

Nur Elemente, bei denen das Flag „ ItemIsFocusable “ gesetzt ist, oder Widgets, für die eine entsprechende Fokusrichtlinie festgelegt ist, können den Tastaturfokus annehmen.

Siehe auch „ setFocus()“, „ hasFocus()“ und „ QGraphicsWidget::focusPolicy “.

QPainterPath QGraphicsItem::clipPath() const

Gibt den Ausschnittpfad dieses Elements zurück oder einen leeren „ QPainterPath “, falls dieses Element nicht ausgeschnitten ist. Der Ausschnittpfad schränkt das Erscheinungsbild und die Interaktion des Elements ein (d. h., er begrenzt den Bereich, in dem das Element gezeichnet werden kann und für den es Ereignisse empfangen kann).

Sie können das Clipping aktivieren, indem Sie die Flags „ ItemClipsToShape “ oder „ ItemClipsChildrenToShape “ setzen. Der Clipping-Pfad des Elements wird durch die Schnittmenge aller Formen der übergeordneten Elemente berechnet. Wenn für das Element „ ItemClipsToShape “ gesetzt ist, wird der endgültige Clipping-Pfad mit der eigenen Form des Elements geschnitten.

Siehe auch isClipped(), shape() und setFlags().

[virtual] bool QGraphicsItem::collidesWithItem(const QGraphicsItem *other, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

Gibt „ true “ zurück, wenn dieses Element mit „ other “ kollidiert; andernfalls wird „ false “ zurückgegeben.

mode wird auf other angewendet, und die resultierende Form oder das Begrenzungsrechteck wird anschließend mit der Form dieses Elements verglichen. Der Standardwert für mode ist Qt::IntersectsItemShape; other kollidiert mit diesem Element, wenn es sich entweder mit der Form dieses Elements schneidet, diese enthält oder von dieser enthalten wird (Einzelheiten siehe Qt::ItemSelectionMode ).

Die Standardimplementierung basiert auf der Schnittmenge der Formen und ruft bei beiden Elementen die Funktion ` shape()` auf. Da die Komplexität der Schnittmenge beliebiger Formen bei komplexen Formen um eine Größenordnung zunimmt, kann dieser Vorgang merklich zeitaufwendig sein. Sie haben die Möglichkeit, diese Funktion in einer Unterklasse von ` QGraphicsItem ` neu zu implementieren, um einen benutzerdefinierten Algorithmus bereitzustellen. Dies ermöglicht es Ihnen, natürliche Einschränkungen in den Formen Ihrer eigenen Elemente zu nutzen, um die Leistung der Kollisionserkennung zu verbessern. Beispielsweise lässt sich die Kollision zweier untransformierter, perfekt kreisförmiger Elemente sehr effizient durch den Vergleich ihrer Positionen und Radien ermitteln.

Beachten Sie, dass bei der Neuimplementierung dieser Funktion und beim Aufruf von ` shape()` oder ` boundingRect()` auf ` other` die zurückgegebenen Koordinaten zunächst auf das Koordinatensystem dieses Objekts abgebildet werden müssen, bevor eine Schnittmenge ermittelt werden kann.

Siehe auch ` contains()` und ` shape()`.

[virtual] bool QGraphicsItem::collidesWithPath(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

Gibt „ true “ zurück, wenn dieses Element mit „ path “ kollidiert.

Die Kollision wird durch „ mode “ bestimmt. Der Standardwert für „ mode “ ist „ Qt::IntersectsItemShape “; „ path “ kollidiert mit diesem Element, wenn es sich entweder mit dessen Form schneidet, diese enthält oder von dieser enthalten wird.

Beachten Sie, dass diese Funktion prüft, ob die Form des Elements oder sein Begrenzungsrechteck (abhängig von mode) in path enthalten ist, und nicht, ob path in der Form oder dem Begrenzungsrechteck des Elements enthalten ist.

Siehe auch collidesWithItem(), contains() und shape().

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

Gibt eine Liste aller Elemente zurück, die mit diesem Element kollidieren.

Die Art und Weise, wie Kollisionen erkannt werden, wird durch die Anwendung von ` mode ` auf Elemente bestimmt, die mit diesem Element verglichen werden, d. h., die Form oder das Begrenzungsrechteck jedes Elements wird mit der Form dieses Elements abgeglichen. Der Standardwert für ` mode ` ist ` Qt::IntersectsItemShape`.

Siehe auch „ collidesWithItem()“.

QGraphicsItem *QGraphicsItem::commonAncestorItem(const QGraphicsItem *other) const

Gibt den nächstgelegenen gemeinsamen Vorfahren dieses Elements und von other zurück oder nullptr, wenn entweder other gleich nullptr ist oder kein gemeinsamer Vorfahr vorhanden ist.

Siehe auch isAncestorOf().

[virtual] bool QGraphicsItem::contains(const QPointF &point) const

Gibt ` true ` zurück, wenn dieses Element ` point` enthält, das in lokalen Koordinaten angegeben ist; andernfalls wird `false` zurückgegeben. Diese Funktion wird meist von ` QGraphicsView ` aufgerufen, um festzustellen, welches Element sich unter dem Cursor befindet, und aus diesem Grund sollte die Implementierung dieser Funktion so ressourcenschonend wie möglich sein.

Standardmäßig ruft diese Funktion „ shape()“ auf, Sie können sie jedoch in einer Unterklasse neu implementieren, um eine (möglicherweise effizientere) Implementierung bereitzustellen.

Siehe auch „ shape()“, „ boundingRect()“ und „ collidesWithPath()“.

[virtual protected] void QGraphicsItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)

Dieser Ereignis-Handler kann in einer Unterklasse neu implementiert werden, um Kontextmenü-Ereignisse zu verarbeiten. Der Parameter „ event “ enthält Details zum zu bearbeitenden Ereignis.

Wenn Sie das Ereignis ignorieren (d. h. durch Aufruf von ` QEvent::ignore()`), wird ` event ` an alle untergeordneten Elemente weitergeleitet. Wenn kein Element das Ereignis annimmt, wird es von der Szene ignoriert und an die Ansicht weitergeleitet.

Es ist üblich, als Reaktion auf den Empfang eines Kontextmenü-Ereignisses ein „ QMenu “ zu öffnen. Beispiel:

void CustomItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
    QMenu menu;
    QAction *removeAction = menu.addAction("Remove");
    QAction *markAction = menu.addAction("Mark");
    QAction *selectedAction = menu.exec(event->screenPos());
    // ...
}

Die Standardimplementierung ignoriert das Ereignis.

Siehe auch „ sceneEvent()“.

QCursor QGraphicsItem::cursor() const

Gibt die aktuelle Cursorform für das Element zurück. Der Mauszeiger nimmt diese Form an, wenn er sich über diesem Element befindet. Eine Auswahl nützlicher Formen finden Sie unter „ list of predefined cursor objects “.

Ein Editor-Element möchte möglicherweise einen I-Balken-Cursor verwenden:

item->setCursor(Qt::IBeamCursor);

Wenn kein Cursor festgelegt wurde, wird der Cursor des darunterliegenden Elements verwendet.

Siehe auch „ setCursor()“, „ hasCursor()“, „ unsetCursor()“, „ QWidget::cursor “ und „ QGuiApplication::overrideCursor()“.

QVariant QGraphicsItem::data(int key) const

Gibt die benutzerdefinierten Daten dieses Elements für den Schlüssel „ key “ als „ QVariant “ zurück.

Benutzerdefinierte Elementdaten sind nützlich, um beliebige Eigenschaften in einem beliebigen Element zu speichern. Beispiel:

static const int ObjectName = 0;

QGraphicsItem *item = scene.itemAt(100, 50, transform);
if (item->data(ObjectName).toString().isEmpty()) {
    if (qgraphicsitem_cast<CustomItem *>(item))
        item->setData(ObjectName, "Custom");
}

Qt nutzt diese Funktion nicht zum Speichern von Daten; sie dient ausschließlich der Benutzerfreundlichkeit.

Siehe auch ` setData()`.

QTransform QGraphicsItem::deviceTransform(const QTransform &viewportTransform) const

Gibt die Gerätetransformationsmatrix dieses Elements zurück, wobei „ viewportTransform “ verwendet wird, um von Szenenkoordinaten auf Gerätekoordinaten abzubilden. Diese Matrix kann verwendet werden, um Koordinaten und geometrische Formen aus dem lokalen Koordinatensystem dieses Elements auf das Koordinatensystem des Ansichtsfensters (oder eines beliebigen Geräts) abzubilden. Um Koordinaten aus dem Ansichtsfenster abzubilden, müssen Sie zunächst die zurückgegebene Matrix invertieren.

Beispiel:

QGraphicsRectItem rect;
rect.setPos(100, 100);

rect.deviceTransform(view->viewportTransform()).map(QPointF(0, 0));
// returns the item's (0, 0) point in view's viewport coordinates

rect.deviceTransform(view->viewportTransform()).inverted().map(QPointF(100, 100));
// returns view's viewport's (100, 100) coordinate in item coordinates

Diese Funktion entspricht der Kombination der Szenentransformation dieses Elements mit der Viewport-Transformation der Ansicht, berücksichtigt jedoch zusätzlich das Flag „ ItemIgnoresTransformations “. Die Gerätetransformation kann verwendet werden, um eine genaue Koordinatenabbildung (und Kollisionserkennung) für nicht transformierbare Elemente durchzuführen.

Siehe auch „ transform()“, „ setTransform()“, „ scenePos()“, „Das Koordinatensystem der Grafikansicht“ und „ itemTransform()“.

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

Dieser Ereignisbehandler für das Ereignis „ event “ kann neu implementiert werden, um „Drag-Enter“-Ereignisse für dieses Element zu empfangen. „Drag-Enter“-Ereignisse werden generiert, sobald der Cursor in den Bereich des Elements eintritt.

Durch das Akzeptieren des Ereignisses (d. h. durch den Aufruf von ` QEvent::accept()`) akzeptiert das Element neben Drag-Move- und Drag-Leave-Ereignissen auch Drop-Ereignisse. Andernfalls wird das Ereignis ignoriert und an das darunterliegende Element weitergeleitet. Wird das Ereignis akzeptiert, erhält das Element ein Drag-Move-Ereignis, bevor die Kontrolle an die Ereignisschleife zurückgegeben wird.

Eine gängige Implementierung von `dragEnterEvent` akzeptiert oder ignoriert ` event ` in Abhängigkeit von den zugehörigen MIME-Daten in ` event`. Beispiel:

CustomItem::CustomItem()
{
    setAcceptDrops(true);
    //...
}

void CustomItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
{
    event->setAccepted(event->mimeData()->hasFormat("text/plain"));
}

Elemente empfangen standardmäßig keine Drag-and-Drop-Ereignisse; um diese Funktion zu aktivieren, rufen Sie ` setAcceptDrops(true)` auf.

Die Standardimplementierung führt keine Aktion aus.

Siehe auch ` dropEvent()`, ` dragMoveEvent()` und ` dragLeaveEvent()`.

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

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um „Drag-Leave“-Ereignisse für dieses Element zu empfangen. „Drag-Leave“-Ereignisse werden generiert, wenn der Cursor den Bereich des Elements verlässt. In den meisten Fällen müssen Sie diese Funktion nicht neu implementieren, sie kann jedoch nützlich sein, um den Status Ihres Elements zurückzusetzen (z. B. die Hervorhebung).

Der Aufruf von ` QEvent::ignore()` oder ` QEvent::accept()` auf ` event ` hat keine Auswirkung.

Elemente empfangen standardmäßig keine Drag-and-Drop-Ereignisse; um diese Funktion zu aktivieren, rufen Sie ` setAcceptDrops(true)` auf.

Die Standardimplementierung führt keine Aktion aus.

Siehe auch dragEnterEvent(), dropEvent() und dragMoveEvent().

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

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Drag-Move-Ereignisse für dieses Element zu empfangen. Drag-Move-Ereignisse werden generiert, wenn sich der Cursor innerhalb des Bereichs des Elements bewegt. In den meisten Fällen müssen Sie diese Funktion nicht neu implementieren; sie dient dazu, anzugeben, dass nur bestimmte Teile des Elements das Ablegen von Elementen zulassen.

Der Aufruf von ` QEvent::ignore()` oder ` QEvent::accept()` auf ` event ` schaltet um, ob das Element ein Ablegen an der Position des Ereignisses zulässt oder nicht. Standardmäßig ist ` event ` gesetzt, was bedeutet, dass das Element das Ablegen an der angegebenen Position zulässt.

Elemente empfangen standardmäßig keine Drag-and-Drop-Ereignisse; um diese Funktion zu aktivieren, rufen Sie „ setAcceptDrops(true) “ auf.

Die Standardimplementierung führt keine Aktion aus.

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

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

Dieser Ereignisbehandler für das Ereignis „ event “ kann neu implementiert werden, um „Drop“-Ereignisse für dieses Element zu empfangen. Elemente können nur dann „Drop“-Ereignisse empfangen, wenn das letzte „Drag-Move“-Ereignis akzeptiert wurde.

Der Aufruf von ` QEvent::ignore()` oder ` QEvent::accept()` auf ` event ` hat keine Auswirkung.

Elemente empfangen standardmäßig keine Drag-and-Drop-Ereignisse; um diese Funktion zu aktivieren, rufen Sie „ setAcceptDrops(true) “ auf.

Die Standardimplementierung führt keine Aktion aus.

Siehe auch dragEnterEvent(), dragMoveEvent() und dragLeaveEvent().

qreal QGraphicsItem::effectiveOpacity() const

Gibt die effektive Deckkraft dieses Elements zurück, die zwischen 0,0 (transparent) und 1,0 (undurchsichtig) liegt. Dieser Wert setzt sich aus der lokalen Deckkraft dieses Elements sowie den Deckkräften seines übergeordneten Elements und seiner Vorfahren zusammen. Die effektive Deckkraft bestimmt, wie das Element dargestellt wird.

Siehe auch opacity(), setOpacity(), paint(), ItemIgnoresParentOpacity sowie ItemDoesntPropagateOpacityToChildren.

void QGraphicsItem::ensureVisible(const QRectF &rect = QRectF(), int xmargin = 50, int ymargin = 50)

Wenn dieses Element Teil einer Szene ist, die von einem „ QGraphicsView “ angezeigt wird, versucht diese Hilfsfunktion, die Ansicht so zu scrollen, dass „ rect “ innerhalb des Ansichtsfensters sichtbar ist. Wenn „ rect “ ein Null-Rechteck ist (Standardeinstellung), wird für „ QGraphicsItem “ standardmäßig das Begrenzungsrechteck des Elements verwendet. „ xmargin “ und „ ymargin “ geben die Anzahl der Pixel an, die die Ansicht für die Ränder verwenden soll.

Wenn das angegebene Rechteck nicht erreicht werden kann, wird der Inhalt an die nächstgelegene gültige Position gescrollt.

Wird dieses Element nicht von einem „ QGraphicsView “ angezeigt, hat diese Funktion keine Auswirkung.

Siehe auch QGraphicsView::ensureVisible().

void QGraphicsItem::ensureVisible(qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50)

Diese Komfortfunktion entspricht dem Aufruf von `ensureVisible(QRectF(x, y, w, h), xmargin, ymargin).`

bool QGraphicsItem::filtersChildEvents() const

Gibt „ true “ zurück, wenn dieses Element untergeordnete Ereignisse filtert (d. h., alle Ereignisse, die für eines seiner untergeordneten Elemente bestimmt sind, werden stattdessen an dieses Element gesendet); andernfalls wird „false“ zurückgegeben.

Der Standardwert ist „false“; untergeordnete Ereignisse werden nicht gefiltert.

Siehe auch „ setFiltersChildEvents()“.

QGraphicsItem::GraphicsItemFlags QGraphicsItem::flags() const

Gibt die Flags dieses Elements zurück. Die Flags beschreiben, welche konfigurierbaren Funktionen des Elements aktiviert sind und welche nicht. Wenn die Flags beispielsweise „ ItemIsFocusable “ enthalten, kann das Element den Eingabefokus annehmen.

Standardmäßig sind keine Flags aktiviert.

Siehe auch „ setFlags()“ und „ setFlag()“.

[virtual protected] void QGraphicsItem::focusInEvent(QFocusEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um bei Ereignissen für dieses Element den Fokus zu erhalten. Die Standardimplementierung ruft die Funktion „ ensureVisible()“ auf.

Siehe auch „ focusOutEvent()“, „ sceneEvent()“ und „ setFocus()“.

QGraphicsItem *QGraphicsItem::focusItem() const

Wenn dieses Element oder ein untergeordnetes Element dieses Elements derzeit den Eingabefokus hat, gibt diese Funktion einen Zeiger auf dieses Element zurück. Wenn kein untergeordnetes Element den Eingabefokus hat, wird „ nullptr “ zurückgegeben.

Siehe auch „ hasFocus()“, „ setFocus()“ und „ QWidget::focusWidget()“.

[virtual protected] void QGraphicsItem::focusOutEvent(QFocusEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Fokusverlust-Ereignisse für dieses Element zu empfangen. Die Standardimplementierung führt keine Aktion aus.

Siehe auch „ focusInEvent()“, „ sceneEvent()“ und „ setFocus()“.

QGraphicsItem *QGraphicsItem::focusProxy() const

Gibt den Fokus-Proxy dieses Elements zurück oder „ nullptr “, falls dieses Element keinen Fokus-Proxy hat.

Siehe auch „ setFocusProxy()“, „ setFocus()“ und „ hasFocus()“.

void QGraphicsItem::grabKeyboard()

Übernimmt die Tastatureingabe.

Das Element empfängt alle Tastatureingaben für die Szene, bis eines der folgenden Ereignisse eintritt:

• Das Element wird unsichtbar
• Das Element wird aus der Szene entfernt
• Das Element wird gelöscht
• Das Element ruft „ ungrabKeyboard()“ auf
• Ein anderes Element ruft `grabKeyboard()` auf; das Element erhält die Tastaturkontrolle zurück, sobald das andere Element ` ungrabKeyboard()` aufruft.

Wenn ein Element die Tastaturkontrolle erhält, erhält es ein „ QEvent::GrabKeyboard “-Ereignis. Wenn es die Tastaturkontrolle verliert, erhält es ein „ QEvent::UngrabKeyboard “-Ereignis. Diese Ereignisse können verwendet werden, um zu erkennen, wann Ihr Element die Tastaturkontrolle auf andere Weise als durch den Erhalt des Eingabefokus erhält oder verliert.

Es ist in Qt fast nie notwendig, die Tastatureingabe explizit zu übernehmen, da Qt dies sinnvoll automatisch übernimmt und wieder freigibt. Insbesondere übernimmt Qt die Tastatureingabe, wenn Ihr Element den Eingabefokus erhält, und gibt sie wieder frei, wenn Ihr Element den Eingabefokus verliert oder wenn das Element ausgeblendet wird.

Beachten Sie, dass nur sichtbare Elemente die Tastatureingabe übernehmen können. Der Aufruf von `grabKeyboard()` bei einem unsichtbaren Element hat keine Wirkung.

Tastaturereignisse sind davon nicht betroffen.

Siehe auch ` ungrabKeyboard()`, ` grabMouse()` und ` setFocus()`.

void QGraphicsItem::grabMouse()

Übernimmt die Mauseingabe.

Dieses Element empfängt alle Mausereignisse für die Szene, bis eines der folgenden Ereignisse eintritt:

• Das Element wird unsichtbar
• Das Element wird aus der Szene entfernt
• Das Element wird gelöscht
• Das Objekt ruft „ ungrabMouse()“ auf
• Ein anderes Element ruft `grabMouse()` auf; das Element erhält die Mauskontrolle zurück, sobald das andere Element ` ungrabMouse()` aufruft.

Wenn ein Element die Mauskontrolle erhält, erhält es ein „ QEvent::GrabMouse “-Ereignis. Wenn es die Mauskontrolle verliert, erhält es ein „ QEvent::UngrabMouse “-Ereignis. Diese Ereignisse können verwendet werden, um zu erkennen, wann Ihr Element die Mauskontrolle auf andere Weise als durch den Empfang von Mausklick-Ereignissen erhält oder verliert.

In Qt ist es fast nie notwendig, die Maus explizit zu erfassen, da Qt dies auf sinnvolle Weise übernimmt. Insbesondere erfasst Qt die Maus, wenn Sie eine Maustaste drücken, und behält die Mauserfassung bei, bis Sie die letzte Maustaste loslassen. Außerdem rufen Widgets vom Typ „ Qt::Popup “ implizit „grabMouse()“ auf, wenn sie angezeigt werden, und „ ungrabMouse()“, wenn sie ausgeblendet werden.

Beachten Sie, dass nur sichtbare Elemente die Mauseingabe erfassen können. Der Aufruf von `grabMouse()` bei einem unsichtbaren Element hat keine Wirkung.

Tastaturereignisse sind davon nicht betroffen.

Siehe auch ` QGraphicsScene::mouseGrabberItem()`, ` ungrabMouse()` und ` grabKeyboard()`.

QGraphicsEffect *QGraphicsItem::graphicsEffect() const

Gibt einen Zeiger auf den Effekt dieses Elements zurück, sofern vorhanden; andernfalls nullptr.

Siehe auch setGraphicsEffect().

QGraphicsItemGroup *QGraphicsItem::group() const

Gibt einen Zeiger auf die Elementgruppe dieses Elements zurück oder „ nullptr “, falls dieses Element nicht zu einer Gruppe gehört.

Siehe auch setGroup(), QGraphicsItemGroup und QGraphicsScene::createItemGroup().

bool QGraphicsItem::hasCursor() const

Gibt „ true “ zurück, wenn für dieses Element ein Cursor festgelegt ist; andernfalls wird „false“ zurückgegeben.

Standardmäßig ist für Elemente kein Cursor festgelegt. „ cursor()“ gibt einen standardmäßigen Zeigepfeil-Cursor zurück.

Siehe auch ` unsetCursor()`.

bool QGraphicsItem::hasFocus() const

Gibt „ true “ zurück, wenn dieses Element aktiv ist und entweder es selbst oder sein „ focus proxy “ den Tastatureingabefokus besitzt; andernfalls wird „ false “ zurückgegeben.

Siehe auch focusItem(), setFocus(), QGraphicsScene::setFocusItem() und isActive().

void QGraphicsItem::hide()

Blendet das Element aus (Elemente sind standardmäßig sichtbar).

Diese Komfortfunktion entspricht dem Aufruf von setVisible(false).

Siehe auch „ show()“ und „ setVisible()“.

[virtual protected] void QGraphicsItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Hover-Enter-Ereignisse für dieses Element zu empfangen. Die Standardimplementierung ruft „ update()“ auf; andernfalls führt sie keine Aktion aus.

Der Aufruf von ` QEvent::ignore()` oder ` QEvent::accept()` auf ` event ` hat keine Auswirkung.

Siehe auch „ hoverMoveEvent()“, „ hoverLeaveEvent()“, „ sceneEvent()“ und „ setAcceptHoverEvents()“.

[virtual protected] void QGraphicsItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um „Hover-Leave“-Ereignisse für dieses Element zu empfangen. Die Standardimplementierung ruft „ update()“ auf; andernfalls führt sie keine Aktion aus.

Der Aufruf von ` QEvent::ignore()` oder ` QEvent::accept()` auf ` event ` hat keine Auswirkung.

Siehe auch „ hoverEnterEvent()“, „ hoverMoveEvent()“, „ sceneEvent()“ und „ setAcceptHoverEvents()“.

[virtual protected] void QGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Hover-Move-Ereignisse für dieses Element zu empfangen. Die Standardimplementierung führt keine Aktion aus.

Der Aufruf von ` QEvent::ignore()` oder ` QEvent::accept()` für ` event ` hat keine Auswirkung.

Siehe auch „ hoverEnterEvent()“, „ hoverLeaveEvent()“, „ sceneEvent()“ und „ setAcceptHoverEvents()“.

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

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Eingabemethoden-Ereignisse für dieses Element zu empfangen. Die Standardimplementierung ignoriert das Ereignis.

Siehe auch ` inputMethodQuery()` und ` sceneEvent()`.

Qt::InputMethodHints QGraphicsItem::inputMethodHints() const

Gibt die aktuellen Eingabemethode-Hinweise für dieses Element zurück.

Hinweise zur Eingabemethode sind nur für Eingabeelemente relevant. Die Hinweise werden von der Eingabemethode verwendet, um anzugeben, wie sie funktionieren soll. Ist beispielsweise das Flag `Qt::ImhNumbersOnly` gesetzt, ändert die Eingabemethode möglicherweise ihre visuellen Komponenten, um anzuzeigen, dass nur Zahlen eingegeben werden können.

Die Auswirkungen können je nach Implementierung der Eingabemethode variieren.

Siehe auch ` setInputMethodHints()` und ` inputMethodQuery()`.

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

Diese Methode ist nur für Eingabeelemente relevant. Sie wird von der Eingabemethode verwendet, um eine Reihe von Eigenschaften des Elements abzufragen, damit komplexe Eingabemethodenoperationen unterstützt werden können, wie beispielsweise die Berücksichtigung des umgebenden Textes und Rückkonvertierungen. query gibt an, welche Eigenschaft abgefragt wird.

Siehe auch inputMethodEvent() und QInputMethodEvent.

void QGraphicsItem::installSceneEventFilter(QGraphicsItem *filterItem)

Installiert einen Ereignisfilter für dieses Element unter filterItem, wodurch alle Ereignisse für dieses Element zunächst die Funktion sceneEventFilter() von filterItem durchlaufen.

Um die Ereignisse eines anderen Elements zu filtern, installieren Sie dieses Element als Ereignisfilter für das andere Element. Beispiel:

QGraphicsScene scene;
QGraphicsEllipseItem *ellipse = scene.addEllipse(QRectF(-10, -10, 20, 20));
QGraphicsLineItem *line = scene.addLine(QLineF(-10, -10, 20, 20));

line->installSceneEventFilter(ellipse);
// line's events are filtered by ellipse's sceneEventFilter() function.

ellipse->installSceneEventFilter(line);
// ellipse's events are filtered by line's sceneEventFilter() function.

Ein Element kann nur Ereignisse anderer Elemente in derselben Szene filtern. Außerdem kann ein Element seine eigenen Ereignisse nicht filtern; stattdessen können Sie ` sceneEvent()` direkt neu implementieren.

Elemente müssen zu einer Szene gehören, damit Szenen-Ereignisfilter installiert und verwendet werden können.

Siehe auch „ removeSceneEventFilter()“, „ sceneEventFilter()“ und „ sceneEvent()“.

bool QGraphicsItem::isActive() const

Gibt „ true “ zurück, wenn dieses Element aktiv ist; andernfalls wird „ false “ zurückgegeben.

Ein Element kann nur aktiv sein, wenn die Szene aktiv ist. Ein Element ist aktiv, wenn es selbst ein aktives Panel ist oder von einem aktiven Panel abstammt. Elemente in nicht aktiven Panels sind nicht aktiv.

Elemente, die nicht Teil eines Panels sind, folgen der Szenenaktivierung, wenn die Szene kein aktives Panel enthält.

Nur aktive Elemente können den Eingabefokus erhalten.

Siehe auch „ QGraphicsScene::isActive()“, „ QGraphicsScene::activePanel()“, „ panel()“ und „ isPanel()“.

bool QGraphicsItem::isAncestorOf(const QGraphicsItem *child) const

Gibt „ true “ zurück, wenn dieses Element ein Vorfahr von „ child “ ist (d. h., wenn dieses Element das übergeordnete Element von „ child “ ist oder zu den Vorfahren eines der übergeordneten Elemente von „ child “ gehört).

Siehe auch parentItem().

bool QGraphicsItem::isBlockedByModalPanel(QGraphicsItem **blockingPanel = nullptr) const

Gibt „ true “ zurück, wenn dieses Element durch ein modales Fenster verdeckt wird, andernfalls „false“. Ist „ blockingPanel “ ungleich Null, wird „ blockingPanel “ auf das modale Fenster gesetzt, das dieses Element verdeckt. Wird dieses Element nicht verdeckt, wird „ blockingPanel “ von dieser Funktion nicht gesetzt.

Diese Funktion gibt für Elemente, die sich nicht in einer Szene befinden, immer „ false “ zurück.

Siehe auch panelModality(), setPanelModality() und PanelModality.

bool QGraphicsItem::isClipped() const

Gibt „ true “ zurück, wenn dieses Element beschnitten ist. Ein Element ist beschnitten, wenn entweder das Flag „ ItemClipsToShape “ gesetzt ist oder wenn entweder das Element selbst oder einer seiner Vorfahren das Flag „ ItemClipsChildrenToShape “ gesetzt hat.

Das Beschnittverhalten wirkt sich sowohl auf die Darstellung des Elements (d. h. das Zeichnen) als auch auf die Auslösung von Maus- und Hover-Ereignissen aus.

Siehe auch „ clipPath()“, „ shape()“ und „ setFlags()“.

bool QGraphicsItem::isEnabled() const

Gibt „ true “ zurück, wenn das Element aktiviert ist; andernfalls wird „false“ zurückgegeben.

Siehe auch setEnabled().

bool QGraphicsItem::isObscured(const QRectF &rect = QRectF()) const

Gibt „ true “ zurück, wenn „ rect “ vollständig von der undurchsichtigen Form eines der darüber liegenden kollidierenden Objekte verdeckt wird (d. h. mit einem höheren Z-Wert als dieses Objekt).

Siehe auch opaqueArea().

bool QGraphicsItem::isObscured(qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `isObscured(QRectF(x, y, w, h))`.

[virtual] bool QGraphicsItem::isObscuredBy(const QGraphicsItem *item) const

Gibt „ true “ zurück, wenn das Begrenzungsrechteck dieses Elements vollständig von der undurchsichtigen Form von „ item “ verdeckt wird.

Die Basisimplementierung bildet die Funktion ` opaqueArea()` von ` item` auf das Koordinatensystem dieses Elements ab und prüft anschließend, ob die Funktion ` boundingRect()` dieses Elements vollständig innerhalb der abgebildeten Form liegt.

Sie können diese Funktion neu implementieren, um einen benutzerdefinierten Algorithmus bereitzustellen, mit dem ermittelt wird, ob dieses Element von „ item “ verdeckt wird.

Siehe auch „ opaqueArea()“ und „ isObscured()“.

bool QGraphicsItem::isPanel() const

Gibt „ true “ zurück, wenn es sich bei dem Element um ein Panel handelt; andernfalls wird „ false “ zurückgegeben.

Siehe auch „ QGraphicsItem::panel()“ und „ ItemIsPanel “.

bool QGraphicsItem::isSelected() const

Gibt „ true “ zurück, wenn dieses Element ausgewählt ist; andernfalls wird „false“ zurückgegeben.

Elemente, die sich in einer Gruppe befinden, übernehmen den Auswahlstatus der Gruppe.

Elemente sind standardmäßig nicht ausgewählt.

Siehe auch „ setSelected()“ und „ QGraphicsScene::setSelectionArea()“.

bool QGraphicsItem::isUnderMouse() const

Gibt „ true “ zurück, wenn sich dieses Element derzeit in einer der Ansichten unter dem Mauszeiger befindet; andernfalls wird „false“ zurückgegeben.

Siehe auch „ QGraphicsScene::views()“ und „ QCursor::pos()“.

bool QGraphicsItem::isVisible() const

Gibt „ true “ zurück, wenn das Element sichtbar ist; andernfalls wird „false“ zurückgegeben.

Beachten Sie, dass die allgemeine Sichtbarkeit des Elements unabhängig davon ist, ob es tatsächlich von einem ` QGraphicsView` visualisiert wird oder nicht.

Siehe auch ` setVisible()`.

bool QGraphicsItem::isVisibleTo(const QGraphicsItem *parent) const

Gibt „ true “ zurück, wenn das Element für „ parent “ sichtbar ist; andernfalls wird „false“ zurückgegeben. „ parent “ kann „ nullptr “ sein; in diesem Fall gibt diese Funktion zurück, ob das Element für die Szene sichtbar ist oder nicht.

Ein Element ist möglicherweise für seine Vorfahren nicht sichtbar, selbst wenn isVisible() wahr ist. Es kann auch für seine Vorfahren sichtbar sein, selbst wenn isVisible() falsch ist. Ist ein Vorfahr ausgeblendet, wird das Element selbst implizit ausgeblendet; in diesem Fall gibt diese Funktion „false“ zurück.

Siehe auch isVisible() und setVisible().

bool QGraphicsItem::isWidget() const

Gibt „ true “ zurück, wenn es sich bei diesem Element um ein Widget handelt (d. h. QGraphicsWidget); andernfalls wird „ false “ zurückgegeben.

bool QGraphicsItem::isWindow() const

Gibt „ true “ zurück, wenn es sich bei dem Element um ein „ QGraphicsWidget “-Fenster handelt, andernfalls wird „false“ zurückgegeben.

Siehe auch QGraphicsWidget::windowFlags().

[virtual protected] QVariant QGraphicsItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)

Diese virtuelle Funktion wird von QGraphicsItem aufgerufen, um benutzerdefinierte Elemente darüber zu informieren, dass sich ein Teil des Zustands des Elements ändert. Durch die Neuimplementierung dieser Funktion können Sie auf eine Änderung reagieren, und in einigen Fällen (abhängig von change) können Anpassungen vorgenommen werden.

change ist der Parameter des Elements, das sich ändert. ` value ` ist der neue Wert; der Typ des Werts hängt von ` change` ab.

Beispiel:

QVariant Component::itemChange(GraphicsItemChange change, const QVariant &value)
{
    if (change == ItemPositionChange && scene()) {
        // value is the new position.
        QPointF newPos = value.toPointF();
        QRectF rect = scene()->sceneRect();
        if (!rect.contains(newPos)) {
            // Keep the item inside the scene rect.
            newPos.setX(qMin(rect.right(), qMax(newPos.x(), rect.left())));
            newPos.setY(qMin(rect.bottom(), qMax(newPos.y(), rect.top())));
            return newPos;
        }
    }
    return QGraphicsItem::itemChange(change, value);
}

Die Standardimplementierung führt keine Aktion durch und gibt „ value “ zurück.

Hinweis: Bestimmte QGraphicsItem -Funktionen können in einer Neuimplementierung dieser Funktion nicht aufgerufen werden; Einzelheiten finden Sie in der Dokumentation zu GraphicsItemChange.

Siehe auch „ GraphicsItemChange “.

QTransform QGraphicsItem::itemTransform(const QGraphicsItem *other, bool *ok = nullptr) const

Gibt eine „ QTransform “ zurück, die Koordinaten von diesem Element auf „ other “ abbildet. Ist „ ok “ nicht null und gibt es keine solche Transformation, wird der von „ ok “ referenzierte Boolesche Wert auf „false“ gesetzt; andernfalls wird er auf „true“ gesetzt.

Diese Transformation bietet eine Alternative zu den Funktionen „ mapToItem()“ oder „ mapFromItem()“, indem sie die entsprechende Transformation zurückgibt, sodass Sie Formen und Koordinaten selbst abbilden können. Außerdem hilft sie Ihnen dabei, effizienteren Code zu schreiben, wenn Sie wiederholt zwischen denselben beiden Elementen abbilden.

Siehe auch „ mapToItem()“, „ mapFromItem()“ und „ deviceTransform()“.

[virtual protected] void QGraphicsItem::keyPressEvent(QKeyEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Tastendruckereignisse für dieses Element zu empfangen. Die Standardimplementierung ignoriert das Ereignis. Wenn Sie diesen Handler neu implementieren, wird das Ereignis standardmäßig akzeptiert.

Beachten Sie, dass Tastenereignisse nur für Elemente empfangen werden, bei denen das Flag „ ItemIsFocusable “ gesetzt ist und die den Tastatureingabefokus haben.

Siehe auch „ keyReleaseEvent()“, „ setFocus()“, „ QGraphicsScene::setFocusItem()“ und „ sceneEvent()“.

[virtual protected] void QGraphicsItem::keyReleaseEvent(QKeyEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Tastenloslass-Ereignisse für dieses Element zu empfangen. Die Standardimplementierung ignoriert das Ereignis. Wenn Sie diesen Handler neu implementieren, wird das Ereignis standardmäßig akzeptiert.

Beachten Sie, dass Tastenereignisse nur für Elemente empfangen werden, bei denen das Flag „ ItemIsFocusable “ gesetzt ist und die den Tastatureingabefokus haben.

Siehe auch „ keyPressEvent()“, „ setFocus()“, „ QGraphicsScene::setFocusItem()“ und „ sceneEvent()“.

QPainterPath QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPainterPath &path) const

Ordnet den Pfad „ path “, der sich im Koordinatensystem von „ item “ befindet, dem Koordinatensystem dieses Elements zu und gibt den zugeordneten Pfad zurück.

Wenn item gleich nullptr ist, gibt diese Funktion dasselbe Ergebnis zurück wie mapFromScene().

Siehe auch „ itemTransform()“, „ mapFromParent()“, „ mapFromScene()“, „ mapToItem()“ und „Das Koordinatensystem der Grafikansicht“.

QPointF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPointF &point) const

Ordnet den Punkt point, der sich im Koordinatensystem von item befindet, dem Koordinatensystem dieses Elements zu und gibt die zugeordnete Koordinate zurück.

Wenn „ item “ gleich „ nullptr “ ist, gibt diese Funktion dasselbe Ergebnis zurück wie „ mapFromScene()“.

Siehe auch „ itemTransform()“, „ mapFromParent()“, „ mapFromScene()“, „ transform()“, „ mapToItem()“ und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPolygonF &polygon) const

Ordnet das Polygon polygon, das sich im Koordinatensystem von item befindet, dem Koordinatensystem dieses Elements zu und gibt das zugeordnete Polygon zurück.

Wenn item gleich nullptr ist, gibt diese Funktion dasselbe Ergebnis zurück wie mapFromScene().

Siehe auch itemTransform(), mapToItem(), mapFromParent(), transform() und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QRectF &rect) const

Ordnet das Rechteck rect, das sich im Koordinatensystem von item befindet, dem Koordinatensystem dieses Elements zu und gibt das zugeordnete Rechteck als Polygon zurück.

Wenn item gleich nullptr ist, gibt diese Funktion dasselbe Ergebnis zurück wie mapFromScene()

Siehe auch itemTransform(), mapToItem(), mapFromParent(), transform() und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `mapFromItem(item, QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapFromItem(const QGraphicsItem *item, qreal x, qreal y) const

Diese Komfortfunktion entspricht dem Aufruf von `mapFromItem(item, QPointF(x, y))`.

QPainterPath QGraphicsItem::mapFromParent(const QPainterPath &path) const

Ordnet den Pfad path, der sich im Koordinatensystem des übergeordneten Elements dieses Elements befindet, dem Koordinatensystem dieses Elements zu und gibt den zugeordneten Pfad zurück.

Siehe auch „ mapFromScene()“, „ mapFromItem()“, „ mapToParent()“ und „Das Koordinatensystem der Grafikansicht“.

QPointF QGraphicsItem::mapFromParent(const QPointF &point) const

Ordnet den Punkt point, der sich im Koordinatensystem des übergeordneten Elements dieses Elements befindet, dem Koordinatensystem dieses Elements zu und gibt die zugeordnete Koordinate zurück.

Siehe auch „ mapFromItem()“, „ mapFromScene()“, „ transform()“, „ mapToParent()“ und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapFromParent(const QPolygonF &polygon) const

Ordnet das Polygon polygon, das sich im Koordinatensystem des übergeordneten Elements dieses Elements befindet, dem Koordinatensystem dieses Elements zu und gibt das zugeordnete Polygon zurück.

Siehe auch „ mapToParent()“, „ mapToItem()“, „ transform()“ und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapFromParent(const QRectF &rect) const

Ordnet das Rechteck rect, das sich im Koordinatensystem des übergeordneten Elements dieses Elements befindet, dem Koordinatensystem dieses Elements zu und gibt das zugeordnete Rechteck als Polygon zurück.

Siehe auch „ mapToParent()“, „ mapFromItem()“, „ transform()“ und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapFromParent(qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von „ mapFromItem “ (QRectF(x, y, w, h)).

QPointF QGraphicsItem::mapFromParent(qreal x, qreal y) const

Diese Komfortfunktion entspricht dem Aufruf von `mapFromParent(QPointF(x, y))`.

QPainterPath QGraphicsItem::mapFromScene(const QPainterPath &path) const

Ordnet den Pfad path, der sich im Koordinatensystem der Szene dieses Elements befindet, dem Koordinatensystem dieses Elements zu und gibt den zugeordneten Pfad zurück.

Siehe auch „ mapFromParent()“, „ mapFromItem()“, „ mapToScene()“ und „Das Koordinatensystem der Grafikansicht“.

QPointF QGraphicsItem::mapFromScene(const QPointF &point) const

Ordnet den Punkt point, der sich im Koordinatensystem der Szene dieses Elements befindet, dem Koordinatensystem dieses Elements zu und gibt die zugeordnete Koordinate zurück.

Siehe auch „ mapFromItem()“, „ mapFromParent()“, „ transform()“, „ mapToScene()“ und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapFromScene(const QPolygonF &polygon) const

Ordnet das Polygon polygon, das sich im Koordinatensystem der Szene dieses Elements befindet, dem Koordinatensystem dieses Elements zu und gibt das zugeordnete Polygon zurück.

Siehe auch „ mapToScene()“, „ mapFromParent()“, „ transform()“ und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapFromScene(const QRectF &rect) const

Ordnet das Rechteck rect, das sich im Koordinatensystem der Szene dieses Elements befindet, dem Koordinatensystem dieses Elements zu und gibt das zugeordnete Rechteck als Polygon zurück.

Siehe auch „ mapToScene()“, „ mapFromItem()“, „ transform()“ und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapFromScene(qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `mapFromScene(QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapFromScene(qreal x, qreal y) const

Diese Komfortfunktion entspricht dem Aufruf von `mapFromScene(QPointF(x, y))`.

QRectF QGraphicsItem::mapRectFromItem(const QGraphicsItem *item, const QRectF &rect) const

Ordnet das Rechteck rect, das sich im Koordinatensystem von item befindet, dem Koordinatensystem dieses Elements zu und gibt das zugeordnete Rechteck als neues Rechteck zurück (d. h. das umschließende Rechteck des resultierenden Polygons).

Wenn item gleich nullptr ist, gibt diese Funktion dasselbe Ergebnis zurück wie mapRectFromScene().

Siehe auch „ itemTransform()“, „ mapToParent()“, „ mapToScene()“, „ mapFromItem()“ und „Das Koordinatensystem der Grafikansicht“.

QRectF QGraphicsItem::mapRectFromItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `mapRectFromItem(item, QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectFromParent(const QRectF &rect) const

Ordnet das Rechteck rect, das sich im Koordinatensystem des übergeordneten Elements dieses Elements befindet, dem Koordinatensystem dieses Elements zu und gibt das zugeordnete Rechteck als neues Rechteck zurück (d. h. das umschließende Rechteck des resultierenden Polygons).

Siehe auch itemTransform(), mapToParent(), mapToScene(), mapFromItem() und „Das Koordinatensystem der Grafikansicht“.

QRectF QGraphicsItem::mapRectFromParent(qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `mapRectFromParent(QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectFromScene(const QRectF &rect) const

Ordnet das Rechteck rect, das in Szenenkoordinaten vorliegt, dem Koordinatensystem dieses Elements zu und gibt das zugeordnete Rechteck als neues Rechteck zurück (d. h. das umschließende Rechteck des resultierenden Polygons).

Siehe auch „ itemTransform()“, „ mapToParent()“, „ mapToScene()“, „ mapFromItem()“ und „Das Koordinatensystem der Grafikansicht“.

QRectF QGraphicsItem::mapRectFromScene(qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `mapRectFromScene(QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectToItem(const QGraphicsItem *item, const QRectF &rect) const

Ordnet das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem von item zu und gibt das zugeordnete Rechteck als neues Rechteck zurück (d. h. das umschließende Rechteck des resultierenden Polygons).

Wenn item gleich nullptr ist, gibt diese Funktion dasselbe Ergebnis zurück wie mapRectToScene().

Siehe auch „ itemTransform()“, „ mapToParent()“, „ mapToScene()“, „ mapFromItem()“ und „Das Koordinatensystem der Grafikansicht“.

QRectF QGraphicsItem::mapRectToItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `mapRectToItem(item, QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectToParent(const QRectF &rect) const

Ordnet das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem seines übergeordneten Elements zu und gibt das zugeordnete Rechteck als neues Rechteck zurück (d. h. das umschließende Rechteck des resultierenden Polygons).

Siehe auch itemTransform(), mapToParent(), mapToScene(), mapFromItem() und „Das Koordinatensystem der Grafikansicht“.

QRectF QGraphicsItem::mapRectToParent(qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `mapRectToParent(QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectToScene(const QRectF &rect) const

Ordnet das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, dem Szenenkoordinatensystem zu und gibt das zugeordnete Rechteck als neues Rechteck zurück (d. h. das umschließende Rechteck des resultierenden Polygons).

Siehe auch itemTransform(), mapToParent(), mapToScene(), mapFromItem() und „Das Koordinatensystem der Grafikansicht“.

QRectF QGraphicsItem::mapRectToScene(qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `mapRectToScene(QRectF(x, y, w, h))`.

QPainterPath QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPainterPath &path) const

Ordnet den Pfad path, der sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem von item zu und gibt den zugeordneten Pfad zurück.

Wenn item gleich nullptr ist, gibt diese Funktion dasselbe Ergebnis zurück wie mapToScene().

Siehe auch „ itemTransform()“, „ mapToParent()“, „ mapToScene()“, „ mapFromItem()“ und „Das Koordinatensystem der Grafikansicht“.

QPointF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPointF &point) const

Ordnet den Punkt point, der sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem von item zu und gibt die zugeordnete Koordinate zurück.

Wenn item gleich nullptr ist, gibt diese Funktion dasselbe Ergebnis zurück wie mapToScene().

Siehe auch itemTransform(), mapToParent(), mapToScene(), transform(), mapFromItem() und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPolygonF &polygon) const

Ordnet das Polygon polygon, das sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem von item zu und gibt das zugeordnete Polygon zurück.

Wenn item gleich nullptr ist, gibt diese Funktion dasselbe Ergebnis zurück wie mapToScene().

Siehe auch „ itemTransform()“, „ mapToParent()“, „ mapToScene()“, „ mapFromItem()“ und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QRectF &rect) const

Ordnet das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem von item zu und gibt das zugeordnete Rechteck als Polygon zurück.

Wenn item gleich nullptr ist, gibt diese Funktion dasselbe Ergebnis zurück wie mapToScene().

Siehe auch itemTransform(), mapToParent(), mapToScene(), mapFromItem() und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `mapToItem(item, QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapToItem(const QGraphicsItem *item, qreal x, qreal y) const

Diese Komfortfunktion entspricht dem Aufruf von `mapToItem(item, QPointF(x, y))`.

QPainterPath QGraphicsItem::mapToParent(const QPainterPath &path) const

Ordnet den Pfad path, der sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem seines übergeordneten Elements zu und gibt den zugeordneten Pfad zurück. Wenn das Element kein übergeordnetes Element hat, wird path dem Koordinatensystem der Szene zugeordnet.

Siehe auch mapToScene(), mapToItem(), mapFromParent() und Das Koordinatensystem der Grafikansicht.

QPointF QGraphicsItem::mapToParent(const QPointF &point) const

Ordnet den Punkt point, der sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem seines übergeordneten Elements zu und gibt die zugeordnete Koordinate zurück. Wenn das Element kein übergeordnetes Element hat, wird point dem Koordinatensystem der Szene zugeordnet.

Siehe auch mapToItem(), mapToScene(), transform(), mapFromParent() und Das Koordinatensystem der Grafikansicht.

QPolygonF QGraphicsItem::mapToParent(const QPolygonF &polygon) const

Ordnet das Polygon polygon, das sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem seines übergeordneten Elements zu und gibt das zugeordnete Polygon zurück. Wenn das Element kein übergeordnetes Element hat, wird polygon dem Koordinatensystem der Szene zugeordnet.

Siehe auch mapToScene(), mapToItem(), mapFromParent() und Das Koordinatensystem der Grafikansicht.

QPolygonF QGraphicsItem::mapToParent(const QRectF &rect) const

Ordnet das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem seines übergeordneten Elements zu und gibt das zugeordnete Rechteck als Polygon zurück. Wenn das Element kein übergeordnetes Element hat, wird rect dem Koordinatensystem der Szene zugeordnet.

Siehe auch mapToScene(), mapToItem(), mapFromParent() und Das Koordinatensystem der Grafikansicht.

QPolygonF QGraphicsItem::mapToParent(qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `mapToParent(QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapToParent(qreal x, qreal y) const

Diese Komfortfunktion entspricht dem Aufruf von `mapToParent(QPointF(x, y))`.

QPainterPath QGraphicsItem::mapToScene(const QPainterPath &path) const

Ordnet den Pfad path, der sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem der Szene zu und gibt den zugeordneten Pfad zurück.

Siehe auch „ mapToParent()“, „ mapToItem()“, „ mapFromScene()“ und „Das Koordinatensystem der Grafikansicht“.

QPointF QGraphicsItem::mapToScene(const QPointF &point) const

Ordnet den Punkt point, der sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem der Szene zu und gibt die zugeordnete Koordinate zurück.

Siehe auch mapToItem(), mapToParent(), transform(), mapFromScene() und Das Koordinatensystem der Grafikansicht.

QPolygonF QGraphicsItem::mapToScene(const QPolygonF &polygon) const

Ordnet das Polygon polygon, das sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem der Szene zu und gibt das zugeordnete Polygon zurück.

Siehe auch „ mapToParent()“, „ mapToItem()“, „ mapFromScene()“ und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapToScene(const QRectF &rect) const

Ordnet das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, dem Koordinatensystem der Szene zu und gibt das zugeordnete Rechteck als Polygon zurück.

Siehe auch mapToParent(), mapToItem(), mapFromScene() und „Das Koordinatensystem der Grafikansicht“.

QPolygonF QGraphicsItem::mapToScene(qreal x, qreal y, qreal w, qreal h) const

Diese Komfortfunktion entspricht dem Aufruf von `mapToScene(QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapToScene(qreal x, qreal y) const

Diese Komfortfunktion entspricht dem Aufruf von `mapToScene(QPointF(x, y))`.

[virtual protected] void QGraphicsItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Doppelklick-Ereignisse für dieses Element zu empfangen.

Beim Doppelklick auf ein Element erhält das Element zunächst ein Mausdruck-Ereignis, gefolgt von einem Loslass-Ereignis (d. h. einem Klick), dann ein Doppelklick-Ereignis und schließlich ein weiteres Loslass-Ereignis.

Der Aufruf von ` QEvent::ignore()` oder ` QEvent::accept()` auf ` event ` hat keine Auswirkung.

Die Standardimplementierung ruft ` mousePressEvent()` auf. Wenn Sie bei der Neuimplementierung dieser Funktion die Basisimplementierung beibehalten möchten, rufen Sie in Ihrer Neuimplementierung `QGraphicsItem::mouseDoubleClickEvent()` auf.

Beachten Sie, dass ein Element keine Doppelklick-Ereignisse empfängt, wenn es weder „ selectable “ noch „ movable “ ist (in diesem Fall werden einzelne Mausklicks ignoriert, wodurch die Erzeugung von Doppelklicks unterbunden wird).

Siehe auch mousePressEvent(), mouseMoveEvent(), mouseReleaseEvent() und sceneEvent().

[virtual protected] void QGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Mausbewegungsereignisse für dieses Element zu empfangen. Wenn Sie dieses Ereignis empfangen, können Sie sicher sein, dass dieses Element auch ein Mausklick-Ereignis empfangen hat und dass dieses Element der aktuelle Maus-Grabber ist.

Der Aufruf von ` QEvent::ignore()` oder ` QEvent::accept()` auf ` event ` hat keine Auswirkung.

Die Standardimplementierung übernimmt grundlegende Interaktionen mit Elementen, wie z. B. Auswahl und Verschieben. Wenn Sie bei der Neuimplementierung dieser Funktion die Basisimplementierung beibehalten möchten, rufen Sie in Ihrer Neuimplementierung `QGraphicsItem::mouseMoveEvent()` auf.

Bitte beachten Sie, dass mousePressEvent() entscheidet, welches Grafikelement Mausereignisse empfängt. Einzelheiten finden Sie in der Beschreibung von mousePressEvent().

Siehe auch mousePressEvent(), mouseReleaseEvent(), mouseDoubleClickEvent() und sceneEvent().

[virtual protected] void QGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Mausklick-Ereignisse für dieses Element zu empfangen. Mausklick-Ereignisse werden nur an Elemente weitergeleitet, die die gedrückte Maustaste akzeptieren. Standardmäßig akzeptiert ein Element alle Maustasten, doch Sie können dies ändern, indem Sie die Funktion „ setAcceptedMouseButtons()“ aufrufen.

Das Mausklick-Ereignis entscheidet, welches Element zum „Mouse Grabber“ wird (siehe QGraphicsScene::mouseGrabberItem()). Wenn Sie diese Funktion nicht neu implementieren, wird das Klick-Ereignis an jedes oberste Element unterhalb dieses Elements weitergeleitet, und es werden keine weiteren Mausereignisse an dieses Element übermittelt.

Wenn Sie diese Funktion neu implementieren, wird standardmäßig „ event “ akzeptiert (siehe QEvent::accept()), und dieses Element ist dann der „Mouse Grabber“. Dadurch kann das Element zukünftige Verschiebungs-, Loslass- und Doppelklick-Ereignisse empfangen. Wenn Sie „ QEvent::ignore()“ auf event aufrufen, verliert dieses Element den „Mouse Grab“, und „ event “ wird an jedes darüberliegende Element weitergeleitet. Es werden keine weiteren Mausereignisse an dieses Element weitergeleitet, es sei denn, es wird ein neues Mausdruckereignis empfangen.

Die Standardimplementierung übernimmt grundlegende Interaktionen mit Elementen, wie z. B. Auswahl und Verschieben. Wenn Sie bei der Neuimplementierung dieser Funktion die Basisimplementierung beibehalten möchten, rufen Sie in Ihrer Neuimplementierung `QGraphicsItem::mousePressEvent()` auf.

Das Ereignis wird für Elemente, die weder „ movable “ noch „ selectable “ sind, als „ QEvent::ignore()“ zurückgegeben.

Siehe auch mouseMoveEvent(), mouseReleaseEvent(), mouseDoubleClickEvent() und sceneEvent().

[virtual protected] void QGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Mausloslass-Ereignisse für dieses Element zu empfangen.

Der Aufruf von ` QEvent::ignore()` oder ` QEvent::accept()` auf ` event ` hat keine Auswirkung.

Die Standardimplementierung übernimmt grundlegende Interaktionen mit dem Element, wie z. B. Auswahl und Verschieben. Wenn Sie bei der Neuimplementierung dieser Funktion die Basisimplementierung beibehalten möchten, rufen Sie in Ihrer Neuimplementierung `QGraphicsItem::mouseReleaseEvent()` auf.

Bitte beachten Sie, dass ` mousePressEvent()` entscheidet, welches Grafikelement Mausereignisse empfängt. Einzelheiten finden Sie in der Beschreibung von ` mousePressEvent()`.

Siehe auch mousePressEvent(), mouseMoveEvent(), mouseDoubleClickEvent() und sceneEvent().

void QGraphicsItem::moveBy(qreal dx, qreal dy)

Verschiebt das Objekt horizontal um dx Punkte und vertikal um dy Punkt. Diese Funktion entspricht dem Aufruf von setPos(pos() + QPointF(dx, dy)).

qreal QGraphicsItem::opacity() const

Gibt die lokale Deckkraft dieses Elements zurück, die zwischen 0,0 (transparent) und 1,0 (undurchsichtig) liegt. Dieser Wert wird mit den Werten der übergeordneten Elemente und Vorfahren in der Funktion ` effectiveOpacity()` kombiniert. Die effektive Deckkraft bestimmt, wie das Element gerendert wird, und beeinflusst zudem dessen Sichtbarkeit, wenn es von Funktionen wie ` QGraphicsView::items()` abgefragt wird.

Die Eigenschaft „opacity“ bestimmt den Zustand des Malers, der an die Funktion „ paint()“ übergeben wird. Wenn das Element zwischengespeichert ist, d. h. „ ItemCoordinateCache “ oder „ DeviceCoordinateCache “, wird die effektive Eigenschaft beim Rendern auf den Cache des Elements angewendet.

Die Standard-Opazität beträgt 1,0; vollständig undurchsichtig.

Siehe auch setOpacity(), paint(), ItemIgnoresParentOpacity und ItemDoesntPropagateOpacityToChildren.

[virtual] QPainterPath QGraphicsItem::opaqueArea() const

Diese virtuelle Funktion gibt eine Form zurück, die den Bereich darstellt, in dem dieses Element undurchsichtig ist. Ein Bereich ist undurchsichtig, wenn er mit einem undurchsichtigen Pinsel oder einer undurchsichtigen Farbe ausgefüllt ist (d. h. nicht transparent ist).

Diese Funktion wird von ` isObscuredBy()` verwendet, die von darunterliegenden Elementen aufgerufen wird, um festzustellen, ob sie von diesem Element verdeckt werden.

Die Standardimplementierung gibt eine leere ` QPainterPath` zurück, was bedeutet, dass dieses Element vollständig transparent ist und keine anderen Elemente verdeckt.

Siehe auch isObscuredBy(), isObscured() und shape().

[pure virtual] void QGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr)

Diese Funktion, die in der Regel von ` QGraphicsView` aufgerufen wird, zeichnet den Inhalt eines Elements in lokalen Koordinaten.

Implementieren Sie diese Funktion in einer Unterklasse von ` QGraphicsItem ` neu, um die Zeichnungsimplementierung des Elements bereitzustellen, wobei Sie ` painter` verwenden. Der Parameter ` option ` stellt Stiloptionen für das Element bereit, wie beispielsweise dessen Zustand, den sichtbaren Bereich und Hinweise zum Detaillierungsgrad. Das Argument ` widget ` ist optional. Falls angegeben, verweist es auf das Widget, auf das gezeichnet wird; andernfalls ist es 0. Bei zwischengespeicherter Darstellung ist ` widget ` immer 0.

void RoundRectItem::paint(QPainter *painter,
                          const QStyleOptionGraphicsItem *option,
                          QWidget *widget)
{
    painter->drawRoundedRect(-10, -10, 20, 20, 5, 5);
}

Der Stift des Painters hat standardmäßig die Breite 0 und wird mit dem Pinsel „ QPalette::Text “ aus der Palette des Malgeräts initialisiert. Der Pinsel wird auf „ QPalette::Window “ initialisiert.

Stellen Sie sicher, dass alle Zeichenvorgänge innerhalb der Grenzen von ` boundingRect()` erfolgen, um Rendering-Artefakte zu vermeiden (da ` QGraphicsView ` den Painter nicht automatisch beschneidet). Insbesondere wenn „ QPainter “ den Umriss einer Form unter Verwendung eines zugewiesenen „ QPen “ rendert, wird die Hälfte des Umrisses außerhalb und die andere Hälfte innerhalb der gerenderten Form gezeichnet (z. B. müssen Sie bei einer Stiftbreite von 2 Einheiten die Umrisse 1 Einheit innerhalb von „ boundingRect()“ zeichnen). „ QGraphicsItem “ unterstützt keine kosmetischen Stifte mit einer Breite ungleich Null.

Alle Zeichenvorgänge erfolgen in lokalen Koordinaten.

Siehe auch ` setCacheMode()`, ` QPen::width()`, „Elementkoordinaten“ und „ ItemUsesExtendedStyleOption “.

QGraphicsItem *QGraphicsItem::panel() const

Gibt das Panel des Elements zurück oder „ nullptr “, falls dieses Element kein Panel hat. Handelt es sich bei dem Element um ein Panel, wird es selbst zurückgegeben. Andernfalls wird der nächsthöhere Vorfahr zurückgegeben, der ein Panel ist.

Siehe auch „ isPanel()“ und „ ItemIsPanel “.

QGraphicsItem::PanelModality QGraphicsItem::panelModality() const

Gibt die Modalität für dieses Element zurück.

Siehe auch „ setPanelModality()“.

QGraphicsItem *QGraphicsItem::parentItem() const

Gibt einen Zeiger auf das übergeordnete Element dieses Elements zurück. Wenn dieses Element kein übergeordnetes Element hat, wird „ nullptr “ zurückgegeben.

Siehe auch „ setParentItem()“ und „ childItems()“.

QGraphicsObject *QGraphicsItem::parentObject() const

Gibt einen Zeiger auf das übergeordnete Element des Elements zurück, der in einen ` QGraphicsObject` umgewandelt wird. Gibt ` nullptr ` zurück, wenn das übergeordnete Element kein ` QGraphicsObject` ist.

Siehe auch „ parentItem()“ und „ childItems()“.

QGraphicsWidget *QGraphicsItem::parentWidget() const

Gibt einen Zeiger auf das übergeordnete Widget des Elements zurück. Das übergeordnete Widget des Elements ist das nächstübergeordnete Element, das ein Widget ist.

Siehe auch „ parentItem()“ und „ childItems()“.

QPointF QGraphicsItem::pos() const

Gibt die Position des Elements in den Koordinaten des übergeordneten Elements zurück. Wenn das Element kein übergeordnetes Element hat, wird seine Position in Szenenkoordinaten angegeben.

Die Position des Objekts beschreibt dessen Ursprung (lokale Koordinate (0, 0)) im Koordinatensystem des übergeordneten Objekts; diese Funktion liefert dasselbe Ergebnis wie ` mapToParent(0, 0)`.

Der Einfachheit halber können Sie auch ` scenePos()` aufrufen, um die Position des Elements in Szenekoordinaten zu ermitteln, unabhängig von seinem übergeordneten Element.

Siehe auch ` x()`, ` y()`, ` setPos()`, ` transform()` und „Das Koordinatensystem der Grafikansicht“.

[protected] void QGraphicsItem::prepareGeometryChange()

Bereitet das Element auf eine Geometrieänderung vor. Rufen Sie diese Funktion auf, bevor Sie das Begrenzungsrechteck eines Elements ändern, um den Index von „ QGraphicsScene “ auf dem neuesten Stand zu halten.

`prepareGeometryChange()` ruft bei Bedarf ` update()` auf.

Beispiel:

void CircleItem::setRadius(qreal newRadius)
{
    if (radius != newRadius) {
        prepareGeometryChange();
        radius = newRadius;
    }
}

Siehe auch ` boundingRect()`.

void QGraphicsItem::removeSceneEventFilter(QGraphicsItem *filterItem)

Entfernt einen Ereignisfilter für dieses Element aus „ filterItem “.

Siehe auch installSceneEventFilter().

void QGraphicsItem::resetTransform()

Setzt die Transformationsmatrix dieses Elements auf die Einheitsmatrix zurück bzw. alle Transformationseigenschaften auf ihre Standardwerte. Dies entspricht dem Aufruf von ` setTransform(QTransform())`.

Siehe auch „ setTransform()“ und „ transform()“.

qreal QGraphicsItem::rotation() const

Gibt die Drehung im Uhrzeigersinn um die Z-Achse in Grad zurück. Der Standardwert ist 0 (d. h., das Element ist nicht gedreht).

Die Drehung wird mit den Funktionen „ scale()“, „ transform()“ und „ transformations()“ des Elements kombiniert, um das Koordinatensystem des Elements auf das übergeordnete Element abzubilden.

Siehe auch „ setRotation()“, „ transformOriginPoint()“ und „ Transformations “.

qreal QGraphicsItem::scale() const

Gibt den Skalierungsfaktor des Elements zurück. Der Standard-Skalierungsfaktor ist 1,0 (d. h., das Element wird nicht skaliert).

Die Skalierung wird mit den Methoden ` rotation()`, ` transform()` und ` transformations()` des Elements kombiniert, um das Koordinatensystem des Elements auf das übergeordnete Element abzubilden.

Siehe auch setScale(), rotation() und Transformations.

QGraphicsScene *QGraphicsItem::scene() const

Gibt die aktuelle Szene für das Element zurück oder „ nullptr “, falls das Element nicht in einer Szene gespeichert ist.

Um ein Element zu einer Szene hinzuzufügen oder darin zu verschieben, rufen Sie „ QGraphicsScene::addItem()“ auf.

QRectF QGraphicsItem::sceneBoundingRect() const

Gibt den Begrenzungsrahmen dieses Elements in Szenenkoordinaten zurück, indem „ sceneTransform()“ mit „ boundingRect()“ kombiniert wird.

Siehe auch boundingRect() und Das Koordinatensystem der Grafikansicht.

[virtual protected] bool QGraphicsItem::sceneEvent(QEvent *event)

Diese virtuelle Funktion empfängt Ereignisse für dieses Element. Implementieren Sie diese Funktion neu, um Ereignisse abzufangen, bevor sie an die spezialisierten Ereignisbehandler contextMenuEvent(), focusInEvent(), focusOutEvent(), hoverEnterEvent(), hoverMoveEvent(), hoverLeaveEvent(), keyPressEvent(), keyReleaseEvent(), mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent() und mouseDoubleClickEvent() weitergeleitet werden.

Gibt ` true ` zurück, wenn das Ereignis erkannt und verarbeitet wurde; andernfalls (z. B. wenn der Ereignistyp nicht erkannt wurde) wird `false` zurückgegeben.

event ist das abgefangene Ereignis.

[virtual protected] bool QGraphicsItem::sceneEventFilter(QGraphicsItem *watched, QEvent *event)

Filtert Ereignisse für das Element „ watched “. „ event “ ist das gefilterte Ereignis.

Durch die Neuimplementierung dieser Funktion in einer Unterklasse kann das Element als Ereignisfilter für andere Elemente verwendet werden, wodurch alle an diese Elemente gesendeten Ereignisse abgefangen werden, bevor diese darauf reagieren können.

Neuimplementierungen müssen „true“ zurückgeben, um die weitere Verarbeitung eines bestimmten Ereignisses zu verhindern und sicherzustellen, dass es nicht an das überwachte Element weitergeleitet wird, oder „false“ zurückgeben, um anzugeben, dass das Ereignis vom Ereignissystem weiterverarbeitet werden soll.

Siehe auch „ installSceneEventFilter()“.

QPointF QGraphicsItem::scenePos() const

Gibt die Position des Objekts in Szenenkoordinaten zurück. Dies entspricht dem Aufruf von ` mapToScene(0, 0)`.

Siehe auch „ pos()“, „ sceneTransform()“ und „Das Koordinatensystem der Grafikansicht“.

QTransform QGraphicsItem::sceneTransform() const

Gibt die Szenentransformationsmatrix dieses Elements zurück. Diese Matrix kann verwendet werden, um Koordinaten und geometrische Formen aus dem lokalen Koordinatensystem dieses Elements in das Koordinatensystem der Szene abzubilden. Um Koordinaten aus der Szene abzubilden, müssen Sie zunächst die zurückgegebene Matrix invertieren.

Beispiel:

QGraphicsRectItem rect;
rect.setPos(100, 100);

rect.sceneTransform().map(QPointF(0, 0));
// returns QPointF(100, 100);

rect.sceneTransform().inverted().map(QPointF(100, 100));
// returns QPointF(0, 0);

Im Gegensatz zu ` transform()`, das nur die lokale Transformation eines Elements zurückgibt, umfasst diese Funktion die Position des Elements (und aller übergeordneten Elemente) sowie alle Transformationseigenschaften.

Siehe auch „ transform()“, „ setTransform()“, „ scenePos()“, „Das Koordinatensystem der Grafikansicht“ und „ Transformations “.

void QGraphicsItem::scroll(qreal dx, qreal dy, const QRectF &rect = QRectF())

Blättert den Inhalt von „ rect “ von dx, dy. Ist „ rect “ ein Null-Rechteck (Standard), wird das Begrenzungsrechteck des Elements geblättert.

Das Scrollen bietet eine schnelle Alternative zum einfachen Neuzeichnen, wenn der Inhalt des Elements (oder Teile davon) vertikal oder horizontal verschoben werden. Je nach aktueller Transformation und den Fähigkeiten des Zeichen-Geräts (d. h. des Viewports) kann dieser Vorgang darin bestehen, Pixel einfach mit memmove() von einer Stelle an eine andere zu verschieben. In den meisten Fällen ist dies schneller als das erneute Rendern des gesamten Bereichs.

Nach dem Scrollen löst das Element eine Aktualisierung für die neu sichtbaren Bereiche aus. Wenn das Scrollen nicht unterstützt wird (z. B. wenn Sie in einen OpenGL-Viewport rendern, der nicht von Scroll-Optimierungen profitiert), entspricht diese Funktion dem Aufruf von `update(rect)`.

Hinweis: Das Scrollen wird nur unterstützt, wenn „ QGraphicsItem::ItemCoordinateCache “ aktiviert ist; in allen anderen Fällen entspricht der Aufruf dieser Funktion dem Aufruf von `update(rect)`. Wenn Sie sicher wissen, dass das Element undurchsichtig ist und nicht von anderen Elementen überlappt wird, können Sie die Koordinaten von ` rect ` auf Viewport-Koordinaten abbilden und den Viewport scrollen.

QTransform xform = item->deviceTransform(view->viewportTransform());
QRect deviceRect = xform.mapRect(rect).toAlignedRect();
view->viewport()->scroll(dx, dy, deviceRect);

Siehe auch ` boundingRect()`.

void QGraphicsItem::setAcceptDrops(bool on)

Wenn „ on “ auf „true“ gesetzt ist, akzeptiert dieses Element Drag-and-Drop-Ereignisse; andernfalls ist es für Drag-and-Drop-Ereignisse transparent. Standardmäßig akzeptieren Elemente keine Drag-and-Drop-Ereignisse.

Siehe auch ` acceptDrops()`.

void QGraphicsItem::setAcceptHoverEvents(bool enabled)

Wenn „ enabled “ auf „true“ gesetzt ist, akzeptiert dieses Element Hover-Ereignisse; andernfalls werden diese ignoriert. Standardmäßig akzeptieren Elemente keine Hover-Ereignisse.

Hover-Ereignisse werden ausgelöst, wenn kein Element den Mauszeiger gerade festhält. Sie werden gesendet, wenn der Mauszeiger in ein Element eintritt, wenn er sich innerhalb des Elements bewegt und wenn der Mauszeiger ein Element verlässt. Hover-Ereignisse werden häufig verwendet, um ein Element beim Betreten hervorzuheben und um den Mauszeiger zu verfolgen, während er über dem Element schwebt (entspricht „ QWidget::mouseTracking “).

Übergeordnete Elemente erhalten Hover-Enter-Ereignisse vor ihren untergeordneten Elementen und Hover-Leave-Ereignisse nach diesen. Das übergeordnete Element erhält jedoch kein Hover-Leave-Ereignis, wenn der Cursor in ein untergeordnetes Element eintritt; das übergeordnete Element bleibt so lange im „Hover“-Zustand, bis der Cursor seinen Bereich – einschließlich der Bereiche seiner untergeordneten Elemente – verlässt.

Wenn ein übergeordnetes Element Ereignisse seiner untergeordneten Elemente verarbeitet, erhält es „hover move“--, „drag move“- und „drop“-Ereignisse, während der Cursor seine untergeordneten Elemente durchläuft; es erhält jedoch weder „hover enter“- und „hover leave“- noch „drag enter“- und „drag leave“-Ereignisse im Namen seiner untergeordneten Elemente.

Ein „ QGraphicsWidget “ mit Fensterdekorationen akzeptiert „hover“-Ereignisse unabhängig vom Wert von „ acceptHoverEvents()“.

Siehe auch „ acceptHoverEvents()“, „ hoverEnterEvent()“, „ hoverMoveEvent()“ und „ hoverLeaveEvent()“.

void QGraphicsItem::setAcceptTouchEvents(bool enabled)

Wenn „ enabled “ auf „true“ gesetzt ist, akzeptiert dieses Element „ touch events “; andernfalls werden diese ignoriert. Standardmäßig akzeptieren Elemente keine Touch-Ereignisse.

Siehe auch ` acceptTouchEvents()`.

void QGraphicsItem::setAcceptedMouseButtons(Qt::MouseButtons buttons)

Legt die Maus buttons en fest, für die dieses Element Mausereignisse akzeptiert.

Standardmäßig werden alle Maustasten akzeptiert. Wenn ein Element eine Maustaste akzeptiert, wird es zum „Mouse Grabber“-Element, sobald ein Mausklick-Ereignis für diese Taste ausgelöst wird. Akzeptiert das Element die Maustaste jedoch nicht, leitet „ QGraphicsScene “ die Mausereignisse an das erste darunterliegende Element weiter, das die Maustaste akzeptiert.

Um Mausereignisse für ein Element zu deaktivieren (d. h. es für Mausereignisse transparent zu machen), rufen Sie setAcceptedMouseButtons(Qt::NoButton) auf.

Siehe auch „ acceptedMouseButtons()“ und „ mousePressEvent()“.

void QGraphicsItem::setActive(bool active)

Wenn „ active “ auf „true“ gesetzt ist und die Szene aktiv ist, wird das Bedienfeld dieses Elements aktiviert. Andernfalls ist das Bedienfeld deaktiviert.

Ist das Element nicht Teil einer aktiven Szene, entscheidet „ active “, was mit dem Bedienfeld geschieht, wenn die Szene aktiv wird oder das Element zur Szene hinzugefügt wird. Ist der Wert „true“, wird das Bedienfeld des Elements aktiviert, sobald das Element entweder zur Szene hinzugefügt wird oder die Szene aktiviert wird. Andernfalls bleibt das Element unabhängig vom Aktivierungsstatus der Szene inaktiv.

Siehe auch „ isPanel()“, „ QGraphicsScene::setActivePanel()“ und „ QGraphicsScene::isActive()“.

void QGraphicsItem::setBoundingRegionGranularity(qreal granularity)

Legt die Granularität des Begrenzungsbereichs auf „ granularity “ fest; ein Wert zwischen 0 und 1 (einschließlich). Der Standardwert ist 0 (d. h. die niedrigste Granularität, bei der der Begrenzungsbereich dem Begrenzungsrechteck des Elements entspricht).

Die Granularität wird von „ boundingRegion()“ verwendet, um zu berechnen, wie fein der Begrenzungsbereich des Elements sein soll. Die höchstmögliche Granularität ist 1; in diesem Fall gibt „ boundingRegion()“ den für das jeweilige Gerät feinsten Umriss zurück (z. B. ergibt dies bei einem „ QGraphicsView “-Viewport einen pixelgenauen Begrenzungsbereich). Die niedrigstmögliche Granularität ist 0. Der Wert von ` granularity ` beschreibt das Verhältnis zwischen der Geräteauflösung und der Auflösung des Begrenzungsbereichs (z. B. liefert ein Wert von 0,25 einen Bereich, in dem jedes Segment 4×4 Geräteeinheiten/Pixel entspricht).

Siehe auch „ boundingRegionGranularity“ ().

void QGraphicsItem::setCacheMode(QGraphicsItem::CacheMode mode, const QSize &logicalCacheSize = QSize())

Setzt den Cache-Modus des Elements auf „ mode “.

Das optionale Argument „ logicalCacheSize “ wird nur im Modus „ ItemCoordinateCache “ verwendet und beschreibt die Auflösung des Cache-Puffers; wenn „ logicalCacheSize “ den Wert (100, 100) hat, passt „ QGraphicsItem “ das Element in einen Bereich von 100 × 100 Pixeln im Grafikspeicher ein, unabhängig von der logischen Größe des Elements selbst. Standardmäßig verwendet „ QGraphicsItem “ die Größe von „ boundingRect()“. Bei allen anderen Cache-Modi außer „ ItemCoordinateCache “ wird „ logicalCacheSize “ ignoriert.

Das Zwischenspeichern kann das Rendern beschleunigen, wenn Ihr Element viel Zeit damit verbringt, sich selbst neu zu zeichnen. In einigen Fällen kann der Cache das Rendern jedoch auch verlangsamen, insbesondere wenn das Element weniger Zeit für das Neuzeichnen benötigt als „ QGraphicsItem “ für das Neuzeichnen aus dem Cache.

Wenn das Caching aktiviert ist, zeichnet die Funktion ` paint()` eines Elements im Allgemeinen in einen Offscreen-Pixmap-Cache; bei allen nachfolgenden Neuzeichnungsanforderungen zeichnet das Graphics-View-Framework aus dem Cache nach. Dieser Ansatz funktioniert besonders gut mit `QGLWidget`, das den gesamten Cache als OpenGL-Texturen speichert.

Beachten Sie, dass die Cache-Begrenzung von ` QPixmapCache` möglicherweise angepasst werden muss, um eine optimale Leistung zu erzielen.

Weitere Informationen zu den verschiedenen Cache-Modi finden Sie in der Dokumentation zu „ CacheMode “.

Siehe auch „ cacheMode()“, „ CacheMode “ und „ QPixmapCache::setCacheLimit()“.

void QGraphicsItem::setCursor(const QCursor &cursor)

Legt die aktuelle Cursorform für das Element auf „ cursor “ fest. Der Mauszeiger nimmt diese Form an, wenn er sich über diesem Element befindet. Eine Auswahl nützlicher Formen finden Sie im „ list of predefined cursor objects “.

Ein Editor-Element möchte möglicherweise einen I-Balken-Cursor verwenden:

item->setCursor(Qt::IBeamCursor);

Wenn kein Cursor festgelegt wurde, wird der Cursor des darunterliegenden Elements verwendet.

Siehe auch cursor(), hasCursor(), unsetCursor(), QWidget::cursor sowie QGuiApplication::overrideCursor().

void QGraphicsItem::setData(int key, const QVariant &value)

Setzt die benutzerdefinierten Daten dieses Elements für den Schlüssel „ key “ auf „ value “.

Benutzerdefinierte Elementdaten sind nützlich, um beliebige Eigenschaften für jedes Element zu speichern. Qt nutzt diese Funktion nicht zum Speichern von Daten; sie dient ausschließlich der Benutzerfreundlichkeit.

Siehe auch ` data()`.

void QGraphicsItem::setEnabled(bool enabled)

Ist „ enabled “ auf „true“ gesetzt, ist das Element aktiviert; andernfalls ist es deaktiviert.

Deaktivierte Elemente sind sichtbar, empfangen jedoch keine Ereignisse und können weder den Fokus erhalten noch ausgewählt werden. Mausereignisse werden verworfen; sie werden nicht weitergeleitet, es sei denn, das Element ist zudem unsichtbar oder akzeptiert keine Mausereignisse (siehe acceptedMouseButtons()). Ein deaktiviertes Element kann nicht zum Maus-Grabber werden; folglich verliert ein Element den Grab, wenn es während des Maus-Grabbs deaktiviert wird, genauso wie es den Fokus verliert, wenn es den Fokus hatte, als es deaktiviert wurde.

Deaktivierte Elemente werden üblicherweise in ausgegrauten Farben dargestellt (siehe QPalette::Disabled).

Wenn Sie ein übergeordnetes Element deaktivieren, werden alle seine untergeordneten Elemente ebenfalls deaktiviert. Wenn Sie ein übergeordnetes Element aktivieren, werden alle untergeordneten Elemente aktiviert, sofern sie nicht explizit deaktiviert wurden (d. h., wenn Sie setEnabled(false) für ein untergeordnetes Element aufrufen, wird es nicht wieder aktiviert, wenn sein übergeordnetes Element deaktiviert und anschließend wieder aktiviert wird).

Elemente sind standardmäßig aktiviert.

Siehe auch ` isEnabled()`.

void QGraphicsItem::setFiltersChildEvents(bool enabled)

Wenn „ enabled “ auf „true“ gesetzt ist, wird dieses Element so konfiguriert, dass es alle Ereignisse für alle seine untergeordneten Elemente filtert (d. h., alle Ereignisse, die für eines seiner untergeordneten Elemente bestimmt sind, werden stattdessen an dieses Element gesendet); andernfalls, wenn „ enabled “ auf „false“ gesetzt ist, verarbeitet dieses Element nur seine eigenen Ereignisse. Der Standardwert ist „false“.

Siehe auch filtersChildEvents().

void QGraphicsItem::setFlag(QGraphicsItem::GraphicsItemFlag flag, bool enabled = true)

Wenn „ enabled “ wahr ist, ist das Element-Flag „ flag “ aktiviert; andernfalls ist es deaktiviert.

Siehe auch „ flags()“ und „ setFlags()“.

void QGraphicsItem::setFlags(QGraphicsItem::GraphicsItemFlags flags)

Setzt die Flags des Elements auf „ flags “. Alle Flags unter „ flags “ werden aktiviert; alle Flags, die nicht unter „ flags “ aufgeführt sind, werden deaktiviert.

Wenn das Element den Fokus hatte und „ flags “ die Option „ ItemIsFocusable “ nicht aktiviert, verliert das Element durch den Aufruf dieser Funktion den Fokus. Ebenso wird das Element automatisch abgewählt, wenn es ausgewählt war und „ flags “ die Option „ ItemIsSelectable “ nicht aktiviert.

Standardmäßig sind keine Flags aktiviert. (QGraphicsWidget aktiviert standardmäßig das Flag ItemSendsGeometryChanges, um Positionsänderungen zu verfolgen.)

Siehe auch flags() und setFlag().

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

Weist diesem Element den Tastatureingabefokus zu. Das Argument „ focusReason “ wird an alle von dieser Funktion generierten „ focus event “-Objekte übergeben; es dient dazu, zu erklären, warum das Element den Fokus erhalten hat.

Nur aktivierte Elemente, bei denen das Flag „ ItemIsFocusable “ gesetzt ist, können den Tastaturfokus annehmen.

Ist dieses Element nicht sichtbar, nicht aktiv oder keiner Szene zugeordnet, erhält es nicht sofort den Eingabefokus. Es wird jedoch als bevorzugtes Fokuselement für seinen Unterbaum von Elementen registriert, sollte es später sichtbar werden.

Als Ergebnis des Aufrufs dieser Funktion erhält dieses Element ein „ focus in event “ mit dem Wert „ focusReason “. Wenn ein anderes Element bereits den Fokus hat, erhält dieses Element zunächst ein „ focus out event “, das anzeigt, dass es den Eingabefokus verloren hat.

Siehe auch „ clearFocus()“, „ hasFocus()“, „ focusItem()“ und „ focusProxy()“.

void QGraphicsItem::setFocusProxy(QGraphicsItem *item)

Legt den Fokus-Proxy des Elements auf „ item “ fest.

Verfügt ein Element über einen Fokus-Proxy, erhält dieser den Eingabefokus, sobald das Element den Eingabefokus erhält. Das Element selbst behält weiterhin den Fokus (d. h., ` hasFocus()` gibt „true“ zurück), doch nur der Fokus-Proxy empfängt die Tastatureingaben.

Ein Fokus-Proxy kann selbst einen Fokus-Proxy haben und so weiter. In einem solchen Fall werden Tastatureingaben vom äußersten Fokus-Proxy verarbeitet.

Der Fokus-Proxy „ item “ muss zur selben Szene wie dieses Element gehören.

Siehe auch „ focusProxy()“, „ setFocus()“ und „ hasFocus()“.

void QGraphicsItem::setGraphicsEffect(QGraphicsEffect *effect)

Legt „ effect “ als Effekt für das Element fest. Wenn für dieses Element bereits ein Effekt installiert ist, löscht „ QGraphicsItem “ den vorhandenen Effekt, bevor der neue Effekt „ effect “ installiert wird. Sie können einen vorhandenen Effekt löschen, indem Sie „setGraphicsEffect(nullptr)“ aufrufen.

Wenn „ effect “ der auf einem anderen Element installierte Effekt ist, entfernt „setGraphicsEffect()“ den Effekt von diesem Element und installiert ihn auf diesem Element.

QGraphicsItem übernimmt die Eigentumsrechte an „ effect “.

Siehe auch ` graphicsEffect()`.

void QGraphicsItem::setGroup(QGraphicsItemGroup *group)

Fügt dieses Element zur Elementgruppe „ group “ hinzu. Wenn „ group “ den Wert „ nullptr “ hat, wird dieses Element aus allen aktuellen Gruppen entfernt und als untergeordnetes Element des übergeordneten Elements der vorherigen Gruppe hinzugefügt.

Siehe auch „ group()“ und „ QGraphicsScene::createItemGroup()“.

void QGraphicsItem::setInputMethodHints(Qt::InputMethodHints hints)

Setzt die aktuellen Eingabemethode-Hinweise für dieses Element auf „ hints “.

Siehe auch „ inputMethodHints()“ und „ inputMethodQuery()“.

void QGraphicsItem::setOpacity(qreal opacity)

Legt die lokale Deckkraft ( opacity) dieses Elements zwischen 0,0 (transparent) und 1,0 (undurchsichtig) fest. Die lokale Deckkraft des Elements wird mit der Deckkraft des übergeordneten Elements und der Vorgängerebenen zur effektiven Deckkraft ( effectiveOpacity) () zusammengefasst.

Standardmäßig wird die Deckkraft vom übergeordneten Element auf das untergeordnete Element weitergegeben. Beträgt die Deckkraft eines übergeordneten Elements also 0,5 und die des untergeordneten Elements ebenfalls 0,5, beträgt die effektive Deckkraft des untergeordneten Elements 0,25.

Die Eigenschaft „opacity“ bestimmt den Zustand des Malers, der an die Funktion „ paint()“ übergeben wird. Wenn das Element zwischengespeichert ist, d. h. „ ItemCoordinateCache “ oder „ DeviceCoordinateCache “, wird die effektive Eigenschaft beim Rendern auf den Cache des Elements angewendet.

Es gibt zwei Element-Flags, die beeinflussen, wie die Deckkraft des Elements mit der des übergeordneten Elements kombiniert wird: „ ItemIgnoresParentOpacity “ und „ ItemDoesntPropagateOpacityToChildren “.

Siehe auch opacity(), effectiveOpacity() und setVisible().

void QGraphicsItem::setPanelModality(QGraphicsItem::PanelModality panelModality)

Legt die Modalität für dieses Element auf „ panelModality “ fest.

Die Änderung der Modalität eines sichtbaren Elements wird sofort wirksam.

Siehe auch ` panelModality()`.

void QGraphicsItem::setParentItem(QGraphicsItem *newParent)

Legt das übergeordnete Element dieses Elements auf „ newParent “ fest. Wenn dieses Element bereits ein übergeordnetes Element hat, wird es zunächst von diesem entfernt. Ist „ newParent “ gleich 0, wird dieses Element zu einem Element der obersten Ebene.

Beachten Sie, dass dieses Grafikelement dadurch implizit zur Szene des übergeordneten Elements hinzugefügt wird. Sie sollten das Element nicht selbst mit „ add “ zur Szene hinzufügen.

Das Verhalten beim Aufruf dieser Funktion für ein Element, das ein Vorfahr von „ newParent “ ist, ist undefiniert.

Siehe auch „ parentItem()“ und „ childItems()“.

void QGraphicsItem::setPos(const QPointF &pos)

Legt die Position des Elements auf „ pos “ fest, wobei es sich um Elternkoordinaten handelt. Bei Elementen ohne übergeordnetes Element bezieht sich „ pos “ auf Szenenkoordinaten.

Die Position des Elements beschreibt dessen Ursprung (lokale Koordinate (0, 0)) in den Koordinaten des übergeordneten Elements.

Siehe auch „ pos()“, „ scenePos()“ und „Das Koordinatensystem der Grafikansicht“.

void QGraphicsItem::setPos(qreal x, qreal y)

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

void QGraphicsItem::setRotation(qreal angle)

Legt den Dreh angle, in Grad, im Uhrzeigersinn um die Z-Achse fest. Der Standardwert ist 0 (d. h., das Element wird nicht gedreht). Durch die Zuweisung eines negativen Werts wird das Element gegen den Uhrzeigersinn gedreht. Normalerweise liegt der Drehwinkel im Bereich (-360, 360), es ist jedoch auch möglich, Werte außerhalb dieses Bereichs zuzuweisen (z. B. entspricht eine Drehung um 370 Grad einer Drehung um 10 Grad).

Das Element wird um seinen Transformationsursprung gedreht, der standardmäßig bei (0, 0) liegt. Sie können einen anderen Transformationsursprung festlegen, indem Sie ` setTransformOriginPoint()` aufrufen.

Die Drehung wird mit den Methoden „ scale()“, „ transform()“ und „ transformations()“ des Elements kombiniert, um das Koordinatensystem des Elements auf das übergeordnete Element abzubilden.

Siehe auch „ rotation()“, „ setTransformOriginPoint()“ und „ Transformations “.

void QGraphicsItem::setScale(qreal factor)

Legt den Skalierungs factor us des Elements fest. Der Standard-Skalierungs us beträgt 1,0 (d. h., das Element wird nicht skaliert). Ein Skalierungsfaktor von 0,0 reduziert das Element auf einen einzigen Punkt. Wenn Sie einen negativen Skalierungsfaktor angeben, wird das Element gespiegelt (d. h. um 180 Grad gedreht).

Das Element wird um seinen Transformationsursprung skaliert, der standardmäßig bei (0, 0) liegt. Sie können einen anderen Transformationsursprung festlegen, indem Sie ` setTransformOriginPoint()` aufrufen.

Die Skalierung wird mit den Methoden ` rotation()`, ` transform()` und ` transformations()` des Elements kombiniert, um das Koordinatensystem des Elements auf das übergeordnete Element abzubilden.

Siehe auch „ scale()“, „ setTransformOriginPoint()“ und „Beispiel für Transformationen“.

void QGraphicsItem::setSelected(bool selected)

Wenn „ selected “ wahr ist und dieses Element auswählbar ist, wird es ausgewählt; andernfalls wird die Auswahl aufgehoben.

Befindet sich das Element in einer Gruppe, wird durch diese Funktion der Auswahlstatus der gesamten Gruppe umgeschaltet. Ist die Gruppe ausgewählt, sind auch alle Elemente in der Gruppe ausgewählt, und ist die Gruppe nicht ausgewählt, ist kein Element in der Gruppe ausgewählt.

Nur sichtbare, aktivierte und auswählbare Elemente können ausgewählt werden. Wenn „ selected “ auf „true“ gesetzt ist und dieses Element entweder unsichtbar, deaktiviert oder nicht auswählbar ist, hat diese Funktion keine Auswirkung.

Standardmäßig können Elemente nicht ausgewählt werden. Um die Auswahl zu aktivieren, setzen Sie das Flag „ ItemIsSelectable “.

Diese Funktion dient der Benutzerfreundlichkeit und ermöglicht das individuelle Umschalten des Auswahlstatus eines Elements. Eine gängigere Methode zur Auswahl von Elementen ist jedoch der Aufruf von ` QGraphicsScene::setSelectionArea()`, wodurch diese Funktion für alle sichtbaren, aktivierten und auswählbaren Elemente innerhalb eines bestimmten Bereichs in der Szene aufgerufen wird.

Siehe auch „ isSelected()“ und „ QGraphicsScene::selectedItems()“.

void QGraphicsItem::setToolTip(const QString &toolTip)

Setzt den Tooltip des Elements auf toolTip. Ist toolTip leer, wird der Tooltip des Elements gelöscht.

Siehe auch toolTip() und QToolTip.

void QGraphicsItem::setTransform(const QTransform &matrix, bool combine = false)

Setzt die aktuelle Transformationsmatrix des Elements auf „ matrix “.

Ist „ combine “ wahr, wird „ matrix “ mit der aktuellen Matrix kombiniert; andernfalls ersetzt „ matrix “ die aktuelle Matrix. „ combine “ ist standardmäßig falsch.

Um die Interaktion mit Elementen in einer transformierten Ansicht zu vereinfachen, stellt „ QGraphicsItem “ die Funktionen „mapTo...“ und „mapFrom...“ bereit, die eine Umrechnung zwischen den Koordinaten der Elemente und denen der Szene ermöglichen. Sie können beispielsweise „ mapToScene()“ aufrufen, um eine Elementkoordinate auf eine Szenenkoordinate abzubilden, oder „ mapFromScene()“, um von Szenenkoordinaten auf Elementkoordinaten abzubilden.

Die Transformationsmatrix wird mit den Funktionen ` rotation()`, ` scale()` und ` transformations()` des Elements zu einer kombinierten Transformation zusammengefasst, die das Koordinatensystem des Elements auf das seines übergeordneten Elements abbildet.

Siehe auch „ transform()“, „ setRotation()“, „ setScale()“, „ setTransformOriginPoint()“, „Das Koordinatensystem der Grafikansicht“ und „ Transformations “.

void QGraphicsItem::setTransformOriginPoint(const QPointF &origin)

Legt den Punkt „ origin “ für die Transformation in Elementkoordinaten fest.

Siehe auch „ transformOriginPoint()“ und „ Transformations “.

void QGraphicsItem::setTransformOriginPoint(qreal x, qreal y)

Legt den Ursprungspunkt für die Transformation in Elementkoordinaten fest. Dies entspricht dem Aufruf von `setTransformOriginPoint(QPointF(x, y))`.

Siehe auch „ setTransformOriginPoint()“ und „ Transformations “.

void QGraphicsItem::setTransformations(const QList<QGraphicsTransform *> &transformations)

Legt eine Liste von Grafik transformations en (QGraphicsTransform) fest, die derzeit für dieses Element gelten.

Wenn Sie ein Element lediglich drehen oder skalieren möchten, sollten Sie stattdessen „ setRotation()“ oder „ setScale()“ aufrufen. Wenn Sie eine beliebige Transformation für ein Element festlegen möchten, können Sie „ setTransform()“ aufrufen.

QGraphicsTransform dient dazu, eine Kette einzelner Transformationsoperationen auf ein Element anzuwenden und zu steuern. Dies ist besonders nützlich bei Animationen, bei denen jede Transformationsoperation unabhängig voneinander oder auf unterschiedliche Weise interpoliert werden muss.

Die Transformationen werden mit den Methoden „ rotation()“, „ scale()“ und „ transform()“ des Elements kombiniert, um das Koordinatensystem des Elements auf das übergeordnete Element abzubilden.

Siehe auch „ transformations()“, „ scale()“, „ setTransformOriginPoint()“ und „ Transformations “.

void QGraphicsItem::setVisible(bool visible)

Wenn „ visible “ wahr ist, wird das Element sichtbar gemacht. Andernfalls wird das Element unsichtbar gemacht. Unsichtbare Elemente werden nicht gezeichnet und empfangen auch keine Ereignisse. Insbesondere werden Mausereignisse direkt durch unsichtbare Elemente hindurchgeleitet und an alle dahinter liegenden Elemente weitergeleitet. Unsichtbare Elemente können zudem nicht ausgewählt werden, sie können keinen Eingabefokus erhalten und werden von den Funktionen zur Ermittlung der Elementposition in QGraphicsScene nicht erkannt.

Wenn ein Element unsichtbar wird, während es den Mauszeiger hält (d. h. während es Mausereignisse empfängt), verliert es automatisch den Mauszeiger, und dieser wird nicht wiedererlangt, indem das Element erneut sichtbar gemacht wird; es muss ein neuer Mausklick erfolgen, um den Mauszeiger wieder zu erhalten.

Ebenso kann ein unsichtbares Element keinen Fokus haben; wenn das Element also den Fokus hat, wenn es unsichtbar wird, verliert es den Fokus, und der Fokus wird nicht wiederhergestellt, indem das Element einfach wieder sichtbar gemacht wird.

Wenn Sie ein übergeordnetes Element ausblenden, werden auch alle seine untergeordneten Elemente ausgeblendet. Wenn Sie ein übergeordnetes Element einblenden, werden alle untergeordneten Elemente eingeblendet, es sei denn, sie wurden explizit ausgeblendet (d. h., wenn Sie setVisible(false) für ein untergeordnetes Element aufrufen, wird es nicht wieder eingeblendet, selbst wenn sein übergeordnetes Element ausgeblendet und anschließend wieder eingeblendet wird).

Elemente sind standardmäßig sichtbar; es ist nicht erforderlich, `setVisible()` für ein neues Element aufzurufen.

Siehe auch „ isVisible()“, „ show()“, „ hide()“ und „ setOpacity()“.

void QGraphicsItem::setX(qreal x)

Legt die Koordinate der Position des Elements im x fest. Entspricht dem Aufruf von ` setPos(x, y())`.

Siehe auch x() und setPos().

void QGraphicsItem::setY(qreal y)

Legt die Koordinate der Position des Elements im y fest. Entspricht dem Aufruf von setPos(x(), y).

Siehe auch y(), x() und setPos().

void QGraphicsItem::setZValue(qreal z)

Setzt den Z-Wert des Elements auf „ z “. Der Z-Wert bestimmt die Stapelreihenfolge von gleichrangigen (benachbarten) Elementen. Ein gleichrangiges Element mit einem höheren Z-Wert wird immer über einem anderen gleichrangigen Element mit einem niedrigeren Z-Wert dargestellt.

Wenn Sie den Z-Wert zurücksetzen, bestimmt die Einfüge-Reihenfolge des Elements dessen Stapelreihenfolge.

Der Z-Wert hat keinerlei Einfluss auf die Größe des Elements.

Der Standard-Z-Wert ist 0.

Siehe auch zValue(), Sorting, stackBefore() und ItemStacksBehindParent.

[virtual] QPainterPath QGraphicsItem::shape() const

Gibt die Form dieses Elements als „ QPainterPath “ in lokalen Koordinaten zurück. Die Form wird für viele Zwecke verwendet, darunter zur Kollisionserkennung, für Hit-Tests und für die Funktionen „ QGraphicsScene::items()“.

Die Standardimplementierung ruft „ boundingRect()“ auf, um eine einfache rechteckige Form zurückzugeben, aber Unterklassen können diese Funktion neu implementieren, um für nicht-rechteckige Elemente eine genauere Form zurückzugeben. Ein rundes Element könnte beispielsweise eine elliptische Form zurückgeben, um die Kollisionserkennung zu verbessern. Beispiel:

QPainterPath RoundItem::shape() const
{
    QPainterPath path;
    path.addEllipse(boundingRect());
    return path;
}

Der Umriss einer Form kann je nach Breite und Stil des beim Zeichnen verwendeten Stifts variieren. Wenn Sie diesen Umriss in die Form des Elements einbeziehen möchten, können Sie mit ` QPainterPathStroker` eine Form aus dem Strich erstellen.

Diese Funktion wird von den Standardimplementierungen von ` contains()` und ` collidesWithPath()` aufgerufen.

Siehe auch boundingRect(), contains(), prepareGeometryChange() und QPainterPathStroker.

void QGraphicsItem::show()

Zeigt das Element an (Elemente sind standardmäßig sichtbar).

Diese Komfortfunktion entspricht dem Aufruf von ` setVisible(true)`.

Siehe auch „ hide()“ und „ setVisible()“.

void QGraphicsItem::stackBefore(const QGraphicsItem *sibling)

Stellt dieses Element vor „ sibling “, was bedeutet, dass dieses Element hinter dem gleichrangigen Element gezeichnet wird. Mit anderen Worten: Das gleichrangige Element wird optisch über diesem Element angezeigt.

Die beiden Elemente müssen Geschwisterelemente sein (d. h., sie müssen dasselbe übergeordnete Element haben oder beide Elemente der obersten Ebene sein). Das Element „ sibling “ muss denselben Z-Wert wie dieses Element haben, andernfalls hat der Aufruf dieser Funktion keine Wirkung.

Standardmäßig werden alle gleichrangigen Elemente in der Reihenfolge ihrer Einfügung gestapelt (d. h., das erste Element, das Sie hinzufügen, wird vor dem nächsten Element gezeichnet, das Sie hinzufügen). Wenn die Z-Werte zweier Elemente unterschiedlich sind, wird das Element mit dem höheren Z-Wert obenauf gezeichnet. Sind die Z-Werte identisch, entscheidet die Einfügungsreihenfolge über die Stapelreihenfolge.

Siehe auch setZValue(), ItemStacksBehindParent und Sorting.

QGraphicsObject *QGraphicsItem::toGraphicsObject()

Gibt das in ein ` QGraphicsObject` umgewandelte Grafikobjekt zurück, sofern es sich tatsächlich um ein Grafikobjekt handelt; andernfalls 0.

const QGraphicsObject *QGraphicsItem::toGraphicsObject() const

Gibt das in ein ` QGraphicsObject` umgewandelte Grafikobjekt zurück, sofern es sich bei der Klasse tatsächlich um ein Grafikobjekt handelt; andernfalls 0.

QString QGraphicsItem::toolTip() const

Gibt den Tooltip des Elements zurück oder ein leeres ` QString `, falls kein Tooltip festgelegt wurde.

Siehe auch „ setToolTip()“ und „ QToolTip “.

QGraphicsItem *QGraphicsItem::topLevelItem() const

Gibt das Element der obersten Ebene dieses Elements zurück. Das Element der obersten Ebene ist das oberste übergeordnete Element des Elements, dessen Elternelement nullptr ist. Wenn ein Element kein Elternelement hat, wird sein eigener Zeiger zurückgegeben (d. h., ein Element der obersten Ebene ist sein eigenes Element der obersten Ebene).

Siehe auch parentItem().

QGraphicsWidget *QGraphicsItem::topLevelWidget() const

Gibt einen Zeiger auf das Widget der obersten Ebene des Elements zurück (d. h. auf das übergeordnete Element des Elements, dessen Elternteil „ nullptr “ ist oder dessen Elternteil kein Widget ist) oder „ nullptr “, falls dieses Element kein Widget der obersten Ebene hat. Ist das Element selbst das Widget der obersten Ebene, gibt diese Funktion einen Zeiger auf das Element selbst zurück.

QTransform QGraphicsItem::transform() const

Gibt die Transformationsmatrix dieses Elements zurück.

Die Transformationsmatrix wird mit den Funktionen „ rotation()“, „ scale()“ und „ transformations()“ des Elements zu einer kombinierten Transformation für das Element zusammengefasst.

Die Standard-Transformationsmatrix ist eine Einheitsmatrix.

Siehe auch „ setTransform()“ und „ sceneTransform()“.

QPointF QGraphicsItem::transformOriginPoint() const

Gibt den Ursprungspunkt für die Transformation in Elementkoordinaten zurück.

Der Standardwert ist QPointF(0,0).

Siehe auch „ setTransformOriginPoint()“ und „ Transformations “.

QList<QGraphicsTransform *> QGraphicsItem::transformations() const

Gibt eine Liste der Grafiktransformationen zurück, die derzeit auf dieses Element angewendet werden.

QGraphicsTransform Dient zum Anwenden und Steuern einer Kette einzelner Transformationsoperationen auf ein Element. Dies ist besonders nützlich bei Animationen, bei denen jede Transformationsoperation unabhängig voneinander oder auf unterschiedliche Weise interpoliert werden muss.

Die Transformationen werden mit den Methoden „ rotation()“, „ scale()“ und „ transform()“ des Elements kombiniert, um das Koordinatensystem des Elements auf das übergeordnete Element abzubilden.

Siehe auch „ setTransformations()“, „ scale()“, „ rotation()“, „ transformOriginPoint()“ und „ Transformations “.

[virtual] int QGraphicsItem::type() const

Gibt den Typ eines Elements als int zurück. Alle Standardklassen für Grafikobjekte sind mit einem eindeutigen Wert verknüpft; siehe QGraphicsItem::Type. Diese Typinformationen werden von qgraphicsitem_cast() verwendet, um zwischen den Typen zu unterscheiden.

Die Standardimplementierung (in ` QGraphicsItem`) gibt ` UserType` zurück.

Um die Verwendung von ` qgraphicsitem_cast()` mit einem benutzerdefinierten Element zu ermöglichen, implementieren Sie diese Funktion neu und deklarieren Sie einen `Type`-Enum-Wert, der dem Typ Ihres benutzerdefinierten Elements entspricht. Benutzerdefinierte Elemente müssen einen Wert zurückgeben, der größer oder gleich ` UserType ` (65536) ist.

Beispiel:

class Item : public QGraphicsItem
{
public:
   enum { Type = UserType + 1 };

   int type() const override
   {
       // Enable the use of qgraphicsitem_cast with this item.
       return Type;
   }
   //...
};

Siehe auch UserType.

void QGraphicsItem::ungrabKeyboard()

Hebt die Tastatursperre auf.

Siehe auch „ grabKeyboard “ () und „ ungrabMouse “ ().

void QGraphicsItem::ungrabMouse()

Löst die Mausfesselung auf.

Siehe auch grabMouse() und ungrabKeyboard().

void QGraphicsItem::unsetCursor()

Entfernt den Cursor von diesem Element.

Siehe auch hasCursor() und setCursor().

void QGraphicsItem::update(const QRectF &rect = QRectF())

Plant eine Neuzeichnung des Bereichs, der von „ rect “ in diesem Element abgedeckt wird. Sie können diese Funktion immer dann aufrufen, wenn Ihr Element neu gezeichnet werden muss, beispielsweise wenn sich dessen Erscheinungsbild oder Größe ändert.

Diese Funktion löst keine sofortige Neuzeichnung aus, sondern plant eine Neuzeichnungsanforderung ein, die von ` QGraphicsView ` verarbeitet wird, sobald die Steuerung die Ereignisschleife erreicht. Das Element wird nur dann neu gezeichnet, wenn es in einer zugehörigen Ansicht sichtbar ist.

Als Nebeneffekt der Neuzeichnung des Elements können auch andere Elemente, die den Bereich „ rect “ überlappen, neu gezeichnet werden.

Ist das Element unsichtbar (d. h., „ isVisible()“ gibt „ false “ zurück), führt diese Funktion keine Aktion aus.

Siehe auch ` paint()` und ` boundingRect()`.

void QGraphicsItem::update(qreal x, qreal y, qreal width, qreal height)

Diese Komfortfunktion entspricht dem Aufruf von `update(QRectF(x, y, width, height))`.

[protected] void QGraphicsItem::updateMicroFocus()

Aktualisiert den Mikrofokus des Objekts.

Siehe auch QInputMethod.

[virtual protected] void QGraphicsItem::wheelEvent(QGraphicsSceneWheelEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann neu implementiert werden, um Räder-Ereignisse für dieses Element zu empfangen. Wenn Sie diese Funktion neu implementieren, wird „ event “ standardmäßig akzeptiert.

Wenn Sie das Ereignis ignorieren (z. B. durch Aufruf von ` QEvent::ignore()`), wird es an alle untergeordneten Elemente weitergeleitet. Wenn kein Element das Ereignis akzeptiert, wird es von der Szene ignoriert und an die Ansicht weitergeleitet (z. B. an die vertikale Bildlaufleiste der Ansicht).

Die Standardimplementierung ignoriert das Ereignis.

Siehe auch ` sceneEvent()`.

QGraphicsWidget *QGraphicsItem::window() const

Gibt das Fenster des Elements zurück oder „ nullptr “, falls dieses Element kein Fenster hat. Handelt es sich bei dem Element um ein Fenster, wird es selbst zurückgegeben. Andernfalls wird der nächsthöhere Vorfahr zurückgegeben, der ein Fenster ist.

Siehe auch QGraphicsWidget::isWindow().

qreal QGraphicsItem::x() const

Diese Komfortfunktion entspricht dem Aufruf von ` pos().x()`.

Siehe auch „ setX()“ und „ y()“.

qreal QGraphicsItem::y() const

Diese Komfortfunktion entspricht dem Aufruf von ` pos()`.y().

Siehe auch „ setY()“ und „ x()“.

qreal QGraphicsItem::zValue() const

Gibt den Z-Wert des Elements zurück. Der Z-Wert beeinflusst die Stapelreihenfolge benachbarter Elemente.

Der Standard-Z-Wert ist 0.

Siehe auch „ setZValue()“, „ Sorting “, „ stackBefore()“ und „ ItemStacksBehindParent “.