QGraphicsWidget Class

Dokumentation zu Mitgliedsfunktionen

QGraphicsWidget::QGraphicsWidget(QGraphicsItem *parent = nullptr, Qt::WindowFlags wFlags = Qt::WindowFlags())

Erstellt eine Instanz von `QGraphicsWidget`. Das optionale Argument ` parent ` wird an den Konstruktor von ` QGraphicsItem` übergeben. Das optionale Argument ` wFlags ` legt die Fensterflags des Widgets fest (z. B. ob das Widget ein Fenster, ein Werkzeug, ein Popup usw. sein soll).

[virtual noexcept] QGraphicsWidget::~QGraphicsWidget()

Löscht die Instanz „ QGraphicsWidget “.

QList<QAction *> QGraphicsWidget::actions() const

Gibt die (möglicherweise leere) Liste der Aktionen dieses Widgets zurück.

Siehe auch insertAction(), removeAction(), QWidget::actions(), QAction::associatedWidgets() und QAction::associatedGraphicsWidgets().

void QGraphicsWidget::addAction(QAction *action)

Fügt die Aktion „ action “ zur Aktionsliste dieses Widgets hinzu.

Alle QGraphicsWidgets verfügen über eine Liste von „ QAction“, die jedoch grafisch auf viele verschiedene Arten dargestellt werden können. Die Standardverwendung der Liste „ QAction “ (wie sie von „ actions()“ zurückgegeben wird) dient dazu, ein Kontext-„ QMenu “ zu erstellen.

Ein „ QGraphicsWidget “ sollte von jeder Aktion nur einmal vorhanden sein; das Hinzufügen einer bereits vorhandenen Aktion führt nicht dazu, dass dieselbe Aktion zweimal im Widget erscheint.

Siehe auch removeAction(), insertAction(), actions() und QWidget::addAction().

void QGraphicsWidget::addActions(const QList<QAction *> &actions)

Fügt die Aktionen „ actions “ zur Aktionsliste dieses Widgets hinzu.

Siehe auch „ removeAction()“, „ QMenu “, „ addAction()“ und „ QWidget::addActions()“.

void QGraphicsWidget::adjustSize()

Passen Sie die Größe des Widgets an dessen effektiven Größenhinweis an.

Diese Funktion wird implizit aufgerufen, wenn das Element zum ersten Mal angezeigt wird.

Siehe auch effectiveSizeHint() und Qt::MinimumSize.

[override virtual] QRectF QGraphicsWidget::boundingRect() const

Implementiert: ` QGraphicsItem::boundingRect()` const.

[virtual protected] void QGraphicsWidget::changeEvent(QEvent *event)

Dieser Ereignis-Handler kann neu implementiert werden, um Zustandsänderungen zu verarbeiten.

Der bei diesem Ereignis geänderte Zustand kann über „ event “ abgerufen werden.

Zu den Änderungsereignissen gehören: „ QEvent::ActivationChange “, „ QEvent::EnabledChange “, „ QEvent::FontChange “, „ QEvent::StyleChange “, „ QEvent::PaletteChange “, „ QEvent::ParentChange “, „ QEvent::LayoutDirectionChange “ und „ QEvent::ContentsRectChange “.

[slot] bool QGraphicsWidget::close()

Rufen Sie diese Funktion auf, um das Widget zu schließen.

Gibt „ true “ zurück, wenn das Widget geschlossen wurde; andernfalls gibt es „ false “ zurück. Dieser Slot sendet zunächst ein „ QCloseEvent “ an das Widget, das das Ereignis annehmen kann oder auch nicht. Wurde das Ereignis ignoriert, geschieht nichts. Wurde das Ereignis angenommen, wird das Widget mit „ hide()“ geschlossen.

Wenn für das Widget das Attribut „ Qt::WA_DeleteOnClose “ gesetzt ist, wird es gelöscht.

[virtual protected] void QGraphicsWidget::closeEvent(QCloseEvent *event)

Dieser Ereignis-Handler für ` event` kann in einer Unterklasse neu implementiert werden, um Ereignisse zum Schließen des Widgets zu empfangen. Die Standardimplementierung akzeptiert das Ereignis.

Siehe auch ` close()` und ` QCloseEvent`.

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

Umsetzt: ` QGraphicsObject::event(QEvent *ev)`.

Behandelt das ` event`. ` QGraphicsWidget ` behandelt die folgenden Ereignisse:

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

Umsetzt: ` QGraphicsItem::focusInEvent(QFocusEvent *event)`.

[virtual protected] bool QGraphicsWidget::focusNextPrevChild(bool next)

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

Manchmal möchten Sie diese Funktion neu implementieren, um eine spezielle Fokusbehandlung für Ihr Widget und dessen untergeordnete Widgets bereitzustellen. Ein Webbrowser könnte sie beispielsweise neu implementieren, um den aktuell aktiven Link vorwärts oder rückwärts zu verschieben, und die Basisimplementierung nur aufrufen, wenn er den letzten oder ersten Link auf der Seite erreicht.

Untergeordnete Widgets rufen `focusNextPrevChild()` bei ihren übergeordneten Widgets auf, aber nur das Fenster, das die untergeordneten Widgets enthält, entscheidet, wohin der Fokus umgeleitet wird. Durch die Neuimplementierung dieser Funktion für ein Objekt erhalten Sie die Kontrolle über die Fokusnavigation für alle untergeordneten Widgets.

Siehe auch ` focusPolicy()`.

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

Umsetzt: ` QGraphicsItem::focusOutEvent(QFocusEvent *event)`.

QGraphicsWidget *QGraphicsWidget::focusWidget() const

Wenn dieses Widget, ein untergeordnetes Widget oder ein Nachkomme dieses Widgets derzeit den Eingabefokus hat, gibt diese Funktion einen Zeiger auf dieses Widget zurück. Wenn kein Nachkomme-Widget den Eingabefokus hat, wird ` nullptr ` zurückgegeben.

Siehe auch „ QGraphicsItem::focusItem()“ und „ QWidget::focusWidget()“.

[signal] void QGraphicsWidget::geometryChanged()

Dieses Signal wird immer dann ausgelöst, wenn die Geometrie in setGeometry() geändert wird.

[override virtual] void QGraphicsWidget::getContentsMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const

Implementiert: ` QGraphicsLayoutItem::getContentsMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const`.

Ruft die Ränder des Widget-Inhalts ab. Die Ränder werden in ` left`, ` top`, ` right ` und ` bottom` als Zeiger auf `qreals` gespeichert. Jedes Argument kann weggelassen werden, indem ` nullptr` übergeben wird.

Siehe auch setContentsMargins().

void QGraphicsWidget::getWindowFrameMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const

Ruft die Ränder des Fensterrahmens des Widgets ab. Die Ränder werden in „ left “, „ top “, „ right “ und „ bottom “ als Zeiger auf „qreals“ gespeichert. Jedes Argument kann weggelassen werden, indem „ nullptr “ übergeben wird.

Siehe auch setWindowFrameMargins() und windowFrameRect().

[virtual protected] void QGraphicsWidget::grabKeyboardEvent(QEvent *event)

Dieser Ereignis-Handler für „ event “ kann in einer Unterklasse neu implementiert werden, um Benachrichtigungen für „ QEvent::GrabKeyboard “-Ereignisse zu empfangen.

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

[virtual protected] void QGraphicsWidget::grabMouseEvent(QEvent *event)

Dieser Ereignis-Handler für „ event “ kann in einer Unterklasse neu implementiert werden, um Benachrichtigungen zu „ QEvent::GrabMouse “-Ereignissen zu empfangen.

Siehe auch grabMouse() und grabKeyboard().

int QGraphicsWidget::grabShortcut(const QKeySequence &sequence, Qt::ShortcutContext context = Qt::WindowShortcut)

Fügt dem Tastenkürzelsystem von Qt ein Tastenkürzel hinzu, das im angegebenen context auf die angegebene Tasten sequence achtet. Wenn der context Qt::ApplicationShortcut lautet, gilt das Tastenkürzel für die gesamte Anwendung. Andernfalls gilt er entweder lokal für dieses Widget ( Qt::WidgetShortcut) oder für das Fenster selbst ( Qt::WindowShortcut). Bei Widgets, die nicht Teil eines Fensters sind (d. h. Widgets der obersten Ebene und deren untergeordnete Elemente), gelten Tastenkombinationen ( Qt::WindowShortcut ) für die Szene.

Wenn dieselbe Tasten sequence von mehreren Widgets beansprucht wurde, wird beim Auftreten der Tasten sequence ein QEvent::Shortcut -Ereignis an alle betroffenen Widgets gesendet – in nicht deterministischer Reihenfolge, jedoch mit dem auf „true“ gesetzten „ambiguous“-Flag.

Siehe auch releaseShortcut(), setShortcutEnabled() und QWidget::grabShortcut().

[virtual protected] void QGraphicsWidget::hideEvent(QHideEvent *event)

Dieser Ereignishandler für „ Hide “-Ereignisse wird ausgelöst, nachdem das Widget ausgeblendet wurde, beispielsweise wenn „setVisible(false)“ für das Widget oder einen seiner Vorfahren aufgerufen wurde, während das Widget zuvor angezeigt war.

Sie können diesen Ereignis-Handler neu implementieren, um zu erkennen, wann Ihr Widget ausgeblendet wird. Der Aufruf von ` QEvent::accept()` oder ` QEvent::ignore()` auf ` event ` hat keine Auswirkung.

Siehe auch „ showEvent()“, „ QWidget::hideEvent()“ und „ ItemVisibleChange “.

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

Implementiert: ` QGraphicsItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)`.

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

Implementiert: ` QGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)`.

[virtual protected] void QGraphicsWidget::initStyleOption(QStyleOption *option) const

Füllt ein Stiloptionsobjekt für dieses Widget basierend auf dessen aktuellem Zustand und speichert die Ausgabe in „ option “. Die Standardimplementierung füllt „ option “ mit den folgenden Eigenschaften.

Unterklassen von ` QGraphicsWidget ` sollten die Basisimplementierung aufrufen und anschließend den Typ von ` option ` mithilfe von ` qstyleoption_cast<>()` prüfen oder ` QStyleOption::Type ` testen, bevor sie widgetspezifische Optionen speichern.

Beispiel:

void MyGroupBoxWidget::initStyleOption(QStyleOption *option) const
{
    QGraphicsWidget::initStyleOption(option);
    if (QStyleOptionGroupBox *box = qstyleoption_cast<QStyleOptionGroupBox *>(option)) {
        // Add group box specific state.
        box->text = tr("My Group Box");
        //...
    }
}

Siehe auch ` QStyleOption::initFrom()`.

void QGraphicsWidget::insertAction(QAction *before, QAction *action)

Fügt die Aktion „ action “ in die Aktionsliste dieses Widgets ein, und zwar vor der Aktion „ before “. Die Aktion wird angehängt, wenn „ before “ den Wert „ nullptr “ hat oder „ before “ keine gültige Aktion für dieses Widget ist.

Ein „ QGraphicsWidget “ sollte jeweils nur eine Instanz jeder Aktion enthalten.

Siehe auch „ removeAction()“, „ addAction()“, „ QMenu “, „ actions()“ und „ QWidget::insertActions()“.

void QGraphicsWidget::insertActions(QAction *before, const QList<QAction *> &actions)

Fügt die Aktion „ actions “ in die Aktionsliste dieses Widgets ein, und zwar vor der Aktion „ before “. Die Aktion wird angehängt, wenn „ before “ den Wert „ nullptr “ hat oder „ before “ keine gültige Aktion für dieses Widget ist.

Ein „ QGraphicsWidget “ kann von jeder Aktion höchstens eine enthalten.

Siehe auch „ removeAction()“, „ QMenu “, „ insertAction()“ und „ QWidget::insertActions()“.

bool QGraphicsWidget::isActiveWindow() const

Gibt „ true “ zurück, wenn sich das Fenster dieses Widgets im aktiven Fenster befindet oder wenn das Widget zwar kein Fenster hat, sich aber in einer aktiven Szene befindet (d. h. einer Szene, die derzeit den Fokus hat).

Das aktive Fenster ist das Fenster, das entweder ein untergeordnetes Widget enthält, das derzeit den Eingabefokus hat, oder das selbst den Eingabefokus hat.

Siehe auch „ QGraphicsScene::activeWindow()“, „ QGraphicsScene::setActiveWindow()“ und „ isActive()“.

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

Umsetzt: QGraphicsItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value).

QGraphicsWidget Verwendet die Basisimplementierung dieser Funktion, um Ereignisse im Zusammenhang mit Zustandsänderungen des Elements abzufangen und weiterzuleiten. Aus diesem Grund ist es sehr wichtig, dass Unterklassen die Basisimplementierung aufrufen.

change gibt die Art der Änderung an, und ` value ` ist der neue Wert.

Beispielsweise verwendet ` QGraphicsWidget ` `ItemVisibleChange`, um die Ereignisse ` Show ` und ` Hide ` zu übermitteln, `ItemPositionHasChanged`, um ` Move `-Ereignisse zu übermitteln, und `ItemParentChange` sowohl zur Übermittlung von ` ParentChange `-Ereignissen als auch zur Verwaltung der Fokus-Kette.

QGraphicsWidget Aktiviert standardmäßig das Flag „ItemSendsGeometryChanges“, um Positionsänderungen zu verfolgen.

Siehe auch „ QGraphicsItem::itemChange()“.

QGraphicsLayout *QGraphicsWidget::layout() const

Gibt das Layout dieses Widgets zurück oder „ nullptr “, falls dieses Widget derzeit von keinem Layout verwaltet wird.

Siehe auch „ setLayout()“.

[virtual protected] void QGraphicsWidget::moveEvent(QGraphicsSceneMoveEvent *event)

Dieser Ereignis-Handler für „ GraphicsSceneMove “-Ereignisse wird ausgelöst, nachdem das Widget verschoben wurde (d. h., seine lokale Position hat sich geändert).

Dieses Ereignis wird nur ausgelöst, wenn das Element lokal verschoben wird. Der Aufruf von ` setTransform()` oder das Verschieben eines der übergeordneten Elemente hat keinen Einfluss auf die lokale Position des Elements.

Sie können diesen Ereignis-Handler neu implementieren, um zu erkennen, wann sich Ihr Widget bewegt hat. Der Aufruf von ` QEvent::accept()` oder ` QEvent::ignore()` auf ` event ` hat keine Auswirkung.

Siehe auch „ ItemPositionChange “ und „ ItemPositionHasChanged “.

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

Implementiert: ` QGraphicsItem::paint` (`QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget`).

[virtual] void QGraphicsWidget::paintWindowFrame(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr)

Diese virtuelle Funktion wird von ` QGraphicsScene ` aufgerufen, um den Fensterrahmen für Fenster, die ` painter`, ` option` und ` widget` verwenden, in lokalen Koordinaten zu zeichnen. Die Basisimplementierung verwendet den aktuellen Stil, um den Rahmen und die Titelleiste darzustellen.

Sie können diese Funktion in einer Unterklasse von ` QGraphicsWidget ` neu implementieren, um eine benutzerdefinierte Darstellung des Fensterrahmens des Widgets bereitzustellen.

Siehe auch ` QGraphicsItem::paint()`.

[virtual protected] void QGraphicsWidget::polishEvent()

Dieses Ereignis wird dem Element von der Szene zu einem Zeitpunkt übermittelt, der nach dessen Erstellung, aber vor dessen Anzeige oder anderweitigem Zugriff durch die Szene liegt. Sie können diesen Ereignis-Handler nutzen, um in letzter Minute Initialisierungen des Widgets durchzuführen, für die das Element vollständig erstellt sein muss.

Die Basisimplementierung führt keine Aktion aus.

QRectF QGraphicsWidget::rect() const

Gibt das lokale Rechteck des Elements als ` QRectF` zurück. Diese Funktion entspricht ` QRectF` (QPointF(), ` size()`).

Siehe auch setGeometry() und resize().

void QGraphicsWidget::releaseShortcut(int id)

Entfernt die Tastenkombination mit dem angegebenen „ id “ aus dem Tastenkombinationensystem von Qt. Das Widget erhält keine „ QEvent::Shortcut “-Ereignisse mehr für die Tastenfolge der Tastenkombination (es sei denn, es gibt andere Tastenkombinationen mit derselben Tastenfolge).

Siehe auch grabShortcut(), setShortcutEnabled() und QWidget::releaseShortcut().

void QGraphicsWidget::removeAction(QAction *action)

Entfernt die Aktion „ action “ aus der Aktionsliste dieses Widgets.

Siehe auch „ insertAction()“, „ actions()“ und „ QWidget::removeAction()“.

void QGraphicsWidget::resize(qreal w, qreal h)

Erstellt eine „resize“-Instanz mit den angegebenen Werten für „ width “ (w) und „ height “ (h). Diese Komfortfunktion entspricht dem Aufruf von „resize(QSizeF(w, h))“.

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

[virtual protected] void QGraphicsWidget::resizeEvent(QGraphicsSceneResizeEvent *event)

Dieser Ereignishandler für „ GraphicsSceneResize “-Ereignisse wird ausgelöst, nachdem die Größe des Widgets geändert wurde (d. h., seine lokale Größe hat sich geändert). „ event “ enthält sowohl die alte als auch die neue Größe.

Dieses Ereignis wird nur ausgelöst, wenn die Größe des Widgets lokal geändert wird; der Aufruf von ` setTransform()` für das Widget selbst, eines seiner übergeordneten Elemente oder der Ansicht hat keinen Einfluss auf die lokale Größe des Widgets.

Sie können diesen Ereignis-Handler neu implementieren, um zu erkennen, wann die Größe Ihres Widgets geändert wurde. Der Aufruf von ` QEvent::accept()` oder ` QEvent::ignore()` für ` event ` hat keine Auswirkung.

Siehe auch „ geometry()“ und „ setGeometry()“.

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

Umsetzt: ` QGraphicsItem::sceneEvent` (`QEvent *event`).

QGraphicsWidgetDie Implementierung von `sceneEvent()` übergibt ` event ` einfach an ` QGraphicsWidget::event()`. Sie können alle Ereignisse für Ihr Widget in ` event()` oder in einer der Hilfsfunktionen behandeln; Sie sollten diese Funktion in einer Unterklasse von ` QGraphicsWidget` nicht neu implementieren müssen.

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

Siehe auch ` QGraphicsItem::sceneEvent()`.

void QGraphicsWidget::setAttribute(Qt::WidgetAttribute attribute, bool on = true)

Wenn „ on “ wahr ist, aktiviert diese Funktion „ attribute “; andernfalls ist „ attribute “ deaktiviert.

Eine vollständige Liste der unterstützten Attribute und deren Funktionen finden Sie in der Klassendokumentation zu „ QGraphicsWidget “.

Siehe auch „ testAttribute()“ und „ QWidget::setAttribute()“.

void QGraphicsWidget::setContentsMargins(QMarginsF margins)

Legt die Inhaltsränder des Widgets auf „ margins “ fest.

Inhaltsränder werden vom zugewiesenen Layout verwendet, um die Platzierung von Unterwidgets und Layouts zu definieren. Ränder sind besonders nützlich für Widgets, die Unterwidgets auf einen bestimmten Bereich ihrer eigenen Geometrie beschränken. Beispielsweise platziert ein Gruppenfeld mit einem Layout Unterwidgets innerhalb seines Rahmens, jedoch unterhalb des Titels.

Das Ändern der Inhaltsränder eines Widgets löst immer einen Aufruf von ` update()` aus, und jedes zugewiesene Layout wird automatisch aktiviert. Das Widget erhält daraufhin ein ` ContentsRectChange `-Ereignis.

Siehe auch getContentsMargins() und setGeometry().

void QGraphicsWidget::setContentsMargins(qreal left, qreal top, qreal right, qreal bottom)

Setzt die Ränder des Widget-Inhalts auf left, top, right und bottom.

void QGraphicsWidget::setGeometry(qreal x, qreal y, qreal w, qreal h)

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

Siehe auch „ geometry()“ und „ resize()“.

void QGraphicsWidget::setLayout(QGraphicsLayout *layout)

Legt das Layout für dieses Widget auf „ layout “ fest. Ein eventuell vorhandener Layout-Manager wird gelöscht, bevor das neue Layout zugewiesen wird. Wenn „ layout “ auf „ nullptr “ gesetzt ist, bleibt das Widget ohne Layout. Die Geometrien vorhandener Unter-Widgets bleiben davon unberührt.

Alle Widgets, die derzeit von ` layout ` oder einem seiner Unterlayouts verwaltet werden, werden automatisch diesem Element untergeordnet. Das Layout wird anschließend ungültig gemacht, und die Geometrien der untergeordneten Widgets werden entsprechend den Eigenschaften ` geometry()` und `contentsMargins()` dieses Elements angepasst. Untergeordnete Elemente, die nicht explizit von ` layout ` verwaltet werden, bleiben von dem Layout unberührt, nachdem es diesem Widget zugewiesen wurde.

QGraphicsWidget Übernimmt die Eigentumsrechte an „ layout “.

Siehe auch „ layout()“, „ QGraphicsLinearLayout::addItem()“ und „ QGraphicsLayout::invalidate()“.

void QGraphicsWidget::setShortcutAutoRepeat(int id, bool enabled = true)

Wenn „ enabled “ wahr ist, ist die automatische Wiederholung des Tastenkürzels mit dem angegebenen „ id “ aktiviert; andernfalls ist sie deaktiviert.

Siehe auch „ grabShortcut()“, „ releaseShortcut()“ und „ QWidget::setShortcutAutoRepeat()“.

void QGraphicsWidget::setShortcutEnabled(int id, bool enabled = true)

Wenn „ enabled “ wahr ist, ist die Tastenkombination mit der angegebenen „ id “ aktiviert; andernfalls ist die Tastenkombination deaktiviert.

Siehe auch grabShortcut(), releaseShortcut() und QWidget::setShortcutEnabled().

void QGraphicsWidget::setStyle(QStyle *style)

Legt den Stil des Widgets auf „ style “ fest. „ QGraphicsWidget “ übernimmt nicht die Eigentümerschaft an „ style “.

Wenn kein Stil zugewiesen ist oder „ style “ gleich „ nullptr “ ist, verwendet das Widget „ QGraphicsScene::style()“ (sofern dies festgelegt wurde). Andernfalls verwendet das Widget „ QApplication::style()“.

Diese Funktion setzt das Attribut „ Qt::WA_SetStyle “, sofern „ style “ nicht „ nullptr “ ist; andernfalls wird das Attribut gelöscht.

Siehe auch „ style()“.

[static] void QGraphicsWidget::setTabOrder(QGraphicsWidget *first, QGraphicsWidget *second)

Verschiebt das Widget „ second “ innerhalb des Fokus-Widget-Rings so, dass der Tastaturfokus beim Drücken der Tabulatortaste vom Widget „ first “ zum Widget „ second “ wechselt.

Beachten Sie, dass sich die Tab-Reihenfolge des „ second “-Widgets geändert hat und Sie eine Kette daher wie folgt anordnen sollten:

setTabOrder(a, b); // a to b
setTabOrder(b, c); // a to b to c
setTabOrder(c, d); // a to b to c to d

nicht so:

// WRONG
setTabOrder(c, d); // c to d
setTabOrder(a, b); // a to b AND c to d
setTabOrder(b, c); // a to b to c, but not c to d

Wenn „ first “ auf „ nullptr “ gesetzt ist, bedeutet dies, dass „ second “ das erste Widget sein sollte, das den Eingabefokus erhält, sobald die Szene den Tab-Fokus erhält (d. h., der Benutzer drückt die Tabulatortaste, sodass der Fokus in die Szene wechselt). Wenn „ second “ auf „ nullptr “ gesetzt ist, bedeutet dies, dass „ first “ das erste Widget sein sollte, das den Fokus erhält, wenn die Szene den BackTab-Fokus erhält.

Standardmäßig wird die Tabulatorreihenfolge implizit anhand der Reihenfolge der Widget-Erstellung definiert.

Siehe auch „ focusPolicy “ und „Keyboard Focus in Widgets“.

void QGraphicsWidget::setWindowFrameMargins(QMarginsF margins)

Legt die Rahmenränder des Widgets auf „ margins “ fest. Die Standard-Rahmenränder werden durch den Stil vorgegeben und hängen von den aktuellen Fensterflags ab.

Wenn Sie Ihre eigene Fensterdekoration zeichnen möchten, können Sie eigene Rahmenränder festlegen, um die Standardränder zu überschreiben.

Siehe auch „ unsetWindowFrameMargins()“, „ getWindowFrameMargins()“ und „ windowFrameRect()“.

void QGraphicsWidget::setWindowFrameMargins(qreal left, qreal top, qreal right, qreal bottom)

Setzt die Ränder des Widget-Fensters auf „ left “, „ top “, „ right “ und „ bottom “.

[override virtual] QPainterPath QGraphicsWidget::shape() const

Implementiert erneut: ` QGraphicsItem::shape()` const.

[virtual protected] void QGraphicsWidget::showEvent(QShowEvent *event)

Dieser Ereignis-Handler für „ Show “-Ereignisse wird ausgelöst, bevor das Widget angezeigt wird, beispielsweise wenn „setVisible(true)“ für das Widget oder einen seiner Vorfahren aufgerufen wurde, nachdem das Widget zuvor ausgeblendet war.

Sie können diesen Ereignis-Handler neu implementieren, um zu erkennen, wann Ihr Widget angezeigt wird. Der Aufruf von ` QEvent::accept()` oder ` QEvent::ignore()` auf ` event ` hat keine Auswirkung.

Siehe auch ` hideEvent()`, ` QWidget::showEvent()` und ` ItemVisibleChange`.

[override virtual protected] QSizeF QGraphicsWidget::sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const

Implementiert neu: ` QGraphicsLayoutItem::sizeHint` (`Qt::SizeHint which, const QSizeF &constraint) const`.

QStyle *QGraphicsWidget::style() const

Gibt einen Zeiger auf den Stil des Widgets zurück. Verfügt dieses Widget über keinen explizit zugewiesenen Stil, wird stattdessen der Stil der Szene zurückgegeben. Verfügt die Szene wiederum über keinen zugewiesenen Stil, gibt diese Funktion „ QApplication::style()“ zurück.

Siehe auch ` setStyle()`.

bool QGraphicsWidget::testAttribute(Qt::WidgetAttribute attribute) const

Gibt „ true “ zurück, wenn „ attribute “ für dieses Widget aktiviert ist; andernfalls wird „ false “ zurückgegeben.

Siehe auch setAttribute().

[override virtual] int QGraphicsWidget::type() const

Implementiert: ` QGraphicsItem::type()` const.

[virtual protected] void QGraphicsWidget::ungrabKeyboardEvent(QEvent *event)

Dieser Ereignis-Handler für „ event “ kann in einer Unterklasse neu implementiert werden, um Benachrichtigungen zu „ QEvent::UngrabKeyboard “-Ereignissen zu empfangen.

Siehe auch ungrabKeyboard() und ungrabMouse().

[virtual protected] void QGraphicsWidget::ungrabMouseEvent(QEvent *event)

Dieser Ereignis-Handler für „ event “ kann in einer Unterklasse neu implementiert werden, um Benachrichtigungen zu „ QEvent::UngrabMouse “-Ereignissen zu empfangen.

Siehe auch ungrabMouse() und ungrabKeyboard().

void QGraphicsWidget::unsetWindowFrameMargins()

Setzt die Ränder des Fensterrahmens auf den Standardwert zurück, der durch den Stil vorgegeben ist.

Siehe auch setWindowFrameMargins(), getWindowFrameMargins() und windowFrameRect().

[override virtual protected] void QGraphicsWidget::updateGeometry()

Implementiert: QGraphicsLayoutItem::updateGeometry().

Wenn dieses Widget derzeit von einem Layout verwaltet wird, benachrichtigt diese Funktion das Layout darüber, dass sich die Größenangaben des Widgets geändert haben, und das Layout muss die Größe und Position des Widgets möglicherweise entsprechend anpassen.

Rufen Sie diese Funktion auf, wenn sich die Größe des Widgets ( sizeHint()) geändert hat.

Siehe auch QGraphicsLayout::invalidate().

[virtual protected] bool QGraphicsWidget::windowFrameEvent(QEvent *event)

Dieser Ereignis-Handler für ` event` empfängt Ereignisse für den Fensterrahmen, sofern dieses Widget ein Fenster ist. Seine Basisimplementierung bietet Unterstützung für die Standardinteraktion mit dem Fensterrahmen, wie z. B. Verschieben, Größenänderung usw.

Sie können diesen Handler in einer Unterklasse von ` QGraphicsWidget ` neu implementieren, um eigene, benutzerdefinierte Funktionen für die Interaktion mit dem Fensterrahmen bereitzustellen.

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

Siehe auch ` event()`.

QRectF QGraphicsWidget::windowFrameGeometry() const

Gibt die Geometrie des Widgets in den Koordinaten des übergeordneten Elements zurück, einschließlich eines etwaigen Fensterrahmens.

Siehe auch „ windowFrameRect()“, „ getWindowFrameMargins()“ und „ setWindowFrameMargins()“.

QRectF QGraphicsWidget::windowFrameRect() const

Gibt das lokale Rechteck des Widgets einschließlich des eventuellen Fensterrahmens zurück.

Siehe auch „ windowFrameGeometry()“, „ getWindowFrameMargins()“ und „ setWindowFrameMargins()“.

[virtual protected] Qt::WindowFrameSection QGraphicsWidget::windowFrameSectionAt(const QPointF &pos) const

Gibt den Fensterrahmenabschnitt an der Position pos zurück oder Qt::NoSection, falls an dieser Position kein Fensterrahmenabschnitt vorhanden ist.

Diese Funktion wird in der Basisimplementierung von „ QGraphicsWidget “ für die Interaktion mit dem Fensterrahmen verwendet.

Sie können diese Funktion neu implementieren, wenn Sie die Art und Weise anpassen möchten, wie ein Fenster interaktiv verschoben oder in der Größe verändert werden kann. Wenn Sie beispielsweise zulassen möchten, dass ein Fenster nur über die rechte untere Ecke in der Größe verändert werden kann, können Sie diese Funktion so neu implementieren, dass sie für alle Abschnitte außer Qt::BottomRightSection den Wert „ Qt::NoSection “ zurückgibt.

Siehe auch ` windowFrameEvent()`, ` paintWindowFrame()` und ` windowFrameGeometry()`.

Qt::WindowType QGraphicsWidget::windowType() const

Gibt den Fenstertyp des Widgets zurück.

Siehe auch „ windowFlags()“, „ isWindow()“ und „ isPanel()“.