Changeset 53372 in vbox for trunk/src/VBox/Frontends/VirtualBox

Timestamp:

Nov 21, 2014 1:52:39 PM (10 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

96997

Message:

FE/Qt: 6278: Support for scaled video-output: Initial implementation, no UI settings for now.

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• extradata/UIExtraDataDefs.cpp (modified) (1 diff)
• extradata/UIExtraDataDefs.h (modified) (1 diff)
• extradata/UIExtraDataManager.cpp (modified) (2 diffs)
• extradata/UIExtraDataManager.h (modified) (1 diff)
• runtime/UIFrameBuffer.cpp (modified) (8 diffs)
• runtime/UIFrameBuffer.h (modified) (2 diffs)
• runtime/UIMachineView.cpp (modified) (12 diffs)
• runtime/UIMachineView.h (modified) (2 diffs)
• runtime/scale/UIMachineViewScale.cpp (modified) (3 diffs)
• runtime/scale/UIMachineViewScale.h (modified) (2 diffs)

trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataDefs.cpp

@@ -136 +136 @@
 const char* UIExtraDataDefs::GUI_GuruMeditationHandler = "GUI/GuruMeditationHandler";
 const char* UIExtraDataDefs::GUI_HidLedsSync = "GUI/HidLedsSync";
+const char* UIExtraDataDefs::GUI_ScaleFactor = "GUI/ScaleFactor";
 
 /* Virtual Machine: Information dialog: */

trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataDefs.h

@@ -237 +237 @@
         /** Holds whether machine should perform HID LEDs synchronization. */
         extern const char* GUI_HidLedsSync;
+        /** Holds the scale-factor. */
+        extern const char* GUI_ScaleFactor;
     /** @} */
 

trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.cpp

@@ -1792 +1792 @@
            << GUI_GuruMeditationHandler
            << GUI_HidLedsSync
+           << GUI_ScaleFactor
            << GUI_InformationWindowGeometry
            << GUI_DefaultCloseAction << GUI_RestrictedCloseActions
@@ -3255 +3256 @@
     /* 'True' unless feature restricted: */
     return !isFeatureRestricted(GUI_HidLedsSync, strID);
+}
+
+double UIExtraDataManager::scaleFactor(const QString &strID)
+{
+    /* Get corresponding extra-data value: */
+    const QString strValue = extraDataString(GUI_ScaleFactor, strID);
+
+    /* Try to convert loaded data to double: */
+    bool fOk = false;
+    double dValue = strValue.toDouble(&fOk);
+
+    /* Invent the default value: */
+    if (!fOk || !dValue)
+        dValue = 1;
+
+    /* Return value: */
+    return dValue;
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.h

@@ -450 +450 @@
         /** Returns whether machine should perform HID LEDs synchronization. */
         bool hidLedsSyncState(const QString &strID);
+
+        /** Returns scale-factor. */
+        double scaleFactor(const QString &strID);
     /** @} */
 

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

@@ -28 +28 @@
 # include "UIMachineView.h"
 # include "UIPopupCenter.h"
+# include "UIExtraDataManager.h"
 # include "VBoxGlobal.h"
 # ifdef VBOX_WITH_MASKED_SEAMLESS
@@ -61 +62 @@
     , m_fUnused(false)
     , m_fAutoEnabled(false)
+    , m_dScaleFactor(gEDataManager->scaleFactor(vboxGlobal().managedVMUuid()))
     , m_hiDPIOptimizationType(HiDPIOptimizationType_None)
     , m_dBackingScaleFactor(1.0)
@@ -469 +471 @@
         rect.setRight(rects->xRight - 1);
         rect.setBottom(rects->yBottom - 1);
+        /* Tune according scale-factor: */
+        // TODO: Take rounding into account..
+        rect.moveTo(rect.topLeft() * m_dScaleFactor);
+        rect.setSize(rect.size() * m_dScaleFactor);
         /* Append region: */
         region += rect;
@@ -719 +725 @@
             paintSeamless(pEvent);
             break;
-        case UIVisualStateType_Scale:
-            paintScaled(pEvent);
-            break;
         default:
             paintDefault(pEvent);
@@ -791 +794 @@
 void UIFrameBuffer::paintDefault(QPaintEvent *pEvent)
 {
+    /* Scaled image is NULL by default: */
+    QImage scaledImage;
+    /* But if scaled-factor is set and current image is NOT null: */
+    if (m_scaledSize.isValid() && !m_image.isNull())
+    {
+        /* We are doing a deep copy of the image to make sure it will not be
+         * detached during scale process, otherwise we can get a frozen frame-buffer. */
+        scaledImage = m_image.copy();
+        /* And scaling the image to predefined scaled-factor: */
+        scaledImage = scaledImage.scaled(m_scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+    }
+    /* Finally we are choosing image to paint from: */
+    const QImage &sourceImage = scaledImage.isNull() ? m_image : scaledImage;
+
     /* Get rectangle to paint: */
-    QRect paintRect = pEvent->rect().intersected(m_image.rect()).intersected(m_pMachineView->viewport()->geometry());
+    QRect paintRect = pEvent->rect().intersected(sourceImage.rect()).intersected(m_pMachineView->viewport()->geometry());
     if (paintRect.isEmpty())
         return;
@@ -800 +817 @@
 
     /* Draw image rectangle: */
-    drawImageRect(painter, m_image, paintRect,
+    drawImageRect(painter, sourceImage, paintRect,
                   m_pMachineView->contentsX(), m_pMachineView->contentsY(),
                   hiDPIOptimizationType(), backingScaleFactor());
@@ -807 +824 @@
 void UIFrameBuffer::paintSeamless(QPaintEvent *pEvent)
 {
+    /* Scaled image is NULL by default: */
+    QImage scaledImage;
+    /* But if scaled-factor is set and current image is NOT null: */
+    if (m_scaledSize.isValid() && !m_image.isNull())
+    {
+        /* We are doing a deep copy of the image to make sure it will not be
+         * detached during scale process, otherwise we can get a frozen frame-buffer. */
+        scaledImage = m_image.copy();
+        /* And scaling the image to predefined scaled-factor: */
+        scaledImage = scaledImage.scaled(m_scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+    }
+    /* Finally we are choosing image to paint from: */
+    const QImage &sourceImage = scaledImage.isNull() ? m_image : scaledImage;
+
     /* Get rectangle to paint: */
-    QRect paintRect = pEvent->rect().intersected(m_image.rect()).intersected(m_pMachineView->viewport()->geometry());
+    QRect paintRect = pEvent->rect().intersected(sourceImage.rect()).intersected(m_pMachineView->viewport()->geometry());
     if (paintRect.isEmpty())
         return;
@@ -851 +882 @@
 
             /* Draw image rectangle: */
-            drawImageRect(painter, m_image, rect,
+            drawImageRect(painter, sourceImage, rect,
                           m_pMachineView->contentsX(), m_pMachineView->contentsY(),
                           hiDPIOptimizationType(), backingScaleFactor());
         }
     }
-}
-
-void UIFrameBuffer::paintScaled(QPaintEvent *pEvent)
-{
-    /* Scaled image is NULL by default: */
-    QImage scaledImage;
-    /* But if scaled-factor is set and current image is NOT null: */
-    if (m_scaledSize.isValid() && !m_image.isNull())
-    {
-        /* We are doing a deep copy of the image to make sure it will not be
-         * detached during scale process, otherwise we can get a frozen frame-buffer. */
-        scaledImage = m_image.copy();
-        /* And scaling the image to predefined scaled-factor: */
-        scaledImage = scaledImage.scaled(m_scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
-    }
-    /* Finally we are choosing image to paint from: */
-    QImage &sourceImage = scaledImage.isNull() ? m_image : scaledImage;
-
-    /* Get rectangle to paint: */
-    QRect paintRect = pEvent->rect().intersected(sourceImage.rect()).intersected(m_pMachineView->viewport()->geometry());
-    if (paintRect.isEmpty())
-        return;
-
-    /* Create painter: */
-    QPainter painter(m_pMachineView->viewport());
-
-    /* Draw image rectangle: */
-    drawImageRect(painter, sourceImage, paintRect,
-                  m_pMachineView->contentsX(), m_pMachineView->contentsY(),
-                  hiDPIOptimizationType(), backingScaleFactor());
 }
 

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

@@ -234 +234 @@
     /** Paint routine for seamless mode. */
     void paintSeamless(QPaintEvent *pEvent);
-    /** Paint routine for scaled mode. */
-    void paintScaled(QPaintEvent *pEvent);
 
     /** Draws corresponding @a rect of passed @a image with @a painter. */
@@ -277 +275 @@
     mutable RTCRITSECT m_critSect;
 
-    /** @name Scaled mode related variables.
+    /** @name Scale-factor related variables.
      * @{ */
-    /** Holds frame-buffer scaled size. */
+    /** Holds the scale-factor used by the scaled-size. */
+    const double m_dScaleFactor;
+    /** Holds the frame-buffer's scaled-size. */
     QSize m_scaledSize;
     /** @} */

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

@@ -185 +185 @@
     AssertMsg(newSize.isValid(), ("Size should be valid!\n"));
 
+    /* Take the scale-factor into account: */
+    const double dScaleFactor = gEDataManager->scaleFactor(vboxGlobal().managedVMUuid());
+    newSize /= dScaleFactor;
+
     /* Expand current limitations: */
     setMaxGuestSize(newSize);
@@ -224 +228 @@
             frameBuffer()->setScaledSize(size());
         }
+        /* Adjust other modes to current NotifyChange event size: */
+        else
+        {
+            /* Assign new frame-buffer logical-size taking the scale-factor into account: */
+            const double dScaleFactor = gEDataManager->scaleFactor(vboxGlobal().managedVMUuid());
+            frameBuffer()->setScaledSize(dScaleFactor == 1 ? QSize() : QSize(iWidth * dScaleFactor, iHeight * dScaleFactor));
+        }
 
         /* Perform frame-buffer mode-change: */
@@ -271 +282 @@
 void UIMachineView::sltHandleNotifyUpdate(int iX, int iY, int iWidth, int iHeight)
 {
-    /* Update corresponding viewport part: */
-    viewport()->update(iX - contentsX(), iY - contentsY(), iWidth, iHeight);
+    /* Take the scale-factor into account: */
+    const double dScaleFactor = gEDataManager->scaleFactor(vboxGlobal().managedVMUuid());
+    if (dScaleFactor == 1)
+    {
+        /* Just update corresponding viewport part: */
+        viewport()->update(iX - contentsX(), iY - contentsY(), iWidth, iHeight);
+    }
+    else
+    {
+        /* Calculate corresponding viewport part: */
+        QRect rect(iX * dScaleFactor - 1 - contentsX(),
+                   iY * dScaleFactor - 1 - contentsY(),
+                   iWidth  * dScaleFactor + 2 * dScaleFactor + 1,
+                   iHeight * dScaleFactor + 2 * dScaleFactor + 1);
+        /* Limit the resulting part by the viewport rectangle: */
+        rect &= viewport()->rect();
+        /* Update corresponding viewport part: */
+        viewport()->update(rect);
+    }
 }
 
@@ -392 +420 @@
 void UIMachineView::prepareFrameBuffer()
 {
+    /* Take scale-factor into account: */
+    const double dScaleFactor = gEDataManager->scaleFactor(vboxGlobal().managedVMUuid());
+
     /* Prepare frame-buffer: */
     UIFrameBuffer *pFrameBuffer = uisession()->frameBuffer(screenId());
@@ -422 +453 @@
 # endif /* !VBOX_WITH_VIDEOHWACCEL */
         m_pFrameBuffer->setHiDPIOptimizationType(uisession()->hiDPIOptimizationType());
-
+        m_pFrameBuffer->setScaledSize(dScaleFactor == 1 ? QSize() :
+                                      QSize(m_pFrameBuffer->width() * dScaleFactor,
+                                            m_pFrameBuffer->height() * dScaleFactor));
         uisession()->setFrameBuffer(screenId(), m_pFrameBuffer);
     }
@@ -463 +496 @@
     /* If we have a valid size, resize the framebuffer. */
     if (size.width() > 0 && size.height() > 0)
+    {
         frameBuffer()->resizeEvent(size.width(), size.height());
+        frameBuffer()->setScaledSize(dScaleFactor == 1 ? QSize() :
+                                     QSize(frameBuffer()->width() * dScaleFactor,
+                                           frameBuffer()->height() * dScaleFactor));
+    }
 }
 
@@ -609 +647 @@
     QSize size(m_pFrameBuffer->width(), m_pFrameBuffer->height());
 
+    /* Take the scale-factor into account: */
+    const double dScaleFactor = gEDataManager->scaleFactor(vboxGlobal().managedVMUuid());
+    size *= dScaleFactor;
+
 #ifdef VBOX_WITH_DEBUGGER_GUI
     // TODO: Fix all DEBUGGER stuff!
@@ -689 +731 @@
         size = QSize(800, 600);
 
+    /* Take the scale-factor into account: */
+    const double dScaleFactor = gEDataManager->scaleFactor(vboxGlobal().managedVMUuid());
+    size *= dScaleFactor;
+
     /* Return size: */
     return size;
@@ -704 +750 @@
 void UIMachineView::resetPausePixmap()
 {
-    /* Reset pixmap: */
+    /* Reset pixmap(s): */
     m_pausePixmap = QPixmap();
+    m_pausePixmapScaled = QPixmap();
 }
 
@@ -737 +784 @@
     /* Finally copy the screen-shot to pause-pixmap: */
     m_pausePixmap = QPixmap::fromImage(screenShot);
+
+    /* Update scaled pause pixmap: */
+    updateScaledPausePixmap();
 }
 
@@ -763 +813 @@
     /* Finally copy the screen-shot to pause-pixmap: */
     m_pausePixmap = QPixmap::fromImage(screenShot);
+
+    /* Update scaled pause pixmap: */
+    updateScaledPausePixmap();
+}
+
+void UIMachineView::updateScaledPausePixmap()
+{
+    /* Make sure pause pixmap is not null: */
+    if (pausePixmap().isNull())
+        return;
+
+    /* Make sure scaled-size is not null: */
+    const QSize scaledSize = frameBuffer()->scaledSize();
+    if (!scaledSize.isValid())
+        return;
+
+    /* Update pause pixmap finally: */
+    m_pausePixmapScaled = pausePixmap().scaled(scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 }
 
@@ -1001 +1069 @@
         QRect rect = pPaintEvent->rect().intersect(viewport()->rect());
         QPainter painter(viewport());
-        painter.drawPixmap(rect, pausePixmap(), QRect(rect.x() + contentsX(), rect.y() + contentsY(),
-                                                      rect.width(), rect.height()));
+        /* Take the scale-factor into account: */
+        const double dScaleFactor = gEDataManager->scaleFactor(vboxGlobal().managedVMUuid());
+        if (dScaleFactor == 1)
+            painter.drawPixmap(rect, pausePixmap(), QRect(rect.x() + contentsX(), rect.y() + contentsY(),
+                                                          rect.width(), rect.height()));
+        else
+            painter.drawPixmap(rect, pausePixmapScaled(), QRect(rect.x() + contentsX(), rect.y() + contentsY(),
+                                                                rect.width(), rect.height()));
 #ifdef Q_WS_MAC
         /* Update the dock icon: */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.h

@@ -194 +194 @@
     /** Returns the pause-pixmap: */
     const QPixmap& pausePixmap() const { return m_pausePixmap; }
+    /** Returns the scaled pause-pixmap: */
+    const QPixmap& pausePixmapScaled() const { return m_pausePixmapScaled; }
     /** Resets the pause-pixmap. */
-    virtual void resetPausePixmap();
+    void resetPausePixmap();
     /** Acquires live pause-pixmap. */
-    virtual void takePausePixmapLive();
+    void takePausePixmapLive();
     /** Acquires snapshot pause-pixmap. */
-    virtual void takePausePixmapSnapshot();
+    void takePausePixmapSnapshot();
+    /** Updates the scaled pause-pixmap. */
+    void updateScaledPausePixmap();
 
     /** The available area on the current screen for application windows. */
@@ -275 +279 @@
     /** Holds the pause-pixmap. */
     QPixmap m_pausePixmap;
+    /** Holds the scaled pause-pixmap. */
+    QPixmap m_pausePixmapScaled;
 
     /* Friend classes: */

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

@@ -53 +53 @@
 #endif
                     )
-    , m_pPauseImage(0)
 {
     /* Resend the last resize hint if necessary: */
@@ -71 +70 @@
 }
 
-void UIMachineViewScale::takePausePixmapLive()
-{
-    /* Take a screen snapshot. Note that TakeScreenShot() always needs a 32bpp image: */
-    QImage shot = QImage(m_pFrameBuffer->width(), m_pFrameBuffer->height(), QImage::Format_RGB32);
-    /* If TakeScreenShot fails or returns no image, just show a black image. */
-    shot.fill(0);
-    display().TakeScreenShot(screenId(), shot.bits(), shot.width(), shot.height(), KBitmapFormat_BGR0);
-    m_pPauseImage = new QImage(shot);
-    scalePauseShot();
-}
-
-void UIMachineViewScale::takePausePixmapSnapshot()
-{
-    ULONG width = 0, height = 0;
-    QVector<BYTE> screenData = machine().ReadSavedScreenshotPNGToArray(0, width, height);
-    if (screenData.size() != 0)
-    {
-        ULONG guestOriginX = 0, guestOriginY = 0, guestWidth = 0, guestHeight = 0;
-        BOOL fEnabled = true;
-        machine().QuerySavedGuestScreenInfo(m_uScreenId, guestOriginX, guestOriginY, guestWidth, guestHeight, fEnabled);
-        QImage shot = QImage::fromData(screenData.data(), screenData.size(), "PNG").scaled(guestWidth > 0 ? QSize(guestWidth, guestHeight) : guestSizeHint());
-        m_pPauseImage = new QImage(shot);
-        scalePauseShot();
-    }
-}
-
-void UIMachineViewScale::resetPausePixmap()
-{
-    /* Call the base class */
-    UIMachineView::resetPausePixmap();
-
-    if (m_pPauseImage)
-    {
-        delete m_pPauseImage;
-        m_pPauseImage = 0;
-    }
-}
-
-void UIMachineViewScale::scalePauseShot()
-{
-    if (m_pPauseImage)
-    {
-        QSize scaledSize = frameBuffer()->scaledSize();
-        if (scaledSize.isValid())
-        {
-            QImage tmpImg = m_pPauseImage->scaled(scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
-            dimImage(tmpImg);
-            m_pausePixmap = QPixmap::fromImage(tmpImg);
-        }
-    }
-}
-
 void UIMachineViewScale::sltPerformGuestScale()
 {
@@ -129 +76 @@
     frameBuffer()->setScaledSize(viewport()->size());
 
-    /* Scale the pause image if necessary */
-    scalePauseShot();
+    /* Scale the pause-pixmap: */
+    updateScaledPausePixmap();
 
     /* Update viewport: */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineViewScale.h

@@ -37 +37 @@
     virtual ~UIMachineViewScale();
 
-    virtual void takePausePixmapLive();
-    virtual void takePausePixmapSnapshot();
-    virtual void resetPausePixmap();
-    void scalePauseShot();
-
 private slots:
 
@@ -70 +65 @@
     void updateSliders();
 
-    /* Private members: */
-    QImage *m_pPauseImage;
-
     /* Friend classes: */
     friend class UIMachineView;