Changeset 52064 in vbox

Timestamp:

Jul 16, 2014 9:23:55 PM (11 years ago)

Author:

vboxsync

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

95065

Message:

Main: IDisplay converted to use API wrappers.

Location:

trunk/src/VBox

Files:

• HostServices/SharedOpenGL/crserver/crservice.cpp (modified) (2 diffs)
• Main/idl/VirtualBox.xidl (modified) (2 diffs)
• Main/include/DisplayImpl.h (modified) (10 diffs)
• Main/src-client/ConsoleImpl.cpp (modified) (5 diffs)
• Main/src-client/ConsoleVRDPServer.cpp (modified) (2 diffs)
• Main/src-client/DisplayImpl.cpp (modified) (215 diffs)
• Main/src-client/GuestDnDPrivate.cpp (modified) (1 diff)
• Main/src-client/MouseImpl.cpp (modified) (3 diffs)
• Main/src-client/VMMDevInterface.cpp (modified) (4 diffs)
• Main/src-client/xpcom/module.cpp (modified) (1 diff)
• Main/testcase/tstMouseImpl.cpp (modified) (4 diffs)

trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp

@@ -1123 +1123 @@
                             CHECK_ERROR_RET(pFramebuffer, COMGETTER(Width)(&w), rc);
                             CHECK_ERROR_RET(pFramebuffer, COMGETTER(Height)(&h), rc);
-                            CHECK_ERROR_RET(pDisplay, GetScreenResolution(i, NULL, NULL, NULL, &xo, &yo), rc);
+                            ULONG dummy;
+                            CHECK_ERROR_RET(pDisplay, GetScreenResolution(i, &dummy, &dummy, &dummy, &xo, &yo), rc);
 
                             rc = crVBoxServerMapScreen(i, xo, yo, w, h, winId);
@@ -1248 +1249 @@
                             CHECK_ERROR_BREAK(pFramebuffer, COMGETTER(Width)(&w));
                             CHECK_ERROR_BREAK(pFramebuffer, COMGETTER(Height)(&h));
-                            CHECK_ERROR_BREAK(pDisplay, GetScreenResolution(screenId, NULL, NULL, NULL, &xo, &yo));
+                            ULONG dummy;
+                            CHECK_ERROR_BREAK(pDisplay, GetScreenResolution(screenId, &dummy, &dummy, &dummy, &xo, &yo));
 
                             rc = crVBoxServerMapScreen(screenId, xo, yo, w, h, winId);

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -15554 +15554 @@
     uuid="0d85a960-bfa7-4f26-9637-fdd521b7f3c1"
     wsmap="managed"
+    wrap-hint-server-addinterfaces="IEventListener"
     >
     <desc>
@@ -18324 +18325 @@
     uuid="12F4DCDB-12B2-4EC1-B7CD-DDD9F6C5BF4D"
     wsmap="managed"
-    wrap-hint-server="addinterface=IInternalSessionControl"
+    wrap-hint-server-addinterfaces="IInternalSessionControl"
     >
     <desc>

trunk/src/VBox/Main/include/DisplayImpl.h

@@ -19 +19 @@
 #define ____H_DISPLAYIMPL
 
-#include "VirtualBoxBase.h"
 #include "SchemaDefs.h"
 
@@ -27 +26 @@
 #include <VBox/VBoxVideo.h>
 #include <VBox/vmm/pdmifs.h>
+#include "DisplayWrap.h"
 
 #ifdef VBOX_WITH_CROGL
@@ -104 +104 @@
 {
 public:
-    virtual int getScreenResolution(uint32_t cScreen, ULONG *pcx,
-                                    ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin) = 0;
-    virtual void getFramebufferDimensions(int32_t *px1, int32_t *py1,
-                                          int32_t *px2, int32_t *py2) = 0;
+    virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
+                                          ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin) = 0;
+    virtual void i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
+                                            int32_t *px2, int32_t *py2) = 0;
 };
 
@@ -113 +113 @@
 
 class ATL_NO_VTABLE Display :
-    public VirtualBoxBase,
-    VBOX_SCRIPTABLE_IMPL(IEventListener),
-    VBOX_SCRIPTABLE_IMPL(IDisplay),
+    public DisplayWrap,
     public DisplayMouseInterface
 {
 public:
 
-    VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Display, IDisplay)
-
-    DECLARE_NOT_AGGREGATABLE(Display)
-
-    DECLARE_PROTECT_FINAL_CONSTRUCT()
-
-    BEGIN_COM_MAP(Display)
-        VBOX_DEFAULT_INTERFACE_ENTRIES(IDisplay)
-        COM_INTERFACE_ENTRY(IEventListener)
-    END_COM_MAP()
-
     DECLARE_EMPTY_CTOR_DTOR(Display)
 
@@ -139 +126 @@
     HRESULT init(Console *aParent);
     void uninit();
-    int  registerSSM(PUVM pUVM);
+    int  i_registerSSM(PUVM pUVM);
 
     // public methods only for internal purposes
-    int  handleDisplayResize(unsigned uScreenId, uint32_t bpp, void *pvVRAM, uint32_t cbLine, uint32_t w, uint32_t h, uint16_t flags);
-    void handleDisplayUpdateLegacy(int x, int y, int cx, int cy);
-    void handleDisplayUpdate(unsigned uScreenId, int x, int y, int w, int h);
+    int  i_handleDisplayResize(unsigned uScreenId, uint32_t bpp, void *pvVRAM, uint32_t cbLine,
+                               uint32_t w, uint32_t h, uint16_t flags);
+    void i_handleDisplayUpdateLegacy(int x, int y, int cx, int cy);
+    void i_handleDisplayUpdate(unsigned uScreenId, int x, int y, int w, int h);
 #ifdef VBOX_WITH_VIDEOHWACCEL
-    int handleVHWACommandProcess(PVBOXVHWACMD pCommand);
+    int  i_handleVHWACommandProcess(PVBOXVHWACMD pCommand);
 #endif
 #ifdef VBOX_WITH_CRHGSMI
-    void handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
-    void handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
-    void handleCrHgsmiCommandProcess(PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
-    void handleCrHgsmiControlProcess(PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl);
-#endif
-#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-    int  handleCrHgcmCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
-                                        PFNCRCTLCOMPLETION pfnCompletion,
-                                        void *pvCompletion);
-    void  handleCrVRecScreenshotPerform(uint32_t uScreen,
-                                        uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBitsPerPixel,
-                                        uint32_t uBytesPerLine, uint32_t uGuestWidth, uint32_t uGuestHeight,
-                                        uint8_t *pu8BufferAddress, uint64_t u64TimeStamp);
-    bool handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t u64TimeStamp);
-    void handleCrVRecScreenshotEnd(uint32_t uScreen, uint64_t u64TimeStamp);
-    void handleVRecCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext);
-#endif
-
-    int notifyCroglResize(const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM);
-
-    void getFramebufferDimensions(int32_t *px1, int32_t *py1, int32_t *px2, int32_t *py2);
-    int getScreenResolution(uint32_t cScreen, ULONG *pcx, ULONG *pcy,
-                            ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin)
+    void i_handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
+    void i_handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam);
+    void i_handleCrHgsmiCommandProcess(PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
+    void i_handleCrHgsmiControlProcess(PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl);
+#endif
+#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
+    int  i_handleCrHgcmCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
+                                 PFNCRCTLCOMPLETION pfnCompletion,
+                                 void *pvCompletion);
+    void  i_handleCrVRecScreenshotPerform(uint32_t uScreen,
+                                          uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBitsPerPixel,
+                                          uint32_t uBytesPerLine, uint32_t uGuestWidth, uint32_t uGuestHeight,
+                                          uint8_t *pu8BufferAddress, uint64_t u64TimeStamp);
+    bool i_handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t u64TimeStamp);
+    void i_handleCrVRecScreenshotEnd(uint32_t uScreen, uint64_t u64TimeStamp);
+    void i_handleVRecCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext);
+#endif
+
+    int i_notifyCroglResize(const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM);
+
+    int  i_handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect);
+    int  i_handleQueryVisibleRegion(uint32_t *pcRect, PRTRECT pRect);
+
+    int  i_VideoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory);
+    void i_VideoAccelFlush(void);
+    bool i_VideoAccelAllowed(void);
+    void i_VideoAccelVRDP(bool fEnable);
+
+    int  i_VideoCaptureStart();
+    void i_VideoCaptureStop();
+    int  i_VideoCaptureEnableScreens(ComSafeArrayIn(BOOL, aScreens));
+
+    void i_notifyPowerDown(void);
+
+    // DisplayMouseInterface methods
+    virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx,
+                                          ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin)
     {
-        return GetScreenResolution(cScreen, pcx, pcy, pcBPP, pXOrigin, pYOrigin);
+        return getScreenResolution(cScreen, pcx, pcy, pcBPP, pXOrigin, pYOrigin);
     }
-
-    int  handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect);
-    int  handleQueryVisibleRegion(uint32_t *pcRect, PRTRECT pRect);
-
-    int  VideoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory);
-    void VideoAccelFlush(void);
-    bool VideoAccelAllowed(void);
-    void VideoAccelVRDP(bool fEnable);
-
-    int  VideoCaptureStart();
-    void VideoCaptureStop();
-    int  VideoCaptureEnableScreens(ComSafeArrayIn(BOOL, aScreens));
-
-    void notifyPowerDown(void);
-
-    // IEventListener methods
-    STDMETHOD(HandleEvent)(IEvent * aEvent);
-
-    // IDisplay methods
-    STDMETHOD(GetScreenResolution)(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ULONG *aBitsPerPixel, LONG *aXOrigin, LONG *aYOrigin);
-    STDMETHOD(AttachFramebuffer)(ULONG aScreenId,
-                                 IFramebuffer *aFramebuffer);
-    STDMETHOD(DetachFramebuffer)(ULONG aScreenId);
-    STDMETHOD(QueryFramebuffer)(ULONG aScreenId,
-                                IFramebuffer **aFramebuffer);
-    STDMETHOD(SetVideoModeHint)(ULONG aDisplay, BOOL aEnabled, BOOL aChangeOrigin, LONG aOriginX, LONG aOriginY, ULONG aWidth, ULONG aHeight, ULONG aBitsPerPixel);
-    STDMETHOD(TakeScreenShot)(ULONG aScreenId, BYTE *address, ULONG width, ULONG height);
-    STDMETHOD(TakeScreenShotToArray)(ULONG aScreenId, ULONG width, ULONG height, ComSafeArrayOut(BYTE, aScreenData));
-    STDMETHOD(TakeScreenShotPNGToArray)(ULONG aScreenId, ULONG width, ULONG height, ComSafeArrayOut(BYTE, aScreenData));
-    STDMETHOD(DrawToScreen)(ULONG aScreenId, BYTE *address, ULONG x, ULONG y, ULONG width, ULONG height);
-    STDMETHOD(InvalidateAndUpdate)();
-    STDMETHOD(SetSeamlessMode)(BOOL enabled);
-
-    STDMETHOD(CompleteVHWACommand)(BYTE *pCommand);
-
-    STDMETHOD(ViewportChanged)(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height);
-    STDMETHOD(QuerySourceBitmap)(ULONG aScreenId,
-                                 IDisplaySourceBitmap **aDisplaySourceBitmap);
-    STDMETHOD(SetFramebufferUpdateMode)(ULONG aScreenId,
-                                        FramebufferUpdateMode_T aFramebufferUpdateMode);
-
+    virtual void i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
+                                            int32_t *px2, int32_t *py2);
+    
     static const PDMDRVREG  DrvReg;
 
 private:
-
+    // Wrapped IDisplay properties
+
+    // Wrapped IDisplay methods
+    virtual HRESULT getScreenResolution(ULONG aScreenId,
+                                        ULONG *aWidth,
+                                        ULONG *aHeight,
+                                        ULONG *aBitsPerPixel,
+                                        LONG *aXOrigin,
+                                        LONG *aYOrigin);
+    virtual HRESULT attachFramebuffer(ULONG aScreenId,
+                                      const ComPtr<IFramebuffer> &aFramebuffer);
+    virtual HRESULT detachFramebuffer(ULONG aScreenId);
+    virtual HRESULT queryFramebuffer(ULONG aScreenId,
+                                     ComPtr<IFramebuffer> &aFramebuffer);
+    virtual HRESULT setVideoModeHint(ULONG aDisplay,
+                                     BOOL aEnabled,
+                                     BOOL aChangeOrigin,
+                                     LONG aOriginX,
+                                     LONG aOriginY,
+                                     ULONG aWidth,
+                                     ULONG aHeight,
+                                     ULONG aBitsPerPixel);
+    virtual HRESULT setSeamlessMode(BOOL aEnabled);
+    virtual HRESULT takeScreenShot(ULONG aScreenId,
+                                   BYTE *aAddress,
+                                   ULONG aWidth,
+                                   ULONG aHeight);
+    virtual HRESULT takeScreenShotToArray(ULONG aScreenId,
+                                          ULONG aWidth,
+                                          ULONG aHeight,
+                                          std::vector<BYTE> &aScreenData);
+    virtual HRESULT takeScreenShotPNGToArray(ULONG aScreenId,
+                                             ULONG aWidth,
+                                             ULONG aHeight,
+                                             std::vector<BYTE> &aScreenData);
+    virtual HRESULT drawToScreen(ULONG aScreenId,
+                                 BYTE *aAddress,
+                                 ULONG aX,
+                                 ULONG aY,
+                                 ULONG aWidth,
+                                 ULONG aHeight);
+    virtual HRESULT invalidateAndUpdate();
+    virtual HRESULT completeVHWACommand(BYTE *aCommand);
+    virtual HRESULT viewportChanged(ULONG aScreenId,
+                                    ULONG aX,
+                                    ULONG aY,
+                                    ULONG aWidth,
+                                    ULONG aHeight);
+    virtual HRESULT querySourceBitmap(ULONG aScreenId,
+                                      ComPtr<IDisplaySourceBitmap> &aDisplaySourceBitmap);
+    virtual HRESULT setFramebufferUpdateMode(ULONG aScreenId,
+                                             FramebufferUpdateMode_T aFramebufferUpdateMode);
+
+    // Wrapped IEventListener properties
+
+    // Wrapped IEventListener methods
+    virtual HRESULT handleEvent(const ComPtr<IEvent> &aEvent);
+
+    // other internal methods    
 #ifdef VBOX_WITH_CRHGSMI
-    void setupCrHgsmiData(void);
-    void destructCrHgsmiData(void);
-#endif
-
-#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-    int crViewportNotify(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height);
-#endif
-
-    static DECLCALLBACK(void*) drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
-    static DECLCALLBACK(int)   drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
-    static DECLCALLBACK(void)  drvDestruct(PPDMDRVINS pDrvIns);
-    static DECLCALLBACK(int)   displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface, uint32_t bpp, void *pvVRAM, uint32_t cbLine, uint32_t cx, uint32_t cy);
-    static DECLCALLBACK(void)  displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
-                                                     uint32_t x, uint32_t y, uint32_t cx, uint32_t cy);
-    static DECLCALLBACK(void)  displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface);
-    static DECLCALLBACK(void)  displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface);
-    static DECLCALLBACK(void)  displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled);
-    static DECLCALLBACK(void)  displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, uint32_t u32VRAMSize);
-    static DECLCALLBACK(void)  displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, unsigned uScreenId);
+    void i_setupCrHgsmiData(void);
+    void i_destructCrHgsmiData(void);
+#endif
+
+#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
+    int i_crViewportNotify(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height);
+#endif
+
+    static DECLCALLBACK(void*) i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID);
+    static DECLCALLBACK(int)   i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags);
+    static DECLCALLBACK(void)  i_drvDestruct(PPDMDRVINS pDrvIns);
+    static DECLCALLBACK(int)   i_displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface, uint32_t bpp, void *pvVRAM,
+                                                       uint32_t cbLine, uint32_t cx, uint32_t cy);
+    static DECLCALLBACK(void)  i_displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
+                                                       uint32_t x, uint32_t y, uint32_t cx, uint32_t cy);
+    static DECLCALLBACK(void)  i_displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface);
+    static DECLCALLBACK(void)  i_displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface);
+    static DECLCALLBACK(void)  i_displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled);
+    static DECLCALLBACK(void)  i_displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
+                                                                   void *pvVRAM, uint32_t u32VRAMSize);
+    static DECLCALLBACK(void)  i_displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
+                                                                   void *pvVRAM, unsigned uScreenId);
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
-    static DECLCALLBACK(int)  displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand);
+    static DECLCALLBACK(int)  i_displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand);
 #endif
 
 #ifdef VBOX_WITH_CRHGSMI
-    static DECLCALLBACK(void)  displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
-    static DECLCALLBACK(void)  displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl);
-
-    static DECLCALLBACK(void)  displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext);
-    static DECLCALLBACK(void)  displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext);
-#endif
-#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-    static DECLCALLBACK(int)  displayCrHgcmCtlSubmit(PPDMIDISPLAYCONNECTOR pInterface,
-                                        struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
-                                        PFNCRCTLCOMPLETION pfnCompletion,
-                                        void *pvCompletion);
-    static DECLCALLBACK(void)  displayCrHgcmCtlSubmitCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext);
+    static DECLCALLBACK(void)  i_displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface,
+                                                              PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd);
+    static DECLCALLBACK(void)  i_displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl,
+                                                              uint32_t cbCtl);
+
+    static DECLCALLBACK(void)  i_displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
+                                                                 void *pvContext);
+    static DECLCALLBACK(void)  i_displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
+                                                                 void *pvContext);
+#endif
+#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
+    static DECLCALLBACK(int)  i_displayCrHgcmCtlSubmit(PPDMIDISPLAYCONNECTOR pInterface,
+                                                       struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
+                                                       PFNCRCTLCOMPLETION pfnCompletion,
+                                                       void *pvCompletion);
+    static DECLCALLBACK(void) i_displayCrHgcmCtlSubmitCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
+                                                                 void *pvContext);
 #endif
 #ifdef VBOX_WITH_HGSMI
-    static DECLCALLBACK(int)   displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags, bool fRenderThreadMode);
-    static DECLCALLBACK(void)  displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
-    static DECLCALLBACK(void)  displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
-    static DECLCALLBACK(void)  displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, const PVBVACMDHDR pCmd, size_t cbCmd);
-    static DECLCALLBACK(void)  displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y, uint32_t cx, uint32_t cy);
-    static DECLCALLBACK(int)   displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM);
-    static DECLCALLBACK(int)   displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha, uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy, const void *pvShape);
-#endif
-
-#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-    static DECLCALLBACK(void) displayCrVRecScreenshotPerform(void *pvCtx, uint32_t uScreen,
-                                                             uint32_t x, uint32_t y,
-                                                             uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
-                                                             uint32_t uGuestWidth, uint32_t uGuestHeight,
-                                                             uint8_t *pu8BufferAddress, uint64_t u64TimeStamp);
-    static DECLCALLBACK(bool) displayCrVRecScreenshotBegin(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp);
-    static DECLCALLBACK(void) displayCrVRecScreenshotEnd(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp);
-
-    static DECLCALLBACK(void)  displayVRecCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext);
-#endif
-    static DECLCALLBACK(void) displayCrCmdFree(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion);
-
-    static DECLCALLBACK(void)  displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser);
-    static DECLCALLBACK(int)   displaySSMLoadScreenshot(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
-    static DECLCALLBACK(void)  displaySSMSave(PSSMHANDLE pSSM, void *pvUser);
-    static DECLCALLBACK(int)   displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
+    static DECLCALLBACK(int)   i_displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
+                                                   PVBVAHOSTFLAGS pHostFlags, bool fRenderThreadMode);
+    static DECLCALLBACK(void)  i_displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
+    static DECLCALLBACK(void)  i_displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId);
+    static DECLCALLBACK(void)  i_displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
+                                                          const PVBVACMDHDR pCmd, size_t cbCmd);
+    static DECLCALLBACK(void)  i_displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y,
+                                                      uint32_t cx, uint32_t cy);
+    static DECLCALLBACK(int)   i_displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView,
+                                                   const PVBVAINFOSCREEN pScreen, void *pvVRAM);
+    static DECLCALLBACK(int)   i_displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
+                                                              uint32_t xHot, uint32_t yHot, uint32_t cx, uint32_t cy,
+                                                              const void *pvShape);
+#endif
+
+#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
+    static DECLCALLBACK(void) i_displayCrVRecScreenshotPerform(void *pvCtx, uint32_t uScreen,
+                                                               uint32_t x, uint32_t y,
+                                                               uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
+                                                               uint32_t uGuestWidth, uint32_t uGuestHeight,
+                                                               uint8_t *pu8BufferAddress, uint64_t u64TimeStamp);
+    static DECLCALLBACK(bool) i_displayCrVRecScreenshotBegin(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp);
+    static DECLCALLBACK(void) i_displayCrVRecScreenshotEnd(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp);
+
+    static DECLCALLBACK(void) i_displayVRecCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
+                                                      void *pvContext);
+#endif
+    static DECLCALLBACK(void) i_displayCrCmdFree(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion);
+
+    static DECLCALLBACK(void) i_displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser);
+    static DECLCALLBACK(int)  i_displaySSMLoadScreenshot(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
+    static DECLCALLBACK(void) i_displaySSMSave(PSSMHANDLE pSSM, void *pvUser);
+    static DECLCALLBACK(int)  i_displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass);
 
     Console * const         mParent;
     /** Pointer to the associated display driver. */
-    struct DRVMAINDISPLAY  *mpDrv;
+    struct DRVMAINDISPLAY   *mpDrv;
     /** Pointer to the device instance for the VMM Device. */
     PPDMDEVINS              mpVMMDev;
@@ -330 +367 @@
 #endif
 
-    bool vbvaFetchCmd(VBVACMDHDR **ppHdr, uint32_t *pcbCmd);
-    void vbvaReleaseCmd(VBVACMDHDR *pHdr, int32_t cbCmd);
-
-    void handleResizeCompletedEMT(unsigned uScreenId, BOOL fResizeContext);
+    bool i_vbvaFetchCmd(VBVACMDHDR **ppHdr, uint32_t *pcbCmd);
+    void i_vbvaReleaseCmd(VBVACMDHDR *pHdr, int32_t cbCmd);
+
+    void i_handleResizeCompletedEMT(unsigned uScreenId, BOOL fResizeContext);
 
     /* Old guest additions (3.x?) use VMMDev for VBVA and the host VBVA code (VideoAccel*)
@@ -342 +379 @@
     volatile uint32_t mfu32PendingVideoAccelDisable;
 
-    int  vbvaLock(void);
-    void vbvaUnlock(void);
+    int  i_vbvaLock(void);
+    void i_vbvaUnlock(void);
 
 public:
-    bool vbvaLockIsOwner(void);
-
-    static int  displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppu8Data, size_t *pcbData, uint32_t *pu32Width, uint32_t *pu32Height);
-
-#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-    static BOOL  displayCheckTakeScreenshotCrOgl(Display *pDisplay, ULONG aScreenId, uint8_t *pu8Data, uint32_t u32Width, uint32_t u32Height);
-    int crCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion);
-    int crCtlSubmitSync(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
+
+    bool i_vbvaLockIsOwner(void);
+
+    static int i_displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppu8Data, size_t *pcbData,
+                                          uint32_t *pu32Width, uint32_t *pu32Height);
+
+#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
+    static BOOL  i_displayCheckTakeScreenshotCrOgl(Display *pDisplay, ULONG aScreenId, uint8_t *pu8Data,
+                                                   uint32_t u32Width, uint32_t u32Height);
+    int i_crCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion);
+    int i_crCtlSubmitSync(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
     /* copies the given command and submits it asynchronously,
      * i.e. the pCmd data may be discarded right after the call returns */
-    int crCtlSubmitAsyncCmdCopy(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
+    int i_crCtlSubmitAsyncCmdCopy(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
     /* performs synchronous request processing if 3D backend has something to display
      * this is primarily to work-around 3d<->main thread deadlocks on OSX
@@ -364 +404 @@
      * that must synchronize with 3D backend only when some 3D data is displayed.
      * The routine does NOT provide any info on whether command is processed asynchronously or not */
-    int crCtlSubmitSyncIfHasDataForScreen(uint32_t u32ScreenID, struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
+    int i_crCtlSubmitSyncIfHasDataForScreen(uint32_t u32ScreenID, struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd);
 #endif
 
 private:
-    static void InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll);
-    static int  drawToScreenEMT(Display *pDisplay, ULONG aScreenId, BYTE *address, ULONG x, ULONG y, ULONG width, ULONG height);
-
-    int  videoAccelRefreshProcess(void);
+    static void i_InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll);
+    static int  i_drawToScreenEMT(Display *pDisplay, ULONG aScreenId, BYTE *address, ULONG x, ULONG y, ULONG width, ULONG height);
+
+    int  i_videoAccelRefreshProcess(void);
 
     /* Functions run under VBVA lock. */
-    int  videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory);
-    int videoAccelFlush(void);
-
-#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-    int crOglWindowsShow(bool fShow);
+    int  i_videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory);
+    int  i_videoAccelFlush(void);
+
+#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
+    int i_crOglWindowsShow(bool fShow);
 #endif
 
@@ -391 +431 @@
 };
 
+/* helper function, code in DisplayResampleImage.cpp */
 void gdImageCopyResampled(uint8_t *dst, uint8_t *src,
-                          int dstX, int dstY, int srcX, int srcY,
-                          int dstW, int dstH, int srcW, int srcH);
+                            int dstX, int dstY, int srcX, int srcY,
+                            int dstW, int dstH, int srcW, int srcH);
 
 void BitmapScale32(uint8_t *dst, int dstW, int dstH,
                    const uint8_t *src, int iDeltaLine, int srcW, int srcH);
 
+/* helper function, code in DisplayPNGUtul.cpp */
 int DisplayMakePNG(uint8_t *pu8Data, uint32_t cx, uint32_t cy,
                    uint8_t **ppu8PNG, uint32_t *pcbPNG, uint32_t *pcxPNG, uint32_t *pcyPNG,
-                   uint8_t fLimitSize);
+                     uint8_t fLimitSize);
 
 class ATL_NO_VTABLE DisplaySourceBitmap:
@@ -416 +458 @@
     void uninit();
 
-    bool usesVRAM(void) { return m.pu8Allocated == NULL; }
+    bool i_usesVRAM(void) { return m.pu8Allocated == NULL; }
 
 private:

trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

@@ -1379 +1379 @@
 
     NOREF(u32ClientId);
-    mDisplay->VideoAccelVRDP(true);
+    mDisplay->i_VideoAccelVRDP(true);
 
 #ifdef VBOX_WITH_GUEST_PROPS
@@ -1413 +1413 @@
     }
 
-    mDisplay->VideoAccelVRDP(false);
+    mDisplay->i_VideoAccelVRDP(false);
 
     if (fu32Intercepted & VRDE_CLIENT_INTERCEPT_USB)
@@ -5183 +5183 @@
             int vrc = VINF_SUCCESS;
             if (SUCCEEDED(rc))
-                vrc = mDisplay->VideoCaptureEnableScreens(ComSafeArrayAsInParam(screens));
+                vrc = mDisplay->i_VideoCaptureEnableScreens(ComSafeArrayAsInParam(screens));
             if (RT_SUCCESS(vrc))
             {
                 if (fEnabled)
                 {
-                    vrc = mDisplay->VideoCaptureStart();
+                    vrc = mDisplay->i_VideoCaptureStart();
                     if (RT_FAILURE(vrc))
                         rc = setError(E_FAIL, tr("Unable to start video capturing (%Rrc)"), vrc);
                 }
                 else
-                    mDisplay->VideoCaptureStop();
+                    mDisplay->i_VideoCaptureStop();
             }
             else
@@ -7324 +7324 @@
         alock.release();
 
-        mDisplay->notifyPowerDown();
+        mDisplay->i_notifyPowerDown();
 
         alock.acquire();
@@ -9370 +9370 @@
                 AssertRCBreak(vrc);
 
-                vrc = static_cast<Console *>(pConsole)->i_getDisplay()->registerSSM(pConsole->mpUVM);
+                vrc = static_cast<Console *>(pConsole)->i_getDisplay()->i_registerSSM(pConsole->mpUVM);
                 AssertRC(vrc);
                 if (RT_FAILURE(vrc))

trunk/src/VBox/Main/src-client/ConsoleVRDPServer.cpp

@@ -1107 +1107 @@
         if (SUCCEEDED(hr))
         {
-            hr = server->mConsole->i_getDisplay()->GetScreenResolution(uScreenId, NULL, NULL, NULL,
+            ULONG dummy;
+            hr = server->mConsole->i_getDisplay()->GetScreenResolution(uScreenId, &dummy, &dummy, &dummy,
                                                                      &xOrigin, &yOrigin);
 
@@ -2138 +2139 @@
     data.aParms[0].u.pointer.size = sizeof(outputRedirect);
 
-    int rc = mConsole->i_getDisplay()->crCtlSubmitSync(&data.Hdr, sizeof (data));
+    int rc = mConsole->i_getDisplay()->i_crCtlSubmitSync(&data.Hdr, sizeof (data));
     if (!RT_SUCCESS(rc))
     {

trunk/src/VBox/Main/src-client/DisplayImpl.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2013 Oracle Corporation
+ * Copyright (C) 2006-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -148 +148 @@
     mCrOglScreenshotData.u32Screen = CRSCREEN_ALL;
     mCrOglScreenshotData.pvContext = this;
-    mCrOglScreenshotData.pfnScreenshotBegin = displayCrVRecScreenshotBegin;
-    mCrOglScreenshotData.pfnScreenshotPerform = displayCrVRecScreenshotPerform;
-    mCrOglScreenshotData.pfnScreenshotEnd = displayCrVRecScreenshotEnd;
+    mCrOglScreenshotData.pfnScreenshotBegin = i_displayCrVRecScreenshotBegin;
+    mCrOglScreenshotData.pfnScreenshotPerform = i_displayCrVRecScreenshotPerform;
+    mCrOglScreenshotData.pfnScreenshotEnd = i_displayCrVRecScreenshotEnd;
 #endif
 
@@ -220 +220 @@
         int iDeltaLine = cx * 4;
 
-        BitmapScale32 (dst,
-                       dstW, dstH,
-                       src,
-                       iDeltaLine,
-                       srcW, srcH);
+        BitmapScale32(dst,
+                      dstW, dstH,
+                      src,
+                      iDeltaLine,
+                      srcW, srcH);
 
         *ppu8Thumbnail = pu8Thumbnail;
@@ -282 +282 @@
 #endif
 
-DECLCALLBACK(void)
-Display::displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser)
+DECLCALLBACK(void) Display::i_displaySSMSaveScreenshot(PSSMHANDLE pSSM, void *pvUser)
 {
     Display *that = static_cast<Display*>(pvUser);
@@ -318 +317 @@
             {
                 VBOX_DISPLAY_SAVESCREENSHOT_DATA *pScreenshot =
-                    (VBOX_DISPLAY_SAVESCREENSHOT_DATA*)RTMemAllocZ(sizeof (*pScreenshot));
+                    (VBOX_DISPLAY_SAVESCREENSHOT_DATA*)RTMemAllocZ(sizeof(*pScreenshot));
                 if (pScreenshot)
                 {
@@ -338 +337 @@
                     data.aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
                     data.aParms[0].u.pointer.addr = &pScreenshot->Base;
-                    data.aParms[0].u.pointer.size = sizeof (pScreenshot->Base);
-
-                    int rc = that->crCtlSubmitSync(&data.Hdr, sizeof (data));
+                    data.aParms[0].u.pointer.size = sizeof(pScreenshot->Base);
+
+                    int rc = that->i_crCtlSubmitSync(&data.Hdr, sizeof(data));
                     if (RT_SUCCESS(rc))
                     {
@@ -373 +372 @@
         {
             /* SSM code is executed on EMT(0), therefore no need to use VMR3ReqCallWait. */
-            int rc = Display::displayTakeScreenshotEMT(that, VBOX_VIDEO_PRIMARY_SCREEN, &pu8Data, &cbData, &cx, &cy);
+            int rc = Display::i_displayTakeScreenshotEMT(that, VBOX_VIDEO_PRIMARY_SCREEN, &pu8Data, &cbData, &cx, &cy);
 
             /*
@@ -399 +398 @@
 
                 /* This can be called from any thread. */
-                Assert(!that->vbvaLockIsOwner());
+                Assert(!that->i_vbvaLockIsOwner());
                 that->mpDrv->pUpPort->pfnFreeScreenshot(that->mpDrv->pUpPort, pu8Data);
             }
@@ -427 +426 @@
 
     /* First block. */
-    SSMR3PutU32(pSSM, cbThumbnail + 2 * sizeof (uint32_t));
+    SSMR3PutU32(pSSM, cbThumbnail + 2 * sizeof(uint32_t));
     SSMR3PutU32(pSSM, 0); /* Block type: thumbnail. */
 
@@ -438 +437 @@
 
     /* Second block. */
-    SSMR3PutU32(pSSM, cbPNG + 2 * sizeof (uint32_t));
+    SSMR3PutU32(pSSM, cbPNG + 2 * sizeof(uint32_t));
     SSMR3PutU32(pSSM, 1); /* Block type: png. */
 
@@ -453 +452 @@
 
 DECLCALLBACK(int)
-Display::displaySSMLoadScreenshot(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
+Display::i_displaySSMLoadScreenshot(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
 {
     Display *that = static_cast<Display*>(pvUser);
@@ -482 +481 @@
          * @todo Fix and increase saved state version.
          */
-        if (cbBlock > 2 * sizeof (uint32_t))
+        if (cbBlock > 2 * sizeof(uint32_t))
         {
             rc = SSMR3Skip(pSSM, cbBlock);
@@ -496 +495 @@
  */
 DECLCALLBACK(void)
-Display::displaySSMSave(PSSMHANDLE pSSM, void *pvUser)
+Display::i_displaySSMSave(PSSMHANDLE pSSM, void *pvUser)
 {
     Display *that = static_cast<Display*>(pvUser);
@@ -515 +514 @@
 
 DECLCALLBACK(int)
-Display::displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
+Display::i_displaySSMLoad(PSSMHANDLE pSSM, void *pvUser, uint32_t uVersion, uint32_t uPass)
 {
     Display *that = static_cast<Display*>(pvUser);
@@ -633 +632 @@
         ComPtr<IEventSource> es;
         mParent->COMGETTER(EventSource)(es.asOutParam());
-        com::SafeArray <VBoxEventType_T> eventTypes;
+        com::SafeArray<VBoxEventType_T> eventTypes;
         eventTypes.push_back(VBoxEventType_OnStateChanged);
         es->RegisterListener(this, ComSafeArrayAsInParam(eventTypes), true);
@@ -688 +687 @@
  * pass pVM
  */
-int Display::registerSSM(PUVM pUVM)
+int Display::i_registerSSM(PUVM pUVM)
 {
     /* Version 2 adds width and height of the framebuffer; version 3 adds
@@ -696 +695 @@
                                    mcMonitors * sizeof(uint32_t) * 8 + sizeof(uint32_t),
                                    NULL, NULL, NULL,
-                                   NULL, displaySSMSave, NULL,
-                                   NULL, displaySSMLoad, NULL, this);
+                                   NULL, i_displaySSMSave, NULL,
+                                   NULL, i_displaySSMLoad, NULL, this);
     AssertRCReturn(rc, rc);
 
@@ -707 +706 @@
                                NULL, NULL, NULL,
                                NULL, NULL, NULL,
-                               NULL, displaySSMLoad, NULL, this);
+                               NULL, i_displaySSMLoad, NULL, this);
     AssertRCReturn(rc, rc);
 
@@ -713 +712 @@
                                NULL, NULL, NULL,
                                NULL, NULL, NULL,
-                               NULL, displaySSMLoad, NULL, this);
+                               NULL, i_displaySSMLoad, NULL, this);
     AssertRCReturn(rc, rc);
 
@@ -719 +718 @@
     rc = SSMR3RegisterExternal(pUVM, "DisplayScreenshot", 1100 /*uInstance*/, sSSMDisplayScreenshotVer, 0 /*cbGuess*/,
                                NULL, NULL, NULL,
-                               NULL, displaySSMSaveScreenshot, NULL,
-                               NULL, displaySSMLoadScreenshot, NULL, this);
+                               NULL, i_displaySSMSaveScreenshot, NULL,
+                               NULL, i_displaySSMLoadScreenshot, NULL, this);
 
     AssertRCReturn(rc, rc);
@@ -727 +726 @@
 }
 
-DECLCALLBACK(void) Display::displayCrCmdFree(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion)
+DECLCALLBACK(void) Display::i_displayCrCmdFree(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, int rc, void *pvCompletion)
 {
     Assert(pvCompletion);
@@ -734 +733 @@
 
 #if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-int Display::crOglWindowsShow(bool fShow)
+int Display::i_crOglWindowsShow(bool fShow)
 {
     if (!mfCrOglDataHidden == !!fShow)
@@ -757 +756 @@
     }
 
-    VBOXCRCMDCTL_HGCM *pData = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof (VBOXCRCMDCTL_HGCM));
+    VBOXCRCMDCTL_HGCM *pData = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof(VBOXCRCMDCTL_HGCM));
     if (!pData)
     {
@@ -770 +769 @@
     pData->aParms[0].u.uint32 = (uint32_t)fShow;
 
-    int rc = crCtlSubmit(&pData->Hdr, sizeof (*pData), displayCrCmdFree, pData);
+    int rc = i_crCtlSubmit(&pData->Hdr, sizeof(*pData), i_displayCrCmdFree, pData);
     if (RT_SUCCESS(rc))
         mfCrOglDataHidden = !fShow;
@@ -784 +783 @@
 
 
-// IEventListener method
-STDMETHODIMP Display::HandleEvent(IEvent * aEvent)
-{
-    VBoxEventType_T aType = VBoxEventType_Invalid;
-
-    aEvent->COMGETTER(Type)(&aType);
-    switch (aType)
-    {
-        case VBoxEventType_OnStateChanged:
-        {
-            ComPtr<IStateChangedEvent> scev = aEvent;
-            Assert(scev);
-            MachineState_T machineState;
-            scev->COMGETTER(State)(&machineState);
-            if (   machineState == MachineState_Running
-                   || machineState == MachineState_Teleporting
-                   || machineState == MachineState_LiveSnapshotting
-                   )
-            {
-                LogRelFlowFunc(("Machine is running.\n"));
-
-                mfMachineRunning = true;
-
-#ifdef VBOX_WITH_CROGL
-                crOglWindowsShow(true);
-#endif
-            }
-            else
-            {
-                mfMachineRunning = false;
-
-#ifdef VBOX_WITH_CROGL
-                if (machineState == MachineState_Paused)
-                    crOglWindowsShow(false);
-#endif
-            }
-            break;
-        }
-        default:
-            AssertFailed();
-    }
-
-    return S_OK;
-}
-
 // public methods only for internal purposes
 /////////////////////////////////////////////////////////////////////////////
 
-int Display::notifyCroglResize(const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM)
+int Display::i_notifyCroglResize(const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM)
 {
 #if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
@@ -850 +804 @@
             {
                 VBOXCRCMDCTL_HGCM *pCtl =
-                    (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof (CRVBOXHGCMDEVRESIZE) + sizeof (VBOXCRCMDCTL_HGCM));
+                    (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof(CRVBOXHGCMDEVRESIZE) + sizeof(VBOXCRCMDCTL_HGCM));
                 if (pCtl)
                 {
@@ -861 +815 @@
                     pCtl->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
                     pCtl->aParms[0].u.pointer.addr = pData;
-                    pCtl->aParms[0].u.pointer.size = sizeof (*pData);
-
-                    rc = crCtlSubmit(&pCtl->Hdr, sizeof (*pCtl), displayCrCmdFree, pCtl);
+                    pCtl->aParms[0].u.pointer.size = sizeof(*pData);
+
+                    rc = i_crCtlSubmit(&pCtl->Hdr, sizeof(*pCtl), i_displayCrCmdFree, pCtl);
                     if (!RT_SUCCESS(rc))
                     {
@@ -889 +843 @@
  *  @thread EMT
  */
-int Display::handleDisplayResize (unsigned uScreenId, uint32_t bpp, void *pvVRAM,
-                                  uint32_t cbLine, uint32_t w, uint32_t h, uint16_t flags)
+int Display::i_handleDisplayResize(unsigned uScreenId, uint32_t bpp, void *pvVRAM,
+                                   uint32_t cbLine, uint32_t w, uint32_t h, uint16_t flags)
 {
     LogRel(("Display::handleDisplayResize(): uScreenId = %d, pvVRAM=%p "
@@ -918 +872 @@
     if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
     {
-        Assert(!vbvaLockIsOwner());
+        Assert(!i_vbvaLockIsOwner());
         mpDrv->pUpPort->pfnSetRenderVRAM(mpDrv->pUpPort, false);
 
@@ -937 +891 @@
     }
 
-    handleResizeCompletedEMT(uScreenId, TRUE);
+    i_handleResizeCompletedEMT(uScreenId, TRUE);
 
     return VINF_SUCCESS;
@@ -948 +902 @@
  *  @thread EMT
  */
-void Display::handleResizeCompletedEMT(unsigned uScreenId, BOOL fResizeContext)
+void Display::i_handleResizeCompletedEMT(unsigned uScreenId, BOOL fResizeContext)
 {
     LogRelFlowFunc(("\n"));
@@ -1003 +957 @@
 
                 if (fResizeContext)
-                    crCtlSubmitAsyncCmdCopy(&data.Hdr, sizeof (data));
+                    i_crCtlSubmitAsyncCmdCopy(&data.Hdr, sizeof(data));
                 else
-                    crCtlSubmitSync(&data.Hdr, sizeof (data));
+                    i_crCtlSubmitSync(&data.Hdr, sizeof(data));
             }
         }
@@ -1012 +966 @@
 }
 
-static void checkCoordBounds (int *px, int *py, int *pw, int *ph, int cx, int cy)
+static void i_checkCoordBounds(int *px, int *py, int *pw, int *ph, int cx, int cy)
 {
     /* Correct negative x and y coordinates. */
@@ -1083 +1037 @@
  *  @thread EMT
  */
-void Display::handleDisplayUpdateLegacy (int x, int y, int w, int h)
+void Display::i_handleDisplayUpdateLegacy(int x, int y, int w, int h)
 {
     unsigned uScreenId = mapCoordsToScreen(maFramebuffers, mcMonitors, &x, &y, &w, &h);
@@ -1091 +1045 @@
 #endif /* DEBUG_sunlover */
 
-    handleDisplayUpdate (uScreenId, x, y, w, h);
-}
-
-void Display::handleDisplayUpdate (unsigned uScreenId, int x, int y, int w, int h)
+    i_handleDisplayUpdate(uScreenId, x, y, w, h);
+}
+
+void Display::i_handleDisplayUpdate(unsigned uScreenId, int x, int y, int w, int h)
 {
     /*
@@ -1111 +1065 @@
 
     if (uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
-        checkCoordBounds (&x, &y, &w, &h, mpDrv->IConnector.cx, mpDrv->IConnector.cy);
+        i_checkCoordBounds (&x, &y, &w, &h, mpDrv->IConnector.cx, mpDrv->IConnector.cy);
     else
-        checkCoordBounds (&x, &y, &w, &h, maFramebuffers[uScreenId].w,
+        i_checkCoordBounds (&x, &y, &w, &h, maFramebuffers[uScreenId].w,
                                           maFramebuffers[uScreenId].h);
 
@@ -1175 +1129 @@
  * and the origin is (0, 0), not (1, 1) like the GUI returns.
  */
-void Display::getFramebufferDimensions(int32_t *px1, int32_t *py1,
-                                       int32_t *px2, int32_t *py2)
+void Display::i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
+                                         int32_t *px2, int32_t *py2)
 {
     int32_t x1 = 0, y1 = 0, x2 = 0, y2 = 0;
@@ -1221 +1175 @@
 {
     /* Initialize result to an empty record. */
-    memset (prectResult, 0, sizeof (RTRECT));
+    memset(prectResult, 0, sizeof(RTRECT));
 
     int xLeftResult = RT_MAX(prect1->xLeft, prect2->xLeft);
@@ -1249 +1203 @@
 }
 
-int Display::handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect)
+int Display::i_handleSetVisibleRegion(uint32_t cRect, PRTRECT pRect)
 {
     RTRECT *pVisibleRegion = (RTRECT *)RTMemTmpAlloc(  RT_MAX(cRect, 1)
-                                                     * sizeof (RTRECT));
+                                                     * sizeof(RTRECT));
     if (!pVisibleRegion)
     {
@@ -1320 +1274 @@
         if (mhCrOglSvc)
         {
-            VBOXCRCMDCTL_HGCM *pCtl = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(RT_MAX(cRect, 1) * sizeof (RTRECT)
-                    + sizeof (VBOXCRCMDCTL_HGCM));
+            VBOXCRCMDCTL_HGCM *pCtl = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(RT_MAX(cRect, 1) * sizeof(RTRECT)
+                    + sizeof(VBOXCRCMDCTL_HGCM));
             if (pCtl)
             {
                 RTRECT *pRectsCopy = (RTRECT*)(pCtl+1);
-                memcpy(pRectsCopy, pRect, cRect * sizeof (RTRECT));
+                memcpy(pRectsCopy, pRect, cRect * sizeof(RTRECT));
 
                 pCtl->Hdr.enmType = VBOXCRCMDCTL_TYPE_HGCM;
@@ -1332 +1286 @@
                 pCtl->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
                 pCtl->aParms[0].u.pointer.addr = pRectsCopy;
-                pCtl->aParms[0].u.pointer.size = cRect * sizeof (RTRECT);
-
-                int rc = crCtlSubmit(&pCtl->Hdr, sizeof (*pCtl), displayCrCmdFree, pCtl);
+                pCtl->aParms[0].u.pointer.size = cRect * sizeof(RTRECT);
+
+                int rc = i_crCtlSubmit(&pCtl->Hdr, sizeof(*pCtl), i_displayCrCmdFree, pCtl);
                 if (!RT_SUCCESS(rc))
                 {
@@ -1354 +1308 @@
 }
 
-int Display::handleQueryVisibleRegion(uint32_t *pcRect, PRTRECT pRect)
+int Display::i_handleQueryVisibleRegion(uint32_t *pcRect, PRTRECT pRect)
 {
     // @todo Currently not used by the guest and is not implemented in framebuffers. Remove?
@@ -1370 +1324 @@
 } VBVADIRTYREGION;
 
-static void vbvaRgnInit (VBVADIRTYREGION *prgn, DISPLAYFBINFO *paFramebuffers, unsigned cMonitors,
-                         Display *pd, PPDMIDISPLAYPORT pp)
+static void vbvaRgnInit(VBVADIRTYREGION *prgn, DISPLAYFBINFO *paFramebuffers, unsigned cMonitors,
+                        Display *pd, PPDMIDISPLAYPORT pp)
 {
     prgn->paFramebuffers = paFramebuffers;
@@ -1387 +1341 @@
 }
 
-static void vbvaRgnDirtyRect (VBVADIRTYREGION *prgn, unsigned uScreenId, VBVACMDHDR *phdr)
+static void vbvaRgnDirtyRect(VBVADIRTYREGION *prgn, unsigned uScreenId, VBVACMDHDR *phdr)
 {
     LogSunlover(("x = %d, y = %d, w = %d, h = %d\n",
@@ -1445 +1399 @@
     {
         //@todo pfnUpdateDisplayRect must take the vram offset parameter for the framebuffer
-        prgn->pPort->pfnUpdateDisplayRect (prgn->pPort, phdr->x, phdr->y, phdr->w, phdr->h);
-        prgn->pDisplay->handleDisplayUpdateLegacy (phdr->x + pFBInfo->xOrigin,
-                                             phdr->y + pFBInfo->yOrigin, phdr->w, phdr->h);
+        prgn->pPort->pfnUpdateDisplayRect(prgn->pPort, phdr->x, phdr->y, phdr->w, phdr->h);
+        prgn->pDisplay->i_handleDisplayUpdateLegacy(phdr->x + pFBInfo->xOrigin,
+                                                    phdr->y + pFBInfo->yOrigin, phdr->w, phdr->h);
     }
 
@@ -1453 +1407 @@
 }
 
-static void vbvaRgnUpdateFramebuffer (VBVADIRTYREGION *prgn, unsigned uScreenId)
+static void vbvaRgnUpdateFramebuffer(VBVADIRTYREGION *prgn, unsigned uScreenId)
 {
     DISPLAYFBINFO *pFBInfo = &prgn->paFramebuffers[uScreenId];
@@ -1463 +1417 @@
     {
         //@todo pfnUpdateDisplayRect must take the vram offset parameter for the framebuffer
-        prgn->pPort->pfnUpdateDisplayRect (prgn->pPort, pFBInfo->dirtyRect.xLeft, pFBInfo->dirtyRect.yTop, w, h);
-        prgn->pDisplay->handleDisplayUpdateLegacy (pFBInfo->dirtyRect.xLeft + pFBInfo->xOrigin,
-                                             pFBInfo->dirtyRect.yTop + pFBInfo->yOrigin, w, h);
-    }
-}
-
-static void vbvaSetMemoryFlags (VBVAMEMORY *pVbvaMemory,
-                                bool fVideoAccelEnabled,
-                                bool fVideoAccelVRDP,
-                                uint32_t fu32SupportedOrders,
-                                DISPLAYFBINFO *paFBInfos,
-                                unsigned cFBInfos)
+        prgn->pPort->pfnUpdateDisplayRect(prgn->pPort, pFBInfo->dirtyRect.xLeft, pFBInfo->dirtyRect.yTop, w, h);
+        prgn->pDisplay->i_handleDisplayUpdateLegacy(pFBInfo->dirtyRect.xLeft + pFBInfo->xOrigin,
+                                                    pFBInfo->dirtyRect.yTop + pFBInfo->yOrigin, w, h);
+    }
+}
+
+static void i_vbvaSetMemoryFlags(VBVAMEMORY *pVbvaMemory,
+                                 bool fVideoAccelEnabled,
+                                 bool fVideoAccelVRDP,
+                                 uint32_t fu32SupportedOrders,
+                                 DISPLAYFBINFO *paFBInfos,
+                                 unsigned cFBInfos)
 {
     if (pVbvaMemory)
@@ -1507 +1461 @@
 
 #ifdef VBOX_WITH_HGSMI
-static void vbvaSetMemoryFlagsHGSMI (unsigned uScreenId,
-                                     uint32_t fu32SupportedOrders,
-                                     bool fVideoAccelVRDP,
-                                     DISPLAYFBINFO *pFBInfo)
+static void vbvaSetMemoryFlagsHGSMI(unsigned uScreenId,
+                                    uint32_t fu32SupportedOrders,
+                                    bool fVideoAccelVRDP,
+                                    DISPLAYFBINFO *pFBInfo)
 {
     LogRelFlowFunc(("HGSMI[%d]: %p\n", uScreenId, pFBInfo->pVBVAHostFlags));
@@ -1535 +1489 @@
 }
 
-static void vbvaSetMemoryFlagsAllHGSMI (uint32_t fu32SupportedOrders,
-                                        bool fVideoAccelVRDP,
-                                        DISPLAYFBINFO *paFBInfos,
-                                        unsigned cFBInfos)
+static void vbvaSetMemoryFlagsAllHGSMI(uint32_t fu32SupportedOrders,
+                                       bool fVideoAccelVRDP,
+                                       DISPLAYFBINFO *paFBInfos,
+                                       unsigned cFBInfos)
 {
     unsigned uScreenId;
@@ -1549 +1503 @@
 #endif /* VBOX_WITH_HGSMI */
 
-bool Display::VideoAccelAllowed (void)
+bool Display::i_VideoAccelAllowed(void)
 {
     return true;
 }
 
-int Display::vbvaLock(void)
+int Display::i_vbvaLock(void)
 {
     return RTCritSectEnter(&mVBVALock);
 }
 
-void Display::vbvaUnlock(void)
+void Display::i_vbvaUnlock(void)
 {
     RTCritSectLeave(&mVBVALock);
 }
 
-bool Display::vbvaLockIsOwner(void)
+bool Display::i_vbvaLockIsOwner(void)
 {
     return RTCritSectIsOwner(&mVBVALock);
@@ -1572 +1526 @@
  * @thread EMT
  */
-int Display::VideoAccelEnable (bool fEnable, VBVAMEMORY *pVbvaMemory)
+int Display::i_VideoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory)
 {
     int rc;
-
     if (fEnable)
     {
         /* Process any pending VGA device changes, resize. */
-        Assert(!vbvaLockIsOwner());
+        Assert(!i_vbvaLockIsOwner());
         mpDrv->pUpPort->pfnUpdateDisplayAll(mpDrv->pUpPort, /* fFailOnResize = */ false);
     }
 
-    vbvaLock();
-    rc = videoAccelEnable (fEnable, pVbvaMemory);
-    vbvaUnlock();
+    i_vbvaLock();
+    rc = i_videoAccelEnable(fEnable, pVbvaMemory);
+    i_vbvaUnlock();
 
     if (!fEnable)
     {
-        Assert(!vbvaLockIsOwner());
+        Assert(!i_vbvaLockIsOwner());
         mpDrv->pUpPort->pfnUpdateDisplayAll(mpDrv->pUpPort, /* fFailOnResize = */ false);
     }
@@ -1596 +1549 @@
 }
 
-int Display::videoAccelEnable (bool fEnable, VBVAMEMORY *pVbvaMemory)
-{
-    Assert(vbvaLockIsOwner());
+int Display::i_videoAccelEnable(bool fEnable, VBVAMEMORY *pVbvaMemory)
+{
+    Assert(i_vbvaLockIsOwner());
 
     int rc = VINF_SUCCESS;
-
     /* Called each time the guest wants to use acceleration,
      * or when the VGA device disables acceleration,
@@ -1618 +1570 @@
     Assert((fEnable && pVbvaMemory) || (!fEnable && pVbvaMemory == NULL));
 
-    if (!VideoAccelAllowed ())
+    if (!i_VideoAccelAllowed ())
         return VERR_NOT_SUPPORTED;
 
@@ -1647 +1599 @@
     {
         /* Process any pending orders and empty the VBVA ring buffer. */
-        videoAccelFlush ();
+        i_videoAccelFlush ();
     }
 
@@ -1676 +1628 @@
 
         /* Initialize the hardware memory. */
-        vbvaSetMemoryFlags(mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders, maFramebuffers, mcMonitors);
+        i_vbvaSetMemoryFlags(mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP,
+                             mfu32SupportedOrders, maFramebuffers, mcMonitors);
         mpVbvaMemory->off32Data = 0;
         mpVbvaMemory->off32Free = 0;
 
-        memset(mpVbvaMemory->aRecords, 0, sizeof (mpVbvaMemory->aRecords));
+        memset(mpVbvaMemory->aRecords, 0, sizeof(mpVbvaMemory->aRecords));
         mpVbvaMemory->indexRecordFirst = 0;
         mpVbvaMemory->indexRecordFree = 0;
@@ -1700 +1653 @@
 /* Called always by one VRDP server thread. Can be thread-unsafe.
  */
-void Display::VideoAccelVRDP (bool fEnable)
+void Display::i_VideoAccelVRDP(bool fEnable)
 {
     LogRelFlowFunc(("fEnable = %d\n", fEnable));
 
-    vbvaLock();
+    i_vbvaLock();
 
     int c = fEnable?
-                ASMAtomicIncS32 (&mcVideoAccelVRDPRefs):
-                ASMAtomicDecS32 (&mcVideoAccelVRDPRefs);
+                ASMAtomicIncS32(&mcVideoAccelVRDPRefs):
+                ASMAtomicDecS32(&mcVideoAccelVRDPRefs);
 
     Assert (c >= 0);
@@ -1722 +1675 @@
         mfu32SupportedOrders = 0;
 
-        vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders,
-                            maFramebuffers, mcMonitors);
+        i_vbvaSetMemoryFlags(mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders,
+                             maFramebuffers, mcMonitors);
 #ifdef VBOX_WITH_HGSMI
         /* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
@@ -1742 +1695 @@
         mfu32SupportedOrders = ~0;
 
-        vbvaSetMemoryFlags (mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders,
-                            maFramebuffers, mcMonitors);
+        i_vbvaSetMemoryFlags(mpVbvaMemory, mfVideoAccelEnabled, mfVideoAccelVRDP, mfu32SupportedOrders,
+                             maFramebuffers, mcMonitors);
 #ifdef VBOX_WITH_HGSMI
         /* Here is VRDP-IN thread. Process the request in vbvaUpdateBegin under DevVGA lock on an EMT. */
@@ -1756 +1709 @@
          * accel state. It remains enabled.
          */
-        Assert (mfVideoAccelVRDP == true);
-    }
-    vbvaUnlock();
-}
-
-static bool vbvaVerifyRingBuffer (VBVAMEMORY *pVbvaMemory)
+        Assert(mfVideoAccelVRDP == true);
+    }
+    i_vbvaUnlock();
+}
+
+static bool i_vbvaVerifyRingBuffer(VBVAMEMORY *pVbvaMemory)
 {
     return true;
 }
 
-static void vbvaFetchBytes (VBVAMEMORY *pVbvaMemory, uint8_t *pu8Dst, uint32_t cbDst)
+static void i_vbvaFetchBytes(VBVAMEMORY *pVbvaMemory, uint8_t *pu8Dst, uint32_t cbDst)
 {
     if (cbDst >= VBVA_RING_BUFFER_SIZE)
     {
-        AssertMsgFailed (("cbDst = 0x%08X, ring buffer size 0x%08X\n", cbDst, VBVA_RING_BUFFER_SIZE));
+        AssertMsgFailed(("cbDst = 0x%08X, ring buffer size 0x%08X\n", cbDst, VBVA_RING_BUFFER_SIZE));
         return;
     }
@@ -1786 +1739 @@
     {
         /* Chunk crosses buffer boundary. */
-        memcpy (pu8Dst, src, u32BytesTillBoundary);
-        memcpy (pu8Dst + u32BytesTillBoundary, &pVbvaMemory->au8RingBuffer[0], i32Diff);
+        memcpy(pu8Dst, src, u32BytesTillBoundary);
+        memcpy(pu8Dst + u32BytesTillBoundary, &pVbvaMemory->au8RingBuffer[0], i32Diff);
     }
 
@@ -1797 +1750 @@
 
 
-static bool vbvaPartialRead (uint8_t **ppu8, uint32_t *pcb, uint32_t cbRecord, VBVAMEMORY *pVbvaMemory)
+static bool i_vbvaPartialRead(uint8_t **ppu8, uint32_t *pcb, uint32_t cbRecord, VBVAMEMORY *pVbvaMemory)
 {
     uint8_t *pu8New;
@@ -1807 +1760 @@
     {
         Assert (*pcb);
-        pu8New = (uint8_t *)RTMemRealloc (*ppu8, cbRecord);
+        pu8New = (uint8_t *)RTMemRealloc(*ppu8, cbRecord);
     }
     else
     {
         Assert (!*pcb);
-        pu8New = (uint8_t *)RTMemAlloc (cbRecord);
+        pu8New = (uint8_t *)RTMemAlloc(cbRecord);
     }
 
@@ -1823 +1776 @@
         if (*ppu8)
         {
-            RTMemFree (*ppu8);
+            RTMemFree(*ppu8);
         }
 
@@ -1833 +1786 @@
 
     /* Fetch data from the ring buffer. */
-    vbvaFetchBytes (pVbvaMemory, pu8New + *pcb, cbRecord - *pcb);
+    i_vbvaFetchBytes(pVbvaMemory, pu8New + *pcb, cbRecord - *pcb);
 
     *ppu8 = pu8New;
@@ -1844 +1797 @@
  * For crossing boundary - allocate a buffer from heap.
  */
-bool Display::vbvaFetchCmd (VBVACMDHDR **ppHdr, uint32_t *pcbCmd)
+bool Display::i_vbvaFetchCmd(VBVACMDHDR **ppHdr, uint32_t *pcbCmd)
 {
     uint32_t indexRecordFirst = mpVbvaMemory->indexRecordFirst;
@@ -1854 +1807 @@
 #endif /* DEBUG_sunlover */
 
-    if (!vbvaVerifyRingBuffer (mpVbvaMemory))
+    if (!i_vbvaVerifyRingBuffer(mpVbvaMemory))
     {
         return false;
@@ -1877 +1830 @@
         /* There is a partial read in process. Continue with it. */
 
-        Assert (mpu8VbvaPartial);
+        Assert(mpu8VbvaPartial);
 
         LogFlowFunc(("continue partial record mcbVbvaPartial = %d cbRecord 0x%08X, first = %d, free = %d\n",
@@ -1885 +1838 @@
         {
             /* New data has been added to the record. */
-            if (!vbvaPartialRead (&mpu8VbvaPartial, &mcbVbvaPartial, cbRecord, mpVbvaMemory))
+            if (!i_vbvaPartialRead(&mpu8VbvaPartial, &mcbVbvaPartial, cbRecord, mpVbvaMemory))
             {
                 return false;
@@ -1905 +1858 @@
 #ifdef DEBUG_sunlover
             LogFlowFunc(("partial done ok, data = %d, free = %d\n",
-                          mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
+                         mpVbvaMemory->off32Data, mpVbvaMemory->off32Free));
 #endif /* DEBUG_sunlover */
         }
@@ -1919 +1872 @@
         {
             /* Partial read must be started. */
-            if (!vbvaPartialRead (&mpu8VbvaPartial, &mcbVbvaPartial, cbRecord, mpVbvaMemory))
+            if (!i_vbvaPartialRead(&mpu8VbvaPartial, &mcbVbvaPartial, cbRecord, mpVbvaMemory))
             {
                 return false;
@@ -1955 +1908 @@
         {
             /* The command crosses buffer boundary. Rare case, so not optimized. */
-            uint8_t *dst = (uint8_t *)RTMemAlloc (cbRecord);
+            uint8_t *dst = (uint8_t *)RTMemAlloc(cbRecord);
 
             if (!dst)
@@ -1964 +1917 @@
             }
 
-            vbvaFetchBytes (mpVbvaMemory, dst, cbRecord);
+            i_vbvaFetchBytes(mpVbvaMemory, dst, cbRecord);
 
             *ppHdr = (VBVACMDHDR *)dst;
@@ -1987 +1940 @@
 }
 
-void Display::vbvaReleaseCmd (VBVACMDHDR *pHdr, int32_t cbCmd)
+void Display::i_vbvaReleaseCmd(VBVACMDHDR *pHdr, int32_t cbCmd)
 {
     uint8_t *au8RingBuffer = mpVbvaMemory->au8RingBuffer;
@@ -1995 +1948 @@
     {
         /* The pointer is inside ring buffer. Must be continuous chunk. */
-        Assert (VBVA_RING_BUFFER_SIZE - ((uint8_t *)pHdr - au8RingBuffer) >= cbCmd);
+        Assert(VBVA_RING_BUFFER_SIZE - ((uint8_t *)pHdr - au8RingBuffer) >= cbCmd);
 
         /* Do nothing. */
 
-        Assert (!mpu8VbvaPartial && mcbVbvaPartial == 0);
+        Assert(!mpu8VbvaPartial && mcbVbvaPartial == 0);
     }
     else
@@ -2016 +1969 @@
         else
         {
-            Assert (!mpu8VbvaPartial && mcbVbvaPartial == 0);
-        }
-
-        RTMemFree (pHdr);
+            Assert(!mpu8VbvaPartial && mcbVbvaPartial == 0);
+        }
+
+        RTMemFree(pHdr);
     }
 
@@ -2032 +1985 @@
  * @thread EMT
  */
-void Display::VideoAccelFlush (void)
-{
-    vbvaLock();
-    int rc = videoAccelFlush();
+void Display::i_VideoAccelFlush(void)
+{
+    i_vbvaLock();
+    int rc = i_videoAccelFlush();
     if (RT_FAILURE(rc))
     {
         /* Disable on errors. */
-        videoAccelEnable(false, NULL);
-    }
-    vbvaUnlock();
+        i_videoAccelEnable(false, NULL);
+    }
+    i_vbvaUnlock();
 
     if (RT_FAILURE(rc))
     {
         /* VideoAccel was disabled because of a failure, switching back to VGA updates. Redraw the screen. */
-        Assert(!vbvaLockIsOwner());
+        Assert(!i_vbvaLockIsOwner());
         mpDrv->pUpPort->pfnUpdateDisplayAll(mpDrv->pUpPort, /* fFailOnResize = */ false);
     }
 }
 
-int Display::videoAccelFlush (void)
-{
-    Assert(vbvaLockIsOwner());
+int Display::i_videoAccelFlush(void)
+{
+    Assert(i_vbvaLockIsOwner());
 
 #ifdef DEBUG_sunlover_2
@@ -2085 +2038 @@
     /* Initialize dirty rectangles accumulator. */
     VBVADIRTYREGION rgn;
-    vbvaRgnInit (&rgn, maFramebuffers, mcMonitors, this, mpDrv->pUpPort);
+    vbvaRgnInit(&rgn, maFramebuffers, mcMonitors, this, mpDrv->pUpPort);
 
     for (;;)
@@ -2093 +2046 @@
 
         /* Fetch the command data. */
-        if (!vbvaFetchCmd (&phdr, &cbCmd))
+        if (!i_vbvaFetchCmd(&phdr, &cbCmd))
         {
             Log(("Display::VideoAccelFlush: unable to fetch command. off32Data = %d, off32Free = %d. Disabling VBVA!!!\n",
@@ -2142 +2095 @@
 
             /* Accumulate the update. */
-            vbvaRgnDirtyRect (&rgn, uScreenId, phdr);
+            vbvaRgnDirtyRect(&rgn, uScreenId, phdr);
 
             /* Forward the command to VRDP server. */
-            mParent->i_consoleVRDPServer()->SendUpdate (uScreenId, phdr, cbCmd);
+            mParent->i_consoleVRDPServer()->SendUpdate(uScreenId, phdr, cbCmd);
 
             *phdr = hdrSaved;
         }
 
-        vbvaReleaseCmd (phdr, cbCmd);
+        i_vbvaReleaseCmd(phdr, cbCmd);
     }
 
@@ -2156 +2109 @@
     {
         /* Draw the framebuffer. */
-        vbvaRgnUpdateFramebuffer (&rgn, uScreenId);
+        vbvaRgnUpdateFramebuffer(&rgn, uScreenId);
     }
     return VINF_SUCCESS;
 }
 
-int Display::videoAccelRefreshProcess(void)
+int Display::i_videoAccelRefreshProcess(void)
 {
     int rc = VWRN_INVALID_STATE; /* Default is to do a display update in VGA device. */
 
-    vbvaLock();
+    i_vbvaLock();
 
     if (ASMAtomicCmpXchgU32(&mfu32PendingVideoAccelDisable, false, true))
     {
-        videoAccelEnable (false, NULL);
+        i_videoAccelEnable(false, NULL);
     }
     else if (mfPendingVideoAccelEnable)
@@ -2184 +2137 @@
         if (mfMachineRunning)
         {
-            videoAccelEnable (mfPendingVideoAccelEnable,
-                              mpPendingVbvaMemory);
+            i_videoAccelEnable(mfPendingVideoAccelEnable,
+                               mpPendingVbvaMemory);
 
             /* Reset the pending state. */
@@ -2201 +2154 @@
         {
             Assert(mpVbvaMemory);
-            rc = videoAccelFlush();
+            rc = i_videoAccelFlush();
             if (RT_FAILURE(rc))
             {
                 /* Disable on errors. */
-                videoAccelEnable(false, NULL);
+                i_videoAccelEnable(false, NULL);
                 rc = VWRN_INVALID_STATE; /* Do a display update in VGA device. */
             }
@@ -2215 +2168 @@
     }
 
-    vbvaUnlock();
+    i_vbvaUnlock();
 
     return rc;
 }
 
-void Display::notifyPowerDown(void)
+void Display::i_notifyPowerDown(void)
 {
     LogRelFlowFunc(("\n"));
@@ -2238 +2191 @@
         if (!pFBInfo->fDisabled)
         {
-            handleDisplayResize(uScreenId, 32,
-                                pFBInfo->pu8FramebufferVRAM,
-                                pFBInfo->u32LineSize,
-                                pFBInfo->w,
-                                pFBInfo->h,
-                                pFBInfo->flags);
-        }
-    }
-}
-
-// IDisplay methods
+            i_handleDisplayResize(uScreenId, 32,
+                                  pFBInfo->pu8FramebufferVRAM,
+                                  pFBInfo->u32LineSize,
+                                  pFBInfo->w,
+                                  pFBInfo->h,
+                                  pFBInfo->flags);
+        }
+    }
+}
+
+// Wrapped IDisplay methods
 /////////////////////////////////////////////////////////////////////////////
-STDMETHODIMP Display::GetScreenResolution(ULONG aScreenId,
-                                          ULONG *aWidth, ULONG *aHeight, ULONG *aBitsPerPixel,
-                                          LONG *aXOrigin, LONG *aYOrigin)
+HRESULT Display::getScreenResolution(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ULONG *aBitsPerPixel,
+                                     LONG *aXOrigin, LONG *aYOrigin)
 {
     LogRelFlowFunc(("aScreenId=%RU32\n", aScreenId));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2276 +2225 @@
             alock.release();
 
-            Assert(!vbvaLockIsOwner());
+            Assert(!i_vbvaLockIsOwner());
             int rc = mpDrv->pUpPort->pfnQueryColorDepth(mpDrv->pUpPort, &u32BitsPerPixel);
             AssertRC(rc);
@@ -2311 +2260 @@
 }
 
-STDMETHODIMP Display::AttachFramebuffer(ULONG aScreenId,
-                                        IFramebuffer *aFramebuffer)
+
+HRESULT Display::attachFramebuffer(ULONG aScreenId, const ComPtr<IFramebuffer> &aFramebuffer)
 {
     LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
-
-    CheckComArgPointerValid(aFramebuffer);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc()))
-        return autoCaller.rc();
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2341 +2284 @@
     {
         /* Setup the new framebuffer. */
-        handleDisplayResize(aScreenId, pFBInfo->u16BitsPerPixel,
-                            pFBInfo->pu8FramebufferVRAM,
-                            pFBInfo->u32LineSize,
-                            pFBInfo->w,
-                            pFBInfo->h,
-                            pFBInfo->flags);
+        i_handleDisplayResize(aScreenId, pFBInfo->u16BitsPerPixel,
+                              pFBInfo->pu8FramebufferVRAM,
+                              pFBInfo->u32LineSize,
+                              pFBInfo->w,
+                              pFBInfo->h,
+                              pFBInfo->flags);
     }
 
@@ -2366 +2309 @@
             data.aParms[0].u.uint32 = aScreenId;
 
-            int vrc = crCtlSubmitSync(&data.Hdr, sizeof(data));
+            int vrc = i_crCtlSubmitSync(&data.Hdr, sizeof(data));
             AssertRC(vrc);
         }
 #endif /* defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL) */
 
-        VMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::InvalidateAndUpdateEMT,
+        VMR3ReqCallNoWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
                            3, this, aScreenId, false);
     }
@@ -2379 +2322 @@
 }
 
-STDMETHODIMP Display::DetachFramebuffer(ULONG aScreenId)
+HRESULT Display::detachFramebuffer(ULONG aScreenId)
 {
     LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc()))
-        return autoCaller.rc();
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2416 +2355 @@
             data.aParms[0].u.uint32 = aScreenId;
 
-            int vrc = crCtlSubmitSync(&data.Hdr, sizeof(data));
+            int vrc = i_crCtlSubmitSync(&data.Hdr, sizeof(data));
             AssertRC(vrc);
         }
@@ -2425 +2364 @@
 }
 
-STDMETHODIMP Display::QueryFramebuffer(ULONG aScreenId,
-                                       IFramebuffer **aFramebuffer)
+HRESULT Display::queryFramebuffer(ULONG aScreenId, ComPtr<IFramebuffer> &aFramebuffer)
 {
     LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
-
-    CheckComArgOutPointerValid(aFramebuffer);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc()))
-        return autoCaller.rc();
 
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2444 +2376 @@
     DISPLAYFBINFO *pFBInfo = &maFramebuffers[aScreenId];
 
-    *aFramebuffer = pFBInfo->pFramebuffer;
-    if (!pFBInfo->pFramebuffer.isNull())
-        pFBInfo->pFramebuffer->AddRef();
+    pFBInfo->pFramebuffer.queryInterfaceTo(aFramebuffer.asOutParam());
 
     return S_OK;
 }
 
-STDMETHODIMP Display::SetVideoModeHint(ULONG aDisplay, BOOL aEnabled,
-                                       BOOL aChangeOrigin, LONG aOriginX, LONG aOriginY,
-                                       ULONG aWidth, ULONG aHeight, ULONG aBitsPerPixel)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Display::setVideoModeHint(ULONG aDisplay, BOOL aEnabled,
+                                  BOOL aChangeOrigin, LONG aOriginX, LONG aOriginY,
+                                  ULONG aWidth, ULONG aHeight, ULONG aBitsPerPixel)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -2477 +2404 @@
 
         uint32_t cBits = 0;
-        Assert(!vbvaLockIsOwner());
+        Assert(!i_vbvaLockIsOwner());
         int rc = mpDrv->pUpPort->pfnQueryColorDepth(mpDrv->pUpPort, &cBits);
         AssertRC(rc);
@@ -2512 +2439 @@
 }
 
-STDMETHODIMP Display::SetSeamlessMode (BOOL enabled)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
+HRESULT Display::setSeamlessMode(BOOL enabled)
+{
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
@@ -2540 +2464 @@
         if (is3denabled && vmmDev)
         {
-            VBOXCRCMDCTL_HGCM *pData = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof (VBOXCRCMDCTL_HGCM));
+            VBOXCRCMDCTL_HGCM *pData = (VBOXCRCMDCTL_HGCM*)RTMemAlloc(sizeof(VBOXCRCMDCTL_HGCM));
             if (!pData)
             {
@@ -2554 +2478 @@
             pData->aParms[0].u.pointer.size = 0; /* <- means null rects, NULL pRects address and 0 rects means "disable" */
 
-            int rc = crCtlSubmit(&pData->Hdr, sizeof (*pData), displayCrCmdFree, pData);
+            int rc = i_crCtlSubmit(&pData->Hdr, sizeof(*pData), i_displayCrCmdFree, pData);
             if (!RT_SUCCESS(rc))
             {
@@ -2567 +2491 @@
 
 #if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-BOOL Display::displayCheckTakeScreenshotCrOgl(Display *pDisplay, ULONG aScreenId, uint8_t *pu8Data,
-                                              uint32_t u32Width, uint32_t u32Height)
+BOOL Display::i_displayCheckTakeScreenshotCrOgl(Display *pDisplay, ULONG aScreenId, uint8_t *pu8Data,
+                                                uint32_t u32Width, uint32_t u32Height)
 {
     BOOL is3denabled;
@@ -2577 +2501 @@
         if (pVMMDev)
         {
-            CRVBOXHGCMTAKESCREENSHOT *pScreenshot = (CRVBOXHGCMTAKESCREENSHOT*)RTMemAlloc(sizeof (*pScreenshot));
+            CRVBOXHGCMTAKESCREENSHOT *pScreenshot = (CRVBOXHGCMTAKESCREENSHOT*)RTMemAlloc(sizeof(*pScreenshot));
             if (pScreenshot)
             {
@@ -2597 +2521 @@
                 data.aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
                 data.aParms[0].u.pointer.addr = pScreenshot;
-                data.aParms[0].u.pointer.size = sizeof (*pScreenshot);
-
-                int rc = pDisplay->crCtlSubmitSync(&data.Hdr, sizeof (data));
+                data.aParms[0].u.pointer.size = sizeof(*pScreenshot);
+
+                int rc = pDisplay->i_crCtlSubmitSync(&data.Hdr, sizeof(data));
 
                 RTMemFree(pScreenshot);
@@ -2617 +2541 @@
 #endif
 
-int Display::displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppu8Data, size_t *pcbData,
-                                      uint32_t *pu32Width, uint32_t *pu32Height)
+int Display::i_displayTakeScreenshotEMT(Display *pDisplay, ULONG aScreenId, uint8_t **ppu8Data, size_t *pcbData,
+                                        uint32_t *pu32Width, uint32_t *pu32Height)
 {
     int rc;
@@ -2625 +2549 @@
         && pDisplay->maFramebuffers[aScreenId].fVBVAEnabled == false) /* A non-VBVA mode. */
     {
-        Assert(!pDisplay->vbvaLockIsOwner());
+        Assert(!pDisplay->i_vbvaLockIsOwner());
         rc = pDisplay->mpDrv->pUpPort->pfnTakeScreenshot(pDisplay->mpDrv->pUpPort, ppu8Data, pcbData, pu32Width, pu32Height);
     }
@@ -2665 +2589 @@
                 uint32_t u32DstBitsPerPixel = 32;
 
-                Assert(!pDisplay->vbvaLockIsOwner());
+                Assert(!pDisplay->i_vbvaLockIsOwner());
                 rc = pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
                                                            width, height,
@@ -2691 +2615 @@
                         && aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
                     {
-                        Assert(!pDisplay->vbvaLockIsOwner());
+                        Assert(!pDisplay->i_vbvaLockIsOwner());
                         rc = pDisplay->mpDrv->pUpPort->pfnTakeScreenshot(pDisplay->mpDrv->pUpPort,
                                                                          ppu8Data, pcbData, pu32Width, pu32Height);
@@ -2716 +2640 @@
 }
 
-static int displayTakeScreenshot(PUVM pUVM, Display *pDisplay, struct DRVMAINDISPLAY *pDrv, ULONG aScreenId,
-                                 BYTE *address, ULONG width, ULONG height)
+static int i_displayTakeScreenshot(PUVM pUVM, Display *pDisplay, struct DRVMAINDISPLAY *pDrv, ULONG aScreenId,
+                                   BYTE *address, ULONG width, ULONG height)
 {
     uint8_t *pu8Data = NULL;
@@ -2726 +2650 @@
 
 # if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-    if (Display::displayCheckTakeScreenshotCrOgl(pDisplay, aScreenId, (uint8_t*)address, width, height))
+    if (Display::i_displayCheckTakeScreenshotCrOgl(pDisplay, aScreenId, (uint8_t*)address, width, height))
         return VINF_SUCCESS;
 #endif
@@ -2737 +2661 @@
                  it would be nice to have an accurate screenshot for the bug
                  report if the VM deadlocks. */
-        vrc = VMR3ReqPriorityCallWaitU(pUVM, VMCPUID_ANY, (PFNRT)Display::displayTakeScreenshotEMT, 6,
+        vrc = VMR3ReqPriorityCallWaitU(pUVM, VMCPUID_ANY, (PFNRT)Display::i_displayTakeScreenshotEMT, 6,
                                        pDisplay, aScreenId, &pu8Data, &cbData, &cx, &cy);
         if (vrc != VERR_TRY_AGAIN)
@@ -2777 +2701 @@
         {
             /* This can be called from any thread. */
-            Assert(!pDisplay->vbvaLockIsOwner());
+            Assert(!pDisplay->i_vbvaLockIsOwner());
             pDrv->pUpPort->pfnFreeScreenshot(pDrv->pUpPort, pu8Data);
         }
@@ -2789 +2713 @@
 }
 
-STDMETHODIMP Display::TakeScreenShot(ULONG aScreenId, BYTE *address, ULONG width, ULONG height)
+HRESULT Display::takeScreenShot(ULONG aScreenId, BYTE *aAddress, ULONG aWidth, ULONG aHeight)
 {
     /// @todo (r=dmik) this function may take too long to complete if the VM
@@ -2798 +2722 @@
 
     LogRelFlowFunc(("address=%p, width=%d, height=%d\n",
-                    address, width, height));
-
-    CheckComArgNotNull(address);
-    CheckComArgExpr(width, width != 0);
-    CheckComArgExpr(height, height != 0);
+                    aAddress, aWidth, aHeight));
+
+    CheckComArgExpr(aWidth, aWidth != 0);
+    CheckComArgExpr(aHeight, aHeight != 0);
 
     /* Do not allow too large screenshots. This also filters out negative
      * values passed as either 'width' or 'height'.
      */
-    CheckComArgExpr(width, width <= 32767);
-    CheckComArgExpr(height, height <= 32767);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+    CheckComArgExpr(aWidth, aWidth <= 32767);
+    CheckComArgExpr(aHeight, aHeight <= 32767);
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2833 +2753 @@
     alock.release();
 
-    int vrc = displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, address, width, height);
+    int vrc = i_displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, aAddress, aWidth, aHeight);
 
     if (vrc == VERR_NOT_IMPLEMENTED)
@@ -2849 +2769 @@
 }
 
-STDMETHODIMP Display::TakeScreenShotToArray(ULONG aScreenId, ULONG width, ULONG height,
-                                            ComSafeArrayOut(BYTE, aScreenData))
-{
-    LogRelFlowFunc(("width=%d, height=%d\n", width, height));
-
-    CheckComArgOutSafeArrayPointerValid(aScreenData);
-    CheckComArgExpr(width, width != 0);
-    CheckComArgExpr(height, height != 0);
+HRESULT Display::takeScreenShotToArray(ULONG aScreenId, ULONG aWidth, ULONG aHeight, std::vector<BYTE> &aScreenData)
+
+{
+    LogRelFlowFunc(("width=%d, height=%d\n", aWidth, aHeight));
+
+    CheckComArgExpr(aWidth, aWidth != 0);
+    CheckComArgExpr(raHeight, aHeight != 0);
 
     /* Do not allow too large screenshots. This also filters out negative
      * values passed as either 'width' or 'height'.
      */
-    CheckComArgExpr(width, width <= 32767);
-    CheckComArgExpr(height, height <= 32767);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+    CheckComArgExpr(aWidth, aWidth <= 32767);
+    CheckComArgExpr(aHeight, aHeight <= 32767);
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2887 +2803 @@
     alock.release();
 
-    size_t cbData = width * 4 * height;
+    size_t cbData = aWidth * 4 * aHeight;
     uint8_t *pu8Data = (uint8_t *)RTMemAlloc(cbData);
 
@@ -2893 +2809 @@
         return E_OUTOFMEMORY;
 
-    int vrc = displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, pu8Data, width, height);
+    int vrc = i_displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, pu8Data, aWidth, aHeight);
 
     if (RT_SUCCESS(vrc))
     {
-        /* Convert pixels to format expected by the API caller: [0] R, [1] G, [2] B, [3] A. */
+        aScreenData.resize(cbData);
+
+        /* Convert pixels to format expected by the API caller: [0] R, [1] G, [2] B, [3] A
+         * and copy to the output buffer.
+         */
+        size_t i = 0;
         uint8_t *pu8 = pu8Data;
-        unsigned cPixels = width * height;
+        unsigned cPixels = aWidth * aHeight;
         while (cPixels)
         {
-            uint8_t u8 = pu8[0];
-            pu8[0] = pu8[2];
-            pu8[2] = u8;
-            pu8[3] = 0xff;
+            aScreenData[i++] = pu8[2];
+            aScreenData[i++] = pu8[1];
+            aScreenData[i++] = pu8[0];
+            aScreenData[i++] = 0xff;
+
             cPixels--;
             pu8 += 4;
         }
-
-        com::SafeArray<BYTE> screenData(cbData);
-        screenData.initFrom(pu8Data, cbData);
-        screenData.detachTo(ComSafeArrayOutArg(aScreenData));
     }
     else if (vrc == VERR_NOT_IMPLEMENTED)
@@ -2927 +2845 @@
 }
 
-STDMETHODIMP Display::TakeScreenShotPNGToArray(ULONG aScreenId, ULONG width, ULONG height,
-                                               ComSafeArrayOut(BYTE, aScreenData))
-{
-    LogRelFlowFunc(("width=%d, height=%d\n", width, height));
-
-    CheckComArgOutSafeArrayPointerValid(aScreenData);
-    CheckComArgExpr(width, width != 0);
-    CheckComArgExpr(height, height != 0);
+HRESULT Display::takeScreenShotPNGToArray(ULONG aScreenId, ULONG aWidth, ULONG aHeight, std::vector<BYTE> &aScreenData)
+{
+    LogRelFlowFunc(("width=%d, height=%d\n", aWidth, aHeight));
+
+    CheckComArgExpr(aWidth, aWidth != 0);
+    CheckComArgExpr(aHeight, aHeight != 0);
 
     /* Do not allow too large screenshots. This also filters out negative
      * values passed as either 'width' or 'height'.
      */
-    CheckComArgExpr(width, width <= 32767);
-    CheckComArgExpr(height, height <= 32767);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+    CheckComArgExpr(aWidth, aWidth <= 32767);
+    CheckComArgExpr(aHeight, aHeight <= 32767);
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -2964 +2877 @@
     alock.release();
 
-    size_t cbData = width * 4 * height;
+    size_t cbData = aWidth * 4 * aHeight;
     uint8_t *pu8Data = (uint8_t *)RTMemAlloc(cbData);
 
@@ -2970 +2883 @@
         return E_OUTOFMEMORY;
 
-    int vrc = displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, pu8Data, width, height);
+    int vrc = i_displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, pu8Data, aWidth, aHeight);
 
     if (RT_SUCCESS(vrc))
@@ -2979 +2892 @@
         uint32_t cyPNG = 0;
 
-        vrc = DisplayMakePNG(pu8Data, width, height, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
+        vrc = DisplayMakePNG(pu8Data, aWidth, aHeight, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
         if (RT_SUCCESS(vrc))
         {
-            com::SafeArray<BYTE> screenData(cbPNG);
-            screenData.initFrom(pu8PNG, cbPNG);
+            aScreenData.resize(cbPNG);
+            memcpy(&aScreenData.front(), pu8PNG, cbPNG);
             if (pu8PNG)
                 RTMemFree(pu8PNG);
-
-            screenData.detachTo(ComSafeArrayOutArg(aScreenData));
         }
         else
@@ -3010 +2921 @@
 }
 
-int Display::VideoCaptureEnableScreens(ComSafeArrayIn(BOOL, aScreens))
+
+int Display::i_VideoCaptureEnableScreens(ComSafeArrayIn(BOOL, aScreens))
 {
 #ifdef VBOX_WITH_VPX
@@ -3025 +2937 @@
  * Start video capturing. Does nothing if capturing is already active.
  */
-int Display::VideoCaptureStart()
+int Display::i_VideoCaptureStart()
 {
 #ifdef VBOX_WITH_VPX
@@ -3124 +3036 @@
  * Stop video capturing. Does nothing if video capturing is not active.
  */
-void Display::VideoCaptureStop()
+void Display::i_VideoCaptureStop()
 {
 #ifdef VBOX_WITH_VPX
@@ -3134 +3046 @@
 }
 
-int Display::drawToScreenEMT(Display *pDisplay, ULONG aScreenId, BYTE *address,
-                             ULONG x, ULONG y, ULONG width, ULONG height)
+int Display::i_drawToScreenEMT(Display *pDisplay, ULONG aScreenId, BYTE *address,
+                               ULONG x, ULONG y, ULONG width, ULONG height)
 {
     int rc = VINF_SUCCESS;
@@ -3143 +3055 @@
     if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
     {
-        Assert(!pDisplay->vbvaLockIsOwner());
+        Assert(!pDisplay->i_vbvaLockIsOwner());
         rc = pDisplay->mpDrv->pUpPort->pfnDisplayBlt(pDisplay->mpDrv->pUpPort, address, x, y, width, height);
     }
@@ -3165 +3077 @@
         uint32_t u32DstBitsPerPixel = pFBInfo->u16BitsPerPixel;
 
-        Assert(!pDisplay->vbvaLockIsOwner());
+        Assert(!pDisplay->i_vbvaLockIsOwner());
         rc = pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
                                                    width, height,
@@ -3218 +3130 @@
                         u32DstBitsPerPixel = 32;
 
-                        Assert(!pDisplay->vbvaLockIsOwner());
+                        Assert(!pDisplay->i_vbvaLockIsOwner());
                         pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
                                                               width, height,
@@ -3233 +3145 @@
             }
 
-            pDisplay->handleDisplayUpdate(aScreenId, x, y, width, height);
+            pDisplay->i_handleDisplayUpdate(aScreenId, x, y, width, height);
         }
     }
@@ -3247 +3159 @@
 }
 
-STDMETHODIMP Display::DrawToScreen(ULONG aScreenId, BYTE *address,
-                                   ULONG x, ULONG y, ULONG width, ULONG height)
+HRESULT Display::drawToScreen(ULONG aScreenId, BYTE *aAddress, ULONG aX, ULONG aY, ULONG aWidth, ULONG aHeight)
 {
     /// @todo (r=dmik) this function may take too long to complete if the VM
@@ -3256 +3167 @@
     //  within the Console lock to make it atomic).
 
-    LogRelFlowFunc(("address=%p, x=%d, y=%d, width=%d, height=%d\n",
-                  (void *)address, x, y, width, height));
-
-    CheckComArgNotNull(address);
-    CheckComArgExpr(width, width != 0);
-    CheckComArgExpr(height, height != 0);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+    LogRelFlowFunc(("aAddress=%p, x=%d, y=%d, width=%d, height=%d\n",
+                   (void *)aAddress, aX, aY, aWidth, aHeight));
+
+    CheckComArgExpr(aWidth, aWidth != 0);
+    CheckComArgExpr(aHeight, aHeight != 0);
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -3281 +3188 @@
      * dirty conversion work.
      */
-    int rcVBox = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::drawToScreenEMT, 7,
-                                  this, aScreenId, address, x, y, width, height);
+    int rcVBox = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_drawToScreenEMT, 7,
+                                  this, aScreenId, aAddress, aX, aY, aWidth, aHeight);
 
     /*
@@ -3308 +3215 @@
 }
 
-void Display::InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll)
+void Display::i_InvalidateAndUpdateEMT(Display *pDisplay, unsigned uId, bool fUpdateAll)
 {
     unsigned uScreenId;
@@ -3318 +3225 @@
             && uScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
         {
-            Assert(!pDisplay->vbvaLockIsOwner());
+            Assert(!pDisplay->i_vbvaLockIsOwner());
             pDisplay->mpDrv->pUpPort->pfnUpdateDisplayAll(pDisplay->mpDrv->pUpPort, /* fFailOnResize = */ true);
         }
@@ -3371 +3278 @@
                         if (ulWidth == pFBInfo->w && ulHeight == pFBInfo->h)
                         {
-
-                            Assert(!pDisplay->vbvaLockIsOwner());
+                            Assert(!pDisplay->i_vbvaLockIsOwner());
                             pDisplay->mpDrv->pUpPort->pfnCopyRect(pDisplay->mpDrv->pUpPort,
                                                                   width, height,
@@ -3387 +3293 @@
                 }
 
-                pDisplay->handleDisplayUpdate (uScreenId, 0, 0, pFBInfo->w, pFBInfo->h);
+                pDisplay->i_handleDisplayUpdate(uScreenId, 0, 0, pFBInfo->w, pFBInfo->h);
             }
         }
@@ -3401 +3307 @@
  * @returns COM status code
  */
-STDMETHODIMP Display::InvalidateAndUpdate()
+
+HRESULT Display::invalidateAndUpdate()
 {
     LogRelFlowFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
@@ -3424 +3328 @@
 
     /* pdm.h says that this has to be called from the EMT thread */
-    int rcVBox = VMR3ReqCallVoidWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::InvalidateAndUpdateEMT,
+    int rcVBox = VMR3ReqCallVoidWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
                                       3, this, 0, true);
     alock.acquire();
@@ -3436 +3340 @@
 }
 
-STDMETHODIMP Display::CompleteVHWACommand(BYTE *pCommand)
+HRESULT Display::completeVHWACommand(BYTE *aCommand)
 {
 #ifdef VBOX_WITH_VIDEOHWACCEL
-    mpDrv->pVBVACallbacks->pfnVHWACommandCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVHWACMD)pCommand);
+    mpDrv->pVBVACallbacks->pfnVHWACommandCompleteAsync(mpDrv->pVBVACallbacks, (PVBOXVHWACMD)aCommand);
     return S_OK;
 #else
@@ -3446 +3350 @@
 }
 
-STDMETHODIMP Display::ViewportChanged(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height)
+HRESULT Display::viewportChanged(ULONG aScreenId, ULONG aX, ULONG aY, ULONG aWidth, ULONG aHeight)
 {
 #if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
@@ -3461 +3365 @@
     if (is3denabled)
     {
-        int rc = crViewportNotify(aScreenId, x, y, width, height);
+        int rc = i_crViewportNotify(aScreenId, aX, aY, aWidth, aHeight);
         if (RT_FAILURE(rc))
         {
             DISPLAYFBINFO *pFb = &maFramebuffers[aScreenId];
             pFb->pendingViewportInfo.fPending = true;
-            pFb->pendingViewportInfo.x = x;
-            pFb->pendingViewportInfo.y = y;
-            pFb->pendingViewportInfo.width = width;
-            pFb->pendingViewportInfo.height = height;
+            pFb->pendingViewportInfo.x = aX;
+            pFb->pendingViewportInfo.y = aY;
+            pFb->pendingViewportInfo.width = aWidth;
+            pFb->pendingViewportInfo.height = aHeight;
         }
     }
@@ -3476 +3380 @@
 }
 
-STDMETHODIMP Display::QuerySourceBitmap(ULONG aScreenId,
-                                        IDisplaySourceBitmap **aDisplaySourceBitmap)
+HRESULT Display::querySourceBitmap(ULONG aScreenId,
+                                   ComPtr<IDisplaySourceBitmap> &aDisplaySourceBitmap)
 {
     LogRelFlowFunc(("aScreenId = %d\n", aScreenId));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     Console::SafeVMPtr ptrVM(mParent);
@@ -3499 +3400 @@
     if (!mfSourceBitmapEnabled)
     {
-        *aDisplaySourceBitmap = NULL;
+        aDisplaySourceBitmap = NULL;
         return E_FAIL;
     }
@@ -3512 +3413 @@
         hr = obj.createObject();
         if (SUCCEEDED(hr))
-        {
             hr = obj->init(this, aScreenId, pFBInfo);
-        }
 
         if (SUCCEEDED(hr))
         {
-            bool fDefaultFormat = !obj->usesVRAM();
+            bool fDefaultFormat = !obj->i_usesVRAM();
 
             if (aScreenId == VBOX_VIDEO_PRIMARY_SCREEN)
@@ -3556 +3455 @@
     if (SUCCEEDED(hr))
     {
-        pFBInfo->pSourceBitmap->AddRef();
-        *aDisplaySourceBitmap = pFBInfo->pSourceBitmap;
+        pFBInfo->pSourceBitmap.queryInterfaceTo(aDisplaySourceBitmap.asOutParam());
     }
 
@@ -3567 +3465 @@
         if (fSetRenderVRAM)
         {
-            Assert(!vbvaLockIsOwner());
+            Assert(!i_vbvaLockIsOwner());
             mpDrv->pUpPort->pfnSetRenderVRAM(mpDrv->pUpPort, true);
         }
 
         if (fInvalidate)
-            VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::InvalidateAndUpdateEMT,
+            VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::i_InvalidateAndUpdateEMT,
                              3, this, aScreenId, false);
     }
@@ -3580 +3478 @@
 }
 
-STDMETHODIMP Display::SetFramebufferUpdateMode(ULONG aScreenId,
-                                               FramebufferUpdateMode_T aFramebufferUpdateMode)
+HRESULT Display::setFramebufferUpdateMode(ULONG aScreenId, FramebufferUpdateMode_T aFramebufferUpdateMode)
 {
     LogRelFlowFunc(("aScreenId %d, aFramebufferUpdateMode %d\n", aScreenId, aFramebufferUpdateMode));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
     HRESULT hr = S_OK;
@@ -3642 +3536 @@
 }
 
+// wrapped IEventListener method
+HRESULT Display::handleEvent(const ComPtr<IEvent> &aEvent)
+{
+    VBoxEventType_T aType = VBoxEventType_Invalid;
+
+    aEvent->COMGETTER(Type)(&aType);
+    switch (aType)
+    {
+        case VBoxEventType_OnStateChanged:
+        {
+            ComPtr<IStateChangedEvent> scev = aEvent;
+            Assert(scev);
+            MachineState_T machineState;
+            scev->COMGETTER(State)(&machineState);
+            if (   machineState == MachineState_Running
+                || machineState == MachineState_Teleporting
+                || machineState == MachineState_LiveSnapshotting
+                || machineState == MachineState_DeletingSnapshotOnline
+                   )
+            {
+                LogRelFlowFunc(("Machine is running.\n"));
+
+                mfMachineRunning = true;
+
+#ifdef VBOX_WITH_CROGL
+                i_crOglWindowsShow(true);
+#endif
+            }
+            else
+            {
+                mfMachineRunning = false;
+
+#ifdef VBOX_WITH_CROGL
+                if (machineState == MachineState_Paused)
+                    i_crOglWindowsShow(false);
+#endif
+            }
+            break;
+        }
+        default:
+            AssertFailed();
+    }
+
+    return S_OK;
+}
+
 
 // private methods
@@ -3647 +3587 @@
 
 #if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-int Display::crViewportNotify(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height)
+int Display::i_crViewportNotify(ULONG aScreenId, ULONG x, ULONG y, ULONG width, ULONG height)
 {
     VMMDev *pVMMDev = mParent->i_getVMMDev();
@@ -3674 +3614 @@
     pData->aParms[4].u.uint32 = height;
 
-    return crCtlSubmitSyncIfHasDataForScreen(aScreenId, &pData->Hdr, (uint32_t)cbData);
+    return i_crCtlSubmitSyncIfHasDataForScreen(aScreenId, &pData->Hdr, (uint32_t)cbData);
 }
 #endif
 
 #ifdef VBOX_WITH_CRHGSMI
-void Display::setupCrHgsmiData(void)
+void Display::i_setupCrHgsmiData(void)
 {
     VMMDev *pVMMDev = mParent->i_getVMMDev();
@@ -3697 +3637 @@
         VBOXVDMACMD_CHROMIUM_CTL_CRHGSMI_SETUP_MAINCB Completion;
         Completion.Hdr.enmType = VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP_MAINCB;
-        Completion.Hdr.cbCmd = sizeof (Completion);
+        Completion.Hdr.cbCmd = sizeof(Completion);
         Completion.hCompletion = mpDrv->pVBVACallbacks;
         Completion.pfnCompletion = mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync;
@@ -3719 +3659 @@
 }
 
-void Display::destructCrHgsmiData(void)
+void Display::i_destructCrHgsmiData(void)
 {
     int rc = RTCritSectRwEnterExcl(&mCrOglLock);
@@ -3733 +3673 @@
  * @see PDMIDISPLAYCONNECTOR::pfnResize
  */
-DECLCALLBACK(int) Display::displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface,
-                                                 uint32_t bpp, void *pvVRAM, uint32_t cbLine, uint32_t cx, uint32_t cy)
+DECLCALLBACK(int) Display::i_displayResizeCallback(PPDMIDISPLAYCONNECTOR pInterface,
+                                                   uint32_t bpp, void *pvVRAM, uint32_t cbLine, uint32_t cx, uint32_t cy)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
@@ -3755 +3695 @@
     }
 
-    int rc = pThis->handleDisplayResize(VBOX_VIDEO_PRIMARY_SCREEN, bpp, pvVRAM, cbLine, cx, cy, VBVA_SCREEN_F_ACTIVE);
+    int rc = pThis->i_handleDisplayResize(VBOX_VIDEO_PRIMARY_SCREEN, bpp, pvVRAM, cbLine, cx, cy, VBVA_SCREEN_F_ACTIVE);
 
     /* Restore the flag.  */
@@ -3769 +3709 @@
  * @see PDMIDISPLAYCONNECTOR::pfnUpdateRect
  */
-DECLCALLBACK(void) Display::displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
-                                                  uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
+DECLCALLBACK(void) Display::i_displayUpdateCallback(PPDMIDISPLAYCONNECTOR pInterface,
+                                                    uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
@@ -3784 +3724 @@
      */
 
-    pDrv->pDisplay->handleDisplayUpdate(VBOX_VIDEO_PRIMARY_SCREEN, x, y, cx, cy);
+    pDrv->pDisplay->i_handleDisplayUpdate(VBOX_VIDEO_PRIMARY_SCREEN, x, y, cx, cy);
 }
 
@@ -3793 +3733 @@
  * @thread EMT
  */
-DECLCALLBACK(void) Display::displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface)
+DECLCALLBACK(void) Display::i_displayRefreshCallback(PPDMIDISPLAYCONNECTOR pInterface)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
@@ -3805 +3745 @@
     unsigned uScreenId;
 
-    int rc = pDisplay->videoAccelRefreshProcess();
+    int rc = pDisplay->i_videoAccelRefreshProcess();
     if (rc != VINF_TRY_AGAIN) /* Means 'do nothing' here. */
     {
@@ -3812 +3752 @@
             /* No VBVA do a display update. */
             DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[VBOX_VIDEO_PRIMARY_SCREEN];
-            Assert(!pDisplay->vbvaLockIsOwner());
+            Assert(!pDisplay->i_vbvaLockIsOwner());
             pDrv->pUpPort->pfnUpdateDisplay(pDrv->pUpPort);
         }
@@ -3826 +3766 @@
             DISPLAYFBINFO *pFBInfo = &pDisplay->maFramebuffers[uScreenId];
 
-            Assert (pDisplay->mParent && pDisplay->mParent->i_consoleVRDPServer());
-            pDisplay->mParent->i_consoleVRDPServer()->SendUpdate (uScreenId, NULL, 0);
+            Assert(pDisplay->mParent && pDisplay->mParent->i_consoleVRDPServer());
+            pDisplay->mParent->i_consoleVRDPServer()->SendUpdate(uScreenId, NULL, 0);
         }
     }
@@ -3852 +3792 @@
                         pData->aParms[0].type = VBOX_HGCM_SVC_PARM_PTR;
                         pData->aParms[0].u.pointer.addr = &pDisplay->mCrOglScreenshotData;
-                        pData->aParms[0].u.pointer.size = sizeof (pDisplay->mCrOglScreenshotData);
-                        rc = pDisplay->crCtlSubmit(&pData->Hdr, sizeof (*pData), displayCrCmdFree, pData);
+                        pData->aParms[0].u.pointer.size = sizeof(pDisplay->mCrOglScreenshotData);
+                        rc = pDisplay->i_crCtlSubmit(&pData->Hdr, sizeof(*pData), i_displayCrCmdFree, pData);
                         if (!RT_SUCCESS(rc))
                             AssertMsgFailed(("crCtlSubmit failed rc %d\n", rc));
@@ -3917 +3857 @@
  * @see PDMIDISPLAYCONNECTOR::pfnReset
  */
-DECLCALLBACK(void) Display::displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface)
+DECLCALLBACK(void) Display::i_displayResetCallback(PPDMIDISPLAYCONNECTOR pInterface)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
@@ -3924 +3864 @@
 
    /* Disable VBVA mode. */
-    pDrv->pDisplay->VideoAccelEnable (false, NULL);
+    pDrv->pDisplay->i_VideoAccelEnable(false, NULL);
 }
 
@@ -3932 +3872 @@
  * @see PDMIDISPLAYCONNECTOR::pfnLFBModeChange
  */
-DECLCALLBACK(void) Display::displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled)
+DECLCALLBACK(void) Display::i_displayLFBModeChangeCallback(PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
@@ -3950 +3890 @@
  * @see PDMIDISPLAYCONNECTOR::pfnProcessAdapterData
  */
-DECLCALLBACK(void) Display::displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM,
-                                                              uint32_t u32VRAMSize)
+DECLCALLBACK(void) Display::i_displayProcessAdapterDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM,
+                                                                uint32_t u32VRAMSize)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
@@ -3981 +3921 @@
          {
              pHdr = (VBOXVIDEOINFOHDR *)pu8;
-             pu8 += sizeof (VBOXVIDEOINFOHDR);
+             pu8 += sizeof(VBOXVIDEOINFOHDR);
 
              if (pu8 >= pu8End)
@@ -3991 +3931 @@
              if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_DISPLAY)
              {
-                 if (pHdr->u16Length != sizeof (VBOXVIDEOINFODISPLAY))
+                 if (pHdr->u16Length != sizeof(VBOXVIDEOINFODISPLAY))
                  {
                      LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "DISPLAY", pHdr->u16Length));
@@ -4016 +3956 @@
              else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_QUERY_CONF32)
              {
-                 if (pHdr->u16Length != sizeof (VBOXVIDEOINFOQUERYCONF32))
+                 if (pHdr->u16Length != sizeof(VBOXVIDEOINFOQUERYCONF32))
                  {
                      LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "CONF32", pHdr->u16Length));
@@ -4068 +4008 @@
  * @see PDMIDISPLAYCONNECTOR::pfnProcessDisplayData
  */
-DECLCALLBACK(void) Display::displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, unsigned uScreenId)
+DECLCALLBACK(void) Display::i_displayProcessDisplayDataCallback(PPDMIDISPLAYCONNECTOR pInterface,
+                                                                void *pvVRAM, unsigned uScreenId)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
@@ -4092 +4033 @@
     {
         pHdr = (VBOXVIDEOINFOHDR *)pu8;
-        pu8 += sizeof (VBOXVIDEOINFOHDR);
+        pu8 += sizeof(VBOXVIDEOINFOHDR);
 
         if (pu8 >= pu8End)
@@ -4102 +4043 @@
         if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_SCREEN)
         {
-            if (pHdr->u16Length != sizeof (VBOXVIDEOINFOSCREEN))
+            if (pHdr->u16Length != sizeof(VBOXVIDEOINFOSCREEN))
             {
                 LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "SCREEN", pHdr->u16Length));
@@ -4133 +4074 @@
                 }
 
-                pDrv->pDisplay->handleDisplayResize(uScreenId, pScreen->bitsPerPixel,
-                                                    (uint8_t *)pvVRAM + pFBInfo->u32Offset,
-                                                    pScreen->u32LineSize,
-                                                    pScreen->u16Width, pScreen->u16Height,
-                                                    VBVA_SCREEN_F_ACTIVE);
+                pDrv->pDisplay->i_handleDisplayResize(uScreenId, pScreen->bitsPerPixel,
+                                                      (uint8_t *)pvVRAM + pFBInfo->u32Offset,
+                                                      pScreen->u32LineSize,
+                                                      pScreen->u16Width, pScreen->u16Height,
+                                                      VBVA_SCREEN_F_ACTIVE);
             }
         }
@@ -4152 +4093 @@
         else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_HOST_EVENTS)
         {
-            if (pHdr->u16Length != sizeof (VBOXVIDEOINFOHOSTEVENTS))
+            if (pHdr->u16Length != sizeof(VBOXVIDEOINFOHOSTEVENTS))
             {
                 LogRel(("VBoxVideo: Guest display information %s invalid length %d!!!\n", "HOST_EVENTS", pHdr->u16Length));
@@ -4167 +4108 @@
         else if (pHdr->u8Type == VBOX_VIDEO_INFO_TYPE_LINK)
         {
-            if (pHdr->u16Length != sizeof (VBOXVIDEOINFOLINK))
+            if (pHdr->u16Length != sizeof(VBOXVIDEOINFOLINK))
             {
                 LogRel(("VBoxVideo: Guest adapter information %s invalid length %d!!!\n", "LINK", pHdr->u16Length));
@@ -4191 +4132 @@
 #endif
 
-int Display::handleVHWACommandProcess(PVBOXVHWACMD pCommand)
+int Display::i_handleVHWACommandProcess(PVBOXVHWACMD pCommand)
 {
     unsigned id = (unsigned)pCommand->iDisplay;
@@ -4218 +4159 @@
 }
 
-DECLCALLBACK(int) Display::displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
+DECLCALLBACK(int) Display::i_displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
 
-    return pDrv->pDisplay->handleVHWACommandProcess(pCommand);
+    return pDrv->pDisplay->i_handleVHWACommandProcess(pCommand);
 }
 #endif
 
 #ifdef VBOX_WITH_CRHGSMI
-void Display::handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
+void Display::i_handleCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
 {
     mpDrv->pVBVACallbacks->pfnCrHgsmiCommandCompleteAsync(mpDrv->pVBVACallbacks,
@@ -4233 +4174 @@
 }
 
-void Display::handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
+void Display::i_handleCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam)
 {
     PVBOXVDMACMD_CHROMIUM_CTL pCtl = (PVBOXVDMACMD_CHROMIUM_CTL)pParam->u.pointer.addr;
@@ -4239 +4180 @@
 }
 
-void Display::handleCrHgsmiCommandProcess(PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd)
+void Display::i_handleCrHgsmiCommandProcess(PVBOXVDMACMD_CHROMIUM_CMD pCmd, uint32_t cbCmd)
 {
     int rc = VERR_NOT_SUPPORTED;
@@ -4264 +4205 @@
 
     /* we are here because something went wrong with command processing, complete it */
-    handleCrHgsmiCommandCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CMD, &parm);
-}
-
-void Display::handleCrHgsmiControlProcess(PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl)
+    i_handleCrHgsmiCommandCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CMD, &parm);
+}
+
+void Display::i_handleCrHgsmiControlProcess(PVBOXVDMACMD_CHROMIUM_CTL pCtl, uint32_t cbCtl)
 {
     int rc = VERR_NOT_SUPPORTED;
@@ -4282 +4223 @@
             bool fCheckPendingViewport = (pCtl->enmType == VBOXVDMACMD_CHROMIUM_CTL_TYPE_CRHGSMI_SETUP);
             rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm,
-                                                Display::displayCrHgsmiControlCompletion, this);
+                                                Display::i_displayCrHgsmiControlCompletion, this);
             AssertRC(rc);
             if (RT_SUCCESS(rc))
@@ -4295 +4236 @@
                             continue;
 
-                        rc = crViewportNotify(ul, pFb->pendingViewportInfo.x, pFb->pendingViewportInfo.y,
+                        rc = i_crViewportNotify(ul, pFb->pendingViewportInfo.x, pFb->pendingViewportInfo.y,
                                               pFb->pendingViewportInfo.width, pFb->pendingViewportInfo.height);
                         if (RT_SUCCESS(rc))
@@ -4314 +4255 @@
 
     /* we are here because something went wrong with command processing, complete it */
-    handleCrHgsmiControlCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm);
-}
-
-DECLCALLBACK(void) Display::displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd,
-                                                         uint32_t cbCmd)
+    i_handleCrHgsmiControlCompletion(rc, SHCRGL_HOST_FN_CRHGSMI_CTL, &parm);
+}
+
+DECLCALLBACK(void) Display::i_displayCrHgsmiCommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd,
+                                                           uint32_t cbCmd)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
 
-    pDrv->pDisplay->handleCrHgsmiCommandProcess(pCmd, cbCmd);
-}
-
-DECLCALLBACK(void) Display::displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd,
-                                                         uint32_t cbCmd)
+    pDrv->pDisplay->i_handleCrHgsmiCommandProcess(pCmd, cbCmd);
+}
+
+DECLCALLBACK(void) Display::i_displayCrHgsmiControlProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd,
+                                                           uint32_t cbCmd)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
 
-    pDrv->pDisplay->handleCrHgsmiControlProcess(pCmd, cbCmd);
-}
-
-DECLCALLBACK(void) Display::displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
-                                                            void *pvContext)
+    pDrv->pDisplay->i_handleCrHgsmiControlProcess(pCmd, cbCmd);
+}
+
+DECLCALLBACK(void) Display::i_displayCrHgsmiCommandCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
+                                                              void *pvContext)
 {
     AssertMsgFailed(("not expected!"));
     Display *pDisplay = (Display *)pvContext;
-    pDisplay->handleCrHgsmiCommandCompletion(result, u32Function, pParam);
-}
-
-DECLCALLBACK(void) Display::displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
-                                                            void *pvContext)
+    pDisplay->i_handleCrHgsmiCommandCompletion(result, u32Function, pParam);
+}
+
+DECLCALLBACK(void) Display::i_displayCrHgsmiControlCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
+                                                              void *pvContext)
 {
     Display *pDisplay = (Display *)pvContext;
-    pDisplay->handleCrHgsmiControlCompletion(result, u32Function, pParam);
+    pDisplay->i_handleCrHgsmiControlCompletion(result, u32Function, pParam);
 
 }
@@ -4351 +4292 @@
 
 #if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-DECLCALLBACK(void)  Display::displayCrHgcmCtlSubmitCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
-                                                              void *pvContext)
+DECLCALLBACK(void)  Display::i_displayCrHgcmCtlSubmitCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam,
+                                                                void *pvContext)
 {
     VBOXCRCMDCTL *pCmd = (VBOXCRCMDCTL*)pParam->u.pointer.addr;
@@ -4359 +4300 @@
 }
 
-int  Display::handleCrHgcmCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
+int  Display::i_handleCrHgcmCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
                                     PFNCRCTLCOMPLETION pfnCompletion,
                                     void *pvCompletion)
@@ -4377 +4318 @@
 
     pCmd->u.pfnInternal = (void(*)())pfnCompletion;
-    int rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CTL, &parm, displayCrHgcmCtlSubmitCompletion,
+    int rc = pVMMDev->hgcmHostFastCallAsync(mhCrOglSvc, SHCRGL_HOST_FN_CTL, &parm, i_displayCrHgcmCtlSubmitCompletion,
                                             pvCompletion);
     if (!RT_SUCCESS(rc))
@@ -4385 +4326 @@
 }
 
-DECLCALLBACK(int)  Display::displayCrHgcmCtlSubmit(PPDMIDISPLAYCONNECTOR pInterface,
-                                    struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
-                                    PFNCRCTLCOMPLETION pfnCompletion,
-                                    void *pvCompletion)
+DECLCALLBACK(int)  Display::i_displayCrHgcmCtlSubmit(PPDMIDISPLAYCONNECTOR pInterface,
+                                                     struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd,
+                                                     PFNCRCTLCOMPLETION pfnCompletion,
+                                                     void *pvCompletion)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
     Display *pThis = pDrv->pDisplay;
-    return pThis->handleCrHgcmCtlSubmit(pCmd, cbCmd, pfnCompletion, pvCompletion);
-}
-
-int Display::crCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion)
+    return pThis->i_handleCrHgcmCtlSubmit(pCmd, cbCmd, pfnCompletion, pvCompletion);
+}
+
+int Display::i_crCtlSubmit(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd, PFNCRCTLCOMPLETION pfnCompletion, void *pvCompletion)
 {
     int rc = RTCritSectRwEnterShared(&mCrOglLock);
@@ -4410 +4351 @@
 }
 
-int Display::crCtlSubmitSync(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
+int Display::i_crCtlSubmitSync(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
 {
     int rc = RTCritSectRwEnterShared(&mCrOglLock);
@@ -4425 +4366 @@
 }
 
-int Display::crCtlSubmitAsyncCmdCopy(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
+int Display::i_crCtlSubmitAsyncCmdCopy(struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
 {
     VBOXCRCMDCTL* pCmdCopy = (VBOXCRCMDCTL*)RTMemAlloc(cbCmd);
@@ -4436 +4377 @@
     memcpy(pCmdCopy, pCmd, cbCmd);
 
-    int rc = crCtlSubmit(pCmdCopy, cbCmd, displayCrCmdFree, pCmdCopy);
+    int rc = i_crCtlSubmit(pCmdCopy, cbCmd, i_displayCrCmdFree, pCmdCopy);
     if (RT_FAILURE(rc))
     {
@@ -4447 +4388 @@
 }
 
-int Display::crCtlSubmitSyncIfHasDataForScreen(uint32_t u32ScreenID, struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
+int Display::i_crCtlSubmitSyncIfHasDataForScreen(uint32_t u32ScreenID, struct VBOXCRCMDCTL* pCmd, uint32_t cbCmd)
 {
     int rc = RTCritSectRwEnterShared(&mCrOglLock);
@@ -4453 +4394 @@
 
     if (mCrOglCallbacks.pfnHasDataForScreen && mCrOglCallbacks.pfnHasDataForScreen(u32ScreenID))
-        rc = crCtlSubmitSync(pCmd, cbCmd);
+        rc = i_crCtlSubmitSync(pCmd, cbCmd);
     else
-        rc = crCtlSubmitAsyncCmdCopy(pCmd, cbCmd);
+        rc = i_crCtlSubmitAsyncCmdCopy(pCmd, cbCmd);
 
     RTCritSectRwLeaveShared(&mCrOglLock);
@@ -4462 +4403 @@
 }
 
-bool  Display::handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t u64TimeStamp)
+bool  Display::i_handleCrVRecScreenshotBegin(uint32_t uScreen, uint64_t u64TimeStamp)
 {
 # if VBOX_WITH_VPX
@@ -4471 +4412 @@
 }
 
-void  Display::handleCrVRecScreenshotEnd(uint32_t uScreen, uint64_t u64TimeStamp)
-{
-}
-
-void  Display::handleCrVRecScreenshotPerform(uint32_t uScreen,
-                                             uint32_t x, uint32_t y, uint32_t uPixelFormat,
-                                             uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
-                                             uint32_t uGuestWidth, uint32_t uGuestHeight,
-                                             uint8_t *pu8BufferAddress, uint64_t u64TimeStamp)
+void  Display::i_handleCrVRecScreenshotEnd(uint32_t uScreen, uint64_t u64TimeStamp)
+{
+}
+
+void  Display::i_handleCrVRecScreenshotPerform(uint32_t uScreen,
+                                               uint32_t x, uint32_t y, uint32_t uPixelFormat,
+                                               uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
+                                               uint32_t uGuestWidth, uint32_t uGuestHeight,
+                                               uint8_t *pu8BufferAddress, uint64_t u64TimeStamp)
 {
     Assert(mfCrOglVideoRecState == CRVREC_STATE_SUBMITTED);
@@ -4492 +4433 @@
 }
 
-void  Display::handleVRecCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
+void  Display::i_handleVRecCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
 {
     Assert(mfCrOglVideoRecState == CRVREC_STATE_SUBMITTED);
@@ -4498 +4439 @@
 }
 
-DECLCALLBACK(void) Display::displayCrVRecScreenshotPerform(void *pvCtx, uint32_t uScreen,
-                                                           uint32_t x, uint32_t y,
-                                                           uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
-                                                           uint32_t uGuestWidth, uint32_t uGuestHeight,
-                                                           uint8_t *pu8BufferAddress, uint64_t u64TimeStamp)
+DECLCALLBACK(void) Display::i_displayCrVRecScreenshotPerform(void *pvCtx, uint32_t uScreen,
+                                                             uint32_t x, uint32_t y,
+                                                             uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
+                                                             uint32_t uGuestWidth, uint32_t uGuestHeight,
+                                                             uint8_t *pu8BufferAddress, uint64_t u64TimeStamp)
 {
     Display *pDisplay = (Display *)pvCtx;
-    pDisplay->handleCrVRecScreenshotPerform(uScreen,
-                                            x, y, FramebufferPixelFormat_FOURCC_RGB, uBitsPerPixel,
-                                            uBytesPerLine, uGuestWidth, uGuestHeight,
-                                            pu8BufferAddress, u64TimeStamp);
-}
-
-DECLCALLBACK(bool) Display::displayCrVRecScreenshotBegin(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp)
+    pDisplay->i_handleCrVRecScreenshotPerform(uScreen,
+                                              x, y, FramebufferPixelFormat_FOURCC_RGB, uBitsPerPixel,
+                                              uBytesPerLine, uGuestWidth, uGuestHeight,
+                                              pu8BufferAddress, u64TimeStamp);
+}
+
+DECLCALLBACK(bool) Display::i_displayCrVRecScreenshotBegin(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp)
 {
     Display *pDisplay = (Display *)pvCtx;
-    return pDisplay->handleCrVRecScreenshotBegin(uScreen, u64TimeStamp);
-}
-
-DECLCALLBACK(void) Display::displayCrVRecScreenshotEnd(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp)
+    return pDisplay->i_handleCrVRecScreenshotBegin(uScreen, u64TimeStamp);
+}
+
+DECLCALLBACK(void) Display::i_displayCrVRecScreenshotEnd(void *pvCtx, uint32_t uScreen, uint64_t u64TimeStamp)
 {
     Display *pDisplay = (Display *)pvCtx;
-    pDisplay->handleCrVRecScreenshotEnd(uScreen, u64TimeStamp);
-}
-
-DECLCALLBACK(void)  Display::displayVRecCompletion(int32_t result, uint32_t u32Function, PVBOXHGCMSVCPARM pParam, void *pvContext)
+    pDisplay->i_handleCrVRecScreenshotEnd(uScreen, u64TimeStamp);
+}
+
+DECLCALLBACK(void) Display::i_displayVRecCompletion(int32_t result, uint32_t u32Function,
+                                                    PVBOXHGCMSVCPARM pParam, void *pvContext)
 {
     Display *pDisplay = (Display *)pvContext;
-    pDisplay->handleVRecCompletion(result, u32Function, pParam, pvContext);
+    pDisplay->i_handleVRecCompletion(result, u32Function, pParam, pvContext);
 }
 
@@ -4533 +4475 @@
 
 #ifdef VBOX_WITH_HGSMI
-DECLCALLBACK(int) Display::displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags, bool fRenderThreadMode)
+DECLCALLBACK(int) Display::i_displayVBVAEnable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags,
+                                               bool fRenderThreadMode)
 {
     LogRelFlowFunc(("uScreenId %d\n", uScreenId));
@@ -4559 +4502 @@
 }
 
-DECLCALLBACK(void) Display::displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
+DECLCALLBACK(void) Display::i_displayVBVADisable(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
 {
     LogRelFlowFunc(("uScreenId %d\n", uScreenId));
@@ -4597 +4540 @@
     {
         /* Force full screen update, because VGA device must take control, do resize, etc. */
-        Assert(!pThis->vbvaLockIsOwner());
+        Assert(!pThis->i_vbvaLockIsOwner());
         pThis->mpDrv->pUpPort->pfnUpdateDisplayAll(pThis->mpDrv->pUpPort, /* fFailOnResize = */ false);
     }
 }
 
-DECLCALLBACK(void) Display::displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
+DECLCALLBACK(void) Display::i_displayVBVAUpdateBegin(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId)
 {
     LogFlowFunc(("uScreenId %d\n", uScreenId));
@@ -4618 +4561 @@
 }
 
-DECLCALLBACK(void) Display::displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
-                                                     const PVBVACMDHDR pCmd, size_t cbCmd)
+DECLCALLBACK(void) Display::i_displayVBVAUpdateProcess(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId,
+                                                       const PVBVACMDHDR pCmd, size_t cbCmd)
 {
     LogFlowFunc(("uScreenId %d pCmd %p cbCmd %d, @%d,%d %dx%d\n", uScreenId, pCmd, cbCmd, pCmd->x, pCmd->y, pCmd->w, pCmd->h));
@@ -4633 +4576 @@
             && !pFBInfo->fDisabled)
         {
-            Assert(!pThis->vbvaLockIsOwner());
-            pDrv->pUpPort->pfnUpdateDisplayRect (pDrv->pUpPort, pCmd->x, pCmd->y, pCmd->w, pCmd->h);
+            Assert(!pThis->i_vbvaLockIsOwner());
+            pDrv->pUpPort->pfnUpdateDisplayRect(pDrv->pUpPort, pCmd->x, pCmd->y, pCmd->w, pCmd->h);
         }
         else if (   !pFBInfo->pSourceBitmap.isNull()
@@ -4674 +4617 @@
                 uint32_t u32DstBitsPerPixel = 32;
 
-                Assert(!pThis->vbvaLockIsOwner());
+                Assert(!pThis->i_vbvaLockIsOwner());
                 pDrv->pUpPort->pfnCopyRect(pDrv->pUpPort,
                                            width, height,
@@ -4697 +4640 @@
 
     /* @todo new SendUpdate entry which can get a separate cmd header or coords. */
-    pThis->mParent->i_consoleVRDPServer()->SendUpdate (uScreenId, pCmd, (uint32_t)cbCmd);
+    pThis->mParent->i_consoleVRDPServer()->SendUpdate(uScreenId, pCmd, (uint32_t)cbCmd);
 
     *pHdrUnconst = hdrSaved;
 }
 
-DECLCALLBACK(void) Display::displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y,
-                                                 uint32_t cx, uint32_t cy)
+DECLCALLBACK(void) Display::i_displayVBVAUpdateEnd(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y,
+                                                   uint32_t cx, uint32_t cy)
 {
     LogFlowFunc(("uScreenId %d %d,%d %dx%d\n", uScreenId, x, y, cx, cy));
@@ -4716 +4659 @@
      *                                cx, cy);
      */
-    pThis->handleDisplayUpdate(uScreenId, x - pFBInfo->xOrigin, y - pFBInfo->yOrigin, cx, cy);
+    pThis->i_handleDisplayUpdate(uScreenId, x - pFBInfo->xOrigin, y - pFBInfo->yOrigin, cx, cy);
 }
 
@@ -4790 +4733 @@
 #endif /* DEBUG_sunlover */
 
-DECLCALLBACK(int) Display::displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView,
-                                             const PVBVAINFOSCREEN pScreen, void *pvVRAM)
+DECLCALLBACK(int) Display::i_displayVBVAResize(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView,
+                                               const PVBVAINFOSCREEN pScreen, void *pvVRAM)
 {
     LogRelFlowFunc(("pScreen %p, pvVRAM %p\n", pScreen, pvVRAM));
@@ -4802 +4745 @@
     if (pScreen->u16Flags & VBVA_SCREEN_F_DISABLED)
     {
-        pThis->notifyCroglResize(pView, pScreen, pvVRAM);
+        pThis->i_notifyCroglResize(pView, pScreen, pvVRAM);
 
         pFBInfo->fDisabled = true;
@@ -4812 +4755 @@
         uint32_t u32Width = pFBInfo->w ? pFBInfo->w : 640;
         uint32_t u32Height = pFBInfo->h ? pFBInfo->h : 480;
-        pThis->handleDisplayResize(pScreen->u32ViewIndex, 0, (uint8_t *)NULL, 0,
-                                   u32Width, u32Height, pScreen->u16Flags);
+        pThis->i_handleDisplayResize(pScreen->u32ViewIndex, 0, (uint8_t *)NULL, 0,
+                                     u32Width, u32Height, pScreen->u16Flags);
 
         fireGuestMonitorChangedEvent(pThis->mParent->i_getEventSource(),
@@ -4848 +4791 @@
 
     if (fNewOrigin || fResize)
-        pThis->notifyCroglResize(pView, pScreen, pvVRAM);
+        pThis->i_notifyCroglResize(pView, pScreen, pvVRAM);
 
     if (pFBInfo->fDisabled)
@@ -4899 +4842 @@
 
     /* Do a regular resize. */
-    return pThis->handleDisplayResize(pScreen->u32ViewIndex, pScreen->u16BitsPerPixel,
-                                      (uint8_t *)pvVRAM + pScreen->u32StartOffset,
-                                      pScreen->u32LineSize, pScreen->u32Width, pScreen->u32Height, pScreen->u16Flags);
-}
-
-DECLCALLBACK(int) Display::displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
-                                                        uint32_t xHot, uint32_t yHot,
-                                                        uint32_t cx, uint32_t cy,
-                                                        const void *pvShape)
+    return pThis->i_handleDisplayResize(pScreen->u32ViewIndex, pScreen->u16BitsPerPixel,
+                                        (uint8_t *)pvVRAM + pScreen->u32StartOffset,
+                                        pScreen->u32LineSize, pScreen->u32Width, pScreen->u32Height, pScreen->u16Flags);
+}
+
+DECLCALLBACK(int) Display::i_displayVBVAMousePointerShape(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
+                                                          uint32_t xHot, uint32_t yHot,
+                                                          uint32_t cx, uint32_t cy,
+                                                          const void *pvShape)
 {
     LogFlowFunc(("\n"));
@@ -4937 +4880 @@
  * @interface_method_impl{PDMIBASE,pfnQueryInterface}
  */
-DECLCALLBACK(void *)  Display::drvQueryInterface(PPDMIBASE pInterface, const char *pszIID)
+DECLCALLBACK(void *)  Display::i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID)
 {
     PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
@@ -4953 +4896 @@
  * @param   pDrvIns     The driver instance data.
  */
-DECLCALLBACK(void) Display::drvDestruct(PPDMDRVINS pDrvIns)
+DECLCALLBACK(void) Display::i_drvDestruct(PPDMDRVINS pDrvIns)
 {
     PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
@@ -4960 +4903 @@
 
     if (pThis->pDisplay)
-        Assert(!pThis->pDisplay->vbvaLockIsOwner());
+        Assert(!pThis->pDisplay->i_vbvaLockIsOwner());
 
     pThis->pUpPort->pfnSetRenderVRAM(pThis->pUpPort, false);
@@ -4974 +4917 @@
         AutoWriteLock displayLock(pThis->pDisplay COMMA_LOCKVAL_SRC_POS);
 #ifdef VBOX_WITH_VPX
-        pThis->pDisplay->VideoCaptureStop();
+        pThis->pDisplay->i_VideoCaptureStop();
 #endif
 #ifdef VBOX_WITH_CRHGSMI
-        pThis->pDisplay->destructCrHgsmiData();
+        pThis->pDisplay->i_destructCrHgsmiData();
 #endif
         pThis->pDisplay->mpDrv = NULL;
@@ -4990 +4933 @@
  * @copydoc FNPDMDRVCONSTRUCT
  */
-DECLCALLBACK(int) Display::drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
+DECLCALLBACK(int) Display::i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
 {
     PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
@@ -5008 +4951 @@
      * Init Interfaces.
      */
-    pDrvIns->IBase.pfnQueryInterface           = Display::drvQueryInterface;
-
-    pThis->IConnector.pfnResize                = Display::displayResizeCallback;
-    pThis->IConnector.pfnUpdateRect            = Display::displayUpdateCallback;
-    pThis->IConnector.pfnRefresh               = Display::displayRefreshCallback;
-    pThis->IConnector.pfnReset                 = Display::displayResetCallback;
-    pThis->IConnector.pfnLFBModeChange         = Display::displayLFBModeChangeCallback;
-    pThis->IConnector.pfnProcessAdapterData    = Display::displayProcessAdapterDataCallback;
-    pThis->IConnector.pfnProcessDisplayData    = Display::displayProcessDisplayDataCallback;
+    pDrvIns->IBase.pfnQueryInterface           = Display::i_drvQueryInterface;
+
+    pThis->IConnector.pfnResize                = Display::i_displayResizeCallback;
+    pThis->IConnector.pfnUpdateRect            = Display::i_displayUpdateCallback;
+    pThis->IConnector.pfnRefresh               = Display::i_displayRefreshCallback;
+    pThis->IConnector.pfnReset                 = Display::i_displayResetCallback;
+    pThis->IConnector.pfnLFBModeChange         = Display::i_displayLFBModeChangeCallback;
+    pThis->IConnector.pfnProcessAdapterData    = Display::i_displayProcessAdapterDataCallback;
+    pThis->IConnector.pfnProcessDisplayData    = Display::i_displayProcessDisplayDataCallback;
 #ifdef VBOX_WITH_VIDEOHWACCEL
-    pThis->IConnector.pfnVHWACommandProcess    = Display::displayVHWACommandProcess;
+    pThis->IConnector.pfnVHWACommandProcess    = Display::i_displayVHWACommandProcess;
 #endif
 #ifdef VBOX_WITH_CRHGSMI
-    pThis->IConnector.pfnCrHgsmiCommandProcess = Display::displayCrHgsmiCommandProcess;
-    pThis->IConnector.pfnCrHgsmiControlProcess = Display::displayCrHgsmiControlProcess;
+    pThis->IConnector.pfnCrHgsmiCommandProcess = Display::i_displayCrHgsmiCommandProcess;
+    pThis->IConnector.pfnCrHgsmiControlProcess = Display::i_displayCrHgsmiControlProcess;
 #endif
 #if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
-    pThis->IConnector.pfnCrHgcmCtlSubmit       = Display::displayCrHgcmCtlSubmit;
+    pThis->IConnector.pfnCrHgcmCtlSubmit       = Display::i_displayCrHgcmCtlSubmit;
 #endif
 #ifdef VBOX_WITH_HGSMI
-    pThis->IConnector.pfnVBVAEnable            = Display::displayVBVAEnable;
-    pThis->IConnector.pfnVBVADisable           = Display::displayVBVADisable;
-    pThis->IConnector.pfnVBVAUpdateBegin       = Display::displayVBVAUpdateBegin;
-    pThis->IConnector.pfnVBVAUpdateProcess     = Display::displayVBVAUpdateProcess;
-    pThis->IConnector.pfnVBVAUpdateEnd         = Display::displayVBVAUpdateEnd;
-    pThis->IConnector.pfnVBVAResize            = Display::displayVBVAResize;
-    pThis->IConnector.pfnVBVAMousePointerShape = Display::displayVBVAMousePointerShape;
+    pThis->IConnector.pfnVBVAEnable            = Display::i_displayVBVAEnable;
+    pThis->IConnector.pfnVBVADisable           = Display::i_displayVBVADisable;
+    pThis->IConnector.pfnVBVAUpdateBegin       = Display::i_displayVBVAUpdateBegin;
+    pThis->IConnector.pfnVBVAUpdateProcess     = Display::i_displayVBVAUpdateProcess;
+    pThis->IConnector.pfnVBVAUpdateEnd         = Display::i_displayVBVAUpdateEnd;
+    pThis->IConnector.pfnVBVAResize            = Display::i_displayVBVAResize;
+    pThis->IConnector.pfnVBVAMousePointerShape = Display::i_displayVBVAMousePointerShape;
 #endif
 
@@ -5069 +5012 @@
 
     /* Disable VRAM to a buffer copy initially. */
-    Assert(!pDisplay->vbvaLockIsOwner());
-    pThis->pUpPort->pfnSetRenderVRAM (pThis->pUpPort, false);
+    Assert(!pDisplay->i_vbvaLockIsOwner());
+    pThis->pUpPort->pfnSetRenderVRAM(pThis->pUpPort, false);
     pThis->IConnector.cBits = 32; /* DevVGA does nothing otherwise. */
 
@@ -5076 +5019 @@
      * Start periodic screen refreshes
      */
-    Assert(!pDisplay->vbvaLockIsOwner());
+    Assert(!pDisplay->i_vbvaLockIsOwner());
     pThis->pUpPort->pfnSetRefreshRate(pThis->pUpPort, 20);
 
 #ifdef VBOX_WITH_CRHGSMI
-    pDisplay->setupCrHgsmiData();
+    pDisplay->i_setupCrHgsmiData();
 #endif
 
@@ -5090 +5033 @@
     if (fEnabled)
     {
-        rc = pDisplay->VideoCaptureStart();
+        rc = pDisplay->i_VideoCaptureStart();
         fireVideoCaptureChangedEvent(pDisplay->mParent->i_getEventSource());
     }
@@ -5123 +5066 @@
     sizeof(DRVMAINDISPLAY),
     /* pfnConstruct */
-    Display::drvConstruct,
+    Display::i_drvConstruct,
     /* pfnDestruct */
-    Display::drvDestruct,
+    Display::i_drvDestruct,
     /* pfnRelocate */
     NULL,
@@ -5149 +5092 @@
     PDM_DRVREG_VERSION
 };
+
 /* vi: set tabstop=4 shiftwidth=4 expandtab: */

trunk/src/VBox/Main/src-client/GuestDnDPrivate.cpp

@@ -476 +476 @@
         return hr;
 
+    ULONG dummy;
     LONG xShift, yShift;
-    hr = pDisplay->GetScreenResolution(uScreenId, NULL, NULL, NULL,
+    hr = pDisplay->GetScreenResolution(uScreenId, &dummy, &dummy, &dummy,
                                        &xShift, &yShift);
     if (FAILED(hr))

trunk/src/VBox/Main/src-client/MouseImpl.cpp

@@ -554 +554 @@
     {
         ULONG displayWidth, displayHeight;
+        ULONG ulDummy;
+        LONG lDummy;
         /* Takes the display lock */
-        HRESULT rc = pDisplay->getScreenResolution(0, &displayWidth,
-                                                   &displayHeight, NULL, NULL, NULL);
+        HRESULT rc = pDisplay->i_getScreenResolution(0, &displayWidth,
+                                                     &displayHeight, &ulDummy, &lDummy, &lDummy);
         if (FAILED(rc))
             return rc;
@@ -569 +571 @@
         int32_t x1, y1, x2, y2;
         /* Takes the display lock */
-        pDisplay->getFramebufferDimensions(&x1, &y1, &x2, &y2);
+        pDisplay->i_getFramebufferDimensions(&x1, &y1, &x2, &y2);
         *pxAdj = x1 < x2 ?   ((x - x1) * VMMDEV_MOUSE_RANGE + ADJUST_RANGE)
                            / (x2 - x1) : 0;
@@ -710 +712 @@
     ULONG cWidth  = 0;
     ULONG cHeight = 0;
+    ULONG cBPP    = 0;
     LONG  xOrigin = 0;
     LONG  yOrigin = 0;
-    HRESULT rc = pDisplay->getScreenResolution(uScreenId, &cWidth, &cHeight, NULL, &xOrigin, &yOrigin);
+    HRESULT rc = pDisplay->i_getScreenResolution(uScreenId, &cWidth, &cHeight, &cBPP, &xOrigin, &yOrigin);
+    NOREF(cBPP);
     ComAssertComRCRetRC(rc);
 

trunk/src/VBox/Main/src-client/VMMDevInterface.cpp

@@ -369 +369 @@
     {
         LogSunlover(("MAIN::VMMDevInterface::iface_VideoAccelEnable: %d, %p\n", fEnable, pVbvaMemory));
-        return display->VideoAccelEnable(fEnable, pVbvaMemory);
+        return display->i_VideoAccelEnable(fEnable, pVbvaMemory);
     }
 
@@ -384 +384 @@
     {
         LogSunlover(("MAIN::VMMDevInterface::iface_VideoAccelFlush\n"));
-        display->VideoAccelFlush ();
+        display->i_VideoAccelFlush();
     }
 }
@@ -451 +451 @@
 
     /* Forward to Display, which calls corresponding framebuffers. */
-    pConsole->i_getDisplay()->handleSetVisibleRegion(cRect, pRect);
+    pConsole->i_getDisplay()->i_handleSetVisibleRegion(cRect, pRect);
 
     return VINF_SUCCESS;
@@ -462 +462 @@
 
     /* Forward to Display, which calls corresponding framebuffers. */
-    pConsole->i_getDisplay()->handleQueryVisibleRegion(pcRect, pRect);
+    pConsole->i_getDisplay()->i_handleQueryVisibleRegion(pcRect, pRect);
 
     return VINF_SUCCESS;

trunk/src/VBox/Main/src-client/xpcom/module.cpp

@@ -70 +70 @@
 NS_DECL_CLASSINFO(Keyboard)
 NS_IMPL_THREADSAFE_ISUPPORTS1_CI(Keyboard, IKeyboard)
-NS_DECL_CLASSINFO(Display)
-NS_IMPL_THREADSAFE_ISUPPORTS2_CI(Display, IDisplay, IEventListener)
 NS_DECL_CLASSINFO(RemoteUSBDevice)
 NS_IMPL_THREADSAFE_ISUPPORTS2_CI(RemoteUSBDevice, IHostUSBDevice, IUSBDevice)

trunk/src/VBox/Main/testcase/tstMouseImpl.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2011-2013 Oracle Corporation
+ * Copyright (C) 2011-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -40 +40 @@
 class TestDisplay : public DisplayMouseInterface
 {
-    void getFramebufferDimensions(int32_t *px1, int32_t *py1,
-                                  int32_t *px2, int32_t *py2);
-    int getScreenResolution(uint32_t cScreen, ULONG *pcx, ULONG *pcy,
-                            ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin);
+    virtual HRESULT i_getScreenResolution(ULONG cScreen, ULONG *pcx, ULONG *pcy,
+                                          ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin);
+    virtual void i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
+                                            int32_t *px2, int32_t *py2);
 };
 
@@ -233 +233 @@
 }
 
-void TestDisplay::getFramebufferDimensions(int32_t *px1, int32_t *py1,
-                                           int32_t *px2, int32_t *py2)
+void TestDisplay::i_getFramebufferDimensions(int32_t *px1, int32_t *py1,
+                                             int32_t *px2, int32_t *py2)
 {
     if (px1)
@@ -246 +246 @@
 }
 
-int TestDisplay::getScreenResolution(uint32_t cScreen, ULONG *pcx,
-                                     ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin)
+HRESULT TestDisplay::i_getScreenResolution(ULONG cScreen, ULONG *pcx,
+                                           ULONG *pcy, ULONG *pcBPP, LONG *pXOrigin, LONG *pYOrigin)
 {
     NOREF(cScreen);