1 files changed, 43 insertions, 52 deletions

diff --git a/src/quick/items/qquickwindow.cpp b/src/quick/items/qquickwindow.cpp
index 156ecdaadb..f68848444e 100644
--- a/src/quick/items/qquickwindow.cpp
+++ b/src/quick/items/qquickwindow.cpp
@@ -428,10 +428,10 @@ static void updatePixelRatioHelper(QQuickItem *item, float pixelRatio)
 void QQuickWindow::physicalDpiChanged()
 {
     Q_D(QQuickWindow);
-    const qreal newPixelRatio = screen()->devicePixelRatio();
-    if (qFuzzyCompare(newPixelRatio, d->devicePixelRatio))
+    const qreal newPixelRatio = effectiveDevicePixelRatio();
+    if (qFuzzyCompare(newPixelRatio, d->lastReportedItemDevicePixelRatio))
         return;
-    d->devicePixelRatio = newPixelRatio;
+    d->lastReportedItemDevicePixelRatio = newPixelRatio;
     if (d->contentItem)
         updatePixelRatioHelper(d->contentItem, newPixelRatio);
 }
@@ -514,7 +514,6 @@ void QQuickWindowPrivate::ensureCustomRenderTarget()
     redirect.renderTargetDirty = false;
 
     redirect.rt.reset(rhi);
-    redirect.devicePixelRatio = customRenderTarget.devicePixelRatio();
 
     // a default constructed QQuickRenderTarget means no redirection
     if (customRenderTarget.isNull())
@@ -535,11 +534,6 @@ void QQuickWindowPrivate::syncSceneGraph()
 
     ensureCustomRenderTarget();
 
-    // Calculate the dpr the same way renderSceneGraph() will.
-    qreal devicePixelRatio = q->effectiveDevicePixelRatio();
-    if (redirect.rt.renderTarget && !QQuickRenderControl::renderWindowFor(q))
-        devicePixelRatio = redirect.devicePixelRatio;
-
     QRhiCommandBuffer *cb = nullptr;
     if (rhi) {
         if (redirect.commandBuffer)
@@ -547,7 +541,7 @@ void QQuickWindowPrivate::syncSceneGraph()
         else
             cb = swapchain->currentFrameCommandBuffer();
     }
-    context->prepareSync(devicePixelRatio, cb, graphicsConfig);
+    context->prepareSync(q->effectiveDevicePixelRatio(), cb, graphicsConfig);
 
     animationController->beforeNodeSync();
 
@@ -646,36 +640,21 @@ void QQuickWindowPrivate::renderSceneGraph(const QSize &size, const QSize &surfa
     const bool flipY = rhi ? !rhi->isYUpInNDC() : false;
     if (flipY)
         matrixFlags |= QSGAbstractRenderer::MatrixTransformFlipY;
+
     const qreal devicePixelRatio = q->effectiveDevicePixelRatio();
-    if (redirect.rt.renderTarget) {
-        const QSize pixelSize = redirect.rt.renderTarget->pixelSize();
-        QRect rect(QPoint(0, 0), pixelSize);
-        renderer->setDeviceRect(rect);
-        renderer->setViewportRect(rect);
-        if (QQuickRenderControl::renderWindowFor(q)) {
-            renderer->setProjectionMatrixToRect(QRect(QPoint(0, 0), size), matrixFlags);
-            renderer->setDevicePixelRatio(devicePixelRatio);
-        } else {
-            const QSizeF logicalSize = pixelSize / redirect.devicePixelRatio;
-            renderer->setProjectionMatrixToRect(QRectF(QPointF(0, 0), logicalSize), matrixFlags);
-            renderer->setDevicePixelRatio(redirect.devicePixelRatio);
-        }
-    } else {
-        QSize pixelSize;
-        QSizeF logicalSize;
-        if (surfaceSize.isEmpty()) {
-            pixelSize = size * devicePixelRatio;
-            logicalSize = size;
-        } else {
-            pixelSize = surfaceSize;
-            logicalSize = QSizeF(surfaceSize) / devicePixelRatio;
-        }
-        QRect rect(QPoint(0, 0), pixelSize);
-        renderer->setDeviceRect(rect);
-        renderer->setViewportRect(rect);
-        renderer->setProjectionMatrixToRect(QRectF(QPoint(0, 0), logicalSize), matrixFlags);
-        renderer->setDevicePixelRatio(devicePixelRatio);
-    }
+    QSize pixelSize;
+    if (redirect.rt.renderTarget)
+        pixelSize = redirect.rt.renderTarget->pixelSize();
+    else if (surfaceSize.isEmpty())
+        pixelSize = size * devicePixelRatio;
+    else
+        pixelSize = surfaceSize;
+    QSizeF logicalSize = QSizeF(pixelSize) / devicePixelRatio;
+
+    renderer->setDevicePixelRatio(devicePixelRatio);
+    renderer->setDeviceRect(QRect(QPoint(0, 0), pixelSize));
+    renderer->setViewportRect(QRect(QPoint(0, 0), pixelSize));
+    renderer->setProjectionMatrixToRect(QRectF(QPointF(0, 0), logicalSize), matrixFlags);
 
     if (rhi) {
         context->renderNextRhiFrame(renderer);
@@ -705,7 +684,7 @@ void QQuickWindowPrivate::renderSceneGraph(const QSize &size, const QSize &surfa
 QQuickWindowPrivate::QQuickWindowPrivate()
     : contentItem(nullptr)
     , dirtyItemList(nullptr)
-    , devicePixelRatio(0)
+    , lastReportedItemDevicePixelRatio(0)
     , context(nullptr)
     , renderer(nullptr)
     , windowManager(nullptr)
@@ -770,7 +749,7 @@ void QQuickWindowPrivate::init(QQuickWindow *c, QQuickRenderControl *control)
     Q_ASSERT(windowManager || renderControl);
 
     if (QScreen *screen = q->screen()) {
-        devicePixelRatio = screen->devicePixelRatio();
+        lastReportedItemDevicePixelRatio = q->effectiveDevicePixelRatio();
         // if the screen changes, then QQuickWindow::handleScreenChanged disconnects
         // and connects to the new screen
         physicalDpiChangedConnection = QObject::connect(screen, &QScreen::physicalDotsPerInchChanged,
@@ -1326,6 +1305,8 @@ QQuickItem *QQuickWindow::contentItem() const
 
     \brief The item which currently has active focus or \c null if there is
     no item with active focus.
+
+    \sa QQuickItem::forceActiveFocus(), {Keyboard Focus in Qt Quick}
 */
 QQuickItem *QQuickWindow::activeFocusItem() const
 {
@@ -3736,21 +3717,31 @@ void QQuickWindow::runJobsAfterSwap()
 }
 
 /*!
- * 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()
+    Returns the device pixel ratio for this window.
+
+    This is different from QWindow::devicePixelRatio() in that it supports
+    redirected rendering via QQuickRenderControl and QQuickRenderTarget. When
+    using a QQuickRenderControl, the QQuickWindow is often not fully created,
+    meaning it is never shown and there is no underlying native window created
+    in the windowing system. As a result, querying properties like the device
+    pixel ratio cannot give correct results. This function takes into account
+    both QQuickRenderControl::renderWindowFor() and
+    QQuickRenderTarget::devicePixelRatio(). When no redirection is in effect,
+    the result is same as QWindow::devicePixelRatio().
+
+    \sa QQuickRenderControl, QQuickRenderTarget, setRenderTarget(), QWindow::devicePixelRatio()
  */
 qreal QQuickWindow::effectiveDevicePixelRatio() const
 {
+    Q_D(const QQuickWindow);
     QWindow *w = QQuickRenderControl::renderWindowFor(const_cast<QQuickWindow *>(this));
-    return w ? w->devicePixelRatio() : devicePixelRatio();
+    if (w)
+        return w->devicePixelRatio();
+
+    if (!d->customRenderTarget.isNull())
+        return d->customRenderTarget.devicePixelRatio();
+
+    return devicePixelRatio();
 }
 
 /*!