VirtualBox

Changeset 108367 in vbox for trunk/src/VBox/Frontends


Ignore:
Timestamp:
Feb 25, 2025 11:12:06 AM (8 weeks ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
167728
Message:

FE/Qt: bugref:10450: Runtime UI: Reworking GUI scaling support according to Qt6; This step is directed to extinguishing difference between formal and actual DPI values as Qt6 supports fractional desktop scale-factors.

Location:
trunk/src/VBox/Frontends/VirtualBox/src
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/UIActionPoolRuntime.cpp

    r107472 r108367  
    41204120        /* Get device-pixel-ratio: */
    41214121        bool fDevicePixelRatioMentioned = false;
    4122         const double dDevicePixelRatioActual = qMin(UIDesktopWidgetWatchdog::devicePixelRatioActual(m_mapHostScreenForGuestScreen.value(iGuestScreenIndex)),
    4123                                                     10.0 /* meh, who knows? */);
     4122        const double dDevicePixelRatio = qMin(UIDesktopWidgetWatchdog::devicePixelRatio(m_mapHostScreenForGuestScreen.value(iGuestScreenIndex)),
     4123                                              10.0 /* meh, who knows? */);
    41244124
    41254125        /* Calculate minimum, maximum and step: */
    41264126        const double dMinimum = 1.0;
    4127         const double dMaximum = ceil(dMinimum + dDevicePixelRatioActual);
     4127        const double dMaximum = ceil(dMinimum + dDevicePixelRatio);
    41284128        const double dStep = 0.25;
    41294129
    … …  
    41414141                {
    41424142                    pAction->setProperty("Requested Scale Factor", dScaleFactor);
    4143                     if (dDevicePixelRatioActual == 1.0)
     4143                    if (dDevicePixelRatio == 1.0)
    41444144                        pAction->setText(QApplication::translate("UIActionPool", "Scale to %1%", "scale-factor")
    41454145                                         .arg(dScaleFactor * 100));
    … …  
    41494149                }
    41504150                /* For the 'autoscaled' action: */
    4151                 else if (   (dScaleFactor >= dDevicePixelRatioActual)
    4152                          && (dDevicePixelRatioActual != 1.0)
     4151                else if (   (dScaleFactor >= dDevicePixelRatio)
     4152                         && (dDevicePixelRatio != 1.0)
    41534153                         && !fDevicePixelRatioMentioned)
    41544154                {
    4155                     pAction->setProperty("Requested Scale Factor", dDevicePixelRatioActual);
     4155                    pAction->setProperty("Requested Scale Factor", dDevicePixelRatio);
    41564156                    pAction->setText(QApplication::translate("UIActionPool", "Scale to %1% (autoscaled output)", "scale-factor")
    4157                                      .arg(dDevicePixelRatioActual * 100));
     4157                                     .arg(dDevicePixelRatio * 100));
    41584158                    fDevicePixelRatioMentioned = true;
    41594159                }

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/UIDesktopWidgetWatchdog.cpp

    r107669 r108367  
    485485    /* Redirect call to wrapper above: */
    486486    return devicePixelRatio(screenNumber(pWidget));
    487 }
    488 
    489 /* static */
    490 double UIDesktopWidgetWatchdog::devicePixelRatioActual(int iHostScreenIndex /* = -1 */)
    491 {
    492     /* First, we should check whether the screen is valid: */
    493     QScreen *pScreen = 0;
    494     if (iHostScreenIndex == -1)
    495     {
    496         pScreen = QGuiApplication::primaryScreen();
    497         iHostScreenIndex = QGuiApplication::screens().indexOf(pScreen);
    498     }
    499     else
    500         pScreen = QGuiApplication::screens().value(iHostScreenIndex);
    501     AssertPtrReturn(pScreen, 1.0);
    502 
    503 #ifdef VBOX_WS_WIN
    504     /* Enumerate available monitors through EnumDisplayMonitors if GetDpiForMonitor is available: */
    505     if (ResolveDynamicImports())
    506     {
    507         QList<QPair<int, int> > listOfScreenDPI;
    508         EnumDisplayMonitors(0, 0, MonitorEnumProcF, (LPARAM)&listOfScreenDPI);
    509         if (iHostScreenIndex >= 0 && iHostScreenIndex < listOfScreenDPI.size())
    510         {
    511             const QPair<int, int> dpiPair = listOfScreenDPI.at(iHostScreenIndex);
    512             if (dpiPair.first > 0)
    513                 return (double)dpiPair.first / 96 /* dpi unawarness value */;
    514         }
    515     }
    516 #else /* !VBOX_WS_WIN */
    517     Q_UNUSED(iHostScreenIndex);
    518 #endif /* !VBOX_WS_WIN */
    519 
    520     /* Then acquire device-pixel-ratio: */
    521     return pScreen->devicePixelRatio();
    522 }
    523 
    524 /* static */
    525 double UIDesktopWidgetWatchdog::devicePixelRatioActual(QWidget *pWidget)
    526 {
    527     /* Redirect call to wrapper above: */
    528     return devicePixelRatioActual(screenNumber(pWidget));
    529487}
    530488

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/UIDesktopWidgetWatchdog.h

    r106061 r108367  
    139139    /** Returns device-pixel-ratio of the host-screen which contains @a pWidget. */
    140140    static double devicePixelRatio(QWidget *pWidget);
    141 
    142     /** Returns actual device-pixel-ratio of the host-screen with @a iHostScreenIndex. */
    143     static double devicePixelRatioActual(int iHostScreenIndex = -1);
    144     /** Returns actual device-pixel-ratio of the host-screen which contains @a pWidget. */
    145     static double devicePixelRatioActual(QWidget *pWidget);
    146141
    147142    /** Search position for @a rectangle to make sure it is fully

  • trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooserItem.cpp

    r108157 r108367  
    225225    QWidget *pParentWidget = qobject_cast<QWidget*>(parent());
    226226    pixmap.setDevicePixelRatio(  pParentWidget
    227                                ? UIDesktopWidgetWatchdog::devicePixelRatioActual(pParentWidget)
    228                                : UIDesktopWidgetWatchdog::devicePixelRatioActual());
     227                               ? UIDesktopWidgetWatchdog::devicePixelRatio(pParentWidget)
     228                               : UIDesktopWidgetWatchdog::devicePixelRatio());
    229229    /* Use the filtered pixmap: */
    230230    pPainter->drawPixmap(offset, pixmap);

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.cpp

    r108075 r108367  
    145145    /** Defines device-pixel-ratio set for HiDPI frame-buffer. */
    146146    void setDevicePixelRatio(double dDevicePixelRatio) { m_dDevicePixelRatio = dDevicePixelRatio; }
    147     /** Returns actual device-pixel-ratio set for HiDPI frame-buffer. */
    148     double devicePixelRatioActual() const { return m_dDevicePixelRatioActual; }
    149     /** Defines actual device-pixel-ratio set for HiDPI frame-buffer. */
    150     void setDevicePixelRatioActual(double dDevicePixelRatioActual) { m_dDevicePixelRatioActual = dDevicePixelRatioActual; }
    151147
    152148    /** Returns whether frame-buffer should use unscaled HiDPI output. */
    … …  
    364360     * @{ */
    365361    /** Holds device-pixel-ratio set for HiDPI frame-buffer. */
    366     double m_dDevicePixelRatio;
    367     /** Holds actual device-pixel-ratio set for HiDPI frame-buffer. */
    368     double m_dDevicePixelRatioActual;
     362    double  m_dDevicePixelRatio;
    369363    /** Holds whether frame-buffer should use unscaled HiDPI output. */
    370     bool m_fUseUnscaledHiDPIOutput;
     364    bool    m_fUseUnscaledHiDPIOutput;
    371365    /** @} */
    372366
    … …  
    401395    , m_enmScalingOptimizationType(ScalingOptimizationType_None)
    402396    , m_dDevicePixelRatio(1.0)
    403     , m_dDevicePixelRatioActual(1.0)
    404397    , m_fUseUnscaledHiDPIOutput(false)
    405398{
    … …  
    11701163        /* Take the device-pixel-ratio into account: */
    11711164        if (!useUnscaledHiDPIOutput())
    1172             cursorHotspot /= devicePixelRatioActual();
     1165            cursorHotspot /= devicePixelRatio();
    11731166
    11741167        /* Acquire cursor position and size: */
    … …  
    11791172        cursorSize *= scaleFactor();
    11801173        /* Take the device-pixel-ratio into account: */
    1181         if (!useUnscaledHiDPIOutput())
     1174        if (useUnscaledHiDPIOutput())
    11821175        {
    1183             cursorPosition *= devicePixelRatioActual();
    1184             cursorSize *= devicePixelRatioActual();
     1176            cursorPosition /= devicePixelRatio();
     1177            cursorSize /= devicePixelRatio();
    11851178        }
    1186         cursorPosition /= devicePixelRatio();
    1187         cursorSize /= devicePixelRatio();
    11881179
    11891180        /* Call for a viewport update, we need to update cumulative
    … …  
    12511242
    12521243    /* Take the device-pixel-ratio into account: */
    1253     if (!useUnscaledHiDPIOutput())
    1254         m_transform = m_transform.scale(devicePixelRatioActual(), devicePixelRatioActual());
    1255     m_transform = m_transform.scale(1.0 / devicePixelRatio(), 1.0 / devicePixelRatio());
     1244    if (useUnscaledHiDPIOutput())
     1245        m_transform = m_transform.scale(1.0 / devicePixelRatio(), 1.0 / devicePixelRatio());
    12561246}
    12571247
    … …  
    12981288    /* But if we should scale image by some reason: */
    12991289    if (   scaledSize().isValid()
    1300         || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
     1290        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
    13011291    {
    13021292        /* Calculate final scaled size: */
    13031293        QSize effectiveSize = !scaledSize().isValid() ? pSourceImage->size() : scaledSize();
    13041294        /* Take the device-pixel-ratio into account: */
    1305         if (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0)
    1306             effectiveSize *= devicePixelRatioActual();
     1295        if (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0)
     1296            effectiveSize *= devicePixelRatio();
    13071297        /* We scale the image to requested size and retain it
    13081298         * by making heap shallow copy of that temporary object: */
    … …  
    13541344    /* If we had to scale image for some reason: */
    13551345    if (   scaledSize().isValid()
    1356         || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
     1346        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
    13571347    {
    13581348        /* Wipe out copied image: */
    … …  
    13931383    /* But if we should scale image by some reason: */
    13941384    if (   scaledSize().isValid()
    1395         || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
     1385        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
    13961386    {
    13971387        /* Calculate final scaled size: */
    13981388        QSize effectiveSize = !scaledSize().isValid() ? pSourceImage->size() : scaledSize();
    13991389        /* Take the device-pixel-ratio into account: */
    1400         if (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0)
    1401             effectiveSize *= devicePixelRatioActual();
     1390        if (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0)
     1391            effectiveSize *= devicePixelRatio();
    14021392        /* We scale the image to requested size and retain it
    14031393         * by making heap shallow copy of that temporary object: */
    … …  
    14651455    /* If we had to scale image for some reason: */
    14661456    if (   scaledSize().isValid()
    1467         || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
     1457        || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
    14681458    {
    14691459        /* Wipe out copied image: */
    … …  
    16671657}
    16681658
    1669 double UIFrameBuffer::devicePixelRatioActual() const
    1670 {
    1671     return m_pFrameBuffer->devicePixelRatioActual();
    1672 }
    1673 
    1674 void UIFrameBuffer::setDevicePixelRatioActual(double dDevicePixelRatioActual)
    1675 {
    1676     m_pFrameBuffer->setDevicePixelRatioActual(dDevicePixelRatioActual);
    1677 }
    1678 
    16791659bool UIFrameBuffer::useUnscaledHiDPIOutput() const
    16801660{

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIFrameBuffer.h

    r107411 r108367  
    108108    /** Defines device-pixel-ratio set for HiDPI frame-buffer. */
    109109    void setDevicePixelRatio(double dDevicePixelRatio);
    110     /** Returns actual device-pixel-ratio set for HiDPI frame-buffer. */
    111     double devicePixelRatioActual() const;
    112     /** Defines actual device-pixel-ratio set for HiDPI frame-buffer. */
    113     void setDevicePixelRatioActual(double dDevicePixelRatioActual);
    114110
    115111    /** Returns whether frame-buffer should use unscaled HiDPI output. */

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp

    r107641 r108367  
    302302    /* Take the device-pixel-ratio into account: */
    303303    frameBuffer()->setDevicePixelRatio(UIDesktopWidgetWatchdog::devicePixelRatio(machineWindow()));
    304     frameBuffer()->setDevicePixelRatioActual(UIDesktopWidgetWatchdog::devicePixelRatioActual(machineWindow()));
    305     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    306     const bool fUseUnscaledHiDPIOutput = dScaleFactor != dDevicePixelRatioActual;
     304    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     305    const bool fUseUnscaledHiDPIOutput = dScaleFactor != dDevicePixelRatio;
    307306    dScaleFactor = fUseUnscaledHiDPIOutput ? dScaleFactor : 1.0;
    308307
    … …  
    322321        // not 3D overlay itself, so for auto scale-up mode we have to take that into account.
    323322        if (!fUseUnscaledHiDPIOutput)
    324             dScaleFactorFor3D *= dDevicePixelRatioActual;
     323            dScaleFactorFor3D *= dDevicePixelRatio;
    325324#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    326325        uimachine()->notifyScaleFactorChange(m_uScreenId,
    … …  
    389388
    390389    /* Take the device-pixel-ratio into account: */
    391     const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
    392     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    393     if (!frameBuffer()->useUnscaledHiDPIOutput())
    394     {
    395         iContentsX *= dDevicePixelRatioActual;
    396         iContentsY *= dDevicePixelRatioActual;
    397     }
    398     iContentsX /= dDevicePixelRatioFormal;
    399     iContentsY /= dDevicePixelRatioFormal;
     390    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     391    if (frameBuffer()->useUnscaledHiDPIOutput())
     392    {
     393        iContentsX /= dDevicePixelRatio;
     394        iContentsY /= dDevicePixelRatio;
     395    }
    400396
    401397    /* Return point shifted according scroll-bars: */
    … …  
    701697        /* Assign new frame-buffer logical-size: */
    702698        QSize scaledSize = size();
    703         const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
    704         const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    705         scaledSize *= dDevicePixelRatioFormal;
    706         if (!frameBuffer()->useUnscaledHiDPIOutput())
    707             scaledSize /= dDevicePixelRatioActual;
     699        const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     700        if (frameBuffer()->useUnscaledHiDPIOutput())
     701            scaledSize *= dDevicePixelRatio;
    708702        frameBuffer()->setScaledSize(scaledSize);
    709703
    … …  
    803797
    804798    /* Take the device-pixel-ratio into account: */
    805     const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
    806     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    807     if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
    808     {
    809         rect.moveTo((int)floor((double)rect.x() * dDevicePixelRatioActual) - 1,
    810                     (int)floor((double)rect.y() * dDevicePixelRatioActual) - 1);
    811         rect.setSize(QSize((int)ceil((double)rect.width()  * dDevicePixelRatioActual) + 2,
    812                            (int)ceil((double)rect.height() * dDevicePixelRatioActual) + 2));
    813     }
    814     if (dDevicePixelRatioFormal != 1.0)
    815     {
    816         rect.moveTo((int)floor((double)rect.x() / dDevicePixelRatioFormal) - 1,
    817                     (int)floor((double)rect.y() / dDevicePixelRatioFormal) - 1);
    818         rect.setSize(QSize((int)ceil((double)rect.width()  / dDevicePixelRatioFormal) + 2,
    819                            (int)ceil((double)rect.height() / dDevicePixelRatioFormal) + 2));
     799    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     800    if (frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatio != 1.0)
     801    {
     802        rect.moveTo((int)floor((double)rect.x() / dDevicePixelRatio) - 1,
     803                    (int)floor((double)rect.y() / dDevicePixelRatio) - 1);
     804        rect.setSize(QSize((int)ceil((double)rect.width()  / dDevicePixelRatio) + 2,
     805                           (int)ceil((double)rect.height() / dDevicePixelRatio) + 2));
    820806    }
    821807
    … …  
    10661052
    10671053    /* Take the device-pixel-ratio into account: */
    1068     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    1069     const bool fUseUnscaledHiDPIOutput = dScaleFactor != dDevicePixelRatioActual;
     1054    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     1055    const bool fUseUnscaledHiDPIOutput = dScaleFactor != dDevicePixelRatio;
    10701056    dScaleFactor = fUseUnscaledHiDPIOutput ? dScaleFactor : 1.0;
    10711057
    … …  
    10851071        // not 3D overlay itself, so for auto scale-up mode we have to take that into account.
    10861072        if (!fUseUnscaledHiDPIOutput)
    1087             dScaleFactorFor3D *= frameBuffer()->devicePixelRatioActual();
     1073            dScaleFactorFor3D *= frameBuffer()->devicePixelRatio();
    10881074#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    10891075        uimachine()->notifyScaleFactorChange(m_uScreenId,
    … …  
    16041590            /* Assign new frame-buffer logical-size: */
    16051591            QSize scaledSize = size();
    1606             const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
    1607             const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    1608             scaledSize *= dDevicePixelRatioFormal;
    1609             if (!frameBuffer()->useUnscaledHiDPIOutput())
    1610                 scaledSize /= dDevicePixelRatioActual;
     1592            const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     1593            if (frameBuffer()->useUnscaledHiDPIOutput())
     1594                scaledSize *= dDevicePixelRatio;
    16111595            frameBuffer()->setScaledSize(scaledSize);
    16121596        }
    … …  
    16601644
    16611645    /* Take the device-pixel-ratio into account: */
    1662     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    1663     if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
    1664         screenShot = screenShot.scaled(screenShot.size() * dDevicePixelRatioActual,
     1646    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     1647    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatio != 1.0)
     1648        screenShot = screenShot.scaled(screenShot.size() * dDevicePixelRatio,
    16651649                                       Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
    16661650
    … …  
    16981682
    16991683    /* Take the device-pixel-ratio into account: */
    1700     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    1701     if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
    1702         effectiveSize *= dDevicePixelRatioActual;
     1684    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     1685    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatio != 1.0)
     1686        effectiveSize *= dDevicePixelRatio;
    17031687
    17041688    /* Create a screen-shot on the basis of the screen-data we have in saved-state: */
    … …  
    17321716
    17331717    /* Take the device-pixel-ratio into account: */
    1734     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    1735     if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
    1736         scaledSize *= dDevicePixelRatioActual;
     1718    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     1719    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatio != 1.0)
     1720        scaledSize *= dDevicePixelRatio;
    17371721
    17381722    /* Update pause pixmap finally: */
    … …  
    17681752
    17691753    /* Take the device-pixel-ratio into account: */
    1770     const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
    1771     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    1772     xRange *= dDevicePixelRatioFormal;
    1773     yRange *= dDevicePixelRatioFormal;
    1774     if (!frameBuffer()->useUnscaledHiDPIOutput())
    1775     {
    1776         xRange /= dDevicePixelRatioActual;
    1777         yRange /= dDevicePixelRatioActual;
     1754    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     1755    if (frameBuffer()->useUnscaledHiDPIOutput())
     1756    {
     1757        xRange *= dDevicePixelRatio;
     1758        yRange *= dDevicePixelRatio;
    17781759    }
    17791760
    … …  
    21762157
    21772158    /* Take the device-pixel-ratio into account: */
    2178     const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
    2179     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    2180     if (!frameBuffer()->useUnscaledHiDPIOutput())
    2181         size = QSize((int)(size.width() * dDevicePixelRatioActual), (int)(size.height() * dDevicePixelRatioActual));
    2182     size = QSize((int)(size.width() / dDevicePixelRatioFormal), (int)(size.height() / dDevicePixelRatioFormal));
     2159    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     2160    if (frameBuffer()->useUnscaledHiDPIOutput())
     2161        size = QSize((int)(size.width() / dDevicePixelRatio), (int)(size.height() / dDevicePixelRatio));
    21832162
    21842163    /* Return result: */
    … …  
    21892168{
    21902169    /* Take the device-pixel-ratio into account: */
    2191     const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
    2192     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    2193     size = QSize((int)(size.width() * dDevicePixelRatioFormal), (int)(size.height() * dDevicePixelRatioFormal));
    2194     if (!frameBuffer()->useUnscaledHiDPIOutput())
    2195         size = QSize(size.width() / dDevicePixelRatioActual, size.height() / dDevicePixelRatioActual);
     2170    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     2171    if (frameBuffer()->useUnscaledHiDPIOutput())
     2172        size = QSize((int)(size.width() * dDevicePixelRatio), (int)(size.height() * dDevicePixelRatio));
    21962173
    21972174    /* Take the scale-factor into account: */
    … …  
    22452222
    22462223    /* Take into account device-pixel-ratio if necessary: */
    2247 # ifdef VBOX_WS_WIN
    22482224    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
    2249 # endif
    2250     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    22512225    const bool fUseUnscaledHiDPIOutput = frameBuffer()->useUnscaledHiDPIOutput();
    2252     //printf("Device-pixel-ratio/actual: %f/%f, Unscaled HiDPI Output: %d\n",
    2253     //       dDevicePixelRatio, dDevicePixelRatioActual, fUseUnscaledHiDPIOutput);
    2254     if (dDevicePixelRatioActual > 1.0 && !fUseUnscaledHiDPIOutput)
    2255         dScaleMultiplier *= dDevicePixelRatioActual;
     2226    if (dDevicePixelRatio > 1.0 && !fUseUnscaledHiDPIOutput)
     2227        dScaleMultiplier *= dDevicePixelRatio;
    22562228
    22572229    /* If scale multiplier was set: */

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMouseHandler.cpp

    r106349 r108367  
    10921092
    10931093            /* Take the device-pixel-ratio into account: */
    1094             const double dDevicePixelRatioFormal = pFrameBuffer->devicePixelRatio();
    1095             const double dDevicePixelRatioActual = pFrameBuffer->devicePixelRatioActual();
    1096             cpnt.setX(cpnt.x() * dDevicePixelRatioFormal);
    1097             cpnt.setY(cpnt.y() * dDevicePixelRatioFormal);
    1098             if (!pFrameBuffer->useUnscaledHiDPIOutput())
     1094            const double dDevicePixelRatio = pFrameBuffer->devicePixelRatio();
     1095            if (pFrameBuffer->useUnscaledHiDPIOutput())
    10991096            {
    1100                 cpnt.setX(cpnt.x() / dDevicePixelRatioActual);
    1101                 cpnt.setY(cpnt.y() / dDevicePixelRatioActual);
     1097                cpnt.setX(cpnt.x() * dDevicePixelRatio);
     1098                cpnt.setY(cpnt.y() * dDevicePixelRatio);
    11021099            }
    11031100

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.cpp

    r106061 r108367  
    5656    /* Assign new frame-buffer logical-size: */
    5757    QSize scaledSize = size();
    58     const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
    59     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    6058    const bool fUseUnscaledHiDPIOutput = frameBuffer()->useUnscaledHiDPIOutput();
    61     scaledSize *= dDevicePixelRatioFormal;
    62     if (!fUseUnscaledHiDPIOutput)
    63         scaledSize /= dDevicePixelRatioActual;
     59    const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     60    if (fUseUnscaledHiDPIOutput)
     61        scaledSize *= dDevicePixelRatio;
    6462    frameBuffer()->setScaledSize(scaledSize);
    6563    frameBuffer()->performRescale();
    … …  
    8179            if (!fUseUnscaledHiDPIOutput)
    8280            {
    83                 xScaleFactor *= dDevicePixelRatioActual;
    84                 yScaleFactor *= dDevicePixelRatioActual;
     81                xScaleFactor *= dDevicePixelRatio;
     82                yScaleFactor *= dDevicePixelRatio;
    8583            }
    8684#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    … …  
    125123    /* If scaled-size is valid: */
    126124    const QSize scaledSize = frameBuffer()->scaledSize();
    127     const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual(); Q_UNUSED(dDevicePixelRatioActual);
    128125    const bool fUseUnscaledHiDPIOutput = frameBuffer()->useUnscaledHiDPIOutput();
    129126    if (scaledSize.isValid())
    … …  
    142139            if (!fUseUnscaledHiDPIOutput)
    143140            {
    144                 xScaleFactor *= dDevicePixelRatioActual;
    145                 yScaleFactor *= dDevicePixelRatioActual;
     141                const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     142                xScaleFactor *= dDevicePixelRatio;
     143                yScaleFactor *= dDevicePixelRatio;
    146144            }
    147145#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette