Index: /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.cpp
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.cpp	(revision 71073)
+++ /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.cpp	(revision 71074)
@@ -157,4 +157,8 @@
     /** Defines device-pixel-ratio set for HiDPI frame-buffer. */
     void setDevicePixelRatio(double dDevicePixelRatio) { m_dDevicePixelRatio = dDevicePixelRatio; }
+    /** Returns actual device-pixel-ratio set for HiDPI frame-buffer. */
+    double devicePixelRatioActual() const { return m_dDevicePixelRatioActual; }
+    /** Defines actual device-pixel-ratio set for HiDPI frame-buffer. */
+    void setDevicePixelRatioActual(double dDevicePixelRatioActual) { m_dDevicePixelRatioActual = dDevicePixelRatioActual; }
 
     /** Returns whether frame-buffer should use unscaled HiDPI output. */
@@ -375,4 +379,6 @@
     /** Holds device-pixel-ratio set for HiDPI frame-buffer. */
     double m_dDevicePixelRatio;
+    /** Holds actual device-pixel-ratio set for HiDPI frame-buffer. */
+    double m_dDevicePixelRatioActual;
     /** Holds whether frame-buffer should use unscaled HiDPI output. */
     bool m_fUseUnscaledHiDPIOutput;
@@ -526,4 +532,5 @@
     , m_enmScalingOptimizationType(ScalingOptimizationType_None)
     , m_dDevicePixelRatio(1.0)
+    , m_dDevicePixelRatioActual(1.0)
     , m_fUseUnscaledHiDPIOutput(false)
 {
@@ -1322,5 +1329,5 @@
     /* Take the device-pixel-ratio into account: */
     if (!useUnscaledHiDPIOutput())
-        m_transform = m_transform.scale(devicePixelRatio(), devicePixelRatio());
+        m_transform = m_transform.scale(devicePixelRatioActual(), devicePixelRatioActual());
     m_transform = m_transform.scale(1.0 / devicePixelRatio(), 1.0 / devicePixelRatio());
 }
@@ -1337,11 +1344,11 @@
     /* But if we should scale image by some reason: */
     if (   scaledSize().isValid()
-        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
+        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
     {
         /* Calculate final scaled size: */
         QSize effectiveSize = !scaledSize().isValid() ? pSourceImage->size() : scaledSize();
         /* Take the device-pixel-ratio into account: */
-        if (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0)
-            effectiveSize *= devicePixelRatio();
+        if (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0)
+            effectiveSize *= devicePixelRatioActual();
         /* We scale the image to requested size and retain it
          * by making heap shallow copy of that temporary object: */
@@ -1392,5 +1399,5 @@
     /* If we had to scale image for some reason: */
     if (   scaledSize().isValid()
-        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
+        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
     {
         /* Wipe out copied image: */
@@ -1411,11 +1418,11 @@
     /* But if we should scale image by some reason: */
     if (   scaledSize().isValid()
-        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
+        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
     {
         /* Calculate final scaled size: */
         QSize effectiveSize = !scaledSize().isValid() ? pSourceImage->size() : scaledSize();
         /* Take the device-pixel-ratio into account: */
-        if (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0)
-            effectiveSize *= devicePixelRatio();
+        if (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0)
+            effectiveSize *= devicePixelRatioActual();
         /* We scale the image to requested size and retain it
          * by making heap shallow copy of that temporary object: */
@@ -1482,5 +1489,5 @@
     /* If we had to scale image for some reason: */
     if (   scaledSize().isValid()
-        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
+        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
     {
         /* Wipe out copied image: */
@@ -1685,4 +1692,14 @@
 }
 
+double UIFrameBuffer::devicePixelRatioActual() const
+{
+    return m_pFrameBuffer->devicePixelRatioActual();
+}
+
+void UIFrameBuffer::setDevicePixelRatioActual(double dDevicePixelRatioActual)
+{
+    m_pFrameBuffer->setDevicePixelRatioActual(dDevicePixelRatioActual);
+}
+
 bool UIFrameBuffer::useUnscaledHiDPIOutput() const
 {
Index: /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.h
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.h	(revision 71073)
+++ /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.h	(revision 71074)
@@ -110,4 +110,8 @@
     /** Defines device-pixel-ratio set for HiDPI frame-buffer. */
     void setDevicePixelRatio(double dDevicePixelRatio);
+    /** Returns actual device-pixel-ratio set for HiDPI frame-buffer. */
+    double devicePixelRatioActual() const;
+    /** Defines actual device-pixel-ratio set for HiDPI frame-buffer. */
+    void setDevicePixelRatioActual(double dDevicePixelRatioActual);
 
     /** Returns whether frame-buffer should use unscaled HiDPI output. */
Index: /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp	(revision 71073)
+++ /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp	(revision 71074)
@@ -261,5 +261,5 @@
         // not 3D overlay itself, so for auto scale-up mode we have to take that into account.
         if (!fUseUnscaledHiDPIOutput)
-            dScaleFactorFor3D *= frameBuffer()->devicePixelRatio();
+            dScaleFactorFor3D *= frameBuffer()->devicePixelRatioActual();
 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
         display().NotifyScaleFactorChange(m_uScreenId,
@@ -366,8 +366,9 @@
         /* Assign new frame-buffer logical-size: */
         QSize scaledSize = size();
-        const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
-        scaledSize *= dDevicePixelRatio;
+        const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
+        const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
+        scaledSize *= dDevicePixelRatioFormal;
         if (!frameBuffer()->useUnscaledHiDPIOutput())
-            scaledSize /= dDevicePixelRatio;
+            scaledSize /= dDevicePixelRatioActual;
         frameBuffer()->setScaledSize(scaledSize);
 
@@ -453,18 +454,19 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
-    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatio != 1.0)
-    {
-        rect.moveTo((int)floor((double)rect.x() * dDevicePixelRatio) - 1,
-                    (int)floor((double)rect.y() * dDevicePixelRatio) - 1);
-        rect.setSize(QSize((int)ceil((double)rect.width()  * dDevicePixelRatio) + 2,
-                           (int)ceil((double)rect.height() * dDevicePixelRatio) + 2));
-    }
-    if (dDevicePixelRatio != 1.0)
-    {
-        rect.moveTo((int)floor((double)rect.x() / dDevicePixelRatio) - 1,
-                    (int)floor((double)rect.y() / dDevicePixelRatio) - 1);
-        rect.setSize(QSize((int)ceil((double)rect.width()  / dDevicePixelRatio) + 2,
-                           (int)ceil((double)rect.height() / dDevicePixelRatio) + 2));
+    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
+    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
+    {
+        rect.moveTo((int)floor((double)rect.x() * dDevicePixelRatioActual) - 1,
+                    (int)floor((double)rect.y() * dDevicePixelRatioActual) - 1);
+        rect.setSize(QSize((int)ceil((double)rect.width()  * dDevicePixelRatioActual) + 2,
+                           (int)ceil((double)rect.height() * dDevicePixelRatioActual) + 2));
+    }
+    if (dDevicePixelRatioFormal != 1.0)
+    {
+        rect.moveTo((int)floor((double)rect.x() / dDevicePixelRatioFormal) - 1,
+                    (int)floor((double)rect.y() / dDevicePixelRatioFormal) - 1);
+        rect.setSize(QSize((int)ceil((double)rect.width()  / dDevicePixelRatioFormal) + 2,
+                           (int)ceil((double)rect.height() / dDevicePixelRatioFormal) + 2));
     }
 
@@ -512,5 +514,5 @@
         // not 3D overlay itself, so for auto scale-up mode we have to take that into account.
         if (!fUseUnscaledHiDPIOutput)
-            dScaleFactorFor3D *= frameBuffer()->devicePixelRatio();
+            dScaleFactorFor3D *= frameBuffer()->devicePixelRatioActual();
 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
         display().NotifyScaleFactorChange(m_uScreenId,
@@ -712,8 +714,10 @@
 
         /* Take the scale-factor related attributes into account: */
-        const double dDevicePixelRatio = gpDesktop->devicePixelRatio(machineWindow());
+        const double dDevicePixelRatioFormal = gpDesktop->devicePixelRatio(machineWindow());
+        const double dDevicePixelRatioActual = gpDesktop->devicePixelRatioActual(machineWindow());
         const double dScaleFactor = gEDataManager->scaleFactor(vboxGlobal().managedVMUuid());
         const bool fUseUnscaledHiDPIOutput = gEDataManager->useUnscaledHiDPIOutput(vboxGlobal().managedVMUuid());
-        m_pFrameBuffer->setDevicePixelRatio(dDevicePixelRatio);
+        m_pFrameBuffer->setDevicePixelRatio(dDevicePixelRatioFormal);
+        m_pFrameBuffer->setDevicePixelRatioActual(dDevicePixelRatioActual);
         m_pFrameBuffer->setScaleFactor(dScaleFactor);
         m_pFrameBuffer->setUseUnscaledHiDPIOutput(fUseUnscaledHiDPIOutput);
@@ -727,5 +731,5 @@
             // not 3D overlay itself, so for auto scale-up mode we have to take that into account.
             if (!fUseUnscaledHiDPIOutput)
-                dScaleFactorFor3D *= dDevicePixelRatio;
+                dScaleFactorFor3D *= dDevicePixelRatioActual;
 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
             display().NotifyScaleFactorChange(m_uScreenId,
@@ -1061,8 +1065,9 @@
             /* Assign new frame-buffer logical-size: */
             QSize scaledSize = size();
-            const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
-            scaledSize *= dDevicePixelRatio;
+            const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
+            const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
+            scaledSize *= dDevicePixelRatioFormal;
             if (!frameBuffer()->useUnscaledHiDPIOutput())
-                scaledSize /= dDevicePixelRatio;
+                scaledSize /= dDevicePixelRatioActual;
             frameBuffer()->setScaledSize(scaledSize);
         }
@@ -1127,7 +1132,7 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
-    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatio != 1.0)
-        screenShot = screenShot.scaled(screenShot.size() * dDevicePixelRatio,
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
+    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
+        screenShot = screenShot.scaled(screenShot.size() * dDevicePixelRatioActual,
                                        Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 
@@ -1165,7 +1170,7 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
-    if (!frameBuffer()->useUnscaledHiDPIOutput())
-        effectiveSize *= dDevicePixelRatio;
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
+    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
+        effectiveSize *= dDevicePixelRatioActual;
 
     /* Create a screen-shot on the basis of the screen-data we have in saved-state: */
@@ -1198,7 +1203,7 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
-    if (!frameBuffer()->useUnscaledHiDPIOutput())
-        scaledSize *= dDevicePixelRatio;
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
+    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
+        scaledSize *= dDevicePixelRatioActual;
 
     /* Update pause pixmap finally: */
@@ -1230,11 +1235,12 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
-    xRange *= dDevicePixelRatio;
-    yRange *= dDevicePixelRatio;
+    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
+    xRange *= dDevicePixelRatioFormal;
+    yRange *= dDevicePixelRatioFormal;
     if (!frameBuffer()->useUnscaledHiDPIOutput())
     {
-        xRange /= dDevicePixelRatio;
-        yRange /= dDevicePixelRatio;
+        xRange /= dDevicePixelRatioActual;
+        yRange /= dDevicePixelRatioActual;
     }
 
@@ -1253,12 +1259,13 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     if (!frameBuffer()->useUnscaledHiDPIOutput())
     {
-        iContentsX *= dDevicePixelRatio;
-        iContentsY *= dDevicePixelRatio;
-    }
-    iContentsX /= dDevicePixelRatio;
-    iContentsY /= dDevicePixelRatio;
+        iContentsX *= dDevicePixelRatioActual;
+        iContentsY *= dDevicePixelRatioActual;
+    }
+    iContentsX /= dDevicePixelRatioFormal;
+    iContentsY /= dDevicePixelRatioFormal;
 
     /* Return point shifted according scroll-bars: */
@@ -1472,4 +1479,5 @@
                         /* Update device-pixel-ratio for underlying frame-buffer: */
                         m_pFrameBuffer->setDevicePixelRatio(gpDesktop->devicePixelRatio(machineWindow()));
+                        m_pFrameBuffer->setDevicePixelRatioActual(gpDesktop->devicePixelRatioActual(machineWindow()));
                         /* Perform frame-buffer rescaling: */
                         m_pFrameBuffer->performRescale();
@@ -1878,8 +1886,9 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     if (!frameBuffer()->useUnscaledHiDPIOutput())
-        size = QSize(size.width() * dDevicePixelRatio, size.height() * dDevicePixelRatio);
-    size = QSize(size.width() / dDevicePixelRatio, size.height() / dDevicePixelRatio);
+        size = QSize(size.width() * dDevicePixelRatioActual, size.height() * dDevicePixelRatioActual);
+    size = QSize(size.width() / dDevicePixelRatioFormal, size.height() / dDevicePixelRatioFormal);
 
     /* Return result: */
@@ -1890,8 +1899,9 @@
 {
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
-    size = QSize(size.width() * dDevicePixelRatio, size.height() * dDevicePixelRatio);
+    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
+    size = QSize(size.width() * dDevicePixelRatioFormal, size.height() * dDevicePixelRatioFormal);
     if (!frameBuffer()->useUnscaledHiDPIOutput())
-        size = QSize(size.width() / dDevicePixelRatio, size.height() / dDevicePixelRatio);
+        size = QSize(size.width() / dDevicePixelRatioActual, size.height() / dDevicePixelRatioActual);
 
     /* Take the scale-factor into account: */
Index: /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMouseHandler.cpp
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMouseHandler.cpp	(revision 71073)
+++ /trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMouseHandler.cpp	(revision 71074)
@@ -1045,11 +1045,12 @@
 
             /* Take the device-pixel-ratio into account: */
-            const double dDevicePixelRatio = pFrameBuffer->devicePixelRatio();
-            cpnt.setX(cpnt.x() * dDevicePixelRatio);
-            cpnt.setY(cpnt.y() * dDevicePixelRatio);
+            const double dDevicePixelRatioFormal = pFrameBuffer->devicePixelRatio();
+            const double dDevicePixelRatioActual = pFrameBuffer->devicePixelRatioActual();
+            cpnt.setX(cpnt.x() * dDevicePixelRatioFormal);
+            cpnt.setY(cpnt.y() * dDevicePixelRatioFormal);
             if (!pFrameBuffer->useUnscaledHiDPIOutput())
             {
-                cpnt.setX(cpnt.x() / dDevicePixelRatio);
-                cpnt.setY(cpnt.y() / dDevicePixelRatio);
+                cpnt.setX(cpnt.x() / dDevicePixelRatioActual);
+                cpnt.setY(cpnt.y() / dDevicePixelRatioActual);
             }
 
Index: /trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.cpp
===================================================================
--- /trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.cpp	(revision 71073)
+++ /trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.cpp	(revision 71074)
@@ -64,9 +64,10 @@
     /* Assign new frame-buffer logical-size: */
     QSize scaledSize = size();
-    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     const bool fUseUnscaledHiDPIOutput = frameBuffer()->useUnscaledHiDPIOutput();
-    scaledSize *= dDevicePixelRatio;
+    scaledSize *= dDevicePixelRatioFormal;
     if (!fUseUnscaledHiDPIOutput)
-        scaledSize /= dDevicePixelRatio;
+        scaledSize /= dDevicePixelRatioActual;
     frameBuffer()->setScaledSize(scaledSize);
     frameBuffer()->performRescale();
@@ -86,6 +87,6 @@
             if (!fUseUnscaledHiDPIOutput)
             {
-                xScaleFactor *= dDevicePixelRatio;
-                yScaleFactor *= dDevicePixelRatio;
+                xScaleFactor *= dDevicePixelRatioActual;
+                yScaleFactor *= dDevicePixelRatioActual;
             }
 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
@@ -130,5 +131,5 @@
     /* If scaled-size is valid: */
     const QSize scaledSize = frameBuffer()->scaledSize();
-    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio(); Q_UNUSED(dDevicePixelRatio);
+    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual(); Q_UNUSED(dDevicePixelRatioActual);
     const bool fUseUnscaledHiDPIOutput = frameBuffer()->useUnscaledHiDPIOutput();
     if (scaledSize.isValid())
@@ -145,6 +146,6 @@
             if (!fUseUnscaledHiDPIOutput)
             {
-                xScaleFactor *= dDevicePixelRatio;
-                yScaleFactor *= dDevicePixelRatio;
+                xScaleFactor *= dDevicePixelRatioActual;
+                yScaleFactor *= dDevicePixelRatioActual;
             }
 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */