QWidget Class

Dokumentation zu den Mitgliedsfunktionen

[explicit] QWidget::QWidget(QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags())

Erstellt ein Widget, das ein untergeordnetes Element von ` parent` ist, wobei die Widget-Flags auf ` f` gesetzt sind.

Ist parent gleich nullptr, wird das neue Widget zu einem Fenster. Ist parent ein anderes Widget, wird dieses Widget zu einem untergeordneten Fenster innerhalb von parent. Das neue Widget wird gelöscht, wenn sein parent gelöscht wird.

Das Argument „widget flags“ ( f) ist normalerweise 0, kann jedoch gesetzt werden, um den Rahmen eines Fensters anzupassen (d. h., parent muss nullptr sein). Um den Rahmen anzupassen, verwenden Sie einen Wert, der sich aus der bitweisen ODER-Verknüpfung beliebiger der window flags zusammensetzt.

Wenn Sie einem bereits sichtbaren Widget ein untergeordnetes Widget hinzufügen, müssen Sie das untergeordnete Widget explizit anzeigen, damit es sichtbar wird.

Beachten Sie, dass die X11-Version von Qt möglicherweise nicht alle Kombinationen von Stilflags auf allen Systemen bereitstellen kann. Dies liegt daran, dass Qt unter X11 nur den Fenstermanager befragen kann und der Fenstermanager die Einstellungen der Anwendung überschreiben kann. Unter Windows kann Qt beliebige Flags setzen.

Siehe auch windowFlags.

[virtual noexcept] QWidget::~QWidget()

Löscht das Widget.

Zuvor werden alle untergeordneten Elemente dieses Widgets gelöscht. Die Anwendung wird beendet, wenn dieses Widget das Haupt-Widget ist.

[virtual protected] void QWidget::actionEvent(QActionEvent *event)

Dieser Ereignis-Handler wird mit dem angegebenen „ event “ aufgerufen, sobald sich die Aktionen des Widgets ändern.

Siehe auch addAction(), insertAction(), removeAction(), actions() und QActionEvent.

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

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

Siehe auch „ contextMenuPolicy“ , „ insertAction()“ und „ removeAction()“.

void QWidget::activateWindow()

Legt das übergeordnete Widget, das dieses Widget enthält, als aktives Fenster fest.

Ein aktives Fenster ist ein sichtbares Fenster der obersten Ebene, das den Tastatureingabefokus besitzt.

Diese Funktion führt denselben Vorgang aus wie ein Mausklick auf die Titelleiste eines Top-Level-Fensters. Unter X11 hängt das Ergebnis vom Window-Manager ab. Wenn Sie sicherstellen möchten, dass das Fenster zusätzlich ganz oben gestapelt wird, sollten Sie zusätzlich ` raise()` aufrufen. Beachten Sie, dass das Fenster sichtbar sein muss, andernfalls hat `activateWindow()` keine Wirkung.

Unter Windows wird das Fenster nicht zum aktiven Fenster, wenn Sie diese Funktion aufrufen, während die Anwendung gerade nicht aktiv ist. Stattdessen wird die Farbe des Eintrags in der Taskleiste geändert, um anzuzeigen, dass sich am Fenster etwas geändert hat. Dies liegt daran, dass Microsoft es nicht zulässt, dass eine Anwendung die aktuelle Tätigkeit des Benutzers in einer anderen Anwendung unterbricht.

Siehe auch isActiveWindow(), window() und show().

void QWidget::addAction(QAction *action)

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

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

Ein „ QWidget “ sollte von jeder Aktion nur jeweils eine Instanz besitzen; das Hinzufügen einer bereits vorhandenen Aktion führt nicht dazu, dass dieselbe Aktion zweimal im Widget vorhanden ist.

Die Eigentumsrechte an action werden nicht auf dieses QWidget übertragen.

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

Diese Hilfsfunktionen erstellen eine neue Aktion mit dem Text „ text “, dem Symbol „ icon “ und gegebenenfalls der Tastenkombination „ shortcut “.

Die Funktionen fügen die neu erstellte Aktion zur Aktionsliste des Widgets hinzu und geben sie zurück.

QWidget übernimmt die Verantwortung für das zurückgegebene ` QAction`.

Diese Funktionen wurden in Qt 6.3 eingeführt.

Diese Hilfsfunktionen erstellen eine neue Aktion mit dem Text „ text “, dem Symbol „ icon “ und gegebenenfalls der Tastenkombination „ shortcut “.

Das Signal „ triggered()“ der Aktion wird so angeschlossen, als würde „ QObject::connect(action, &QAction::triggered, args...)“ aufgerufen, wobei „ args “ einschließlich eines möglichen „ Qt::ConnectionType “ vollständig weitergeleitet wird.

Die Funktion fügt die neu erstellte Aktion zur Aktionsliste des Widgets hinzu und gibt diese zurück.

QWidget übernimmt die Verantwortung für den zurückgegebenen ` QAction`.

Diese Funktionen wurden in Qt 6.3 eingeführt.

Diese Komfortfunktion erstellt eine neue Aktion mit dem Text „ text “, dem Symbol „ icon “ und gegebenenfalls der Tastenkombination „ shortcut “.

Das Signal „ triggered()“ der Aktion wird mit dem Slot „ member “ von „ receiver “ verbunden. Die Funktion fügt die neu erstellte Aktion zur Aktionsliste des Widgets hinzu und gibt sie zurück.

QWidget übernimmt die Verantwortung für das zurückgegebene ` QAction`.

Diese Funktionen wurden in Qt 6.3 eingeführt.

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

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

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

void QWidget::adjustSize()

Passen die Größe des Widgets an seinen Inhalt an.

Diese Funktion verwendet ` sizeHint()`, sofern diese gültig ist, d. h., die Breite und Höhe des Größenhinweises sind >= 0. Andernfalls wird die Größe auf das untergeordnete Rechteck festgelegt, das alle untergeordneten Widgets abdeckt (die Vereinigung aller Rechtecke der untergeordneten Widgets).

Bei Fenstern wird zudem die Bildschirmgröße berücksichtigt. Ist der Größenhint ` sizeHint()` kleiner als (200, 100) und die Größenrichtlinie ` expanding`, beträgt die Mindestgröße des Fensters (200, 100). Die maximale Größe eines Fensters beträgt 2/3 der Bildschirmbreite und -höhe.

Siehe auch sizeHint() und childrenRect().

QPalette::ColorRole QWidget::backgroundRole() const

Gibt die Hintergrundrolle des Widgets zurück.

Die Hintergrundrolle definiert den Pinsel aus dem „ palette “ des Widgets, der zum Rendern des Hintergrunds verwendet wird.

Wenn keine explizite Hintergrundrolle festgelegt ist, erbt das Widget die Hintergrundrolle seines übergeordneten Widgets.

Siehe auch „ setBackgroundRole()“ und „ foregroundRole()“.

QBackingStore *QWidget::backingStore() const

Gibt das ` QBackingStore ` zurück, in das dieses Widget gezeichnet wird.

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

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

Der in diesem Ereignis geänderte Zustand kann über das bereitgestellte ` event ` abgerufen werden.

Zu den Änderungsereignissen gehören: „ QEvent::ToolBarChange “, „ QEvent::ActivationChange “, „ QEvent::EnabledChange “, „ QEvent::FontChange “, „ QEvent::StyleChange “, „ QEvent::PaletteChange “, „ QEvent::WindowTitleChange “, „ QEvent::IconTextChange “, „ QEvent::ModifiedChange “, „ QEvent::MouseTrackingChange “, „ QEvent::ParentChange “, „ QEvent::WindowStateChange “, „ QEvent::LanguageChange “, „ QEvent::LocaleChange “, „ QEvent::LayoutDirectionChange “ und „ QEvent::ReadOnlyChange “.

QWidget *QWidget::childAt(int x, int y) const

Gibt das sichtbare untergeordnete Widget an der Position (x, y) im Koordinatensystem des Widgets zurück. Befindet sich an der angegebenen Position kein sichtbares untergeordnetes Widget, gibt die Funktion „ nullptr “ zurück.

QWidget *QWidget::childAt(const QPoint &p) const

Gibt das sichtbare untergeordnete Widget am Punkt p im eigenen Koordinatensystem des Widgets zurück.

[since 6.8] QWidget *QWidget::childAt(const QPointF &p) const

Gibt das sichtbare untergeordnete Widget am Punkt p im eigenen Koordinatensystem des Widgets zurück.

Diese Funktion wurde in Qt 6.8 eingeführt.

void QWidget::clearFocus()

Entzieht dem Widget den Fokus für Tastatureingaben.

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

Dieses Widget muss die Fokuseinstellung aktivieren, um den Tastatureingabefokus zu erhalten; das heißt, es muss ` setFocusPolicy()` aufrufen.

Siehe auch „ hasFocus()“, „ setFocus()“, „ focusInEvent()“, „ focusOutEvent()“, „ setFocusPolicy()“ und „ QApplication::focusWidget()“.

void QWidget::clearMask()

Entfernt alle mit „ setMask()“ festgelegten Masken.

Siehe auch setMask().

[slot] bool QWidget::close()

Schließt dieses Widget. Gibt „ true “ zurück, wenn das Widget geschlossen wurde; andernfalls wird „ false “ zurückgegeben.

Zunächst wird dem Widget ein „ QCloseEvent “ gesendet. Das Widget ist „ hidden “, wenn es das „close“-Ereignis „ accepts “ (abfängt). Wenn es das Ereignis „ ignores “ (ignoriert), geschieht nichts. Die Standardimplementierung von „ QWidget::closeEvent()“ akzeptiert das „close“-Ereignis.

Wenn das Widget das Flag „ Qt::WA_DeleteOnClose “ gesetzt hat, wird es zudem gelöscht. Ein „close“-Ereignis wird an das Widget gesendet, unabhängig davon, ob das Widget sichtbar ist oder nicht.

Das Signal „ QGuiApplication::lastWindowClosed()“ wird ausgelöst, wenn das letzte sichtbare primäre Fenster (d. h. ein Fenster ohne übergeordnetes Fenster), bei dem das Attribut „ Qt::WA_QuitOnClose “ gesetzt ist, geschlossen wird. Standardmäßig ist dieses Attribut für alle Widgets gesetzt, mit Ausnahme von vorübergehenden Fenstern wie Startbildschirmen, Werkzeugfenstern und Popup-Menüs.

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

Dieser Ereignis-Handler wird mit dem angegebenen „ event “ aufgerufen, wenn Qt vom Fenstersystem eine Anforderung zum Schließen eines Widgets der obersten Ebene erhält.

Standardmäßig wird das Ereignis akzeptiert und das Widget geschlossen. Sie können diese Funktion neu implementieren, um das Verhalten des Widgets bei Fenster-Schließanforderungen anzupassen. Beispielsweise können Sie das Schließen des Fensters verhindern, indem Sie bei allen Ereignissen ` ignore()` aufrufen.

Hauptfenster-Anwendungen verwenden in der Regel eine Neuimplementierung dieser Funktion, um zu prüfen, ob die Arbeit des Benutzers gespeichert wurde, und vor dem Schließen um Erlaubnis zu bitten.

Siehe auch event(), hide(), close() und QCloseEvent.

QMargins QWidget::contentsMargins() const

Die Funktion „contentsMargins“ gibt die Ränder des Widget-Inhalts zurück.

Siehe auch „ setContentsMargins()“ und „ contentsRect()“.

QRect QWidget::contentsRect() const

Gibt den Bereich innerhalb der Ränder des Widgets zurück.

Siehe auch „ setContentsMargins()“ und „ contentsMargins()“.

[virtual protected] void QWidget::contextMenuEvent(QContextMenuEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann in einer Unterklasse neu implementiert werden, um Ereignisse des Widget-Kontextmenüs zu empfangen.

Der Handler wird aufgerufen, wenn das „ contextMenuPolicy “ des Widgets auf „ Qt::DefaultContextMenu “ gesetzt ist.

Die Standardimplementierung ignoriert das Kontext-Ereignis. Weitere Details finden Sie in der Dokumentation zu ` QContextMenuEvent `.

Siehe auch „ event()“, „ QContextMenuEvent “ und „ customContextMenuRequested()“.

[protected] void QWidget::create(WId window = 0, bool initializeWindow = true, bool destroyOldWindow = true)

Erstellt ein neues Widget-Fenster.

Die Parameter „ window “, „ initializeWindow “ und „ destroyOldWindow “ werden in Qt 5 ignoriert. Bitte verwenden Sie „ QWindow::fromWinId()“, um ein „ QWindow “ zu erstellen, das ein externes Fenster umschließt, und übergeben Sie dieses stattdessen an „ QWidget::createWindowContainer()“.

Siehe auch createWindowContainer() und QWindow::fromWinId().

[static] QWidget *QWidget::createWindowContainer(QWindow *window, QWidget *parent = nullptr, Qt::WindowFlags flags = Qt::WindowFlags())

Erstellt einen „ QWidget “, der es ermöglicht, „ window “ in eine auf „ QWidget “ basierende Anwendung einzubetten.

Der Fenstercontainer wird als untergeordnetes Element von ` parent ` und mit den Fensterflags ` flags` erstellt.

Sobald das Fenster in den Container eingebettet wurde, steuert der Container die Geometrie und Sichtbarkeit des Fensters. Explizite Aufrufe von QWindow::setGeometry(), QWindow::show() oder QWindow::hide() für ein eingebettetes Fenster werden nicht empfohlen.

Der Container übernimmt die Eigentümerschaft an ` window`. Das Fenster kann durch einen Aufruf von ` QWindow::setParent()` aus dem Fenstercontainer entfernt werden.

Der Fenstercontainer wird als natives untergeordnetes Fenster an das oberste Fenster angehängt, dessen untergeordnetes Element er ist. Wenn ein Fenstercontainer als untergeordnetes Element eines „ QAbstractScrollArea “ oder „ QMdiArea “ verwendet wird, erstellt er für jedes Widget in seiner übergeordneten Kette ein „ native window “, um in diesem Anwendungsfall eine korrekte Stapelung und Beschneidung zu ermöglichen. Das Erstellen eines nativen Fensters für den Fenstercontainer ermöglicht ebenfalls eine korrekte Stapelung und Beschneidung. Dies muss vor dem Anzeigen des Fenstercontainers erfolgen. Bei Anwendungen mit vielen nativen untergeordneten Fenstern können Leistungsprobleme auftreten.

Der Fenstercontainer weist eine Reihe bekannter Einschränkungen auf:

• Stapelreihenfolge: Das eingebettete Fenster wird als undurchsichtige Box oberst in der Widget-Hierarchie angeordnet. Die Stapelreihenfolge mehrerer sich überlappender Fenstercontainer-Instanzen ist nicht definiert.
• Rendering-Integration: Der Fenstercontainer ist nicht kompatibel mit ` QGraphicsProxyWidget`, ` QWidget::render()` oder ähnlichen Funktionen.
• Fokusbehandlung: Es ist möglich, der Instanz des Fenster-Containers eine beliebige Fokusrichtlinie zuzuweisen, und sie delegiert den Fokus über einen Aufruf von ` QWindow::requestActivate()` an das Fenster. Die Rückkehr zur normalen Fokus-Kette von der ` QWindow `-Instanz hängt jedoch von der Implementierung der ` QWindow `-Instanz selbst ab. Außerdem ist es plattformabhängig, ob ` QWindow::requestActivate()` dem Fenster tatsächlich den Fokus übergibt.

  Beim Einbetten eines auf Qt Quick basierenden Fensters sorgt Qt automatisch dafür, dass Tabulatortasten-Eingaben zum Ein- und Ausblenden des eingebetteten QML-Fensters führen, sodass der Fokus zum nächsten oder vorherigen fokussierbaren Objekt in der Fenster-Container-Kette wechseln kann.

• Die Verwendung vieler Fenstercontainer-Instanzen in einer auf „ QWidget “ basierenden Anwendung kann die Gesamtleistung der Anwendung erheblich beeinträchtigen.

[signal] void QWidget::customContextMenuRequested(const QPoint &pos)

Dieses Signal wird ausgelöst, wenn die Eigenschaft „ contextMenuPolicy “ des Widgets den Wert „ Qt::CustomContextMenu “ hat und der Benutzer ein Kontextmenü für das Widget angefordert hat. Die Position „ pos “ ist die Position des Kontextmenü-Ereignisses, das das Widget empfängt. Normalerweise handelt es sich dabei um Widget-Koordinaten. Eine Ausnahme von dieser Regel bilden „ QAbstractScrollArea “ und dessen Unterklassen, die das Kontextmenü-Ereignis auf die Koordinaten von „ viewport()“ abbilden.

Siehe auch mapToGlobal(), QMenu und contextMenuPolicy.

[protected] void QWidget::destroy(bool destroyWindow = true, bool destroySubWindows = true)

Gibt Ressourcen des Fenstersystems frei. Löscht das Widget-Fenster, wenn destroyWindow auf „true“ gesetzt ist.

destroy() ruft sich selbst rekursiv für alle untergeordneten Widgets auf und übergibt dabei destroySubWindows als Parameter für „ destroyWindow “. Um mehr Kontrolle über die Zerstörung von Unter-Widgets zu haben, sollten diese zunächst selektiv zerstört werden.

Diese Funktion wird in der Regel aus dem Destruktor von ` QWidget ` aufgerufen.

[virtual protected] void QWidget::dragEnterEvent(QDragEnterEvent *event)

Dieser Ereignis-Handler wird aufgerufen, wenn ein Drag-Vorgang läuft und die Maus in dieses Widget gelangt. Das Ereignis wird über den Parameter „ event “ übergeben.

Wird das Ereignis ignoriert, erhält das Widget keine „ drag move events “-Daten.

Einen Überblick darüber, wie Sie Drag-and-Drop in Ihrer Anwendung implementieren können, finden Sie in der Dokumentation zu Drag-and-Drop.

Siehe auch „ QDrag “ und „ QDragEnterEvent “.

[virtual protected] void QWidget::dragLeaveEvent(QDragLeaveEvent *event)

Dieser Ereignis-Handler wird aufgerufen, wenn ein Drag-Vorgang läuft und die Maus dieses Widget verlässt. Das Ereignis wird über den Parameter „ event “ übergeben.

Einen Überblick darüber, wie Sie Drag-and-Drop in Ihrer Anwendung implementieren können, finden Sie in der Dokumentation zu Drag-and-Drop.

Siehe auch „ QDrag “ und „ QDragLeaveEvent “.

[virtual protected] void QWidget::dragMoveEvent(QDragMoveEvent *event)

Dieser Ereignis-Handler wird aufgerufen, wenn ein Drag-Vorgang im Gange ist und eine der folgenden Bedingungen eintritt: Der Cursor betritt dieses Widget, der Cursor bewegt sich innerhalb dieses Widgets oder eine Modifikatortaste wird auf der Tastatur gedrückt, während dieses Widget den Fokus hat. Das Ereignis wird über den Parameter „ event “ übergeben.

Einen Überblick darüber, wie Sie Drag-and-Drop in Ihrer Anwendung implementieren können, finden Sie in der Dokumentation zu Drag-and-Drop.

Siehe auch „ QDrag “ und „ QDragMoveEvent “.

[virtual protected] void QWidget::dropEvent(QDropEvent *event)

Dieser Ereignis-Handler wird aufgerufen, wenn das gezogene Element auf diesem Widget abgelegt wird. Das Ereignis wird über den Parameter „ event “ übergeben.

Einen Überblick darüber, wie Sie Drag-and-Drop in Ihrer Anwendung implementieren können, finden Sie in der Dokumentation zu Drag-and-Drop.

Siehe auch „ QDrag “ und „ QDropEvent “.

WId QWidget::effectiveWinId() const

Gibt die effektive Fenstersystem-ID des Widgets zurück, d. h. die Fenstersystem-ID des nativen übergeordneten Widgets.

Wenn es sich um ein natives Widget handelt, gibt diese Funktion die native Widget-ID zurück. Andernfalls wird die Fenster-ID des ersten nativen übergeordneten Widgets zurückgegeben, d. h. des Widgets der obersten Ebene, das dieses Widget enthält.

Siehe auch ` nativeParentWidget()`.

void QWidget::ensurePolished() const

Stellt sicher, dass das Widget und seine untergeordneten Elemente von „ QStyle “ aufbereitet wurden (d. h., dass sie über eine korrekte Schriftart und Farbpalette verfügen).

QWidget Ruft diese Funktion auf, nachdem das Widget vollständig erstellt wurde, aber bevor es zum allerersten Mal angezeigt wird. Sie können diese Funktion aufrufen, wenn Sie sicherstellen möchten, dass das Widget vor der Ausführung einer Operation optimiert ist; beispielsweise könnte die korrekte Schriftgröße in der Neaimplementierung von ` sizeHint()` des Widgets erforderlich sein. Beachten Sie, dass diese Funktion aus der Standardimplementierung von ` sizeHint()` aufgerufen wird.

Die „Polishing“-Funktion ist nützlich für die abschließende Initialisierung, die erst erfolgen darf, nachdem alle Konstruktoren (sowohl aus Basisklassen als auch aus Unterklassen) aufgerufen wurden.

Wenn Sie beim „Polishing“ eines Widgets bestimmte Einstellungen ändern müssen, implementieren Sie ` event()` neu und verarbeiten Sie den Ereignistyp ` QEvent::Polish `.

Hinweis: Die Funktion ist als `const` deklariert, damit sie von anderen `const`-Funktionen (z. B. ` sizeHint()`) aufgerufen werden kann.

Siehe auch ` event()`.

[virtual protected] void QWidget::enterEvent(QEnterEvent *event)

Dieser Ereignis-Handler kann in einer Unterklasse neu implementiert werden, um „Enter“-Ereignisse des Widgets zu empfangen, die über den Parameter „ event “ übergeben werden.

Ein Ereignis wird an das Widget gesendet, wenn der Mauszeiger in das Widget eintritt.

Siehe auch „ leaveEvent()“, „ mouseMoveEvent()“ und „ event()“.

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

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

Dies ist der Haupt-Ereignisbehandler; er verarbeitet das Ereignis „ event “. Sie können diese Funktion in einer Unterklasse neu implementieren, wir empfehlen jedoch, stattdessen einen der spezialisierten Ereignisbehandler zu verwenden.

Tastenanschlag- und Loslass-Ereignisse werden anders behandelt als andere Ereignisse. `event()` prüft auf `Tab` und `Shift+Tab` und versucht, den Fokus entsprechend zu verschieben. Wenn kein Widget vorhanden ist, auf das der Fokus verschoben werden kann (oder der Tastenanschlag nicht `Tab` oder `Shift+Tab` ist), ruft `event()` ` keyPressEvent()` auf.

Auch die Behandlung von Maus- und Tablet-Ereignissen ist etwas speziell: Nur wenn das Widget „ enabled “ ist, ruft `event()` die spezialisierten Handler wie ` mousePressEvent()` auf; andernfalls wird das Ereignis verworfen.

Diese Funktion gibt „ true “ zurück, wenn das Ereignis erkannt wurde, andernfalls gibt sie „ false “ zurück. Wurde das erkannte Ereignis akzeptiert (siehe „ QEvent::accepted “), wird jede weitere Verarbeitung, wie z. B. die Ereignisweitergabe an das übergeordnete Widget, gestoppt.

Siehe auch closeEvent(), focusInEvent(), focusOutEvent(), enterEvent(), keyPressEvent(), keyReleaseEvent(), leaveEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), mousePressEvent(), mouseReleaseEvent(), moveEvent(), paintEvent(), resizeEvent(), QObject::event() und QObject::timerEvent().

[static] QWidget *QWidget::find(WId id)

Gibt einen Zeiger auf das Widget mit der Fensterkennung/dem Fenster-Handle „ id “ zurück.

Der Typ der Fensterkennung hängt vom zugrunde liegenden Fenstersystem ab; die konkrete Definition finden Sie unter qwindowdefs.h. Wenn kein Widget mit dieser Kennung vorhanden ist, wird nullptr zurückgegeben.

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

Dieser Ereignis-Handler kann in einer Unterklasse neu implementiert werden, um Tastaturfokus-Ereignisse (Fokus erhalten) für das Widget zu empfangen. Das Ereignis wird über den Parameter „ event “ übergeben

Ein Widget muss normalerweise ` setFocusPolicy()` auf einen anderen Wert als ` Qt::NoFocus ` setzen, um Fokusereignisse zu empfangen. (Beachten Sie, dass der Anwendungsprogrammierer ` setFocus()` für jedes Widget aufrufen kann, auch für solche, die normalerweise keinen Fokus akzeptieren.)

Die Standardimplementierung aktualisiert das Widget (mit Ausnahme von Fenstern, für die kein ` focusPolicy()` angegeben ist).

Siehe auch focusOutEvent(), setFocusPolicy(), keyPressEvent(), keyReleaseEvent(), event() und QFocusEvent.

[protected] bool QWidget::focusNextChild()

Sucht ein neues Widget, dem der Tastaturfokus zugewiesen werden soll, entsprechend der Einstellung „ Tab “, und gibt „ true “ zurück, wenn ein neues Widget gefunden wird, andernfalls „false“.

Siehe auch focusPreviousChild().

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

Sucht ein neues Widget, dem der Tastaturfokus zugewiesen werden soll, je nach Bedarf für „Tab“ und „Umschalt+Tab“, und gibt „ true “ zurück, wenn ein neues Widget gefunden wird, andernfalls „false“.

Ist „ next “ wahr, sucht diese Funktion vorwärts; ist „ next “ falsch, sucht sie rückwärts.

Manchmal möchten Sie diese Funktion neu implementieren. Beispielsweise könnte ein Webbrowser sie neu implementieren, um seinen „derzeit aktiven Link“ vorwärts oder rückwärts zu verschieben, und `focusNextPrevChild()` nur dann 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 somit die Kontrolle über die Fokusnavigation für alle untergeordneten Widgets.

Siehe auch ` focusNextChild()` und ` focusPreviousChild()`.

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

Dieser Ereignis-Handler kann in einer Unterklasse neu implementiert werden, um Tastaturfokus-Ereignisse (Fokusverlust) für das Widget zu empfangen. Die Ereignisse werden über den Parameter „ event “ übergeben.

Ein Widget muss normalerweise ` setFocusPolicy()` auf einen anderen Wert als ` Qt::NoFocus ` setzen, um Fokusereignisse zu empfangen. (Beachten Sie, dass der Anwendungsprogrammierer ` setFocus()` für jedes Widget aufrufen kann, auch für solche, die normalerweise keinen Fokus akzeptieren.)

Die Standardimplementierung aktualisiert das Widget (mit Ausnahme von Fenstern, für die kein ` focusPolicy()` angegeben ist).

Siehe auch „ focusInEvent()“, „ setFocusPolicy()“, „ keyPressEvent()“, „ keyReleaseEvent()“, „ event()“ und „ QFocusEvent “.

[protected] bool QWidget::focusPreviousChild()

Sucht ein neues Widget, dem der Tastaturfokus zugewiesen werden soll, entsprechend der Angabe in ` Shift+Tab`, und gibt ` true ` zurück, wenn ein neues Widget gefunden wird, andernfalls `false`.

Siehe auch focusNextChild().

QWidget *QWidget::focusProxy() const

Gibt den Fokus-Proxy zurück oder „ nullptr “, falls kein Fokus-Proxy vorhanden ist.

Siehe auch setFocusProxy().

QWidget *QWidget::focusWidget() const

Gibt das letzte untergeordnete Element dieses Widgets zurück, für das „ setFocus “ aufgerufen wurde. Bei Widgets der obersten Ebene ist dies das Widget, das den Fokus erhält, falls dieses Fenster aktiviert wird

Dies ist nicht dasselbe wie ` QApplication::focusWidget()`, das das Fokus-Widget im aktuell aktiven Fenster zurückgibt.

QFontInfo QWidget::fontInfo() const

Gibt die Schriftartinformationen für die aktuelle Schriftart des Widgets zurück. Entspricht „ QFontInfo(widget->font()) “.

Siehe auch „ font()“, „ fontMetrics()“ und „ setFont()“.

QFontMetrics QWidget::fontMetrics() const

Gibt die Schriftmetriken für die aktuelle Schriftart des Widgets zurück. Entspricht „ QFontMetrics(widget->font()) “.

Siehe auch „ font()“, „ fontInfo()“ und „ setFont()“.

QPalette::ColorRole QWidget::foregroundRole() const

Gibt die Vordergrundfarbe zurück.

Die Vordergrundrolle definiert die Farbe aus dem „ palette “ des Widgets, die zum Zeichnen des Vordergrunds verwendet wird.

Wenn keine explizite Vordergrundrolle festgelegt ist, gibt die Funktion eine Rolle zurück, die sich von der Hintergrundrolle abhebt.

Siehe auch „ setForegroundRole()“ und „ backgroundRole()“.

[invokable] QPixmap QWidget::grab(const QRect &rectangle = QRect(QPoint(0, 0), QSize(-1, -1)))

Zeichnet das Widget in eine Pixmap, deren Größe durch die angegebene ` rectangle` begrenzt ist. Falls das Widget untergeordnete Elemente enthält, werden diese ebenfalls an den entsprechenden Positionen gezeichnet.

Wird ein Rechteck mit einer ungültigen Größe angegeben (Standardeinstellung), wird das gesamte Widget gezeichnet.

Siehe auch ` render()` und ` QPixmap`.

void QWidget::grabGesture(Qt::GestureType gesture, Qt::GestureFlags flags = Qt::GestureFlags())

Meldet das Widget bei einem bestimmten gesture mit spezifischen flags an.

Siehe auch ungrabGesture() und QGestureEvent.

void QWidget::grabKeyboard()

Übernimmt die Tastatureingabe.

Dieses Widget empfängt alle Tastaturereignisse, bis „ releaseKeyboard()“ aufgerufen wird; andere Widgets erhalten überhaupt keine Tastaturereignisse. Mausereignisse sind davon nicht betroffen. Verwenden Sie „ grabMouse()“, wenn Sie diese erfassen möchten.

Das Fokus-Widget ist davon nicht betroffen, außer dass es keine Tastaturereignisse empfängt. ` setFocus()` verschiebt den Fokus wie gewohnt, aber das neue Fokus-Widget empfängt Tastaturereignisse erst, nachdem ` releaseKeyboard()` aufgerufen wurde.

Wenn derzeit ein anderes Widget die Tastatureingabe erfasst, wird die Erfassung durch dieses Widget zuerst freigegeben.

Siehe auch „ releaseKeyboard()“, „ grabMouse()“, „ releaseMouse()“ und „ focusWidget()“.

void QWidget::grabMouse()

Übernimmt die Mauseingaben.

Dieses Widget empfängt alle Mausereignisse, bis „ releaseMouse()“ aufgerufen wird; andere Widgets erhalten überhaupt keine Mausereignisse. Tastaturereignisse sind davon nicht betroffen. Verwenden Sie „ grabKeyboard()“, wenn Sie diese abfangen möchten.

Bei der Verwendung von Qt ist es selten notwendig, die Maus zu erfassen, da Qt dies selbst sinnvoll übernimmt. Insbesondere erfasst Qt die Maus, wenn eine Maustaste gedrückt wird, und behält die Kontrolle, bis die letzte Taste losgelassen wird.

Siehe auch ` releaseMouse()`, ` grabKeyboard()` und ` releaseKeyboard()`.

void QWidget::grabMouse(const QCursor &cursor)

Übernimmt die Mauseingabe und ändert die Form des Cursors.

Der Cursor nimmt die Form cursor an (solange der Mausfokus ergriffen ist) und dieses Widget ist das einzige, das Mausereignisse empfängt, bis releaseMouse() aufgerufen wird.

Siehe auch releaseMouse(), grabKeyboard(), releaseKeyboard() und setCursor().

int QWidget::grabShortcut(const QKeySequence &key, Qt::ShortcutContext context = Qt::WindowShortcut)

Fügt dem Qt-Shortcut-System einen Shortcut hinzu, der in der angegebenen „ context “ auf die angegebene „ key “-Sequenz achtet. Wenn die „ context “ auf „ Qt::ApplicationShortcut “ gesetzt ist, gilt der Shortcut für die gesamte Anwendung. Andernfalls gilt er entweder lokal für dieses Widget („ Qt::WidgetShortcut “) oder für das Fenster selbst („ Qt::WindowShortcut “).

Wenn dieselbe Tastenkombination „ key “ von mehreren Widgets belegt wurde, wird bei Auftreten der Tastenkombination „ key “ ein „ QEvent::Shortcut “-Ereignis an alle betroffenen Widgets in nicht deterministischer Reihenfolge gesendet, wobei das Flag „ambiguous“ auf „true“ gesetzt ist.

Siehe auch releaseShortcut() und setShortcutEnabled().

QGraphicsEffect *QWidget::graphicsEffect() const

Die Funktion „graphicsEffect“ gibt einen Zeiger auf den Grafikeffekt des Widgets zurück.

Wenn das Widget keinen Grafikeffekt hat, wird ` nullptr ` zurückgegeben.

Siehe auch ` setGraphicsEffect()`.

QGraphicsProxyWidget *QWidget::graphicsProxyWidget() const

Gibt das Proxy-Widget für das entsprechende eingebettete Widget in einer Grafikansicht zurück; andernfalls wird „ nullptr “ zurückgegeben.

Siehe auch ` QGraphicsProxyWidget::createProxyForChildWidget()` und ` QGraphicsScene::addWidget()`.

[virtual] bool QWidget::hasHeightForWidth() const

Gibt „ true “ zurück, wenn die bevorzugte Höhe des Widgets von dessen Breite abhängt; andernfalls wird „ false “ zurückgegeben.

[virtual] int QWidget::heightForWidth(int w) const

Gibt die bevorzugte Höhe für dieses Widget zurück, ausgehend von der Breite w.

Verfügt dieses Widget über ein Layout, gibt die Standardimplementierung die bevorzugte Höhe des Layouts zurück. Ist kein Layout vorhanden, gibt die Standardimplementierung den Wert -1 zurück, was bedeutet, dass die bevorzugte Höhe nicht von der Breite abhängt.

[slot] void QWidget::hide()

Blendet das Widget aus. Diese Funktion entspricht „ setVisible(false)“.

Siehe auch „ hideEvent()“, „ isHidden()“, „ show()“, „ setVisible()“, „ isVisible()“ und „ close()“.

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

Dieser Ereignis-Handler kann in einer Unterklasse neu implementiert werden, um Ereignisse zum Ausblenden von Widgets zu empfangen. Das Ereignis wird über den Parameter „ event “ übergeben.

Ausblendereignisse werden unmittelbar nach dem Ausblenden an Widgets gesendet.

Hinweis: Ein Widget empfängt spontane Einblend- und Ausblendereignisse, wenn sein Zuordnungsstatus vom Fenstersystem geändert wird, z. B. ein spontanes Ausblendereignis, wenn der Benutzer das Fenster minimiert, und ein spontanes Einblendereignis, wenn das Fenster wiederhergestellt wird. Nach dem Empfang eines spontanen Ausblendereignisses gilt ein Widget im Sinne von ` isVisible()` weiterhin als sichtbar.

Siehe auch visible, event() und QHideEvent.

[override virtual protected] void QWidget::initPainter(QPainter *painter) const

Initialisiert den Stift „ painter “, den Hintergrund und die Schriftart so, dass sie mit denen des angegebenen Widgets übereinstimmen. Diese Funktion wird automatisch aufgerufen, wenn der „ “ auf einer „ QWidget “ geöffnet wird.

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

Dieser Ereignis-Handler für das Ereignis „ event “ kann in einer Unterklasse neu implementiert werden, um Ereignisse zur Zusammensetzung der Eingabemethode zu empfangen. Dieser Handler wird aufgerufen, wenn sich der Status der Eingabemethode ändert.

Beachten Sie, dass beim Erstellen benutzerdefinierter Textbearbeitungs-Widgets das Fensterattribut „ Qt::WA_InputMethodEnabled “ explizit (mithilfe der Funktion „ setAttribute()“) gesetzt werden muss, um Ereignisse der Eingabemethode zu empfangen.

Die Standardimplementierung ruft `event->ignore()` auf, wodurch das Eingabemethode-Ereignis zurückgewiesen wird. Weitere Details finden Sie in der Dokumentation zu ` QInputMethodEvent `.

Siehe auch „ event()“ und „ QInputMethodEvent “.

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

Diese Methode ist nur für Eingabe-Widgets relevant. Sie wird von der Eingabemethode verwendet, um eine Reihe von Eigenschaften des Widgets abzufragen, damit komplexe Eingabemethodenoperationen wie die Unterstützung von umgebendem Text und Rückkonvertierungen unterstützt werden können.

query Gibt an, welche Eigenschaft abgefragt wird.

Siehe auch inputMethodEvent(), QInputMethodEvent, QInputMethodQueryEvent und inputMethodHints.

void QWidget::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 „ QWidget “ sollte von jeder Aktion nur jeweils eine enthalten.

Siehe auch „ removeAction()“, „ addAction()“, „ QMenu “, „ contextMenuPolicy “ und „ actions()“.

void QWidget::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 “ auf „ nullptr “ gesetzt ist oder „ before “ für dieses Widget keine gültige Aktion ist.

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

Siehe auch „ removeAction()“, „ QMenu “, „ insertAction()“ und „ contextMenuPolicy “.

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

Gibt „ true “ zurück, wenn dieses Widget ein übergeordnetes Widget (oder ein übergeordnetes Widget der nächsten Ebene usw. bis zu beliebiger Ebene) des angegebenen „ child “ ist und sich beide Widgets im selben Fenster befinden; andernfalls wird „ false “ zurückgegeben.

bool QWidget::isEnabledTo(const QWidget *ancestor) const

Gibt „ true “ zurück, wenn dieses Widget aktiviert würde, sofern „ ancestor “ aktiviert ist; andernfalls wird „ false “ zurückgegeben.

Dies ist der Fall, wenn weder das Widget selbst noch alle übergeordneten Elemente bis einschließlich ancestor (ausgenommen selbst) explizit deaktiviert wurden.

isEnabledTo(0) gibt „false“ zurück, wenn dieses Widget oder eines seiner übergeordneten Widgets explizit deaktiviert wurde.

Der Begriff „Vorfahre“ bezeichnet hier ein übergeordnetes Widget innerhalb desselben Fensters.

Daher endet isEnabledTo(0) beim Fenster dieses Widgets, im Gegensatz zu isEnabled(), das auch übergeordnete Fenster berücksichtigt.

Siehe auch ` setEnabled()` und ` enabled`.

bool QWidget::isHidden() const

Gibt „ true “ zurück, wenn das Widget ausgeblendet ist, andernfalls „ false “.

Ein ausgeblendetes Widget wird erst sichtbar, wenn „ show()“ dafür aufgerufen wird. Es wird nicht automatisch angezeigt, wenn das übergeordnete Element angezeigt wird.

Um die Sichtbarkeit zu prüfen, verwenden Sie stattdessen !isVisible() (beachten Sie das Ausrufezeichen).

`isHidden()` impliziert `!isVisible()`, aber ein Widget kann gleichzeitig nicht sichtbar und nicht ausgeblendet sein. Dies ist der Fall bei Widgets, die Kinder von nicht sichtbaren Widgets sind.

Widgets sind ausgeblendet, wenn:

• sie als eigenständige Fenster erstellt wurden,
• sie als untergeordnete Elemente sichtbarer Widgets erstellt wurden,
• hide() oder ` setVisible(false)` aufgerufen wurde.

bool QWidget::isVisibleTo(const QWidget *ancestor) const

Gibt „ true “ zurück, wenn dieses Widget sichtbar würde, sobald „ ancestor “ angezeigt wird; andernfalls wird „ false “ zurückgegeben.

Der Fall „true“ tritt ein, wenn weder das Widget selbst noch ein übergeordnetes Element bis einschließlich ancestor explizit ausgeblendet wurde.

Diese Funktion gibt weiterhin „true“ zurück, wenn das Widget von anderen Fenstern auf dem Bildschirm verdeckt wird, aber physisch sichtbar wäre, wenn dieses oder jene Fenster verschoben würden.

isVisibleTo(0) ist identisch mit isVisible().

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

bool QWidget::isWindow() const

Gibt „ true “ zurück, wenn das Widget ein eigenständiges Fenster ist, andernfalls „ false “.

Ein Fenster ist ein Widget, das optisch keinem anderen Widget untergeordnet ist und in der Regel über einen Rahmen und ein „ window title “ verfügt.

Ein Fenster kann ein „ parent widget “ haben. Es wird dann mit seinem übergeordneten Element gruppiert und gelöscht, wenn dieses gelöscht wird, minimiert, wenn dieses minimiert wird, usw. Sofern vom Fenstermanager unterstützt, verfügt es außerdem über einen gemeinsamen Taskleisten-Eintrag mit seinem übergeordneten Element.

QDialog Und „ QMainWindow “-Widgets sind standardmäßig Fenster, selbst wenn im Konstruktor ein übergeordnetes Widget angegeben wird. Dieses Verhalten wird durch das Flag „ Qt::Window “ festgelegt.

Siehe auch „ window()“, „ isModal()“ und „ parentWidget()“.

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

Dieser Ereignis-Handler für das Ereignis „ event “ kann in einer Unterklasse neu implementiert werden, um Tastendruckereignisse für das Widget zu empfangen.

Ein Widget muss zunächst ` setFocusPolicy()` aufrufen, um den Fokus anzunehmen, und den Fokus besitzen, um ein Tastendruckereignis empfangen zu können.

Wenn Sie diesen Handler neu implementieren, ist es sehr wichtig, dass Sie die Implementierung der Basisklasse aufrufen, falls Sie die Taste nicht weiterverarbeiten.

Die Standardimplementierung schließt Popup-Widgets, wenn der Benutzer die Tastenkombination für ` QKeySequence::Cancel ` drückt (typischerweise die Escape-Taste). Andernfalls wird das Ereignis ignoriert, sodass das übergeordnete Widget es interpretieren kann.

Beachten Sie, dass „ QKeyEvent “ mit `isAccepted()` == `true` beginnt; Sie müssen also ` QKeyEvent::accept()` nicht aufrufen – rufen Sie lediglich die Implementierung der Basisklasse nicht auf, wenn Sie auf die Taste reagieren.

Siehe auch „ keyReleaseEvent()“, „ setFocusPolicy()“, „ focusInEvent()“, „ focusOutEvent()“, „ event()“ und „ QKeyEvent “.

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

Dieser Ereignisbehandler für das Ereignis „ event “ kann in einer Unterklasse neu implementiert werden, um Tastenloslass-Ereignisse für das Widget zu empfangen.

Ein Widget muss zunächst ` accept focus ` und anschließend ` have focus ` aufrufen, um ein Tastenloslass-Ereignis zu empfangen.

Wenn Sie diesen Handler neu implementieren, ist es sehr wichtig, dass Sie die Implementierung der Basisklasse aufrufen, falls Sie die Taste nicht weiterverarbeiten.

Die Standardimplementierung ignoriert das Ereignis, damit das übergeordnete Widget es interpretieren kann.

Beachten Sie, dass ` QKeyEvent ` mit `isAccepted() == true` beginnt; Sie müssen also ` QKeyEvent::accept()` nicht aufrufen – rufen Sie die Implementierung der Basisklasse lediglich nicht auf, wenn Sie auf die Taste reagieren.

Siehe auch „ keyPressEvent()“, „ QEvent::ignore()“, „ setFocusPolicy()“, „ focusInEvent()“, „ focusOutEvent()“, „ event()“ und „ QKeyEvent “.

[static] QWidget *QWidget::keyboardGrabber()

Gibt das Widget zurück, das derzeit die Tastatureingabe erfasst.

Wenn derzeit kein Widget in dieser Anwendung die Tastatureingabe erfasst, wird ` nullptr ` zurückgegeben.

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

QLayout *QWidget::layout() const

Gibt den auf diesem Widget installierten Layout-Manager zurück oder „ nullptr “, falls kein Layout-Manager installiert ist.

Der Layout-Manager legt die Geometrie der untergeordneten Elemente des Widgets fest, die dem Layout hinzugefügt wurden.

Siehe auch „ setLayout()“, „ sizePolicy()“ und „Layout-Verwaltung“.

[virtual protected] void QWidget::leaveEvent(QEvent *event)

Dieser Ereignis-Handler kann in einer Unterklasse neu implementiert werden, um „Widget-Leave“-Ereignisse zu empfangen, die über den Parameter „ event “ übergeben werden.

Ein „Leave“-Ereignis wird an das Widget gesendet, wenn der Mauszeiger das Widget verlässt.

Siehe auch „ enterEvent()“, „ mouseMoveEvent()“ und „ event()“.

[slot] void QWidget::lower()

Verschiebt das Widget an das Ende des Stapels des übergeordneten Widgets.

Nach diesem Aufruf befindet sich das Widget visuell hinter allen überlappenden Geschwister-Widgets (und wird daher von diesen verdeckt).

Siehe auch „ raise()“ und „ stackUnder()“.

[since 6.0] QPointF QWidget::mapFrom(const QWidget *parent, const QPointF &pos) const

Wandelt die Widget-Koordinaten pos vom Koordinatensystem von parent in das Koordinatensystem dieses Widgets um. Die parent darf nicht nullptr sein und muss ein übergeordnetes Element des aufrufenden Widgets sein.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch mapTo(), mapFromParent(), mapFromGlobal() und underMouse().

QPoint QWidget::mapFrom(const QWidget *parent, const QPoint &pos) const

[since 6.0] QPointF QWidget::mapFromGlobal(const QPointF &pos) const

Konvertiert die globalen Bildschirmkoordinaten pos in Widget-Koordinaten.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch mapToGlobal(), mapFrom() und mapFromParent().

QPoint QWidget::mapFromGlobal(const QPoint &pos) const

[since 6.0] QPointF QWidget::mapFromParent(const QPointF &pos) const

Konvertiert die Koordinaten des übergeordneten Widgets pos in Widget-Koordinaten.

Entspricht ` mapFromGlobal()` , wenn das Widget kein übergeordnetes Widget hat.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch „ mapToParent()“, „ mapFrom()“, „ mapFromGlobal()“ und „ underMouse()“.

QPoint QWidget::mapFromParent(const QPoint &pos) const

[since 6.0] QPointF QWidget::mapTo(const QWidget *parent, const QPointF &pos) const

Konvertiert das Koordinaten pos des Widgets in das Koordinatensystem von parent. Die parent darf nicht nullptr sein und muss ein übergeordnetes Element des aufrufenden Widgets sein.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch mapFrom(), mapToParent(), mapToGlobal() und underMouse().

QPoint QWidget::mapTo(const QWidget *parent, const QPoint &pos) const

[since 6.0] QPointF QWidget::mapToGlobal(const QPointF &pos) const

Wandelt die Widget-Koordinaten pos in globale Bildschirmkoordinaten um. Beispielsweise würde mapToGlobal(QPointF(0,0)) die globalen Koordinaten des Pixels in der oberen linken Ecke des Widgets liefern.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch ` mapFromGlobal()`, ` mapTo()` und ` mapToParent()`.

QPoint QWidget::mapToGlobal(const QPoint &pos) const

[since 6.0] QPointF QWidget::mapToParent(const QPointF &pos) const

Konvertiert die Koordinaten des Widgets pos in eine Koordinate im übergeordneten Widget.

Entspricht ` mapToGlobal()` , wenn das Widget kein übergeordnetes Widget hat.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch „ mapFromParent()“, „ mapTo()“, „ mapToGlobal()“ und „ underMouse()“.

QPoint QWidget::mapToParent(const QPoint &pos) const

QRegion QWidget::mask() const

Gibt die derzeit für ein Widget festgelegte Maske zurück. Ist keine Maske festgelegt, ist der Rückgabewert ein leerer Bereich.

Siehe auch setMask(), clearMask() und QRegion::isEmpty().

[override virtual protected] int QWidget::metric(QPaintDevice::PaintDeviceMetric m) const

Implementiert: ` QPaintDevice::metric` (QPaintDevice::PaintDeviceMetric metric) const.

Interne Implementierung der virtuellen Funktion ` QPaintDevice::metric()`.

m ist die abzurufende Metrik.

[virtual protected] void QWidget::mouseDoubleClickEvent(QMouseEvent *event)

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

Die Standardimplementierung ruft ` mousePressEvent()` auf.

Siehe auch mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent(), event() und QMouseEvent.

[static] QWidget *QWidget::mouseGrabber()

Gibt das Widget zurück, das derzeit die Mauseingabe verarbeitet.

Wenn derzeit kein Widget in dieser Anwendung die Maus gesteuert, wird ` nullptr ` zurückgegeben.

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

[virtual protected] void QWidget::mouseMoveEvent(QMouseEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann in einer Unterklasse neu implementiert werden, um Mausbewegungsereignisse für das Widget zu empfangen.

Ist die Mausverfolgung deaktiviert, treten Mausbewegungsereignisse nur auf, wenn während der Mausbewegung eine Maustaste gedrückt wird. Ist die Mausverfolgung aktiviert, treten Mausbewegungsereignisse auch dann auf, wenn keine Maustaste gedrückt ist.

QMouseEvent::position() gibt die Position des Mauszeigers relativ zu diesem Widget zurück. Bei Klick- und Loslassereignissen entspricht die Position in der Regel der Position des letzten Mausbewegungsereignisses, kann jedoch abweichen, wenn die Hand des Benutzers zittert. Dies ist eine Eigenschaft des zugrunde liegenden Fenstersystems, nicht von Qt.

Wenn Sie einen Tooltip sofort anzeigen möchten, während die Maus bewegt wird (z. B. um die Mauskoordinaten mit ` QMouseEvent::position()` abzurufen und sie als Tooltip anzuzeigen), müssen Sie zunächst das Maus-Tracking wie oben beschrieben aktivieren. Um sicherzustellen, dass der Tooltip sofort aktualisiert wird, müssen Sie dann in Ihrer Implementierung von `mouseMoveEvent()` ` QToolTip::showText()` anstelle von ` setToolTip()` aufrufen.

Siehe auch „ setMouseTracking()“, „ mousePressEvent()“, „ mouseReleaseEvent()“, „ mouseDoubleClickEvent()“, „ event()“, „ QMouseEvent “ und das Scribble-Beispiel.

[virtual protected] void QWidget::mousePressEvent(QMouseEvent *event)

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

Wenn Sie in der Funktion `mousePressEvent()` neue Widgets erstellen, landet die Funktion ` mouseReleaseEvent()` möglicherweise nicht dort, wo Sie es erwarten – abhängig vom zugrunde liegenden Fenstersystem (oder X11-Fenstermanager), der Position der Widgets und möglicherweise weiteren Faktoren.

Die Standardimplementierung sorgt dafür, dass Popup-Widgets geschlossen werden, wenn Sie außerhalb des Fensters klicken. Bei anderen Widget-Typen führt sie keine Aktion aus.

Siehe auch ` mouseReleaseEvent()`, ` mouseDoubleClickEvent()`, ` mouseMoveEvent()`, ` event()`, ` QMouseEvent` und das Scribble-Beispiel.

[virtual protected] void QWidget::mouseReleaseEvent(QMouseEvent *event)

Dieser Ereignis-Handler für das Ereignis „ event “ kann in einer Unterklasse neu implementiert werden, um Maus-Loslass-Ereignisse für das Widget zu empfangen.

Siehe auch „ mousePressEvent()“, „ mouseDoubleClickEvent()“, „ mouseMoveEvent()“, „ event()“, „ QMouseEvent “ und „Scribble-Beispiel“.

void QWidget::move(int x, int y)

Dies entspricht der Funktion „move(QPoint(x, y))“.

[virtual protected] void QWidget::moveEvent(QMoveEvent *event)

Dieser Ereignishandler kann in einer Unterklasse neu implementiert werden, um Widget-Verschiebungsereignisse zu empfangen, die über den Parameter ` event ` übergeben werden. Wenn das Widget dieses Ereignis empfängt, befindet es sich bereits an der neuen Position.

Auf die alte Position kann über ` QMoveEvent::oldPos()` zugegriffen werden.

Siehe auch „ resizeEvent()“, „ event()“, „ move()“ und „ QMoveEvent “.

[virtual protected] bool QWidget::nativeEvent(const QByteArray &eventType, void *message, qintptr *result)

Dieser spezielle Ereignis-Handler kann in einer Unterklasse neu implementiert werden, um native Plattformereignisse zu empfangen, die durch „ eventType “ identifiziert und über den Parameter „ message “ übergeben werden.

Wenn Sie in Ihrer Neuimplementierung dieser Funktion verhindern möchten, dass das Ereignis von Qt verarbeitet wird, geben Sie „true“ zurück und setzen Sie „ result “. Der Parameter „ result “ ist nur unter Windows von Bedeutung. Wenn Sie „false“ zurückgeben, wird dieses native Ereignis an Qt zurückgegeben, das das Ereignis in ein Qt-Ereignis umwandelt und an das Widget sendet.

Siehe auch QAbstractNativeEventFilter.

QWidget *QWidget::nativeParentWidget() const

Gibt das native übergeordnete Widget für dieses Widget zurück, d. h. das nächste übergeordnete Widget, das über eine System-ID verfügt, oder nullptr, falls es kein natives übergeordnetes Widget gibt.

Siehe auch effectiveWinId().

QWidget *QWidget::nextInFocusChain() const

Gibt das nächste Widget in der Fokus-Kette dieses Widgets zurück.

Siehe auch ` previousInFocusChain()`.

void QWidget::overrideWindowFlags(Qt::WindowFlags flags)

Setzt die Fensterflags für das Widget auf „ flags “, ohne das Fenstersystem darüber zu informieren.

Siehe auch ` setWindowFlags()`.

[override virtual] QPaintEngine *QWidget::paintEngine() const

Implementiert neu: ` QPaintDevice::paintEngine()` const.

Gibt die Zeichen-Engine des Widgets zurück.

Beachten Sie, dass diese Funktion nicht explizit vom Benutzer aufgerufen werden sollte, da sie ausschließlich zur Neuimplementierung vorgesehen ist. Die Funktion wird intern von Qt aufgerufen, und die Standardimplementierung gibt möglicherweise nicht immer einen gültigen Zeiger zurück.

[virtual protected] void QWidget::paintEvent(QPaintEvent *event)

Dieser Ereignis-Handler kann in einer Unterklasse neu implementiert werden, um die in ` event` übergebenen Paint-Ereignisse zu empfangen.

Ein Zeichnungsereignis ist eine Anforderung, ein Widget ganz oder teilweise neu zu zeichnen. Dies kann aus einem der folgenden Gründe geschehen:

• repaint() oder update() wurde aufgerufen,
• das Widget war verdeckt und ist nun wieder sichtbar, oder
• aus vielen anderen Gründen.

Viele Widgets können auf Anfrage einfach ihre gesamte Oberfläche neu zeichnen, doch einige langsame Widgets müssen die Leistung optimieren, indem sie nur den angeforderten Bereich zeichnen: ` QPaintEvent::region()`. Diese Geschwindigkeitsoptimierung ändert nichts am Ergebnis, da das Zeichnen während der Ereignisverarbeitung auf diesen Bereich beschränkt wird. ` QListView ` und ` QTableView ` tun dies beispielsweise.

Qt versucht außerdem, das Zeichnen zu beschleunigen, indem mehrere Zeichnungsereignisse zu einem zusammengefasst werden. Wenn update() mehrmals aufgerufen wird oder das Fenstersystem mehrere Zeichnungsereignisse sendet, fasst Qt diese Ereignisse zu einem einzigen Ereignis mit einem größeren Bereich zusammen (siehe QRegion::united()). Die Funktion repaint() lässt diese Optimierung nicht zu, daher empfehlen wir, wann immer möglich update() zu verwenden.

Wenn das Zeichenereignis eintritt, wurde der Aktualisierungsbereich normalerweise bereits gelöscht, sodass Sie auf den Hintergrund des Widgets zeichnen.

Der Hintergrund kann mit „ setBackgroundRole()“ und „ setPalette()“ festgelegt werden.

Seit Qt 4.0 führt „ QWidget “ automatisch ein Double-Buffering beim Zeichnen durch, sodass es nicht notwendig ist, Code für das Double-Buffering in „paintEvent()“ zu schreiben, um Flackern zu vermeiden.

Siehe auch ` event()`, ` repaint()`, ` update()`, ` QPainter`, ` QPixmap`, ` QPaintEvent` und „Analog Clock“.

QWidget *QWidget::parentWidget() const

Gibt das übergeordnete Widget dieses Widgets zurück oder „ nullptr “, falls es kein übergeordnetes Widget hat.

QWidget *QWidget::previousInFocusChain() const

Die Funktion „previousInFocusChain“ gibt das vorherige Widget in der Fokus-Kette dieses Widgets zurück.

Siehe auch „ nextInFocusChain()“.

[slot] void QWidget::raise()

Bringt dieses Widget an den Anfang des Stapels des übergeordneten Widgets.

Nach diesem Aufruf befindet sich das Widget optisch vor allen überlappenden Geschwister-Widgets.

Siehe auch „ lower()“ und „ stackUnder()“.

void QWidget::releaseKeyboard()

Löst die Tastatursperre auf.

Siehe auch grabKeyboard(), grabMouse() und releaseMouse().

void QWidget::releaseMouse()

Löst die Mausbindung.

Siehe auch grabMouse(), grabKeyboard() und releaseKeyboard().

void QWidget::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 verfügt über andere Tastenkombinationen mit derselben Tastenfolge).

Siehe auch grabShortcut() und setShortcutEnabled().

void QWidget::removeAction(QAction *action)

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

Siehe auch „ insertAction()“ und „ actions()“.

void QWidget::render(QPaintDevice *target, const QPoint &targetOffset = QPoint(), const QRegion &sourceRegion = QRegion(), QWidget::RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren))

Rendert die „ sourceRegion “ dieses Widgets in die „ target “, wobei „ renderFlags “ zur Bestimmung der Darstellungsweise verwendet wird. Das Rendern beginnt bei „ targetOffset “ in der „ target “. Beispiel:

QPixmap pixmap(widget->size());
widget->render(&pixmap);

Wenn „ sourceRegion “ ein null-Bereich ist, verwendet diese Funktion „ QWidget::rect()“ als Bereich, d. h. das gesamte Widget.

Stellen Sie sicher, dass Sie vor dem Rendern QPainter::end() für den aktiven Painter des target -Geräts (falls vorhanden) aufrufen. Beispiel:

QPainter painter(this);
...
painter.end();
myWidget->render(this);

void QWidget::render(QPainter *painter, const QPoint &targetOffset = QPoint(), const QRegion &sourceRegion = QRegion(), QWidget::RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren))

Rendert das Widget in die „ QPainter::device “ des „ painter “ ().

Beim Rendern werden die auf das „ painter “ angewendeten Transformationen und Einstellungen verwendet.

Siehe auch QPainter::device().

[slot] void QWidget::repaint()

Zeichnet das Widget direkt neu, indem sofort ` paintEvent()` aufgerufen wird, es sei denn, Aktualisierungen sind deaktiviert oder das Widget ist ausgeblendet.

Wir empfehlen, `repaint()` nur zu verwenden, wenn eine sofortige Neuzeichnung erforderlich ist, beispielsweise während einer Animation. In den meisten Fällen ist ` update()` die bessere Wahl, da Qt dadurch die Geschwindigkeit optimieren und Flackern minimieren kann.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        widget, qOverload<>(&QWidget::repaint));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        widget, [receiver = widget]() { receiver->repaint(); });

Siehe auch „ update()“, „ paintEvent()“ und „ setUpdatesEnabled()“.

void QWidget::repaint(const QRect &rect)

Diese Version zeichnet ein Rechteck rect innerhalb des Widgets neu.

void QWidget::repaint(const QRegion &rgn)

Diese Version zeichnet einen Bereich rgn innerhalb des Widgets neu.

void QWidget::repaint(int x, int y, int w, int h)

Diese Version zeichnet ein Rechteck (x, y, w, h) innerhalb des Widgets neu.

Ist w negativ, wird es durch width() - x ersetzt, und ist h negativ, wird es durch height() - y ersetzt.

void QWidget::resize(int w, int h)

Dies entspricht resize(QSize(w, h)).

[virtual protected] void QWidget::resizeEvent(QResizeEvent *event)

Dieser Ereignis-Handler kann in einer Unterklasse neu implementiert werden, um Ereignisse zur Größenänderung des Widgets zu empfangen, die über den Parameter „ event “ übergeben werden. Wenn „resizeEvent()“ aufgerufen wird, verfügt das Widget bereits über seine neue Geometrie. Die alte Größe kann über „ QResizeEvent::oldSize()“ abgerufen werden.

Das Widget wird unmittelbar nach der Verarbeitung des Größenänderungsereignisses gelöscht und erhält ein Zeichnungsereignis. Innerhalb dieses Handlers muss (und sollte) keine Zeichnung erfolgen.

Siehe auch „ moveEvent()“, „ event()“, „ resize()“, „ QResizeEvent “, „ paintEvent()“ und das Scribble-Beispiel.

bool QWidget::restoreGeometry(const QByteArray &geometry)

Stellt die Geometrie und den Zustand der Widgets der obersten Ebene wieder her, die im Byte-Array „ geometry “ gespeichert sind. Gibt bei Erfolg „ true “ zurück; andernfalls wird „ false “ zurückgegeben.

Befindet sich die wiederhergestellte Geometrie außerhalb des Bildschirms, wird sie so angepasst, dass sie innerhalb der verfügbaren Bildschirmgeometrie liegt.

Um die mit ` QSettings` gespeicherte Geometrie wiederherzustellen, können Sie folgenden Code verwenden:

QSettings settings("MyCompany", "MyApp");
myWidget->restoreGeometry(settings.value("myWidget/geometry").toByteArray());

Einen Überblick über Geometrieprobleme bei Fenstern finden Sie in der Dokumentation zur Fenstergeometrie.

Verwenden Sie „ QMainWindow::restoreState()“, um die Geometrie sowie den Zustand von Symbolleisten und Andock-Widgets wiederherzustellen.

Siehe auch „ saveGeometry()“, „ QSettings “, „ QMainWindow::saveState()“ und „ QMainWindow::restoreState()“.

QByteArray QWidget::saveGeometry() const

Speichert die aktuelle Geometrie und den aktuellen Zustand von Widgets der obersten Ebene.

Um die Geometrie beim Schließen des Fensters zu speichern, können Sie ein Schließereignis wie folgt implementieren:

void MyWidget::closeEvent(QCloseEvent *event)
{
    QSettings settings("MyCompany", "MyApp");
    settings.setValue("geometry", saveGeometry());
    QWidget::closeEvent(event);
}

Einen Überblick über Geometrieprobleme bei Fenstern finden Sie in der Dokumentation zur Fenstergeometrie.

Verwenden Sie ` QMainWindow::saveState()` (), um die Geometrie und den Zustand von Symbolleisten und Dock-Widgets zu speichern.

Siehe auch ` restoreGeometry()`, ` QMainWindow::saveState()` und ` QMainWindow::restoreState()`.

QScreen *QWidget::screen() const

Gibt den Bildschirm zurück, auf dem sich das Widget befindet.

Siehe auch „ setScreen()“ und „ windowHandle()“.

void QWidget::scroll(int dx, int dy)

Scrollt das Widget einschließlich seiner untergeordneten Elemente um dx Pixel nach rechts und um dy nach unten. Sowohl dx als auch dy können negative Werte annehmen.

Nach dem Scrollen erhalten die Widgets Zeichnungsereignisse für die Bereiche, die neu gezeichnet werden müssen. Bei Widgets, die Qt als undurchsichtig erkennt, sind dies nur die neu sichtbaren Teile. Wenn beispielsweise ein undurchsichtiges Widget um 8 Pixel nach links gescrollt wird, muss nur ein 8 Pixel breiter Streifen am rechten Rand aktualisiert werden.

Da Widgets standardmäßig den Inhalt ihrer übergeordneten Elemente weitergeben, müssen Sie die Eigenschaft „ autoFillBackground “ setzen oder mit ` setAttribute()` das Attribut „ Qt::WA_OpaquePaintEvent “ festlegen, um ein Widget undurchsichtig zu machen.

Bei Widgets, die die Inhaltsweitergabe nutzen, führt ein Bildlauf zu einer Aktualisierung des gesamten Bildlaufbereichs.

Siehe auch „ Transparency and Double Buffering “.

void QWidget::scroll(int dx, int dy, const QRect &r)

Diese Version scrollt nur „ r “ und verschiebt die untergeordneten Elemente des Widgets nicht.

Ist „ r “ leer oder ungültig, ist das Ergebnis undefiniert.

Siehe auch QScrollArea.

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

Setzt das Attribut „ attribute “ für dieses Widget, wenn „ on “ auf „true“ gesetzt ist; andernfalls wird das Attribut gelöscht.

Siehe auch „ testAttribute()“.

void QWidget::setBackgroundRole(QPalette::ColorRole role)

Legt die Hintergrundrolle des Widgets auf „ role “ fest.

Die Hintergrundrolle definiert den Pinsel aus dem „ palette “ des Widgets, der zum Rendern des Hintergrunds verwendet wird.

Wenn „ role “ auf „ QPalette::NoRole “ gesetzt ist, übernimmt das Widget die Hintergrundrolle seines übergeordneten Widgets.

Beachten Sie, dass Stile beliebige Farben aus der Palette auswählen können. Sie können die Palette anpassen oder ein Stylesheet festlegen, wenn Sie mit `setBackgroundRole()` nicht das gewünschte Ergebnis erzielen.

Siehe auch „ backgroundRole()“ und „ foregroundRole()“.

void QWidget::setBaseSize(int basew, int baseh)

Dies entspricht setBaseSize(QSize(basew, baseh)). Legt die Grundgröße des Widgets auf die Breite basew und die Höhe baseh fest.

Siehe auch baseSize().

void QWidget::setContentsMargins(int left, int top, int right, int bottom)

Legt die Ränder um den Inhalt des Widgets mit den Größen left, top, right und bottom fest. Die Ränder werden vom Layout-System verwendet und können von Unterklassen genutzt werden, um den zu zeichnenden Bereich festzulegen (z. B. unter Ausschluss des Rahmens).

Eine Änderung der Ränder löst ein ` resizeEvent()` aus.

Siehe auch „ contentsRect()“ und „ contentsMargins()“.

void QWidget::setContentsMargins(const QMargins &margins)

Die Funktion `setContentsMargins` legt die Ränder um den Inhalt des Widgets fest.

Legt die Ränder um den Inhalt des Widgets so fest, dass ihre Größe durch ` margins` bestimmt wird. Die Ränder werden vom Layout-System verwendet und können von Unterklassen genutzt werden, um den zu zeichnenden Bereich festzulegen (z. B. unter Ausschluss des Rahmens).

Das Ändern der Ränder löst ein ` resizeEvent()` aus.

Siehe auch „ contentsRect()“ und „ contentsMargins()“.

[slot] void QWidget::setDisabled(bool disable)

Deaktiviert Eingabeereignisse für Widgets, wenn „ disable “ auf „true“ gesetzt ist; andernfalls werden Eingabeereignisse aktiviert.

Weitere Informationen finden Sie in der Dokumentation zu „ enabled “.

Siehe auch „ isEnabledTo()“, „ QKeyEvent “, „ QMouseEvent “ und „ changeEvent()“.

void QWidget::setFixedHeight(int h)

Setzt sowohl die minimale als auch die maximale Höhe des Widgets auf „ h “, ohne die Breiten zu ändern. Wird aus praktischen Gründen bereitgestellt.

Siehe auch sizeHint(), minimumSize(), maximumSize() und setFixedSize().

void QWidget::setFixedSize(const QSize &s)

Legt sowohl die Mindest- als auch die Höchstgröße des Widgets auf s fest und verhindert so, dass es jemals größer oder kleiner wird.

Dadurch werden die durch „ QLayout “ festgelegten Standardgrößenbeschränkungen überschrieben.

Um die Größenbeschränkungen aufzuheben, setzen Sie die Größe auf ` QWIDGETSIZE_MAX`.

Alternativ können Sie, wenn das Widget eine feste Größe basierend auf seinem Inhalt haben soll, „ QLayout::setSizeConstraint “ (QLayout::SetFixedSize) aufrufen;

Siehe auch maximumSize und minimumSize.

void QWidget::setFixedSize(int w, int h)

Legt die Breite des Widgets auf w und die Höhe auf h fest.

void QWidget::setFixedWidth(int w)

Setzt sowohl die minimale als auch die maximale Breite des Widgets auf w, ohne die Höhen zu ändern. Wird aus praktischen Gründen bereitgestellt.

Siehe auch „ sizeHint()“, „ minimumSize()“, „ maximumSize()“ und „ setFixedSize()“.

void QWidget::setFocus(Qt::FocusReason reason)

Weist diesem Widget (oder dessen Fokus-Proxy) den Tastatureingabefokus zu, wenn dieses Widget oder eines seiner übergeordneten Widgets das „ active window “ ist. Das Argument „ reason “ wird an jedes von dieser Funktion gesendete Fokusereignis übergeben und dient dazu, zu erklären, warum das Widget den Fokus erhalten hat. Ist das Fenster nicht aktiv, erhält das Widget den Fokus, sobald das Fenster aktiv wird.

Zunächst wird ein „Focus-Change“-Ereignis an das Fokus-Widget (sofern vorhanden) gesendet, um ihm mitzuteilen, dass es den Fokus verlieren wird. Anschließend wird der Fokus gewechselt: Ein „Focus-Out“-Ereignis wird an das bisherige Fokus-Element gesendet und ein „Focus-In“-Ereignis an das neue Element, um diesem mitzuteilen, dass es gerade den Fokus erhalten hat. (Es geschieht nichts, wenn das „Focus-In“- und das „Focus-Out“-Widget identisch sind.)

setFocus() vergibt den Fokus an ein Widget unabhängig von dessen Fokusrichtlinie, hebt jedoch keine Tastatursperre auf (siehe grabKeyboard()).

Beachten Sie, dass ein ausgeblendetes Widget den Fokus erst annimmt, wenn es angezeigt wird.

Siehe auch hasFocus(), clearFocus(), focusInEvent(), focusOutEvent(), setFocusPolicy(), focusWidget(), QApplication::focusWidget(), grabKeyboard(), grabMouse(), Tastaturfokus in Widgets und QEvent::RequestSoftwareInputPanel.

[slot] void QWidget::setFocus()

Weist diesem Widget (oder dessen Fokus-Proxy) den Tastatureingabefokus zu, wenn dieses Widget oder eines seiner übergeordneten Widgets die „ active window “ ist.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        widget, qOverload<>(&QWidget::setFocus));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        widget, [receiver = widget]() { receiver->setFocus(); });

void QWidget::setFocusProxy(QWidget *w)

Setzt den Fokus-Proxy des Widgets auf das Widget „ w “. Wenn „ w “ auf „ nullptr “ gesetzt ist, setzt die Funktion dieses Widget so zurück, dass es keinen Fokus-Proxy mehr hat.

Manche Widgets können zwar „den Fokus haben“, erstellen jedoch ein untergeordnetes Widget, wie z. B. QLineEdit, um den Fokus tatsächlich zu verwalten. In diesem Fall kann das Widget das Zeileneingabefeld als seinen Fokus-Proxy festlegen.

setFocusProxy() legt das Widget fest, das tatsächlich den Fokus erhält, wenn „dieses Widget“ den Fokus erhält. Wenn ein Fokus-Proxy vorhanden ist, wirken sich setFocus() und hasFocus() auf den Fokus-Proxy aus. Ist „dieses Widget“ das Fokus-Widget, verlagert setFocusProxy() den Fokus auf den neuen Fokus-Proxy.

Siehe auch ` focusProxy()`.

void QWidget::setForegroundRole(QPalette::ColorRole role)

Legt die Vordergrundfarbe des Widgets auf „ role “ fest.

Die Vordergrundrolle definiert die Farbe aus der „ palette “ des Widgets, die zum Zeichnen des Vordergrunds verwendet wird.

Wenn „ role “ auf „ QPalette::NoRole “ gesetzt ist, verwendet das Widget eine Vordergrundrolle, die sich von der Hintergrundrolle abhebt.

Beachten Sie, dass Stile beliebige Farben aus der Palette auswählen können. Sie können die Palette anpassen oder ein Stylesheet festlegen, wenn Sie mit `setForegroundRole()` nicht das gewünschte Ergebnis erzielen.

Siehe auch „ foregroundRole()“ und „ backgroundRole()“.

void QWidget::setGeometry(int x, int y, int w, int h)

Dies entspricht setGeometry(QRect(x, y, w, h)).

Siehe auch ` geometry()`.

void QWidget::setGraphicsEffect(QGraphicsEffect *effect)

Die Funktion „setGraphicsEffect“ dient zum Festlegen des Grafikeffekts des Widgets.

Legt „ effect “ als Effekt des Widgets fest. Wenn auf diesem Widget bereits ein Effekt installiert ist, löscht „ QWidget “ den vorhandenen Effekt, bevor der neue Effekt „ effect “ installiert wird.

Wenn „ effect “ bereits als Effekt auf einem anderen Widget installiert ist, entfernt „setGraphicsEffect()“ den Effekt von diesem Widget und installiert ihn auf diesem Widget.

QWidget übernimmt die Eigentumsrechte an „ effect “.

Siehe auch ` graphicsEffect()`.

[slot] void QWidget::setHidden(bool hidden)

Hilfsfunktion, entspricht setVisible(!hidden).

Siehe auch isHidden().

void QWidget::setLayout(QLayout *layout)

Legt den Layout-Manager für dieses Widget auf „ layout “ fest.

Wenn auf diesem Widget bereits ein Layout-Manager installiert ist, lässt „ QWidget “ die Installation eines weiteren nicht zu. Sie müssen zunächst den vorhandenen Layout-Manager (der von ` layout()` zurückgegeben wird) löschen, bevor Sie `setLayout()` mit dem neuen Layout aufrufen können.

Wenn „ layout “ der Layout-Manager eines anderen Widgets ist, ordnet „setLayout()“ das Layout neu zu und macht es zum Layout-Manager für dieses Widget.

Beispiel:

QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(formWidget);
formWidget->setLayout(layout);

Eine Alternative zum Aufruf dieser Funktion besteht darin, dieses Widget an den Konstruktor des Layouts zu übergeben.

Der „ QWidget “ übernimmt dann die Verantwortung für „ layout “.

Siehe auch ` layout()` und „Layout-Verwaltung“.

void QWidget::setMask(const QBitmap &bitmap)

Sorgt dafür, dass nur die Pixel des Widgets sichtbar sind, für die „ bitmap “ ein entsprechendes 1-Bit enthält. Wenn der Bereich Pixel außerhalb des „ rect()“ des Widgets umfasst, sind die Steuerelemente des Fenstersystems in diesem Bereich je nach Plattform möglicherweise sichtbar oder auch nicht.

Beachten Sie, dass dieser Effekt langsam sein kann, wenn der Bereich besonders komplex ist.

Der folgende Code zeigt, wie ein Bild mit einem Alphakanal verwendet werden kann, um eine Maske für ein Widget zu erzeugen:

QLabel topLevelLabel;
QPixmap pixmap(":/images/tux.png");
topLevelLabel.setPixmap(pixmap);
topLevelLabel.setMask(pixmap.mask());

Das durch diesen Code angezeigte Label wird mithilfe des darin enthaltenen Bildes maskiert, wodurch der Eindruck entsteht, dass ein unregelmäßig geformtes Bild direkt auf den Bildschirm gezeichnet wird.

Maskierte Widgets empfangen Mausereignisse nur auf ihren sichtbaren Bereichen.

Siehe auch mask(), clearMask() und windowOpacity().

void QWidget::setMask(const QRegion &region)

Sorgt dafür, dass nur die Teile des Widgets sichtbar sind, die sich mit region überschneiden. Wenn der Bereich Pixel außerhalb des rect() des Widgets umfasst, sind die Steuerelemente des Fenstersystems in diesem Bereich je nach Plattform möglicherweise sichtbar oder auch nicht.

Da mit ` QRegion ` beliebig komplexe Bereiche erstellt werden können, lassen sich Widget-Masken auch für Fenster mit äußerst ungewöhnlichen Formen anpassen und ermöglichen sogar die Anzeige von Widgets mit Aussparungen. Beachten Sie, dass dieser Effekt langsam sein kann, wenn der Bereich besonders komplex ist.

Widget-Masken dienen dazu, dem Fenstersystem mitzuteilen, dass die Anwendung keine Mausereignisse für Bereiche außerhalb der Maske wünscht. Auf den meisten Systemen führen sie zudem zu grober visueller Beschneidung. Um glatte Fensterkanten zu erhalten, verwenden Sie stattdessen einen durchscheinenden Hintergrund und Anti-Aliasing, wie im Beispiel „Translucent Background“ gezeigt.

Siehe auch „ windowOpacity “.

void QWidget::setMaximumSize(int maxw, int maxh)

Diese Funktion entspricht setMaximumSize(QSize(maxw, maxh)). Legt die maximale Breite auf maxw und die maximale Höhe auf maxh fest.

Siehe auch „ maximumSize()“.

void QWidget::setMinimumSize(int minw, int minh)

Diese Funktion entspricht setMinimumSize(QSize(minw, minh)). Legt die Mindestbreite auf minw und die Mindesthöhe auf minh fest.

Siehe auch minimumSize().

void QWidget::setParent(QWidget *parent)

Setzt das übergeordnete Element des Widgets auf „ parent “ und setzt die Fensterflags zurück. Das Widget wird an die Position (0, 0) in seinem neuen übergeordneten Element verschoben.

Befindet sich das neue übergeordnete Widget in einem anderen Fenster, werden das Widget mit dem geänderten übergeordneten Element und seine untergeordneten Elemente am Ende der „ tab chain “ des neuen übergeordneten Widgets angehängt, und zwar in derselben internen Reihenfolge wie zuvor. Hatte eines der verschobenen Widgets den Tastaturfokus, ruft `setParent()` für dieses Widget die Methode ` clearFocus()` auf.

Befindet sich das neue übergeordnete Widget im selben Fenster wie das alte übergeordnete Widget, ändert das Festlegen des übergeordneten Widgets weder die Tabulatorreihenfolge noch den Tastaturfokus.

Ist das „neue“ übergeordnete Widget das alte übergeordnete Widget, führt diese Funktion keine Aktion aus.

Siehe auch ` setWindowFlags()`.

void QWidget::setParent(QWidget *parent, Qt::WindowFlags f)

Diese Funktion nimmt außerdem Widget-Flags ( f ) als Argument entgegen.

void QWidget::setScreen(QScreen *screen)

Legt den Bildschirm fest, auf dem das Widget angezeigt werden soll: screen.

Die Festlegung des Bildschirms ist nur für Fenster sinnvoll. Falls erforderlich, wird das Fenster des Widgets unter screen neu erstellt.

Siehe auch „ screen()“ und „ QWindow::setScreen()“.

void QWidget::setShortcutAutoRepeat(int id, bool enable = true)

Wenn „ enable “ auf „true“ gesetzt ist, ist die automatische Wiederholung des Tastenkürzels mit dem angegebenen „ id “ aktiviert; andernfalls ist sie deaktiviert.

Siehe auch „ grabShortcut()“ und „ releaseShortcut()“.

void QWidget::setShortcutEnabled(int id, bool enable = true)

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

Siehe auch „ grabShortcut “ () und „ releaseShortcut “ ().

void QWidget::setSizeIncrement(int w, int h)

Legt die Schrittweite für die x-Achse (Breite) auf w und die Schrittweite für die y-Achse (Höhe) auf h fest.

Siehe auch sizeIncrement().

void QWidget::setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical)

Legt die Größenrichtlinie des Widgets auf „ horizontal “ und „ vertical “ fest, mit standardmäßiger Dehnung und ohne „height-for-width“.

Siehe auch ` sizePolicy()` und ` QSizePolicy::QSizePolicy()`.

void QWidget::setStyle(QStyle *style)

Setzt den GUI-Stil des Widgets auf „ style “. Die Eigentumsrechte am Stilobjekt werden nicht übertragen.

Wenn kein Stil festgelegt ist, verwendet das Widget stattdessen den Stil der Anwendung, „ QApplication::style()“.

Das Festlegen eines Stils für ein Widget hat keine Auswirkungen auf bestehende oder zukünftige untergeordnete Widgets.

Siehe auch style(), QStyle, QApplication::style() und QApplication::setStyle().

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

Fügt das Widget „ second “ in der Fokusreihenfolge hinter das Widget „ first “ ein.

Dadurch wird das Widget „ second “ effektiv aus seiner Fokus-Kette entfernt und hinter dem Widget „ first “ eingefügt.

Beachten Sie, dass sich die Tabulatorreihenfolge des Widgets „ second “ 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 “ oder „ second “ über einen Fokus-Proxy verfügt, ersetzt `setTabOrder()` diesen Proxy korrekt.

Siehe auch „ setFocusPolicy()“, „ setFocusProxy()“ und „Tastaturfokus in Widgets“.

[static, since 6.6] void QWidget::setTabOrder(std::initializer_list<QWidget *> widgets)

Legt die Tabulatorreihenfolge für die Widgets in der Liste „ widgets “ fest, indem für jedes aufeinanderfolgende Widget-Paar die Funktion ` QWidget::setTabOrder(QWidget *, QWidget *)` aufgerufen wird.

Anstatt jedes Paar manuell wie folgt einzurichten:

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

können Sie Folgendes aufrufen:

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

Der Aufruf erzeugt keine geschlossene Tabulator-Fokus-Schleife. Wenn weitere Widgets mit der Fokusrichtlinie „ Qt::TabFocus “ vorhanden sind, wird durch Drücken der Tabulatortaste auf „ d “ der Fokus auf eines dieser Widgets verschoben und nicht zurück zu „ a “.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch setFocusPolicy(), setFocusProxy() und Tastaturfokus in Widgets.

void QWidget::setWindowFlag(Qt::WindowType flag, bool on = true)

Setzt das Fenster-Flag „ flag “ für dieses Widget, wenn „ on “ wahr ist; andernfalls wird das Flag zurückgesetzt.

Siehe auch setWindowFlags(), windowFlags() und windowType().

void QWidget::setWindowRole(const QString &role)

Setzt die Rolle des Fensters auf „ role “. Dies ist nur für Fenster unter X11 sinnvoll.

Siehe auch ` windowRole()`.

void QWidget::setWindowState(Qt::WindowStates windowState)

Setzt den Fensterstatus auf „ windowState “. Der Fensterstatus ist eine logische ODER-Verknüpfung aus „ Qt::WindowState “, „ Qt::WindowMinimized “, „ Qt::WindowMaximized “, „ Qt::WindowFullScreen “ und „ Qt::WindowActive “.

Ist das Fenster nicht sichtbar (d. h. „ isVisible()“ gibt „ false “ zurück), wird der Fensterstatus wirksam, sobald „ show()“ aufgerufen wird. Bei sichtbaren Fenstern erfolgt die Änderung sofort. Um beispielsweise zwischen Vollbild- und Normalmodus umzuschalten, verwenden Sie den folgenden Code:

w->setWindowState(w->windowState() ^ Qt::WindowFullScreen);

Um ein minimiertes Fenster wiederherzustellen und zu aktivieren (unter Beibehaltung seines maximierten und/oder Vollbild-Zustands), verwenden Sie Folgendes:

w->setWindowState((w->windowState() & ~Qt::WindowMinimized) | Qt::WindowActive);

Der Aufruf dieser Funktion blendet das Widget aus. Sie müssen ` show()` aufrufen, um das Widget wieder sichtbar zu machen.

Wenn sich der Fensterzustand ändert, erhält das Widget einen Aufruf von ` changeEvent()` vom Typ ` QEvent::WindowStateChange`.

Siehe auch ` Qt::WindowState ` und ` windowState()`.

void QWidget::setupUi(QWidget *widget)

Richtet die Benutzeroberfläche für das angegebene „ widget “ ein.

Siehe auch „Verwenden einer UI-Datei des Qt Widgets -Designers in Ihrer Anwendung“.

[slot] void QWidget::show()