summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorShawn Rutledge <shawn.rutledge@qt.io>2021-02-17 13:59:06 +0100
committerShawn Rutledge <shawn.rutledge@qt.io>2021-02-17 16:12:00 +0100
commit902c68f3ceaae407306ca5a3fdcdcfa159009e78 (patch)
treed0c8814fc83ceee82fc07f7967f42b648895a292
parent79f0af6cd097f55eacb763574e173f134c9c0a32 (diff)
Stage 4: remove non-delivery code from qquickdeliveryagent.cpp
-rw-r--r--src/quick/util/qquickdeliveryagent.cpp3026
1 files changed, 0 insertions, 3026 deletions
diff --git a/src/quick/util/qquickdeliveryagent.cpp b/src/quick/util/qquickdeliveryagent.cpp
index 365304128d..a0cf389fe8 100644
--- a/src/quick/util/qquickdeliveryagent.cpp
+++ b/src/quick/util/qquickdeliveryagent.cpp
@@ -558,507 +558,6 @@ void QQuickWindowPrivate::notifyFocusChangesRecur(QQuickItem **items, int remain
}
}
-void QQuickWindowPrivate::dirtyItem(QQuickItem *)
-{
- Q_Q(QQuickWindow);
- q->maybeUpdate();
-}
-
-void QQuickWindowPrivate::cleanup(QSGNode *n)
-{
- Q_Q(QQuickWindow);
-
- Q_ASSERT(!cleanupNodeList.contains(n));
- cleanupNodeList.append(n);
- q->maybeUpdate();
-}
-
-/*!
- \qmltype Window
- \instantiates QQuickWindow
- \inqmlmodule QtQuick.Window
- \ingroup qtquick-visual
- \brief Creates a new top-level window.
-
- The Window object creates a new top-level window for a Qt Quick scene. It automatically sets up the
- window for use with \c {QtQuick 2.x} graphical types.
-
- To use this type, you will need to import the module with the following line:
- \code
- import QtQuick.Window 2.2
- \endcode
-
- Omitting this import will allow you to have a QML environment without
- access to window system features.
-
- A Window can be declared inside an Item or inside another Window; in that
- case the inner Window will automatically become "transient for" the outer
- Window: that is, most platforms will show it centered upon the outer window
- by default, and there may be other platform-dependent behaviors, depending
- also on the \l flags. If the nested window is intended to be a dialog in
- your application, you should also set \l flags to Qt.Dialog, because some
- window managers will not provide the centering behavior without that flag.
- You can also declare multiple windows inside a top-level \l QtObject, in which
- case the windows will have no transient relationship.
-
- Alternatively you can set or bind \l x and \l y to position the Window
- explicitly on the screen.
-
- When the user attempts to close a window, the \l closing signal will be
- emitted. You can force the window to stay open (for example to prompt the
- user to save changes) by writing an \c onClosing handler and setting
- \c {close.accepted = false}.
-*/
-/*!
- \class QQuickWindow
- \since 5.0
-
- \inmodule QtQuick
-
- \brief The QQuickWindow class provides the window for displaying a graphical QML scene.
-
- QQuickWindow provides the graphical scene management needed to interact with and display
- a scene of QQuickItems.
-
- A QQuickWindow always has a single invisible root item. To add items to this window,
- reparent the items to the root item or to an existing item in the scene.
-
- For easily displaying a scene from a QML file, see \l{QQuickView}.
-
- \section1 Rendering
-
- QQuickWindow uses a scene graph to represent what needs to be rendered.
- This scene graph is disconnected from the QML scene and potentially lives in
- another thread, depending on the platform implementation. Since the
- rendering scene graph lives independently from the QML scene, it can also be
- completely released without affecting the state of the QML scene.
-
- The sceneGraphInitialized() signal is emitted on the rendering thread before
- the QML scene is rendered to the screen for the first time. If the rendering
- scene graph has been released, the signal will be emitted again before the
- next frame is rendered. A visible, on-screen QQuickWindow is driven
- internally by a \c{render loop}, of which there are multiple implementations
- provided in the scene graph. For details on the scene graph rendering
- process, see \l{Qt Quick Scene Graph}.
-
- By default, a QQuickWindow renders using an accelerated 3D graphics API,
- such as OpenGL or Vulkan. See \l{Scene Graph Adaptations} for a detailed
- overview of scene graph backends and the supported graphics APIs.
-
- \warning It is crucial that graphics operations and interaction with the
- scene graph happens exclusively on the rendering thread, primarily during
- the updatePaintNode() phase.
-
- \warning As many of the signals related to rendering are emitted from the
- rendering thread, connections should be made using Qt::DirectConnection.
-
- \section2 Integration with Accelerated 3D Graphics APIs
-
- It is possible to integrate OpenGL, Vulkan, Metal, or Direct3D 11 calls
- directly into the QQuickWindow, as long as the QQuickWindow and the
- underlying scene graph is rendering using the same API. To access native
- graphics objects, such as device or context object handles, use
- QSGRendererInterface. An instance of QSGRendererInterface is queriable from
- QQuickWindow by calling rendererInterface(). The enablers for this
- integration are the beforeRendering(), beforeRenderPassRecording(),
- afterRenderPassRecording(), and related signals. These allow rendering
- underlays or overlays. Alternatively, QNativeInterface::QSGOpenGLTexture,
- QNativeInterface::QSGVulkanTexture, and other similar classes allow
- wrapping an existing native texture or image object in a QSGTexture that
- can then be used with the scene graph.
-
- \section2 Rendering without Acceleration
-
- A limited, pure software based rendering path is available as well. With the
- \c software backend, a number of Qt Quick features are not available, QML
- items relying on these will not be rendered at all. At the same time, this
- allows QQuickWindow to be functional even on systems where there is no 3D
- graphics API available at all. See \l{Qt Quick Software Adaptation} for more
- details.
-
- \section2 Redirected Rendering
-
- A QQuickWindow is not necessarily backed by a native window on screen. The
- rendering can be redirected to target a custom render target, such as a
- given native texture. This is achieved in combination with the
- QQuickRenderControl class, and functions such as setRenderTarget(),
- setGraphicsDevice(), and setGraphicsConfiguration().
-
- In this case, the QQuickWindow represents the scene, and provides the
- intrastructure for rendering a frame. It will not be backed by a render
- loop and a native window. Instead, in this case the application drives
- rendering, effectively substituting for the render loops. This allows
- generating image sequences, rendering into textures for use in external 3D
- engines, or rendering Qt Quick content within a VR environment.
-
- \section2 Resource Management
-
- QML will try to cache images and scene graph nodes to improve performance,
- but in some low-memory scenarios it might be required to aggressively
- release these resources. The releaseResources() function can be used to
- force the clean up of certain resources, especially resource that are cached
- and can be recreated later when needed again.
-
- Additionally, calling releaseResources() may result in releasing the entire
- scene graph and the associated graphics resources. The
- sceneGraphInvalidated() signal will be emitted when this happens. This
- behavior is controlled by the setPersistentGraphics() and
- setPersistentSceneGraph() functions.
-
- \note All classes with QSG prefix should be used solely on the scene graph's
- rendering thread. See \l {Scene Graph and Rendering} for more information.
-
- \section2 Exposure and Visibility
-
- When a QQuickWindow instance is deliberately hidden with hide() or
- setVisible(false), it will stop rendering and its scene graph and graphics
- context might be released as well. This depends on the settings configured
- by setPersistentGraphics() and setPersistentSceneGraph(). The behavior in
- this respect is identical to explicitly calling the releaseResources()
- function. A window can become not exposed, in other words non-renderable, by
- other means as well. This depends on the platform and windowing system. For
- example, on Windows minimizing a window makes it stop rendering. On \macos
- fully obscuring a window by other windows on top triggers the same. On
- Linux/X11, the behavior is dependent on the window manager.
-
- \section2 OpenGL Context and Surface Formats
-
- While it is possible to specify a QSurfaceFormat for every QQuickWindow by
- calling the member function setFormat(), windows may also be created from
- QML by using the Window and ApplicationWindow elements. In this case there
- is no C++ code involved in the creation of the window instance, yet
- applications may still wish to set certain surface format values, for
- example to request a given OpenGL version or profile. Such applications can
- call the static function QSurfaceFormat::setDefaultFormat() at startup. The
- specified format will be used for all Quick windows created afterwards.
-
- \section2 Vulkan Instance
-
- When using Vulkan, a QQuickWindow is automatically associated with a
- QVulkanInstance that is created and managed internally by the scene graph.
- This way most applications do not need to worry about having a \c
- VkInstance available since it all happens automatically. In advanced cases
- an application may wish to create its own QVulkanInstance, in order to
- configure it in a specific way. That is possible as well. Calling
- \l{QWindow::setVulkanInstance()}{setVulkanInstance()} on the QQuickWindow
- right after construction, before making it visible, leads to using the
- application-supplied QVulkanInstance (and the underlying \c VkInstance).
- When redirecting via QQuickRenderControl, there is no QVulkanInstance
- provided automatically, but rather the application is expected to provide
- its own and associate it with the QQuickWindow.
-
- \section2 Graphics Contexts and Devices
-
- When the scene graph is initialized, which typically happens when the
- window becomes exposed or, in case of redirected rendering, initialization
- is performed \l{QQuickRenderControl::initialize()}{via
- QQuickRenderControl}, the context or device objects necessary for rendering
- are created automatically. This includes OpenGL contexts, Direct3D devices
- and device contexts, Vulkan and Metal devices. These are also queriable by
- application code afterwards via
- \l{QSGRendererInterface::getResource()}{QSGRendererInterface}. When using
- the \c basic render loop, which performs all rendering on the GUI thread,
- the same context or device is used with all visible QQuickWindows. The \c
- threaded render loop uses a dedicated context or device object for each
- rendering thread, and so for each QQuickWindow. With some graphics APIs,
- there is a degree of customizability provided via
- setGraphicsConfiguration(). This makes it possible, for example, to specify
- the list of Vulkan extensions to enable on the \c VkDevice. Alternatively,
- it is also possible to provide a set of existing context or device objects
- for use by the QQuickWindow, instead of letting it construct its own. This
- is achieved through setGraphicsDevice().
-
- \sa QQuickView, QQuickRenderControl, QQuickRenderTarget,
- QQuickGraphicsDevice, QQuickGraphicsConfiguration, QSGRendererInterface
-*/
-
-/*!
- Constructs a window for displaying a QML scene with parent window \a parent.
-*/
-QQuickWindow::QQuickWindow(QWindow *parent)
- : QQuickWindow(*new QQuickWindowPrivate, parent)
-{
-}
-
-
-
-/*!
- \internal
-*/
-QQuickWindow::QQuickWindow(QQuickWindowPrivate &dd, QWindow *parent)
- : QWindow(dd, parent)
-{
- Q_D(QQuickWindow);
- d->init(this);
-}
-
-/*!
- \internal
-*/
-QQuickWindow::QQuickWindow(QQuickRenderControl *control)
- : QWindow(*(new QQuickWindowPrivate), nullptr)
-{
- Q_D(QQuickWindow);
- d->init(this, control);
-}
-
-/*!
- \internal
-*/
-QQuickWindow::QQuickWindow(QQuickWindowPrivate &dd, QQuickRenderControl *control)
- : QWindow(dd, nullptr)
-{
- Q_D(QQuickWindow);
- d->init(this, control);
-}
-
-/*!
- Destroys the window.
-*/
-QQuickWindow::~QQuickWindow()
-{
- Q_D(QQuickWindow);
-
- if (d->renderControl) {
- QQuickRenderControlPrivate::get(d->renderControl)->windowDestroyed();
- } else if (d->windowManager) {
- d->windowManager->removeWindow(this);
- d->windowManager->windowDestroyed(this);
- }
-
- delete d->incubationController; d->incubationController = nullptr;
-#if QT_CONFIG(quick_draganddrop)
- delete d->dragGrabber; d->dragGrabber = nullptr;
-#endif
- QQuickRootItem *root = d->contentItem;
- d->contentItem = nullptr;
- delete root;
-
- d->renderJobMutex.lock();
- qDeleteAll(d->beforeSynchronizingJobs);
- d->beforeSynchronizingJobs.clear();
- qDeleteAll(d->afterSynchronizingJobs);
- d->afterSynchronizingJobs.clear();
- qDeleteAll(d->beforeRenderingJobs);
- d->beforeRenderingJobs.clear();
- qDeleteAll(d->afterRenderingJobs);
- d->afterRenderingJobs.clear();
- qDeleteAll(d->afterSwapJobs);
- d->afterSwapJobs.clear();
- d->renderJobMutex.unlock();
-
- // It is important that the pixmap cache is cleaned up during shutdown.
- // Besides playing nice, this also solves a practical problem that
- // QQuickTextureFactory implementations in other libraries need
- // have their destructors loaded while they the library is still
- // loaded into memory.
- QQuickPixmap::purgeCache();
-}
-
-#if QT_CONFIG(quick_shadereffect)
-void qtquick_shadereffect_purge_gui_thread_shader_cache();
-#endif
-
-/*!
- 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 or shader programs.
-
- \note The releasing of cached graphics resources is not dependent on the
- hint from setPersistentGraphics().
-
- Additionally, depending on the render loop in use, this function may also
- result in the scene graph and all 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.
-
- \sa sceneGraphInvalidated(), setPersistentGraphics(), setPersistentSceneGraph()
- */
-
-void QQuickWindow::releaseResources()
-{
- Q_D(QQuickWindow);
- if (d->windowManager)
- d->windowManager->releaseResources(this);
- QQuickPixmap::purgeCache();
-#if QT_CONFIG(quick_shadereffect)
- qtquick_shadereffect_purge_gui_thread_shader_cache();
-#endif
-}
-
-
-
-/*!
- 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 \a 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.
-
- \note The rules for when a window is not renderable are platform and
- window manager specific.
-
- \note All graphics resources are released when the last QQuickWindow is
- deleted, regardless of this setting.
-
- \note This is a hint, and is not guaranteed that it is taken into account.
-
- \note This hint does not apply to cached resources, that are relatively
- cheap to drop and then recreate later. Therefore, calling releaseResources()
- will typically lead to releasing those regardless of the value of this hint.
-
- \sa setPersistentSceneGraph(), sceneGraphInitialized(), sceneGraphInvalidated(), releaseResources()
- */
-
-void QQuickWindow::setPersistentGraphics(bool persistent)
-{
- Q_D(QQuickWindow);
- d->persistentGraphics = persistent;
-}
-
-
-
-/*!
- Returns whether essential graphics resources can be released during the
- lifetime of the QQuickWindow.
-
- \note This is a hint, and is not guaranteed that it is taken into account.
-
- \sa setPersistentGraphics()
- */
-
-bool QQuickWindow::isPersistentGraphics() const
-{
- Q_D(const QQuickWindow);
- return d->persistentGraphics;
-}
-
-
-
-/*!
- Sets whether the scene graph nodes and resources are \a persistent.
- Persistent means the nodes and resources cannot be released.
- The default value is \c 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.
-
- \note The rules for when a window is not renderable are platform and
- window manager specific.
-
- \note The scene graph nodes and resources are always released when the
- last QQuickWindow is deleted, regardless of this setting.
-
- \note This is a hint, and is not guaranteed that it is taken into account.
-
- \sa setPersistentGraphics(), sceneGraphInvalidated(), sceneGraphInitialized(), releaseResources()
- */
-
-void QQuickWindow::setPersistentSceneGraph(bool persistent)
-{
- Q_D(QQuickWindow);
- d->persistentSceneGraph = persistent;
-}
-
-
-
-/*!
- Returns whether the scene graph nodes and resources can be
- released during the lifetime of this QQuickWindow.
-
- \note This is a hint. When and how this happens is implementation
- specific.
- */
-
-bool QQuickWindow::isPersistentSceneGraph() const
-{
- Q_D(const QQuickWindow);
- return d->persistentSceneGraph;
-}
-
-
-
-
-/*!
- \qmlattachedproperty Item Window::contentItem
- \since 5.4
-
- This attached property holds the invisible root item of the scene or
- \c null if the item is not in a window. The Window attached property
- can be attached to any Item.
-*/
-
-/*!
- \property QQuickWindow::contentItem
- \brief The invisible root item of the scene.
-
- A QQuickWindow always has a single invisible root item containing all of its content.
- To add items to this window, reparent the items to the contentItem or to an existing
- item in the scene.
-*/
-QQuickItem *QQuickWindow::contentItem() const
-{
- Q_D(const QQuickWindow);
-
- return d->contentItem;
-}
-
-/*!
- \property QQuickWindow::activeFocusItem
-
- \brief The item which currently has active focus or \c null if there is
- no item with active focus.
-*/
-QQuickItem *QQuickWindow::activeFocusItem() const
-{
- Q_D(const QQuickWindow);
-
- return d->activeFocusItem;
-}
-
-/*!
- \internal
- \reimp
-*/
-QObject *QQuickWindow::focusObject() const
-{
- Q_D(const QQuickWindow);
-
- if (d->activeFocusItem)
- return d->activeFocusItem;
- return const_cast<QQuickWindow*>(this);
-}
-
-
-/*!
- \obsolete Use QPointerEvent::exclusiveGrabber()
- Returns the item which currently has the mouse grab.
-*/
-QQuickItem *QQuickWindow::mouseGrabberItem() const
-{
- Q_D(const QQuickWindow);
- auto epd = const_cast<QQuickWindowPrivate *>(d)->mousePointData();
- if (!epd && d->eventsInDelivery.isEmpty()) {
- qCDebug(lcMouse, "mouse grabber ambiguous: no event is currently being delivered");
- return qmlobject_cast<QQuickItem *>(QPointingDevicePrivate::get(QPointingDevice::primaryPointingDevice())->
- firstPointExclusiveGrabber());
- }
- return qobject_cast<QQuickItem *>(epd->exclusiveGrabber);
-}
-
bool QQuickWindowPrivate::clearHover(ulong timestamp)
{
Q_Q(QQuickWindow);
@@ -1192,24 +691,6 @@ bool QQuickWindow::event(QEvent *e)
return QWindow::event(e);
}
-/*! \reimp */
-void QQuickWindow::keyPressEvent(QKeyEvent *e)
-{
- Q_D(QQuickWindow);
- Q_QUICK_INPUT_PROFILE(QQuickProfiler::Key, QQuickProfiler::InputKeyPress, e->key(),
- e->modifiers());
- d->deliverKeyEvent(e);
-}
-
-/*! \reimp */
-void QQuickWindow::keyReleaseEvent(QKeyEvent *e)
-{
- Q_D(QQuickWindow);
- Q_QUICK_INPUT_PROFILE(QQuickProfiler::Key, QQuickProfiler::InputKeyRelease, e->key(),
- e->modifiers());
- d->deliverKeyEvent(e);
-}
-
void QQuickWindowPrivate::deliverKeyEvent(QKeyEvent *e)
{
if (activeFocusItem) {
@@ -1425,37 +906,6 @@ bool QQuickWindowPrivate::deliverSinglePointEventUntilAccepted(QPointerEvent *ev
return false; // it wasn't handled
}
-#if QT_CONFIG(wheelevent)
-/*! \reimp */
-void QQuickWindow::wheelEvent(QWheelEvent *event)
-{
- Q_D(QQuickWindow);
- Q_QUICK_INPUT_PROFILE(QQuickProfiler::Mouse, QQuickProfiler::InputMouseWheel,
- event->angleDelta().x(), event->angleDelta().y());
-
- qCDebug(lcMouse) << event;
-
- //if the actual wheel event was accepted, accept the compatibility wheel event and return early
- if (d->lastWheelEventAccepted && event->angleDelta().isNull() && event->phase() == Qt::ScrollUpdate)
- return;
-
- event->ignore();
- d->deliverSinglePointEventUntilAccepted(event);
- d->lastWheelEventAccepted = event->isAccepted();
-}
-#endif // wheelevent
-
-#if QT_CONFIG(tabletevent)
-/*! \reimp */
-void QQuickWindow::tabletEvent(QTabletEvent *event)
-{
- Q_D(QQuickWindow);
- qCDebug(lcTablet) << event;
- // TODO Qt 6: make sure TabletEnterProximity and TabletLeaveProximity are delivered here
- d->deliverPointerEvent(event);
-}
-#endif // tabletevent
-
bool QQuickWindowPrivate::deliverTouchCancelEvent(QTouchEvent *event)
{
qCDebug(lcTouch) << event;
@@ -1685,31 +1135,6 @@ void QQuickWindowPrivate::handleTouchEvent(QTouchEvent *event)
}
}
-/*! \reimp */
-void QQuickWindow::mousePressEvent(QMouseEvent *event)
-{
- Q_D(QQuickWindow);
- d->handleMouseEvent(event);
-}
-/*! \reimp */
-void QQuickWindow::mouseMoveEvent(QMouseEvent *event)
-{
- Q_D(QQuickWindow);
- d->handleMouseEvent(event);
-}
-/*! \reimp */
-void QQuickWindow::mouseDoubleClickEvent(QMouseEvent *event)
-{
- Q_D(QQuickWindow);
- d->handleMouseEvent(event);
-}
-/*! \reimp */
-void QQuickWindow::mouseReleaseEvent(QMouseEvent *event)
-{
- Q_D(QQuickWindow);
- d->handleMouseEvent(event);
-}
-
void QQuickWindowPrivate::handleMouseEvent(QMouseEvent *event)
{
if (event->source() == Qt::MouseEventSynthesizedBySystem) {
@@ -2383,61 +1808,6 @@ bool QQuickWindowPrivate::deliverDragEvent(QQuickDragGrabber *grabber, QQuickIte
}
#endif // quick_draganddrop
-#if QT_CONFIG(cursor)
-void QQuickWindowPrivate::updateCursor(const QPointF &scenePos)
-{
- Q_Q(QQuickWindow);
-
- auto cursorItemAndHandler = findCursorItemAndHandler(contentItem, scenePos);
-
- if (cursorItem != cursorItemAndHandler.first || cursorHandler != cursorItemAndHandler.second) {
- QWindow *renderWindow = QQuickRenderControl::renderWindowFor(q);
- QWindow *window = renderWindow ? renderWindow : q;
- cursorItem = cursorItemAndHandler.first;
- cursorHandler = cursorItemAndHandler.second;
- if (cursorItem)
- window->setCursor(QQuickItemPrivate::get(cursorItem)->effectiveCursor(cursorHandler));
- else
- window->unsetCursor();
- }
-}
-
-QPair<QQuickItem*, QQuickPointerHandler*> QQuickWindowPrivate::findCursorItemAndHandler(QQuickItem *item, const QPointF &scenePos) const
-{
- QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
- if (itemPrivate->flags & QQuickItem::ItemClipsChildrenToShape) {
- QPointF p = item->mapFromScene(scenePos);
- if (!item->contains(p))
- return {nullptr, nullptr};
- }
-
- if (itemPrivate->subtreeCursorEnabled) {
- QList<QQuickItem *> children = itemPrivate->paintOrderChildItems();
- for (int ii = children.count() - 1; ii >= 0; --ii) {
- QQuickItem *child = children.at(ii);
- if (!child->isVisible() || !child->isEnabled() || QQuickItemPrivate::get(child)->culled)
- continue;
- auto ret = findCursorItemAndHandler(child, scenePos);
- if (ret.first)
- return ret;
- }
- if (itemPrivate->hasCursorHandler) {
- if (auto handler = itemPrivate->effectiveCursorHandler()) {
- if (handler->parentContains(scenePos))
- return {item, handler};
- }
- }
- if (itemPrivate->hasCursor) {
- QPointF p = item->mapFromScene(scenePos);
- if (item->contains(p))
- return {item, nullptr};
- }
- }
-
- return {nullptr, nullptr};
-}
-#endif
-
bool QQuickWindowPrivate::sendFilteredPointerEvent(QPointerEvent *event, QQuickItem *receiver, QQuickItem *filteringParent)
{
return sendFilteredPointerEventImpl(event, receiver, filteringParent ? filteringParent : receiver->parentItem());
@@ -2616,2400 +1986,4 @@ bool QQuickWindowPrivate::dragOverThreshold(QVector2D delta)
return qAbs(delta.x()) > threshold || qAbs(delta.y()) > threshold;
}
-/*!
- \qmlproperty list<Object> Window::data
- \default
-
- The data property allows you to freely mix visual children, resources
- and other Windows in a Window.
-
- If you assign another Window to the data list, the nested window will
- become "transient for" the outer Window.
-
- If you assign an \l Item to the data list, it becomes a child of the
- Window's \l contentItem, so that it appears inside the window. The item's
- parent will be the window's contentItem, which is the root of the Item
- ownership tree within that Window.
-
- If you assign any other object type, it is added as a resource.
-
- It should not generally be necessary to refer to the \c data property,
- as it is the default property for Window and thus all child items are
- automatically assigned to this property.
-
- \sa QWindow::transientParent()
- */
-
-void QQuickWindowPrivate::data_append(QQmlListProperty<QObject> *property, QObject *o)
-{
- if (!o)
- return;
- QQuickWindow *that = static_cast<QQuickWindow *>(property->object);
- if (QQuickWindow *window = qmlobject_cast<QQuickWindow *>(o)) {
- qCDebug(lcTransient) << window << "is transient for" << that;
- window->setTransientParent(that);
- }
- QQmlListProperty<QObject> itemProperty = QQuickItemPrivate::get(that->contentItem())->data();
- itemProperty.append(&itemProperty, o);
-}
-
-qsizetype QQuickWindowPrivate::data_count(QQmlListProperty<QObject> *property)
-{
- QQuickWindow *win = static_cast<QQuickWindow*>(property->object);
- if (!win || !win->contentItem() || !QQuickItemPrivate::get(win->contentItem())->data().count)
- return 0;
- QQmlListProperty<QObject> itemProperty = QQuickItemPrivate::get(win->contentItem())->data();
- return itemProperty.count(&itemProperty);
-}
-
-QObject *QQuickWindowPrivate::data_at(QQmlListProperty<QObject> *property, qsizetype i)
-{
- QQuickWindow *win = static_cast<QQuickWindow*>(property->object);
- QQmlListProperty<QObject> itemProperty = QQuickItemPrivate::get(win->contentItem())->data();
- return itemProperty.at(&itemProperty, i);
-}
-
-void QQuickWindowPrivate::data_clear(QQmlListProperty<QObject> *property)
-{
- QQuickWindow *win = static_cast<QQuickWindow*>(property->object);
- QQmlListProperty<QObject> itemProperty = QQuickItemPrivate::get(win->contentItem())->data();
- itemProperty.clear(&itemProperty);
-}
-
-void QQuickWindowPrivate::data_replace(QQmlListProperty<QObject> *property, qsizetype i, QObject *o)
-{
- QQuickWindow *win = static_cast<QQuickWindow*>(property->object);
- QQmlListProperty<QObject> itemProperty = QQuickItemPrivate::get(win->contentItem())->data();
- itemProperty.replace(&itemProperty, i, o);
-}
-
-void QQuickWindowPrivate::data_removeLast(QQmlListProperty<QObject> *property)
-{
- QQuickWindow *win = static_cast<QQuickWindow*>(property->object);
- QQmlListProperty<QObject> itemProperty = QQuickItemPrivate::get(win->contentItem())->data();
- itemProperty.removeLast(&itemProperty);
-}
-
-bool QQuickWindowPrivate::isRenderable() const
-{
- Q_Q(const QQuickWindow);
- return ((q->isExposed() && q->isVisible())) && q->geometry().isValid();
-}
-
-void QQuickWindowPrivate::rhiCreationFailureMessage(const QString &backendName,
- QString *translatedMessage,
- QString *untranslatedMessage)
-{
- const char msg[] = QT_TRANSLATE_NOOP("QQuickWindow",
- "Failed to initialize graphics backend for %1.");
- *translatedMessage = QQuickWindow::tr(msg).arg(backendName);
- *untranslatedMessage = QString::fromLatin1(msg).arg(backendName);
-}
-
-void QQuickWindowPrivate::cleanupNodes()
-{
- for (int ii = 0; ii < cleanupNodeList.count(); ++ii)
- delete cleanupNodeList.at(ii);
- cleanupNodeList.clear();
-}
-
-void QQuickWindowPrivate::cleanupNodesOnShutdown(QQuickItem *item)
-{
- QQuickItemPrivate *p = QQuickItemPrivate::get(item);
- if (p->itemNodeInstance) {
- delete p->itemNodeInstance;
- p->itemNodeInstance = nullptr;
-
- if (p->extra.isAllocated()) {
- p->extra->opacityNode = nullptr;
- p->extra->clipNode = nullptr;
- p->extra->rootNode = nullptr;
- }
-
- p->paintNode = nullptr;
-
- p->dirty(QQuickItemPrivate::Window);
- }
-
- // Qt 6: Make invalidateSceneGraph a virtual member of QQuickItem
- if (p->flags & QQuickItem::ItemHasContents) {
- const QMetaObject *mo = item->metaObject();
- int index = mo->indexOfSlot("invalidateSceneGraph()");
- if (index >= 0) {
- const QMetaMethod &method = mo->method(index);
- // Skip functions named invalidateSceneGraph() in QML items.
- if (strstr(method.enclosingMetaObject()->className(), "_QML_") == nullptr)
- method.invoke(item, Qt::DirectConnection);
- }
- }
-
- for (int ii = 0; ii < p->childItems.count(); ++ii)
- cleanupNodesOnShutdown(p->childItems.at(ii));
-}
-
-// This must be called from the render thread, with the main thread frozen
-void QQuickWindowPrivate::cleanupNodesOnShutdown()
-{
- Q_Q(QQuickWindow);
- cleanupNodes();
- cleanupNodesOnShutdown(contentItem);
- for (QSet<QQuickItem *>::const_iterator it = parentlessItems.begin(), cend = parentlessItems.end(); it != cend; ++it)
- cleanupNodesOnShutdown(*it);
- animationController->windowNodesDestroyed();
- q->cleanupSceneGraph();
-}
-
-void QQuickWindowPrivate::updateDirtyNodes()
-{
- qCDebug(lcDirty) << "QQuickWindowPrivate::updateDirtyNodes():";
-
- cleanupNodes();
-
- QQuickItem *updateList = dirtyItemList;
- dirtyItemList = nullptr;
- if (updateList) QQuickItemPrivate::get(updateList)->prevDirtyItem = &updateList;
-
- while (updateList) {
- QQuickItem *item = updateList;
- QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(item);
- itemPriv->removeFromDirtyList();
-
- qCDebug(lcDirty) << " QSGNode:" << item << qPrintable(itemPriv->dirtyToString());
- updateDirtyNode(item);
- }
-}
-
-static inline QSGNode *qquickitem_before_paintNode(QQuickItemPrivate *d)
-{
- const QList<QQuickItem *> childItems = d->paintOrderChildItems();
- QQuickItem *before = nullptr;
- for (int i=0; i<childItems.size(); ++i) {
- QQuickItemPrivate *dd = QQuickItemPrivate::get(childItems.at(i));
- // Perform the same check as the in fetchNextNode below.
- if (dd->z() < 0 && (dd->explicitVisible || (dd->extra.isAllocated() && dd->extra->effectRefCount)))
- before = childItems.at(i);
- else
- break;
- }
- return Q_UNLIKELY(before) ? QQuickItemPrivate::get(before)->itemNode() : nullptr;
-}
-
-static QSGNode *fetchNextNode(QQuickItemPrivate *itemPriv, int &ii, bool &returnedPaintNode)
-{
- QList<QQuickItem *> orderedChildren = itemPriv->paintOrderChildItems();
-
- for (; ii < orderedChildren.count() && orderedChildren.at(ii)->z() < 0; ++ii) {
- QQuickItemPrivate *childPrivate = QQuickItemPrivate::get(orderedChildren.at(ii));
- if (!childPrivate->explicitVisible &&
- (!childPrivate->extra.isAllocated() || !childPrivate->extra->effectRefCount))
- continue;
-
- ii++;
- return childPrivate->itemNode();
- }
-
- if (itemPriv->paintNode && !returnedPaintNode) {
- returnedPaintNode = true;
- return itemPriv->paintNode;
- }
-
- for (; ii < orderedChildren.count(); ++ii) {
- QQuickItemPrivate *childPrivate = QQuickItemPrivate::get(orderedChildren.at(ii));
- if (!childPrivate->explicitVisible &&
- (!childPrivate->extra.isAllocated() || !childPrivate->extra->effectRefCount))
- continue;
-
- ii++;
- return childPrivate->itemNode();
- }
-
- return nullptr;
-}
-
-void QQuickWindowPrivate::updateDirtyNode(QQuickItem *item)
-{
- QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(item);
- quint32 dirty = itemPriv->dirtyAttributes;
- itemPriv->dirtyAttributes = 0;
-
- if ((dirty & QQuickItemPrivate::TransformUpdateMask) ||
- (dirty & QQuickItemPrivate::Size && itemPriv->origin() != QQuickItem::TopLeft &&
- (itemPriv->scale() != 1. || itemPriv->rotation() != 0.))) {
-
- QMatrix4x4 matrix;
-
- if (itemPriv->x != 0. || itemPriv->y != 0.)
- matrix.translate(itemPriv->x, itemPriv->y);
-
- for (int ii = itemPriv->transforms.count() - 1; ii >= 0; --ii)
- itemPriv->transforms.at(ii)->applyTo(&matrix);
-
- if (itemPriv->scale() != 1. || itemPriv->rotation() != 0.) {
- QPointF origin = item->transformOriginPoint();
- matrix.translate(origin.x(), origin.y());
- if (itemPriv->scale() != 1.)
- matrix.scale(itemPriv->scale(), itemPriv->scale());
- if (itemPriv->rotation() != 0.)
- matrix.rotate(itemPriv->rotation(), 0, 0, 1);
- matrix.translate(-origin.x(), -origin.y());
- }
-
- itemPriv->itemNode()->setMatrix(matrix);
- }
-
- bool clipEffectivelyChanged = (dirty & (QQuickItemPrivate::Clip | QQuickItemPrivate::Window)) &&
- ((item->clip() == false) != (itemPriv->clipNode() == nullptr));
- int effectRefCount = itemPriv->extra.isAllocated()?itemPriv->extra->effectRefCount:0;
- bool effectRefEffectivelyChanged = (dirty & (QQuickItemPrivate::EffectReference | QQuickItemPrivate::Window)) &&
- ((effectRefCount == 0) != (itemPriv->rootNode() == nullptr));
-
- if (clipEffectivelyChanged) {
- QSGNode *parent = itemPriv->opacityNode() ? (QSGNode *) itemPriv->opacityNode() :
- (QSGNode *) itemPriv->itemNode();
- QSGNode *child = itemPriv->rootNode();
-
- if (item->clip()) {
- Q_ASSERT(itemPriv->clipNode() == nullptr);
- QQuickDefaultClipNode *clip = new QQuickDefaultClipNode(item->clipRect());
- itemPriv->extra.value().clipNode = clip;
- clip->update();
-
- if (!child) {
- parent->reparentChildNodesTo(clip);
- parent->appendChildNode(clip);
- } else {
- parent->removeChildNode(child);
- clip->appendChildNode(child);
- parent->appendChildNode(clip);
- }
-
- } else {
- QQuickDefaultClipNode *clip = itemPriv->clipNode();
- Q_ASSERT(clip);
- parent->removeChildNode(clip);
- if (child) {
- clip->removeChildNode(child);
- parent->appendChildNode(child);
- } else {
- clip->reparentChildNodesTo(parent);
- }
-
- delete itemPriv->clipNode();
- itemPriv->extra->clipNode = nullptr;
- }
- }
-
- if (effectRefEffectivelyChanged) {
- if (dirty & QQuickItemPrivate::ChildrenUpdateMask)
- itemPriv->childContainerNode()->removeAllChildNodes();
-
- QSGNode *parent = itemPriv->clipNode();
- if (!parent)
- parent = itemPriv->opacityNode();
- if (!parent)
- parent = itemPriv->itemNode();
-
- if (itemPriv->extra.isAllocated() && itemPriv->extra->effectRefCount) {
- Q_ASSERT(itemPriv->rootNode() == nullptr);
- QSGRootNode *root = new QSGRootNode();
- itemPriv->extra->rootNode = root;
- parent->reparentChildNodesTo(root);
- parent->appendChildNode(root);
- } else {
- Q_ASSERT(itemPriv->rootNode() != nullptr);
- QSGRootNode *root = itemPriv->rootNode();
- parent->removeChildNode(root);
- root->reparentChildNodesTo(parent);
- delete itemPriv->rootNode();
- itemPriv->extra->rootNode = nullptr;
- }
- }
-
- if (dirty & QQuickItemPrivate::ChildrenUpdateMask) {
- int ii = 0;
- bool fetchedPaintNode = false;
- QList<QQuickItem *> orderedChildren = itemPriv->paintOrderChildItems();
- int desiredNodesSize = orderedChildren.size() + (itemPriv->paintNode ? 1 : 0);
-
- // now start making current state match the promised land of
- // desiredNodes. in the case of our current state matching desiredNodes
- // (though why would we get ChildrenUpdateMask with no changes?) then we
- // should make no changes at all.
-
- // how many nodes did we process, when examining changes
- int desiredNodesProcessed = 0;
-
- // currentNode is how far, in our present tree, we have processed. we
- // make use of this later on to trim the current child list if the
- // desired list is shorter.
- QSGNode *groupNode = itemPriv->childContainerNode();
- QSGNode *currentNode = groupNode->firstChild();
- int added = 0;
- int removed = 0;
- int replaced = 0;
- QSGNode *desiredNode = nullptr;
-
- while (currentNode && (desiredNode = fetchNextNode(itemPriv, ii, fetchedPaintNode))) {
- // uh oh... reality and our utopic paradise are diverging!
- // we need to reconcile this...
- if (currentNode != desiredNode) {
- // for now, we're just removing the node from the children -
- // and replacing it with the new node.
- if (desiredNode->parent())
- desiredNode->parent()->removeChildNode(desiredNode);
- groupNode->insertChildNodeAfter(desiredNode, currentNode);
- groupNode->removeChildNode(currentNode);
- replaced++;
-
- // since we just replaced currentNode, we also need to reset
- // the pointer.
- currentNode = desiredNode;
- }
-
- currentNode = currentNode->nextSibling();
- desiredNodesProcessed++;
- }
-
- // if we didn't process as many nodes as in the new list, then we have
- // more nodes at the end of desiredNodes to append to our list.
- // this will be the case when adding new nodes, for instance.
- if (desiredNodesProcessed < desiredNodesSize) {
- while ((desiredNode = fetchNextNode(itemPriv, ii, fetchedPaintNode))) {
- if (desiredNode->parent())
- desiredNode->parent()->removeChildNode(desiredNode);
- groupNode->appendChildNode(desiredNode);
- added++;
- }
- } else if (currentNode) {
- // on the other hand, if we processed less than our current node
- // tree, then nodes have been _removed_ from the scene, and we need
- // to take care of that here.
- while (currentNode) {
- QSGNode *node = currentNode->nextSibling();
- groupNode->removeChildNode(currentNode);
- currentNode = node;
- removed++;
- }
- }
- }
-
- if ((dirty & QQuickItemPrivate::Size) && itemPriv->clipNode()) {
- itemPriv->clipNode()->setRect(item->clipRect());
- itemPriv->clipNode()->update();
- }
-
- if (dirty & (QQuickItemPrivate::OpacityValue | QQuickItemPrivate::Visible
- | QQuickItemPrivate::HideReference | QQuickItemPrivate::Window))
- {
- qreal opacity = itemPriv->explicitVisible && (!itemPriv->extra.isAllocated() || itemPriv->extra->hideRefCount == 0)
- ? itemPriv->opacity() : qreal(0);
-
- if (opacity != 1 && !itemPriv->opacityNode()) {
- QSGOpacityNode *node = new QSGOpacityNode;
- itemPriv->extra.value().opacityNode = node;
-
- QSGNode *parent = itemPriv->itemNode();
- QSGNode *child = itemPriv->clipNode();
- if (!child)
- child = itemPriv->rootNode();
-
- if (child) {
- parent->removeChildNode(child);
- node->appendChildNode(child);
- parent->appendChildNode(node);
- } else {
- parent->reparentChildNodesTo(node);
- parent->appendChildNode(node);
- }
- }
- if (itemPriv->opacityNode())
- itemPriv->opacityNode()->setOpacity(opacity);
- }
-
- if (dirty & QQuickItemPrivate::ContentUpdateMask) {
-
- if (itemPriv->flags & QQuickItem::ItemHasContents) {
- updatePaintNodeData.transformNode = itemPriv->itemNode();
- itemPriv->paintNode = item->updatePaintNode(itemPriv->paintNode, &updatePaintNodeData);
-
- Q_ASSERT(itemPriv->paintNode == nullptr ||
- itemPriv->paintNode->parent() == nullptr ||
- itemPriv->paintNode->parent() == itemPriv->childContainerNode());
-
- if (itemPriv->paintNode && itemPriv->paintNode->parent() == nullptr) {
- QSGNode *before = qquickitem_before_paintNode(itemPriv);
- if (before && before->parent()) {
- Q_ASSERT(before->parent() == itemPriv->childContainerNode());
- itemPriv->childContainerNode()->insertChildNodeAfter(itemPriv->paintNode, before);
- } else {
- itemPriv->childContainerNode()->prependChildNode(itemPriv->paintNode);
- }
- }
- } else if (itemPriv->paintNode) {
- delete itemPriv->paintNode;
- itemPriv->paintNode = nullptr;
- }
- }
-
-#ifndef QT_NO_DEBUG
- // Check consistency.
-
- QList<QSGNode *> nodes;
- nodes << itemPriv->itemNodeInstance
- << itemPriv->opacityNode()
- << itemPriv->clipNode()
- << itemPriv->rootNode()
- << itemPriv->paintNode;
- nodes.removeAll(nullptr);
-
- Q_ASSERT(nodes.constFirst() == itemPriv->itemNodeInstance);
- for (int i=1; i<nodes.size(); ++i) {
- QSGNode *n = nodes.at(i);
- // Failing this means we messed up reparenting
- Q_ASSERT(n->parent() == nodes.at(i-1));
- // Only the paintNode and the one who is childContainer may have more than one child.
- Q_ASSERT(n == itemPriv->paintNode || n == itemPriv->childContainerNode() || n->childCount() == 1);
- }
-#endif
-
-}
-
-bool QQuickWindowPrivate::emitError(QQuickWindow::SceneGraphError error, const QString &msg)
-{
- Q_Q(QQuickWindow);
- static const QMetaMethod errorSignal = QMetaMethod::fromSignal(&QQuickWindow::sceneGraphError);
- if (q->isSignalConnected(errorSignal)) {
- emit q->sceneGraphError(error, msg);
- return true;
- }
- return false;
-}
-
-void QQuickWindow::maybeUpdate()
-{
- Q_D(QQuickWindow);
- if (d->renderControl)
- QQuickRenderControlPrivate::get(d->renderControl)->maybeUpdate();
- else if (d->windowManager)
- d->windowManager->maybeUpdate(this);
-}
-
-void QQuickWindow::cleanupSceneGraph()
-{
- Q_D(QQuickWindow);
- if (!d->renderer)
- return;
-
- delete d->renderer->rootNode();
- delete d->renderer;
- d->renderer = nullptr;
-
- d->runAndClearJobs(&d->beforeSynchronizingJobs);
- d->runAndClearJobs(&d->afterSynchronizingJobs);
- d->runAndClearJobs(&d->beforeRenderingJobs);
- d->runAndClearJobs(&d->afterRenderingJobs);
- d->runAndClearJobs(&d->afterSwapJobs);
-}
-
-void QQuickWindow::setTransientParent_helper(QQuickWindow *window)
-{
- qCDebug(lcTransient) << this << "is transient for" << window;
- setTransientParent(window);
- disconnect(sender(), SIGNAL(windowChanged(QQuickWindow*)),
- this, SLOT(setTransientParent_helper(QQuickWindow*)));
-}
-
-QOpenGLContext *QQuickWindowPrivate::openglContext()
-{
-#if QT_CONFIG(opengl)
- if (context && context->isValid()) {
- QSGRendererInterface *rif = context->sceneGraphContext()->rendererInterface(context);
- if (rif) {
- Q_Q(QQuickWindow);
- return reinterpret_cast<QOpenGLContext *>(rif->getResource(q, QSGRendererInterface::OpenGLContextResource));
- }
- }
-#endif
- return nullptr;
-}
-
-/*!
- Returns true if the scene graph has been initialized; otherwise returns false.
- */
-bool QQuickWindow::isSceneGraphInitialized() const
-{
- Q_D(const QQuickWindow);
- return d->context != nullptr && d->context->isValid();
-}
-
-/*!
- \fn 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.
-*/
-
-/*!
- \qmlsignal QtQuick.Window::Window::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.
- */
-
-/*!
- \fn 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.
- */
-
-/*!
- \qmlsignal QtQuick.Window::Window::sceneGraphInitialized()
- \internal
- */
-
-/*!
- \fn 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.
- */
-
-/*!
- \qmlsignal QtQuick.Window::Window::sceneGraphInvalidated()
- \internal
- */
-
-/*!
- \fn void QQuickWindow::sceneGraphError(SceneGraphError error, const QString &message)
-
- This signal is emitted when an \a 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 \a message, or show a message box, and terminate the application.
-
- This signal will be emitted from the GUI thread.
-
- \since 5.3
- */
-
-/*!
- \qmlsignal QtQuick.Window::Window::sceneGraphError(SceneGraphError error, QString message)
-
- This signal is emitted when an \a error occurred during scene graph initialization.
-
- You can implement onSceneGraphError(error, message) to handle errors,
- such as graphics context creation failures, in a custom way.
- If no handler is connected to this signal, Quick will print the \a message,
- or show a message box, and terminate the application.
-
- \since 5.3
- */
-
-/*!
- \class QQuickCloseEvent
- \internal
- \since 5.1
-
- \inmodule QtQuick
-
- \brief Notification that a \l QQuickWindow is about to be closed
-*/
-/*!
- \qmltype CloseEvent
- \instantiates QQuickCloseEvent
- \inqmlmodule QtQuick.Window
- \ingroup qtquick-visual
- \brief Notification that a \l Window is about to be closed.
- \since 5.1
-
- Notification that a window is about to be closed by the windowing system
- (e.g. the user clicked the title bar close button). The CloseEvent contains
- an accepted property which can be set to false to abort closing the window.
-
- \sa QQuickWindow::closing()
-*/
-
-/*!
- \qmlproperty bool CloseEvent::accepted
-
- This property indicates whether the application will allow the user to
- close the window. It is true by default.
-*/
-
-/*!
- \fn void QQuickWindow::closing(QQuickCloseEvent *close)
- \since 5.1
-
- This signal is emitted when the window receives the event \a close from
- the windowing system.
-
- On \macOs, Qt will create a menu item \c Quit if there is no menu item
- whose text is "quit" or "exit". This menu item calls the \c QCoreApplication::quit
- signal, not the \c QQuickWindow::closing() signal.
-
- \sa {QMenuBar as a Global Menu Bar}
-*/
-
-/*!
- \qmlsignal QtQuick.Window::Window::closing(CloseEvent close)
- \since 5.1
-
- This signal is emitted when the user tries to close the window.
-
- This signal includes a \a close parameter. The \c {close.accepted}
- property is true by default so that the window is allowed to close; but you
- can implement an \c onClosing handler and set \c {close.accepted = false} if
- you need to do something else before the window can be closed.
- */
-
-/*!
- Sets the render target for this window to be \a 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
- \a 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 \a target.
-
- For example, assuming the scenegraph is using Vulkan to render, one can
- redirect its output into a \c 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.
-
- \badcode
- QQuickRenderTarget rt = QQuickRenderTarget::fromVulkanImage(vulkanImage, VK_IMAGE_LAYOUT_PREINITIALIZED, pixelSize);
- quickWindow->setRenderTarget(rt);
- \endcode
-
- 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 \a 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.
-
- \note This function should not be used when using the \c software backend.
- Instead, use grabWindow() to render the content into a QImage.
-
- \note The window does not take ownership of any native objects referenced
- in \a target.
-
- \note It is the caller's responsibility to ensure the native objects
- referred to in \a target are valid for the scenegraph renderer too. For
- instance, with Vulkan, Metal, and Direct3D this implies that the texture or
- image is created on the same graphics device that is used by the scenegraph
- internally. Therefore, when texture objects created on an already existing
- device or context are involved, this function is often used in combination
- with setGraphicsDevice().
-
- \note With graphics APIs where relevant, the application must pay attention
- to image layout transitions performed by the scenegraph. For example, once
- a VkImage is associated with the scenegraph by calling this function, its
- layout will transition to \c VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL when
- rendering a frame.
-
- \warning This function can only be called from the thread doing the
- rendering.
-
- \since 6.0
-
- \sa QQuickRenderControl, setGraphicsDevice(), setGraphicsApi()
- */
-void QQuickWindow::setRenderTarget(const QQuickRenderTarget &target)
-{
- Q_D(QQuickWindow);
- if (target != d->customRenderTarget) {
- d->customRenderTarget = target;
- d->redirect.renderTargetDirty = true;
- }
-}
-
-/*!
- \return the QQuickRenderTarget passed to setRenderTarget(), or a default
- constructed one otherwise
-
- \since 6.0
-
- \sa setRenderTarget()
- */
-QQuickRenderTarget QQuickWindow::renderTarget() const
-{
- Q_D(const QQuickWindow);
- return d->customRenderTarget;
-}
-
-/*!
- 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 \l{QWindow::create()} {created}
- and has a valid size and that no other QQuickWindow instances are rendering
- in the same process.
-
- \note When using this window in combination with QQuickRenderControl, the
- result of this function is an empty image, unless the \c software backend
- is in use. This is because when redirecting the output to an
- application-managed graphics resource (such as, a texture) by using
- QQuickRenderControl and setRenderTarget(), the application is better suited
- for managing and executing an eventual read back operation, since it is in
- full control of the resource to begin with.
-
- \warning Calling this function will cause performance problems.
-
- \warning This function can only be called from the GUI thread.
- */
-QImage QQuickWindow::grabWindow()
-{
- Q_D(QQuickWindow);
-
- if (!isVisible() && !d->renderControl) {
- // backends like software can grab regardless of the window state
- if (d->windowManager && (d->windowManager->flags() & QSGRenderLoop::SupportsGrabWithoutExpose))
- return d->windowManager->grab(this);
-
- if (!isSceneGraphInitialized() && QSGRhiSupport::instance()->isRhiEnabled()) {
- // We do not have rendering up and running. Forget the render loop,
- // do a frame completely offscreen and synchronously into a
- // texture. This can be *very* slow due to all the device/context
- // and resource initialization but the documentation warns for it,
- // and is still important for some use cases.
- Q_ASSERT(!d->rhi);
- return QSGRhiSupport::instance()->grabOffscreen(this);
- }
- }
-
- // The common case: we have an exposed window with an initialized
- // scenegraph, meaning we can request grabbing via the render loop, or we
- // are not targeting the window, in which case the request is to be
- // forwarded to the rendercontrol.
- if (d->renderControl)
- return QQuickRenderControlPrivate::get(d->renderControl)->grab();
- else if (d->windowManager)
- return d->windowManager->grab(this);
- return QImage();
-}
-
-/*!
- 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 \l{QQmlEngine::setIncubationController()}.
-
- The controller is owned by the window and will be destroyed when the window
- is deleted.
-*/
-QQmlIncubationController *QQuickWindow::incubationController() const
-{
- Q_D(const QQuickWindow);
-
- if (!d->windowManager)
- return nullptr; // TODO: make sure that this is safe
-
- if (!d->incubationController)
- d->incubationController = new QQuickWindowIncubationController(d->windowManager);
- return d->incubationController;
-}
-
-
-
-/*!
- \enum QQuickWindow::CreateTextureOption
-
- The CreateTextureOption enums are used to customize a texture is wrapped.
-
- \value TextureHasAlphaChannel The texture has an alpha channel and should
- be drawn using blending.
-
- \value TextureHasMipmaps The texture has mipmaps and can be drawn with
- mipmapping enabled.
-
- \value TextureOwnsGLTexture As of Qt 6.0, this flag is not used in practice
- and is ignored. Native graphics resource ownership is not transferable to
- the wrapping QSGTexture, because Qt Quick may not have the necessary details
- on how such an object and the associated memory should be freed.
-
- \value TextureCanUseAtlas The image can be uploaded into a texture atlas.
-
- \value TextureIsOpaque The texture will return false for
- QSGTexture::hasAlphaChannel() and will not be blended. This flag was added
- in Qt 5.6.
-
- */
-
-/*!
- \enum QQuickWindow::SceneGraphError
-
- This enum describes the error in a sceneGraphError() signal.
-
- \value ContextNotAvailable graphics context creation failed. This typically means that
- no suitable OpenGL implementation was found, for example because no graphics drivers
- are installed and so no OpenGL 2 support is present. On mobile and embedded boards
- that use OpenGL ES such an error is likely to indicate issues in the windowing system
- integration and possibly an incorrect configuration of Qt.
-
- \since 5.3
- */
-
-/*!
- \enum QQuickWindow::TextRenderType
- \since 5.10
-
- This enum describes the default render type of text-like elements in Qt
- Quick (\l Text, \l TextInput, etc.).
-
- Select NativeTextRendering if you prefer text to look native on the target
- platform and do not require advanced features such as transformation of the
- text. Using such features in combination with the NativeTextRendering
- render type will lend poor and sometimes pixelated results.
-
- \value QtTextRendering Use Qt's own rasterization algorithm.
-
- \value NativeTextRendering Use the operating system's native rasterizer for text.
-*/
-
-/*!
- \fn 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.
-
- \warning This signal is emitted from the scene graph rendering thread. If your
- slot function needs to finish before execution continues, you must make sure that
- the connection is direct (see Qt::ConnectionType).
-
- \warning When using OpenGL, be aware that setting OpenGL 3.x or 4.x specific
- states and leaving these enabled or set to non-default values when returning
- from the connected slot can interfere with the scene graph's rendering.
-*/
-
-/*!
- \qmlsignal QtQuick.Window::Window::beforeSynchronizing()
- \internal
-*/
-
-/*!
- \fn 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.
-
- \warning This signal is emitted from the scene graph rendering thread. If your
- slot function needs to finish before execution continues, you must make sure that
- the connection is direct (see Qt::ConnectionType).
-
- \warning When using OpenGL, be aware that setting OpenGL 3.x or 4.x specific
- states and leaving these enabled or set to non-default values when returning
- from the connected slot can interfere with the scene graph's rendering.
-
- \since 5.3
- */
-
-/*!
- \qmlsignal QtQuick.Window::Window::afterSynchronizing()
- \internal
- \since 5.3
- */
-
-/*!
- \fn 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.
-
- \warning This signal is emitted from the scene graph rendering thread. If your
- slot function needs to finish before execution continues, you must make sure that
- the connection is direct (see Qt::ConnectionType).
-
- \warning When using OpenGL, be aware that setting OpenGL 3.x or 4.x specific
- states and leaving these enabled or set to non-default values when returning
- from the connected slot can interfere with the scene graph's rendering.
-
- \sa rendererInterface(), {Scene Graph - OpenGL Under QML}, {Scene Graph - Metal Under QML},
- {Scene Graph - Vulkan Under QML}, {Scene Graph - Direct3D 11 Under QML}
-*/
-
-/*!
- \qmlsignal QtQuick.Window::Window::beforeRendering()
- \internal
-*/
-
-/*!
- \fn 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.
-
- \warning This signal is emitted from the scene graph rendering thread. If your
- slot function needs to finish before execution continues, you must make sure that
- the connection is direct (see Qt::ConnectionType).
-
- \warning When using OpenGL, be aware that setting OpenGL 3.x or 4.x specific
- states and leaving these enabled or set to non-default values when returning
- from the connected slot can interfere with the scene graph's rendering.
-
- \sa rendererInterface(), {Scene Graph - OpenGL Under QML}, {Scene Graph - Metal Under QML},
- {Scene Graph - Vulkan Under QML}, {Scene Graph - Direct3D 11 Under QML}
- */
-
-/*!
- \qmlsignal QtQuick.Window::Window::afterRendering()
- \internal
- */
-
-/*!
- \fn 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.
-
- \note Resource updates (uploads, copies) typically cannot be enqueued from
- within a render pass. Therefore, more complex user rendering will need to
- connect to both beforeRendering() and this signal.
-
- \warning This signal is emitted from the scene graph rendering thread. If your
- slot function needs to finish before execution continues, you must make sure that
- the connection is direct (see Qt::ConnectionType).
-
- \sa rendererInterface()
-
- \since 5.14
-*/
-
-/*!
- \qmlsignal QtQuick.Window::Window::beforeRenderPassRecording()
- \internal
- \since 5.14
-*/
-
-/*!
- \fn 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.
-
- \note Resource updates (uploads, copies) typically cannot be enqueued from
- within a render pass. Therefore, more complex user rendering will need to
- connect to both beforeRendering() and this signal.
-
- \warning This signal is emitted from the scene graph rendering thread. If your
- slot function needs to finish before execution continues, you must make sure that
- the connection is direct (see Qt::ConnectionType).
-
- \sa rendererInterface()
-
- \since 5.14
-*/
-
-/*!
- \fn 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.
-
- \warning This signal is emitted from the scene graph rendering thread. If your
- slot function needs to finish before execution continues, you must make sure that
- the connection is direct (see Qt::ConnectionType).
-
- \since 6.0
-
- \sa afterFrameEnd(), rendererInterface()
-*/
-
-/*!
- \qmlsignal QtQuick.Window::Window::beforeFrameBegin()
- \internal
-*/
-
-/*!
- \fn 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.
-
- \note Unlike frameSwapped(), this signal is guaranteed to be emitted also
- when the Qt Quick output is redirected via QQuickRenderControl.
-
- \warning This signal is emitted from the scene graph rendering thread. If your
- slot function needs to finish before execution continues, you must make sure that
- the connection is direct (see Qt::ConnectionType).
-
- \since 6.0
-
- \sa beforeFrameBegin(), rendererInterface()
-*/
-
-/*!
- \qmlsignal QtQuick.Window::Window::afterFrameEnd()
- \internal
-*/
-
-/*!
- \qmlsignal QtQuick.Window::Window::afterRenderPassRecording()
- \internal
- \since 5.14
-*/
-
-/*!
- \fn 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.
-
- \since 5.3
- */
-
-/*!
- \qmlsignal QtQuick.Window::Window::afterAnimating()
-
- This signal is emitted on the GUI thread before requesting the render thread to
- perform the synchronization of the scene graph.
-
- You can implement onAfterAnimating to do additional processing after each animation step.
-
- \since 5.3
- */
-
-/*!
- \fn 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.
-
- \warning This signal is emitted from the scene graph rendering thread. If your
- slot function needs to finish before execution continues, you must make sure that
- the connection is direct (see Qt::ConnectionType).
-
- \warning Make very sure that a signal handler for sceneGraphAboutToStop() leaves the
- graphics context in the same state as it was when the signal handler was entered.
- Failing to do so can result in the scene not rendering properly.
-
- \sa sceneGraphInvalidated()
- \since 5.3
- */
-
-/*!
- \qmlsignal QtQuick.Window::Window::sceneGraphAboutToStop()
- \internal
- \since 5.3
- */
-
-/*!
- \overload
- */
-
-QSGTexture *QQuickWindow::createTextureFromImage(const QImage &image) const
-{
- return createTextureFromImage(image, {});
-}
-
-
-/*!
- Creates a new QSGTexture from the supplied \a 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 \a 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 \a 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 \a 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 \c
- GL_TEXTURE_2D as texture target and \c GL_RGBA as internal format. With
- other graphics APIs, the texture format is typically \c RGBA8. Reimplement
- QSGTexture to create textures with different parameters.
-
- \warning This function will return 0 if the scene graph has not yet been
- initialized.
-
- \warning The returned texture is not memory managed by the scene graph and
- must be explicitly deleted by the caller on the rendering thread.
- This is achieved by deleting the texture from a QSGNode destructor
- or by using deleteLater() in the case where the texture already has affinity
- to the rendering thread.
-
- This function can be called from any thread.
-
- \sa sceneGraphInitialized(), QSGTexture
- */
-
-QSGTexture *QQuickWindow::createTextureFromImage(const QImage &image, CreateTextureOptions options) const
-{
- Q_D(const QQuickWindow);
- if (!isSceneGraphInitialized()) // check both for d->context and d->context->isValid()
- return nullptr;
- uint flags = 0;
- if (options & TextureCanUseAtlas) flags |= QSGRenderContext::CreateTexture_Atlas;
- if (options & TextureHasMipmaps) flags |= QSGRenderContext::CreateTexture_Mipmap;
- if (!(options & TextureIsOpaque)) flags |= QSGRenderContext::CreateTexture_Alpha;
- return d->context->createTexture(image, flags);
-}
-
-QSGTexture *QQuickWindowPrivate::createTextureFromNativeTexture(quint64 nativeObjectHandle,
- int nativeLayout,
- const QSize &size,
- QQuickWindow::CreateTextureOptions options,
- TextureFromNativeTextureFlags flags) const
-{
- if (!rhi)
- return nullptr;
-
- QSGPlainTexture *texture = new QSGPlainTexture;
- texture->setTextureFromNativeTexture(rhi, nativeObjectHandle, nativeLayout,
- size, options, flags);
- texture->setHasAlphaChannel(options & QQuickWindow::TextureHasAlphaChannel);
- // note that the QRhiTexture does not (and cannot) own the native object
- texture->setOwnsTexture(true); // texture meaning the QRhiTexture here, not the native object
- texture->setTextureSize(size);
- return texture;
-}
-
-/*!
- \qmlproperty color Window::color
-
- The background color for the window.
-
- Setting this property is more efficient than using a separate Rectangle.
-*/
-
-/*!
- \property QQuickWindow::color
- \brief The color used to clear the color buffer at the beginning of each frame.
-
- By default, the clear color is white.
-
- \sa setDefaultAlphaBuffer()
- */
-
-void QQuickWindow::setColor(const QColor &color)
-{
- Q_D(QQuickWindow);
- if (color == d->clearColor)
- return;
-
- if (color.alpha() != d->clearColor.alpha()) {
- QSurfaceFormat fmt = requestedFormat();
- if (color.alpha() < 255)
- fmt.setAlphaBufferSize(8);
- else
- fmt.setAlphaBufferSize(-1);
- setFormat(fmt);
- }
- d->clearColor = color;
- emit colorChanged(color);
- update();
-}
-
-QColor QQuickWindow::color() const
-{
- return d_func()->clearColor;
-}
-
-/*!
- \brief Returns whether to use alpha transparency on newly created windows.
-
- \since 5.1
- \sa setDefaultAlphaBuffer()
- */
-bool QQuickWindow::hasDefaultAlphaBuffer()
-{
- return QQuickWindowPrivate::defaultAlphaBuffer;
-}
-
-/*!
- \brief \a useAlpha specifies whether to use alpha transparency on newly created windows.
- \since 5.1
-
- 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.
-
- \sa hasDefaultAlphaBuffer()
- */
-void QQuickWindow::setDefaultAlphaBuffer(bool useAlpha)
-{
- QQuickWindowPrivate::defaultAlphaBuffer = useAlpha;
-}
-
-/*!
- \struct QQuickWindow::GraphicsStateInfo
- \inmodule QtQuick
- \since 5.14
-
- \brief Describes some of the RHI's graphics state at the point of a
- \l{QQuickWindow::beginExternalCommands()}{beginExternalCommands()} call.
- */
-
-/*!
- \return 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.
- */
-const QQuickWindow::GraphicsStateInfo &QQuickWindow::graphicsStateInfo()
-{
- Q_D(QQuickWindow);
- if (d->rhi) {
- d->rhiStateInfo.currentFrameSlot = d->rhi->currentFrameSlot();
- d->rhiStateInfo.framesInFlight = d->rhi->resourceLimit(QRhi::FramesInFlight);
- }
- return d->rhiStateInfo;
-}
-
-/*!
- 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
- \l{QSGRenderNode::render()}{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().
-
- \warning Watch out for the fact that
- QSGRendererInterface::CommandListResource may return a different object
- between beginExternalCommands() - endExternalCommands(). This can happen
- when the underlying implementation provides a dedicated secondary command
- buffer for recording external graphics commands within a render pass.
- Therefore, always query CommandListResource after calling this function. Do
- not attempt to reuse an object from an earlier query.
-
- \note When the scenegraph is using OpenGL, pay attention to the fact that
- the OpenGL state in the context can have arbitrary settings, and this
- function does not perform any resetting of the state back to defaults.
-
- \sa endExternalCommands(), QQuickOpenGLUtils::resetOpenGLState()
-
- \since 5.14
- */
-void QQuickWindow::beginExternalCommands()
-{
- Q_D(QQuickWindow);
- if (d->rhi && d->context && d->context->isValid()) {
- QSGDefaultRenderContext *rc = static_cast<QSGDefaultRenderContext *>(d->context);
- QRhiCommandBuffer *cb = rc->currentFrameCommandBuffer();
- if (cb)
- cb->beginExternal();
- }
-}
-
-/*!
- 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
- \l{QSGRenderNode::render()}{render()} implementation of a QSGRenderNode
- because the scene graph performs the necessary steps implicitly for render
- nodes.
-
- \sa beginExternalCommands(), QQuickOpenGLUtils::resetOpenGLState()
-
- \since 5.14
- */
-void QQuickWindow::endExternalCommands()
-{
- Q_D(QQuickWindow);
- if (d->rhi && d->context && d->context->isValid()) {
- QSGDefaultRenderContext *rc = static_cast<QSGDefaultRenderContext *>(d->context);
- QRhiCommandBuffer *cb = rc->currentFrameCommandBuffer();
- if (cb)
- cb->endExternal();
- }
-}
-
-/*!
- \qmlproperty string Window::title
-
- The window's title in the windowing system.
-
- The window title might appear in the title area of the window decorations,
- depending on the windowing system and the window flags. It might also
- be used by the windowing system to identify the window in other contexts,
- such as in the task switcher.
- */
-
-/*!
- \qmlproperty Qt::WindowModality Window::modality
-
- The modality of the window.
-
- A modal window prevents other windows from receiving input events.
- Possible values are Qt.NonModal (the default), Qt.WindowModal,
- and Qt.ApplicationModal.
- */
-
-/*!
- \qmlproperty Qt::WindowFlags Window::flags
-
- The window flags of the window.
-
- The window flags control the window's appearance in the windowing system,
- whether it's a dialog, popup, or a regular window, and whether it should
- have a title bar, etc.
-
- The flags which you read from this property might differ from the ones
- that you set if the requested flags could not be fulfilled.
-
- \sa Qt::WindowFlags
- */
-
-/*!
- \qmlattachedproperty Window Window::window
- \since 5.7
-
- This attached property holds the item's window.
- The Window attached property can be attached to any Item.
-*/
-
-/*!
- \qmlattachedproperty int Window::width
- \qmlattachedproperty int Window::height
- \since 5.5
-
- These attached properties hold the size of the item's window.
- The Window attached property can be attached to any Item.
-*/
-
-/*!
- \qmlproperty int Window::x
- \qmlproperty int Window::y
- \qmlproperty int Window::width
- \qmlproperty int Window::height
-
- Defines the window's position and size.
-
- The (x,y) position is relative to the \l Screen if there is only one,
- or to the virtual desktop (arrangement of multiple screens).
-
- \qml
- Window { x: 100; y: 100; width: 100; height: 100 }
- \endqml
-
- \image screen-and-window-dimensions.jpg
- */
-
-/*!
- \qmlproperty int Window::minimumWidth
- \qmlproperty int Window::minimumHeight
- \since 5.1
-
- Defines the window's minimum size.
-
- This is a hint to the window manager to prevent resizing below the specified
- width and height.
- */
-
-/*!
- \qmlproperty int Window::maximumWidth
- \qmlproperty int Window::maximumHeight
- \since 5.1
-
- Defines the window's maximum size.
-
- This is a hint to the window manager to prevent resizing above the specified
- width and height.
- */
-
-/*!
- \qmlproperty bool Window::visible
-
- Whether the window is visible on the screen.
-
- Setting visible to false is the same as setting \l visibility to \l {QWindow::}{Hidden}.
-
- \sa visibility
- */
-
-/*!
- \qmlproperty QWindow::Visibility Window::visibility
-
- The screen-occupation state of the window.
-
- Visibility is whether the window should appear in the windowing system as
- normal, minimized, maximized, fullscreen or hidden.
-
- To set the visibility to \l {QWindow::}{AutomaticVisibility} means to give the
- window a default visible state, which might be \l {QWindow::}{FullScreen} or
- \l {QWindow::}{Windowed} depending on the platform. However when reading the
- visibility property you will always get the actual state, never
- \c AutomaticVisibility.
-
- When a window is not visible its visibility is Hidden, and setting
- visibility to \l {QWindow::}{Hidden} is the same as setting \l visible to \c false.
-
- \sa visible
- \since 5.1
- */
-
-/*!
- \qmlattachedproperty QWindow::Visibility Window::visibility
- \since 5.4
-
- This attached property holds whether the window is currently shown
- in the windowing system as normal, minimized, maximized, fullscreen or
- hidden. The \c Window attached property can be attached to any Item. If the
- item is not shown in any window, the value will be \l {QWindow::}{Hidden}.
-
- \sa visible, visibility
-*/
-
-/*!
- \qmlproperty Item Window::contentItem
- \readonly
- \brief The invisible root item of the scene.
-*/
-
-/*!
- \qmlproperty Qt::ScreenOrientation Window::contentOrientation
-
- This is a hint to the window manager in case it needs to display
- additional content like popups, dialogs, status bars, or similar
- in relation to the window.
-
- The recommended orientation is \l {Screen::orientation}{Screen.orientation}, but
- an application doesn't have to support all possible orientations,
- and thus can opt to ignore the current screen orientation.
-
- The difference between the window and the content orientation
- determines how much to rotate the content by.
-
- The default value is Qt::PrimaryOrientation.
-
- \sa Screen
-
- \since 5.1
- */
-
-/*!
- \qmlproperty real Window::opacity
-
- The opacity of the window.
-
- If the windowing system supports window opacity, this can be used to fade the
- window in and out, or to make it semitransparent.
-
- A value of 1.0 or above is treated as fully opaque, whereas a value of 0.0 or below
- is treated as fully transparent. Values inbetween represent varying levels of
- translucency between the two extremes.
-
- The default value is 1.0.
-
- \since 5.1
- */
-
-/*!
- \qmlproperty variant Window::screen
-
- The screen with which the window is associated.
-
- If specified before showing a window, will result in the window being shown
- on that screen, unless an explicit window position has been set. The value
- must be an element from the Qt.application.screens array.
-
- \note To ensure that the window is associated with the desired screen when
- the underlying native window is created, make sure this property is set as
- early as possible and that the setting of its value is not deferred. This
- can be particularly important on embedded platforms without a windowing system,
- where only one window per screen is allowed at a time. Setting the screen after
- a window has been created does not move the window if the new screen is part of
- the same virtual desktop as the old screen.
-
- \since 5.9
-
- \sa QWindow::setScreen(), QWindow::screen(), QScreen, {QtQml::Qt::application}{Qt.application}
- */
-
-/*!
- \qmlproperty QWindow Window::transientParent
- \since 5.13
-
- The window for which this window is a transient pop-up.
-
- This is a hint to the window manager that this window is a dialog or pop-up
- on behalf of the transient parent. It usually means that the transient
- window will be centered over its transient parent when it is initially
- shown, that minimizing the parent window will also minimize the transient
- window, and so on; however results vary somewhat from platform to platform.
-
- Normally if you declare a Window inside an Item or inside another Window,
- this relationship is deduced automatically. In that case, if you declare
- this window's \l visible property \c true, it will not actually be shown
- until the \c transientParent window is shown.
-
- However if you set this property, then Qt Quick will no longer wait until
- the \c transientParent window is shown before showing this window. If you
- want to to be able to show a transient window independently of the "parent"
- Item or Window within which it was declared, you can remove that
- relationship by setting \c transientParent to \c null:
-
- \qml
- import QtQuick.Window 2.13
-
- Window {
- // visible is false by default
- Window {
- transientParent: null
- visible: true
- }
- }
- \endqml
-
- In order to cause the window to be centered above its transient parent by
- default, depending on the window manager, it may also be necessary to set
- the \l Window::flags property with a suitable \l Qt::WindowType (such as
- \c Qt::Dialog).
-*/
-
-/*!
- \property QQuickWindow::transientParent
- \brief The window for which this window is a transient pop-up.
- \since 5.13
-
- This is a hint to the window manager that this window is a dialog or pop-up
- on behalf of the transient parent, which may be any kind of \l QWindow.
-
- In order to cause the window to be centered above its transient parent by
- default, depending on the window manager, it may also be necessary to set
- the \l flags property with a suitable \l Qt::WindowType (such as \c Qt::Dialog).
-
- \sa parent()
- */
-
-/*!
- \qmlproperty Item Window::activeFocusItem
- \since 5.1
-
- The item which currently has active focus or \c null if there is
- no item with active focus.
- */
-
-/*!
- \qmlattachedproperty Item Window::activeFocusItem
- \since 5.4
-
- This attached property holds the item which currently has active focus or
- \c null if there is no item with active focus. The Window attached property
- can be attached to any Item.
-*/
-
-/*!
- \qmlproperty bool Window::active
- \since 5.1
-
- The active status of the window.
-
- \sa requestActivate()
- */
-
-/*!
- \qmlattachedproperty bool Window::active
- \since 5.4
-
- This attached property tells whether the window is active. The Window
- attached property can be attached to any Item.
-
- Here is an example which changes a label to show the active state of the
- window in which it is shown:
-
- \qml
- import QtQuick 2.4
- import QtQuick.Window 2.2
-
- Text {
- text: Window.active ? "active" : "inactive"
- }
- \endqml
-*/
-
-/*!
- \qmlmethod QtQuick::Window::requestActivate()
- \since 5.1
-
- Requests the window to be activated, i.e. receive keyboard focus.
- */
-
-/*!
- \qmlmethod QtQuick::Window::alert(int msec)
- \since 5.1
-
- Causes an alert to be shown for \a msec milliseconds. If \a msec is \c 0
- (the default), then the alert is shown indefinitely until the window
- becomes active again.
-
- In alert state, the window indicates that it demands attention, for example
- by flashing or bouncing the taskbar entry.
-*/
-
-/*!
- \qmlmethod QtQuick::Window::close()
-
- Closes the window.
-
- When this method is called, or when the user tries to close the window by
- its title bar button, the \l closing signal will be emitted. If there is no
- handler, or the handler does not revoke permission to close, the window
- will subsequently close. If the QGuiApplication::quitOnLastWindowClosed
- property is \c true, and there are no other windows open, the application
- will quit.
-*/
-
-/*!
- \qmlmethod QtQuick::Window::raise()
-
- Raises the window in the windowing system.
-
- Requests that the window be raised to appear above other windows.
-*/
-
-/*!
- \qmlmethod QtQuick::Window::lower()
-
- Lowers the window in the windowing system.
-
- Requests that the window be lowered to appear below other windows.
-*/
-
-/*!
- \qmlmethod QtQuick::Window::show()
-
- Shows the window.
-
- This is equivalent to calling showFullScreen(), showMaximized(), or showNormal(),
- depending on the platform's default behavior for the window type and flags.
-
- \sa showFullScreen(), showMaximized(), showNormal(), hide(), QQuickItem::flags()
-*/
-
-/*!
- \qmlmethod QtQuick::Window::hide()
-
- Hides the window.
-
- Equivalent to setting \l visible to \c false or \l visibility to \l {QWindow::}{Hidden}.
-
- \sa show()
-*/
-
-/*!
- \qmlmethod QtQuick::Window::showMinimized()
-
- Shows the window as minimized.
-
- Equivalent to setting \l visibility to \l {QWindow::}{Minimized}.
-*/
-
-/*!
- \qmlmethod QtQuick::Window::showMaximized()
-
- Shows the window as maximized.
-
- Equivalent to setting \l visibility to \l {QWindow::}{Maximized}.
-*/
-
-/*!
- \qmlmethod QtQuick::Window::showFullScreen()
-
- Shows the window as fullscreen.
-
- Equivalent to setting \l visibility to \l {QWindow::}{FullScreen}.
-*/
-
-/*!
- \qmlmethod QtQuick::Window::showNormal()
-
- Shows the window as normal, i.e. neither maximized, minimized, nor fullscreen.
-
- Equivalent to setting \l visibility to \l {QWindow::}{Windowed}.
-*/
-
-/*!
- \enum QQuickWindow::RenderStage
- \since 5.4
-
- \value BeforeSynchronizingStage Before synchronization.
- \value AfterSynchronizingStage After synchronization.
- \value BeforeRenderingStage Before rendering.
- \value AfterRenderingStage After rendering.
- \value AfterSwapStage After the frame is swapped.
- \value NoStage As soon as possible. This value was added in Qt 5.6.
-
- \sa {Scene Graph and Rendering}
- */
-
-/*!
- \since 5.4
-
- Schedules \a job to run when the rendering of this window reaches
- the given \a stage.
-
- This is a convenience to the equivalent signals in QQuickWindow for
- "one shot" tasks.
-
- The window takes ownership over \a job and will delete it when the
- job is completed.
-
- If rendering is shut down before \a 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 \a stage is \l NoStage, \a 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 \l NoStage jobs.
-
- \note This function does not trigger rendering; the jobs targeting any other
- stage than NoStage will be stored run until rendering is triggered elsewhere.
- To force the job to run earlier, call QQuickWindow::update();
-
- \sa beforeRendering(), afterRendering(), beforeSynchronizing(),
- afterSynchronizing(), frameSwapped(), sceneGraphInvalidated()
- */
-
-void QQuickWindow::scheduleRenderJob(QRunnable *job, RenderStage stage)
-{
- Q_D(QQuickWindow);
-
- d->renderJobMutex.lock();
- if (stage == BeforeSynchronizingStage) {
- d->beforeSynchronizingJobs << job;
- } else if (stage == AfterSynchronizingStage) {
- d->afterSynchronizingJobs << job;
- } else if (stage == BeforeRenderingStage) {
- d->beforeRenderingJobs << job;
- } else if (stage == AfterRenderingStage) {
- d->afterRenderingJobs << job;
- } else if (stage == AfterSwapStage) {
- d->afterSwapJobs << job;
- } else if (stage == NoStage) {
- if (d->renderControl && d->rhi && d->rhi->thread() == QThread::currentThread()) {
- job->run();
- delete job;
- } else if (isExposed()) {
- d->windowManager->postJob(this, job);
- } else {
- delete job;
- }
- }
- d->renderJobMutex.unlock();
-}
-
-void QQuickWindowPrivate::runAndClearJobs(QList<QRunnable *> *jobs)
-{
- renderJobMutex.lock();
- QList<QRunnable *> jobList = *jobs;
- jobs->clear();
- renderJobMutex.unlock();
-
- for (QRunnable *r : qAsConst(jobList)) {
- r->run();
- delete r;
- }
-}
-
-void QQuickWindow::runJobsAfterSwap()
-{
- Q_D(QQuickWindow);
- d->runAndClearJobs(&d->afterSwapJobs);
-}
-
-/*!
- * Returns the device pixel ratio for this window.
- *
- * This is different from QWindow::devicePixelRatio() in that it supports
- * redirected rendering via QQuickRenderControl. When using a
- * QQuickRenderControl, the QQuickWindow is often not 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. Use this function instead.
- *
- * \sa QWindow::devicePixelRatio()
- */
-qreal QQuickWindow::effectiveDevicePixelRatio() const
-{
- QWindow *w = QQuickRenderControl::renderWindowFor(const_cast<QQuickWindow *>(this));
- return w ? w->devicePixelRatio() : devicePixelRatio();
-}
-
-/*!
- \return the current renderer interface. The value is always valid and is never null.
-
- \note This function can be called at any time after constructing the
- QQuickWindow, even while isSceneGraphInitialized() is still false. However,
- some renderer interface functions, in particular
- QSGRendererInterface::getResource() will not be functional until the
- scenegraph is up and running. Backend queries, like
- QSGRendererInterface::graphicsApi() or QSGRendererInterface::shaderType(),
- will always be functional on the other hand.
-
- \note The ownership of the returned pointer stays with Qt. The returned
- instance may or may not be shared between different QQuickWindow instances,
- depending on the scenegraph backend in use. Therefore applications are
- expected to query the interface object for each QQuickWindow instead of
- reusing the already queried pointer.
-
- \sa QSGRenderNode, QSGRendererInterface
-
- \since 5.8
- */
-QSGRendererInterface *QQuickWindow::rendererInterface() const
-{
- Q_D(const QQuickWindow);
-
- // no context validity check - it is essential to be able to return a
- // renderer interface instance before scenegraphInitialized() is emitted
- // (depending on the backend, that can happen way too late for some of the
- // rif use cases, like examining the graphics api or shading language in
- // use)
-
- return d->context->sceneGraphContext()->rendererInterface(d->context);
-}
-
-/*!
- Requests the specified graphics \a api.
-
- When the built-in, default graphics adaptation is used, \a api specifies
- which graphics API (OpenGL, Vulkan, Metal, or Direct3D) the scene graph
- should use to render. In addition, the \c software backend is built-in as
- well, and can be requested by setting \a 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 \c{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.
-
- \note The call to the function must happen before constructing the first
- QQuickWindow in the application. The graphics API cannot be changed
- afterwards.
-
- \note When used in combination with QQuickRenderControl, this rule is
- relaxed: it is possible to change the graphics API, but only when all
- existing QQuickRenderControl and QQuickWindow instances have been
- destroyed.
-
- To query what graphics API the scene graph is using to render,
- QSGRendererInterface::graphicsApi() after the scene graph
- \l{QQuickWindow::isSceneGraphInitialized()}{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 \a api to
- QSGRendererInterface::Unknown.
-
- \since 5.8
- */
-void QQuickWindow::setGraphicsApi(QSGRendererInterface::GraphicsApi api)
-{
- // Special cases: these are different scenegraph backends.
- switch (api) {
- case QSGRendererInterface::Software:
- setSceneGraphBackend(QStringLiteral("software"));
- break;
- case QSGRendererInterface::OpenVG:
- setSceneGraphBackend(QStringLiteral("openvg"));
- break;
- default:
- break;
- }
-
- // Standard case: tell the QRhi-based default adaptation what graphics api
- // (QRhi backend) to use.
- if (QSGRendererInterface::isApiRhiBased(api) || api == QSGRendererInterface::Unknown)
- QSGRhiSupport::configure(api);
-}
-
-/*!
- \return 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.
-
- \note This static function is intended to be called on the main (GUI)
- thread only. For querying the API when rendering, use QSGRendererInterface
- since that object lives on the render thread.
-
- \note This function does not take scene graph backends into account.
-
- \since 6.0
- */
-QSGRendererInterface::GraphicsApi QQuickWindow::graphicsApi()
-{
- // Note that this applies the settings e.g. from the env vars
- // (QSG_RHI_BACKEND) if it was not done at least once already. Whereas if
- // setGraphicsApi() was called before, or the scene graph is already
- // initialized, then this is just a simple query.
- return QSGRhiSupport::instance()->graphicsApi();
-}
-
-/*!
- Requests a Qt Quick scenegraph \a backend. Backends can either be built-in
- or be installed in form of dynamically loaded plugins.
-
- \overload
-
- \note The call to the function must happen before constructing the first
- QQuickWindow in the application. It cannot be changed afterwards.
-
- If \a backend is invalid or an error occurs, the request is ignored.
-
- \note Calling this function is equivalent to setting the
- \c QT_QUICK_BACKEND or \c QMLSCENE_DEVICE environment variables. However, this
- API is safer to use in applications that spawn other processes as there is
- no need to worry about environment inheritance.
-
- \since 5.8
- */
-void QQuickWindow::setSceneGraphBackend(const QString &backend)
-{
- QSGContext::setBackend(backend);
-}
-
-/*!
- Returns the requested Qt Quick scenegraph backend.
-
- \note The return value of this function may still be outdated by
- subsequent calls to setSceneGraphBackend() until the first QQuickWindow in the
- application has been constructed.
-
- \note The value only reflects the request in the \c{QT_QUICK_BACKEND}
- environment variable after a QQuickWindow has been constructed.
-
- \since 5.9
- */
-QString QQuickWindow::sceneGraphBackend()
-{
- return QSGContext::backend();
-}
-
-/*!
- Sets the graphics device objects for this window. The scenegraph will use
- existing device, physical device, and other objects specified by \a 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 \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 \c VkPhysicalDevice, \c 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.
-
- \warning This function can only be called before initializing the
- scenegraph and will have no effect if called afterwards. In practice this
- typically means calling it right before QQuickRenderControl::initialize().
-
- As an example, this time with Direct3D, the typical usage is expected to be
- the following:
-
- \badcode
- // 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);
- ...
- \endcode
-
- The key aspect of using this function is to ensure that resources or
- handles to resources, such as \c 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).
-
- \note Using QQuickRenderControl does not always imply having to call this
- function. When adopting an existing device or context is not needed, this
- function should not be called, and the scene graph will then initialize its
- own devices and contexts normally, just as it would with an on-screen
- QQuickWindow.
-
- \since 6.0
-
- \sa QQuickRenderControl, setRenderTarget(), setGraphicsApi()
- */
-void QQuickWindow::setGraphicsDevice(const QQuickGraphicsDevice &device)
-{
- Q_D(QQuickWindow);
- d->customDeviceObjects = device;
-}
-
-/*!
- \return the QQuickGraphicsDevice passed to setGraphicsDevice(), or a
- default constructed one otherwise
-
- \since 6.0
-
- \sa setGraphicsDevice()
- */
-QQuickGraphicsDevice QQuickWindow::graphicsDevice() const
-{
- Q_D(const QQuickWindow);
- return d->customDeviceObjects;
-}
-
-/*!
- Sets the graphics configuration for this window. \a 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.
-
- \note The configuration is ignored when adopting existing graphics devices
- via setGraphicsDevice() since the scene graph is then not in control of the
- actual construction of those objects.
-
- QQuickGraphicsConfiguration instances are implicitly shared, copyable, and
- can be passed by value.
-
- \warning Setting a QQuickGraphicsConfiguration on a QQuickWindow must
- happen early enough, before the scene graph is initialized for the first
- time for that window. With on-screen windows this means the call must be
- done before invoking show() on the QQuickWindow or QQuickView. With
- QQuickRenderControl the configuration must be finalized before calling
- \l{QQuickRenderControl::initialize()}{initialize()}.
-
- \since 6.0
- */
-void QQuickWindow::setGraphicsConfiguration(const QQuickGraphicsConfiguration &config)
-{
- Q_D(QQuickWindow);
- d->graphicsConfig = config;
-}
-
-/*!
- \return the QQuickGraphicsDevice passed to setGraphicsDevice(), or a
- default constructed one otherwise
-
- \since 6.0
-
- \sa setGraphicsConfiguration()
- */
-QQuickGraphicsConfiguration QQuickWindow::graphicsConfiguration() const
-{
- Q_D(const QQuickWindow);
- return d->graphicsConfig;
-}
-
-/*!
- 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.
-
- \since 5.8
- \sa QSGRectangleNode
- */
-QSGRectangleNode *QQuickWindow::createRectangleNode() const
-{
- Q_D(const QQuickWindow);
- return isSceneGraphInitialized() ? d->context->sceneGraphContext()->createRectangleNode() : nullptr;
-}
-
-/*!
- 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.
-
- \since 5.8
- \sa QSGImageNode
- */
-QSGImageNode *QQuickWindow::createImageNode() const
-{
- Q_D(const QQuickWindow);
- return isSceneGraphInitialized() ? d->context->sceneGraphContext()->createImageNode() : nullptr;
-}
-
-/*!
- Creates a nine patch node. When the scenegraph is not initialized, the return value is null.
-
- \since 5.8
- */
-QSGNinePatchNode *QQuickWindow::createNinePatchNode() const
-{
- Q_D(const QQuickWindow);
- return isSceneGraphInitialized() ? d->context->sceneGraphContext()->createNinePatchNode() : nullptr;
-}
-
-/*!
- \since 5.10
-
- Returns the render type of text-like elements in Qt Quick.
- The default is QQuickWindow::QtTextRendering.
-
- \sa setTextRenderType()
-*/
-QQuickWindow::TextRenderType QQuickWindow::textRenderType()
-{
- return QQuickWindowPrivate::textRenderType;
-}
-
-/*!
- \since 5.10
-
- Sets the default render type of text-like elements in Qt Quick to \a renderType.
-
- \note setting the render type will only affect elements created afterwards;
- the render type of existing elements will not be modified.
-
- \sa textRenderType()
-*/
-void QQuickWindow::setTextRenderType(QQuickWindow::TextRenderType renderType)
-{
- QQuickWindowPrivate::textRenderType = renderType;
-}
-
-
-/*!
- \since 6.0
- \qmlproperty QQuickPalette Window::palette
-
- This property holds the palette currently set for the window.
-
- The default palette depends on the system environment. QGuiApplication maintains a system/theme
- palette which serves as a default for all application windows. You can also set the default palette
- for windows by passing a custom palette to QGuiApplication::setPalette(), before loading any QML.
-
- ApplicationWindow propagates explicit palette properties to child controls. If you change a specific
- property on the window's palette, that property propagates to all child controls in the window,
- overriding any system defaults for that property.
-
- \sa Item::palette, Popup::palette, QQuickColorGroup
- //! internal \sa QQuickAbstractPaletteProvider, QQuickPalette
-*/
-
-#ifndef QT_NO_DEBUG_STREAM
-QDebug operator<<(QDebug debug, const QQuickWindow *win)
-{
- QDebugStateSaver saver(debug);
- debug.nospace();
- if (!win) {
- debug << "QQuickWindow(0)";
- return debug;
- }
-
- debug << win->metaObject()->className() << '(' << static_cast<const void *>(win);
- if (win->isActive())
- debug << " active";
- if (win->isExposed())
- debug << " exposed";
- debug << ", visibility=" << win->visibility() << ", flags=" << win->flags();
- if (!win->title().isEmpty())
- debug << ", title=" << win->title();
- if (!win->objectName().isEmpty())
- debug << ", name=" << win->objectName();
- if (win->parent())
- debug << ", parent=" << static_cast<const void *>(win->parent());
- if (win->transientParent())
- debug << ", transientParent=" << static_cast<const void *>(win->transientParent());
- debug << ", geometry=";
- QtDebugUtils::formatQRect(debug, win->geometry());
- debug << ')';
- return debug;
-}
-#endif
-
-#include "moc_qquickwindow.cpp"
-
QT_END_NAMESPACE