QQuickWindow Class

Member Function Documentation

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

Constructs a window for displaying a QML scene with parent window parent.

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

Constructs a window for displaying a QML scene, whose rendering will be controlled by the control object. Please refer to QQuickRenderControl's documentation for more information.

[override virtual] QQuickWindow::~QQuickWindow()

Destroys the window.

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

Returns an accessibility interface for this window, or 0 if such an interface cannot be created.

[signal] void QQuickWindow::afterAnimating()

This signal is emitted on the GUI thread before requesting the render thread to perform the synchronization of the scene graph.

Unlike the other similar signals, this one is emitted on the GUI thread instead of the render thread. It can be used to synchronize external animation systems with the QML content. At the same time this means that this signal is not suitable for triggering graphics operations.

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

This signal is emitted when the scene graph has submitted a frame. This is emitted after all other related signals, such as afterRendering(). It is the last signal that is emitted by the scene graph rendering thread when rendering a frame.

This function was introduced in Qt 6.0.

See also beforeFrameBegin() and rendererInterface().

[signal] void QQuickWindow::afterRenderPassRecording()

This signal is emitted after the scenegraph has recorded the commands for its main render pass, but the pass is not yet finalized on the command buffer.

This signal is emitted earlier than afterRendering(), and it guarantees that not just the frame but also the recording of the scenegraph's main render pass is still active. This allows inserting commands without having to generate an entire, separate render pass (which would typically clear the attached images). The native graphics objects can be queried via QSGRendererInterface.

See also rendererInterface().

[signal] void QQuickWindow::afterRendering()

The signal is emitted after scene graph has added its commands to the command buffer, which is not yet submitted to the graphics queue. If desired, the slot function connected to this signal can query native resources, like the command buffer, before via QSGRendererInterface. Note however that the render pass (or passes) are already recorded at this point and it is not possible to add more commands within the scenegraph's pass. Instead, use afterRenderPassRecording() for that. This signal has therefore limited use in Qt 6, unlike in Qt 5. Rather, it is the combination of beforeRendering() and beforeRenderPassRecording(), or beforeRendering() and afterRenderPassRecording(), that is typically used to achieve under- or overlaying of the custom rendering.

When using OpenGL, the QOpenGLContext used for rendering by the scene graph will be bound at this point.

See also rendererInterface(), Scene Graph - OpenGL Under QML, Scene Graph - Metal Under QML, Scene Graph - Vulkan Under QML, and Scene Graph - Direct3D 11 Under QML.

[signal] void QQuickWindow::afterSynchronizing()

This signal is emitted after the scene graph is synchronized with the QML state.

This signal can be used to do preparation required after calls to QQuickItem::updatePaintNode(), while the GUI thread is still locked.

When using OpenGL, the QOpenGLContext used for rendering by the scene graph will be bound at this point.

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

This signal is emitted before the scene graph starts preparing the frame. This precedes signals like beforeSynchronizing() or beforeRendering(). It is the earliest signal that is emitted by the scene graph rendering thread when starting to prepare a new frame.

This signal is relevant for lower level graphics frameworks that need to execute certain operations, such as resource cleanup, at a stage where Qt Quick has not initiated the recording of a new frame via the underlying rendering hardware interface APIs.

This function was introduced in Qt 6.0.

See also afterFrameEnd() and rendererInterface().

[signal] void QQuickWindow::beforeRenderPassRecording()

This signal is emitted before the scenegraph starts recording commands for the main render pass. (Layers have their own passes and are fully recorded by the time this signal is emitted.) The render pass is already active on the command buffer when the signal is emitted.

This signal is emitted later than beforeRendering() and it guarantees that not just the frame, but also the recording of the scenegraph's main render pass is active. This allows inserting commands without having to generate an entire, separate render pass (which would typically clear the attached images). The native graphics objects can be queried via QSGRendererInterface.

See also rendererInterface().

[signal] void QQuickWindow::beforeRendering()

This signal is emitted after the preparations for the frame have been done, meaning there is a command buffer in recording mode, where applicable. If desired, the slot function connected to this signal can query native resources like the command before via QSGRendererInterface. Note however that the recording of the main render pass is not yet started at this point and it is not possible to add commands within that pass. Starting a pass means clearing the color, depth, and stencil buffers so it is not possible to achieve an underlay type of rendering by just connecting to this signal. Rather, connect to beforeRenderPassRecording(). However, connecting to this signal is still important if the recording of copy type of commands is desired since those cannot be enqueued within a render pass.

When using OpenGL, the QOpenGLContext used for rendering by the scene graph will be bound at this point.

See also rendererInterface(), Scene Graph - OpenGL Under QML, Scene Graph - Metal Under QML, Scene Graph - Vulkan Under QML, and Scene Graph - Direct3D 11 Under QML.

[signal] void QQuickWindow::beforeSynchronizing()

This signal is emitted before the scene graph is synchronized with the QML state.

Even though the signal is emitted from the scene graph rendering thread, the GUI thread is guaranteed to be blocked, like it is in QQuickItem::updatePaintNode(). Therefore, it is safe to access GUI thread thread data in a slot or lambda that is connected with Qt::DirectConnection.

This signal can be used to do any preparation required before calls to QQuickItem::updatePaintNode().

When using OpenGL, the QOpenGLContext used for rendering by the scene graph will be bound at this point.

void QQuickWindow::beginExternalCommands()

When mixing raw graphics (OpenGL, Vulkan, Metal, etc.) commands with scene graph rendering, it is necessary to call this function before recording commands to the command buffer used by the scene graph to render its main render pass. This is to avoid clobbering state.

In practice this function is often called from a slot connected to the beforeRenderPassRecording() or afterRenderPassRecording() signals.

The function does not need to be called when recording commands to the application's own command buffer (such as, a VkCommandBuffer or MTLCommandBuffer + MTLRenderCommandEncoder created and managed by the application, not retrieved from the scene graph). With graphics APIs where no native command buffer concept is exposed (OpenGL, Direct 3D 11), beginExternalCommands() and endExternalCommands() together provide a replacement for the Qt 5 resetOpenGLState() function.

Calling this function and endExternalCommands() is not necessary within the render() implementation of a QSGRenderNode because the scene graph performs the necessary steps implicitly for render nodes.

Native graphics objects (such as, graphics device, command buffer or encoder) are accessible via QSGRendererInterface::getResource().

See also endExternalCommands() and QQuickOpenGLUtils::resetOpenGLState().

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

Reimplements: QWindow::closeEvent(QCloseEvent *ev).

QSGImageNode *QQuickWindow::createImageNode() const

Creates a simple image node. When the scenegraph is not initialized, the return value is null.

This is cross-backend alternative to constructing a QSGSimpleTextureNode directly.

See also QSGImageNode.

QSGNinePatchNode *QQuickWindow::createNinePatchNode() const

Creates a nine patch node. When the scenegraph is not initialized, the return value is null.

QSGRectangleNode *QQuickWindow::createRectangleNode() const

Creates a simple rectangle node. When the scenegraph is not initialized, the return value is null.

This is cross-backend alternative to constructing a QSGSimpleRectNode directly.

See also QSGRectangleNode.

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

Creates a new QSGTexture from the supplied image. If the image has an alpha channel, the corresponding texture will have an alpha channel.

The caller of the function is responsible for deleting the returned texture. The underlying native texture object is then destroyed together with the QSGTexture.

When options contains TextureCanUseAtlas, the engine may put the image into a texture atlas. Textures in an atlas need to rely on QSGTexture::normalizedTextureSubRect() for their geometry and will not support QSGTexture::Repeat. Other values from CreateTextureOption are ignored.

When options contains TextureIsOpaque, the engine will create an RGB texture which returns false for QSGTexture::hasAlphaChannel(). Opaque textures will in most cases be faster to render. When this flag is not set, the texture will have an alpha channel based on the image's format.

When options contains TextureHasMipmaps, the engine will create a texture which can use mipmap filtering. Mipmapped textures can not be in an atlas.

When the scene graph uses OpenGL, the returned texture will be using GL_TEXTURE_2D as texture target and GL_RGBA as internal format. With other graphics APIs, the texture format is typically RGBA8. Reimplement QSGTexture to create textures with different parameters.

This function can be called from any thread.

See also sceneGraphInitialized() and QSGTexture.

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

This is an overloaded function.

qreal QQuickWindow::effectiveDevicePixelRatio() const

Returns the device pixel ratio for this window.

This is different from QWindow::devicePixelRatio() in that it supports redirected rendering via QQuickRenderControl and QQuickRenderTarget. When using a QQuickRenderControl, the QQuickWindow is often not fully created, meaning it is never shown and there is no underlying native window created in the windowing system. As a result, querying properties like the device pixel ratio cannot give correct results. This function takes into account both QQuickRenderControl::renderWindowFor() and QQuickRenderTarget::devicePixelRatio(). When no redirection is in effect, the result is same as QWindow::devicePixelRatio().

See also QQuickRenderControl, QQuickRenderTarget, setRenderTarget(), and QWindow::devicePixelRatio().

void QQuickWindow::endExternalCommands()

When mixing raw graphics (OpenGL, Vulkan, Metal, etc.) commands with scene graph rendering, it is necessary to call this function after recording commands to the command buffer used by the scene graph to render its main render pass. This is to avoid clobbering state.

In practice this function is often called from a slot connected to the beforeRenderPassRecording() or afterRenderPassRecording() signals.

The function does not need to be called when recording commands to the application's own command buffer (such as, a VkCommandBuffer or MTLCommandBuffer + MTLRenderCommandEncoder created and managed by the application, not retrieved from the scene graph). With graphics APIs where no native command buffer concept is exposed (OpenGL, Direct 3D 11), beginExternalCommands() and endExternalCommands() together provide a replacement for the Qt 5 resetOpenGLState() function.

Calling this function and beginExternalCommands() is not necessary within the render() implementation of a QSGRenderNode because the scene graph performs the necessary steps implicitly for render nodes.

See also beginExternalCommands() and QQuickOpenGLUtils::resetOpenGLState().

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

Reimplements: QWindow::event(QEvent *ev).

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

Reimplements: QWindow::exposeEvent(QExposeEvent *ev).

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

Reimplements: QWindow::focusInEvent(QFocusEvent *ev).

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

Reimplements: QWindow::focusOutEvent(QFocusEvent *ev).

[signal] void QQuickWindow::frameSwapped()

This signal is emitted when a frame has been queued for presenting. With vertical synchronization enabled the signal is emitted at most once per vsync interval in a continuously animating scene.

This signal will be emitted from the scene graph rendering thread.

QImage QQuickWindow::grabWindow()

Grabs the contents of the window and returns it as an image.

It is possible to call the grabWindow() function when the window is not visible. This requires that the window is created and has a valid size and that no other QQuickWindow instances are rendering in the same process.

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

Returns the graphics API that would be used by the scene graph if it was initialized at this point in time.

The standard way to query the API used by the scene graph is to use QSGRendererInterface::graphicsApi() once the scene graph has initialized, for example when or after the sceneGraphInitialized() signal is emitted. In that case one gets the true, real result, because then it is known that everything was initialized correctly using that graphics API.

This is not always convenient. If the application needs to set up external frameworks, or needs to work with setGraphicsDevice() in a manner that depends on the scene graph's built in API selection logic, it is not always feasiable to defer such operations until after the QQuickWindow has been made visible or QQuickRenderControl::initialize() has been called.

Therefore, this static function is provided as a counterpart to setGraphicsApi(): it can be called at any time, and the result reflects what API the scene graph would choose if it was initialized at the point of the call.

This function was introduced in Qt 6.0.

See also setGraphicsApi().

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

Returns the QQuickGraphicsDevice passed to setGraphicsDevice(), or a default constructed one otherwise

This function was introduced in Qt 6.0.

See also setGraphicsConfiguration().

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

Returns the QQuickGraphicsDevice passed to setGraphicsDevice(), or a default constructed one otherwise

This function was introduced in Qt 6.0.

See also setGraphicsDevice().

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

Returns a reference to a GraphicsStateInfo struct describing some of the RHI's internal state, in particular, the double or tripple buffering status of the backend (such as, the Vulkan or Metal integrations). This is relevant when the underlying graphics APIs is Vulkan or Metal, and the external rendering code wishes to perform double or tripple buffering of its own often-changing resources, such as, uniform buffers, in order to avoid stalling the pipeline.

[static] bool QQuickWindow::hasDefaultAlphaBuffer()

Returns whether to use alpha transparency on newly created windows.

See also setDefaultAlphaBuffer().

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

Reimplements: QWindow::hideEvent(QHideEvent *ev).

QQmlIncubationController *QQuickWindow::incubationController() const

Returns an incubation controller that splices incubation between frames for this window. QQuickView automatically installs this controller for you, otherwise you will need to install it yourself using QQmlEngine::setIncubationController().

The controller is owned by the window and will be destroyed when the window is deleted.

bool QQuickWindow::isPersistentGraphics() const

Returns whether essential graphics resources can be released during the lifetime of the QQuickWindow.

See also setPersistentGraphics().

bool QQuickWindow::isPersistentSceneGraph() const

Returns whether the scene graph nodes and resources can be released during the lifetime of this QQuickWindow.

bool QQuickWindow::isSceneGraphInitialized() const

Returns true if the scene graph has been initialized; otherwise returns false.

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

Reimplements: QWindow::keyPressEvent(QKeyEvent *ev).

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

Reimplements: QWindow::keyReleaseEvent(QKeyEvent *ev).

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

Reimplements: QWindow::mouseDoubleClickEvent(QMouseEvent *ev).

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

Reimplements: QWindow::mouseMoveEvent(QMouseEvent *ev).

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

Reimplements: QWindow::mousePressEvent(QMouseEvent *ev).

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

Reimplements: QWindow::mouseReleaseEvent(QMouseEvent *ev).

[slot] void QQuickWindow::releaseResources()

This function tries to release redundant resources currently held by the QML scene.

Calling this function requests the scene graph to release cached graphics resources, such as graphics pipeline objects, shader programs, or image data.

Additionally, depending on the render loop in use, this function may also result in the scene graph and all window-related rendering resources to be released. If this happens, the sceneGraphInvalidated() signal will be emitted, allowing users to clean up their own graphics resources. The setPersistentGraphics() and setPersistentSceneGraph() functions can be used to prevent this from happening, if handling the cleanup is not feasible in the application, at the cost of higher memory usage.

See also sceneGraphInvalidated(), setPersistentGraphics(), and setPersistentSceneGraph().

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

Returns the QQuickRenderTarget passed to setRenderTarget(), or a default constructed one otherwise

This function was introduced in Qt 6.0.

See also setRenderTarget().

QSGRendererInterface *QQuickWindow::rendererInterface() const

Returns the current renderer interface. The value is always valid and is never null.

See also QSGRenderNode and QSGRendererInterface.

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

Reimplements: QWindow::resizeEvent(QResizeEvent *ev).

[signal] void QQuickWindow::sceneGraphAboutToStop()

This signal is emitted on the render thread when the scene graph is about to stop rendering. This happens usually because the window has been hidden.

Applications may use this signal to release resources, but should be prepared to reinstantiated them again fast. The scene graph and the graphics context are not released at this time.

See also sceneGraphInvalidated().

[static] QString QQuickWindow::sceneGraphBackend()

Returns the requested Qt Quick scenegraph backend.

See also setSceneGraphBackend().

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

This signal is emitted when an error occurred during scene graph initialization.

Applications should connect to this signal if they wish to handle errors, like graphics context creation failures, in a custom way. When no slot is connected to the signal, the behavior will be different: Quick will print the message, or show a message box, and terminate the application.

This signal will be emitted from the GUI thread.

[signal] void QQuickWindow::sceneGraphInitialized()

This signal is emitted when the scene graph has been initialized.

This signal will be emitted from the scene graph rendering thread.

[signal] void QQuickWindow::sceneGraphInvalidated()

This signal is emitted when the scene graph has been invalidated.

This signal implies that the graphics rendering context used has been invalidated and all user resources tied to that context should be released.

When rendering with OpenGL, the QOpenGLContext of this window will be bound when this function is called. The only exception is if the native OpenGL has been destroyed outside Qt's control, for instance through EGL_CONTEXT_LOST.

This signal will be emitted from the scene graph rendering thread.

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

Schedules job to run when the rendering of this window reaches the given stage.

This is a convenience to the equivalent signals in QQuickWindow for "one shot" tasks.

The window takes ownership over job and will delete it when the job is completed.

If rendering is shut down before job has a chance to run, the job will be run and then deleted as part of the scene graph cleanup. If the window is never shown and no rendering happens before the QQuickWindow is destroyed, all pending jobs will be destroyed without their run() method being called.

If the rendering is happening on a different thread, then the job will happen on the rendering thread.

If stage is NoStage, job will be run at the earliest opportunity whenever the render thread is not busy rendering a frame. If the window is not exposed, and is not renderable, at the time the job is either posted or handled, the job is deleted without executing the run() method. If a non-threaded renderer is in use, the run() method of the job is executed synchronously. When rendering with OpenGL, the OpenGL context is changed to the renderer's context before executing any job, including NoStage jobs.

See also beforeRendering(), afterRendering(), beforeSynchronizing(), afterSynchronizing(), frameSwapped(), and sceneGraphInvalidated().

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

useAlpha specifies whether to use alpha transparency on newly created windows.

In any application which expects to create translucent windows, it's necessary to set this to true before creating the first QQuickWindow. The default value is false.

See also hasDefaultAlphaBuffer().

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

Requests the specified graphics api.

When the built-in, default graphics adaptation is used, api specifies which graphics API (OpenGL, Vulkan, Metal, or Direct3D) the scene graph should use to render. In addition, the software backend is built-in as well, and can be requested by setting api to QSGRendererInterface::Software.

Unlike setSceneGraphBackend(), which can only be used to request a given backend (shipped either built-in or installed as dynamically loaded plugins), this function works with the higher level concept of graphics APIs. It covers the backends that ship with Qt Quick, and thus have corresponding values in the QSGRendererInterface::GraphicsApi enum.

When this function is not called at all, and the equivalent environment variable QSG_RHI_BACKEND is not set either, the scene graph will choose the graphics API to use based on the platform.

This function becomes important in applications that are only prepared for rendering with a given API. For example, if there is native OpenGL or Vulkan rendering done by the application, it will want to ensure Qt Quick is rendering using OpenGL or Vulkan too. Such applications are expected to call this function early in their main() function.

To query what graphics API the scene graph is using to render, QSGRendererInterface::graphicsApi() after the scene graph has initialized, which typically happens either when the window becomes visible for the first time, or when QQuickRenderControl::initialize() is called.

To switch back to the default behavior, where the scene graph chooses a graphics API based on the platform and other conditions, set api to QSGRendererInterface::Unknown.

This function was introduced in Qt 6.0.

See also graphicsApi().

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

Sets the graphics configuration for this window. config contains various settings that may be taken into account by the scene graph when initializing the underlying graphics devices and contexts.

Such additional configuration, specifying for example what device extensions to enable for Vulkan, becomes relevant and essential when integrating native graphics rendering code that relies on certain extensions. The same is true when integrating with an external 3D or VR engines, such as OpenXR.

QQuickGraphicsConfiguration instances are implicitly shared, copyable, and can be passed by value.

This function was introduced in Qt 6.0.

See also graphicsConfiguration().

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

Sets the graphics device objects for this window. The scenegraph will use existing device, physical device, and other objects specified by device instead of creating new ones.

This function is very often used in combination with QQuickRenderControl and setRenderTarget(), in order to redirect Qt Quick rendering into a texture.

A default constructed QQuickGraphicsDevice does not change the default behavior in any way. Once a device created via one of the QQuickGraphicsDevice factory functions, such as, QQuickGraphicsDevice::fromDeviceObjects(), is passed in, and the scenegraph uses a matching graphics API (with the example of fromDeviceObjects(), that would be Vulkan), the scenegraph will use the existing device objects (such as, the VkPhysicalDevice, VkDevice, and graphics queue family index, in case of Vulkan) encapsulated by the QQuickGraphicsDevice. This allows using the same device, and so sharing resources, such as buffers and textures, between Qt Quick and native rendering engines.

As an example, this time with Direct3D, the typical usage is expected to be the following:

// 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);
...

The key aspect of using this function is to ensure that resources or handles to resources, such as texture in the above example, are visible to and usable by both the external rendering engine and the scenegraph renderer. This requires using the same graphics device (or with OpenGL, OpenGL context).

QQuickGraphicsDevice instances are implicitly shared, copyable, and can be passed by value. They do not own the associated native objects (such as, the ID3D11Device in the example).

This function was introduced in Qt 6.0.

See also graphicsDevice(), QQuickRenderControl, setRenderTarget(), and setGraphicsApi().

void QQuickWindow::setPersistentGraphics(bool persistent)

Sets whether the graphics resources (graphics device or context, swapchain, buffers, textures) should be preserved, and cannot be released until the last window is deleted, to persistent. The default value is true.

When calling releaseResources(), or when the window gets hidden (more specifically, not renderable), some render loops have the possibility to release all, not just the cached, graphics resources. This can free up memory temporarily, but it also means the rendering engine will have to do a full, potentially costly reinitialization of the resources when the window needs to render again.

See also isPersistentGraphics(), setPersistentSceneGraph(), sceneGraphInitialized(), sceneGraphInvalidated(), and releaseResources().

void QQuickWindow::setPersistentSceneGraph(bool persistent)

Sets whether the scene graph nodes and resources are persistent. Persistent means the nodes and resources cannot be released. The default value is true.

When calling releaseResources(), when the window gets hidden (more specifically, not renderable), some render loops have the possibility to release the scene graph nodes and related graphics resources. This frees up memory temporarily, but will also mean the scene graph has to be rebuilt when the window renders next time.

See also isPersistentSceneGraph(), setPersistentGraphics(), sceneGraphInvalidated(), sceneGraphInitialized(), and releaseResources().

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

Sets the render target for this window to be target.

A QQuickRenderTarget serves as an opaque handle for a renderable native object, most commonly a 2D texture, and associated metadata, such as the size in pixels.

A default constructed QQuickRenderTarget means no redirection. A valid target, created via one of the static QQuickRenderTarget factory functions, on the other hand, enables redirection of the rendering of the Qt Quick scene: it will no longer target the color buffers for the surface associated with the window, but rather the textures or other graphics objects specified in target.

For example, assuming the scenegraph is using Vulkan to render, one can redirect its output into a VkImage. For graphics APIs like Vulkan, the image layout must be provided as well. QQuickRenderTarget instances are implicitly shared and are copyable and can be passed by value. They do not own the associated native objects (such as, the VkImage in the example), however.

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

This function is very often used in combination with QQuickRenderControl and an invisible QQuickWindow, in order to render Qt Quick content into a texture, without creating an on-screen native window for this QQuickWindow.

When the desired target, or associated data, such as the size, changes, call this function with a new QQuickRenderTarget. Constructing QQuickRenderTarget instances and calling this function is cheap, but be aware that setting a new target with a different native object or other data may lead to potentially expensive initialization steps when the scenegraph is about to render the next frame. Therefore change the target only when necessary.

This function was introduced in Qt 6.0.

See also renderTarget(), QQuickRenderControl, setGraphicsDevice(), and setGraphicsApi().

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

Requests a Qt Quick scenegraph backend. Backends can either be built-in or be installed in form of dynamically loaded plugins.

This is an overloaded function.

See Switch Between Adaptations in Your Application for more information about the list of backends. If backend is invalid or an error occurs, the request is ignored.

See also sceneGraphBackend().

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

Sets the default render type of text-like elements in Qt Quick to renderType.

See also textRenderType().

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

Reimplements: QWindow::showEvent(QShowEvent *ev).

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

Reimplements: QWindow::tabletEvent(QTabletEvent *ev).

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

Returns the render type of text-like elements in Qt Quick. The default is QQuickWindow::QtTextRendering.

See also setTextRenderType().

[slot] void QQuickWindow::update()

Schedules the window to render another frame.

Calling QQuickWindow::update() differs from QQuickItem::update() in that it always triggers a repaint, regardless of changes in the underlying scene graph or not.

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

Reimplements: QWindow::wheelEvent(QWheelEvent *ev).