QGraphicsItem Class

Dokumentation der Mitgliedsfunktionen

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

Konstruiert ein QGraphicsItem mit dem angegebenen parent Element. Das übergeordnete Objekt, das von QObject::parent() zurückgegeben wird, wird nicht verändert.

Wenn parent nullptr ist, können Sie das Element durch den 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()

Zerstört das Element QGraphicsItem und alle seine Unterelemente. Wenn dieses Element derzeit mit einer Szene verknüpft ist, wird das Element aus der Szene entfernt, bevor es gelöscht wird.

bool QGraphicsItem::acceptDrops() const

Gibt true zurück, wenn dieses Element Drag&Drop-Ereignisse akzeptieren kann; andernfalls wird false zurückgegeben. Standardmäßig akzeptieren Elemente keine Drag&Drop-Ereignisse; Elemente sind für Drag&Drop 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 Gegenstand touch events akzeptiert; andernfalls wird false zurückgegeben. Standardmäßig akzeptieren Gegenstände keine Berührungsereignisse.

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 Mausgrabber-Element, wenn ein Mausdruckereignis für diese Maustaste geliefert wird. Akzeptiert das Element die Maustaste jedoch nicht, leitet QGraphicsScene die Mausereignisse an das erste Element weiter, das darunter liegt und die Maustaste akzeptiert.

Siehe auch setAcceptedMouseButtons() und mousePressEvent().

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

Diese virtuelle Funktion wird zweimal für alle Elemente durch den QGraphicsScene::advance()-Slot aufgerufen. In der ersten Phase werden alle Elemente mit phase == 0 aufgerufen, was anzeigt, dass die Elemente in der Szene im Begriff sind, sich weiterzuentwickeln, und dann werden alle Elemente mit phase == 1 aufgerufen. Implementieren Sie diese Funktion neu, um Ihr Element zu aktualisieren, wenn Sie eine einfache szenengesteuerte Animation benötigen.

Die Standardimplementierung tut nichts.

Diese Funktion ist für Animationen gedacht. Eine Alternative ist die Mehrfachvererbung von QObject und QGraphicsItem und die Verwendung des Animation Frameworks.

Siehe auch QGraphicsScene::advance() und QTimeLine.

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

Diese rein virtuelle Funktion definiert die äußeren Grenzen des Elements als Rechteck; alle Malvorgänge müssen sich auf das Innere des Begrenzungsrechtecks eines Elements beschränken. QGraphicsView verwendet dies, um zu bestimmen, ob das Element neu gezeichnet werden muss.

Obwohl die Form des Objekts beliebig sein kann, ist das Begrenzungsrechteck immer rechteckig und wird von der Transformation des Objekts nicht berührt.

Wenn Sie das Begrenzungsrechteck des Objekts ändern wollen, müssen Sie zuerst prepareGeometryChange() aufrufen. Dadurch wird die Szene über die bevorstehende Änderung informiert, so dass sie den Geometrieindex des Elements aktualisieren kann; andernfalls weiß die Szene nichts von der neuen Geometrie des Elements, und die Ergebnisse sind undefiniert (typischerweise werden Rendering-Artefakte in der Ansicht hinterlassen).

Reimplementieren Sie diese Funktion, damit QGraphicsView bestimmen kann, welche Teile des Widgets, wenn überhaupt, neu gezeichnet werden müssen.

Hinweis: Für Formen, die einen Umriss / Strich malen, ist es wichtig, die Hälfte der Stiftbreite in das Begrenzungsrechteck einzubeziehen. Es ist jedoch nicht notwendig, Antialiasing zu kompensieren.

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 eine Identität QTransform als Parameter übergeben, gibt diese Funktion einen lokalen Koordinatenbereich zurück.

Die Bounding-Region beschreibt einen groben Umriss des visuellen Inhalts des Elements. Die Berechnung ist zwar aufwändig, aber präziser als boundingRect() und kann dazu beitragen, dass ein Element nicht unnötig neu gezeichnet wird, wenn es aktualisiert wird. Dies ist besonders effizient für dünne Elemente (z. B. Linien oder einfache Polygone). Sie können die Granularität für den Begrenzungsbereich durch den Aufruf von setBoundingRegionGranularity() einstellen. Die Standardgranularität ist 0, d. h. der Begrenzungsbereich des Objekts entspricht dem Begrenzungsrechteck des Objekts.

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

Siehe auch boundingRegionGranularity().

qreal QGraphicsItem::boundingRegionGranularity() const

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

Siehe auch setBoundingRegionGranularity().

QGraphicsItem::CacheMode QGraphicsItem::cacheMode() const

Gibt den Cachemodus für dieses Element zurück. Der Standardmodus ist NoCache (d. h., der Cache ist deaktiviert und alle Bilder werden sofort angezeigt).

Siehe auch setCacheMode().

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

Gibt eine Liste der Kinder dieses Elements zurück.

Die Elemente werden nach 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 enthält alle Nachkommen, nachdem sie auf lokale Koordinaten abgebildet worden sind. Wenn das Element keine Kinder hat, gibt diese Funktion ein leeres QRectF zurück.

Dies beinhaltet nicht das eigene Begrenzungsrechteck dieses Elements; es gibt nur die kumulierten Begrenzungsrechte seiner Nachkommen zurück. Wenn Sie das Begrenzungsrechteck dieses Elements einbeziehen müssen, können Sie boundingRect() zu childrenBoundingRect() mit QRectF::operator|() hinzufügen.

Diese Funktion ist linear in der Komplexität; sie bestimmt die Größe des zurückgegebenen Bounding Rects durch Iteration durch alle Nachfahren.

Siehe auch boundingRect() und sceneBoundingRect().

void QGraphicsItem::clearFocus()

Nimmt den Tastatureingabefokus vom Element.

Wenn es den Fokus hat, wird eine focus out event an dieses Element gesendet, um ihm mitzuteilen, dass es im Begriff ist, den Fokus zu verlieren.

Nur Elemente, die das Kennzeichen ItemIsFocusable setzen, oder Widgets, die eine entsprechende Fokusrichtlinie festlegen, können den Tastaturfokus annehmen.

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

QPainterPath QGraphicsItem::clipPath() const

Gibt den Clip-Pfad dieses Elements zurück oder ein leeres QPainterPath, wenn dieses Element nicht geclippt ist. Der Beschneidungspfad schränkt das Erscheinungsbild und die Interaktion des Objekts ein (d. h., er begrenzt den Bereich, in dem das Objekt zeichnen und Ereignisse empfangen kann).

Sie können die Beschneidung aktivieren, indem Sie die Flags ItemClipsToShape oder ItemClipsChildrenToShape setzen. Der Beschneidungspfad des Objekts wird berechnet, indem alle Formen der Beschneidungsvorfahren geschnitten werden. Wenn das Element ItemClipsToShape setzt, wird der endgültige Clip 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 begrenzende Rechteck wird dann mit der Form dieses Elements verglichen. Der Standardwert für mode ist Qt::IntersectsItemShape; other kollidiert mit diesem Element, wenn es die Form dieses Elements entweder schneidet, enthält oder in ihr enthalten ist (siehe Qt::ItemSelectionMode für Einzelheiten).

Die Standardimplementierung basiert auf der Formschnittmenge und ruft shape() für beide Elemente auf. Da die Komplexität einer beliebigen Formschnittmenge um eine Größenordnung zunimmt, wenn die Formen komplex sind, kann dieser Vorgang sehr zeitaufwändig sein. Sie haben die Möglichkeit, diese Funktion in einer Unterklasse von QGraphicsItem neu zu implementieren, um einen eigenen Algorithmus bereitzustellen. So können Sie die natürlichen Beschränkungen in den Formen Ihrer eigenen Elemente nutzen, um die Leistung der Kollisionserkennung zu verbessern. Zum Beispiel kann die Kollision zweier nicht transformierter, perfekt kreisförmiger Objekte sehr effizient durch den Vergleich ihrer Positionen und Radien bestimmt werden.

Beachten Sie bei der Neuimplementierung dieser Funktion und dem Aufruf von shape() oder boundingRect() auf other, dass die zurückgegebenen Koordinaten auf das Koordinatensystem dieses Elements abgebildet werden müssen, bevor eine Überschneidung stattfinden 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 die Form dieses Elements entweder schneidet, enthält oder von ihr umfasst wird.

Beachten Sie, dass diese Funktion prüft, ob die Form oder das Begrenzungsrechteck des Elements (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 verglichen. Der Standardwert für mode ist Qt::IntersectsItemShape.

Siehe auch collidesWithItem().

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

Gibt den nächsten gemeinsamen Vorgänger dieses Elements und other zurück, oder nullptr, wenn entweder other nullptr ist, oder es keinen gemeinsamen Vorgänger gibt.

Siehe auch isAncestorOf().

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

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

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

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

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

Dieser Eventhandler kann in einer Unterklasse neu implementiert werden, um Kontextmenüereignisse zu verarbeiten. Der Parameter event enthält Details über das zu behandelnde Ereignis.

Wenn Sie das Ereignis ignorieren (z. B. durch den Aufruf von QEvent::ignore()), wird event an jedes Element unterhalb dieses Elements weitergegeben. Wenn keine Elemente das Ereignis akzeptieren, wird es von der Szene ignoriert und an die Ansicht weitergegeben.

Es ist üblich, ein QMenu als Reaktion auf den Empfang eines Kontextmenü-Ereignisses 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 Form des Cursors für das Element zurück. Der Mauszeiger nimmt diese Form an, wenn er sich über diesem Element befindet. Siehe list of predefined cursor objects für eine Reihe von nützlichen Formen.

Ein Editor-Element könnte einen I-Balken-Cursor verwenden wollen:

item->setCursor(Qt::IBeamCursor);

Wenn kein Cursor festgelegt wurde, wird der Cursor des darunter liegenden 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);
if (item->data(ObjectName).toString().isEmpty()) {
    if (qgraphicsitem_cast<ButtonItem *>(item))
        item->setData(ObjectName, "Button");
}

Qt verwendet diese Funktion nicht zum Speichern von Daten; sie wird nur zur Bequemlichkeit des Benutzers bereitgestellt.

Siehe auch setData().

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

Gibt die Gerätetransformationsmatrix dieses Elements zurück, wobei viewportTransform zur Abbildung von Szenekoordinaten auf Gerätekoordinaten verwendet wird. Diese Matrix kann verwendet werden, um Koordinaten und geometrische Formen vom lokalen Koordinatensystem dieses Objekts 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 Objekts mit der Viewport-Transformation des Viewports, versteht aber auch das ItemIgnoresTransformations Flag. Die Gerätetransformation kann verwendet werden, um eine genaue Koordinatenzuordnung (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 Event-Handler für das Ereignis event kann neu implementiert werden, um Drag-Enter-Ereignisse für dieses Element zu empfangen. Drag-Enter-Ereignisse werden erzeugt, wenn der Cursor in den Bereich des Elements eintritt.

Wenn das Ereignis akzeptiert wird (d. h. durch den Aufruf von QEvent::accept()), akzeptiert das Element Drop-Ereignisse und empfängt außerdem Drag Move und Drag Leave. Andernfalls wird das Ereignis ignoriert und an das darunter liegende Element weitergegeben. Wenn das Ereignis akzeptiert wird, erhält das Element ein Drag Move-Ereignis, bevor die Kontrolle an die Ereignisschleife zurückgeht.

Eine übliche Implementierung von dragEnterEvent akzeptiert oder ignoriert event abhängig 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 erhalten standardmäßig keine Drag&Drop-Ereignisse; um diese Funktion zu aktivieren, rufen Sie setAcceptDrops(true) auf.

Die Standardimplementierung tut nichts.

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

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

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

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

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

Die Standardimplementierung tut nichts.

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

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

Dieser Event-Handler für das Ereignis event kann neu implementiert werden, um Drag-Move-Ereignisse für dieses Element zu empfangen. Ziehbewegungsereignisse werden erzeugt, wenn sich der Cursor innerhalb des Bereichs des Elements bewegt. In den meisten Fällen werden Sie diese Funktion nicht neu implementieren müssen; sie wird verwendet, um anzuzeigen, dass nur Teile des Objekts fallen gelassen werden können.

Der Aufruf von QEvent::ignore() oder QEvent::accept() auf event schaltet um, ob der Gegenstand an der Position des Ereignisses Tropfen annimmt oder nicht. Standardmäßig wird event akzeptiert, was anzeigt, dass das Element Abwürfe an der angegebenen Position zulässt.

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

Die Standardimplementierung tut nichts.

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

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

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

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

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

Die Standardimplementierung bewirkt nichts.

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 ist eine Kombination aus der lokalen Deckkraft des Elements und der Deckkraft seiner Eltern und Vorfahren. Die effektive Deckkraft bestimmt, wie das Element gerendert wird.

Siehe auch opacity(), setOpacity(), paint(), ItemIgnoresParentOpacity, und 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 betrachtet wird, versucht diese Funktion, die Ansicht zu scrollen, um sicherzustellen, dass rect innerhalb des Ansichtsfensters sichtbar ist. Wenn rect ein Null-Rect ist (die Vorgabe), wird QGraphicsItem auf das Begrenzungs-Rect des Elements gesetzt. xmargin und ymargin sind die Anzahl der Pixel, die der View für die Ränder verwenden soll.

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

Wenn dieses Element nicht von einem QGraphicsView angezeigt wird, bewirkt diese Funktion nichts.

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 zum Beispiel ItemIsFocusable enthalten, kann das Element den Eingabefokus akzeptieren.

Standardmäßig sind keine Flags aktiviert.

Siehe auch setFlags() und setFlag().

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

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

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

QGraphicsItem *QGraphicsItem::focusItem() const

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

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

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

Dieser Event-Handler für das Ereignis event kann neu implementiert werden, um Focus-Out-Ereignisse für dieses Element zu empfangen. Die Standardimplementierung tut nichts.

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

QGraphicsItem *QGraphicsItem::focusProxy() const

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

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

void QGraphicsItem::grabKeyboard()

Ergreift die Tastatureingabe.

Der Gegenstand erhält alle Tastatureingaben in der Szene, bis eines der folgenden Ereignisse eintritt:

• Der Gegenstand wird unsichtbar
• Der Gegenstand 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 Tastatureingabe zurück, wenn das andere Element ungrabKeyboard() aufruft.

Wenn ein Element den Tastaturgriff erlangt, erhält es ein QEvent::GrabKeyboard Ereignis. Wenn es die Tastaturbelegung verliert, erhält es ein QEvent::UngrabKeyboard Ereignis. Diese Ereignisse können verwendet werden, um zu erkennen, wenn Ihr Element den Tastaturzugriff auf andere Weise als durch das Erreichen des Eingabefokus erhält oder verliert.

Es ist fast nie notwendig, die Tastatur in Qt explizit zu ergreifen, da Qt sie sinnvollerweise ergreift und freigibt. Insbesondere ergreift Qt die Tastatur, wenn Ihr Element den Eingabefokus erhält, und gibt sie wieder frei, wenn Ihr Element den Eingabefokus verliert oder wenn das Element versteckt ist.

Beachten Sie, dass nur sichtbare Elemente Tastatureingaben erfassen können. Der Aufruf von grabKeyboard() auf einem unsichtbaren Element hat keinen Effekt.

Tastaturereignisse sind nicht betroffen.

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

void QGraphicsItem::grabMouse()

Ergreift die Mauseingabe.

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

• Der Gegenstand wird unsichtbar
• Der Gegenstand wird aus der Szene entfernt
• Das Element wird gelöscht
• Das Element ruft ungrabMouse() auf
• Ein anderes Element ruft grabMouse() auf; das Element erhält den Mausgriff zurück, wenn das andere Element ungrabMouse() aufruft.

Wenn ein Element die Maus zu fassen bekommt, erhält es ein QEvent::GrabMouse Ereignis. Wenn es den Mausgriff verliert, erhält es ein QEvent::UngrabMouse Ereignis. Diese Ereignisse können verwendet werden, um zu erkennen, wann ein Element den Mausgriff auf andere Weise als durch den Empfang von Maustastenereignissen erhält oder verliert.

Es ist fast nie notwendig, die Maus in Qt explizit zu greifen, da Qt die Maus auf sinnvolle Weise greift und loslässt. Insbesondere ergreift Qt die Maus, wenn Sie eine Maustaste drücken, und hält die Maus fest, bis Sie die letzte Maustaste loslassen. Außerdem rufen Qt::Popup Widgets implizit grabMouse() auf, wenn sie angezeigt werden, und ungrabMouse(), wenn sie versteckt sind.

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

Tastaturereignisse sind nicht betroffen.

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

QGraphicsEffect *QGraphicsItem::graphicsEffect() const

Gibt einen Zeiger auf den Effekt dieses Elements zurück, wenn es einen hat; andernfalls nullptr.

Siehe auch setGraphicsEffect().

QGraphicsItemGroup *QGraphicsItem::group() const

Gibt einen Zeiger auf die Artikelgruppe dieses Artikels zurück, oder nullptr, wenn dieser Artikel nicht Mitglied einer Gruppe ist.

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

bool QGraphicsItem::hasCursor() const

Gibt true zurück, wenn dieses Element einen Cursor gesetzt hat; andernfalls wird false zurückgegeben.

Standardmäßig ist für Elemente kein Cursor gesetzt. cursor() gibt einen Standard-Pfeilcursor zurück.

Siehe auch unsetCursor().

bool QGraphicsItem::hasFocus() const

Gibt true zurück, wenn dieses Element aktiv ist und es oder sein focus proxy den Fokus der Tastatureingabe hat; 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 Event-Handler für das Ereignis event kann neu implementiert werden, um Hover-Entry-Ereignisse für dieses Element zu empfangen. Die Standardimplementierung ruft update() auf; andernfalls tut sie nichts.

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

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

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

Dieser Event-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 tut sie nichts.

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

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

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

Dieser Event-Handler für das Ereignis event kann neu implementiert werden, um Hover-Move-Ereignisse für dieses Element zu empfangen. Die Standardimplementierung bewirkt nichts.

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

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

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

Diese Ereignisbehandlungsroutine für das Ereignis event kann neu implementiert werden, um Eingabemethodenereignisse für dieses Element zu empfangen. Die Standardimplementierung ignoriert das Ereignis.

Siehe auch inputMethodQuery() und sceneEvent().

Qt::InputMethodHints QGraphicsItem::inputMethodHints() const

Liefert die aktuellen Eingabemethoden-Hinweise für diesen Eintrag.

Hinweise zur Eingabemethode sind nur für Eingabeelemente relevant. Die Hinweise werden von der Eingabemethode verwendet, um anzuzeigen, wie sie arbeiten soll. Wenn zum Beispiel das Qt::ImhNumbersOnly Flag gesetzt ist, kann die Eingabemethode ihre visuellen Komponenten ändern, um anzuzeigen, dass nur Zahlen eingegeben werden können.

Der Effekt kann 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, um komplexe Eingabemethoden zu unterstützen, wie z. B. die Unterstützung von umgebendem Text und Rückumwandlungen. query gibt an, welche Eigenschaft abgefragt wird.

Siehe auch inputMethodEvent() und QInputMethodEvent.

void QGraphicsItem::installSceneEventFilter(QGraphicsItem *filterItem)

Installiert einen Ereignisfilter für dieses Element auf filterItem, wodurch alle Ereignisse für dieses Element zuerst die Funktion sceneEventFilter() von filterItem durchlaufen.

Um die Ereignisse eines anderen Elements zu filtern, installieren Sie dieses Element als einen 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 für andere Elemente in derselben Szene filtern. Außerdem kann ein Element nicht seine eigenen Ereignisse filtern; stattdessen können Sie sceneEvent() direkt neu implementieren.

Elemente müssen zu einer Szene gehören, damit Ereignisfilter für Szenen 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 false.

Ein Element kann nur aktiv sein, wenn die Szene aktiv ist. Ein Element ist aktiv, wenn es ein aktives Bedienfeld ist oder von einem solchen abhängt. Elemente in nicht aktiven Panels sind nicht aktiv.

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

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 Vorfahre von child ist (d. h., wenn dieses Element ein Elternteil von child oder ein Vorfahre eines Elternteils von child ist).

Siehe auch parentItem().

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

Gibt true zurück, wenn dieses Element durch ein modales Panel blockiert wird, andernfalls false. Wenn blockingPanel ungleich Null ist, wird blockingPanel auf das modale Panel gesetzt, das dieses Element blockiert. Wenn dieses Element nicht blockiert ist, wird blockingPanel von dieser Funktion nicht gesetzt.

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

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

bool QGraphicsItem::isClipped() const

Gibt true zurück, wenn dieses Element geclippt ist. Ein Element ist beschnitten, wenn es entweder das Flag ItemClipsToShape gesetzt hat, oder wenn es oder einer seiner Vorgänger das Flag ItemClipsChildrenToShape gesetzt hat.

Das Beschneiden wirkt sich auf das Erscheinungsbild des Elements (d. h. auf das Malen) sowie auf die Ausgabe von Maus- und Schwebeereignissen 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

Dies ist eine überladene Funktion.

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

Siehe auch opaqueArea().

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

Dies ist eine überladene Funktion.

Diese Komfortfunktion ist gleichbedeutend mit 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 opaqueArea() von item auf das Koordinatensystem dieses Elements ab und prüft dann, ob das boundingRect() dieses Elements vollständig in der abgebildeten Form enthalten ist.

Sie können diese Funktion neu implementieren, um einen benutzerdefinierten Algorithmus zur Bestimmung, ob dieses Element von item verdeckt wird, bereitzustellen.

Siehe auch opaqueArea() und isObscured().

bool QGraphicsItem::isPanel() const

Gibt true zurück, wenn das Element ein Panel ist; andernfalls false.

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, erben den Auswahlstatus der Gruppe.

Standardmäßig sind Elemente nicht ausgewählt.

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

bool QGraphicsItem::isUnderMouse() const

Gibt true zurück, wenn sich dieses Element derzeit unter dem Mauszeiger in einer der Ansichten 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 nichts damit zu tun hat, 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 kann für seine Vorfahren nicht sichtbar sein, selbst wenn isVisible() wahr ist. Er kann auch für seine Vorfahren sichtbar sein, selbst wenn isVisible() falsch ist. Wenn ein Vorgänger verborgen ist, ist das Element selbst implizit verborgen. In diesem Fall gibt diese Funktion false zurück.

Siehe auch isVisible() und setVisible().

bool QGraphicsItem::isWidget() const

Gibt true zurück, wenn dieses Element ein Widget ist (d. h. QGraphicsWidget); andernfalls wird false zurückgegeben.

bool QGraphicsItem::isWindow() const

Gibt true zurück, wenn das Element ein QGraphicsWidget Fenster ist, andernfalls false.

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 Elementstatus ä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, der sich ändert. value ist der neue Wert; der Typ des Wertes 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 tut nichts und gibt value zurück.

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

Siehe auch GraphicsItemChange.

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

Gibt eine QTransform zurück, die die Koordinaten dieses Elements auf other abbildet. Wenn ok nicht null ist und es keine solche Transformation gibt, wird der boolesche Wert, auf den ok verweist, 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, so dass Sie Formen und Koordinaten selbst zuordnen können. Sie hilft Ihnen auch, effizienteren Code zu schreiben, wenn Sie wiederholt zwischen denselben zwei Elementen abbilden.

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

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

Dieser Event-Handler für das Ereignis event kann neu implementiert werden, um Tastendruck-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, die das Flag ItemIsFocusable gesetzt haben und die den Fokus der Tastatureingabe haben.

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

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

Dieser Event-Handler für das Ereignis event kann neu implementiert werden, um Ereignisse zur Freigabe von Tasten für dieses Element zu empfangen. Bei der Standardimplementierung wird das Ereignis ignoriert. Wenn Sie diesen Handler neu implementieren, wird das Ereignis standardmäßig akzeptiert.

Beachten Sie, dass Tastenereignisse nur für Elemente empfangen werden, die das Flag ItemIsFocusable gesetzt haben und die den Fokus der Tastatureingabe haben.

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

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

Überträgt den Pfad path, der sich im Koordinatensystem von item befindet, auf das Koordinatensystem dieses Elements und gibt den übertragenen Pfad zurück.

Wenn item nullptr ist, gibt diese Funktion das Gleiche 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

Überträgt den Punkt point, der sich im Koordinatensystem von item befindet, auf das Koordinatensystem dieses Elements und gibt die übertragene Koordinate zurück.

Wenn item nullptr ist, gibt diese Funktion dasselbe 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

Bildet das Polygon polygon, das sich im Koordinatensystem von item befindet, auf das Koordinatensystem dieses Elements ab und gibt das abgebildete Polygon zurück.

Wenn item nullptr ist, gibt diese Funktion dasselbe 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

Bildet das Rechteck rect, das sich im Koordinatensystem von item befindet, auf das Koordinatensystem dieses Elements ab und gibt das abgebildete Rechteck als Polygon zurück.

Wenn item nullptr ist, gibt diese Funktion dasselbe 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

Dies ist eine überladene Funktion.

Diese Komfortfunktion ist gleichbedeutend mit dem Aufruf von mapFromItem(item, QPointF(x, y)).

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

Überträgt den Pfad path, der sich im Koordinatensystem des übergeordneten Elements befindet, auf das Koordinatensystem dieses Elements und gibt den übertragenen Pfad zurück.

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

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

Überträgt den Punkt point, der sich im Koordinatensystem des übergeordneten Elements befindet, auf das Koordinatensystem dieses Elements und gibt die übertragene Koordinate zurück.

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

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

Überträgt das Polygon polygon, das sich im Koordinatensystem des übergeordneten Elements befindet, auf das Koordinatensystem dieses Elements und gibt das übertragene Polygon zurück.

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

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

Überträgt das Rechteck rect, das sich im Koordinatensystem des übergeordneten Elements befindet, auf das Koordinatensystem dieses Elements und gibt das übertragene 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

Dies ist eine überladene Funktion.

Diese Komfortfunktion ist gleichbedeutend mit dem Aufruf von mapFromParent(QPointF(x, y)).

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

Überträgt den Pfad path, der sich im Koordinatensystem der Szene dieses Objekts befindet, auf das Koordinatensystem dieses Objekts und gibt den übertragenen Pfad zurück.

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

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

Überträgt den Punkt point, der sich im Koordinatensystem der Szene dieses Objekts befindet, auf das Koordinatensystem dieses Objekts und gibt die übertragene Koordinate zurück.

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

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

Bildet das Polygon polygon, das sich im Koordinatensystem der Szene dieses Elements befindet, auf das Koordinatensystem dieses Elements ab und gibt das abgebildete Polygon zurück.

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

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

Bildet das Rechteck rect, das sich im Koordinatensystem der Szene dieses Elements befindet, auf das Koordinatensystem dieses Elements ab und gibt das abgebildete 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

Dies ist eine überladene Funktion.

Diese Komfortfunktion ist gleichbedeutend mit dem Aufruf von mapFromScene(QPointF(x, y)).

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

Bildet das Rechteck rect, das sich im Koordinatensystem von item befindet, auf das Koordinatensystem dieses Elements ab und gibt das abgebildete Rechteck als neues Rechteck zurück (d. h. das Begrenzungsrechteck des resultierenden Polygons).

Wenn item nullptr ist, gibt diese Funktion dasselbe 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

Überträgt das Rechteck rect, das sich im Koordinatensystem des übergeordneten Elements befindet, auf das Koordinatensystem dieses Elements und gibt das übertragene Rechteck als neues Rechteck zurück (d. h. das Begrenzungsrechteck 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

Überträgt das Rechteck rect, das in Szenekoordinaten vorliegt, auf das Koordinatensystem dieses Elements und gibt das übertragene Rechteck als neues Rechteck zurück (d. h. das Begrenzungsrechteck 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

Überträgt das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, auf das Koordinatensystem von item und gibt das übertragene Rechteck als neues Rechteck zurück (d. h. das begrenzende Rechteck des resultierenden Polygons).

Wenn item nullptr ist, gibt diese Funktion dasselbe 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

Überträgt das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, auf das Koordinatensystem des übergeordneten Elements und gibt das übertragene Rechteck als neues Rechteck zurück (d. h. das Begrenzungsrechteck 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

Überträgt das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, auf das Koordinatensystem der Szene und gibt das übertragene Rechteck als neues Rechteck zurück (d. h. das begrenzende 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

Überträgt den Pfad path, der sich im Koordinatensystem dieses Elements befindet, auf das Koordinatensystem von item und gibt den übertragenen Pfad zurück.

Wenn item nullptr ist, gibt diese Funktion das Gleiche 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

Überträgt den Punkt point, der sich im Koordinatensystem dieses Elements befindet, in das Koordinatensystem von item und gibt die übertragene Koordinate zurück.

Wenn item nullptr ist, gibt diese Funktion dasselbe 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

Überträgt das Polygon polygon, das sich im Koordinatensystem dieses Elements befindet, auf das Koordinatensystem von item und gibt das übertragene Polygon zurück.

Wenn item nullptr ist, gibt diese Funktion dasselbe 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

Überträgt das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, auf das Koordinatensystem von item und gibt das übertragene Rechteck als Polygon zurück.

Wenn item nullptr ist, gibt diese Funktion dasselbe 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

Dies ist eine überladene Funktion.

Diese Komfortfunktion ist gleichbedeutend mit dem Aufruf von mapToItem(item, QPointF(x, y)).

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

Überträgt den Pfad path, der sich im Koordinatensystem des Elements befindet, auf das Koordinatensystem des übergeordneten Elements und gibt den übertragenen Pfad zurück. Wenn das Element kein übergeordnetes Element hat, wird path auf das Koordinatensystem der Szene abgebildet.

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

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

Überträgt den Punkt point, der sich im Koordinatensystem dieses Elements befindet, auf das Koordinatensystem seines Elternteils und gibt die übertragene Koordinate zurück. Wenn das Element kein übergeordnetes System hat, wird point auf das Koordinatensystem der Szene abgebildet.

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

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

Überträgt das Polygon polygon, das sich im Koordinatensystem dieses Objekts befindet, auf das Koordinatensystem des übergeordneten Objekts und gibt das übertragene Polygon zurück. Wenn das Element kein übergeordnetes System hat, wird polygon auf das Koordinatensystem der Szene abgebildet.

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

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

Überträgt das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, auf das Koordinatensystem des übergeordneten Elements und gibt das übertragene Rechteck als Polygon zurück. Wenn das Element kein übergeordnetes System hat, wird rect auf das Koordinatensystem der Szene abgebildet.

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

Dies ist eine überladene Funktion.

Diese Komfortfunktion ist gleichbedeutend mit 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

Überträgt den Punkt point, der sich im Koordinatensystem dieses Elements befindet, auf das Koordinatensystem der Szene und gibt die übertragene Koordinate zurück.

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

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

Bildet das Polygon polygon, das sich im Koordinatensystem dieses Elements befindet, auf das Koordinatensystem der Szene ab und gibt das abgebildete Polygon zurück.

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

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

Bildet das Rechteck rect, das sich im Koordinatensystem dieses Elements befindet, auf das Koordinatensystem der Szene ab und gibt das abgebildete 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

Dies ist eine überladene Funktion.

Diese Komfortfunktion ist gleichbedeutend mit dem Aufruf von mapToScene(QPointF(x, y)).

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

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

Wenn Sie auf ein Element doppelklicken, erhält das Element zuerst ein Mausdruck-Ereignis, gefolgt von einem Loslass-Ereignis (d. h. einem Klick), dann ein Doppelklick-Ereignis und schließlich ein Loslass-Ereignis.

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

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

Beachten Sie, dass ein Element keine Doppelklick-Ereignisse empfängt, wenn es weder selectable noch movable ist (einfache Mausklicks werden in diesem Fall ignoriert, und das verhindert die Erzeugung von Doppelklicks).

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

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

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

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

Die Standardimplementierung behandelt grundlegende Elementinteraktionen, wie Auswahl und Verschieben. Wenn Sie bei der Neuimplementierung dieser Funktion die Basisimplementierung beibehalten wollen, rufen Sie QGraphicsItem::mouseMoveEvent() in Ihrer Neuimplementierung auf.

Bitte beachten Sie, dass mousePressEvent() entscheidet, welches Grafikelement Mausereignisse empfängt. Siehe die Beschreibung von mousePressEvent() für Details.

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

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

Dieser Eventhandler für das Ereignis event kann neu implementiert werden, um Mausdruckereignisse für dieses Element zu empfangen. Mausklick-Ereignisse werden nur an Elemente geliefert, die die gedrückte Maustaste akzeptieren. Standardmäßig akzeptiert ein Element alle Maustasten, aber Sie können dies durch den Aufruf von setAcceptedMouseButtons() ändern.

Das Mausklick-Ereignis entscheidet, welches Element zum Mausgrabber werden soll (siehe QGraphicsScene::mouseGrabberItem()). Wenn Sie diese Funktion nicht neu implementieren, wird das Druckereignis an jedes oberste Element unter diesem Element weitergegeben, und es werden keine anderen Mausereignisse an dieses Element geliefert.

Wenn Sie diese Funktion neu implementieren, wird event standardmäßig akzeptiert (siehe QEvent::accept()), und dieses Element ist dann der Mausgrabber. Dies ermöglicht es dem Element, zukünftige Bewegungs-, Freigabe- und Doppelklick-Ereignisse zu empfangen. Wenn Sie QEvent::ignore() auf event aufrufen, verliert dieses Element den Mauszugriff, und event überträgt sich auf alle Elemente, die sich darunter befinden. Es werden keine weiteren Mausereignisse an dieses Element geliefert, es sei denn, es wird ein neues Mausdruckereignis empfangen.

Die Standardimplementierung behandelt grundlegende Elementinteraktionen wie die Auswahl und das Verschieben. Wenn Sie bei der Neuimplementierung dieser Funktion die Basisimplementierung beibehalten wollen, rufen Sie QGraphicsItem::mousePressEvent() in Ihrer Neuimplementierung auf.

Das Ereignis ist QEvent::ignore()d für Elemente, die weder movable noch selectable sind.

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

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

Dieser Ereignishandler für das Ereignis event kann neu implementiert werden, um Mausfreigabeereignisse für dieses Element zu empfangen.

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

Die Standardimplementierung behandelt grundlegende Elementinteraktionen, wie Auswahl und Verschieben. Wenn Sie bei der Neuimplementierung dieser Funktion die Basisimplementierung beibehalten wollen, rufen Sie QGraphicsItem::mouseReleaseEvent() in Ihrer Neuimplementierung auf.

Bitte beachten Sie, dass mousePressEvent() entscheidet, welches Grafikelement Mausereignisse empfängt. Siehe die Beschreibung von mousePressEvent() für Details.

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

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

Verschiebt das Element um dx Punkte horizontal und dy Punkt vertikal. 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 von Eltern und Vorfahren in effectiveOpacity() kombiniert. Die effektive Deckkraft entscheidet darüber, wie das Element gerendert wird und wirkt sich auch auf seine Sichtbarkeit aus, wenn es von Funktionen wie QGraphicsView::items() abgefragt wird.

Die Deckkraft-Eigenschaft entscheidet über den Zustand des Malers, der an die Funktion paint() übergeben wird. Wenn das Element im Cache gespeichert ist, d. h. ItemCoordinateCache oder DeviceCoordinateCache, wird die effektive Eigenschaft auf den Cache des Elements angewendet, wenn es gerendert wird.

Die Standard-Opazität ist 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 gefüllt ist (d. h. nicht transparent).

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

Die Standardimplementierung gibt ein leeres QPainterPath zurück, das anzeigt, 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 normalerweise von QGraphicsView aufgerufen wird, malt den Inhalt eines Elements in lokalen Koordinaten.

Reimplementieren Sie diese Funktion in einer QGraphicsItem Unterklasse, um die Malimplementierung des Elements unter Verwendung von painter bereitzustellen. Der Parameter option bietet Stiloptionen für das Element, wie z. B. seinen Zustand, den exponierten Bereich und die Hinweise zum Detaillierungsgrad. Das Argument widget ist optional. Wenn es vorhanden ist, zeigt es auf das Widget, auf das gemalt wird; andernfalls ist es 0. Für gecachte Malerei 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 Malers hat standardmäßig eine Breite von 0, und sein Stift wird mit dem QPalette::Text Pinsel aus der Palette des Malgeräts initialisiert. Der Pinsel wird mit QPalette::Window initialisiert.

Stellen Sie sicher, dass Sie alle Malvorgänge innerhalb der Grenzen von boundingRect() einschränken, um Rendering-Artefakte zu vermeiden (da QGraphicsView den Maler nicht für Sie beschneidet). Wenn QPainter den Umriss einer Form mit einem 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 nicht die Verwendung von kosmetischen Stiften mit einer Breite ungleich Null.

Alle Zeichnungen werden in lokalen Koordinaten vorgenommen.

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

QGraphicsItem *QGraphicsItem::panel() const

Gibt das Panel des Elements zurück, oder nullptr, wenn dieses Element kein Panel hat. Wenn das Element ein Panel ist, wird es sich selbst zurückgeben. Andernfalls wird der nächste Vorfahre 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 zurück, der in ein QGraphicsObject umgewandelt wird. nullptr wird zurückgegeben, 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ächstgelegene übergeordnete Element, das ein Widget ist.

Siehe auch parentItem() und childItems().

QPointF QGraphicsItem::pos() const

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

Die Position des Objekts beschreibt seinen Ursprung (lokale Koordinate (0, 0)) in übergeordneten Koordinaten; diese Funktion gibt dasselbe zurück wie mapToParent(0, 0).

Der Einfachheit halber können Sie auch scenePos() aufrufen, um die Position des Elements in Szenekoordinaten zu bestimmen, unabhängig von seinem Elternteil.

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 Objekts ändern, damit der Index von QGraphicsScene auf dem neuesten Stand bleibt.

prepareGeometryChange() ruft update() auf, wenn dies notwendig ist.

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 Objekts auf die Identitätsmatrix oder alle Transformationseigenschaften auf ihre Standardwerte zurück. Dies ist gleichbedeutend mit dem Aufruf von setTransform(QTransform()).

Siehe auch setTransform() und transform().

qreal QGraphicsItem::rotation() const

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

Die Drehung wird mit scale(), transform() und transformations() kombiniert, um das Koordinatensystem des Objekts auf das übergeordnete Objekt abzubilden.

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

qreal QGraphicsItem::scale() const

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

Der Maßstab wird mit rotation(), transform() und transformations() kombiniert, um das Koordinatensystem des Eintrags auf den übergeordneten Eintrag abzubilden.

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

QGraphicsScene *QGraphicsItem::scene() const

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

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

QRectF QGraphicsItem::sceneBoundingRect() const

Gibt das Begrenzungsrechteck dieses Elements in Szenekoordinaten 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 zu diesem Element. Reimplementieren Sie diese Funktion, 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, wobei alle an diese Elemente gesendeten Ereignisse abgefangen werden, bevor sie reagieren können.

Reimplementierungen müssen true zurückgeben, um die weitere Verarbeitung eines gegebenen Ereignisses zu verhindern und sicherzustellen, dass es nicht an das überwachte Element geliefert wird, oder false zurückgeben, um anzuzeigen, dass das Ereignis vom Ereignissystem weitergegeben werden soll.

Siehe auch installSceneEventFilter().

QPointF QGraphicsItem::scenePos() const

Gibt die Position des Objekts in Szenekoordinaten zurück. Dies ist gleichbedeutend mit dem Aufruf von mapToScene(0, 0).

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

QTransform QGraphicsItem::sceneTransform() const

Gibt die Szenen-Transformationsmatrix dieses Objekts zurück. Diese Matrix kann verwendet werden, um Koordinaten und geometrische Formen aus dem lokalen Koordinatensystem des Objekts in das Koordinatensystem der Szene zu übertragen. Um Koordinaten aus der Szene abzubilden, müssen Sie die zurückgegebene Matrix zunächst 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(), die nur die lokale Transformation eines Objekts zurückgibt, umfasst diese Funktion die Position des Objekts (und aller Eltern) 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())

Scrollt den Inhalt von rect um dx, dy. Wenn rect ein Null-Rect ist (die Vorgabe), wird das Begrenzungs-Rect des Elements gescrollt.

Scrollen bietet eine schnelle Alternative zum einfachen Neuzeichnen, wenn der Inhalt des Elements (oder Teile des Elements) vertikal oder horizontal verschoben wird. Abhängig von der aktuellen Transformation und den Fähigkeiten des Malgeräts (d.h. des Ansichtsfensters) kann diese Operation darin bestehen, dass einfach Pixel mit memmove() von einem Ort zum anderen verschoben werden. In den meisten Fällen ist dies schneller, als den gesamten Bereich neu zu rendern.

Nach dem Scrollen gibt das Element eine Aktualisierung für die neu freigelegten Bereiche aus. Wenn Scrollen nicht unterstützt wird (z.B. wenn Sie in ein OpenGL-Viewport rendern, das nicht von Scroll-Optimierungen profitiert), ist diese Funktion äquivalent zum Aufruf von update(rect).

Hinweis: Scrollen wird nur unterstützt, wenn QGraphicsItem::ItemCoordinateCache aktiviert ist; in allen anderen Fällen ist der Aufruf dieser Funktion gleichbedeutend mit 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 rect auf Ansichtsfenster-Koordinaten abbilden und das Ansichtsfenster 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 wahr ist, akzeptiert dieses Element Drag&Drop-Ereignisse; andernfalls ist es für Drag&Drop-Ereignisse transparent. Standardmäßig akzeptieren Elemente keine Drag&Drop-Ereignisse.

Siehe auch acceptDrops().

void QGraphicsItem::setAcceptHoverEvents(bool enabled)

Wenn enabled wahr ist, akzeptiert dieses Element Hover-Ereignisse; andernfalls werden sie ignoriert. Standardmäßig akzeptieren Elemente keine Hover-Ereignisse.

Hover-Ereignisse werden gesendet, wenn es kein aktuelles Mausgrabber-Element gibt. Sie werden gesendet, wenn der Mauszeiger ein Element betritt, wenn er sich innerhalb des Elements bewegt und wenn der Mauszeiger ein Element verlässt. Hover-Ereignisse werden üblicherweise verwendet, um ein Element zu markieren, wenn es betreten wird, und um den Mauszeiger zu verfolgen, wenn er über dem Element schwebt (entspricht QWidget::mouseTracking).

Übergeordnete Elemente erhalten Hover-Eingabeereignisse vor ihren Kindern und Verlassen-Ereignisse nach ihren Kindern. Das übergeordnete Element erhält jedoch kein Hover Leave-Ereignis, wenn der Mauszeiger in ein untergeordnetes Element eintritt; das übergeordnete Element bleibt so lange in der Schwebe, bis der Mauszeiger seinen Bereich, einschließlich der Bereiche der untergeordneten Elemente, verlässt.

Wenn ein übergeordnetes Element Kind-Ereignisse verarbeitet, empfängt es Hover-Move-, Drag-Move- und Drop-Ereignisse, wenn der Cursor durch seine Kinder läuft, aber es empfängt weder Hover-Entry- und Hover-Learn-Ereignisse noch Drag-Entry- und Drag-Learn-Ereignisse im Namen seiner Kinder.

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 wahr ist, akzeptiert dieser Gegenstand touch events; andernfalls ignoriert er sie. Standardmäßig akzeptieren Gegenstände keine Berührungsereignisse.

Siehe auch acceptTouchEvents().

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

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

Standardmäßig werden alle Maustasten akzeptiert. Wenn ein Element eine Maustaste akzeptiert, wird es zum Mausgrabber-Element, wenn ein Mausdruckereignis für diese Taste geliefert wird. Wenn das Element jedoch keine Maustaste akzeptiert, leitet QGraphicsScene die Mausereignisse an das erste Element weiter, das darunter liegt und eine 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 wahr ist und die Szene aktiv ist, wird das Panel dieses Elements aktiviert. Andernfalls wird das Bedienfeld deaktiviert.

Ist das Element nicht Teil einer aktiven Szene, entscheidet active, was mit dem Panel geschieht, wenn die Szene aktiv wird oder das Element der Szene hinzugefügt wird. Wenn true, wird das Panel des Objekts aktiviert, wenn das Objekt entweder zur Szene hinzugefügt 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)

Setzt die Granularität des Begrenzungsbereichs auf granularity; ein Wert zwischen einschließlich 0 und 1. 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 Objekts sein sollte. Die höchste erreichbare Granularität ist 1, wobei boundingRegion() den feinsten Umriss zurückgibt, der für das jeweilige Gerät möglich ist (z. B. ergibt dies für ein QGraphicsView Ansichtsfenster eine pixelgenaue Begrenzungsregion). Die kleinstmögliche Granularität ist 0. Der Wert von granularity beschreibt das Verhältnis zwischen der Geräteauflösung und der Auflösung der Begrenzungsregion (z. B. ergibt ein Wert von 0,25 eine Region, in der jedes Stück 4x4 Geräteeinheiten / Pixel entspricht).

Siehe auch boundingRegionGranularity().

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

Setzt den Cachemodus des Objekts auf mode.

Das optionale Argument logicalCacheSize wird nur vom Modus ItemCoordinateCache verwendet und beschreibt die Auflösung des Cache-Puffers; wenn logicalCacheSize (100, 100) ist, wird QGraphicsItem das Element in 100x100 Pixel im Grafikspeicher einpassen, unabhängig von der logischen Größe des Elements selbst. Standardmäßig verwendet QGraphicsItem die Größe von boundingRect(). Für alle anderen Cache-Modi außer ItemCoordinateCache wird logicalCacheSize ignoriert.

Die Zwischenspeicherung kann das Rendern beschleunigen, wenn Ihr Element eine beträchtliche Zeit damit verbringt, sich neu zu zeichnen. In einigen Fällen kann der Cache auch das Rendern verlangsamen, insbesondere wenn das Element weniger Zeit mit dem Neuzeichnen verbringt als QGraphicsItem mit dem Neuzeichnen aus dem Cache.

Wenn die Zwischenspeicherung aktiviert ist, zeichnet die Funktion paint() eines Elements in der Regel in einen pixmap-Zwischenspeicher außerhalb des Bildschirms; bei allen nachfolgenden Anforderungen zum erneuten Zeichnen zeichnet das Graphics View Framework aus dem Zwischenspeicher neu. Dieser Ansatz funktioniert besonders gut mit QGLWidget, das den gesamten Cache als OpenGL-Texturen speichert.

Beachten Sie, dass das Cache-Limit von QPixmapCache möglicherweise geändert werden muss, um eine optimale Leistung zu erzielen.

Sie können mehr über die verschiedenen Cachemodi in der CacheMode Dokumentation lesen.

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

void QGraphicsItem::setCursor(const QCursor &cursor)

Setzt die aktuelle Form des Mauszeigers für das Element auf cursor. Der Mauszeiger nimmt diese Form an, wenn er sich über diesem Element befindet. Siehe list of predefined cursor objects für eine Reihe von nützlichen Formen.

Ein Editor-Element könnte einen I-Balken-Cursor verwenden wollen:

item->setCursor(Qt::IBeamCursor);

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

Siehe auch cursor(), hasCursor(), unsetCursor(), QWidget::cursor, und 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 ein beliebiges Element zu speichern. Qt verwendet diese Funktion nicht zum Speichern von Daten; sie dient ausschließlich der Bequemlichkeit des Benutzers.

Siehe auch data().

void QGraphicsItem::setEnabled(bool enabled)

Wenn enabled wahr ist, ist das Element aktiviert, andernfalls ist es deaktiviert.

Deaktivierte Elemente sind sichtbar, empfangen aber 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 auch unsichtbar oder akzeptiert keine Mausereignisse (siehe acceptedMouseButtons()). Ein deaktiviertes Element kann nicht zum Mausgrabber werden, und daher verliert ein Element den Grab, wenn es deaktiviert wird, wenn es mit der Maus gegrabbt wird, genauso wie es den Fokus verliert, wenn es den Fokus hatte, als es deaktiviert wurde.

Deaktivierte Elemente werden traditionell mit ausgegrauten Farben gezeichnet (siehe QPalette::Disabled).

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

Elemente sind standardmäßig aktiviert.

Siehe auch isEnabled().

void QGraphicsItem::setFiltersChildEvents(bool enabled)

Wenn enabled wahr ist, wird dieses Element so eingestellt, dass es alle Ereignisse für alle seine Kinder filtert (d. h. alle Ereignisse, die für eines seiner Kinder bestimmt sind, werden stattdessen an dieses Element gesendet); wenn enabled falsch ist, behandelt 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 Element-Flags auf flags. Alle Flags unter flags sind aktiviert; alle Flags, die nicht unter flags stehen, sind deaktiviert.

Wenn das Element den Fokus hatte und flags nicht ItemIsFocusable aktiviert, verliert das Element durch den Aufruf dieser Funktion den Fokus. Ähnlich verhält es sich, wenn das Element ausgewählt war und flags nicht ItemIsSelectable aktiviert, wird das Element automatisch abgewählt.

Standardmäßig sind keine Flaggen 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)

Gibt diesem Element den Fokus der Tastatureingabe. Das Argument focusReason wird an alle focus event übergeben, die von dieser Funktion erzeugt werden; es wird verwendet, um eine Erklärung dafür zu geben, warum das Element den Fokus erhält.

Nur aktivierte Elemente, die das ItemIsFocusable Flag setzen, können den Tastaturfokus annehmen.

Wenn dieses Element nicht sichtbar, nicht aktiv oder nicht mit einer Szene verbunden ist, erhält es keinen unmittelbaren 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 eine focus in event mit focusReason. Wenn ein anderes Element bereits den Fokus hat, erhält dieses Element zunächst eine focus out event, die anzeigt, dass es den Eingabefokus verloren hat.

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

void QGraphicsItem::setFocusProxy(QGraphicsItem *item)

Setzt den Fokus-Proxy des Elements auf item.

Wenn ein Element einen Fokus-Proxy hat, erhält der Fokus-Proxy den Eingabefokus, wenn das Element den Eingabefokus erhält. Das Element selbst hat weiterhin den Fokus (d. h. hasFocus() gibt true zurück), aber nur der Fokus-Proxy erhält die Tastatureingabe.

Ein Fokus-Proxy kann selbst einen Fokus-Proxy haben, usw. In diesem Fall wird die Tastatureingabe von dem äußersten Fokus-Proxy verarbeitet.

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

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

void QGraphicsItem::setGraphicsEffect(QGraphicsEffect *effect)

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

Wenn effect der installierte Effekt für ein anderes Element ist, entfernt setGraphicsEffect() den Effekt aus dem Element und installiert ihn für dieses Element.

QGraphicsItem übernimmt das Eigentum an effect.

Siehe auch graphicsEffect().

void QGraphicsItem::setGroup(QGraphicsItemGroup *group)

Fügt diesen Artikel der Artikelgruppe group hinzu. Wenn group gleich nullptr ist, wird dieses Element aus der aktuellen Gruppe entfernt und als Kind der übergeordneten Gruppe der vorherigen Gruppe hinzugefügt.

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

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

Setzt die aktuellen Eingabemethoden-Hinweise dieses Elements auf hints.

Siehe auch inputMethodHints() und inputMethodQuery().

void QGraphicsItem::setOpacity(qreal opacity)

Legt die lokale Deckkraft dieses Elements opacity zwischen 0,0 (transparent) und 1,0 (undurchsichtig) fest. Die lokale Deckkraft des Elements wird mit den Deckkraftwerten der Eltern und Vorfahren in effectiveOpacity() kombiniert.

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

Die Deckkraft-Eigenschaft entscheidet über den Zustand des Malers, der an die Funktion paint() übergeben wird. Wenn das Element im Cache gespeichert ist, d. h. ItemCoordinateCache oder DeviceCoordinateCache, wird die effektive Eigenschaft auf den Cache des Elements angewendet, wenn es gerendert wird.

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

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

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

Setzt die Modalität für dieses Element auf panelModality.

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

Siehe auch panelModality().

void QGraphicsItem::setParentItem(QGraphicsItem *newParent)

Setzt das übergeordnete Element dieses Eintrags auf newParent. Wenn dieser Eintrag bereits ein übergeordnetes Element hat, wird er zunächst vom vorherigen übergeordneten Element entfernt. Wenn newParent gleich 0 ist, wird dieses Element zu einem Element der obersten Ebene.

Beachten Sie, dass dieses Grafikelement damit implizit der Szene des übergeordneten Elements hinzugefügt wird. Sie sollten add das Element nicht selbst in die Szene einfügen.

Das Verhalten beim Aufruf dieser Funktion für ein Element, das ein Vorfahre von newParent ist, ist nicht definiert.

Siehe auch parentItem() und childItems().

void QGraphicsItem::setPos(const QPointF &pos)

Setzt die Position des Objekts auf pos, die in übergeordneten Koordinaten angegeben ist. Bei Elementen ohne übergeordnetes Element ist pos in Szenekoordinaten angegeben.

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

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

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

Dies ist eine überladene Funktion.

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

void QGraphicsItem::setRotation(qreal angle)

Legt die Drehung im Uhrzeigersinn angle in Grad um die Z-Achse fest. Der Standardwert ist 0 (d. h. das Element wird nicht gedreht). Wenn Sie einen negativen Wert zuweisen, wird das Element gegen den Uhrzeigersinn gedreht. Normalerweise liegt der Drehwinkel im Bereich (-360, 360), aber es ist auch möglich, Werte außerhalb dieses Bereichs zuzuweisen (z. B. ist eine Drehung von 370 Grad dasselbe wie eine Drehung von 10 Grad).

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

Die Drehung wird mit scale(), transform() und transformations() kombiniert, um das Koordinatensystem des Objekts auf das übergeordnete Objekt abzubilden.

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

void QGraphicsItem::setScale(qreal factor)

Legt die Skalierung factor des Elements fest. Der Standard-Skalierungsfaktor ist 1,0 (d. h. das Element wird nicht skaliert). Bei einem Skalierungsfaktor von 0,0 wird das Element auf einen einzigen Punkt reduziert. Wenn Sie einen negativen Skalierungsfaktor angeben, wird das Element gespiegelt (d. h. um 180 Grad gedreht).

Das Objekt wird um seinen Transformations-Ursprungspunkt skaliert, der standardmäßig (0, 0) ist. Sie können einen anderen Transformationsursprung wählen, indem Sie setTransformOriginPoint() aufrufen.

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

Siehe auch scale(), setTransformOriginPoint(), und Transformations Example.

void QGraphicsItem::setSelected(bool selected)

Wenn selected wahr ist und dieses Element auswählbar ist, ist dieses Element ausgewählt; andernfalls ist es nicht ausgewählt.

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

Nur sichtbare, aktivierte, auswählbare Elemente können ausgewählt werden. Wenn selected wahr ist und dieses Element entweder unsichtbar, deaktiviert oder nicht auswählbar ist, bewirkt diese Funktion nichts.

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

Diese Funktion dient der Bequemlichkeit, da sie es ermöglicht, den ausgewählten Status eines Eintrags individuell umzuschalten. Eine üblichere Methode zur Auswahl von Elementen ist jedoch der Aufruf von QGraphicsScene::setSelectionArea(), der diese Funktion für alle sichtbaren, aktivierten und auswählbaren Elemente innerhalb eines bestimmten Bereichs der Szene aufruft.

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

void QGraphicsItem::setToolTip(const QString &toolTip)

Setzt den Tooltip des Elements auf toolTip. Wenn toolTip leer ist, 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 Objekts auf matrix.

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

Um die Interaktion mit Elementen zu vereinfachen, die eine transformierte Ansicht verwenden, bietet QGraphicsItem die Funktionen mapTo... und mapFrom..., die zwischen den Koordinaten von Elementen und der Szene übersetzen können. Sie können zum Beispiel mapToScene() aufrufen, um eine Objektkoordinate auf eine Szenenkoordinate abzubilden, oder mapFromScene(), um von Szenenkoordinaten auf Objektkoordinaten abzubilden.

Die Transformationsmatrix wird mit rotation(), scale() und transformations() zu einer kombinierten Transformation kombiniert, die das Koordinatensystem des Objekts auf sein Elternteil abbildet.

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

void QGraphicsItem::setTransformOriginPoint(const QPointF &origin)

Setzt den origin Punkt für die Transformation in Positionskoordinaten.

Siehe auch transformOriginPoint() und Transformations.

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

Dies ist eine überladene Funktion.

Setzt den Ursprungspunkt für die Transformation in Positionskoordinaten. 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 Grafiken transformations (QGraphicsTransform) fest, die derzeit für diesen Artikel gelten.

Wenn Sie ein Element lediglich drehen oder skalieren wollen, sollten Sie stattdessen setRotation() oder setScale() aufrufen. Wenn Sie eine beliebige Transformation auf ein Element anwenden wollen, können Sie setTransform() aufrufen.

QGraphicsTransform dient dazu, eine Kette von einzelnen Transformationsoperationen auf ein Objekt anzuwenden und zu steuern. Dies ist besonders nützlich bei Animationen, bei denen jede Transformation unabhängig oder unterschiedlich interpoliert werden muss.

Die Transformationen werden mit 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 der Gegenstand unsichtbar gemacht. Unsichtbare Elemente werden nicht gezeichnet und erhalten auch keine Ereignisse. Insbesondere gehen Mausereignisse durch unsichtbare Elemente hindurch und werden an jedes Element weitergeleitet, das sich dahinter befinden könnte. Unsichtbare Objekte sind auch nicht auswählbar, sie können den Eingabefokus nicht annehmen und werden von den Objektortungsfunktionen von QGraphicsScene nicht erkannt.

Wenn ein Element unsichtbar wird, während es mit der Maus gegriffen wird (d. h. während es Mausereignisse empfängt), verliert es automatisch den Mausgriff, und der Griff wird nicht wiederhergestellt, indem das Element wieder sichtbar gemacht wird; es muss einen neuen Mausdruck erhalten, um den Mausgriff wiederzuerlangen.

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 alle seine Kinder ebenfalls 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 das übergeordnete Element ausgeblendet und dann wieder eingeblendet wird).

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

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

void QGraphicsItem::setX(qreal x)

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

Siehe auch x() und setPos().

void QGraphicsItem::setY(qreal y)

Setzt die y Koordinate der Position des Elements. 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 entscheidet über die Stapelreihenfolge von geschwisterlichen (benachbarten) Elementen. Ein geschwisterliches Element mit einem hohen Z-Wert wird immer über einem anderen geschwisterlichen Element mit einem niedrigeren Z-Wert gezeichnet.

Wenn Sie den Z-Wert wiederherstellen, entscheidet die Einfügereihenfolge des Elements über seine Stapelreihenfolge.

Der Z-Wert hat keinen Einfluss auf die Größe des Objekts.

Der Standardwert für den Z-Wert ist 0.

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

[virtual] QPainterPath QGraphicsItem::shape() const

Gibt die Form dieses Objekts als QPainterPath in lokalen Koordinaten zurück. Die Form wird für viele Dinge verwendet, einschließlich Kollisionserkennung, Treffertests 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 eine genauere Form für nicht-rechteckige Elemente zurückzugeben. Ein rundes Objekt kann zum Beispiel eine elliptische Form zurückgeben, um eine bessere Kollisionserkennung zu ermöglichen. Ein Beispiel:

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

Der Umriss einer Form kann abhängig von der Breite und dem Stil des beim Zeichnen verwendeten Stifts variieren. Wenn Sie diesen Umriss in die Form des Objekts 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 ist äquivalent zum Aufruf von setVisible(true).

Siehe auch hide() und setVisible().

void QGraphicsItem::stackBefore(const QGraphicsItem *sibling)

Stapelt dieses Element vor sibling, das ein geschwisterliches Element sein muss (d.h. die beiden Elemente müssen das gleiche übergeordnete Element haben oder beide müssen Toplevel-Elemente sein). sibling muss denselben Z-Wert haben wie dieses Element, andernfalls hat der Aufruf dieser Funktion keine Wirkung.

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

Siehe auch setZValue(), ItemStacksBehindParent, und Sorting.

QGraphicsObject *QGraphicsItem::toGraphicsObject()

Gibt das in QGraphicsObject umgewandelte Grafikelement zurück, wenn die Klasse tatsächlich ein Grafikobjekt ist, ansonsten 0.

const QGraphicsObject *QGraphicsItem::toGraphicsObject() const

Gibt das in QGraphicsObject umgewandelte Grafikelement zurück, wenn die Klasse tatsächlich ein Grafikobjekt ist, ansonsten 0.

QString QGraphicsItem::toolTip() const

Gibt den Tooltip des Elements zurück oder ein leeres QString, wenn kein Tooltip gesetzt wurde.

Siehe auch setToolTip() und QToolTip.

QGraphicsItem *QGraphicsItem::topLevelItem() const

Gibt das Element der obersten Ebene dieses Elements zurück. Das oberste Element ist das oberste Vorgängerelement des Elements, dessen übergeordnetes Element nullptr ist. Wenn ein Element kein übergeordnetes Element 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 Top-Level-Widget des Elements zurück (d.h. den Vorgänger des Elements, dessen Elternteil nullptr ist, oder dessen Elternteil kein Widget ist), oder nullptr, wenn dieses Element kein Top-Level-Widget hat. Wenn das Element sein eigenes Top-Level-Widget ist, gibt diese Funktion einen Zeiger auf das Element selbst zurück.

QTransform QGraphicsItem::transform() const

Gibt die Transformationsmatrix dieses Eintrags zurück.

Die Transformationsmatrix wird mit rotation(), scale() und transformations() des Eintrags zu einer kombinierten Transformation für den Eintrag kombiniert.

Die Standard-Transformationsmatrix ist eine Identitätsmatrix.

Siehe auch setTransform() und sceneTransform().

QPointF QGraphicsItem::transformOriginPoint() const

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

Die Vorgabe ist QPointF(0,0).

Siehe auch setTransformOriginPoint() und Transformations.

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

Gibt eine Liste der Grafiktransformationen zurück, die derzeit für dieses Element gelten.

QGraphicsTransform dient zur Anwendung und Steuerung einer Kette einzelner Transformationsvorgänge auf ein Element. Dies ist besonders nützlich bei Animationen, bei denen jede Transformation unabhängig oder unterschiedlich interpoliert werden muss.

Die Transformationen werden mit 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 Standard-Graphicitem-Klassen sind mit einem eindeutigen Wert verbunden; siehe QGraphicsItem::Type. Diese Typinformation wird von qgraphicsitem_cast() verwendet, um zwischen 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 als oder gleich UserType (65536) ist.

Ein Beispiel:

class CustomItem : 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()

Gibt den Tastaturgriff frei.

Siehe auch grabKeyboard() und ungrabMouse().

void QGraphicsItem::ungrabMouse()

Gibt den Mausgriff frei.

Siehe auch grabMouse() und ungrabKeyboard().

void QGraphicsItem::unsetCursor()

Löscht den Cursor von diesem Element.

Siehe auch hasCursor() und setCursor().

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

Plant ein erneutes Zeichnen des von rect abgedeckten Bereichs in diesem Artikel. Sie können diese Funktion immer dann aufrufen, wenn Ihr Element neu gezeichnet werden muss, z. B. wenn es sein Aussehen oder seine Größe ändert.

Diese Funktion bewirkt kein sofortiges Zeichnen; stattdessen plant sie eine Zeichenanforderung, die von QGraphicsView verarbeitet wird, nachdem die Kontrolle die Ereignisschleife erreicht hat. Das Element wird nur neu gezeichnet, wenn es in einer zugehörigen Ansicht sichtbar ist.

Als Nebeneffekt des neu gezeichneten Elements können andere Elemente, die den Bereich rect überlappen, ebenfalls neu gezeichnet werden.

Wenn das Element unsichtbar ist (d.h. isVisible() gibt false zurück), tut diese Funktion nichts.

Siehe auch paint() und boundingRect().

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

Dies ist eine überladene Funktion.

Diese Komfortfunktion ist gleichbedeutend mit 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 Event-Handler für das Ereignis event kann neu implementiert werden, um Rad-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 den Aufruf von QEvent::ignore()), wird es an jedes Element unterhalb dieses Elements weitergegeben. Wenn keine Elemente das Ereignis akzeptieren, wird es von der Szene ignoriert und an die Ansicht weitergegeben (z. B. an die vertikale Bildlaufleiste der Ansicht).

Die Standardimplementierung ignoriert das Ereignis.

Siehe auch sceneEvent().

QGraphicsWidget *QGraphicsItem::window() const

Gibt das Fenster des Objekts zurück, oder nullptr, wenn das Objekt kein Fenster hat. Wenn das Element ein Fenster ist, wird es sich selbst zurückgeben. Andernfalls wird der nächstliegende Vorgänger 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 wirkt sich auf die Stapelreihenfolge von benachbarten Elementen aus.

Der Standard-Z-Wert ist 0.

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