Changeset 72352 in vbox for trunk/src

Timestamp:

May 26, 2018 12:37:50 PM (7 years ago)

Author:

vboxsync

Message:

Main, VMMDev: implemented IDisplay::SetScreenLayout, VMMDev multimonitor resize request and VBoxManage controlvm setscreenlayout. bugref:8393

Location:

trunk/src/VBox

Files:

• Additions/WINNT/VBoxTray/VBoxDisplay.cpp (modified) (3 diffs)
• Additions/common/VBoxGuest/VBoxGuest.cpp (modified) (1 diff)
• Additions/common/VBoxGuest/lib/VBoxGuestR0LibGenericRequest.cpp (modified) (1 diff)
• Additions/common/VBoxGuest/lib/VBoxGuestR3LibVideo.cpp (modified) (1 diff)
• Devices/VMMDev/VMMDev.cpp (modified) (6 diffs)
• Devices/VMMDev/VMMDevState.h (modified) (3 diffs)
• Frontends/VBoxManage/VBoxManageControlVM.cpp (modified) (1 diff)
• Frontends/VBoxManage/VBoxManageHelp.cpp (modified) (1 diff)
• Main/idl/VirtualBox.xidl (modified) (2 diffs)
• Main/include/DisplayImpl.h (modified) (3 diffs)
• Main/src-client/DisplayImpl.cpp (modified) (3 diffs)

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDisplay.cpp

@@ -769 +769 @@
 }
 
+static void doResize(PVBOXDISPLAYCONTEXT pCtx,
+                     uint32_t iDisplay,
+                     uint32_t cx,
+                     uint32_t cy,
+                     uint32_t cBits,
+                     bool     fEnabled,
+                     uint32_t cxOrigin,
+                     uint32_t cyOrigin,
+                     bool     fChangeOrigin)
+{
+    for (;;)
+    {
+        VBOXDISPLAY_DRIVER_TYPE enmDriverType = getVBoxDisplayDriverType(pCtx);
+        if (enmDriverType == VBOXDISPLAY_DRIVER_TYPE_UNKNOWN)
+        {
+            LogFlowFunc(("vboxDisplayDriver is not active\n"));
+            break;
+        }
+
+        if (pCtx->pfnChangeDisplaySettingsEx != 0)
+        {
+            LogFlowFunc(("Detected W2K or later\n"));
+            if (!ResizeDisplayDevice(pCtx,
+                                     iDisplay,
+                                     cx,
+                                     cy,
+                                     cBits,
+                                     fEnabled,
+                                     cxOrigin,
+                                     cyOrigin,
+                                     fChangeOrigin,
+                                     true /*fExtDispSup*/ ))
+            {
+                LogFlowFunc(("ResizeDipspalyDevice return 0\n"));
+                break;
+            }
+
+        }
+        else
+        {
+            LogFlowFunc(("Detected NT\n"));
+            ResizeDisplayDeviceNT4(cx, cy, cBits);
+            break;
+        }
+
+        /* Retry the change a bit later. */
+        RTThreadSleep(1000);
+    }
+}
+
 /**
  * Thread function to wait for and process display change requests.
@@ -821 +871 @@
             {
                 LogFlowFunc(("going to get display change information\n"));
+
+#if 0
+                /* Prototype code which processes the multimonitor resize request. */
+                VMMDevDisplayDef aDisplays[64];
+                uint32_t cDisplays = VBoxDisplayGetCount();
+                rc = VbglR3GetDisplayChangeRequestMulti(cDisplays, &cDisplays, &aDisplays[0], true /* fAck */);
+                if (RT_SUCCESS(rc))
+                {
+                    LogRel(("Got multi resize request %d displays\n", cDisplays));
+
+                    uint32_t i;
+                    for (i = 0; i < cDisplays; ++i)
+                    {
+                        LogRel(("[%d]: %d 0x%02X %d,%d %dx%d %d\n",
+                                 i, aDisplays[i].idDisplay,
+                                 aDisplays[i].fDisplayFlags,
+                                 aDisplays[i].xOrigin,
+                                 aDisplays[i].yOrigin,
+                                 aDisplays[i].cx,
+                                 aDisplays[i].cy,
+                                 aDisplays[i].cBitsPerPixel));
+
+                        doResize(pCtx,
+                                 aDisplays[i].idDisplay,
+                                 (aDisplays[i].fDisplayFlags & VMMDEV_DISPLAY_CX) ? aDisplays[i].cx : 0,
+                                 (aDisplays[i].fDisplayFlags & VMMDEV_DISPLAY_CY) ? aDisplays[i].cy : 0,
+                                 (aDisplays[i].fDisplayFlags & VMMDEV_DISPLAY_BPP) ? aDisplays[i].cBitsPerPixel : 0,
+                                 !RT_BOOL(aDisplays[i].fDisplayFlags & VMMDEV_DISPLAY_DISABLED),
+                                 aDisplays[i].xOrigin,
+                                 aDisplays[i].yOrigin,
+                                 RT_BOOL(aDisplays[i].fDisplayFlags & VMMDEV_DISPLAY_ORIGIN));
+                    }
+
+                    continue; /* Done */
+                }
+                /* Fall back to the single monitor resize request. */
+#endif
 
                 /*
@@ -850 +937 @@
                                  iDisplay, cx, cy, cBits, fEnabled, cxOrigin, cyOrigin, fChangeOrigin));
 
-                    for (;;)
-                    {
-                        VBOXDISPLAY_DRIVER_TYPE enmDriverType = getVBoxDisplayDriverType(pCtx);
-                        if (enmDriverType == VBOXDISPLAY_DRIVER_TYPE_UNKNOWN)
-                        {
-                            LogFlowFunc(("vboxDisplayDriver is not active\n"));
-                            break;
-                        }
-
-                        if (pCtx->pfnChangeDisplaySettingsEx != 0)
-                        {
-                            LogFlowFunc(("Detected W2K or later\n"));
-                            if (!ResizeDisplayDevice(pCtx,
-                                                     iDisplay,
-                                                     cx,
-                                                     cy,
-                                                     cBits,
-                                                     fEnabled,
-                                                     cxOrigin,
-                                                     cyOrigin,
-                                                     fChangeOrigin,
-                                                     true /*fExtDispSup*/ ))
-                            {
-                                LogFlowFunc(("ResizeDipspalyDevice return 0\n"));
-                                break;
-                            }
-
-                        }
-                        else
-                        {
-                            LogFlowFunc(("Detected NT\n"));
-                            ResizeDisplayDeviceNT4(cx, cy, cBits);
-                            break;
-                        }
-
-                        /* Retry the change a bit later. */
-                        RTThreadSleep(1000);
-                    }
+                    doResize(pCtx,
+                             iDisplay,
+                             cx,
+                             cy,
+                             cBits,
+                             fEnabled,
+                             cxOrigin,
+                             cyOrigin,
+                             fChangeOrigin);
                 }
             } // if (fDisplayChangeQueried)

trunk/src/VBox/Additions/common/VBoxGuest/VBoxGuest.cpp

@@ -2381 +2381 @@
         case VMMDevReq_VideoSetVisibleRegion:
         case VMMDevReq_GetDisplayChangeRequestEx:
+        case VMMDevReq_GetDisplayChangeRequestMulti:
         case VMMDevReq_GetSeamlessChangeRequest:
         case VMMDevReq_GetVRDPChangeRequest:

trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR0LibGenericRequest.cpp

@@ -82 +82 @@
      */
     if (   pReq->requestType == VMMDevReq_ChangeMemBalloon
+        || pReq->requestType == VMMDevReq_GetDisplayChangeRequestMulti
 #ifdef VBOX_WITH_64_BITS_GUESTS
         || pReq->requestType == VMMDevReq_HGCMCall32

trunk/src/VBox/Additions/common/VBoxGuest/lib/VBoxGuestR3LibVideo.cpp

@@ -273 +273 @@
         return getDisplayChangeRequest2(pcx, pcy, pcBits, piDisplay, fAck);
     }
+    return rc;
+}
+
+
+/**
+ * Query the last display change request sent from the host to the guest.
+ *
+ * @returns iprt status value
+ * @param   cDisplaysIn   How many elements in the paDisplays array.
+ * @param   pcDisplaysOut How many elements were returned.
+ * @param   paDisplays    Display information.
+ * @param   fAck          Whether or not to acknowledge the newest request sent by
+ *                        the host.  If this is set, the function will return the
+ *                        most recent host request, otherwise it will return the
+ *                        last request to be acknowledged.
+ */
+VBGLR3DECL(int) VbglR3GetDisplayChangeRequestMulti(uint32_t cDisplaysIn,
+                                                   uint32_t *pcDisplaysOut,
+                                                   VMMDevDisplayDef *paDisplays,
+                                                   bool fAck)
+{
+    VMMDevDisplayChangeRequestMulti *pReq;
+    size_t cbDisplays;
+    size_t cbAlloc;
+    int rc = VINF_SUCCESS;
+
+    AssertReturn(cDisplaysIn > 0 && cDisplaysIn <= 64 /* VBOX_VIDEO_MAX_SCREENS */, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pcDisplaysOut, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(paDisplays, VERR_INVALID_PARAMETER);
+
+    cbDisplays = cDisplaysIn * sizeof(VMMDevDisplayDef);
+    cbAlloc = RT_UOFFSETOF(VMMDevDisplayChangeRequestMulti, aDisplays) + cbDisplays;
+    pReq = (VMMDevDisplayChangeRequestMulti *)RTMemAllocZ(cbAlloc);
+    AssertPtrReturn(pReq, VERR_NO_MEMORY);
+
+    rc = vmmdevInitRequest(&pReq->header, VMMDevReq_GetDisplayChangeRequestMulti);
+    AssertRCReturnStmt(rc, RTMemFree(pReq), rc);
+
+    pReq->header.size += (uint32_t)cbDisplays;
+    pReq->cDisplays = cDisplaysIn;
+    if (fAck)
+        pReq->eventAck = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
+
+    rc = vbglR3GRPerform(&pReq->header);
+    AssertRCReturnStmt(rc, RTMemFree(pReq), rc);
+
+    rc = pReq->header.rc;
+    if (RT_SUCCESS(rc))
+    {
+        memcpy(paDisplays, pReq->aDisplays, pReq->cDisplays * sizeof(VMMDevDisplayDef));
+        *pcDisplaysOut = pReq->cDisplays;
+    }
+
+    RTMemFree(pReq);
     return rc;
 }

trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

@@ -83 +83 @@
 /* Enable dev_vmm Log3 statements to get IRQ-related logging. */
 #define LOG_GROUP LOG_GROUP_DEV_VMM
-#include <VBoxVideo.h>  /* For VBVA definitions. */
+#include <VBox/AssertGuest.h>
 #include <VBox/VMMDev.h>
 #include <VBox/vmm/mm.h>
@@ -1311 +1311 @@
     }
 
-    if (pThis->displayChangeData.fGuestSentChangeEventAck)
-    {
-        pReq->xres = pDispRequest->lastReadDisplayChangeRequest.xres;
-        pReq->yres = pDispRequest->lastReadDisplayChangeRequest.yres;
-        pReq->bpp  = pDispRequest->lastReadDisplayChangeRequest.bpp;
-    }
-    else
-    {
-        /* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
-         * read the last valid video mode hint. This happens when the guest X server
-         * determines the initial mode. */
-        pReq->xres = pDispRequest->displayChangeRequest.xres;
-        pReq->yres = pDispRequest->displayChangeRequest.yres;
-        pReq->bpp  = pDispRequest->displayChangeRequest.bpp;
-    }
+    /* If not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
+     * read the last valid video mode hint. This happens when the guest X server
+     * determines the initial mode. */
+    VMMDevDisplayDef const *pDisplayDef = pThis->displayChangeData.fGuestSentChangeEventAck ?
+                                              &pDispRequest->lastReadDisplayChangeRequest :
+                                              &pDispRequest->displayChangeRequest;
+    pReq->xres = RT_BOOL(pDisplayDef->fDisplayFlags & VMMDEV_DISPLAY_CX)  ? pDisplayDef->cx : 0;
+    pReq->yres = RT_BOOL(pDisplayDef->fDisplayFlags & VMMDEV_DISPLAY_CY)  ? pDisplayDef->cy : 0;
+    pReq->bpp  = RT_BOOL(pDisplayDef->fDisplayFlags & VMMDEV_DISPLAY_BPP) ? pDisplayDef->cBitsPerPixel : 0;
+
     Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d\n", pReq->xres, pReq->yres, pReq->bpp));
 
@@ -1396 +1391 @@
     }
 
-    if (pThis->displayChangeData.fGuestSentChangeEventAck)
-    {
-        pReq->xres    = pDispRequest->lastReadDisplayChangeRequest.xres;
-        pReq->yres    = pDispRequest->lastReadDisplayChangeRequest.yres;
-        pReq->bpp     = pDispRequest->lastReadDisplayChangeRequest.bpp;
-        pReq->display = pDispRequest->lastReadDisplayChangeRequest.display;
-    }
-    else
-    {
-        /* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
-         * read the last valid video mode hint. This happens when the guest X server
-         * determines the initial video mode. */
-        pReq->xres    = pDispRequest->displayChangeRequest.xres;
-        pReq->yres    = pDispRequest->displayChangeRequest.yres;
-        pReq->bpp     = pDispRequest->displayChangeRequest.bpp;
-        pReq->display = pDispRequest->displayChangeRequest.display;
-    }
+    /* If not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
+     * read the last valid video mode hint. This happens when the guest X server
+     * determines the initial mode. */
+    VMMDevDisplayDef const *pDisplayDef = pThis->displayChangeData.fGuestSentChangeEventAck ?
+                                              &pDispRequest->lastReadDisplayChangeRequest :
+                                              &pDispRequest->displayChangeRequest;
+    pReq->xres    = RT_BOOL(pDisplayDef->fDisplayFlags & VMMDEV_DISPLAY_CX)  ? pDisplayDef->cx : 0;
+    pReq->yres    = RT_BOOL(pDisplayDef->fDisplayFlags & VMMDEV_DISPLAY_CY)  ? pDisplayDef->cy : 0;
+    pReq->bpp     = RT_BOOL(pDisplayDef->fDisplayFlags & VMMDEV_DISPLAY_BPP) ? pDisplayDef->cBitsPerPixel : 0;
+    pReq->display = pDisplayDef->idDisplay;
+
     Log(("VMMDev: returning display change request xres = %d, yres = %d, bpp = %d at %d\n",
          pReq->xres, pReq->yres, pReq->bpp, pReq->display));
@@ -1487 +1476 @@
     }
 
-    if (pThis->displayChangeData.fGuestSentChangeEventAck)
-    {
-        pReq->xres          = pDispRequest->lastReadDisplayChangeRequest.xres;
-        pReq->yres          = pDispRequest->lastReadDisplayChangeRequest.yres;
-        pReq->bpp           = pDispRequest->lastReadDisplayChangeRequest.bpp;
-        pReq->display       = pDispRequest->lastReadDisplayChangeRequest.display;
-        pReq->cxOrigin      = pDispRequest->lastReadDisplayChangeRequest.xOrigin;
-        pReq->cyOrigin      = pDispRequest->lastReadDisplayChangeRequest.yOrigin;
-        pReq->fEnabled      = pDispRequest->lastReadDisplayChangeRequest.fEnabled;
-        pReq->fChangeOrigin = pDispRequest->lastReadDisplayChangeRequest.fChangeOrigin;
-    }
-    else
-    {
-        /* This is not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
-         * read the last valid video mode hint. This happens when the guest X server
-         * determines the initial video mode. */
-        pReq->xres          = pDispRequest->displayChangeRequest.xres;
-        pReq->yres          = pDispRequest->displayChangeRequest.yres;
-        pReq->bpp           = pDispRequest->displayChangeRequest.bpp;
-        pReq->display       = pDispRequest->displayChangeRequest.display;
-        pReq->cxOrigin      = pDispRequest->displayChangeRequest.xOrigin;
-        pReq->cyOrigin      = pDispRequest->displayChangeRequest.yOrigin;
-        pReq->fEnabled      = pDispRequest->displayChangeRequest.fEnabled;
-        pReq->fChangeOrigin = pDispRequest->displayChangeRequest.fChangeOrigin;
-
-    }
+    /* If not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
+     * read the last valid video mode hint. This happens when the guest X server
+     * determines the initial mode. */
+    VMMDevDisplayDef const *pDisplayDef = pThis->displayChangeData.fGuestSentChangeEventAck ?
+                                              &pDispRequest->lastReadDisplayChangeRequest :
+                                              &pDispRequest->displayChangeRequest;
+    pReq->xres          = RT_BOOL(pDisplayDef->fDisplayFlags & VMMDEV_DISPLAY_CX)  ? pDisplayDef->cx : 0;
+    pReq->yres          = RT_BOOL(pDisplayDef->fDisplayFlags & VMMDEV_DISPLAY_CY)  ? pDisplayDef->cy : 0;
+    pReq->bpp           = RT_BOOL(pDisplayDef->fDisplayFlags & VMMDEV_DISPLAY_BPP) ? pDisplayDef->cBitsPerPixel : 0;
+    pReq->display       = pDisplayDef->idDisplay;
+    pReq->cxOrigin      = pDisplayDef->xOrigin;
+    pReq->cyOrigin      = pDisplayDef->yOrigin;
+    pReq->fEnabled      = !RT_BOOL(pDisplayDef->fDisplayFlags & VMMDEV_DISPLAY_DISABLED);
+    pReq->fChangeOrigin = RT_BOOL(pDisplayDef->fDisplayFlags & VMMDEV_DISPLAY_ORIGIN);
+
     Log(("VMMDevEx: returning display change request xres = %d, yres = %d, bpp = %d id %d xPos = %d, yPos = %d & Enabled=%d\n",
          pReq->xres, pReq->yres, pReq->bpp, pReq->display, pReq->cxOrigin, pReq->cyOrigin, pReq->fEnabled));
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Handles VMMDevReq_GetDisplayChangeRequestMulti.
+ *
+ * @returns VBox status code that the guest should see.
+ * @param   pThis           The VMMDev instance data.
+ * @param   pReqHdr         The header of the request to handle.
+ */
+static int vmmdevReqHandler_GetDisplayChangeRequestMulti(PVMMDEV pThis, VMMDevRequestHeader *pReqHdr)
+{
+    VMMDevDisplayChangeRequestMulti *pReq = (VMMDevDisplayChangeRequestMulti *)pReqHdr;
+    unsigned i;
+
+    ASSERT_GUEST_MSG_RETURN(pReq->header.size >= sizeof(*pReq),
+                            ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    uint32_t const cDisplays = pReq->cDisplays;
+    ASSERT_GUEST_MSG_RETURN(cDisplays > 0 && cDisplays <= RT_ELEMENTS(pThis->displayChangeData.aRequests),
+                            ("cDisplays %u\n", cDisplays), VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    ASSERT_GUEST_MSG_RETURN(pReq->header.size >= sizeof(*pReq) + (cDisplays - 1) * sizeof(VMMDevDisplayDef),
+                            ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    if (pReq->eventAck == VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
+    {
+        /* Remember which resolution the client has queried, subsequent reads
+         * will return the same values. */
+        for (i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); ++i)
+        {
+            DISPLAYCHANGEREQUEST *pDCR = &pThis->displayChangeData.aRequests[i];
+
+            pDCR->lastReadDisplayChangeRequest = pDCR->displayChangeRequest;
+            pDCR->fPending = false;
+        }
+    }
+
+    /* Fill the guest request with monitor layout data. */
+    for (i = 0; i < cDisplays; ++i)
+    {
+        /* If not a response to a VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, just
+         * read the last valid video mode hint. This happens when the guest X server
+         * determines the initial mode. */
+        DISPLAYCHANGEREQUEST const *pDCR = &pThis->displayChangeData.aRequests[i];
+        VMMDevDisplayDef const *pDisplayDef = pThis->displayChangeData.fGuestSentChangeEventAck ?
+                                                  &pDCR->lastReadDisplayChangeRequest :
+                                                  &pDCR->displayChangeRequest;
+        pReq->aDisplays[i] = *pDisplayDef;
+    }
+
+    Log(("VMMDev: returning multimonitor display change request cDisplays %d\n", cDisplays));
 
     return VINF_SUCCESS;
@@ -2570 +2605 @@
         case VMMDevReq_GetDisplayChangeRequestEx:
             pReqHdr->rc = vmmdevReqHandler_GetDisplayChangeRequestEx(pThis, pReqHdr);
+            break;
+
+        case VMMDevReq_GetDisplayChangeRequestMulti:
+            pReqHdr->rc = vmmdevReqHandler_GetDisplayChangeRequestMulti(pThis, pReqHdr);
             break;
 
@@ -3182 +3221 @@
 }
 
+static bool vmmdevIsMonitorDefEqual(VMMDevDisplayDef const *pNew, VMMDevDisplayDef const *pOld)
+{
+    bool     fEqual = pNew->idDisplay == pOld->idDisplay;
+
+    fEqual = fEqual && (   !RT_BOOL(pNew->fDisplayFlags & VMMDEV_DISPLAY_ORIGIN)    /* No change. */
+                        || (   RT_BOOL(pOld->fDisplayFlags & VMMDEV_DISPLAY_ORIGIN) /* Old value exists and */
+                            && pNew->xOrigin == pOld->xOrigin                       /* the old is equal to the new. */
+                            && pNew->yOrigin == pOld->yOrigin));
+
+    fEqual = fEqual && (   !RT_BOOL(pNew->fDisplayFlags & VMMDEV_DISPLAY_CX)
+                        || (   RT_BOOL(pOld->fDisplayFlags & VMMDEV_DISPLAY_CX)
+                            && pNew->cx == pOld->cx));
+
+    fEqual = fEqual && (   !RT_BOOL(pNew->fDisplayFlags & VMMDEV_DISPLAY_CY)
+                        || (   RT_BOOL(pOld->fDisplayFlags & VMMDEV_DISPLAY_CY)
+                            && pNew->cy == pOld->cy));
+
+    fEqual = fEqual && (   !RT_BOOL(pNew->fDisplayFlags & VMMDEV_DISPLAY_BPP)
+                        || (   RT_BOOL(pOld->fDisplayFlags & VMMDEV_DISPLAY_BPP)
+                            && pNew->cBitsPerPixel == pOld->cBitsPerPixel));
+
+    fEqual = fEqual && (   RT_BOOL(pNew->fDisplayFlags & VMMDEV_DISPLAY_DISABLED)
+                        == RT_BOOL(pOld->fDisplayFlags & VMMDEV_DISPLAY_DISABLED));
+
+    fEqual = fEqual && (   RT_BOOL(pNew->fDisplayFlags & VMMDEV_DISPLAY_PRIMARY)
+                        == RT_BOOL(pOld->fDisplayFlags & VMMDEV_DISPLAY_PRIMARY));
+
+    return fEqual;
+}
+
 /**
  * @interface_method_impl{PDMIVMMDEVPORT,pfnRequestDisplayChange}
  */
 static DECLCALLBACK(int)
-vmmdevIPort_RequestDisplayChange(PPDMIVMMDEVPORT pInterface, uint32_t cx, uint32_t cy, uint32_t cBits, uint32_t idxDisplay,
-                                 int32_t xOrigin, int32_t yOrigin, bool fEnabled, bool fChangeOrigin)
-{
+vmmdevIPort_RequestDisplayChange(PPDMIVMMDEVPORT pInterface, uint32_t cDisplays, VMMDevDisplayDef const *paDisplays, bool fForce)
+{
+    int rc = VINF_SUCCESS;
+
     PVMMDEV pThis = RT_FROM_MEMBER(pInterface, VMMDEV, IPort);
-
-    if (idxDisplay >= RT_ELEMENTS(pThis->displayChangeData.aRequests))
-        return VERR_INVALID_PARAMETER;
+    bool fNotifyGuest = false;
 
     PDMCritSectEnter(&pThis->CritSect, VERR_IGNORED);
 
-    DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[idxDisplay];
-
-    /* Verify that the new resolution is different and that guest does not yet know about it. */
-    bool fSameResolution = (!cx    || pRequest->lastReadDisplayChangeRequest.xres == cx)
-                        && (!cy    || pRequest->lastReadDisplayChangeRequest.yres == cy)
-                        && (!cBits || pRequest->lastReadDisplayChangeRequest.bpp  == cBits)
-                        && pRequest->lastReadDisplayChangeRequest.xOrigin  == xOrigin
-                        && pRequest->lastReadDisplayChangeRequest.yOrigin  == yOrigin
-                        && pRequest->lastReadDisplayChangeRequest.fEnabled == fEnabled
-                        && pRequest->lastReadDisplayChangeRequest.display  == idxDisplay;
-
-    if (!cx && !cy && !cBits)
-    {
-        /* Special case of reset video mode. */
-        fSameResolution = false;
-    }
-
-    Log3(("vmmdevIPort_RequestDisplayChange: same=%d. new: cx=%d, cy=%d, cBits=%d, idxDisplay=%d.\
-          old: cx=%d, cy=%d, cBits=%d, idxDisplay=%d. \n \
-          ,OriginX = %d , OriginY=%d, Enabled=%d, ChangeOrigin=%d\n",
-          fSameResolution, cx, cy, cBits, idxDisplay, pRequest->lastReadDisplayChangeRequest.xres,
-          pRequest->lastReadDisplayChangeRequest.yres, pRequest->lastReadDisplayChangeRequest.bpp,
-          pRequest->lastReadDisplayChangeRequest.display,
-          xOrigin, yOrigin, fEnabled, fChangeOrigin));
-
-    /* we could validate the information here but hey, the guest can do that as well! */
-    pRequest->displayChangeRequest.xres          = cx;
-    pRequest->displayChangeRequest.yres          = cy;
-    pRequest->displayChangeRequest.bpp           = cBits;
-    pRequest->displayChangeRequest.display       = idxDisplay;
-    pRequest->displayChangeRequest.xOrigin       = xOrigin;
-    pRequest->displayChangeRequest.yOrigin       = yOrigin;
-    pRequest->displayChangeRequest.fEnabled      = fEnabled;
-    pRequest->displayChangeRequest.fChangeOrigin = fChangeOrigin;
-
-    pRequest->fPending = !fSameResolution;
-
-    if (!fSameResolution)
-    {
-        LogRel(("VMMDev: SetVideoModeHint: Got a video mode hint (%dx%dx%d)@(%dx%d),(%d;%d) at %d\n",
-                cx, cy, cBits, xOrigin, yOrigin, fEnabled, fChangeOrigin, idxDisplay));
-
-        /* IRQ so the guest knows what's going on */
-        VMMDevNotifyGuest(pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
+    uint32_t i;
+    for (i = 0; i < cDisplays; ++i)
+    {
+        VMMDevDisplayDef const *p = &paDisplays[i];
+
+        /* Either one display definition is provided or the display id must be equal to the array index. */
+        AssertBreakStmt(cDisplays == 1 || p->idDisplay == i, rc = VERR_INVALID_PARAMETER);
+        AssertBreakStmt(p->idDisplay < RT_ELEMENTS(pThis->displayChangeData.aRequests), rc = VERR_INVALID_PARAMETER);
+
+        DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[p->idDisplay];
+
+        VMMDevDisplayDef const *pLastRead = &pRequest->lastReadDisplayChangeRequest;
+
+        /* Verify that the new resolution is different and that guest does not yet know about it. */
+        bool const fDifferentResolution = fForce || !vmmdevIsMonitorDefEqual(p, pLastRead);
+
+        LogFunc(("same=%d. New: %dx%d, cBits=%d, id=%d. Old: %dx%d, cBits=%d, id=%d. @%d,%d, Enabled=%d, ChangeOrigin=%d\n",
+                 !fDifferentResolution, p->cx, p->cy, p->cBitsPerPixel, p->idDisplay,
+                 pLastRead->cx, pLastRead->cy, pLastRead->cBitsPerPixel, pLastRead->idDisplay,
+                 p->xOrigin, p->yOrigin,
+                 !RT_BOOL(p->fDisplayFlags & VMMDEV_DISPLAY_DISABLED),
+                 RT_BOOL(p->fDisplayFlags & VMMDEV_DISPLAY_ORIGIN)));
+
+        /* We could validate the information here but hey, the guest can do that as well! */
+        pRequest->displayChangeRequest = *p;
+        pRequest->fPending = fDifferentResolution;
+
+        fNotifyGuest = fNotifyGuest || fDifferentResolution;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        if (fNotifyGuest)
+        {
+            for (i = 0; i < RT_ELEMENTS(pThis->displayChangeData.aRequests); ++i)
+            {
+                DISPLAYCHANGEREQUEST *pRequest = &pThis->displayChangeData.aRequests[i];
+                if (pRequest->fPending)
+                {
+                    VMMDevDisplayDef const *p = &pRequest->displayChangeRequest;
+                    LogRel(("VMMDev: SetVideoModeHint: Got a video mode hint (%dx%dx%d)@(%dx%d),(%d;%d) at %d\n",
+                            p->cx, p->cy, p->cBitsPerPixel, p->xOrigin, p->yOrigin,
+                            !RT_BOOL(p->fDisplayFlags & VMMDEV_DISPLAY_DISABLED),
+                            RT_BOOL(p->fDisplayFlags & VMMDEV_DISPLAY_ORIGIN), i));
+                }
+            }
+
+            /* IRQ so the guest knows what's going on */
+            VMMDevNotifyGuest(pThis, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST);
+        }
     }
 
     PDMCritSectLeave(&pThis->CritSect);
-    return VINF_SUCCESS;
+    return rc;
 }
 

trunk/src/VBox/Devices/VMMDev/VMMDevState.h

@@ -19 +19 @@
 #define ___VMMDev_VMMDevState_h
 
+#include <VBoxVideo.h>  /* For VBVA definitions. */
 #include <VBox/VMMDev.h>
 #include <VBox/vmm/pdmdev.h>
@@ -31 +32 @@
 #define VMMDEV_WITH_ALT_TIMESYNC
 
-typedef struct DISPLAYCHANGEINFO
-{
-    uint32_t xres;
-    uint32_t yres;
-    uint32_t bpp;
-    uint32_t display;
-    int32_t xOrigin;
-    int32_t yOrigin;
-    bool fEnabled;
-    bool fChangeOrigin;
-} DISPLAYCHANGEINFO;
-
 typedef struct DISPLAYCHANGEREQUEST
 {
     bool fPending;
     bool afAlignment[3];
-    DISPLAYCHANGEINFO displayChangeRequest;
-    DISPLAYCHANGEINFO lastReadDisplayChangeRequest;
+    VMMDevDisplayDef displayChangeRequest;
+    VMMDevDisplayDef lastReadDisplayChangeRequest;
 } DISPLAYCHANGEREQUEST;
 
@@ -60 +49 @@
     bool afAlignment[3];
 
-    DISPLAYCHANGEREQUEST aRequests[64]; /// @todo maxMonitors
+    DISPLAYCHANGEREQUEST aRequests[VBOX_VIDEO_MAX_SCREENS];
 } DISPLAYCHANGEDATA;
 

trunk/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp

@@ -1441 +1441 @@
                                                          uXRes, uYRes, uBpp));
         }
+        else if (!strcmp(a->argv[1], "setscreenlayout"))
+        {
+            if (a->argc < 4)
+            {
+                errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
+                rc = E_FAIL;
+                break;
+            }
+
+            ComPtr<IDisplay> pDisplay;
+            CHECK_ERROR_BREAK(console, COMGETTER(Display)(pDisplay.asOutParam()));
+            if (!pDisplay)
+            {
+                RTMsgError("Guest not running");
+                rc = E_FAIL;
+                break;
+            }
+
+            com::SafeIfaceArray<IGuestScreenInfo> aGuestScreenInfos;
+
+            /* Parse "<display> on|primary <xorigin> <yorigin> <xres> <yres> <bpp> | off" sequences. */
+            int argc = a->argc - 2;
+            char **argv = &a->argv[2];
+            while (argc >= 2)
+            {
+                ULONG aDisplay = RTStrToUInt32(argv[0]);
+                BOOL aPrimary = FALSE;
+
+                GuestMonitorStatus_T aStatus;
+                if (RTStrICmp(argv[1], "primary") == 0)
+                {
+                    aStatus = GuestMonitorStatus_Enabled;
+                    aPrimary = TRUE;
+                }
+                else if (RTStrICmp(argv[1], "on") == 0)
+                    aStatus = GuestMonitorStatus_Enabled;
+                else if (RTStrICmp(argv[1], "off") == 0)
+                    aStatus = GuestMonitorStatus_Disabled;
+                else
+                {
+                    errorSyntax(USAGE_CONTROLVM, "Display status must be <on> or <off>");
+                    rc = E_FAIL;
+                    break;
+                }
+
+                BOOL aChangeOrigin = FALSE;
+                LONG aOriginX = 0;
+                LONG aOriginY = 0;
+                ULONG aWidth = 0;
+                ULONG aHeight = 0;
+                ULONG aBitsPerPixel = 0;
+                if (aStatus = GuestMonitorStatus_Enabled)
+                {
+                    if (argc < 7)
+                    {
+                        errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
+                        rc = E_FAIL;
+                        break;
+                    }
+
+                    aChangeOrigin = TRUE;
+                    aOriginX      = RTStrToUInt32(argv[2]);
+                    aOriginY      = RTStrToUInt32(argv[3]);
+                    aWidth        = RTStrToUInt32(argv[4]);
+                    aHeight       = RTStrToUInt32(argv[5]);
+                    aBitsPerPixel = RTStrToUInt32(argv[6]);
+
+                    argc -= 7;
+                    argv += 7;
+                }
+                else
+                {
+                    argc -= 2;
+                    argv += 2;
+                }
+
+                ComPtr<IGuestScreenInfo> pInfo;
+                CHECK_ERROR_BREAK(pDisplay, CreateGuestScreenInfo(aDisplay, aStatus, aPrimary, aChangeOrigin,
+                                                                  aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel,
+                                                                  pInfo.asOutParam()));
+                aGuestScreenInfos.push_back(pInfo);
+            }
+
+            if (FAILED(rc))
+                break;
+
+            CHECK_ERROR_BREAK(pDisplay, SetScreenLayout(ScreenLayoutMode_Apply, ComSafeArrayAsInParam(aGuestScreenInfos)));
+        }
         else if (!strcmp(a->argv[1], "setcredentials"))
         {

trunk/src/VBox/Frontends/VBoxManage/VBoxManageHelp.cpp

@@ -825 +825 @@
                      "                                            [[<display>] [<enabled:yes|no> |\n"
                      "                                              [<xorigin> <yorigin>]]] |\n"
+                     "                            setscreenlayout <display> on|primary <xorigin> <yorigin> <xres> <yres> <bpp> | off\n"
                      "                            screenshotpng <file> [display] |\n"
                      "                            videocap on|off |\n"

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

@@ -17495 +17495 @@
     wsmap="managed"
     wrap-hint-server-addinterfaces="IEventListener"
-    reservedMethods="4" reservedAttributes="2"
+    reservedMethods="3" reservedAttributes="2"
     >
     <desc>
@@ -17844 +17844 @@
       </desc>
       <param name="screenIds" type="long" safearray="yes" dir="in"/>
+    </method>
+
+    <method name="createGuestScreenInfo">
+      <desc>
+        Make a IGuestScreenInfo object with the provided parameters.
+      </desc>
+      <param name="display" type="unsigned long" dir="in">
+        <desc>
+          The number of the guest display.
+        </desc>
+      </param>
+      <param name="status" type="GuestMonitorStatus" dir="in">
+        <desc>
+          @c True, if this guest screen is enabled,
+          @c False otherwise.
+        </desc>
+      </param>
+      <param name="primary" type="boolean" dir="in">
+        <desc>
+          Whether this guest monitor must be primary.
+        </desc>
+      </param>
+      <param name="changeOrigin" type="boolean" dir="in">
+        <desc>
+          @c True, if the origin of the guest screen should be changed,
+          @c False otherwise.
+        </desc>
+      </param>
+      <param name="originX" type="long" dir="in">
+        <desc>
+          The X origin of the guest screen.
+        </desc>
+      </param>
+      <param name="originY" type="long" dir="in">
+        <desc>
+          The Y origin of the guest screen.
+        </desc>
+      </param>
+      <param name="width" type="unsigned long" dir="in">
+        <desc>
+          The width of the guest screen.
+        </desc>
+      </param>
+      <param name="height" type="unsigned long" dir="in">
+        <desc>
+          The height of the guest screen.
+        </desc>
+      </param>
+      <param name="bitsPerPixel" type="unsigned long" dir="in">
+        <desc>
+          The number of bits per pixel of the guest screen.
+        </desc>
+      </param>
+      <param name="guestScreenInfo" type="IGuestScreenInfo" dir="out">
+        <desc>
+          The created object.
+        </desc>
+      </param>
     </method>
 

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

@@ -38 +38 @@
 
 #include "DisplaySourceBitmapWrap.h"
+#include "GuestScreenInfoWrap.h"
 
 
@@ -298 +299 @@
                                     const std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenInfo);
     virtual HRESULT detachScreens(const std::vector<LONG> &aScreenIds);
+    virtual HRESULT createGuestScreenInfo(ULONG aDisplay,
+                                          GuestMonitorStatus_T aStatus,
+                                          BOOL aPrimary,
+                                          BOOL aChangeOrigin,
+                                          LONG aOriginX,
+                                          LONG aOriginY,
+                                          ULONG aWidth,
+                                          ULONG aHeight,
+                                          ULONG aBitsPerPixel,
+                                          ComPtr<IGuestScreenInfo> &aGuestScreenInfo);
 
     // Wrapped IEventListener properties
@@ -596 +607 @@
 };
 
+class ATL_NO_VTABLE GuestScreenInfo:
+    public GuestScreenInfoWrap
+{
+public:
+
+    DECLARE_EMPTY_CTOR_DTOR(GuestScreenInfo)
+
+    HRESULT FinalConstruct();
+    void FinalRelease();
+
+    /* Public initializer/uninitializer for internal purposes only. */
+    HRESULT init(ULONG aDisplay,
+                 GuestMonitorStatus_T aGuestMonitorStatus,
+                 BOOL aPrimary,
+                 BOOL aChangeOrigin,
+                 LONG aOriginX,
+                 LONG aOriginY,
+                 ULONG aWidth,
+                 ULONG aHeight,
+                 ULONG aBitsPerPixel);
+    void uninit();
+
+private:
+    // wrapped IGuestScreenInfo properties
+    virtual HRESULT getScreenId(ULONG *aScreenId);
+    virtual HRESULT getGuestMonitorStatus(GuestMonitorStatus_T *aGuestMonitorStatus);
+    virtual HRESULT getPrimary(BOOL *aPrimary);
+    virtual HRESULT getOrigin(BOOL *aOrigin);
+    virtual HRESULT getOriginX(LONG *aOriginX);
+    virtual HRESULT getOriginY(LONG *aOriginY);
+    virtual HRESULT getWidth(ULONG *aWidth);
+    virtual HRESULT getHeight(ULONG *aHeight);
+    virtual HRESULT getBitsPerPixel(ULONG *aBitsPerPixel);
+    virtual HRESULT getExtendedInfo(com::Utf8Str &aExtendedInfo);
+
+    ULONG mScreenId;
+    GuestMonitorStatus_T mGuestMonitorStatus;
+    BOOL  mPrimary;
+    BOOL  mOrigin;
+    LONG  mOriginX;
+    LONG  mOriginY;
+    ULONG mWidth;
+    ULONG mHeight;
+    ULONG mBitsPerPixel;
+};
+
 #endif // !____H_DISPLAYIMPL
 /* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

@@ -1954 +1954 @@
         PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
         if (pVMMDevPort)
-            pVMMDevPort->pfnRequestDisplayChange(pVMMDevPort, aWidth, aHeight, aBitsPerPixel,
-                                                 aDisplay, aOriginX, aOriginY,
-                                                 RT_BOOL(aEnabled), RT_BOOL(aChangeOrigin));
+        {
+            VMMDevDisplayDef d;
+            d.idDisplay     = aDisplay;
+            d.xOrigin       = aOriginX;
+            d.yOrigin       = aOriginY;
+            d.cx            = aWidth;
+            d.cy            = aHeight;
+            d.cBitsPerPixel = aBitsPerPixel;
+            d.fDisplayFlags = VMMDEV_DISPLAY_CX | VMMDEV_DISPLAY_CY | VMMDEV_DISPLAY_BPP;
+            if (!aEnabled)
+                d.fDisplayFlags |= VMMDEV_DISPLAY_DISABLED;
+            if (aChangeOrigin)
+                d.fDisplayFlags |= VMMDEV_DISPLAY_ORIGIN;
+            if (aDisplay == 0)
+                d.fDisplayFlags |= VMMDEV_DISPLAY_PRIMARY;
+
+            pVMMDevPort->pfnRequestDisplayChange(pVMMDevPort, 1, &d, false);
+        }
     }
     return S_OK;
@@ -3122 +3137 @@
 
 HRESULT Display::setScreenLayout(ScreenLayoutMode_T aScreenLayoutMode,
-                                    const std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenInfo)
-{
-    NOREF(aScreenLayoutMode);
-    NOREF(aGuestScreenInfo);
-    return E_NOTIMPL;
+                                 const std::vector<ComPtr<IGuestScreenInfo> > &aGuestScreenInfo)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (aGuestScreenInfo.size() != mcMonitors)
+        return E_INVALIDARG;
+
+    CHECK_CONSOLE_DRV(mpDrv);
+
+    /*
+     * It is up to the guest to decide whether the hint is
+     * valid. Therefore don't do any VRAM sanity checks here.
+     */
+
+    /* Have to release the lock because the pfnRequestDisplayChange
+     * will call EMT.  */
+    alock.release();
+
+    VMMDev *pVMMDev = mParent->i_getVMMDev();
+    if (pVMMDev)
+    {
+        PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
+        if (pVMMDevPort)
+        {
+            uint32_t const cDisplays = (uint32_t)aGuestScreenInfo.size();
+
+            size_t const cbAlloc = cDisplays * sizeof(VMMDevDisplayDef);
+            VMMDevDisplayDef *paDisplayDefs = (VMMDevDisplayDef *)RTMemAlloc(cbAlloc);
+            if (paDisplayDefs)
+            {
+                for (uint32_t i = 0; i < cDisplays; ++i)
+                {
+                    VMMDevDisplayDef *p = &paDisplayDefs[i];
+                    ComPtr<IGuestScreenInfo> pScreenInfo = aGuestScreenInfo[i];
+
+                    ULONG screenId     = 0;
+                    GuestMonitorStatus_T guestMonitorStatus = GuestMonitorStatus_Enabled;
+                    BOOL  origin       = FALSE;
+                    BOOL  primary      = FALSE;
+                    LONG  originX      = 0;
+                    LONG  originY      = 0;
+                    ULONG width        = 0;
+                    ULONG height       = 0;
+                    ULONG bitsPerPixel = 0;
+
+                    pScreenInfo->COMGETTER(ScreenId)    (&screenId);
+                    pScreenInfo->COMGETTER(GuestMonitorStatus)(&guestMonitorStatus);
+                    pScreenInfo->COMGETTER(Primary)     (&primary);
+                    pScreenInfo->COMGETTER(Origin)      (&origin);
+                    pScreenInfo->COMGETTER(OriginX)     (&originX);
+                    pScreenInfo->COMGETTER(OriginY)     (&originY);
+                    pScreenInfo->COMGETTER(Width)       (&width);
+                    pScreenInfo->COMGETTER(Height)      (&height);
+                    pScreenInfo->COMGETTER(BitsPerPixel)(&bitsPerPixel);
+
+                    LogFlowFunc(("%d %d,%d %dx%d\n", screenId, originX, originY, width, height));
+
+                    p->idDisplay     = screenId;
+                    p->xOrigin       = originX;
+                    p->yOrigin       = originY;
+                    p->cx            = width;
+                    p->cy            = height;
+                    p->cBitsPerPixel = bitsPerPixel;
+                    p->fDisplayFlags = VMMDEV_DISPLAY_CX | VMMDEV_DISPLAY_CY | VMMDEV_DISPLAY_BPP;
+                    if (guestMonitorStatus == GuestMonitorStatus_Disabled)
+                        p->fDisplayFlags |= VMMDEV_DISPLAY_DISABLED;
+                    if (origin)
+                        p->fDisplayFlags |= VMMDEV_DISPLAY_ORIGIN;
+                    if (primary)
+                        p->fDisplayFlags |= VMMDEV_DISPLAY_PRIMARY;
+                }
+
+                bool const fForce =    aScreenLayoutMode == ScreenLayoutMode_Reset
+                                    || aScreenLayoutMode == ScreenLayoutMode_Apply;
+                pVMMDevPort->pfnRequestDisplayChange(pVMMDevPort, cDisplays, paDisplayDefs, fForce);
+
+                RTMemFree(paDisplayDefs);
+            }
+        }
+    }
+    return S_OK;
 }
 
@@ -3133 +3224 @@
     NOREF(aScreenIds);
     return E_NOTIMPL;
+}
+
+HRESULT Display::createGuestScreenInfo(ULONG aDisplay,
+                                       GuestMonitorStatus_T aStatus,
+                                       BOOL aPrimary,
+                                       BOOL aChangeOrigin,
+                                       LONG aOriginX,
+                                       LONG aOriginY,
+                                       ULONG aWidth,
+                                       ULONG aHeight,
+                                       ULONG aBitsPerPixel,
+                                       ComPtr<IGuestScreenInfo> &aGuestScreenInfo)
+{
+    /* Create a new object. */
+    ComObjPtr<GuestScreenInfo> obj;
+    HRESULT hr = obj.createObject();
+    if (SUCCEEDED(hr))
+        hr = obj->init(aDisplay, aStatus, aPrimary, aChangeOrigin, aOriginX, aOriginY,
+                       aWidth, aHeight, aBitsPerPixel);
+    if (SUCCEEDED(hr))
+        obj.queryInterfaceTo(aGuestScreenInfo.asOutParam());
+
+    return hr;
+}
+
+
+/*
+ * GuestScreenInfo implementation.
+ */
+DEFINE_EMPTY_CTOR_DTOR(GuestScreenInfo)
+
+HRESULT GuestScreenInfo::FinalConstruct()
+{
+    return BaseFinalConstruct();
+}
+
+void GuestScreenInfo::FinalRelease()
+{
+    uninit();
+
+    BaseFinalRelease();
+}
+
+HRESULT GuestScreenInfo::init(ULONG aDisplay,
+                              GuestMonitorStatus_T aGuestMonitorStatus,
+                              BOOL aPrimary,
+                              BOOL aChangeOrigin,
+                              LONG aOriginX,
+                              LONG aOriginY,
+                              ULONG aWidth,
+                              ULONG aHeight,
+                              ULONG aBitsPerPixel)
+{
+    LogFlowThisFunc(("[%u]\n", aDisplay));
+
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    mScreenId = aDisplay;
+    mGuestMonitorStatus = aGuestMonitorStatus;
+    mPrimary = aPrimary;
+    mOrigin = aChangeOrigin;
+    mOriginX =  aOriginX;
+    mOriginY = aOriginY;
+    mWidth = aWidth;
+    mHeight = aHeight;
+    mBitsPerPixel = aBitsPerPixel;
+
+    /* Confirm a successful initialization */
+    autoInitSpan.setSucceeded();
+
+    return S_OK;
+}
+
+void GuestScreenInfo::uninit()
+{
+    /* Enclose the state transition Ready->InUninit->NotReady */
+    AutoUninitSpan autoUninitSpan(this);
+    if (autoUninitSpan.uninitDone())
+        return;
+
+    LogFlowThisFunc(("[%u]\n", mScreenId));
+}
+
+HRESULT GuestScreenInfo::getScreenId(ULONG *aScreenId)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    *aScreenId = mScreenId;
+    return S_OK;
+}
+
+HRESULT GuestScreenInfo::getGuestMonitorStatus(GuestMonitorStatus_T *aGuestMonitorStatus)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    *aGuestMonitorStatus = mGuestMonitorStatus;
+    return S_OK;
+}
+
+HRESULT GuestScreenInfo::getPrimary(BOOL *aPrimary)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    *aPrimary = mPrimary;
+    return S_OK;
+}
+
+HRESULT GuestScreenInfo::getOrigin(BOOL *aOrigin)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    *aOrigin = mOrigin;
+    return S_OK;
+}
+
+HRESULT GuestScreenInfo::getOriginX(LONG *aOriginX)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    *aOriginX = mOriginX;
+    return S_OK;
+}
+
+HRESULT GuestScreenInfo::getOriginY(LONG *aOriginY)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    *aOriginY = mOriginY;
+    return S_OK;
+}
+
+HRESULT GuestScreenInfo::getWidth(ULONG *aWidth)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    *aWidth = mWidth;
+    return S_OK;
+}
+
+HRESULT GuestScreenInfo::getHeight(ULONG *aHeight)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    *aHeight = mHeight;
+    return S_OK;
+}
+
+HRESULT GuestScreenInfo::getBitsPerPixel(ULONG *aBitsPerPixel)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    *aBitsPerPixel = mBitsPerPixel;
+    return S_OK;
+}
+
+HRESULT GuestScreenInfo::getExtendedInfo(com::Utf8Str &aExtendedInfo)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    aExtendedInfo = com::Utf8Str();
+    return S_OK;
 }