Index: trunk/src/VBox/Frontends/VirtualBox/src/globals/UIActionPoolRuntime.cpp
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/globals/UIActionPoolRuntime.cpp	(revision 108359)
+++ trunk/src/VBox/Frontends/VirtualBox/src/globals/UIActionPoolRuntime.cpp	(revision 108367)
@@ -4120,10 +4120,10 @@
         /* Get device-pixel-ratio: */
         bool fDevicePixelRatioMentioned = false;
-        const double dDevicePixelRatioActual = qMin(UIDesktopWidgetWatchdog::devicePixelRatioActual(m_mapHostScreenForGuestScreen.value(iGuestScreenIndex)),
-                                                    10.0 /* meh, who knows? */);
+        const double dDevicePixelRatio = qMin(UIDesktopWidgetWatchdog::devicePixelRatio(m_mapHostScreenForGuestScreen.value(iGuestScreenIndex)),
+                                              10.0 /* meh, who knows? */);
 
         /* Calculate minimum, maximum and step: */
         const double dMinimum = 1.0;
-        const double dMaximum = ceil(dMinimum + dDevicePixelRatioActual);
+        const double dMaximum = ceil(dMinimum + dDevicePixelRatio);
         const double dStep = 0.25;
 
@@ -4141,5 +4141,5 @@
                 {
                     pAction->setProperty("Requested Scale Factor", dScaleFactor);
-                    if (dDevicePixelRatioActual == 1.0)
+                    if (dDevicePixelRatio == 1.0)
                         pAction->setText(QApplication::translate("UIActionPool", "Scale to %1%", "scale-factor")
                                          .arg(dScaleFactor * 100));
@@ -4149,11 +4149,11 @@
                 }
                 /* For the 'autoscaled' action: */
-                else if (   (dScaleFactor >= dDevicePixelRatioActual)
-                         && (dDevicePixelRatioActual != 1.0)
+                else if (   (dScaleFactor >= dDevicePixelRatio)
+                         && (dDevicePixelRatio != 1.0)
                          && !fDevicePixelRatioMentioned)
                 {
-                    pAction->setProperty("Requested Scale Factor", dDevicePixelRatioActual);
+                    pAction->setProperty("Requested Scale Factor", dDevicePixelRatio);
                     pAction->setText(QApplication::translate("UIActionPool", "Scale to %1% (autoscaled output)", "scale-factor")
-                                     .arg(dDevicePixelRatioActual * 100));
+                                     .arg(dDevicePixelRatio * 100));
                     fDevicePixelRatioMentioned = true;
                 }
Index: trunk/src/VBox/Frontends/VirtualBox/src/globals/UIDesktopWidgetWatchdog.cpp
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/globals/UIDesktopWidgetWatchdog.cpp	(revision 108359)
+++ trunk/src/VBox/Frontends/VirtualBox/src/globals/UIDesktopWidgetWatchdog.cpp	(revision 108367)
@@ -485,46 +485,4 @@
     /* Redirect call to wrapper above: */
     return devicePixelRatio(screenNumber(pWidget));
-}
-
-/* static */
-double UIDesktopWidgetWatchdog::devicePixelRatioActual(int iHostScreenIndex /* = -1 */)
-{
-    /* First, we should check whether the screen is valid: */
-    QScreen *pScreen = 0;
-    if (iHostScreenIndex == -1)
-    {
-        pScreen = QGuiApplication::primaryScreen();
-        iHostScreenIndex = QGuiApplication::screens().indexOf(pScreen);
-    }
-    else
-        pScreen = QGuiApplication::screens().value(iHostScreenIndex);
-    AssertPtrReturn(pScreen, 1.0);
-
-#ifdef VBOX_WS_WIN
-    /* Enumerate available monitors through EnumDisplayMonitors if GetDpiForMonitor is available: */
-    if (ResolveDynamicImports())
-    {
-        QList<QPair<int, int> > listOfScreenDPI;
-        EnumDisplayMonitors(0, 0, MonitorEnumProcF, (LPARAM)&listOfScreenDPI);
-        if (iHostScreenIndex >= 0 && iHostScreenIndex < listOfScreenDPI.size())
-        {
-            const QPair<int, int> dpiPair = listOfScreenDPI.at(iHostScreenIndex);
-            if (dpiPair.first > 0)
-                return (double)dpiPair.first / 96 /* dpi unawarness value */;
-        }
-    }
-#else /* !VBOX_WS_WIN */
-    Q_UNUSED(iHostScreenIndex);
-#endif /* !VBOX_WS_WIN */
-
-    /* Then acquire device-pixel-ratio: */
-    return pScreen->devicePixelRatio();
-}
-
-/* static */
-double UIDesktopWidgetWatchdog::devicePixelRatioActual(QWidget *pWidget)
-{
-    /* Redirect call to wrapper above: */
-    return devicePixelRatioActual(screenNumber(pWidget));
 }
 
Index: trunk/src/VBox/Frontends/VirtualBox/src/globals/UIDesktopWidgetWatchdog.h
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/globals/UIDesktopWidgetWatchdog.h	(revision 108359)
+++ trunk/src/VBox/Frontends/VirtualBox/src/globals/UIDesktopWidgetWatchdog.h	(revision 108367)
@@ -139,9 +139,4 @@
     /** Returns device-pixel-ratio of the host-screen which contains @a pWidget. */
     static double devicePixelRatio(QWidget *pWidget);
-
-    /** Returns actual device-pixel-ratio of the host-screen with @a iHostScreenIndex. */
-    static double devicePixelRatioActual(int iHostScreenIndex = -1);
-    /** Returns actual device-pixel-ratio of the host-screen which contains @a pWidget. */
-    static double devicePixelRatioActual(QWidget *pWidget);
 
     /** Search position for @a rectangle to make sure it is fully
Index: trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooserItem.cpp
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooserItem.cpp	(revision 108359)
+++ trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooserItem.cpp	(revision 108367)
@@ -225,6 +225,6 @@
     QWidget *pParentWidget = qobject_cast<QWidget*>(parent());
     pixmap.setDevicePixelRatio(  pParentWidget
-                               ? UIDesktopWidgetWatchdog::devicePixelRatioActual(pParentWidget)
-                               : UIDesktopWidgetWatchdog::devicePixelRatioActual());
+                               ? UIDesktopWidgetWatchdog::devicePixelRatio(pParentWidget)
+                               : UIDesktopWidgetWatchdog::devicePixelRatio());
     /* Use the filtered pixmap: */
     pPainter->drawPixmap(offset, pixmap);
Index: trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.cpp
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.cpp	(revision 108359)
+++ trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.cpp	(revision 108367)
@@ -145,8 +145,4 @@
     /** 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. */
@@ -364,9 +360,7 @@
      * @{ */
     /** 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;
+    double  m_dDevicePixelRatio;
     /** Holds whether frame-buffer should use unscaled HiDPI output. */
-    bool m_fUseUnscaledHiDPIOutput;
+    bool    m_fUseUnscaledHiDPIOutput;
     /** @} */
 
@@ -401,5 +395,4 @@
     , m_enmScalingOptimizationType(ScalingOptimizationType_None)
     , m_dDevicePixelRatio(1.0)
-    , m_dDevicePixelRatioActual(1.0)
     , m_fUseUnscaledHiDPIOutput(false)
 {
@@ -1170,5 +1163,5 @@
         /* Take the device-pixel-ratio into account: */
         if (!useUnscaledHiDPIOutput())
-            cursorHotspot /= devicePixelRatioActual();
+            cursorHotspot /= devicePixelRatio();
 
         /* Acquire cursor position and size: */
@@ -1179,11 +1172,9 @@
         cursorSize *= scaleFactor();
         /* Take the device-pixel-ratio into account: */
-        if (!useUnscaledHiDPIOutput())
+        if (useUnscaledHiDPIOutput())
         {
-            cursorPosition *= devicePixelRatioActual();
-            cursorSize *= devicePixelRatioActual();
+            cursorPosition /= devicePixelRatio();
+            cursorSize /= devicePixelRatio();
         }
-        cursorPosition /= devicePixelRatio();
-        cursorSize /= devicePixelRatio();
 
         /* Call for a viewport update, we need to update cumulative
@@ -1251,7 +1242,6 @@
 
     /* Take the device-pixel-ratio into account: */
-    if (!useUnscaledHiDPIOutput())
-        m_transform = m_transform.scale(devicePixelRatioActual(), devicePixelRatioActual());
-    m_transform = m_transform.scale(1.0 / devicePixelRatio(), 1.0 / devicePixelRatio());
+    if (useUnscaledHiDPIOutput())
+        m_transform = m_transform.scale(1.0 / devicePixelRatio(), 1.0 / devicePixelRatio());
 }
 
@@ -1298,11 +1288,11 @@
     /* But if we should scale image by some reason: */
     if (   scaledSize().isValid()
-        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
+        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
     {
         /* Calculate final scaled size: */
         QSize effectiveSize = !scaledSize().isValid() ? pSourceImage->size() : scaledSize();
         /* Take the device-pixel-ratio into account: */
-        if (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0)
-            effectiveSize *= devicePixelRatioActual();
+        if (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0)
+            effectiveSize *= devicePixelRatio();
         /* We scale the image to requested size and retain it
          * by making heap shallow copy of that temporary object: */
@@ -1354,5 +1344,5 @@
     /* If we had to scale image for some reason: */
     if (   scaledSize().isValid()
-        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
+        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
     {
         /* Wipe out copied image: */
@@ -1393,11 +1383,11 @@
     /* But if we should scale image by some reason: */
     if (   scaledSize().isValid()
-        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
+        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
     {
         /* Calculate final scaled size: */
         QSize effectiveSize = !scaledSize().isValid() ? pSourceImage->size() : scaledSize();
         /* Take the device-pixel-ratio into account: */
-        if (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0)
-            effectiveSize *= devicePixelRatioActual();
+        if (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0)
+            effectiveSize *= devicePixelRatio();
         /* We scale the image to requested size and retain it
          * by making heap shallow copy of that temporary object: */
@@ -1465,5 +1455,5 @@
     /* If we had to scale image for some reason: */
     if (   scaledSize().isValid()
-        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
+        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
     {
         /* Wipe out copied image: */
@@ -1667,14 +1657,4 @@
 }
 
-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 108359)
+++ trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.h	(revision 108367)
@@ -108,8 +108,4 @@
     /** 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 108359)
+++ trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp	(revision 108367)
@@ -302,7 +302,6 @@
     /* Take the device-pixel-ratio into account: */
     frameBuffer()->setDevicePixelRatio(UIDesktopWidgetWatchdog::devicePixelRatio(machineWindow()));
-    frameBuffer()->setDevicePixelRatioActual(UIDesktopWidgetWatchdog::devicePixelRatioActual(machineWindow()));
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-    const bool fUseUnscaledHiDPIOutput = dScaleFactor != dDevicePixelRatioActual;
+    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    const bool fUseUnscaledHiDPIOutput = dScaleFactor != dDevicePixelRatio;
     dScaleFactor = fUseUnscaledHiDPIOutput ? dScaleFactor : 1.0;
 
@@ -322,5 +321,5 @@
         // not 3D overlay itself, so for auto scale-up mode we have to take that into account.
         if (!fUseUnscaledHiDPIOutput)
-            dScaleFactorFor3D *= dDevicePixelRatioActual;
+            dScaleFactorFor3D *= dDevicePixelRatio;
 #endif /* VBOX_WS_WIN || VBOX_WS_NIX */
         uimachine()->notifyScaleFactorChange(m_uScreenId,
@@ -389,13 +388,10 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-    if (!frameBuffer()->useUnscaledHiDPIOutput())
-    {
-        iContentsX *= dDevicePixelRatioActual;
-        iContentsY *= dDevicePixelRatioActual;
-    }
-    iContentsX /= dDevicePixelRatioFormal;
-    iContentsY /= dDevicePixelRatioFormal;
+    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    if (frameBuffer()->useUnscaledHiDPIOutput())
+    {
+        iContentsX /= dDevicePixelRatio;
+        iContentsY /= dDevicePixelRatio;
+    }
 
     /* Return point shifted according scroll-bars: */
@@ -701,9 +697,7 @@
         /* Assign new frame-buffer logical-size: */
         QSize scaledSize = size();
-        const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
-        const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-        scaledSize *= dDevicePixelRatioFormal;
-        if (!frameBuffer()->useUnscaledHiDPIOutput())
-            scaledSize /= dDevicePixelRatioActual;
+        const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+        if (frameBuffer()->useUnscaledHiDPIOutput())
+            scaledSize *= dDevicePixelRatio;
         frameBuffer()->setScaledSize(scaledSize);
 
@@ -803,19 +797,11 @@
 
     /* Take the device-pixel-ratio into account: */
-    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));
+    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));
     }
 
@@ -1066,6 +1052,6 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-    const bool fUseUnscaledHiDPIOutput = dScaleFactor != dDevicePixelRatioActual;
+    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    const bool fUseUnscaledHiDPIOutput = dScaleFactor != dDevicePixelRatio;
     dScaleFactor = fUseUnscaledHiDPIOutput ? dScaleFactor : 1.0;
 
@@ -1085,5 +1071,5 @@
         // not 3D overlay itself, so for auto scale-up mode we have to take that into account.
         if (!fUseUnscaledHiDPIOutput)
-            dScaleFactorFor3D *= frameBuffer()->devicePixelRatioActual();
+            dScaleFactorFor3D *= frameBuffer()->devicePixelRatio();
 #endif /* VBOX_WS_WIN || VBOX_WS_NIX */
         uimachine()->notifyScaleFactorChange(m_uScreenId,
@@ -1604,9 +1590,7 @@
             /* Assign new frame-buffer logical-size: */
             QSize scaledSize = size();
-            const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
-            const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-            scaledSize *= dDevicePixelRatioFormal;
-            if (!frameBuffer()->useUnscaledHiDPIOutput())
-                scaledSize /= dDevicePixelRatioActual;
+            const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+            if (frameBuffer()->useUnscaledHiDPIOutput())
+                scaledSize *= dDevicePixelRatio;
             frameBuffer()->setScaledSize(scaledSize);
         }
@@ -1660,7 +1644,7 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
-        screenShot = screenShot.scaled(screenShot.size() * dDevicePixelRatioActual,
+    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatio != 1.0)
+        screenShot = screenShot.scaled(screenShot.size() * dDevicePixelRatio,
                                        Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 
@@ -1698,7 +1682,7 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
-        effectiveSize *= dDevicePixelRatioActual;
+    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatio != 1.0)
+        effectiveSize *= dDevicePixelRatio;
 
     /* Create a screen-shot on the basis of the screen-data we have in saved-state: */
@@ -1732,7 +1716,7 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
-        scaledSize *= dDevicePixelRatioActual;
+    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatio != 1.0)
+        scaledSize *= dDevicePixelRatio;
 
     /* Update pause pixmap finally: */
@@ -1768,12 +1752,9 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-    xRange *= dDevicePixelRatioFormal;
-    yRange *= dDevicePixelRatioFormal;
-    if (!frameBuffer()->useUnscaledHiDPIOutput())
-    {
-        xRange /= dDevicePixelRatioActual;
-        yRange /= dDevicePixelRatioActual;
+    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    if (frameBuffer()->useUnscaledHiDPIOutput())
+    {
+        xRange *= dDevicePixelRatio;
+        yRange *= dDevicePixelRatio;
     }
 
@@ -2176,9 +2157,7 @@
 
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-    if (!frameBuffer()->useUnscaledHiDPIOutput())
-        size = QSize((int)(size.width() * dDevicePixelRatioActual), (int)(size.height() * dDevicePixelRatioActual));
-    size = QSize((int)(size.width() / dDevicePixelRatioFormal), (int)(size.height() / dDevicePixelRatioFormal));
+    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    if (frameBuffer()->useUnscaledHiDPIOutput())
+        size = QSize((int)(size.width() / dDevicePixelRatio), (int)(size.height() / dDevicePixelRatio));
 
     /* Return result: */
@@ -2189,9 +2168,7 @@
 {
     /* Take the device-pixel-ratio into account: */
-    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
-    size = QSize((int)(size.width() * dDevicePixelRatioFormal), (int)(size.height() * dDevicePixelRatioFormal));
-    if (!frameBuffer()->useUnscaledHiDPIOutput())
-        size = QSize(size.width() / dDevicePixelRatioActual, size.height() / dDevicePixelRatioActual);
+    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    if (frameBuffer()->useUnscaledHiDPIOutput())
+        size = QSize((int)(size.width() * dDevicePixelRatio), (int)(size.height() * dDevicePixelRatio));
 
     /* Take the scale-factor into account: */
@@ -2245,13 +2222,8 @@
 
     /* Take into account device-pixel-ratio if necessary: */
-# ifdef VBOX_WS_WIN
     const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
-# endif
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     const bool fUseUnscaledHiDPIOutput = frameBuffer()->useUnscaledHiDPIOutput();
-    //printf("Device-pixel-ratio/actual: %f/%f, Unscaled HiDPI Output: %d\n",
-    //       dDevicePixelRatio, dDevicePixelRatioActual, fUseUnscaledHiDPIOutput);
-    if (dDevicePixelRatioActual > 1.0 && !fUseUnscaledHiDPIOutput)
-        dScaleMultiplier *= dDevicePixelRatioActual;
+    if (dDevicePixelRatio > 1.0 && !fUseUnscaledHiDPIOutput)
+        dScaleMultiplier *= dDevicePixelRatio;
 
     /* If scale multiplier was set: */
Index: trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMouseHandler.cpp
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMouseHandler.cpp	(revision 108359)
+++ trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMouseHandler.cpp	(revision 108367)
@@ -1092,12 +1092,9 @@
 
             /* Take the device-pixel-ratio into account: */
-            const double dDevicePixelRatioFormal = pFrameBuffer->devicePixelRatio();
-            const double dDevicePixelRatioActual = pFrameBuffer->devicePixelRatioActual();
-            cpnt.setX(cpnt.x() * dDevicePixelRatioFormal);
-            cpnt.setY(cpnt.y() * dDevicePixelRatioFormal);
-            if (!pFrameBuffer->useUnscaledHiDPIOutput())
+            const double dDevicePixelRatio = pFrameBuffer->devicePixelRatio();
+            if (pFrameBuffer->useUnscaledHiDPIOutput())
             {
-                cpnt.setX(cpnt.x() / dDevicePixelRatioActual);
-                cpnt.setY(cpnt.y() / dDevicePixelRatioActual);
+                cpnt.setX(cpnt.x() * dDevicePixelRatio);
+                cpnt.setY(cpnt.y() * dDevicePixelRatio);
             }
 
Index: trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.cpp
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.cpp	(revision 108359)
+++ trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.cpp	(revision 108367)
@@ -56,10 +56,8 @@
     /* Assign new frame-buffer logical-size: */
     QSize scaledSize = size();
-    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     const bool fUseUnscaledHiDPIOutput = frameBuffer()->useUnscaledHiDPIOutput();
-    scaledSize *= dDevicePixelRatioFormal;
-    if (!fUseUnscaledHiDPIOutput)
-        scaledSize /= dDevicePixelRatioActual;
+    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+    if (fUseUnscaledHiDPIOutput)
+        scaledSize *= dDevicePixelRatio;
     frameBuffer()->setScaledSize(scaledSize);
     frameBuffer()->performRescale();
@@ -81,6 +79,6 @@
             if (!fUseUnscaledHiDPIOutput)
             {
-                xScaleFactor *= dDevicePixelRatioActual;
-                yScaleFactor *= dDevicePixelRatioActual;
+                xScaleFactor *= dDevicePixelRatio;
+                yScaleFactor *= dDevicePixelRatio;
             }
 #endif /* VBOX_WS_WIN || VBOX_WS_NIX */
@@ -125,5 +123,4 @@
     /* If scaled-size is valid: */
     const QSize scaledSize = frameBuffer()->scaledSize();
-    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual(); Q_UNUSED(dDevicePixelRatioActual);
     const bool fUseUnscaledHiDPIOutput = frameBuffer()->useUnscaledHiDPIOutput();
     if (scaledSize.isValid())
@@ -142,6 +139,7 @@
             if (!fUseUnscaledHiDPIOutput)
             {
-                xScaleFactor *= dDevicePixelRatioActual;
-                yScaleFactor *= dDevicePixelRatioActual;
+                const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
+                xScaleFactor *= dDevicePixelRatio;
+                yScaleFactor *= dDevicePixelRatio;
             }
 #endif /* VBOX_WS_WIN || VBOX_WS_NIX */
