Changeset 27682 in vbox for trunk/src

Timestamp:

Mar 24, 2010 6:37:48 PM (15 years ago)

Author:

vboxsync

Message:

2d: unified code for VBoxXxx & UIXxx, moved 2D state logic outside QGLWidget

Location:

trunk/src/VBox

Files:

• Devices/Graphics/DevVGA_VBVA.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/VBoxConsoleView.cpp (modified) (5 diffs)
• Frontends/VirtualBox/src/VBoxFBOverlay.cpp (modified) (92 diffs)
• Frontends/VirtualBox/src/VBoxFBOverlay.h (modified) (34 diffs)
• Frontends/VirtualBox/src/VBoxFBQGL.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/VBoxFrameBuffer.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/VBoxFrameBuffer.h (modified) (1 diff)
• Frontends/VirtualBox/src/globals/VBoxDefs.h (modified) (1 diff)
• Frontends/VirtualBox/src/globals/VBoxGlobal.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/runtime/UIFrameBufferQGL.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/runtime/UIFrameBufferQGL.h (modified) (1 diff)
• Frontends/VirtualBox/src/runtime/UIMachineView.cpp (modified) (6 diffs)
• Frontends/VirtualBox/src/runtime/UIMachineView.h (modified) (1 diff)

trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp

@@ -1090 +1090 @@
 
         pBody->pVM = pVM;
+        pBody->pvVRAM = pVGAState->vram_ptrR3;
+        pBody->cbVRAM = pVGAState->vram_size;
 
         int rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);

trunk/src/VBox/Frontends/VirtualBox/src/VBoxConsoleView.cpp

@@ -756 +756 @@
     setFrameStyle (QFrame::NoFrame);
 
-#ifdef VBOX_GUI_USE_QGL
+#ifdef VBOX_GUI_USE_QGLFB
     QWidget *pViewport;
     switch (mode)
@@ -806 +806 @@
     switch (mode)
     {
-#if defined (VBOX_GUI_USE_QGL)
+#if defined (VBOX_GUI_USE_QGLFB)
         case VBoxDefs::QGLMode:
             mFrameBuf = new VBoxQGLFrameBuffer (this);
@@ -818 +818 @@
             mFrameBuf =
 #ifdef VBOX_WITH_VIDEOHWACCEL
-                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQImageFrameBuffer> (this, &mainWnd->session()) :
+                    /* these two additional template args is a workaround to this [VBox|UI] duplication
+                     * @todo: they are to be removed once VBox stuff is gone */
+                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQImageFrameBuffer, VBoxConsoleView, VBoxResizeEvent> (this, viewport(), &mainWnd->session()) :
 #endif
                     new VBoxQImageFrameBuffer (this);
@@ -835 +837 @@
             mFrameBuf =
 #if defined(VBOX_WITH_VIDEOHWACCEL) && defined(DEBUG_misha) /* not tested yet */
-                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxSDLFrameBuffer> (this, &mainWnd->session()) :
+                    /* these two additional template args is a workaround to this [VBox|UI] duplication
+                     * @todo: they are to be removed once VBox stuff is gone */
+                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxSDLFrameBuffer, VBoxConsoleView, VBoxResizeEvent> (this, viewport(), &mainWnd->session()) :
 #endif
                     new VBoxSDLFrameBuffer (this);
@@ -858 +862 @@
             mFrameBuf =
 #ifdef VBOX_WITH_VIDEOHWACCEL
-                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQuartz2DFrameBuffer> (this, &mainWnd->session()) :
+                    /* these two additional template args is a workaround to this [VBox|UI] duplication
+                     * @todo: they are to be removed once VBox stuff is gone */
+                    mAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQuartz2DFrameBuffer, VBoxConsoleView, VBoxResizeEvent> (this, viewport(), &mainWnd->session()) :
 #endif
                     new VBoxQuartz2DFrameBuffer (this);

trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp

@@ -1181 +1181 @@
 }
 
-VBoxVHWASurfaceBase::VBoxVHWASurfaceBase(class VBoxGLWidget *aWidget,
+VBoxVHWASurfaceBase::VBoxVHWASurfaceBase(class VBoxVHWAImage *pImage,
         const QSize & aSize,
         const QRect & aTargRect,
@@ -1203 +1203 @@
                 mComplexList(NULL),
                 mpPrimary(NULL),
-                mWidget(aWidget),
-                mHGHandle(VBOXVHWA_SURFHANDLE_INVALID)
+                mHGHandle(VBOXVHWA_SURFHANDLE_INVALID),
+                mpImage(pImage)
 #ifdef DEBUG
                 ,
@@ -1549 +1549 @@
 
 #ifdef VBOXVHWA_PROFILE_FPS
-    mWidget->reportNewFrame();
+    mpImage->reportNewFrame();
 #endif
 
@@ -1892 +1892 @@
 class VBoxVHWAGlProgramMngr * VBoxVHWASurfaceBase::getGlProgramMngr()
 {
-    return mWidget->vboxVHWAGetGlProgramMngr();
+    return mpImage->vboxVHWAGetGlProgramMngr();
 }
 
@@ -1917 +1917 @@
 };
 
-VBoxGLWidget::VBoxGLWidget (CConsole console, QWidget *aParent, VBoxVHWASettings *aSettings)
-    : QGLWidget (new VBoxGLContext(VBoxGLWidget::vboxGLFormat()), aParent),
-    mSurfHandleTable(128), /* 128 should be enough */
-    mpfnOp(NULL),
-    mOpContext(NULL),
-    mPixelFormat(0),
-    mUsesGuestVRAM(false),
+
+VBoxGLWgt::VBoxGLWgt(VBoxVHWAImage * pImage,
+            QWidget* parent, const QGLWidget* shareWidget)
+
+        : QGLWidget(new VBoxGLContext(shareWidget->format()), parent, shareWidget),
+          mpImage(pImage)
+{
+    /* work-around to disable done current needed to old ATI drivers on Linux */
+    VBoxGLContext *pc = (VBoxGLContext*)context();
+    pc->allowDoneCurrent (false);
+}
+
+
+VBoxVHWAImage::VBoxVHWAImage ()
+    : mSurfHandleTable(128), /* 128 should be enough */
     mRepaintNeeded(false),
 //    mbVGASurfCreated(false),
-    m_console(console),
     mConstructingList(NULL),
     mcRemaining2Contruct(0),
-    mSettings(aSettings)
+    mSettings(NULL)
 #ifdef VBOXVHWA_PROFILE_FPS
     ,
@@ -1941 +1948 @@
 }
 
-const QGLFormat & VBoxGLWidget::vboxGLFormat()
+int VBoxVHWAImage::init(VBoxVHWASettings *aSettings)
+{
+    mSettings = aSettings;
+    return VINF_SUCCESS;
+}
+
+const QGLFormat & VBoxVHWAImage::vboxGLFormat()
 {
     static QGLFormat vboxFormat = QGLFormat();
@@ -1958 +1971 @@
 }
 
-VBoxGLWidget::~VBoxGLWidget()
+
+VBoxVHWAImage::~VBoxVHWAImage()
 {
     delete mpMngr;
@@ -1964 +1978 @@
 
 #ifdef VBOXVHWA_OLD_COORD
-void VBoxGLWidget::doSetupMatrix(const QSize & aSize, bool bInverted)
+void VBoxVHWAImage::doSetupMatrix(const QSize & aSize, bool bInverted)
 {
     VBOXQGL_CHECKERR(
@@ -1991 +2005 @@
 #endif
 
-void VBoxGLWidget::adjustViewport(const QSize &display, const QRect &viewport)
+void VBoxVHWAImage::adjustViewport(const QSize &display, const QRect &viewport)
 {
     glViewport(-viewport.x(),
@@ -1999 +2013 @@
 }
 
-void VBoxGLWidget::setupMatricies(const QSize &display, bool bInverted)
+void VBoxVHWAImage::setupMatricies(const QSize &display, bool bInverted)
 {
     glMatrixMode(GL_PROJECTION);
@@ -2013 +2027 @@
 }
 
-VBoxVHWACommandElement * VBoxGLWidget::processCmdList(VBoxVHWACommandElement * pCmd)
-{
-    VBoxVHWACommandElement * pCur;
-    do
-    {
-        pCur = pCmd;
-        switch(pCmd->type())
-        {
-        case VBOXVHWA_PIPECMD_PAINT:
-            vboxDoUpdateRect(&pCmd->rect());
-            break;
-#ifdef VBOX_WITH_VIDEOHWACCEL
-        case VBOXVHWA_PIPECMD_VHWA:
-            vboxDoVHWACmd(pCmd->vhwaCmd());
-            break;
-        case VBOXVHWA_PIPECMD_OP:
-        {
-            const VBOXVHWACALLBACKINFO & info = pCmd->op();
-            (info.pThis->*(info.pfnCallback))(info.pContext);
-            break;
-        }
-        case VBOXVHWA_PIPECMD_FUNC:
-        {
-            const VBOXVHWAFUNCCALLBACKINFO & info = pCmd->func();
-            info.pfnCallback(info.pContext1, info.pContext2);
-            break;
-        }
-#endif
-        default:
-            Assert(0);
-        }
-        pCmd = pCmd->mpNext;
-    } while(pCmd);
-
-    return pCur;
-}
-
-void VBoxGLWidget::vboxDoProcessVHWACommands(void *pContext)
-{
-    VBoxVHWACommandElementProcessor * pPipe = (VBoxVHWACommandElementProcessor*)pContext;
-    VBoxVHWACommandElement * pFirst = pPipe->detachCmdList(NULL, NULL);
-    do
-    {
-        VBoxVHWACommandElement * pLast = processCmdList(pFirst);
-
-        pFirst = pPipe->detachCmdList(pFirst, pLast);
-    } while(pFirst);
-}
-
-int VBoxGLWidget::reset(VHWACommandList * pCmdList)
+//VBoxVHWACommandElement * VBoxVHWAImage::processCmdList(VBoxVHWACommandElement * pCmd)
+//{
+//    VBoxVHWACommandElement * pCur;
+//    do
+//    {
+//        pCur = pCmd;
+//        switch(pCmd->type())
+//        {
+//        case VBOXVHWA_PIPECMD_PAINT:
+//            vboxDoUpdateRect(&pCmd->rect());
+//            break;
+//#ifdef VBOX_WITH_VIDEOHWACCEL
+//        case VBOXVHWA_PIPECMD_VHWA:
+//            vboxDoVHWACmd(pCmd->vhwaCmd());
+//            break;
+//        case VBOXVHWA_PIPECMD_FUNC:
+//        {
+//            const VBOXVHWAFUNCCALLBACKINFO & info = pCmd->func();
+//            info.pfnCallback(info.pContext1, info.pContext2);
+//            break;
+//        }
+//#endif
+//        default:
+//            Assert(0);
+//        }
+//        pCmd = pCmd->mpNext;
+//    } while(pCmd);
+//
+//    return pCur;
+//}
+//
+//void VBoxVHWAImage::vboxDoProcessVHWACommands(void *pContext)
+//{
+//    VBoxVHWACommandElementProcessor * pPipe = (VBoxVHWACommandElementProcessor*)pContext;
+//    VBoxVHWACommandElement * pFirst = pPipe->detachCmdList(NULL, NULL);
+//    do
+//    {
+//        VBoxVHWACommandElement * pLast = processCmdList(pFirst);
+//
+//        pFirst = pPipe->detachCmdList(pFirst, pLast);
+//    } while(pFirst);
+//}
+
+int VBoxVHWAImage::reset(VHWACommandList * pCmdList)
 {
     VBOXVHWACMD * pCmd;
@@ -2116 +2124 @@
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
-void VBoxGLWidget::vboxDoVHWACmd(void *cmd)
-{
-    vboxDoVHWACmdExec(cmd);
-
-    CDisplay display = m_console.GetDisplay();
-    Assert (!display.isNull());
-
-    display.CompleteVHWACommand((BYTE*)cmd);
-}
-
-void VBoxGLWidget::vboxDoVHWACmdAndFree(void *cmd)
-{
-    vboxDoVHWACmdExec(cmd);
-
-    free(cmd);
-}
-
-void VBoxGLWidget::vboxDoVHWACmdExec(void *cmd)
-{
-    struct _VBOXVHWACMD * pCmd = (struct _VBOXVHWACMD *)cmd;
-    switch(pCmd->enmCmd)
-    {
-        case VBOXVHWACMD_TYPE_SURF_CANCREATE:
-        {
-            VBOXVHWACMD_SURF_CANCREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CANCREATE);
-            pCmd->rc = vhwaSurfaceCanCreate(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_SURF_CREATE:
-        {
-            VBOXVHWACMD_SURF_CREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE);
-            pCmd->rc = vhwaSurfaceCreate(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_SURF_DESTROY:
-        {
-            VBOXVHWACMD_SURF_DESTROY * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY);
-            pCmd->rc = vhwaSurfaceDestroy(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_SURF_LOCK:
-        {
-            VBOXVHWACMD_SURF_LOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_LOCK);
-            pCmd->rc = vhwaSurfaceLock(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_SURF_UNLOCK:
-        {
-            VBOXVHWACMD_SURF_UNLOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_UNLOCK);
-            pCmd->rc = vhwaSurfaceUnlock(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_SURF_BLT:
-        {
-            VBOXVHWACMD_SURF_BLT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT);
-            pCmd->rc = vhwaSurfaceBlt(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_SURF_FLIP:
-        {
-            VBOXVHWACMD_SURF_FLIP * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP);
-            pCmd->rc = vhwaSurfaceFlip(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE:
-        {
-            VBOXVHWACMD_SURF_OVERLAY_UPDATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE);
-            pCmd->rc = vhwaSurfaceOverlayUpdate(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION:
-        {
-            VBOXVHWACMD_SURF_OVERLAY_SETPOSITION * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_SETPOSITION);
-            pCmd->rc = vhwaSurfaceOverlaySetPosition(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_SURF_COLORKEY_SET:
-        {
-            VBOXVHWACMD_SURF_COLORKEY_SET * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORKEY_SET);
-            pCmd->rc = vhwaSurfaceColorkeySet(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_QUERY_INFO1:
-        {
-            VBOXVHWACMD_QUERYINFO1 * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1);
-            pCmd->rc = vhwaQueryInfo1(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_QUERY_INFO2:
-        {
-            VBOXVHWACMD_QUERYINFO2 * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO2);
-            pCmd->rc = vhwaQueryInfo2(pBody);
-        } break;
-        case VBOXVHWACMD_TYPE_ENABLE:
-        case VBOXVHWACMD_TYPE_DISABLE:
-            pCmd->rc = VINF_SUCCESS;
-            break;
-        case VBOXVHWACMD_TYPE_HH_CONSTRUCT:
-        {
-            VBOXVHWACMD_HH_CONSTRUCT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
-            pCmd->rc = vhwaConstruct(pBody);
-        } break;
-        default:
-            Assert(0);
-            pCmd->rc = VERR_NOT_IMPLEMENTED;
-            break;
-    }
-}
-
-int VBoxGLWidget::vhwaSurfaceCanCreate(struct _VBOXVHWACMD_SURF_CANCREATE *pCmd)
+//void VBoxVHWAImage::vboxDoVHWACmd(void *cmd)
+//{
+//    vboxDoVHWACmdExec(cmd);
+//
+//    CDisplay display = m_console.GetDisplay();
+//    Assert (!display.isNull());
+//
+//    display.CompleteVHWACommand((BYTE*)cmd);
+//}
+//
+//void VBoxVHWAImage::vboxDoVHWACmdAndFree(void *cmd)
+//{
+//    vboxDoVHWACmdExec(cmd);
+//
+//    free(cmd);
+//}
+//
+//void VBoxVHWAImage::vboxDoVHWACmdExec(void *cmd)
+//{
+//    struct _VBOXVHWACMD * pCmd = (struct _VBOXVHWACMD *)cmd;
+//    switch(pCmd->enmCmd)
+//    {
+//        case VBOXVHWACMD_TYPE_SURF_CANCREATE:
+//        {
+//            VBOXVHWACMD_SURF_CANCREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CANCREATE);
+//            pCmd->rc = vhwaSurfaceCanCreate(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_SURF_CREATE:
+//        {
+//            VBOXVHWACMD_SURF_CREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE);
+//            pCmd->rc = vhwaSurfaceCreate(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_SURF_DESTROY:
+//        {
+//            VBOXVHWACMD_SURF_DESTROY * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY);
+//            pCmd->rc = vhwaSurfaceDestroy(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_SURF_LOCK:
+//        {
+//            VBOXVHWACMD_SURF_LOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_LOCK);
+//            pCmd->rc = vhwaSurfaceLock(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_SURF_UNLOCK:
+//        {
+//            VBOXVHWACMD_SURF_UNLOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_UNLOCK);
+//            pCmd->rc = vhwaSurfaceUnlock(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_SURF_BLT:
+//        {
+//            VBOXVHWACMD_SURF_BLT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT);
+//            pCmd->rc = vhwaSurfaceBlt(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_SURF_FLIP:
+//        {
+//            VBOXVHWACMD_SURF_FLIP * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP);
+//            pCmd->rc = vhwaSurfaceFlip(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE:
+//        {
+//            VBOXVHWACMD_SURF_OVERLAY_UPDATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE);
+//            pCmd->rc = vhwaSurfaceOverlayUpdate(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION:
+//        {
+//            VBOXVHWACMD_SURF_OVERLAY_SETPOSITION * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_SETPOSITION);
+//            pCmd->rc = vhwaSurfaceOverlaySetPosition(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_SURF_COLORKEY_SET:
+//        {
+//            VBOXVHWACMD_SURF_COLORKEY_SET * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORKEY_SET);
+//            pCmd->rc = vhwaSurfaceColorkeySet(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_QUERY_INFO1:
+//        {
+//            VBOXVHWACMD_QUERYINFO1 * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1);
+//            pCmd->rc = vhwaQueryInfo1(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_QUERY_INFO2:
+//        {
+//            VBOXVHWACMD_QUERYINFO2 * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO2);
+//            pCmd->rc = vhwaQueryInfo2(pBody);
+//        } break;
+//        case VBOXVHWACMD_TYPE_ENABLE:
+//        case VBOXVHWACMD_TYPE_DISABLE:
+//            pCmd->rc = VINF_SUCCESS;
+//            break;
+//        case VBOXVHWACMD_TYPE_HH_CONSTRUCT:
+//        {
+//            VBOXVHWACMD_HH_CONSTRUCT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
+//            pCmd->rc = vhwaConstruct(pBody);
+//        } break;
+//        default:
+//            Assert(0);
+//            pCmd->rc = VERR_NOT_IMPLEMENTED;
+//            break;
+//    }
+//}
+
+int VBoxVHWAImage::vhwaSurfaceCanCreate(struct _VBOXVHWACMD_SURF_CANCREATE *pCmd)
 {
     VBOXQGLLOG_ENTER(("\n"));
 
-    const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(context());
+    const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(NULL);
 
     if(!(pCmd->SurfInfo.flags & VBOXVHWA_SD_CAPS))
@@ -2312 +2320 @@
 }
 
-int VBoxGLWidget::vhwaSurfaceCreate (struct _VBOXVHWACMD_SURF_CREATE *pCmd)
+int VBoxVHWAImage::vhwaSurfaceCreate (struct _VBOXVHWACMD_SURF_CREATE *pCmd)
 {
     VBOXQGLLOG_ENTER (("\n"));
@@ -2328 +2336 @@
 
     VBoxVHWASurfaceBase *surf = NULL;
+    const VBoxVHWASurfaceBase *existingSurf = NULL;
     bool bNoPBO = false;
     bool bPrimary = false;
@@ -2360 +2369 @@
         bNoPBO = true;
         bPrimary = true;
-        VBoxVHWASurfaceBase * pVga = vboxGetVGASurface();
+        VBoxVHWASurfaceBase * pVga = vgaSurface();
 
         Assert((pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_OFFSCREENPLAIN) == 0);
@@ -2378 +2387 @@
                                                 pCmd->SurfInfo.PixelFormat.m2.rgbGBitMask,
                                                 pCmd->SurfInfo.PixelFormat.m3.rgbBBitMask);
-                    Assert(pVga->colorFormat().equals(format));
-//                    if(pVga->colorFormat().equals(format))
+                    Assert(pVga->pixelFormat().equals(format));
+//                    if(pVga->pixelFormat().equals(format))
                     {
+                        existingSurf = pVga;
                         surf = pVga;
 
@@ -2458 +2468 @@
 
         uchar * addr = vboxVRAMAddressFromOffset(pCmd->SurfInfo.offSurface);
-        surf->init(mDisplay.getPrimary(), addr);
+        if (!existingSurf)
+            surf->init(mDisplay.getPrimary(), addr);
 
         if(pCmd->SurfInfo.surfCaps & VBOXVHWA_SCAPS_OVERLAY)
@@ -2482 +2493 @@
         else
         {
-            VBoxVHWASurfaceBase * pVga = vboxGetVGASurface();
+            VBoxVHWASurfaceBase * pVga = vgaSurface();
             Assert(pVga->handle() != VBOXVHWA_SURFHANDLE_INVALID);
             Assert(pVga != surf); NOREF(pVga);
@@ -2534 +2545 @@
 }
 
-int VBoxGLWidget::vhwaSurfaceDestroy(struct _VBOXVHWACMD_SURF_DESTROY *pCmd)
+int VBoxVHWAImage::vhwaSurfaceDestroy(struct _VBOXVHWACMD_SURF_DESTROY *pCmd)
 {
     VBoxVHWASurfaceBase *pSurf = handle2Surface(pCmd->u.in.hSurf);
@@ -2610 +2621 @@
                  (_pr)->bottom - (_pr)->top)
 
-int VBoxGLWidget::vhwaSurfaceLock(struct _VBOXVHWACMD_SURF_LOCK *pCmd)
+int VBoxVHWAImage::vhwaSurfaceLock(struct _VBOXVHWACMD_SURF_LOCK *pCmd)
 {
     VBoxVHWASurfaceBase *pSurf = handle2Surface(pCmd->u.in.hSurf);
@@ -2623 +2634 @@
 }
 
-int VBoxGLWidget::vhwaSurfaceUnlock(struct _VBOXVHWACMD_SURF_UNLOCK *pCmd)
+int VBoxVHWAImage::vhwaSurfaceUnlock(struct _VBOXVHWACMD_SURF_UNLOCK *pCmd)
 {
     VBoxVHWASurfaceBase *pSurf = handle2Surface(pCmd->u.in.hSurf);
@@ -2664 +2675 @@
 }
 
-int VBoxGLWidget::vhwaSurfaceBlt(struct _VBOXVHWACMD_SURF_BLT *pCmd)
+int VBoxVHWAImage::vhwaSurfaceBlt(struct _VBOXVHWACMD_SURF_BLT *pCmd)
 {
     Q_UNUSED(pCmd);
@@ -2670 +2681 @@
 }
 
-int VBoxGLWidget::vhwaSurfaceFlip(struct _VBOXVHWACMD_SURF_FLIP *pCmd)
+int VBoxVHWAImage::vhwaSurfaceFlip(struct _VBOXVHWACMD_SURF_FLIP *pCmd)
 {
     VBoxVHWASurfaceBase *pTargSurf = handle2Surface(pCmd->u.in.hTargSurf);
@@ -2695 +2706 @@
 }
 
-void VBoxGLWidget::vhwaDoSurfaceOverlayUpdate(VBoxVHWASurfaceBase *pDstSurf, VBoxVHWASurfaceBase *pSrcSurf, struct _VBOXVHWACMD_SURF_OVERLAY_UPDATE *pCmd)
+void VBoxVHWAImage::vhwaDoSurfaceOverlayUpdate(VBoxVHWASurfaceBase *pDstSurf, VBoxVHWASurfaceBase *pSrcSurf, struct _VBOXVHWACMD_SURF_OVERLAY_UPDATE *pCmd)
 {
     if(pCmd->u.in.flags & VBOXVHWA_OVER_KEYDEST)
@@ -2775 +2786 @@
 }
 
-int VBoxGLWidget::vhwaSurfaceOverlayUpdate(struct _VBOXVHWACMD_SURF_OVERLAY_UPDATE *pCmd)
+int VBoxVHWAImage::vhwaSurfaceOverlayUpdate(struct _VBOXVHWACMD_SURF_OVERLAY_UPDATE *pCmd)
 {
     VBoxVHWASurfaceBase *pSrcSurf = handle2Surface(pCmd->u.in.hSrcSurf);
@@ -2829 +2840 @@
 }
 
-int VBoxGLWidget::vhwaSurfaceOverlaySetPosition(struct _VBOXVHWACMD_SURF_OVERLAY_SETPOSITION *pCmd)
+int VBoxVHWAImage::vhwaSurfaceOverlaySetPosition(struct _VBOXVHWACMD_SURF_OVERLAY_SETPOSITION *pCmd)
 {
     VBoxVHWASurfaceBase *pDstSurf = handle2Surface(pCmd->u.in.hDstSurf);
@@ -2870 +2881 @@
 }
 
-int VBoxGLWidget::vhwaSurfaceColorkeySet(struct _VBOXVHWACMD_SURF_COLORKEY_SET *pCmd)
+int VBoxVHWAImage::vhwaSurfaceColorkeySet(struct _VBOXVHWACMD_SURF_COLORKEY_SET *pCmd)
 {
     VBoxVHWASurfaceBase *pSurf = handle2Surface(pCmd->u.in.hSurf);
@@ -2904 +2915 @@
 }
 
-int VBoxGLWidget::vhwaQueryInfo1(struct _VBOXVHWACMD_QUERYINFO1 *pCmd)
+int VBoxVHWAImage::vhwaQueryInfo1(struct _VBOXVHWACMD_QUERYINFO1 *pCmd)
 {
     VBOXQGLLOG_ENTER(("\n"));
     bool bEnabled = false;
-    const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(context());
+    const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(NULL);
     if(info.isVHWASupported())
     {
@@ -3007 +3018 @@
 }
 
-int VBoxGLWidget::vhwaQueryInfo2(struct _VBOXVHWACMD_QUERYINFO2 *pCmd)
+int VBoxVHWAImage::vhwaQueryInfo2(struct _VBOXVHWACMD_QUERYINFO2 *pCmd)
 {
     VBOXQGLLOG_ENTER(("\n"));
 
-    const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(context());
+    const VBoxVHWAInfo & info = vboxVHWAGetSupportInfo(NULL);
     uint32_t aFourcc[VBOXVHWA_NUMFOURCC];
     int num = mSettings->getIntersection(info, VBOXVHWA_NUMFOURCC, aFourcc);
@@ -3023 +3034 @@
 }
 
-static DECLCALLBACK(void) vboxQGLSaveExec(PSSMHANDLE pSSM, void *pvUser)
-{
-    VBoxGLWidget * pw = (VBoxGLWidget*)pvUser;
-    pw->vhwaSaveExec(pSSM);
-}
-
-static DECLCALLBACK(int) vboxQGLLoadExec(PSSMHANDLE pSSM, void *pvUser, uint32_t u32Version, uint32_t uPass)
-{
-    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
-    VBoxGLWidget * pw = (VBoxGLWidget*)pvUser;
-    return VBoxGLWidget::vhwaLoadExec(&pw->onResizeCmdList(), pSSM, u32Version);
-}
-
-int VBoxGLWidget::vhwaSaveSurface(struct SSMHANDLE * pSSM, VBoxVHWASurfaceBase *pSurf, uint32_t surfCaps)
+//static DECLCALLBACK(void) vboxQGLSaveExec(PSSMHANDLE pSSM, void *pvUser)
+//{
+//    VBoxVHWAImage * pw = (VBoxVHWAImage*)pvUser;
+//    pw->vhwaSaveExec(pSSM);
+//}
+//
+//static DECLCALLBACK(int) vboxQGLLoadExec(PSSMHANDLE pSSM, void *pvUser, uint32_t u32Version, uint32_t uPass)
+//{
+//    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
+//    VBoxVHWAImage * pw = (VBoxVHWAImage*)pvUser;
+//    return VBoxVHWAImage::vhwaLoadExec(&pw->onResizeCmdList(), pSSM, u32Version);
+//}
+
+int VBoxVHWAImage::vhwaSaveSurface(struct SSMHANDLE * pSSM, VBoxVHWASurfaceBase *pSurf, uint32_t surfCaps)
 {
     VBOXQGL_SAVE_SURFSTART(pSSM);
@@ -3091 +3102 @@
     }
 
-    const VBoxVHWAColorFormat & format = pSurf->colorFormat();
+    const VBoxVHWAColorFormat & format = pSurf->pixelFormat();
     flags = 0;
     if(format.fourcc())
@@ -3115 +3126 @@
 }
 
-int VBoxGLWidget::vhwaLoadSurface(VHWACommandList * pCmdList, struct SSMHANDLE * pSSM, uint32_t cBackBuffers, uint32_t u32Version)
+int VBoxVHWAImage::vhwaLoadSurface(VHWACommandList * pCmdList, struct SSMHANDLE * pSSM, uint32_t cBackBuffers, uint32_t u32Version)
 {
     Q_UNUSED(u32Version);
@@ -3185 +3196 @@
 
         pCmdList->push_back(pCmd);
-//        vboxExecOnResize(&VBoxGLWidget::vboxDoVHWACmdAndFree, pCmd); AssertRC(rc);
+//        vboxExecOnResize(&VBoxVHWAImage::vboxDoVHWACmdAndFree, pCmd); AssertRC(rc);
 //        if(RT_SUCCESS(rc))
 //        {
@@ -3198 +3209 @@
 }
 
-int VBoxGLWidget::vhwaSaveOverlayData(struct SSMHANDLE * pSSM, VBoxVHWASurfaceBase *pSurf, bool bVisible)
+int VBoxVHWAImage::vhwaSaveOverlayData(struct SSMHANDLE * pSSM, VBoxVHWASurfaceBase *pSurf, bool bVisible)
 {
     VBOXQGL_SAVE_OVERLAYSTART(pSSM);
@@ -3273 +3284 @@
 }
 
-int VBoxGLWidget::vhwaLoadOverlayData(VHWACommandList * pCmdList, struct SSMHANDLE * pSSM, uint32_t u32Version)
+int VBoxVHWAImage::vhwaLoadOverlayData(VHWACommandList * pCmdList, struct SSMHANDLE * pSSM, uint32_t u32Version)
 {
     Q_UNUSED(u32Version);
@@ -3328 +3339 @@
 }
 
-void VBoxGLWidget::vhwaSaveExecVoid(struct SSMHANDLE * pSSM)
+void VBoxVHWAImage::vhwaSaveExecVoid(struct SSMHANDLE * pSSM)
 {
     VBOXQGL_SAVE_START(pSSM);
@@ -3335 +3346 @@
 }
 
-void VBoxGLWidget::vhwaSaveExec(struct SSMHANDLE * pSSM)
+void VBoxVHWAImage::vhwaSaveExec(struct SSMHANDLE * pSSM)
 {
     VBOXQGL_SAVE_START(pSSM);
@@ -3429 +3440 @@
 }
 
-int VBoxGLWidget::vhwaLoadVHWAEnable(VHWACommandList * pCmdList)
+int VBoxVHWAImage::vhwaLoadVHWAEnable(VHWACommandList * pCmdList)
 {
     char *buf = (char*)malloc(sizeof(VBOXVHWACMD));
@@ -3446 +3457 @@
 }
 
-int VBoxGLWidget::vhwaLoadExec(VHWACommandList * pCmdList, struct SSMHANDLE * pSSM, uint32_t u32Version)
+int VBoxVHWAImage::vhwaLoadExec(VHWACommandList * pCmdList, struct SSMHANDLE * pSSM, uint32_t u32Version)
 {
     VBOXQGL_LOAD_START(pSSM);
@@ -3517 +3528 @@
 }
 
-int VBoxGLWidget::vhwaConstruct(struct _VBOXVHWACMD_HH_CONSTRUCT *pCmd)
-{
-    PVM pVM = (PVM)pCmd->pVM;
-    uint32_t intsId = 0; /* @todo: set the proper id */
-
-    char nameFuf[sizeof(VBOXQGL_STATE_NAMEBASE) + 8];
-
-    char * pszName = nameFuf;
-    sprintf(pszName, "%s%d", VBOXQGL_STATE_NAMEBASE, intsId);
-    int rc = SSMR3RegisterExternal(
-            pVM,                    /* The VM handle*/
-            pszName,                /* Data unit name. */
-            intsId,                 /* The instance identifier of the data unit.
-                                     * This must together with the name be unique. */
-            VBOXQGL_STATE_VERSION,   /* Data layout version number. */
-            128,             /* The approximate amount of data in the unit.
-                              * Only for progress indicators. */
-            NULL, NULL, NULL, /* pfnLiveXxx */
-            NULL,            /* Prepare save callback, optional. */
-            vboxQGLSaveExec, /* Execute save callback, optional. */
-            NULL,            /* Done save callback, optional. */
-            NULL,            /* Prepare load callback, optional. */
-            vboxQGLLoadExec, /* Execute load callback, optional. */
-            NULL,            /* Done load callback, optional. */
-            this             /* User argument. */
-            );
-    AssertRC(rc);
-    return rc;
-}
-
-uchar * VBoxGLWidget::vboxVRAMAddressFromOffset(uint64_t offset)
-{
-    return ((offset != VBOXVHWA_OFFSET64_VOID) && vboxUsesGuestVRAM()) ? vboxAddress() + offset : NULL;
-}
-
-uint64_t VBoxGLWidget::vboxVRAMOffsetFromAddress(uchar* addr)
-{
-    return uint64_t(addr - vboxAddress());
-}
-
-uint64_t VBoxGLWidget::vboxVRAMOffset(VBoxVHWASurfaceBase * pSurf)
+int VBoxVHWAImage::vhwaConstruct(struct _VBOXVHWACMD_HH_CONSTRUCT *pCmd)
+{
+//    PVM pVM = (PVM)pCmd->pVM;
+//    uint32_t intsId = 0; /* @todo: set the proper id */
+//
+//    char nameFuf[sizeof(VBOXQGL_STATE_NAMEBASE) + 8];
+//
+//    char * pszName = nameFuf;
+//    sprintf(pszName, "%s%d", VBOXQGL_STATE_NAMEBASE, intsId);
+//    int rc = SSMR3RegisterExternal(
+//            pVM,                    /* The VM handle*/
+//            pszName,                /* Data unit name. */
+//            intsId,                 /* The instance identifier of the data unit.
+//                                     * This must together with the name be unique. */
+//            VBOXQGL_STATE_VERSION,   /* Data layout version number. */
+//            128,             /* The approximate amount of data in the unit.
+//                              * Only for progress indicators. */
+//            NULL, NULL, NULL, /* pfnLiveXxx */
+//            NULL,            /* Prepare save callback, optional. */
+//            vboxQGLSaveExec, /* Execute save callback, optional. */
+//            NULL,            /* Done save callback, optional. */
+//            NULL,            /* Prepare load callback, optional. */
+//            vboxQGLLoadExec, /* Execute load callback, optional. */
+//            NULL,            /* Done load callback, optional. */
+//            this             /* User argument. */
+//            );
+//    AssertRC(rc);
+    mpvVRAM = pCmd->pvVRAM;
+    mcbVRAM = pCmd->cbVRAM;
+    return VINF_SUCCESS;
+}
+
+uchar * VBoxVHWAImage::vboxVRAMAddressFromOffset(uint64_t offset)
+{
+    /* @todo: check vramSize() */
+    return (offset != VBOXVHWA_OFFSET64_VOID) ? ((uint8_t*)vramBase()) + offset : NULL;
+}
+
+uint64_t VBoxVHWAImage::vboxVRAMOffsetFromAddress(uchar* addr)
+{
+    return uint64_t(addr - ((uchar*)vramBase()));
+}
+
+uint64_t VBoxVHWAImage::vboxVRAMOffset(VBoxVHWASurfaceBase * pSurf)
 {
     return pSurf->addressAlocated() ? VBOXVHWA_OFFSET64_VOID : vboxVRAMOffsetFromAddress(pSurf->address());
@@ -3563 +3577 @@
 
 #endif
-
-void VBoxGLWidget::initializeGL()
-{
-    vboxVHWAGetSupportInfo(context());
-    VBoxVHWASurfaceBase::globalInit();
-}
 
 #ifdef VBOXQGL_DBG_SURF
@@ -3575 +3583 @@
 VBoxVHWASurfaceBase * g_apSurf[] = {NULL, NULL, NULL};
 
-void VBoxGLWidget::vboxDoTestSurfaces(void* context)
+void VBoxVHWAImage::vboxDoTestSurfaces(void* context)
 {
     if(g_iCur >= RT_ELEMENTS(g_apSurf))
@@ -3587 +3595 @@
 #endif
 
-void VBoxGLWidget::vboxDoUpdateViewport(const QRect & aRect)
+void VBoxVHWAImage::vboxDoUpdateViewport(const QRect & aRect)
 {
     adjustViewport(mDisplay.getPrimary()->size(), aRect);
@@ -3631 +3639 @@
 }
 
-bool VBoxGLWidget::hasSurfaces() const
+bool VBoxVHWAImage::hasSurfaces() const
 {
     if(mDisplay.overlays().size() != 0)
@@ -3640 +3648 @@
 }
 
-bool VBoxGLWidget::hasVisibleOverlays()
+bool VBoxVHWAImage::hasVisibleOverlays()
 {
     const OverlayList & overlays = mDisplay.overlays();
@@ -3653 +3661 @@
 }
 
-QRect VBoxGLWidget::overlaysRectUnion()
+QRect VBoxVHWAImage::overlaysRectUnion()
 {
     const OverlayList & overlays = mDisplay.overlays();
@@ -3669 +3677 @@
 }
 
-QRect VBoxGLWidget::overlaysRectIntersection()
+QRect VBoxVHWAImage::overlaysRectIntersection()
 {
     const OverlayList & overlays = mDisplay.overlays();
@@ -3695 +3703 @@
 }
 
-void VBoxGLWidget::vboxDoUpdateRect(const QRect * pRect)
+void VBoxVHWAImage::vboxDoUpdateRect(const QRect * pRect)
 {
     mDisplay.getPrimary()->updatedMem(pRect);
 }
 
-void VBoxGLWidget::vboxDoResize(void *resize)
-{
-    VBOXQGLLOG(("format().blueBufferSize()(%d)\n", format().blueBufferSize()));
-    VBOXQGLLOG(("format().greenBufferSize()(%d)\n", format().greenBufferSize()));
-    VBOXQGLLOG(("format().redBufferSize()(%d)\n", format().redBufferSize()));
-#ifdef DEBUG_misha
-    Assert(format().blueBufferSize() == 8);
-    Assert(format().greenBufferSize() == 8);
-    Assert(format().redBufferSize() == 8);
-#endif
-
-    Assert(format().directRendering());
-    Assert(format().doubleBuffer());
-    Assert(format().hasOpenGL());
-    VBOXQGLLOG(("hasOpenGLOverlays(%d), hasOverlay(%d)\n", format().hasOpenGLOverlays(), format().hasOverlay()));
-    Assert(format().plane() == 0);
-    Assert(format().rgba());
-    Assert(!format().sampleBuffers());
-    Assert(!format().stereo());
-    VBOXQGLLOG(("swapInterval(%d)\n", format().swapInterval()));
+void VBoxVHWAImage::resize(const VBoxFBSizeInfo & size)
+{
+//    VBOXQGLLOG(("format().blueBufferSize()(%d)\n", format().blueBufferSize()));
+//    VBOXQGLLOG(("format().greenBufferSize()(%d)\n", format().greenBufferSize()));
+//    VBOXQGLLOG(("format().redBufferSize()(%d)\n", format().redBufferSize()));
+//#ifdef DEBUG_misha
+//    Assert(format().blueBufferSize() == 8);
+//    Assert(format().greenBufferSize() == 8);
+//    Assert(format().redBufferSize() == 8);
+//#endif
+//
+//    Assert(format().directRendering());
+//    Assert(format().doubleBuffer());
+//    Assert(format().hasOpenGL());
+//    VBOXQGLLOG(("hasOpenGLOverlays(%d), hasOverlay(%d)\n", format().hasOpenGLOverlays(), format().hasOverlay()));
+//    Assert(format().plane() == 0);
+//    Assert(format().rgba());
+//    Assert(!format().sampleBuffers());
+//    Assert(!format().stereo());
+//    VBOXQGLLOG(("swapInterval(%d)\n", format().swapInterval()));
 
 
@@ -3726 +3734 @@
         );
 
-    VBoxResizeEvent *re = (VBoxResizeEvent*)resize;
     bool remind = false;
     bool fallback = false;
 
     VBOXQGLLOG(("resizing: fmt=%d, vram=%p, bpp=%d, bpl=%d, width=%d, height=%d\n",
-                      re->pixelFormat(), re->VRAM(),
-                      re->bitsPerPixel(), re->bytesPerLine(),
-                      re->width(), re->height()));
+                      size.pixelFormat(), size.VRAM(),
+                      size.bitsPerPixel(), size.bytesPerLine(),
+                      size.width(), size.height()));
 
     /* clean the old values first */
@@ -3740 +3747 @@
     uint32_t bitsPerPixel;
     uint32_t b = 0xff, g = 0xff00, r = 0xff0000;
+    ulong pixelFormat;
+    bool bUsesGuestVram;
 
     /* check if we support the pixel format and can use the guest VRAM directly */
-    if (re->pixelFormat() == FramebufferPixelFormat_FOURCC_RGB)
-    {
-
-        bitsPerPixel = re->bitsPerPixel();
-        bytesPerLine = re->bytesPerLine();
+    if (size.pixelFormat() == FramebufferPixelFormat_FOURCC_RGB)
+    {
+
+        bitsPerPixel = size.bitsPerPixel();
+        bytesPerLine = size.bytesPerLine();
         ulong bitsPerLine = bytesPerLine * 8;
 
@@ -3785 +3794 @@
         {
             /* QImage only supports 32-bit aligned scan lines... */
-            Assert ((re->bytesPerLine() & 3) == 0);
-            fallback = ((re->bytesPerLine() & 3) != 0);
+            Assert ((size.bytesPerLine() & 3) == 0);
+            fallback = ((size.bytesPerLine() & 3) != 0);
         }
         if (!fallback)
         {
             /* ...and the scan lines ought to be a whole number of pixels. */
-            Assert ((bitsPerLine & (re->bitsPerPixel() - 1)) == 0);
-            fallback = ((bitsPerLine & (re->bitsPerPixel() - 1)) != 0);
+            Assert ((bitsPerLine & (size.bitsPerPixel() - 1)) == 0);
+            fallback = ((bitsPerLine & (size.bitsPerPixel() - 1)) != 0);
         }
         if (!fallback)
         {
-            // ulong virtWdt = bitsPerLine / re->bitsPerPixel();
-            mPixelFormat = FramebufferPixelFormat_FOURCC_RGB;
-            mUsesGuestVRAM = true;
+            // ulong virtWdt = bitsPerLine / size.bitsPerPixel();
+            pixelFormat = FramebufferPixelFormat_FOURCC_RGB;
+            bUsesGuestVram = true;
         }
     }
@@ -3814 +3823 @@
         g = 0xff00;
         r = 0xff0000;
-        bytesPerLine = re->width()*bitsPerPixel/8;
-        mPixelFormat = FramebufferPixelFormat_FOURCC_RGB;
-        mUsesGuestVRAM = false;
+        bytesPerLine = size.width()*bitsPerPixel/8;
+        pixelFormat = FramebufferPixelFormat_FOURCC_RGB;
+        bUsesGuestVram = false;
     }
 
     ulong bytesPerPixel = bitsPerPixel/8;
     ulong displayWidth = bytesPerLine/bytesPerPixel;
-    ulong displayHeight = re->height();
+    ulong displayHeight = size.height();
 
 #ifdef VBOXQGL_DBG_SURF
@@ -3855 +3864 @@
 #endif
             0);
-    pDisplay->init(NULL, mUsesGuestVRAM ? re->VRAM() : NULL);
+    pDisplay->init(NULL, bUsesGuestVram ? size.VRAM() : NULL);
     mDisplay.setVGA(pDisplay);
 //    VBOXQGLLOG(("\n\n*******\n\n     viewport size is: (%d):(%d)\n\n*******\n\n", size().width(), size().height()));
@@ -3928 +3937 @@
 #endif
 
-    if(!mOnResizeCmdList.empty())
-    {
-        for (VHWACommandList::const_iterator it = mOnResizeCmdList.begin();
-             it != mOnResizeCmdList.end(); ++ it)
-        {
-            VBOXVHWACMD * pCmd = (*it);
-            vboxDoVHWACmdExec(pCmd);
-            free(pCmd);
-        }
-        mOnResizeCmdList.clear();
-    }
+//    if(!mOnResizeCmdList.empty())
+//    {
+//        for (VHWACommandList::const_iterator it = mOnResizeCmdList.begin();
+//             it != mOnResizeCmdList.end(); ++ it)
+//        {
+//            VBOXVHWACMD * pCmd = (*it);
+//            vboxDoVHWACmdExec(pCmd);
+//            free(pCmd);
+//        }
+//        mOnResizeCmdList.clear();
+//    }
 
     if (remind)
@@ -3953 +3962 @@
             }
         };
-        (new RemindEvent (re->bitsPerPixel()))->post();
+        (new RemindEvent (size.bitsPerPixel()))->post();
     }
 }
@@ -4120 +4129 @@
 }
 
-VBoxQGLOverlay::VBoxQGLOverlay (VBoxConsoleView *aView, VBoxFrameBuffer * aContainer, CSession * aSession)
-    : mpOverlayWidget (NULL),
-      mView (aView),
-      mContainer (aContainer),
+VBoxQGLOverlay::VBoxQGLOverlay (QWidget *pViewport,QObject *pPostEventObject,  CSession * aSession)
+    : mpOverlayWgt (NULL),
+      mpViewport (pViewport),
       mGlOn (false),
       mOverlayWidgetVisible (false),
@@ -4131 +4139 @@
       mNeedOverlayRepaint (false),
       mNeedSetVisible (false),
-      mCmdPipe (aView),
-      mSettings (*aSession)
+      mCmdPipe (pPostEventObject),
+      mSettings (*aSession),
+      mpSession(aSession)
 {
     /* postpone the gl widget initialization to avoid conflict with 3D on Mac */
 }
 
+class VBoxGLShareWgt : public QGLWidget
+{
+public:
+    VBoxGLShareWgt() :
+        QGLWidget(VBoxVHWAImage::vboxGLFormat())
+    {}
+
+protected:
+    void initializeGL()
+    {
+        vboxVHWAGetSupportInfo(context());
+        VBoxVHWASurfaceBase::globalInit();
+    }
+};
 void VBoxQGLOverlay::initGl()
 {
-    if(mpOverlayWidget)
+    if(mpOverlayWgt)
+    {
+        Assert(mpShareWgt);
         return;
-
-    mpOverlayWidget = new VBoxGLWidget (mView->console(), mView->viewport(), &mSettings);
-
-    VBoxGLContext *pc = (VBoxGLContext*)mpOverlayWidget->context();
-    pc->allowDoneCurrent (false);
+    }
+
+    if (!mpShareWgt)
+    {
+        mpShareWgt = new VBoxGLShareWgt();
+        /* force initializeGL */
+        mpShareWgt->updateGL();
+    }
+
+    mOverlayImage.init(&mSettings);
+    mpOverlayWgt = new VBoxGLWgt(&mOverlayImage, mpViewport, mpShareWgt);
 
     mOverlayWidgetVisible = true; /* to ensure it is set hidden with vboxShowOverlay */
     vboxShowOverlay (false);
 
-    mpOverlayWidget->setMouseTracking (true);
+    mpOverlayWgt->setMouseTracking (true);
 }
 
@@ -4159 +4190 @@
     if(pHead)
     {
-        CDisplay display = mView->console().GetDisplay();
+        CDisplay display = mpSession->GetConsole().GetDisplay();
         Assert (!display.isNull());
 
@@ -4174 +4205 @@
                     display.CompleteVHWACommand((BYTE*)pCmd);
                 }
-                break;
-            case VBOXVHWA_PIPECMD_OP:
-                /* should not happen, don't handle this for now */
-                Assert(0);
                 break;
             case VBOXVHWA_PIPECMD_FUNC:
@@ -4210 +4237 @@
 int VBoxQGLOverlay::resetGl()
 {
-    if(mpOverlayWidget)
-    {
-        VHWACommandList list;
-        int rc = mpOverlayWidget->reset(&list);
-        if(RT_SUCCESS(rc))
-        {
-            for (VHWACommandList::const_iterator sIt = list.begin();
+    VHWACommandList list;
+    int rc = mOverlayImage.reset(&list);
+    AssertRC(rc);
+    if (RT_SUCCESS(rc))
+    {
+        for (VHWACommandList::const_iterator sIt = list.begin();
                     sIt != list.end(); ++ sIt)
-            {
-                VBOXVHWACMD *pCmd = (*sIt);
-                VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandFreeCmd, pCmd);
-                mCmdPipe.postCmd(VBOXVHWA_PIPECMD_VHWA, pCmd, 0);
-            }
+        {
+            VBOXVHWACMD *pCmd = (*sIt);
+            VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandFreeCmd, pCmd);
+            mCmdPipe.postCmd(VBOXVHWA_PIPECMD_VHWA, pCmd, 0);
         }
     }
@@ -4298 +4323 @@
 }
 
-void VBoxQGLOverlay::onResizeEvent (const VBoxResizeEvent *re)
-{
-    Q_UNUSED(re);
-}
-
-void VBoxQGLOverlay::onResizeEventPostprocess (const VBoxResizeEvent *re)
-{
-    Q_UNUSED(re);
+void VBoxQGLOverlay::onResizeEventPostprocess (const VBoxFBSizeInfo &re, const QPoint & topLeft)
+{
+    mSizeInfo = re;
+    mContentsTopLeft = topLeft;
 
     if(mGlOn)
@@ -4345 +4366 @@
     }
 
-    mView->viewport()->repaint (rect.x() - mView->contentsX(),
-            rect.y() - mView->contentsY(),
+    mpViewport->repaint (rect.x() - mContentsTopLeft.x(),
+            rect.y() - mContentsTopLeft.y(),
             rect.width(), rect.height());
 
@@ -4356 +4377 @@
     vboxDoVHWACmdExec(cmd);
 
-    CDisplay display = mView->console().GetDisplay();
+    CDisplay display = mpSession->GetConsole().GetDisplay();
     Assert (!display.isNull());
 
@@ -4364 +4385 @@
 bool VBoxQGLOverlay::vboxSynchGl()
 {
-    if(mpOverlayWidget->vboxIsInitialized()
-            && mContainer->pixelFormat() == mpOverlayWidget->vboxPixelFormat()
-            && mContainer->address() == mpOverlayWidget->vboxAddress()
-            && mContainer->bitsPerPixel() == mpOverlayWidget->vboxBitsPerPixel()
-            && mContainer->bytesPerLine() == mpOverlayWidget->vboxBytesPerLine()
-            && (int)mContainer->width() == mpOverlayWidget->vboxFbWidth()
-            && (int)mContainer->height() == mpOverlayWidget->vboxFbHeight())
+    VBoxVHWASurfaceBase * pVGA = mOverlayImage.vgaSurface();
+    if(pVGA
+            && mSizeInfo.pixelFormat() == pVGA->pixelFormat().toVBoxPixelFormat()
+            && mSizeInfo.VRAM() == pVGA->address()
+            && mSizeInfo.bitsPerPixel() == pVGA->bitsPerPixel()
+            && mSizeInfo.bytesPerLine() == pVGA->bytesPerLine()
+            && mSizeInfo.width() == pVGA->width()
+            && mSizeInfo.height() == pVGA->height()
+            )
     {
         return false;
@@ -4376 +4399 @@
     /* create and issue a resize event to the gl widget to ensure we have all gl data initialized
      * and synchronized with the framebuffer */
-    VBoxResizeEvent re(mContainer->pixelFormat(),
-            mContainer->address(),
-            mContainer->bitsPerPixel(),
-            mContainer->bytesPerLine(),
-            mContainer->width(),
-            mContainer->height());
-
-    mpOverlayWidget->vboxDoResize(&re);
+    mOverlayImage.resize(mSizeInfo);
     return true;
 }
@@ -4397 +4413 @@
     {
         /* need to ensure we have gl functions initialized */
-        mpOverlayWidget->makeCurrent();
-        vboxVHWAGetSupportInfo(mpOverlayWidget->context());
+        mpOverlayWgt->makeCurrent();
+        vboxVHWAGetSupportInfo(mpOverlayWgt->context());
 
         VBOXQGLLOGREL(("Switching Gl mode on\n"));
-        Assert(!mpOverlayWidget->isVisible());
+        Assert(!mpOverlayWgt->isVisible());
         /* just to ensure */
         vboxShowOverlay(false);
@@ -4424 +4440 @@
     }
 
-    int cX = mView->contentsX();
-    int cY = mView->contentsY();
-    QRect fbVp(cX, cY, mView->viewport()->width(), mView->viewport()->height());
+    int cX = mContentsTopLeft.x();
+    int cY = mContentsTopLeft.y();
+    QRect fbVp(cX, cY, mpViewport->width(), mpViewport->height());
     QRect overVp = fbVp.intersected(mOverlayViewport);
 
@@ -4435 +4451 @@
     else
     {
-        if(overVp != mpOverlayWidget->vboxViewport())
+        if(overVp != mOverlayImage.vboxViewport())
         {
             makeCurrent();
-            mpOverlayWidget->vboxDoUpdateViewport(overVp);
+            mOverlayImage.vboxDoUpdateViewport(overVp);
             mNeedOverlayRepaint = true;
         }
@@ -4449 +4465 @@
 
         /* workaround for linux ATI issue: need to update gl viewport after widget becomes visible */
-        mpOverlayWidget->vboxDoUpdateViewport(overVp);
+        mOverlayImage.vboxDoUpdateViewport(overVp);
     }
 }
@@ -4457 +4473 @@
     if(mOverlayWidgetVisible != show)
     {
-        mpOverlayWidget->setVisible(show);
+        mpOverlayWgt->setVisible(show);
         mOverlayWidgetVisible = show;
         mGlCurrent = false;
         if(!show)
         {
-            mMainDirtyRect.add(mpOverlayWidget->vboxViewport());
+            mMainDirtyRect.add(mOverlayImage.vboxViewport());
         }
     }
@@ -4469 +4485 @@
 void VBoxQGLOverlay::vboxCheckUpdateOverlay(const QRect & rect)
 {
-    QRect overRect(mpOverlayWidget->pos(), mpOverlayWidget->size());
+    QRect overRect(mpOverlayWgt->pos(), mpOverlayWgt->size());
     if(overRect.x() != rect.x() || overRect.y() != rect.y())
     {
 #if defined(RT_OS_WINDOWS)
-        mpOverlayWidget->setVisible(false);
+        mpOverlayWgt->setVisible(false);
         mNeedSetVisible = true;
 #endif
         VBOXQGLLOG_QRECT("moving wgt to " , &rect, "\n");
-        mpOverlayWidget->move(rect.x(), rect.y());
+        mpOverlayWgt->move(rect.x(), rect.y());
         mGlCurrent = false;
     }
@@ -4484 +4500 @@
     {
 #if defined(RT_OS_WINDOWS)
-        mpOverlayWidget->setVisible(false);
+        mpOverlayWgt->setVisible(false);
         mNeedSetVisible = true;
 #endif
         VBOXQGLLOG(("resizing wgt to w(%d) ,h(%d)\n" , rect.width(), rect.height()));
-        mpOverlayWidget->resize(rect.width(), rect.height());
+        mpOverlayWgt->resize(rect.width(), rect.height());
         mGlCurrent = false;
     }
@@ -4498 +4514 @@
     if(mGlOn)
     {
-        mpOverlayWidget->vboxDoUpdateRect(&aRect);
+        mOverlayImage.vboxDoUpdateRect(&aRect);
         mNeedOverlayRepaint = true;
     }
@@ -4505 +4521 @@
 int VBoxQGLOverlay::vhwaSurfaceUnlock(struct _VBOXVHWACMD_SURF_UNLOCK *pCmd)
 {
-    int rc = mpOverlayWidget->vhwaSurfaceUnlock(pCmd);
-    VBoxVHWASurfaceBase * pVGA = mpOverlayWidget->vboxGetVGASurface();
+    int rc = mOverlayImage.vhwaSurfaceUnlock(pCmd);
+    VBoxVHWASurfaceBase * pVGA = mOverlayImage.vgaSurface();
     const VBoxVHWADirtyRect & rect = pVGA->getDirtyRect();
     mNeedOverlayRepaint = true;
@@ -4525 +4541 @@
             VBOXVHWACMD_SURF_CANCREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CANCREATE);
             makeCurrent();
-            pCmd->rc = mpOverlayWidget->vhwaSurfaceCanCreate(pBody);
+            pCmd->rc = mOverlayImage.vhwaSurfaceCanCreate(pBody);
         } break;
         case VBOXVHWACMD_TYPE_SURF_CREATE:
@@ -4532 +4548 @@
             makeCurrent();
             vboxSetGlOn(true);
-            pCmd->rc = mpOverlayWidget->vhwaSurfaceCreate(pBody);
-            if(!mpOverlayWidget->hasSurfaces())
+            pCmd->rc = mOverlayImage.vhwaSurfaceCreate(pBody);
+            if(!mOverlayImage.hasSurfaces())
             {
                 vboxSetGlOn(false);
@@ -4539 +4555 @@
             else
             {
-                mOverlayVisible = mpOverlayWidget->hasVisibleOverlays();
+                mOverlayVisible = mOverlayImage.hasVisibleOverlays();
                 if(mOverlayVisible)
                 {
-                    mOverlayViewport = mpOverlayWidget->overlaysRectUnion();
+                    mOverlayViewport = mOverlayImage.overlaysRectUnion();
                 }
                 vboxDoCheckUpdateViewport();
@@ -4552 +4568 @@
             VBOXVHWACMD_SURF_DESTROY * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY);
             makeCurrent();
-            pCmd->rc = mpOverlayWidget->vhwaSurfaceDestroy(pBody);
-            if(!mpOverlayWidget->hasSurfaces())
+            pCmd->rc = mOverlayImage.vhwaSurfaceDestroy(pBody);
+            if(!mOverlayImage.hasSurfaces())
             {
                 vboxSetGlOn(false);
@@ -4559 +4575 @@
             else
             {
-                mOverlayVisible = mpOverlayWidget->hasVisibleOverlays();
+                mOverlayVisible = mOverlayImage.hasVisibleOverlays();
                 if(mOverlayVisible)
                 {
-                    mOverlayViewport = mpOverlayWidget->overlaysRectUnion();
+                    mOverlayViewport = mOverlayImage.overlaysRectUnion();
                 }
                 vboxDoCheckUpdateViewport();
@@ -4572 +4588 @@
             VBOXVHWACMD_SURF_LOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_LOCK);
             makeCurrent();
-            pCmd->rc = mpOverlayWidget->vhwaSurfaceLock(pBody);
+            pCmd->rc = mOverlayImage.vhwaSurfaceLock(pBody);
         } break;
         case VBOXVHWACMD_TYPE_SURF_UNLOCK:
@@ -4585 +4601 @@
             VBOXVHWACMD_SURF_BLT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT);
             makeCurrent();
-            pCmd->rc = mpOverlayWidget->vhwaSurfaceBlt(pBody);
+            pCmd->rc = mOverlayImage.vhwaSurfaceBlt(pBody);
             mNeedOverlayRepaint = true;
         } break;
@@ -4592 +4608 @@
             VBOXVHWACMD_SURF_FLIP * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP);
             makeCurrent();
-            pCmd->rc = mpOverlayWidget->vhwaSurfaceFlip(pBody);
+            pCmd->rc = mOverlayImage.vhwaSurfaceFlip(pBody);
             mNeedOverlayRepaint = true;
         } break;
@@ -4599 +4615 @@
             VBOXVHWACMD_SURF_OVERLAY_UPDATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE);
             makeCurrent();
-            pCmd->rc = mpOverlayWidget->vhwaSurfaceOverlayUpdate(pBody);
-            mOverlayVisible = mpOverlayWidget->hasVisibleOverlays();
+            pCmd->rc = mOverlayImage.vhwaSurfaceOverlayUpdate(pBody);
+            mOverlayVisible = mOverlayImage.hasVisibleOverlays();
             if(mOverlayVisible)
             {
-                mOverlayViewport = mpOverlayWidget->overlaysRectUnion();
+                mOverlayViewport = mOverlayImage.overlaysRectUnion();
             }
             vboxDoCheckUpdateViewport();
@@ -4612 +4628 @@
             VBOXVHWACMD_SURF_OVERLAY_SETPOSITION * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_SETPOSITION);
             makeCurrent();
-            pCmd->rc = mpOverlayWidget->vhwaSurfaceOverlaySetPosition(pBody);
-            mOverlayVisible = mpOverlayWidget->hasVisibleOverlays();
+            pCmd->rc = mOverlayImage.vhwaSurfaceOverlaySetPosition(pBody);
+            mOverlayVisible = mOverlayImage.hasVisibleOverlays();
             if(mOverlayVisible)
             {
-                mOverlayViewport = mpOverlayWidget->overlaysRectUnion();
+                mOverlayViewport = mOverlayImage.overlaysRectUnion();
             }
             vboxDoCheckUpdateViewport();
@@ -4625 +4641 @@
             VBOXVHWACMD_SURF_COLORKEY_SET * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORKEY_SET);
             makeCurrent();
-            pCmd->rc = mpOverlayWidget->vhwaSurfaceColorkeySet(pBody);
+            pCmd->rc = mOverlayImage.vhwaSurfaceColorkeySet(pBody);
             /* this is here to ensure we have color key changes picked up */
             vboxDoCheckUpdateViewport();
@@ -4635 +4651 @@
             initGl();
             makeCurrent();
-            pCmd->rc = mpOverlayWidget->vhwaQueryInfo1(pBody);
+            pCmd->rc = mOverlayImage.vhwaQueryInfo1(pBody);
         } break;
         case VBOXVHWACMD_TYPE_QUERY_INFO2:
@@ -4641 +4657 @@
             VBOXVHWACMD_QUERYINFO2 * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO2);
             makeCurrent();
-            pCmd->rc = mpOverlayWidget->vhwaQueryInfo2(pBody);
+            pCmd->rc = mOverlayImage.vhwaQueryInfo2(pBody);
         } break;
         case VBOXVHWACMD_TYPE_ENABLE:
@@ -4675 +4691 @@
 int VBoxQGLOverlay::vhwaLoadExec(struct SSMHANDLE * pSSM, uint32_t u32Version)
 {
-    return VBoxGLWidget::vhwaLoadExec(&mOnResizeCmdList, pSSM, u32Version);
+    return VBoxVHWAImage::vhwaLoadExec(&mOnResizeCmdList, pSSM, u32Version);
 }
 
 void VBoxQGLOverlay::vhwaSaveExec(struct SSMHANDLE * pSSM)
 {
-    if(mpOverlayWidget)
-        mpOverlayWidget->vhwaSaveExec(pSSM);
-    else
-        VBoxGLWidget::vhwaSaveExecVoid(pSSM);
+    mOverlayImage.vhwaSaveExec(pSSM);
 }
 
@@ -4713 +4726 @@
             );
     AssertRC(rc);
+    if (RT_SUCCESS(rc))
+    {
+        rc = mOverlayImage.vhwaConstruct(pCmd);
+        AssertRC(rc);
+    }
     return rc;
 }
@@ -4756 +4774 @@
             vboxDoVHWACmd(pCmd->vhwaCmd());
             break;
-        case VBOXVHWA_PIPECMD_OP:
-        {
-            const VBOXVHWACALLBACKINFO & info = pCmd->op();
-            (info.pThis->*(info.pfnCallback))(info.pContext);
-            break;
-        }
         case VBOXVHWA_PIPECMD_FUNC:
         {
@@ -5176 +5188 @@
     uint32_t type = calcProgramType(pDst, pDstCKey, pSrcCKey, bNotIntersected);
 
-    return mProgramMngr->getProgram(type, &colorFormat(), pDst ? &pDst->colorFormat() : NULL);
+    return mProgramMngr->getProgram(type, &pixelFormat(), pDst ? &pDst->pixelFormat() : NULL);
 }
 
@@ -5265 +5277 @@
         if(pSrcCKey)
         {
-            VBoxVHWATextureImage::setCKey(pProgram, &colorFormat(), pSrcCKey, false);
+            VBoxVHWATextureImage::setCKey(pProgram, &pixelFormat(), pSrcCKey, false);
         }
         if(pDstCKey)
         {
-            VBoxVHWATextureImage::setCKey(pProgram, &pDst->colorFormat(), pDstCKey, true);
+            VBoxVHWATextureImage::setCKey(pProgram, &pDst->pixelFormat(), pDstCKey, true);
         }
         pProgram->stop();

trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.h

@@ -242 +242 @@
     bool equals (const VBoxVHWAColorFormat & other) const;
 
+    ulong toVBoxPixelFormat() const
+    {
+        if (!mDataFormat)
+        {
+            /* RGB data */
+            switch (mFormat)
+            {
+                case GL_BGRA_EXT:
+                    return FramebufferPixelFormat_FOURCC_RGB;
+            }
+        }
+        return FramebufferPixelFormat_Opaque;
+    }
+
 private:
     void init(uint32_t bitsPerPixel, uint32_t r, uint32_t g, uint32_t b);
@@ -493 +507 @@
     uint32_t bytesPerLine() { return mpTex[0]->bytesPerLine(); }
 
-    const VBoxVHWAColorFormat &colorFormat() { return mColorFormat; }
+    const VBoxVHWAColorFormat &pixelFormat() { return mColorFormat; }
 
     uint32_t numComponents() {return mcTex;}
@@ -737 +751 @@
 {
 public:
-    VBoxVHWASurfaceBase (
-            class VBoxGLWidget *aWidget,
+    VBoxVHWASurfaceBase (class VBoxVHWAImage *pImage,
             const QSize & aSize,
             const QRect & aTargRect,
@@ -778 +791 @@
     ulong   memSize();
 
-    ulong width()  { return mRect.width();  }
-    ulong height() { return mRect.height(); }
-    const QSize size() {return mRect.size();}
-
-    uint32_t fourcc() {return mImage->colorFormat().fourcc(); }
-
-    ulong  bitsPerPixel() { return mImage->colorFormat().bitsPerPixel(); }
-    ulong  bytesPerLine() { return mImage->bytesPerLine(); }
+    ulong width() const { return mRect.width();  }
+    ulong height() const { return mRect.height(); }
+    const QSize size() const {return mRect.size();}
+
+    uint32_t fourcc() const {return mImage->pixelFormat().fourcc(); }
+
+    ulong  bitsPerPixel() const { return mImage->pixelFormat().bitsPerPixel(); }
+    ulong  bytesPerLine() const { return mImage->bytesPerLine(); }
 
     const VBoxVHWAColorKey * dstBltCKey() const { return mpDstBltCKey; }
@@ -884 +897 @@
     }
 
-    const VBoxVHWAColorFormat & colorFormat() { return mImage->colorFormat(); }
+    const VBoxVHWAColorFormat & pixelFormat() const { return mImage->pixelFormat(); }
 
     void setAddress(uchar * addr);
@@ -951 +964 @@
     VBoxVHWASurfaceBase *mpPrimary;
 
-    class VBoxGLWidget *mWidget;
-
     uint32_t mHGHandle;
+
+    class VBoxVHWAImage *mpImage;
 
 #ifdef DEBUG
@@ -1133 +1146 @@
 };
 
-typedef void (VBoxGLWidget::*PFNVBOXQGLOP)(void* );
-
 typedef void (*PFNVBOXQGLFUNC)(void*, void*);
 
@@ -1141 +1152 @@
     VBOXVHWA_PIPECMD_PAINT = 1,
     VBOXVHWA_PIPECMD_VHWA,
-    VBOXVHWA_PIPECMD_OP,
-    VBOXVHWA_PIPECMD_FUNC,
+    VBOXVHWA_PIPECMD_FUNC
 }VBOXVHWA_PIPECMD_TYPE;
-
-typedef struct VBOXVHWACALLBACKINFO
-{
-    VBoxGLWidget *pThis;
-    PFNVBOXQGLOP pfnCallback;
-    void * pContext;
-}VBOXVHWACALLBACKINFO;
 
 typedef struct VBOXVHWAFUNCCALLBACKINFO
@@ -1172 +1175 @@
         mType = VBOXVHWA_PIPECMD_PAINT;
         mRect = aRect;
-    }
-
-    void setOp(const VBOXVHWACALLBACKINFO & aOp)
-    {
-        mType = VBOXVHWA_PIPECMD_OP;
-        u.mCallback = aOp;
     }
 
@@ -1195 +1192 @@
         case VBOXVHWA_PIPECMD_VHWA:
             setVHWACmd((struct _VBOXVHWACMD *)pvData);
-            break;
-        case VBOXVHWA_PIPECMD_OP:
-            setOp(*((VBOXVHWACALLBACKINFO *)pvData));
             break;
         case VBOXVHWA_PIPECMD_FUNC:
@@ -1211 +1205 @@
     const QRect & rect() const {return mRect;}
     struct _VBOXVHWACMD * vhwaCmd() const {return u.mpCmd;}
-    const VBOXVHWACALLBACKINFO & op() const {return u.mCallback; }
     const VBOXVHWAFUNCCALLBACKINFO & func() const {return u.mFuncCallback; }
 
@@ -1220 +1213 @@
     {
         struct _VBOXVHWACMD * mpCmd;
-        VBOXVHWACALLBACKINFO mCallback;
         VBOXVHWAFUNCCALLBACKINFO mFuncCallback;
     }u;
@@ -1335 +1327 @@
 };
 
-class VBoxGLWidget : public QGLWidget
-{
-public:
-    VBoxGLWidget (CConsole console, QWidget *aParent, VBoxVHWASettings *aSettings);
-    ~VBoxGLWidget();
-
-    ulong vboxPixelFormat() { return mPixelFormat; }
-    bool vboxUsesGuestVRAM() { return mUsesGuestVRAM; }
-
-    uchar *vboxAddress() { return mDisplay.getVGA() ? mDisplay.getVGA()->address() : NULL; }
-
+/* added to workaround this ** [VBox|UI] duplication */
+class VBoxFBSizeInfo
+{
+public:
+    VBoxFBSizeInfo() {}
+    template<class T> VBoxFBSizeInfo(T * e) :
+        mPixelFormat(e->pixelFormat()), mVRAM(e->VRAM()), mBitsPerPixel(e->bitsPerPixel()),
+        mBytesPerLine(e->bytesPerLine()), mWidth(e->width()), mHeight(e->height()) {}
+
+    VBoxFBSizeInfo(ulong aPixelFormat, uchar *aVRAM,
+                     ulong aBitsPerPixel, ulong aBytesPerLine,
+                     ulong aWidth, ulong aHeight) :
+        mPixelFormat (aPixelFormat), mVRAM (aVRAM), mBitsPerPixel (aBitsPerPixel),
+        mBytesPerLine (aBytesPerLine), mWidth (aWidth), mHeight (aHeight) {}
+    ulong pixelFormat() const { return mPixelFormat; }
+    uchar *VRAM() const { return mVRAM; }
+    ulong bitsPerPixel() const { return mBitsPerPixel; }
+    ulong bytesPerLine() const { return mBytesPerLine; }
+    ulong width() const { return mWidth; }
+    ulong height() const { return mHeight; }
+
+private:
+    ulong mPixelFormat;
+    uchar *mVRAM;
+    ulong mBitsPerPixel;
+    ulong mBytesPerLine;
+    ulong mWidth;
+    ulong mHeight;
+};
+
+class VBoxVHWAImage
+{
+public:
+    VBoxVHWAImage ();
+    ~VBoxVHWAImage();
+
+    int init(VBoxVHWASettings *aSettings);
 #ifdef VBOX_WITH_VIDEOHWACCEL
     uchar *vboxVRAMAddressFromOffset(uint64_t offset);
@@ -1369 +1387 @@
     int vhwaConstruct(struct _VBOXVHWACMD_HH_CONSTRUCT *pCmd);
 
+    void *vramBase() { return mpvVRAM; }
+    uint32_t vramSize() { return mcbVRAM; }
+
     bool hasSurfaces() const;
     bool hasVisibleOverlays();
@@ -1375 +1396 @@
 #endif
 
+    static const QGLFormat & vboxGLFormat();
+
     int reset(VHWACommandList * pCmdList);
 
-    ulong vboxBitsPerPixel() { return mDisplay.getVGA()->bitsPerPixel(); }
-    ulong vboxBytesPerLine() { return mDisplay.getVGA() ? mDisplay.getVGA()->bytesPerLine() : 0; }
+//    ulong vboxBitsPerPixel() { return mDisplay.getVGA()->bitsPerPixel(); }
+//    ulong vboxBytesPerLine() { return mDisplay.getVGA() ? mDisplay.getVGA()->bytesPerLine() : 0; }
     int vboxFbWidth() {return mDisplay.getVGA()->width(); }
     int vboxFbHeight() {return mDisplay.getVGA()->height(); }
-    bool vboxIsInitialized() {return mDisplay.getVGA() != NULL; }
-
-    void vboxDoResize(void *re);
-
-    void vboxResizeEvent (void *re) {vboxPerformGLOp(&VBoxGLWidget::vboxDoResize, re); }
-
-    void vboxProcessVHWACommands(class VBoxVHWACommandElementProcessor * pPipe) {vboxPerformGLOp(&VBoxGLWidget::vboxDoProcessVHWACommands, pPipe);}
+    bool isInitialized() {return mDisplay.getVGA() != NULL; }
+
+    void resize(const VBoxFBSizeInfo & size);
 
     class VBoxVHWAGlProgramMngr * vboxVHWAGetGlProgramMngr() { return mpMngr; }
 
-    VBoxVHWASurfaceBase * vboxGetVGASurface() { return mDisplay.getVGA(); }
+    VBoxVHWASurfaceBase * vgaSurface() { return mDisplay.getVGA(); }
 
 #ifdef VBOXVHWA_OLD_COORD
@@ -1406 +1425 @@
 #endif
 
-    bool performDisplayAndSwap(bool bForce)
+    bool performDisplay(bool bForce)
     {
         bForce = mDisplay.performDisplay(bForce | mRepaintNeeded);
-        if(bForce)
-        {
-            swapBuffers();
-        }
 
 #ifdef VBOXVHWA_PROFILE_FPS
@@ -1429 +1444 @@
     }
 
-    VHWACommandList &onResizeCmdList() { return mOnResizeCmdList; }
+//    VHWACommandList &onResizeCmdList() { return mOnResizeCmdList; }
 
     static void pushSettingsAndSetupViewport(const QSize &display, const QRect &viewport)
@@ -1448 +1463 @@
     }
 
-protected:
-
-    void paintGL()
-    {
-        if(mpfnOp)
-        {
-            (this->*mpfnOp)(mOpContext);
-            mpfnOp = NULL;
-        }
-        VBOXQGLLOG(("paintGL\n"));
-
-        mDisplay.performDisplay(true);
-    }
-
-    void initializeGL();
-
 private:
     static void setupMatricies(const QSize &display, bool bInvert);
@@ -1473 +1472 @@
 #endif
 #ifdef VBOX_WITH_VIDEOHWACCEL
-    void vboxDoVHWACmdExec(void *cmd);
-    void vboxDoVHWACmdAndFree(void *cmd);
-    void vboxDoVHWACmd(void *cmd);
+//    void vboxDoVHWACmdExec(void *cmd);
+//    void vboxDoVHWACmdAndFree(void *cmd);
+//    void vboxDoVHWACmd(void *cmd);
 
     void vboxCheckUpdateAddress (VBoxVHWASurfaceBase * pSurface, uint64_t offset)
@@ -1497 +1496 @@
     void vhwaDoSurfaceOverlayUpdate(VBoxVHWASurfaceBase *pDstSurf, VBoxVHWASurfaceBase *pSrcSurf, struct _VBOXVHWACMD_SURF_OVERLAY_UPDATE *pCmd);
 #endif
-    static const QGLFormat & vboxGLFormat();
 
     VBoxVHWADisplay mDisplay;
 
-
-    /* we do all opengl stuff in the paintGL context,
-     * submit the operation to be performed
-     * @todo: could be moved outside the updateGL */
-    void vboxPerformGLOp(PFNVBOXQGLOP pfn, void* pContext)
-    {
-        mpfnOp = pfn;
-        mOpContext = pContext;
-        updateGL();
-    }
-
-    void vboxDoProcessVHWACommands(void *pContext);
-
-    class VBoxVHWACommandElement * processCmdList(class VBoxVHWACommandElement * pCmd);
+//    void vboxDoProcessVHWACommands(void *pContext);
+
+//    class VBoxVHWACommandElement * processCmdList(class VBoxVHWACommandElement * pCmd);
 
     VBoxVHWASurfaceBase* handle2Surface(uint32_t h)
@@ -1525 +1512 @@
     VBoxVHWAHandleTable mSurfHandleTable;
 
-    PFNVBOXQGLOP mpfnOp;
-    void *mOpContext;
-
-    ulong  mPixelFormat;
-    bool   mUsesGuestVRAM;
-
     bool mRepaintNeeded;
 
     QRect mViewport;
-
-    CConsole m_console;
 
     VBoxVHWASurfList *mConstructingList;
@@ -1542 +1521 @@
     /* this is used in saved state restore to postpone surface restoration
      * till the framebuffer size is restored */
-    VHWACommandList mOnResizeCmdList;
+//    VHWACommandList mOnResizeCmdList;
 
     class VBoxVHWAGlProgramMngr *mpMngr;
 
     VBoxVHWASettings *mSettings;
+
+    void    *mpvVRAM;
+    uint32_t mcbVRAM;
 
 #ifdef VBOXVHWA_PROFILE_FPS
@@ -1552 +1534 @@
     bool mbNewFrame;
 #endif
+};
+
+class VBoxGLWgt : public QGLWidget
+{
+public:
+    VBoxGLWgt(VBoxVHWAImage * pImage,
+            QWidget* parent, const QGLWidget* shareWidget);
+
+protected:
+    void paintGL()
+    {
+        mpImage->performDisplay(true);
+    }
+private:
+    VBoxVHWAImage * mpImage;
 };
 
@@ -1645 +1642 @@
         T::update(pRect);
 
-        VBoxGLWidget::pushSettingsAndSetupViewport(rect().size(), rect());
+        VBoxVHWAImage::pushSettingsAndSetupViewport(rect().size(), rect());
         mFBO.bind();
         T::display();
         mFBO.unbind();
-        VBoxGLWidget::popSettingsAfterSetupViewport();
+        VBoxVHWAImage::popSettingsAfterSetupViewport();
     }
 
@@ -1673 +1670 @@
 {
 public:
-    VBoxQGLOverlay (class VBoxConsoleView *aView, class VBoxFrameBuffer * aContainer, CSession * aSession);
+    VBoxQGLOverlay (QWidget *pViewport, QObject *pPostEventObject, CSession * aSession);
+    ~VBoxQGLOverlay()
+    {
+        if (mpShareWgt)
+            delete mpShareWgt;
+    }
+
+    void updateViewport(QWidget *pViewport);
 
     int onVHWACommand (struct _VBOXVHWACMD * pCommand);
@@ -1699 +1703 @@
     }
 
-    void onResizeEvent (const class VBoxResizeEvent *re);
-    void onResizeEventPostprocess (const class VBoxResizeEvent *re);
+    void onResizeEventPostprocess (const VBoxFBSizeInfo &re, const QPoint & topLeft);
 
     void onViewportResized (QResizeEvent * /*re*/)
@@ -1708 +1711 @@
     }
 
-    void onViewportScrolled (int /*dx*/, int /*dy*/)
-    {
+    void onViewportScrolled (const QPoint & newTopLeft)
+    {
+        mContentsTopLeft = newTopLeft;
         vboxDoCheckUpdateViewport();
         mGlCurrent = false;
@@ -1737 +1741 @@
         {
             mNeedSetVisible = false;
-            mpOverlayWidget->setVisible (true);
+            mpOverlayWgt->setVisible (true);
         }
     }
@@ -1748 +1752 @@
     void makeCurrent()
     {
-        if(!mGlCurrent)
+        if (!mGlCurrent)
         {
             mGlCurrent = true;
-            mpOverlayWidget->makeCurrent();
+            mpOverlayWgt->makeCurrent();
         }
     }
@@ -1757 +1761 @@
     void performDisplayOverlay()
     {
-        if(mOverlayVisible)
+        if (mOverlayVisible)
         {
             makeCurrent();
-            mpOverlayWidget->performDisplayAndSwap (false);
+            if (mOverlayImage.performDisplay(false))
+                mpOverlayWgt->swapBuffers();
         }
     }
@@ -1783 +1788 @@
     void initGl();
 
-    VBoxGLWidget *mpOverlayWidget;
-    class VBoxConsoleView *mView;
-    class VBoxFrameBuffer *mContainer;
+    VBoxGLWgt *mpOverlayWgt;
+    VBoxVHWAImage mOverlayImage;
+    QWidget *mpViewport;
     bool mGlOn;
     bool mOverlayWidgetVisible;
@@ -1803 +1808 @@
 
     VBoxVHWASettings mSettings;
-};
-
-
-template <class T>
+    CSession * mpSession;
+
+    VBoxFBSizeInfo mSizeInfo;
+    QPoint mContentsTopLeft;
+
+    QGLWidget *mpShareWgt;
+};
+
+/* these two additional class V, class R are to workaround the [VBox|UI] duplication,
+ * @todo: remove them once VBox stuff is removed */
+template <class T, class V, class R>
 class VBoxOverlayFrameBuffer : public T
 {
 public:
-    VBoxOverlayFrameBuffer (class VBoxConsoleView *aView, CSession * aSession)
-        : T (aView),
-          mOverlay (aView, this, aSession)
+    VBoxOverlayFrameBuffer (V *pView, QWidget *pWidget, CSession * aSession)
+        : T (pView),
+          mOverlay (pWidget, pView, aSession),
+          mpView (pView)
     {}
 
@@ -1852 +1865 @@
     }
 
-    void resizeEvent (VBoxResizeEvent *re)
-    {
-        mOverlay.onResizeEvent (re);
+    void resizeEvent (R *re)
+    {
         T::resizeEvent (re);
-        mOverlay.onResizeEventPostprocess (re);
+        mOverlay.onResizeEventPostprocess (VBoxFBSizeInfo(re),
+                QPoint(mpView->contentsX(), mpView->contentsY()));
     }
 
@@ -1867 +1880 @@
     void viewportScrolled (int dx, int dy)
     {
-        mOverlay.onViewportScrolled (dx, dy);
+        mOverlay.onViewportScrolled (QPoint(mpView->contentsX(), mpView->contentsY()));
         T::viewportScrolled (dx, dy);
     }
 private:
     VBoxQGLOverlay mOverlay;
+    V *mpView;
 };
 

trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBQGL.cpp

@@ -19 +19 @@
  * additional information or have any questions.
  */
-#if defined (VBOX_GUI_USE_QGL)
+#if defined (VBOX_GUI_USE_QGLFB)
 
 #ifdef VBOX_WITH_PRECOMPILED_HEADERS

trunk/src/VBox/Frontends/VirtualBox/src/VBoxFrameBuffer.cpp

@@ -450 +450 @@
 /////////////////////////////////////////////////////////////////////////////
 
-#if defined (VBOX_GUI_USE_QGL)
+#if defined (VBOX_GUI_USE_QGLFB)
 
 /* The class is defined in VBoxFBQGL.cpp */

trunk/src/VBox/Frontends/VirtualBox/src/VBoxFrameBuffer.h

@@ -296 +296 @@
 /////////////////////////////////////////////////////////////////////////////
 
-#if defined (VBOX_GUI_USE_QGL)
+#if defined (VBOX_GUI_USE_QGLFB)
 
 class VBoxQGLFrameBuffer : public VBoxFrameBuffer

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxDefs.h

@@ -83 +83 @@
     {
         InvalidRenderMode, TimerMode, QImageMode, SDLMode, DDRAWMode, Quartz2DMode
-#ifdef VBOX_GUI_USE_QGL
+#ifdef VBOX_GUI_USE_QGLFB
         , QGLMode
 #endif

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxGlobal.cpp

@@ -576 +576 @@
             mode = VBoxDefs::Quartz2DMode;
 #endif
-#if defined (VBOX_GUI_USE_QGL)
+#if defined (VBOX_GUI_USE_QGLFB)
         else if (::strcmp (aModeStr, "qgl") == 0)
             mode = VBoxDefs::QGLMode;

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

@@ -19 +19 @@
  * additional information or have any questions.
  */
-#if defined (VBOX_GUI_USE_QGL)
+#if defined (VBOX_GUI_USE_QGLFB)
 
 #ifdef VBOX_WITH_PRECOMPILED_HEADERS

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

@@ -26 +26 @@
 /* Global includes */
 #include "UIFrameBuffer.h"
-#if defined (VBOX_GUI_USE_QGL)
+#if defined (VBOX_GUI_USE_QGLFB)
 #include "VBoxFBOverlay.h"
 

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

@@ -37 +37 @@
 #include "UIFrameBufferQuartz2D.h"
 #include "UIFrameBufferSDL.h"
+#include "VBoxFBOverlay.h"
 #include "UISession.h"
 #include "UIActionsPool.h"
@@ -463 +464 @@
 {
     /* Prepare viewport: */
-#ifdef VBOX_GUI_USE_QGL
+#ifdef VBOX_GUI_USE_QGLFB
     QWidget *pViewport;
     switch (mode())
@@ -486 +487 @@
 #ifdef VBOX_GUI_USE_QIMAGE
         case VBoxDefs::QImageMode:
-//# ifdef VBOX_WITH_VIDEOHWACCEL
-//            m_pFrameBuffer = m_fAccelerate2DVideo ? new VBoxOverlayFrameBuffer<UIFrameBufferQImage>(this, &machineWindowWrapper()->session()) : new UIFrameBufferQImage(this);
-//# else
+# ifdef VBOX_WITH_VIDEOHWACCEL
+            /* these two additional template args is a workaround to this [VBox|UI] duplication
+             * @todo: they are to be removed once VBox stuff is gone */
+            m_pFrameBuffer = m_fAccelerate2DVideo ? new VBoxOverlayFrameBuffer<UIFrameBufferQImage, UIMachineView, UIResizeEvent>(this, viewport(), &machineWindowWrapper()->session()) : new UIFrameBufferQImage(this);
+# else
             m_pFrameBuffer = new UIFrameBufferQImage(this);
-//# endif
+# endif
             break;
 #endif /* VBOX_GUI_USE_QIMAGE */
-#ifdef VBOX_GUI_USE_QGL
+#ifdef VBOX_GUI_USE_QGLFB
         case VBoxDefs::QGLMode:
             m_pFrameBuffer = new UIFrameBufferQGL(this);
@@ -500 +503 @@
 //            m_pFrameBuffer = new UIQGLOverlayFrameBuffer(this);
 //            break;
-#endif /* VBOX_GUI_USE_QGL */
+#endif /* VBOX_GUI_USE_QGLFB */
 #ifdef VBOX_GUI_USE_SDL
         case VBoxDefs::SDLMode:
@@ -510 +513 @@
             XFlush(QX11Info::display());
 # endif
-//# if defined(VBOX_WITH_VIDEOHWACCEL) && defined(DEBUG_misha) /* not tested yet */
-//            m_pFrameBuffer = m_fAccelerate2DVideo ? new VBoxOverlayFrameBuffer<UISDLFrameBuffer> (this, &machineWindowWrapper()->session()) : new UISDLFrameBuffer(this);
-//# else
+# if defined(VBOX_WITH_VIDEOHWACCEL) && defined(DEBUG_misha) /* not tested yet */
+            /* these two additional template args is a workaround to this [VBox|UI] duplication
+             * @todo: they are to be removed once VBox stuff is gone */
+            m_pFrameBuffer = m_fAccelerate2DVideo ? new VBoxOverlayFrameBuffer<UIFrameBufferSDL, UIMachineView, UIResizeEvent> (this, viewport(), &machineWindowWrapper()->session()) : new UIFrameBufferSDL(this);
+# else
             m_pFrameBuffer = new UIFrameBufferSDL(this);
-//# endif
+# endif
             /* Disable scrollbars because we cannot correctly draw in a scrolled window using SDL: */
             horizontalScrollBar()->setEnabled(false);
@@ -538 +543 @@
             /* Indicate that we are doing all drawing stuff ourself: */
             viewport()->setAttribute(Qt::WA_PaintOnScreen);
-//# ifdef VBOX_WITH_VIDEOHWACCEL
-//            m_pFrameBuffer = m_fAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQuartz2DFrameBuffer>(this, &machineWindowWrapper()->session()) : new UIFrameBufferQuartz2D(this);
-//# else
+# ifdef VBOX_WITH_VIDEOHWACCEL
+            /* these two additional template args is a workaround to this [VBox|UI] duplication
+             * @todo: they are to be removed once VBox stuff is gone */
+            m_pFrameBuffer = m_fAccelerate2DVideo ? new VBoxOverlayFrameBuffer<VBoxQuartz2DFrameBuffer, UIMachineView, UIResizeEvent>(this, viewport(), &machineWindowWrapper()->session()) : new UIFrameBufferQuartz2D(this);
+# else
             m_pFrameBuffer = new UIFrameBufferQuartz2D(this);
-//# endif
+# endif
             break;
 #endif /* VBOX_GUI_USE_QUARTZ2D */

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

@@ -264 +264 @@
     friend class UIFrameBufferQuartz2D;
     friend class UIFrameBufferQGL;
+    template<class UIFrameBufferQImage, class UIMachineView, class UIResizeEvent> friend class VBoxOverlayFrameBuffer;
+    template<class UIFrameBufferQuartz2D, class UIMachineView, class UIResizeEvent> friend class VBoxOverlayFrameBuffer;
+    template<class UIFrameBufferSDL, class UIMachineView, class UIResizeEvent> friend class VBoxOverlayFrameBuffer;
 };