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

Timestamp:

May 24, 2013 12:44:24 PM (12 years ago)

Author:

vboxsync

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

85987

Message:

FE/Qt: 6749: Runtime UI: QImage frame-buffer: Support for embedded clipping (which required by the seamless-mode) under Win/Mac hosts.

Location:

trunk/src/VBox/Frontends/VirtualBox/src/runtime

Files:

• UIFrameBuffer.h (modified) (2 diffs)
• UIFrameBufferQImage.cpp (modified) (3 diffs)
• UIFrameBufferQImage.h (modified) (2 diffs)
• UIFrameBufferQuartz2D.cpp (modified) (2 diffs)
• UIFrameBufferQuartz2D.h (modified) (1 diff)
• seamless/UIMachineViewSeamless.cpp (modified) (1 diff)
• seamless/UIMachineViewSeamless.h (modified) (3 diffs)
• seamless/UIMachineWindowSeamless.cpp (modified) (2 diffs)
• seamless/UIMachineWindowSeamless.h (modified) (2 diffs)

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

@@ -216 +216 @@
     virtual void resizeEvent(UIResizeEvent *pEvent) = 0;
     virtual void paintEvent(QPaintEvent *pEvent) = 0;
+    virtual void applyVisibleRegionEvent(UISetRegionEvent *pEvent) = 0;
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -236 +237 @@
     ulong m_width;
     ulong m_height;
+    QRegion m_visibleRegion;
     QSize m_scaledSize;
     int64_t m_WinId;

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

@@ -34 +34 @@
 # include "VBoxGlobal.h"
 # include "UISession.h"
+# include "UIMachineLogic.h"
+# ifdef Q_WS_X11
+#  include "UIMachineWindow.h"
+# endif /* Q_WS_X11 */
 
 /* COM includes: */
@@ -51 +55 @@
 void UIFrameBufferQImage::resizeEvent(UIResizeEvent *pEvent)
 {
-#if 0
-    LogFlowFunc (("fmt=%d, vram=%p, bpp=%d, bpl=%d, width=%d, height=%d\n",
-                  pEvent->pixelFormat(), pEvent->VRAM(),
-                  pEvent->bitsPerPixel(), pEvent->bytesPerLine(),
-                  pEvent->width(), pEvent->height()));
-#endif
+    /* Invalidate visible-region if necessary: */
+    if (m_width != pEvent->width() ||
+        m_height != pEvent->height())
+        m_visibleRegion = QRegion();
 
     /* Remember new width/height: */
@@ -156 +158 @@
         goFallback();
 
-    /* Scaled image by default is empty: */
+    /* Depending on visual-state type: */
+    switch (m_pMachineView->machineLogic()->visualStateType())
+    {
+        case UIVisualStateType_Seamless:
+            paintSeamless(pEvent);
+            break;
+        case UIVisualStateType_Scale:
+            paintScale(pEvent);
+            break;
+        default:
+            paintDefault(pEvent);
+            break;
+    }
+}
+
+void UIFrameBufferQImage::applyVisibleRegionEvent(UISetRegionEvent *pEvent)
+{
+    /* Make sure visible-region changed: */
+    if (m_visibleRegion == pEvent->region())
+        return;
+
+    /* Compose viewport region to update: */
+    QRegion toUpdate = pEvent->region() + m_visibleRegion;
+    /* Remember new visible-region: */
+    m_visibleRegion = pEvent->region();
+    /* Update viewport region finally: */
+    m_pMachineView->viewport()->update(toUpdate);
+#ifdef Q_WS_X11
+    /* Qt 4.8.3 under X11 has Qt::WA_TranslucentBackground window attribute broken,
+     * so we are still have to use old one known Xshape extension wrapped by the widget setMask API: */
+    m_pMachineView->machineWindow()->setMask(m_visibleRegion);
+#endif /* Q_WS_X11 */
+}
+
+void UIFrameBufferQImage::paintDefault(QPaintEvent *pEvent)
+{
+    /* Get rectangle to paint: */
+    QRect paintRect = pEvent->rect().intersected(m_img.rect());
+    if (paintRect.isEmpty())
+        return;
+
+    /* Create painter: */
+    QPainter painter(m_pMachineView->viewport());
+
+    /* Draw image rectangle depending on rectangle width: */
+    if ((ulong)paintRect.width() < m_width * 2 / 3)
+        drawImageRectNarrow(painter, m_img,
+                            paintRect, m_pMachineView->contentsX(), m_pMachineView->contentsY());
+    else
+        drawImageRectWide(painter, m_img,
+                          paintRect, m_pMachineView->contentsX(), m_pMachineView->contentsY());
+}
+
+void UIFrameBufferQImage::paintSeamless(QPaintEvent *pEvent)
+{
+    /* Get rectangle to paint: */
+    QRect paintRect = pEvent->rect().intersected(m_img.rect());
+    if (paintRect.isEmpty())
+        return;
+
+    /* Create painter: */
+    QPainter painter(m_pMachineView->viewport());
+
+    /* Clear paint rectangle first: */
+    painter.setCompositionMode(QPainter::CompositionMode_Clear);
+    painter.eraseRect(paintRect);
+    painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
+
+    /* Repaint all the rectangles of visible-region: */
+    QRegion visiblePaintRegion = m_visibleRegion & paintRect;
+    foreach (const QRect &rect, visiblePaintRegion.rects())
+    {
+#ifdef Q_WS_WIN
+        /* Replace translucent background with black one,
+         * that is necessary for window with Qt::WA_TranslucentBackground: */
+        painter.setCompositionMode(QPainter::CompositionMode_Source);
+        painter.fillRect(rect, QColor(Qt::black));
+        painter.setCompositionMode(QPainter::CompositionMode_SourceAtop);
+#endif /* Q_WS_WIN */
+
+        /* Draw image rectangle depending on rectangle width: */
+        if ((ulong)rect.width() < m_width * 2 / 3)
+            drawImageRectNarrow(painter, m_img,
+                                rect, m_pMachineView->contentsX(), m_pMachineView->contentsY());
+        else
+            drawImageRectWide(painter, m_img,
+                              rect, m_pMachineView->contentsX(), m_pMachineView->contentsY());
+    }
+}
+
+void UIFrameBufferQImage::paintScale(QPaintEvent *pEvent)
+{
+    /* Scaled image is NULL by default: */
     QImage scaledImage;
-    /* If scaled-factor is set and current image is NOT null: */
+    /* But if scaled-factor is set and current image is NOT null: */
     if (m_scaledSize.isValid() && !m_img.isNull())
     {
-        /* We are doing a deep copy of image to make sure it will not be
+        /* 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_img.copy();
-        /* Scale image to scaled-factor: */
+        /* And scaling the image to predefined scaled-factor: */
         scaledImage = scaledImage.scaled(m_scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
     }
-    /* Choose required image: */
-    QImage *pSourceImage = scaledImage.isNull() ? &m_img : &scaledImage;
-
-    /* Get clipping rectangle: */
-    const QRect &r = pEvent->rect().intersected(pSourceImage->rect());
-    if (r.isEmpty())
-        return;
-
-#if 0
-    LogFlowFunc (("%dx%d-%dx%d (img=%dx%d)\n", r.x(), r.y(), r.width(), r.height(), img.width(), img.height()));
-#endif
+    /* Finally we are choosing image to paint from: */
+    QImage &sourceImage = scaledImage.isNull() ? m_img : scaledImage;
+
+    /* Get rectangle to paint: */
+    QRect paintRect = pEvent->rect().intersected(sourceImage.rect());
+    if (paintRect.isEmpty())
+        return;
 
     /* Create painter: */
     QPainter painter(m_pMachineView->viewport());
-    if ((ulong)r.width() < m_width * 2 / 3)
-    {
-        /* This method is faster for narrow updates: */
-        m_PM = QPixmap::fromImage(pSourceImage->copy(r.x() + m_pMachineView->contentsX(),
-                                                     r.y() + m_pMachineView->contentsY(),
-                                                     r.width(), r.height()));
-        painter.drawPixmap(r.x(), r.y(), m_PM);
-    }
+
+    /* Draw image rectangle depending on rectangle width: */
+    if ((ulong)paintRect.width() < m_width * 2 / 3)
+        drawImageRectNarrow(painter, sourceImage,
+                            paintRect, m_pMachineView->contentsX(), m_pMachineView->contentsY());
     else
-    {
-        /* This method is faster for wide updates: */
-        m_PM = QPixmap::fromImage(QImage(pSourceImage->scanLine(r.y() + m_pMachineView->contentsY()),
-                                         pSourceImage->width(), r.height(), pSourceImage->bytesPerLine(),
-                                         QImage::Format_RGB32));
-        painter.drawPixmap(r.x(), r.y(), m_PM, r.x() + m_pMachineView->contentsX(), 0, 0, 0);
-    }
+        drawImageRectWide(painter, sourceImage,
+                          paintRect, m_pMachineView->contentsX(), m_pMachineView->contentsY());
+}
+
+/* static */
+void UIFrameBufferQImage::drawImageRectNarrow(QPainter &painter, const QImage &image,
+                                              const QRect &rect, int iContentsShiftX, int iContentsShiftY)
+{
+    /* This method is faster for narrow updates: */
+    QPixmap pm = QPixmap::fromImage(image.copy(rect.x() + iContentsShiftX,
+                                               rect.y() + iContentsShiftY,
+                                               rect.width(), rect.height()));
+    painter.drawPixmap(rect.x(), rect.y(), pm);
+}
+
+/* static */
+void UIFrameBufferQImage::drawImageRectWide(QPainter &painter, const QImage &image,
+                                            const QRect &rect, int iContentsShiftX, int /*iContentsShiftY*/)
+{
+    /* This method is faster for wide updates: */
+    QPixmap pm = QPixmap::fromImage(QImage(image.scanLine(rect.y() + iContentsShiftX),
+                                           image.width(), rect.height(), image.bytesPerLine(),
+                                           QImage::Format_RGB32));
+    painter.drawPixmap(rect.x(), rect.y(), pm, rect.x() + iContentsShiftX, 0, 0, 0);
 }
 

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

@@ -47 +47 @@
     void resizeEvent(UIResizeEvent *pEvent);
     void paintEvent(QPaintEvent *pEvent);
+    void applyVisibleRegionEvent(UISetRegionEvent *pEvent);
 
 private:
+
+    /* Helpers: Visual-mode paint stuff: */
+    void paintDefault(QPaintEvent *pEvent);
+    void paintSeamless(QPaintEvent *pEvent);
+    void paintScale(QPaintEvent *pEvent);
+
+    /* Static helpers: Drawing stuff: */
+    static void drawImageRectNarrow(QPainter &painter, const QImage &image,
+                                    const QRect &rect, int iContentsShiftX, int iContentsShiftY);
+    static void drawImageRectWide(QPainter &painter, const QImage &image,
+                                  const QRect &rect, int iContentsShiftX, int iContentsShiftY);
 
     /* Helper: Fallback stuff: */
@@ -54 +66 @@
 
     /* Variables: */
-    QPixmap m_PM;
     QImage m_img;
     ulong m_uPixelFormat;

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

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2006-2012 Oracle Corporation
+ * Copyright (C) 2006-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -463 +463 @@
 }
 
+void UIFrameBufferQuartz2D::applyVisibleRegionEvent(UISetRegionEvent *pEvent)
+{
+    /* Make sure visible-region changed: */
+    if (m_visibleRegion == pEvent->region())
+        return;
+
+    /* Remember new visible-region: */
+    m_visibleRegion = pEvent->region();
+    /* Invalidate whole the viewport: */
+    ::darwinWindowInvalidateShape(m_pMachineView->viewport());
+}
+
 void UIFrameBufferQuartz2D::clean(bool fPreserveRegions)
 {

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

@@ -50 +50 @@
     void resizeEvent(UIResizeEvent *pEvent);
     void paintEvent(QPaintEvent *pEvent);
+    void applyVisibleRegionEvent(UISetRegionEvent *pEvent);
 
 #ifdef VBOX_WITH_VIDEOHWACCEL

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineViewSeamless.cpp

@@ -85 +85 @@
         {
             /* Apply new seamless-region: */
-            UISetRegionEvent *pSetRegionEvent = static_cast<UISetRegionEvent*>(pEvent);
-            m_lastVisibleRegion = pSetRegionEvent->region();
-            machineWindow()->setMask(m_lastVisibleRegion);
+            m_pFrameBuffer->applyVisibleRegionEvent(static_cast<UISetRegionEvent*>(pEvent));
             return true;
         }

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineViewSeamless.h

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2010-2011 Oracle Corporation
+ * Copyright (C) 2010-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -26 +26 @@
 {
     Q_OBJECT;
-
-public:
-
-    /* Public getters: */
-    QRegion lastVisibleRegion() const { return m_lastVisibleRegion; }
 
 protected:
@@ -72 +67 @@
     QSize calculateMaxGuestSize() const;
 
-    /* Private variables: */
-    QRegion m_lastVisibleRegion;
-
     /* Friend classes: */
     friend class UIMachineView;

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineWindowSeamless.cpp

@@ -87 +87 @@
     UIMachineWindow::prepareVisualState();
 
-    /* This might be required to correctly mask: */
-    centralWidget()->setAutoFillBackground(false);
+#ifdef Q_WS_WIN
+    /* Enable translucent background for Win host,
+     * Mac host has it native, Qt 4.8.3 under x11 host has is broken: */
+    setAttribute(Qt::WA_TranslucentBackground);
+#endif /* Q_WS_WIN */
 
 #ifdef Q_WS_MAC
@@ -270 +273 @@
 #endif /* Q_WS_MAC */
 
-void UIMachineWindowSeamless::setMask(const QRegion &incomingRegion)
-{
-    /* Copy region: */
-    QRegion region(incomingRegion);
-
-#ifndef Q_WS_MAC
+#ifdef Q_WS_WIN
+void UIMachineWindowSeamless::showEvent(QShowEvent*)
+{
+    /* Following workaround allows to fix the next Qt BUG:
+     * https://bugreports.qt-project.org/browse/QTBUG-17548
+     * https://bugreports.qt-project.org/browse/QTBUG-30974
+     * Widgets with Qt::WA_TranslucentBackground attribute
+     * stops repainting after minimizing/restoring, we have to call for single update. */
+    QApplication::postEvent(this, new QEvent(QEvent::UpdateRequest), Qt::LowEventPriority);
+}
+#endif /* Q_WS_WIN */
+
+#ifdef Q_WS_X11
+void UIMachineWindowSeamless::setMask(const QRegion &region)
+{
+    /* Prepare mask-region: */
+    QRegion maskRegion(region);
+
     /* Shift region if left spacer width is NOT zero or top spacer height is NOT zero: */
     if (m_pLeftSpacer->geometry().width() || m_pTopSpacer->geometry().height())
-        region.translate(m_pLeftSpacer->geometry().width(), m_pTopSpacer->geometry().height());
-#endif /* !Q_WS_MAC */
-
-#ifdef VBOX_GUI_USE_QUARTZ2D
-    if (vboxGlobal().vmRenderMode() == Quartz2DMode)
-    {
-        /* If we are using the Quartz2D backend we have to trigger a repaint only.
-         * All the magic clipping stuff is done in the paint engine. */
-        ::darwinWindowInvalidateShape(m_pMachineView->viewport());
-    }
-#else /* VBOX_GUI_USE_QUARTZ2D */
+        maskRegion.translate(m_pLeftSpacer->geometry().width(), m_pTopSpacer->geometry().height());
+
     /* Seamless-window for empty region should be empty too,
-     * but native API wrapped by the QWidget::setMask() doesn't allow this.
+     * but the QWidget::setMask() wrapper doesn't allow this.
      * Instead, we have a full painted screen of seamless-geometry size visible.
      * Moreover, we can't just hide the empty seamless-window as 'hiding'
      * 1. will collide with the multi-screen layout behavior and
      * 2. will cause a task-bar flicker on moving window from one screen to another.
-     * As a temporary though quite a dirty workaround we have to make sure
+     * As a *temporary* though quite a dirty workaround we have to make sure
      * region have at least one pixel. */
-    if (region.isEmpty())
-        region += QRect(0, 0, 1, 1);
-    /* Make sure region had changed: */
-    if (m_previousRegion != region)
-    {
-        /* Remember new region: */
-        m_previousRegion = region;
-        /* Assign new region: */
-        UIMachineWindow::setMask(m_previousRegion);
-        /* Update viewport contents: */
-        m_pMachineView->viewport()->update();
-    }
-#endif /* !VBOX_GUI_USE_QUARTZ2D */
-}
-
+    if (maskRegion.isEmpty())
+        maskRegion += QRect(0, 0, 1, 1);
+    /* Make sure mask-region had changed: */
+    if (m_maskRegion != maskRegion)
+    {
+        /* Compose viewport region to update: */
+        QRegion toUpdate = m_maskRegion + maskRegion;
+        /* Remember new mask-region: */
+        m_maskRegion = maskRegion;
+        /* Assign new mask-region: */
+        UIMachineWindow::setMask(m_maskRegion);
+        /* Update viewport region finally: */
+        m_pMachineView->viewport()->update(toUpdate);
+    }
+}
+#endif /* Q_WS_X11 */
+

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineWindowSeamless.h

@@ -79 +79 @@
 #endif /* Q_WS_MAC */
 
-    /* Helpers: */
+#ifdef Q_WS_WIN
+    /* Handler: Translucency stuff: */
+    void showEvent(QShowEvent *pEvent);
+#endif /* Q_WS_WIN */
+
+#ifdef Q_WS_X11
+    /* Helper: Masking stuff: */
     void setMask(const QRegion &region);
+#endif /* Q_WS_X11 */
 
     /* Widgets: */
@@ -88 +95 @@
 #endif /* !Q_WS_MAC */
 
-    /* Variables: */
-    QRegion m_previousRegion;
+#ifdef Q_WS_X11
+    /* Variable: Masking stuff: */
+    QRegion m_maskRegion;
+#endif /* Q_WS_X11 */
 
     /* Factory support: */