VirtualBox

Ignore:
Timestamp:
Feb 20, 2018 5:43:24 PM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
120938
Message:

FE/Qt: bugref:8694: Runtime UI: Use the actual device-pixel-ratio provided in r120769 for smart fractional rescaling.

Location:
trunk/src/VBox/Frontends/VirtualBox/src/runtime
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r71073 r71074  
    157157    /** Defines device-pixel-ratio set for HiDPI frame-buffer. */
    158158    void setDevicePixelRatio(double dDevicePixelRatio) { m_dDevicePixelRatio = dDevicePixelRatio; }
     159    /** Returns actual device-pixel-ratio set for HiDPI frame-buffer. */
     160    double devicePixelRatioActual() const { return m_dDevicePixelRatioActual; }
     161    /** Defines actual device-pixel-ratio set for HiDPI frame-buffer. */
     162    void setDevicePixelRatioActual(double dDevicePixelRatioActual) { m_dDevicePixelRatioActual = dDevicePixelRatioActual; }
    159163
    160164    /** Returns whether frame-buffer should use unscaled HiDPI output. */
    … …  
    375379    /** Holds device-pixel-ratio set for HiDPI frame-buffer. */
    376380    double m_dDevicePixelRatio;
     381    /** Holds actual device-pixel-ratio set for HiDPI frame-buffer. */
     382    double m_dDevicePixelRatioActual;
    377383    /** Holds whether frame-buffer should use unscaled HiDPI output. */
    378384    bool m_fUseUnscaledHiDPIOutput;
    … …  
    526532    , m_enmScalingOptimizationType(ScalingOptimizationType_None)
    527533    , m_dDevicePixelRatio(1.0)
     534    , m_dDevicePixelRatioActual(1.0)
    528535    , m_fUseUnscaledHiDPIOutput(false)
    529536{
    … …  
    13221329    /* Take the device-pixel-ratio into account: */
    13231330    if (!useUnscaledHiDPIOutput())
    1324         m_transform = m_transform.scale(devicePixelRatio(), devicePixelRatio());
     1331        m_transform = m_transform.scale(devicePixelRatioActual(), devicePixelRatioActual());
    13251332    m_transform = m_transform.scale(1.0 / devicePixelRatio(), 1.0 / devicePixelRatio());
    13261333}
    … …  
    13371344    /* But if we should scale image by some reason: */
    13381345    if (   scaledSize().isValid()
    1339         || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
     1346        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
    13401347    {
    13411348        /* Calculate final scaled size: */
    13421349        QSize effectiveSize = !scaledSize().isValid() ? pSourceImage->size() : scaledSize();
    13431350        /* Take the device-pixel-ratio into account: */
    1344         if (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0)
    1345             effectiveSize *= devicePixelRatio();
     1351        if (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0)
     1352            effectiveSize *= devicePixelRatioActual();
    13461353        /* We scale the image to requested size and retain it
    13471354         * by making heap shallow copy of that temporary object: */
    … …  
    13921399    /* If we had to scale image for some reason: */
    13931400    if (   scaledSize().isValid()
    1394         || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
     1401        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
    13951402    {
    13961403        /* Wipe out copied image: */
    … …  
    14111418    /* But if we should scale image by some reason: */
    14121419    if (   scaledSize().isValid()
    1413         || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
     1420        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
    14141421    {
    14151422        /* Calculate final scaled size: */
    14161423        QSize effectiveSize = !scaledSize().isValid() ? pSourceImage->size() : scaledSize();
    14171424        /* Take the device-pixel-ratio into account: */
    1418         if (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0)
    1419             effectiveSize *= devicePixelRatio();
     1425        if (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0)
     1426            effectiveSize *= devicePixelRatioActual();
    14201427        /* We scale the image to requested size and retain it
    14211428         * by making heap shallow copy of that temporary object: */
    … …  
    14821489    /* If we had to scale image for some reason: */
    14831490    if (   scaledSize().isValid()
    1484         || (!useUnscaledHiDPIOutput() && devicePixelRatio() != 1.0))
     1491        || (!useUnscaledHiDPIOutput() && devicePixelRatioActual() != 1.0))
    14851492    {
    14861493        /* Wipe out copied image: */
    … …  
    16851692}
    16861693
     1694double UIFrameBuffer::devicePixelRatioActual() const
     1695{
     1696    return m_pFrameBuffer->devicePixelRatioActual();
     1697}
     1698
     1699void UIFrameBuffer::setDevicePixelRatioActual(double dDevicePixelRatioActual)
     1700{
     1701    m_pFrameBuffer->setDevicePixelRatioActual(dDevicePixelRatioActual);
     1702}
     1703
    16871704bool UIFrameBuffer::useUnscaledHiDPIOutput() const
    16881705{

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

    r71056 r71074  
    110110    /** Defines device-pixel-ratio set for HiDPI frame-buffer. */
    111111    void setDevicePixelRatio(double dDevicePixelRatio);
     112    /** Returns actual device-pixel-ratio set for HiDPI frame-buffer. */
     113    double devicePixelRatioActual() const;
     114    /** Defines actual device-pixel-ratio set for HiDPI frame-buffer. */
     115    void setDevicePixelRatioActual(double dDevicePixelRatioActual);
    112116
    113117    /** Returns whether frame-buffer should use unscaled HiDPI output. */

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

    r71073 r71074  
    261261        // not 3D overlay itself, so for auto scale-up mode we have to take that into account.
    262262        if (!fUseUnscaledHiDPIOutput)
    263             dScaleFactorFor3D *= frameBuffer()->devicePixelRatio();
     263            dScaleFactorFor3D *= frameBuffer()->devicePixelRatioActual();
    264264#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    265265        display().NotifyScaleFactorChange(m_uScreenId,
    … …  
    366366        /* Assign new frame-buffer logical-size: */
    367367        QSize scaledSize = size();
    368         const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
    369         scaledSize *= dDevicePixelRatio;
     368        const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
     369        const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     370        scaledSize *= dDevicePixelRatioFormal;
    370371        if (!frameBuffer()->useUnscaledHiDPIOutput())
    371             scaledSize /= dDevicePixelRatio;
     372            scaledSize /= dDevicePixelRatioActual;
    372373        frameBuffer()->setScaledSize(scaledSize);
    373374
    … …  
    453454
    454455    /* Take the device-pixel-ratio into account: */
    455     const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
    456     if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatio != 1.0)
    457     {
    458         rect.moveTo((int)floor((double)rect.x() * dDevicePixelRatio) - 1,
    459                     (int)floor((double)rect.y() * dDevicePixelRatio) - 1);
    460         rect.setSize(QSize((int)ceil((double)rect.width()  * dDevicePixelRatio) + 2,
    461                            (int)ceil((double)rect.height() * dDevicePixelRatio) + 2));
    462     }
    463     if (dDevicePixelRatio != 1.0)
    464     {
    465         rect.moveTo((int)floor((double)rect.x() / dDevicePixelRatio) - 1,
    466                     (int)floor((double)rect.y() / dDevicePixelRatio) - 1);
    467         rect.setSize(QSize((int)ceil((double)rect.width()  / dDevicePixelRatio) + 2,
    468                            (int)ceil((double)rect.height() / dDevicePixelRatio) + 2));
     456    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
     457    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     458    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
     459    {
     460        rect.moveTo((int)floor((double)rect.x() * dDevicePixelRatioActual) - 1,
     461                    (int)floor((double)rect.y() * dDevicePixelRatioActual) - 1);
     462        rect.setSize(QSize((int)ceil((double)rect.width()  * dDevicePixelRatioActual) + 2,
     463                           (int)ceil((double)rect.height() * dDevicePixelRatioActual) + 2));
     464    }
     465    if (dDevicePixelRatioFormal != 1.0)
     466    {
     467        rect.moveTo((int)floor((double)rect.x() / dDevicePixelRatioFormal) - 1,
     468                    (int)floor((double)rect.y() / dDevicePixelRatioFormal) - 1);
     469        rect.setSize(QSize((int)ceil((double)rect.width()  / dDevicePixelRatioFormal) + 2,
     470                           (int)ceil((double)rect.height() / dDevicePixelRatioFormal) + 2));
    469471    }
    470472
    … …  
    512514        // not 3D overlay itself, so for auto scale-up mode we have to take that into account.
    513515        if (!fUseUnscaledHiDPIOutput)
    514             dScaleFactorFor3D *= frameBuffer()->devicePixelRatio();
     516            dScaleFactorFor3D *= frameBuffer()->devicePixelRatioActual();
    515517#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    516518        display().NotifyScaleFactorChange(m_uScreenId,
    … …  
    712714
    713715        /* Take the scale-factor related attributes into account: */
    714         const double dDevicePixelRatio = gpDesktop->devicePixelRatio(machineWindow());
     716        const double dDevicePixelRatioFormal = gpDesktop->devicePixelRatio(machineWindow());
     717        const double dDevicePixelRatioActual = gpDesktop->devicePixelRatioActual(machineWindow());
    715718        const double dScaleFactor = gEDataManager->scaleFactor(vboxGlobal().managedVMUuid());
    716719        const bool fUseUnscaledHiDPIOutput = gEDataManager->useUnscaledHiDPIOutput(vboxGlobal().managedVMUuid());
    717         m_pFrameBuffer->setDevicePixelRatio(dDevicePixelRatio);
     720        m_pFrameBuffer->setDevicePixelRatio(dDevicePixelRatioFormal);
     721        m_pFrameBuffer->setDevicePixelRatioActual(dDevicePixelRatioActual);
    718722        m_pFrameBuffer->setScaleFactor(dScaleFactor);
    719723        m_pFrameBuffer->setUseUnscaledHiDPIOutput(fUseUnscaledHiDPIOutput);
    … …  
    727731            // not 3D overlay itself, so for auto scale-up mode we have to take that into account.
    728732            if (!fUseUnscaledHiDPIOutput)
    729                 dScaleFactorFor3D *= dDevicePixelRatio;
     733                dScaleFactorFor3D *= dDevicePixelRatioActual;
    730734#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    731735            display().NotifyScaleFactorChange(m_uScreenId,
    … …  
    10611065            /* Assign new frame-buffer logical-size: */
    10621066            QSize scaledSize = size();
    1063             const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
    1064             scaledSize *= dDevicePixelRatio;
     1067            const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
     1068            const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     1069            scaledSize *= dDevicePixelRatioFormal;
    10651070            if (!frameBuffer()->useUnscaledHiDPIOutput())
    1066                 scaledSize /= dDevicePixelRatio;
     1071                scaledSize /= dDevicePixelRatioActual;
    10671072            frameBuffer()->setScaledSize(scaledSize);
    10681073        }
    … …  
    11271132
    11281133    /* Take the device-pixel-ratio into account: */
    1129     const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
    1130     if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatio != 1.0)
    1131         screenShot = screenShot.scaled(screenShot.size() * dDevicePixelRatio,
     1134    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     1135    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
     1136        screenShot = screenShot.scaled(screenShot.size() * dDevicePixelRatioActual,
    11321137                                       Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
    11331138
    … …  
    11651170
    11661171    /* Take the device-pixel-ratio into account: */
    1167     const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
    1168     if (!frameBuffer()->useUnscaledHiDPIOutput())
    1169         effectiveSize *= dDevicePixelRatio;
     1172    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     1173    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
     1174        effectiveSize *= dDevicePixelRatioActual;
    11701175
    11711176    /* Create a screen-shot on the basis of the screen-data we have in saved-state: */
    … …  
    11981203
    11991204    /* Take the device-pixel-ratio into account: */
    1200     const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
    1201     if (!frameBuffer()->useUnscaledHiDPIOutput())
    1202         scaledSize *= dDevicePixelRatio;
     1205    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     1206    if (!frameBuffer()->useUnscaledHiDPIOutput() && dDevicePixelRatioActual != 1.0)
     1207        scaledSize *= dDevicePixelRatioActual;
    12031208
    12041209    /* Update pause pixmap finally: */
    … …  
    12301235
    12311236    /* Take the device-pixel-ratio into account: */
    1232     const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
    1233     xRange *= dDevicePixelRatio;
    1234     yRange *= dDevicePixelRatio;
     1237    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
     1238    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     1239    xRange *= dDevicePixelRatioFormal;
     1240    yRange *= dDevicePixelRatioFormal;
    12351241    if (!frameBuffer()->useUnscaledHiDPIOutput())
    12361242    {
    1237         xRange /= dDevicePixelRatio;
    1238         yRange /= dDevicePixelRatio;
     1243        xRange /= dDevicePixelRatioActual;
     1244        yRange /= dDevicePixelRatioActual;
    12391245    }
    12401246
    … …  
    12531259
    12541260    /* Take the device-pixel-ratio into account: */
    1255     const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     1261    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
     1262    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    12561263    if (!frameBuffer()->useUnscaledHiDPIOutput())
    12571264    {
    1258         iContentsX *= dDevicePixelRatio;
    1259         iContentsY *= dDevicePixelRatio;
    1260     }
    1261     iContentsX /= dDevicePixelRatio;
    1262     iContentsY /= dDevicePixelRatio;
     1265        iContentsX *= dDevicePixelRatioActual;
     1266        iContentsY *= dDevicePixelRatioActual;
     1267    }
     1268    iContentsX /= dDevicePixelRatioFormal;
     1269    iContentsY /= dDevicePixelRatioFormal;
    12631270
    12641271    /* Return point shifted according scroll-bars: */
    … …  
    14721479                        /* Update device-pixel-ratio for underlying frame-buffer: */
    14731480                        m_pFrameBuffer->setDevicePixelRatio(gpDesktop->devicePixelRatio(machineWindow()));
     1481                        m_pFrameBuffer->setDevicePixelRatioActual(gpDesktop->devicePixelRatioActual(machineWindow()));
    14741482                        /* Perform frame-buffer rescaling: */
    14751483                        m_pFrameBuffer->performRescale();
    … …  
    18781886
    18791887    /* Take the device-pixel-ratio into account: */
    1880     const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     1888    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
     1889    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    18811890    if (!frameBuffer()->useUnscaledHiDPIOutput())
    1882         size = QSize(size.width() * dDevicePixelRatio, size.height() * dDevicePixelRatio);
    1883     size = QSize(size.width() / dDevicePixelRatio, size.height() / dDevicePixelRatio);
     1891        size = QSize(size.width() * dDevicePixelRatioActual, size.height() * dDevicePixelRatioActual);
     1892    size = QSize(size.width() / dDevicePixelRatioFormal, size.height() / dDevicePixelRatioFormal);
    18841893
    18851894    /* Return result: */
    … …  
    18901899{
    18911900    /* Take the device-pixel-ratio into account: */
    1892     const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
    1893     size = QSize(size.width() * dDevicePixelRatio, size.height() * dDevicePixelRatio);
     1901    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
     1902    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
     1903    size = QSize(size.width() * dDevicePixelRatioFormal, size.height() * dDevicePixelRatioFormal);
    18941904    if (!frameBuffer()->useUnscaledHiDPIOutput())
    1895         size = QSize(size.width() / dDevicePixelRatio, size.height() / dDevicePixelRatio);
     1905        size = QSize(size.width() / dDevicePixelRatioActual, size.height() / dDevicePixelRatioActual);
    18961906
    18971907    /* Take the scale-factor into account: */

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

    r71073 r71074  
    10451045
    10461046            /* Take the device-pixel-ratio into account: */
    1047             const double dDevicePixelRatio = pFrameBuffer->devicePixelRatio();
    1048             cpnt.setX(cpnt.x() * dDevicePixelRatio);
    1049             cpnt.setY(cpnt.y() * dDevicePixelRatio);
     1047            const double dDevicePixelRatioFormal = pFrameBuffer->devicePixelRatio();
     1048            const double dDevicePixelRatioActual = pFrameBuffer->devicePixelRatioActual();
     1049            cpnt.setX(cpnt.x() * dDevicePixelRatioFormal);
     1050            cpnt.setY(cpnt.y() * dDevicePixelRatioFormal);
    10501051            if (!pFrameBuffer->useUnscaledHiDPIOutput())
    10511052            {
    1052                 cpnt.setX(cpnt.x() / dDevicePixelRatio);
    1053                 cpnt.setY(cpnt.y() / dDevicePixelRatio);
     1053                cpnt.setX(cpnt.x() / dDevicePixelRatioActual);
     1054                cpnt.setY(cpnt.y() / dDevicePixelRatioActual);
    10541055            }
    10551056

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

    r71073 r71074  
    6464    /* Assign new frame-buffer logical-size: */
    6565    QSize scaledSize = size();
    66     const double dDevicePixelRatio = frameBuffer()->devicePixelRatio();
     66    const double dDevicePixelRatioFormal = frameBuffer()->devicePixelRatio();
     67    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual();
    6768    const bool fUseUnscaledHiDPIOutput = frameBuffer()->useUnscaledHiDPIOutput();
    68     scaledSize *= dDevicePixelRatio;
     69    scaledSize *= dDevicePixelRatioFormal;
    6970    if (!fUseUnscaledHiDPIOutput)
    70         scaledSize /= dDevicePixelRatio;
     71        scaledSize /= dDevicePixelRatioActual;
    7172    frameBuffer()->setScaledSize(scaledSize);
    7273    frameBuffer()->performRescale();
    … …  
    8687            if (!fUseUnscaledHiDPIOutput)
    8788            {
    88                 xScaleFactor *= dDevicePixelRatio;
    89                 yScaleFactor *= dDevicePixelRatio;
     89                xScaleFactor *= dDevicePixelRatioActual;
     90                yScaleFactor *= dDevicePixelRatioActual;
    9091            }
    9192#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    … …  
    130131    /* If scaled-size is valid: */
    131132    const QSize scaledSize = frameBuffer()->scaledSize();
    132     const double dDevicePixelRatio = frameBuffer()->devicePixelRatio(); Q_UNUSED(dDevicePixelRatio);
     133    const double dDevicePixelRatioActual = frameBuffer()->devicePixelRatioActual(); Q_UNUSED(dDevicePixelRatioActual);
    133134    const bool fUseUnscaledHiDPIOutput = frameBuffer()->useUnscaledHiDPIOutput();
    134135    if (scaledSize.isValid())
    … …  
    145146            if (!fUseUnscaledHiDPIOutput)
    146147            {
    147                 xScaleFactor *= dDevicePixelRatio;
    148                 yScaleFactor *= dDevicePixelRatio;
     148                xScaleFactor *= dDevicePixelRatioActual;
     149                yScaleFactor *= dDevicePixelRatioActual;
    149150            }
    150151#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
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