QQuickWindow Class

Dokumentation der Mitgliedsfunktionen

[explicit] QQuickWindow::QQuickWindow(QQuickRenderControl *control)

Erstellt ein Fenster zur Anzeige einer QML-Szene, deren Darstellung vom Objekt „ control “ gesteuert wird. Weitere Informationen finden Sie in der Dokumentation unter QQuickRenderControl.

[explicit] QQuickWindow::QQuickWindow(QWindow *parent = nullptr)

Erstellt ein Fenster zur Anzeige einer QML-Szene, wobei das übergeordnete Fenster parent ist.

[override virtual noexcept] QQuickWindow::~QQuickWindow()

Löscht das Fenster.

[override virtual] QAccessibleInterface *QQuickWindow::accessibleRoot() const

Gibt eine Barrierefreiheitsschnittstelle für dieses Fenster zurück oder 0, wenn eine solche Schnittstelle nicht erstellt werden kann.

[signal] void QQuickWindow::afterAnimating()

Dieses Signal wird im GUI-Thread ausgesendet, bevor der Render-Thread aufgefordert wird, die Synchronisation des Szenengraphen durchzuführen.

Im Gegensatz zu anderen ähnlichen Signalen wird dieses Signal im GUI-Thread statt im Render-Thread ausgesendet. Es kann verwendet werden, um externe Animationssysteme mit dem QML-Inhalt zu synchronisieren. Gleichzeitig bedeutet dies, dass dieses Signal nicht zum Auslösen von Grafikoperationen geeignet ist.

[signal, since 6.0] void QQuickWindow::afterFrameEnd()

Dieses Signal wird ausgelöst, wenn der Szenenbaum einen Frame übermittelt hat. Es wird nach allen anderen damit zusammenhängenden Signalen, wie beispielsweise „ afterRendering()“, ausgelöst. Es ist das letzte Signal, das vom Rendering-Thread des Szenenbaums beim Rendern eines Frames ausgelöst wird.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch beforeFrameBegin() und rendererInterface().

[signal] void QQuickWindow::afterRenderPassRecording()

Dieses Signal wird ausgegeben, nachdem der Szenengraf die Befehle für seinen Haupt-Render-Durchlauf aufgezeichnet hat, der Durchlauf im Befehlspuffer jedoch noch nicht abgeschlossen ist.

Dieses Signal wird früher ausgelöst als „ afterRendering()“ und garantiert, dass nicht nur der Frame, sondern auch die Aufzeichnung des Hauptrenderdurchlaufs des Szenengrafiks noch aktiv ist. Dies ermöglicht das Einfügen von Befehlen, ohne einen gesamten, separaten Renderdurchlauf generieren zu müssen (was normalerweise die angehängten Bilder löschen würde). Die nativen Grafikobjekte können über „ QSGRendererInterface “ abgefragt werden.

Siehe auch rendererInterface() und „Scene Graph – RHI“ unter QML.

[signal] void QQuickWindow::afterRendering()

afterRenderPassRecording beforeRendering beforeRenderPassRecording beforeRenderingDas Signal wird ausgesendet, nachdem der Szenengraph seine Befehle in den Befehlspuffer eingefügt hat, der noch nicht an die Grafikwarteschlange übergeben wurde. Falls gewünscht, kann die mit diesem Signal verbundene Slot-Funktion über ` QSGRendererInterface` zuvor native Ressourcen wie den Befehlspuffer abfragen. Beachten Sie jedoch, dass der Render-Durchlauf (oder die Durchläufe) zu diesem Zeitpunkt bereits aufgezeichnet sind und es nicht möglich ist, weitere Befehle innerhalb des Durchlaufs des Szenengraphen hinzuzufügen. afterRenderPassRecording

Siehe auch „ rendererInterface()“, „Szenengrafik – RHI unter QML“, „Szenengrafik – OpenGL unter QML“, „Szenengrafik – Metal unter QML“, „Szenengrafik – Vulkan unter QML“ und „Szenengrafik – Direct3D 11 unter QML“.

[signal] void QQuickWindow::afterSynchronizing()

Dieses Signal wird ausgelöst, nachdem der Szenengraph mit dem QML-Zustand synchronisiert wurde.

Dieses Signal kann verwendet werden, um die nach dem Aufruf von ` QQuickItem::updatePaintNode()` erforderlichen Vorbereitungen zu treffen, solange der GUI-Thread noch gesperrt ist.

Bei Verwendung von OpenGL wird zu diesem Zeitpunkt der vom Szenenbaum für das Rendering verwendete ` QOpenGLContext ` gebunden.

[signal, since 6.0] void QQuickWindow::beforeFrameBegin()

Dieses Signal wird ausgesendet, bevor der Szenengraph mit der Vorbereitung des Bildes beginnt. Es geht Signalen wie „ beforeSynchronizing()“ oder „ beforeRendering()“ voraus. Es ist das früheste Signal, das vom Rendering-Thread des Szenengraphen ausgesendet wird, wenn dieser mit der Vorbereitung eines neuen Bildes beginnt.

Dieses Signal ist für Grafik-Frameworks auf niedrigerer Ebene relevant, die bestimmte Operationen, wie z. B. die Bereinigung von Ressourcen, in einer Phase ausführen müssen, in der ` Qt Quick ` die Aufzeichnung eines neuen Frames über die zugrunde liegenden Rendering-Hardware-Schnittstellen-APIs noch nicht initiiert hat.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch ` afterFrameEnd()` und ` rendererInterface()`.

[signal] void QQuickWindow::beforeRenderPassRecording()

Dieses Signal wird ausgesendet, bevor der Szenengrafik-Baum mit der Aufzeichnung von Befehlen für den Hauptrenderdurchlauf beginnt. (Ebenen haben ihre eigenen Durchläufe und sind zum Zeitpunkt der Aussendung dieses Signals bereits vollständig aufgezeichnet.) Der Renderdurchlauf ist zum Zeitpunkt der Aussendung des Signals bereits im Befehlspuffer aktiv.

Dieses Signal wird später als „ beforeRendering()“ ausgesendet und garantiert, dass nicht nur der Frame, sondern auch die Aufzeichnung des Hauptrenderdurchlaufs des Szenengraphen aktiv ist. Dies ermöglicht das Einfügen von Befehlen, ohne einen vollständigen, separaten Renderdurchlauf generieren zu müssen (was normalerweise die angehängten Bilder löschen würde). Die nativen Grafikobjekte können über „ QSGRendererInterface “ abgefragt werden.

Siehe auch „ rendererInterface()“ und „Szenengrafik – RHI unter QML“.

[signal] void QQuickWindow::beforeRendering()

Dieses Signal wird ausgegeben, nachdem die Vorbereitungen für das Bild abgeschlossen sind, d. h., es liegt gegebenenfalls ein Befehlspuffer im Aufnahmemodus vor. Falls gewünscht, kann die mit diesem Signal verbundene Slot-Funktion native Ressourcen wie den Befehl zuvor über „ QSGRendererInterface “ abfragen. Beachten Sie jedoch, dass die Aufzeichnung des Hauptrender-Durchgangs zu diesem Zeitpunkt noch nicht begonnen hat und es nicht möglich ist, Befehle innerhalb dieses Durchgangs hinzuzufügen. Das Starten eines Durchgangs bedeutet das Löschen der Farb-, Tiefen- und Stencil-Puffer, sodass es nicht möglich ist, eine Unterlags-Rendering-Art zu erzielen, indem man sich lediglich an dieses Signal anschließt. Schließen Sie sich stattdessen an „ beforeRenderPassRecording()“ an. Die Verbindung zu diesem Signal ist jedoch weiterhin wichtig, wenn die Aufzeichnung von Befehlen vom Typ „copy“ gewünscht wird, da diese nicht innerhalb eines Render-Durchgangs in die Warteschlange gestellt werden können.

Siehe auch „ rendererInterface()“, „Szenengrafik – RHI unter QML“, „Szenengrafik – OpenGL unter QML“, „Szenengrafik – Metal unter QML“, „Szenengrafik – Vulkan unter QML“ und „Szenengrafik – Direct3D 11 unter QML“.

[signal] void QQuickWindow::beforeSynchronizing()

Dieses Signal wird ausgesendet, bevor der Szenengraph mit dem QML-Zustand synchronisiert wird.

Auch wenn das Signal vom Rendering-Thread des Szenengraphen ausgesendet wird, wird garantiert, dass der GUI-Thread blockiert wird, genau wie bei ` QQuickItem::updatePaintNode()`. Daher ist es sicher, in einem Slot oder Lambda, der mit ` Qt::DirectConnection` verbunden ist, auf Daten des GUI-Threads zuzugreifen.

Dieses Signal kann verwendet werden, um alle erforderlichen Vorbereitungen vor dem Aufruf von ` QQuickItem::updatePaintNode()` zu treffen.

Bei Verwendung von OpenGL wird an dieser Stelle das für das Rendering durch den Szenenbaum verwendete ` QOpenGLContext ` gebunden.

void QQuickWindow::beginExternalCommands()

Wenn Rohgrafikbefehle (OpenGL, Vulkan, Metal usw.) mit dem Rendering über den Szenengraphen kombiniert werden, muss diese Funktion aufgerufen werden, bevor Befehle in den Befehlspuffer geschrieben werden, den der Szenengraph zum Rendern seines Hauptrenderdurchgangs verwendet. Damit soll eine Überschreibung des Status verhindert werden.

In der Praxis wird diese Funktion häufig aus einem Slot aufgerufen, der mit den Signalen „ beforeRenderPassRecording()“ oder „ afterRenderPassRecording()“ verbunden ist.

Die Funktion muss nicht aufgerufen werden, wenn Befehle in den anwendungsspezifischen Befehlspuffer geschrieben werden (z. B. einen VkCommandBuffer oder MTLCommandBuffer + MTLRenderCommandEncoder, der von der Anwendung erstellt und verwaltet wird und nicht aus dem Szenenbaum stammt). Bei Grafik-APIs, bei denen kein natives Befehlspuffer-Konzept bereitgestellt wird (OpenGL, Direct 3D 11), bieten „beginExternalCommands()“ und „ endExternalCommands()“ gemeinsam einen Ersatz für die Qt-5-Funktion „resetOpenGLState()“.

Der Aufruf dieser Funktion und von ` endExternalCommands()` ist innerhalb der ` render()`-Implementierung eines „ QSGRenderNode “ nicht erforderlich, da der Szenenbaum die notwendigen Schritte für Render-Knoten implizit ausführt.

Auf native Grafikobjekte (wie z. B. Grafikgeräte, Befehlspuffer oder Encoder) kann über ` QSGRendererInterface::getResource()` zugegriffen werden.

Siehe auch „ endExternalCommands()“ und „ QQuickOpenGLUtils::resetOpenGLState()“.

[override virtual protected] void QQuickWindow::closeEvent(QCloseEvent *e)

Implementiert: ` QWindow::closeEvent(QCloseEvent *ev)`.

QSGImageNode *QQuickWindow::createImageNode() const

Erstellt einen einfachen Bildknoten. Wenn der Szenengraf noch nicht initialisiert ist, ist der Rückgabewert null.

Dies ist eine backendübergreifende Alternative zur direkten Erstellung eines „ QSGSimpleTextureNode “.

Siehe auch „ QSGImageNode “.

QSGNinePatchNode *QQuickWindow::createNinePatchNode() const

Erstellt einen „Nine-Patch“-Knoten. Wenn der Szenengraf noch nicht initialisiert ist, ist der Rückgabewert null.

QSGRectangleNode *QQuickWindow::createRectangleNode() const

Erstellt einen einfachen Rechteck-Knoten. Ist der Szenengraph nicht initialisiert, ist der Rückgabewert null.

Dies ist eine backendübergreifende Alternative zur direkten Erstellung eines ` QSGSimpleRectNode `.

Siehe auch „ QSGRectangleNode “.

[since 6.7] QSGTextNode *QQuickWindow::createTextNode() const

Erstellt einen Textknoten. Wenn der Szenengraph nicht initialisiert ist, ist der Rückgabewert null.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch QSGTextNode.

QSGTexture *QQuickWindow::createTextureFromImage(const QImage &image, QQuickWindow::CreateTextureOptions options) const

Erstellt ein neues ` QSGTexture ` aus dem übergebenen ` image`. Verfügt das Bild über einen Alphakanal, so verfügt auch die entsprechende Textur über einen Alphakanal.

Der Aufrufer der Funktion ist für das Löschen der zurückgegebenen Textur verantwortlich. Das zugrunde liegende native Texturobjekt wird dann zusammen mit dem ` QSGTexture` zerstört.

Wenn ` options ` den Wert ` TextureCanUseAtlas` enthält, kann die Engine das Bild in einen Texturatlas einfügen. Texturen in einem Atlas müssen für ihre Geometrie auf ` QSGTexture::normalizedTextureSubRect()` zurückgreifen und unterstützen ` QSGTexture::Repeat` nicht. Andere Werte aus ` CreateTextureOption ` werden ignoriert.

Wenn „ options “ den Wert „ TextureIsOpaque “ enthält, erstellt die Engine eine RGB-Textur, die bei „ QSGTexture::hasAlphaChannel()“ den Wert „false“ zurückgibt. Opake Texturen lassen sich in den meisten Fällen schneller rendern. Ist dieses Flag nicht gesetzt, verfügt die Textur über einen Alphakanal, der auf dem Bildformat basiert.

Wenn ` options ` den Wert ` TextureHasMipmaps` enthält, erstellt die Engine eine Textur, die Mipmap-Filterung nutzen kann. Mipmap-Texturen können nicht in einem Atlas enthalten sein.

Die Einstellung von ` TextureHasAlphaChannel ` auf ` options ` hat für diese Funktion keine Auswirkung, da standardmäßig von einem Alphakanal und einer Überblendung ausgegangen wird. Um dies zu deaktivieren, setzen Sie ` TextureIsOpaque`.

Wenn der Szenengraph OpenGL verwendet, nutzt die zurückgegebene Textur „ GL_TEXTURE_2D “ als Texturziel und „ GL_RGBA “ als internes Format. Bei anderen Grafik-APIs ist das Texturformat in der Regel „ RGBA8 “. Implementieren Sie „ QSGTexture “ neu, um Texturen mit anderen Parametern zu erstellen.

Diese Funktion kann sowohl vom Haupt- als auch vom Render-Thread aus aufgerufen werden.

Siehe auch ` sceneGraphInitialized()` und ` QSGTexture`.

QSGTexture *QQuickWindow::createTextureFromImage(const QImage &image) const

[since 6.6] QSGTexture *QQuickWindow::createTextureFromRhiTexture(QRhiTexture *texture, QQuickWindow::CreateTextureOptions options = {}) const

Erstellt ein neues ` QSGTexture ` aus dem übergebenen ` texture`.

Verwenden Sie ` options `, um die Texturattribute anzupassen. Diese Funktion berücksichtigt ausschließlich das Flag ` TextureHasAlphaChannel `. Ist dieses gesetzt, wird das resultierende ` QSGTexture ` vom Szenengraph-Renderer stets so behandelt, als ob ein Blending erforderlich wäre. Bei vollständig opaken Texturen kann das Weglassen des Flags die Kosten für die Durchführung eines Alpha-Blendings während des Renderings einsparen. Das Flag steht in keinem direkten Zusammenhang mit dem „ format “ des „ QRhiTexture “, d. h., es ist völlig normal, das Flag nicht zu setzen, während ein Texturformat wie das häufig verwendete „ QRhiTexture::RGBA8 “ verwendet wird.

Das Mipmapping wird nicht über „ options “ gesteuert, da „ texture “ bereits erstellt wurde und das Vorhandensein oder Fehlen von Mipmaps bereits fest eingebettet ist.

Das zurückgegebene ` QSGTexture ` besitzt das ` QRhiTexture`, was bedeutet, dass ` texture ` zusammen mit dem zurückgegebenen ` QSGTexture` zerstört wird.

Ob „ texture “ Eigentümer seiner zugrunde liegenden nativen Grafikressourcen (OpenGL-Texturobjekt, Vulkan-Bild usw.) ist, hängt davon ab, wie „ QRhiTexture “ erstellt wurde (QRhiTexture::create() oder QRhiTexture::createFrom()), und wird von dieser Funktion weder gesteuert noch geändert.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch createTextureFromImage(), sceneGraphInitialized() und QSGTexture.

[signal, since 6.11] void QQuickWindow::devicePixelRatioChanged()

Dieses Signal wird ausgegeben, wenn sich das effektive Bildpunktverhältnis des Geräts geändert hat.

Diese Funktion wurde in Qt 6.11 eingeführt.

Siehe auch ` effectiveDevicePixelRatio()`.

qreal QQuickWindow::effectiveDevicePixelRatio() const

Gibt das Gerätepixelverhältnis für dieses Fenster zurück.

Dies unterscheidet sich von ` QWindow::devicePixelRatio()` dadurch, dass es das umgeleitete Rendering über ` QQuickRenderControl ` und ` QQuickRenderTarget` unterstützt. Bei Verwendung eines ` QQuickRenderControl` wird das ` QQuickWindow ` oft nicht vollständig erstellt, was bedeutet, dass es nie angezeigt wird und kein zugrunde liegendes natives Fenster im Fenstersystem erstellt wird. Infolgedessen kann die Abfrage von Eigenschaften wie dem Gerätepixelverhältnis keine korrekten Ergebnisse liefern. Diese Funktion berücksichtigt sowohl ` QQuickRenderControl::renderWindowFor()` als auch ` QQuickRenderTarget::devicePixelRatio()`. Wenn keine Umleitung aktiv ist, entspricht das Ergebnis dem von ` QWindow::devicePixelRatio()`.

Siehe auch „ QQuickRenderControl“ , „ QQuickRenderTarget “, „ setRenderTarget()“ und „ QWindow::devicePixelRatio()“.

void QQuickWindow::endExternalCommands()

Wenn Rohgrafikbefehle (OpenGL, Vulkan, Metal usw.) mit dem Rendering über den Szenengraphen kombiniert werden, muss diese Funktion aufgerufen werden, nachdem die Befehle in den Befehlspuffer geschrieben wurden, den der Szenengraph zum Rendern seines Hauptrenderdurchgangs verwendet. Damit soll eine Überschreibung des Status verhindert werden.

In der Praxis wird diese Funktion häufig aus einem Slot aufgerufen, der mit den Signalen „ beforeRenderPassRecording()“ oder „ afterRenderPassRecording()“ verbunden ist.

Die Funktion muss nicht aufgerufen werden, wenn Befehle in den anwendungsspezifischen Befehlspuffer geschrieben werden (z. B. einen VkCommandBuffer oder MTLCommandBuffer + MTLRenderCommandEncoder, der von der Anwendung erstellt und verwaltet wird und nicht aus dem Szenenbaum stammt). Bei Grafik-APIs, bei denen kein natives Befehlspuffer-Konzept bereitgestellt wird (OpenGL, Direct 3D 11), bilden „ beginExternalCommands()“ und „endExternalCommands()“ zusammen einen Ersatz für die Qt-5-Funktion „resetOpenGLState()“.

Der Aufruf dieser Funktion und von ` beginExternalCommands()` ist innerhalb der ` render()`-Implementierung eines ` QSGRenderNode ` nicht erforderlich, da der Szenenbaum die notwendigen Schritte für Render-Knoten implizit durchführt.

Siehe auch ` beginExternalCommands()` und ` QQuickOpenGLUtils::resetOpenGLState()`.

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

Implementiert: ` QWindow::event(QEvent *ev)`.

[override virtual protected] void QQuickWindow::exposeEvent(QExposeEvent *)

Implementiert: ` QWindow::exposeEvent` (`QExposeEvent *ev`).

[override virtual protected] void QQuickWindow::focusInEvent(QFocusEvent *ev)

Umsetzt: ` QWindow::focusInEvent(QFocusEvent *ev)`.

[override virtual protected] void QQuickWindow::focusOutEvent(QFocusEvent *ev)

Umsetzt: ` QWindow::focusOutEvent(QFocusEvent *ev)`.

[signal] void QQuickWindow::frameSwapped()

Dieses Signal wird ausgegeben, wenn ein Frame zur Darstellung in die Warteschlange gestellt wurde. Bei aktivierter vertikaler Synchronisation wird das Signal in einer kontinuierlich animierten Szene höchstens einmal pro vsync-Intervall ausgegeben.

Dieses Signal wird vom Rendering-Thread des Szenengraphen ausgegeben.

QImage QQuickWindow::grabWindow()

Ruft den Inhalt des Fensters ab und gibt ihn als Bild zurück.

Die Funktion `grabWindow()` kann auch aufgerufen werden, wenn das Fenster nicht sichtbar ist. Voraussetzung hierfür ist, dass das Fenster ` created ` ist, eine gültige Größe hat und keine anderen ` QQuickWindow `-Instanzen im selben Prozess gerendert werden.

[static, since 6.0] QSGRendererInterface::GraphicsApi QQuickWindow::graphicsApi()

Gibt die Grafik-API zurück, die vom Szenengraphen verwendet würde, wenn dieser zu diesem Zeitpunkt initialisiert würde.

Die übliche Vorgehensweise, um die vom Szenengraphen verwendete API abzufragen, besteht darin, ` QSGRendererInterface::graphicsApi()` aufzurufen, sobald der Szenengraph initialisiert ist, beispielsweise wenn oder nachdem das Signal ` sceneGraphInitialized()` ausgesendet wurde. In diesem Fall erhält man das tatsächliche, echte Ergebnis, da dann bekannt ist, dass alles korrekt unter Verwendung dieser Grafik-API initialisiert wurde.

Dies ist jedoch nicht immer praktikabel. Wenn die Anwendung externe Frameworks einrichten muss oder mit ` setGraphicsDevice()` in einer Weise arbeiten muss, die von der integrierten API-Auswahl-Logik des Szenengraphen abhängt, ist es nicht immer möglich, solche Operationen aufzuschieben, bis das Signal ` QQuickWindow ` sichtbar gemacht oder ` QQuickRenderControl::initialize()` aufgerufen wurde.

Daher wird diese statische Funktion als Gegenstück zu ` setGraphicsApi()` bereitgestellt: Sie kann jederzeit aufgerufen werden, und das Ergebnis spiegelt wider, welche API der Szenengraph wählen würde, wenn er zum Zeitpunkt des Aufrufs initialisiert würde.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch ` setGraphicsApi()`.

[since 6.0] QQuickGraphicsConfiguration QQuickWindow::graphicsConfiguration() const

Gibt das an „ setGraphicsConfiguration()“ übergebene „ QQuickGraphicsConfiguration “ zurück oder andernfalls ein standardmäßig initialisiertes Exemplar.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch ` setGraphicsConfiguration()`.

[since 6.0] QQuickGraphicsDevice QQuickWindow::graphicsDevice() const

Gibt das an „ setGraphicsDevice()“ übergebene „ QQuickGraphicsDevice “ zurück, andernfalls ein standardmäßig konstruiertes Objekt

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch ` setGraphicsDevice()`.

const QQuickWindow::GraphicsStateInfo &QQuickWindow::graphicsStateInfo()

Gibt eine Referenz auf eine „ GraphicsStateInfo “-Struktur zurück, die einen Teil des internen Zustands des RHI beschreibt, insbesondere den Status der doppelten oder dreifachen Pufferung des Backends (z. B. der Vulkan- oder Metal-Integrationen). Dies ist relevant, wenn die zugrunde liegenden Grafik-APIs Vulkan oder Metal sind und der externe Rendering-Code eine doppelte oder dreifache Pufferung seiner sich häufig ändernden Ressourcen, wie z. B. Uniform-Buffer, durchführen möchte, um ein Blockieren der Pipeline zu vermeiden.

[static] bool QQuickWindow::hasDefaultAlphaBuffer()

Gibt zurück, ob bei neu erstellten Fenstern Alpha-Transparenz verwendet werden soll.

Siehe auch „ setDefaultAlphaBuffer()“.

[override virtual protected] void QQuickWindow::hideEvent(QHideEvent *)

Implementiert: ` QWindow::hideEvent(QHideEvent *ev)`.

QQmlIncubationController *QQuickWindow::incubationController() const

Gibt einen Inkubations-Controller zurück, der die Inkubation zwischen den Frames für dieses Fenster einfügt. „ QQuickView “ installiert diesen Controller automatisch für Sie; andernfalls müssen Sie ihn selbst mithilfe von „ QQmlEngine::setIncubationController()“ installieren.

Der Controller gehört zum Fenster und wird gelöscht, wenn das Fenster geschlossen wird.

bool QQuickWindow::isPersistentGraphics() const

Gibt zurück, ob wichtige Grafikressourcen während der Laufzeit von ` QQuickWindow` freigegeben werden können.

Siehe auch ` setPersistentGraphics()`.

bool QQuickWindow::isPersistentSceneGraph() const

Gibt zurück, ob die Knoten und Ressourcen des Szenengrafiks während der Lebensdauer dieses ` QQuickWindow` freigegeben werden können.

bool QQuickWindow::isSceneGraphInitialized() const

Gibt „true“ zurück, wenn der Szenengraph initialisiert wurde; andernfalls „false“.

[override virtual protected] void QQuickWindow::keyPressEvent(QKeyEvent *e)

Implementiert: ` QWindow::keyPressEvent(QKeyEvent *ev)`.

[override virtual protected] void QQuickWindow::keyReleaseEvent(QKeyEvent *e)

Implementiert: ` QWindow::keyReleaseEvent(QKeyEvent *ev)`.

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

Implementiert: ` QWindow::mouseDoubleClickEvent(QMouseEvent *ev)`.

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

Implementiert: ` QWindow::mouseMoveEvent(QMouseEvent *ev)`.

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

Implementiert: ` QWindow::mousePressEvent(QMouseEvent *ev)`.

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

Implementiert: ` QWindow::mouseReleaseEvent(QMouseEvent *ev)`.

[slot] void QQuickWindow::releaseResources()

Diese Funktion versucht, überflüssige Ressourcen freizugeben, die derzeit von der QML-Szene belegt sind.

Der Aufruf dieser Funktion fordert den Szenengraphen auf, zwischengespeicherte Grafikressourcen wie Grafik-Pipeline-Objekte, Shader-Programme oder Bilddaten freizugeben.

Darüber hinaus kann diese Funktion je nach verwendeter Render-Schleife dazu führen, dass der Szenengraph und alle fensterbezogenen Rendering-Ressourcen freigegeben werden. In diesem Fall wird das Signal „ sceneGraphInvalidated()“ ausgesendet, wodurch Benutzer ihre eigenen Grafikressourcen bereinigen können. Die Funktionen „ setPersistentGraphics()“ und „ setPersistentSceneGraph()“ können verwendet werden, um dies zu verhindern, falls die Aufräumung in der Anwendung nicht durchführbar ist – allerdings auf Kosten eines höheren Speicherverbrauchs.

Siehe auch „ sceneGraphInvalidated()“, „ setPersistentGraphics()“ und „ setPersistentSceneGraph()“.

[since 6.0] QQuickRenderTarget QQuickWindow::renderTarget() const

Gibt das an ` setRenderTarget()` übergebene ` QQuickRenderTarget ` zurück oder andernfalls ein standardmäßig initialisiertes Exemplar

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch ` setRenderTarget()`.

QSGRendererInterface *QQuickWindow::rendererInterface() const

Gibt die aktuelle Renderer-Schnittstelle zurück. Der Wert ist immer gültig und niemals null.

Siehe auch „ QSGRenderNode “ und „ QSGRendererInterface “.

[override virtual protected] void QQuickWindow::resizeEvent(QResizeEvent *ev)

Implementiert: ` QWindow::resizeEvent(QResizeEvent *ev)`.

[since 6.6] QRhi *QQuickWindow::rhi() const

Gibt das „ QRhi “-Objekt zurück, das von diesem Fenster für die Darstellung verwendet wird.

Nur verfügbar, wenn das Fenster die Qt 3D-API und die Shading-Sprachabstraktionen verwendet; das bedeutet, dass das Ergebnis bei Verwendung der „ software “-Anpassung immer null ist.

Das Ergebnis ist nur gültig, wenn die Darstellung initialisiert wurde, was durch die Emission des Signals ` sceneGraphInitialized()` angezeigt wird. Vor diesem Zeitpunkt ist der zurückgegebene Wert `null`. Bei einer regulären, bildschirmbasierten Darstellung ( QQuickWindow ) erfolgt die Initialisierung der Szenengrafik in der Regel, wenn das native Fenster zum ersten Mal angezeigt wird. Bei Verwendung von ` QQuickRenderControl` erfolgt die Initialisierung durch den expliziten Aufruf von ` initialize()`.

In der Praxis ist diese Funktion eine Abkürzung für die Abfrage von ` QRhi ` über ` QSGRendererInterface`.

Diese Funktion wurde in Qt 6.6 eingeführt.

[signal] void QQuickWindow::sceneGraphAboutToStop()

Dieses Signal wird im Render-Thread ausgelöst, wenn der Szenengraph kurz davor ist, das Rendern zu beenden. Dies geschieht in der Regel, weil das Fenster ausgeblendet wurde.

Anwendungen können dieses Signal nutzen, um Ressourcen freizugeben, sollten jedoch darauf vorbereitet sein, diese schnell wieder instanziieren zu müssen. Der Szenenbaum und der Grafikkontext werden zu diesem Zeitpunkt noch nicht freigegeben.

Siehe auch sceneGraphInvalidated().

[static] QString QQuickWindow::sceneGraphBackend()

Gibt das angeforderte „ Qt Quick “-Scenegraph-Backend zurück.

Siehe auch setSceneGraphBackend().

[signal] void QQuickWindow::sceneGraphError(QQuickWindow::SceneGraphError error, const QString &message)

Dieses Signal wird ausgegeben, wenn während der Initialisierung des Szenengraphen ein „ error “ aufgetreten ist.

Anwendungen sollten sich an dieses Signal anschließen, wenn sie Fehler, wie z. B. Fehler beim Erstellen des Grafikkontexts, auf benutzerdefinierte Weise behandeln möchten. Wenn kein Slot an das Signal angeschlossen ist, verhält sich das Programm anders: Quick gibt das message aus oder zeigt ein Meldungsfeld an und beendet die Anwendung.

Dieses Signal wird vom GUI-Thread ausgegeben.

[signal] void QQuickWindow::sceneGraphInitialized()

Dieses Signal wird ausgelöst, wenn der Szenenbaum initialisiert wurde.

Dieses Signal wird vom Rendering-Thread des Szenengraphen ausgegeben.

[signal] void QQuickWindow::sceneGraphInvalidated()

Dieses Signal wird ausgelöst, wenn der Szenengraph ungültig gemacht wurde.

Dieses Signal bedeutet, dass der verwendete Grafik-Rendering-Kontext ungültig geworden ist und alle mit diesem Kontext verknüpften Benutzerressourcen freigegeben werden sollten.

Beim Rendern mit OpenGL wird der „ QOpenGLContext “ dieses Fensters beim Aufruf dieser Funktion gebunden. Die einzige Ausnahme besteht darin, dass das native OpenGL außerhalb der Kontrolle von Qt zerstört wurde, beispielsweise durch EGL_CONTEXT_LOST.

Dieses Signal wird vom Rendering-Thread des Szenengraphen ausgesendet.

void QQuickWindow::scheduleRenderJob(QRunnable *job, QQuickWindow::RenderStage stage)

Plant die Ausführung von „ job “, sobald die Darstellung dieses Fensters den angegebenen Wert „ stage “ erreicht.

Dies ist eine Erleichterung gegenüber den entsprechenden Signalen in „ QQuickWindow “ für einmalige Aufgaben.

Das Fenster übernimmt die Verantwortung für ` job ` und löscht es, sobald der Auftrag abgeschlossen ist.

Wird das Rendern beendet, bevor „ job “ ausgeführt werden kann, wird der Auftrag ausgeführt und anschließend im Rahmen der Bereinigung des Szenengraphen gelöscht. Wird das Fenster nie angezeigt und findet kein Rendern statt, bevor „ QQuickWindow “ zerstört wird, werden alle ausstehenden Aufträge zerstört, ohne dass ihre `run()`-Methode aufgerufen wird.

Wenn das Rendern in einem anderen Thread stattfindet, wird der Job im Rendering-Thread ausgeführt.

Ist „ stage “ auf „ NoStage “ gesetzt, wird „ job “ bei der ersten sich bietenden Gelegenheit ausgeführt, sobald der Render-Thread nicht mit dem Rendern eines Frames beschäftigt ist. Ist das Fenster zum Zeitpunkt der Übermittlung oder Bearbeitung des Jobs nicht sichtbar und nicht renderbar, wird der Job gelöscht, ohne dass die „run()“-Methode ausgeführt wird. Wird ein nicht-threadbasierter Renderer verwendet, wird die run()-Methode des Jobs synchron ausgeführt. Beim Rendern mit OpenGL wird der OpenGL-Kontext vor der Ausführung eines Jobs – einschließlich „ NoStage “-Jobs – auf den Kontext des Renderers umgestellt.

Siehe auch „ beforeRendering()“, „ afterRendering()“, „ beforeSynchronizing()“, „ afterSynchronizing()“, „ frameSwapped()“ und „ sceneGraphInvalidated()“.

[static] void QQuickWindow::setDefaultAlphaBuffer(bool useAlpha)

useAlpha Legt fest, ob bei neu erstellten Fenstern Alpha-Transparenz verwendet werden soll.

In jeder Anwendung, in der durchsichtige Fenster erstellt werden sollen, muss dieser Wert vor dem Erstellen des ersten ` QQuickWindow` auf `true` gesetzt werden. Der Standardwert ist `false`.

Siehe auch ` hasDefaultAlphaBuffer()`.

[static, since 6.0] void QQuickWindow::setGraphicsApi(QSGRendererInterface::GraphicsApi api)

Fordert die angegebene Grafik api ation an.

Wenn die integrierte Standard-Grafikadaptation verwendet wird, legt ` api ` fest, welche Grafik-API (OpenGL, Vulkan, Metal oder Direct3D) der Szenenbaum zum Rendern verwenden soll. Darüber hinaus ist das Backend „ software “ ebenfalls integriert und kann durch Setzen von ` api ` auf ` QSGRendererInterface::Software` angefordert werden.

Im Gegensatz zu ` setSceneGraphBackend()`, das nur zur Anforderung eines bestimmten Backends (entweder integriert oder als dynamisch geladene Plugins installiert) verwendet werden kann, arbeitet diese Funktion mit dem übergeordneten Konzept der Grafik-APIs. Sie deckt die Backends ab, die mit „ Qt Quick “ ausgeliefert werden, und verfügt daher über entsprechende Werte in der Enumeration ` QSGRendererInterface::GraphicsApi `.

Wird diese Funktion überhaupt nicht aufgerufen und ist auch die entsprechende Umgebungsvariable ` QSG_RHI_BACKEND ` nicht gesetzt, wählt der Szenengraph die zu verwendende Grafik-API basierend auf der Plattform aus.

Diese Funktion ist besonders wichtig in Anwendungen, die ausschließlich für das Rendern mit einer bestimmten API ausgelegt sind. Wenn die Anwendung beispielsweise natives OpenGL- oder Vulkan-Rendering durchführt, muss sichergestellt werden, dass Qt Quick ebenfalls mit OpenGL oder Vulkan rendert. Von solchen Anwendungen wird erwartet, dass sie diese Funktion frühzeitig in ihrer `main()`-Funktion aufrufen.

Um abzufragen, welche Grafik-API der Szenenbaum zum Rendern verwendet, rufen Sie ` QSGRendererInterface::graphicsApi()` nach dem Szenenbaum ` has initialized` auf, was typischerweise entweder dann geschieht, wenn das Fenster zum ersten Mal sichtbar wird, oder wenn ` QQuickRenderControl::initialize()` aufgerufen wird.

Um zum Standardverhalten zurückzukehren, bei dem der Szenenbaum die Grafik-API basierend auf der Plattform und anderen Bedingungen auswählt, setzen Sie ` api ` auf ` QSGRendererInterface::Unknown`.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch ` graphicsApi()`.

[since 6.0] void QQuickWindow::setGraphicsConfiguration(const QQuickGraphicsConfiguration &config)

Legt die Grafikkonfiguration für dieses Fenster fest. „ config “ enthält verschiedene Einstellungen, die vom Szenengraphen bei der Initialisierung der zugrunde liegenden Grafikgeräte und -kontexte berücksichtigt werden können.

Eine solche zusätzliche Konfiguration, die beispielsweise festlegt, welche Geräteerweiterungen für Vulkan aktiviert werden sollen, wird relevant und unerlässlich, wenn nativer Grafik-Rendering-Code integriert wird, der auf bestimmte Erweiterungen angewiesen ist. Dasselbe gilt für die Integration mit externen 3D- oder VR-Engines wie beispielsweise OpenXR.

QQuickGraphicsConfiguration Instanzen werden implizit gemeinsam genutzt, sind kopierbar und können als Wert übergeben werden.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch graphicsConfiguration().

[since 6.0] void QQuickWindow::setGraphicsDevice(const QQuickGraphicsDevice &device)

Legt die Grafikgeräteobjekte für dieses Fenster fest. Der Szenengrafikbaum verwendet vorhandene Geräte-, physikalische Geräte- und andere Objekte, die über ` device ` angegeben wurden, anstatt neue zu erstellen.

Diese Funktion wird sehr häufig in Kombination mit ` QQuickRenderControl ` und ` setRenderTarget()` verwendet, um das Rendering von ` Qt Quick ` in eine Textur umzuleiten.

Ein standardmäßig initialisiertes ` QQuickGraphicsDevice ` ändert das Standardverhalten in keiner Weise. Sobald ein ` device `, das über eine der QQuickGraphicsDevice -Factory-Funktionen wie beispielsweise ` QQuickGraphicsDevice::fromDeviceObjects()` erstellt wurde, übergeben wird und der Szenengrafikbaum eine passende Grafik-API verwendet (im Beispiel von `fromDeviceObjects()` wäre dies Vulkan), verwendet der Szenengrafikbaum die vorhandenen Geräteobjekte (wie z. B. „ VkPhysicalDevice “, „ VkDevice “ und den Index der Grafikwarteschlangenfamilie im Fall von Vulkan), die von „ QQuickGraphicsDevice “ gekapselt sind. Dies ermöglicht die Verwendung desselben Geräts und somit die gemeinsame Nutzung von Ressourcen wie Puffern und Texturen zwischen „ Qt Quick “ und nativen Rendering-Engines.

Als Beispiel, diesmal mit Direct3D, wird die typische Verwendung voraussichtlich wie folgt aussehen:

// native graphics resources set up by a custom D3D rendering engine
ID3D11Device *device;
ID3D11DeviceContext *context;
ID3D11Texture2D *texture;
...
// now to redirect Qt Quick content into 'texture' we could do the following:
QQuickRenderControl *renderControl = new QQuickRenderControl;
QQuickWindow *window = new QQuickWindow(renderControl); // this window will never be shown on-screen
...
window->setGraphicsDevice(QQuickGraphicsDevice::fromDeviceAndContext(device, context));
renderControl->initialize();
window->setRenderTarget(QQuickRenderTarget::fromD3D11Texture(texture, textureSize);
...

Der entscheidende Aspekt bei der Verwendung dieser Funktion besteht darin, sicherzustellen, dass Ressourcen oder Handles zu Ressourcen – wie beispielsweise ` texture ` im obigen Beispiel – sowohl für die externe Rendering-Engine als auch für den Scenegraph-Renderer sichtbar und nutzbar sind. Dies erfordert die Verwendung desselben Grafikgeräts (oder bei OpenGL eines OpenGL-Kontexts).

QQuickGraphicsDevice Instanzen werden implizit gemeinsam genutzt, sind kopierbar und können als Wert übergeben werden. Sie besitzen nicht die zugehörigen nativen Objekte (wie beispielsweise das `ID3D11Device` im Beispiel).

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch ` graphicsDevice()`, ` QQuickRenderControl`, ` setRenderTarget()` und ` setGraphicsApi()`.

void QQuickWindow::setPersistentGraphics(bool persistent)

Legt fest, ob die Grafikressourcen (Grafikgerät oder -kontext, Swapchain, Puffer, Texturen) beibehalten werden sollen und erst freigegeben werden können, wenn das letzte Fenster gelöscht wurde, und zwar über ` persistent`. Der Standardwert ist `true`.

Beim Aufruf von ` releaseResources()` oder wenn das Fenster ausgeblendet wird (genauer gesagt, nicht mehr renderbar ist), haben einige Render-Schleifen die Möglichkeit, alle Grafikressourcen freizugeben, nicht nur die im Cache gespeicherten. Dies kann vorübergehend Speicher freigeben, bedeutet aber auch, dass die Render-Engine eine vollständige, potenziell aufwendige Neuinitialisierung der Ressourcen durchführen muss, wenn das Fenster erneut gerendert werden soll.

Siehe auch ` isPersistentGraphics()`, ` setPersistentSceneGraph()`, ` sceneGraphInitialized()`, ` sceneGraphInvalidated()` und ` releaseResources()`.

void QQuickWindow::setPersistentSceneGraph(bool persistent)

Legt fest, ob die Knoten und Ressourcen des Szenengraphen „ persistent “ sind. „Persistent“ bedeutet, dass die Knoten und Ressourcen nicht freigegeben werden können. Der Standardwert ist „ true “.

Beim Aufruf von ` releaseResources()` haben einige Render-Schleifen die Möglichkeit, die Knoten des Szenengraphen und die zugehörigen Grafikressourcen freizugeben, wenn das Fenster ausgeblendet wird (genauer gesagt, wenn es nicht renderbar ist). Dadurch wird vorübergehend Speicher freigegeben, was jedoch auch bedeutet, dass der Szenengraph beim nächsten Rendern des Fensters neu aufgebaut werden muss.

Siehe auch isPersistentSceneGraph(), setPersistentGraphics(), sceneGraphInvalidated(), sceneGraphInitialized() und releaseResources().

[since 6.0] void QQuickWindow::setRenderTarget(const QQuickRenderTarget &target)

Legt „ target “ als Renderziel für dieses Fenster fest.

Ein ` QQuickRenderTarget ` dient als undurchsichtiger Handle für ein darstellbares natives Objekt – meist eine 2D-Textur – sowie für zugehörige Metadaten, wie beispielsweise die Größe in Pixeln.

Ein standardmäßig erstelltes ` QQuickRenderTarget ` bedeutet, dass keine Umleitung stattfindet. Ein gültiges ` target`, das über eine der statischen Factory-Funktionen ` QQuickRenderTarget ` erstellt wurde, ermöglicht hingegen die Umleitung der Darstellung der ` Qt Quick `-Szene: Diese zielt dann nicht mehr auf die Farbpuffer der mit dem Fenster verknüpften Oberfläche ab, sondern auf die in ` target` angegebenen Texturen oder anderen Grafikobjekte.

Angenommen, der Szenengrafikbaum nutzt Vulkan zum Rendern, so kann man seine Ausgabe beispielsweise in ein ` VkImage` umleiten. Bei Grafik-APIs wie Vulkan muss zudem das Bildlayout angegeben werden. ` QQuickRenderTarget `-Instanzen werden implizit gemeinsam genutzt, sind kopierbar und können als Wert übergeben werden. Sie besitzen jedoch nicht die zugehörigen nativen Objekte (wie beispielsweise das `VkImage` im Beispiel).

QQuickRenderTarget rt = QQuickRenderTarget::fromVulkanImage(vulkanImage, VK_IMAGE_LAYOUT_PREINITIALIZED, pixelSize);
quickWindow->setRenderTarget(rt);

Diese Funktion wird sehr häufig in Kombination mit ` QQuickRenderControl ` und einem unsichtbaren ` QQuickWindow` verwendet, um Inhalte von ` Qt Quick ` in eine Textur zu rendern, ohne dafür ein natives Fenster auf dem Bildschirm für dieses ` QQuickWindow` zu erstellen.

Wenn sich das gewünschte Ziel oder zugehörige Daten, wie beispielsweise die Größe, ändern, rufen Sie diese Funktion mit einem neuen ` QQuickRenderTarget` auf. Das Erstellen von ` QQuickRenderTarget `-Instanzen und der Aufruf dieser Funktion sind ressourcenschonend, beachten Sie jedoch, dass das Festlegen eines neuen ` target ` mit einem anderen nativen Objekt oder anderen Daten zu potenziell ressourcenintensiven Initialisierungsschritten führen kann, wenn der Szenengrafikbaum im Begriff ist, das nächste Bild zu rendern. Ändern Sie das Ziel daher nur, wenn es notwendig ist.

Diese Funktion wurde in Qt 6.0 eingeführt.

Siehe auch „ renderTarget()“, „ QQuickRenderControl “, „ setGraphicsDevice()“ und „ setGraphicsApi()“.

[static] void QQuickWindow::setSceneGraphBackend(const QString &backend)

Fordert eine „ Qt Quick “-Szenengrafik an backend. Backends können entweder integriert sein oder in Form von dynamisch geladenen Plugins installiert werden.

Weitere Informationen zur Liste der Backends finden Sie unter „Zwischen Anpassungen in Ihrer Anwendung wechseln “. Ist „ backend “ ungültig oder tritt ein Fehler auf, wird die Anforderung ignoriert.

Siehe auch sceneGraphBackend().

[static] void QQuickWindow::setTextRenderType(QQuickWindow::TextRenderType renderType)

Legt den Standard-Rendertyp für textähnliche Elemente in „ Qt Quick “ auf „ renderType “ fest.

Siehe auch textRenderType().

[override virtual protected] void QQuickWindow::showEvent(QShowEvent *)

Implementiert: ` QWindow::showEvent(QShowEvent *ev)`.

[since 6.6] QRhiSwapChain *QQuickWindow::swapChain() const

Gibt den von diesem Fenster verwendeten „ QRhiSwapChain “ zurück, sofern vorhanden.

Diese Funktion wurde in Qt 6.6 eingeführt.

[override virtual protected] void QQuickWindow::tabletEvent(QTabletEvent *event)

Implementiert: ` QWindow::tabletEvent(QTabletEvent *ev)`.

[static] QQuickWindow::TextRenderType QQuickWindow::textRenderType()

Gibt den Darstellungstyp von textähnlichen Elementen in „ Qt Quick “ zurück. Der Standardwert ist „ QQuickWindow::QtTextRendering “.

Siehe auch setTextRenderType().

[slot] void QQuickWindow::update()

Plant die Darstellung eines weiteren Frames im Fenster ein.

Der Aufruf von `QQuickWindow::update()` unterscheidet sich von ` QQuickItem::update()` darin, dass er immer eine Neuzeichnung auslöst, unabhängig davon, ob sich der zugrunde liegende Szenenbaum geändert hat oder nicht.

[override virtual protected] void QQuickWindow::wheelEvent(QWheelEvent *event)

Umsetzt: ` QWindow::wheelEvent(QWheelEvent *ev)`.