VirtualBox

Changeset 68437 in vbox


Ignore:
Timestamp:
Aug 17, 2017 10:18:32 AM (7 years ago)
Author:
vboxsync
Message:

VBoxTray: Use VbglR3 APIs for everything. Untested.

Location:
trunk/src/VBox/Additions/WINNT/VBoxTray
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r68375 r68437  
    529529{
    530530    BOOL fDispAlreadyEnabled = false; /* check whether the monitor with ID is already enabled. */
    531     BOOL fModeReset = (Width == 0 && Height == 0 && BitsPerPixel == 0 &&
    532                        dwNewPosX == 0 && dwNewPosY == 0 && !fChangeOrigin);
     531    BOOL fModeReset = (   Width == 0 && Height == 0 && BitsPerPixel == 0
     532                       && dwNewPosX == 0 && dwNewPosY == 0 && !fChangeOrigin);
    533533    DWORD dmFields = 0;
    534534
    535535    LogFlowFunc(("[%d] %dx%d at %d,%d fChangeOrigin %d fEnabled %d fExtDisSup %d\n",
    536           Id, Width, Height, dwNewPosX, dwNewPosY, fChangeOrigin, fEnabled, fExtDispSup));
     536                 Id, Width, Height, dwNewPosX, dwNewPosY, fChangeOrigin, fEnabled, fExtDispSup));
    537537
    538538    if (!pCtx->fAnyX)
    … …  
    566566        LogFlowFunc(("ResizeDisplayDevice: NumDevices(%d) != DevNum(%d)\n", NumDevices, DevNum));
    567567
    568     DWORD i = 0;
    569 
     568    DWORD i;
    570569    for (i = 0; i < DevNum; ++i)
    571570    {
    … …  
    649648     * all rect conditions are true. Thus in this case nothing has to be done.
    650649     */
    651     if (   !fModeReset && (!fEnabled == !fDispAlreadyEnabled)
     650    if (   !fModeReset
     651        && (!fEnabled == !fDispAlreadyEnabled)
    652652        && paRects[Id].left                      == dwNewPosX
    653653        && paRects[Id].top                       == dwNewPosY
    … …  
    770770    }
    771771
    772     LogFlowFunc(("Enable And Resize Device. Id = %d, Width=%d Height=%d, \
    773          dwNewPosX = %d, dwNewPosY = %d fEnabled=%d & fExtDispSupport = %d \n",
    774          Id, Width, Height, dwNewPosX, dwNewPosY, fEnabled, fExtDispSup));
     772    LogFlowFunc(("Enable And Resize Device. Id = %d, Width=%d Height=%d, dwNewPosX = %d, dwNewPosY = %d fEnabled=%d & fExtDispSupport = %d \n",
     773                 Id, Width, Height, dwNewPosX, dwNewPosY, fEnabled, fExtDispSup));
    775774    dwStatus = EnableAndResizeDispDev(paDeviceModes, paDisplayDevices, DevNum, Id, Width, Height, BitsPerPixel,
    776775                                      dwNewPosX, dwNewPosY, fEnabled, fExtDispSup);
    … …  
    787786
    788787/**
    789  * Thread function to wait for and process display change
    790  * requests
     788 * Thread function to wait for and process display change requests.
    791789 */
    792 DECLCALLBACK(int) VBoxDisplayWorker(void *pInstance, bool volatile *pfShutdown)
    793 {
    794     AssertPtr(pInstance);
    795     LogFlowFunc(("pInstance=%p\n", pInstance));
     790static DECLCALLBACK(int) VBoxDisplayWorker(void *pvInstance, bool volatile *pfShutdown)
     791{
     792    AssertPtr(pvInstance);
     793    PVBOXDISPLAYCONTEXT pCtx = (PVBOXDISPLAYCONTEXT)pvInstance;
     794    AssertPtr(pCtx->pEnv);
     795    LogFlowFunc(("pvInstance=%p\n", pvInstance));
    796796
    797797    /*
    … …  
    801801    RTThreadUserSignal(RTThreadSelf());
    802802
    803     PVBOXDISPLAYCONTEXT pCtx = (PVBOXDISPLAYCONTEXT)pInstance;
    804 
    805     HANDLE gVBoxDriver = pCtx->pEnv->hDriver;
    806     VBoxGuestFilterMaskInfo maskInfo;
    807     DWORD cbReturned;
    808 
    809     maskInfo.u32OrMask = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST | VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED;
    810     maskInfo.u32NotMask = 0;
    811     if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
    812     {
    813         DWORD dwErr = GetLastError();
    814         LogFlowFunc(("DeviceIOControl(CtlMask - or) failed with %ld, exiting\n", dwErr));
    815         return RTErrConvertFromWin32(dwErr);
     803    int rc = VbglR3CtlFilterMask(VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST | VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED, 0 /*fNot*/);
     804    if (RT_FAILURE(rc))
     805    {
     806        LogFlowFunc(("VbglR3CtlFilterMask(mask,0): %Rrc\n", rc));
     807        return rc;
    816808    }
    817809
    … …  
    820812    VBoxDispIfResizeStarted(&pCtx->pEnv->dispIf);
    821813
    822     int rc = VINF_SUCCESS;
    823 
    824     while (*pfShutdown == false)
    825     {
    826         BOOL fExtDispSup = TRUE;
    827         /* Wait for a display change event. */
    828         VBoxGuestWaitEventInfo waitEvent;
    829         waitEvent.u32TimeoutIn   = 1000;
    830         waitEvent.u32EventMaskIn = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST | VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED;
    831         if (DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_WAITEVENT, &waitEvent, sizeof(waitEvent), &waitEvent, sizeof(waitEvent), &cbReturned, NULL))
    832         {
    833             /*LogFlowFunc(("DeviceIOControl succeeded\n"));*/
    834 
    835             if (NULL == pCtx) {
    836                 LogFlowFunc(("Invalid context detected!\n"));
    837                 break;
    838             }
    839 
    840             if (NULL == pCtx->pEnv) {
    841                 LogFlowFunc(("Invalid context environment detected!\n"));
    842                 break;
    843             }
    844 
    845             /* are we supposed to stop? */
    846             if (*pfShutdown)
    847                 break;
    848 
    849             /* did we get the right event? */
    850             if (waitEvent.u32EventFlagsOut & VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
     814    for (;;)
     815    {
     816        /*
     817         * Wait for a display change event, checking for shutdown both before and after.
     818         */
     819        if (*pfShutdown)
     820        {
     821            rc = VINF_SUCCESS;
     822            break;
     823        }
     824
     825        uint32_t fEvents = 0;
     826        rc = VbglR3WaitEvent(VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST | VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED, 1000 /*ms*/, &fEvents);
     827
     828        if (*pfShutdown)
     829        {
     830            rc = VINF_SUCCESS;
     831            break;
     832        }
     833
     834        if (RT_SUCCESS(rc))
     835        {
     836            if (fEvents & VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST)
    851837            {
    852838                LogFlowFunc(("going to get display change information\n"));
    853                 BOOL fDisplayChangeQueried;
    854 
    855 
    856                 /* We got at least one event. Read the requested resolution
    857                  * and try to set it until success. New events will not be seen
    858                  * but a new resolution will be read in this poll loop.
     839
     840                /*
     841                 * We got at least one event. (bird: What does that mean actually?  The driver wakes us up immediately upon
     842                 * receiving the event.  Or are we refering to mouse & display?  In the latter case it's misleading.)
     843                 *
     844                 * Read the requested resolution and try to set it until success.
     845                 * New events will not be seen but a new resolution will be read in
     846                 * this poll loop.
     847                 *
     848                 * Note! The interface we're using here was added in VBox 4.2.4.  As of 2017-08-16, this
     849                 *       version has been unsupported for a long time and we therefore don't bother
     850                 *       implementing fallbacks using VMMDevDisplayChangeRequest2 and VMMDevDisplayChangeRequest.
    859851                 */
    860                 /* Try if extended mode display information is available from the host. */
    861                 VMMDevDisplayChangeRequestEx displayChangeRequest = {0};
    862                 fExtDispSup                             = TRUE;
    863                 displayChangeRequest.header.size        = sizeof(VMMDevDisplayChangeRequestEx);
    864                 displayChangeRequest.header.version     = VMMDEV_REQUEST_HEADER_VERSION;
    865                 displayChangeRequest.header.requestType = VMMDevReq_GetDisplayChangeRequestEx;
    866                 displayChangeRequest.eventAck           = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
    867                 fDisplayChangeQueried = DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_VMMREQUEST(sizeof(VMMDevDisplayChangeRequestEx)), &displayChangeRequest, sizeof(VMMDevDisplayChangeRequestEx),
    868                                                                  &displayChangeRequest, sizeof(VMMDevDisplayChangeRequestEx), &cbReturned, NULL);
    869 
    870                if (!fDisplayChangeQueried)
    871                {
    872                     LogFlowFunc(("Extended Display Not Supported. Trying VMMDevDisplayChangeRequest2\n"));
    873                     fExtDispSup = FALSE; /* Extended display Change request is not supported */
    874 
    875                     displayChangeRequest.header.size        = sizeof(VMMDevDisplayChangeRequest2);
    876                     displayChangeRequest.header.version     = VMMDEV_REQUEST_HEADER_VERSION;
    877                     displayChangeRequest.header.requestType = VMMDevReq_GetDisplayChangeRequest2;
    878                     displayChangeRequest.eventAck           = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
    879                     fDisplayChangeQueried = DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_VMMREQUEST(sizeof(VMMDevDisplayChangeRequest2)), &displayChangeRequest, sizeof(VMMDevDisplayChangeRequest2),
    880                                                              &displayChangeRequest, sizeof(VMMDevDisplayChangeRequest2), &cbReturned, NULL);
    881                     displayChangeRequest.cxOrigin = 0;
    882                     displayChangeRequest.cyOrigin = 0;
    883                     displayChangeRequest.fChangeOrigin = 0;
    884                     displayChangeRequest.fEnabled = 1; /* Always Enabled for old VMs on Host.*/
    885                 }
    886 
    887                 if (!fDisplayChangeQueried)
    888                 {
    889                     LogFlowFunc(("Extended Display Not Supported. Trying VMMDevDisplayChangeRequest\n"));
    890                     fExtDispSup = FALSE; /*Extended display Change request is not supported */
    891                     /* Try the old version of the request for old VBox hosts. */
    892                     displayChangeRequest.header.size        = sizeof(VMMDevDisplayChangeRequest);
    893                     displayChangeRequest.header.version     = VMMDEV_REQUEST_HEADER_VERSION;
    894                     displayChangeRequest.header.requestType = VMMDevReq_GetDisplayChangeRequest;
    895                     displayChangeRequest.eventAck           = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
    896                     fDisplayChangeQueried = DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_VMMREQUEST(sizeof(VMMDevDisplayChangeRequest)), &displayChangeRequest, sizeof(VMMDevDisplayChangeRequest),
    897                                                              &displayChangeRequest, sizeof(VMMDevDisplayChangeRequest), &cbReturned, NULL);
    898                     displayChangeRequest.display = 0;
    899                     displayChangeRequest.cxOrigin = 0;
    900                     displayChangeRequest.cyOrigin = 0;
    901                     displayChangeRequest.fChangeOrigin = 0;
    902                     displayChangeRequest.fEnabled = 1; /* Always Enabled for old VMs on Host.*/
    903                 }
    904 
    905                 if (fDisplayChangeQueried)
     852                uint32_t cx             = 0;
     853                uint32_t cy             = 0;
     854                uint32_t cBits          = 0;
     855                uint32_t iDisplay       = 0;
     856                uint32_t cxOrigin       = 0;
     857                uint32_t cyOrigin       = 0;
     858                bool     fChangeOrigin  = false;
     859                bool     fEnabled       = false;
     860                rc = VbglR3GetDisplayChangeRequest(&cx, &cy, &cBits, &iDisplay, &cxOrigin, &cyOrigin, &fEnabled, &fChangeOrigin,
     861                                                   true /*fAck*/);
     862                if (RT_SUCCESS(rc))
    906863                {
    907864                    /* Try to set the requested video mode. Repeat until it is successful or is rejected by the driver. */
    908                     LogFlowFunc(("DisplayChangeReqEx parameters  aDisplay=%d x xRes=%d x yRes=%d x bpp=%d x SecondayMonEnb=%d x NewOriginX=%d x NewOriginY=%d x ChangeOrigin=%d\n",
    909                         displayChangeRequest.display,
    910                         displayChangeRequest.xres,
    911                         displayChangeRequest.yres,
    912                         displayChangeRequest.bpp,
    913                         displayChangeRequest.fEnabled,
    914                         displayChangeRequest.cxOrigin,
    915                         displayChangeRequest.cyOrigin,
    916                         displayChangeRequest.fChangeOrigin));
     865                    LogFlowFunc(("DisplayChangeReqEx parameters  iDisplay=%d x cx=%d x cy=%d x cBits=%d x SecondayMonEnb=%d x NewOriginX=%d x NewOriginY=%d x ChangeOrigin=%d\n",
     866                                 iDisplay, cx, cy, cBits, fEnabled, cxOrigin, cyOrigin, fChangeOrigin));
    917867
    918868                    for (;;)
    919869                    {
    920                         VBOXDISPLAY_DRIVER_TYPE enmDriverType = getVBoxDisplayDriverType (pCtx);
    921 
     870                        VBOXDISPLAY_DRIVER_TYPE enmDriverType = getVBoxDisplayDriverType(pCtx);
    922871                        if (enmDriverType == VBOXDISPLAY_DRIVER_TYPE_UNKNOWN)
    923872                        {
    … …  
    930879                            LogFlowFunc(("Detected W2K or later\n"));
    931880                            if (!ResizeDisplayDevice(pCtx,
    932                                                         displayChangeRequest.display,
    933                                                         displayChangeRequest.xres,
    934                                                         displayChangeRequest.yres,
    935                                                         displayChangeRequest.bpp,
    936                                                         displayChangeRequest.fEnabled,
    937                                                         displayChangeRequest.cxOrigin,
    938                                                         displayChangeRequest.cyOrigin,
    939                                                         displayChangeRequest.fChangeOrigin,
    940                                                         fExtDispSup
    941                                                         ))
     881                                                     iDisplay,
     882                                                     cx,
     883                                                     cy,
     884                                                     cBits,
     885                                                     fEnabled,
     886                                                     cxOrigin,
     887                                                     cyOrigin,
     888                                                     fChangeOrigin,
     889                                                     true /*fExtDispSup*/ ))
    942890                            {
    943891                                LogFlowFunc(("ResizeDipspalyDevice return 0\n"));
    … …  
    949897                        {
    950898                            LogFlowFunc(("Detected NT\n"));
    951                             ResizeDisplayDeviceNT4(
    952                                 displayChangeRequest.xres,
    953                                 displayChangeRequest.yres,
    954                                 displayChangeRequest.bpp);
     899                            ResizeDisplayDeviceNT4(cx, cy, cBits);
    955900                            break;
    956901                        }
    … …  
    962907            } // if (fDisplayChangeQueried)
    963908
    964             if (waitEvent.u32EventFlagsOut & VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED)
     909            if (fEvents & VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED)
    965910                hlpReloadCursor();
    966911        }
    … …  
    980925                }
    981926            }
     927
    982928            /* sleep a bit to not eat too much CPU in case the above call always fails */
    983             RTThreadSleep(10);
     929            if (rc != VERR_TIMEOUT)
     930                RTThreadSleep(10);
    984931        }
    985932    }
    … …  
    988935     * Remove event filter and graphics capability report.
    989936     */
    990     maskInfo.u32OrMask = 0;
    991     maskInfo.u32NotMask = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST | VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED;
    992     if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
    993         LogFlowFunc(("DeviceIOControl(CtlMask - not) failed\n"));
     937    int rc2 = VbglR3CtlFilterMask(0 /*fOr*/, VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST | VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED /*fNot*/);
     938    if (RT_FAILURE(rc2))
     939        LogFlowFunc(("VbglR3CtlFilterMask failed: %Rrc\n", rc2));
    994940    PostMessage(g_hwndToolWindow, WM_VBOX_GRAPHICS_UNSUPPORTED, 0, 0);
    995941

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxSeamless.cpp

    r63100 r68437  
    371371 * requests
    372372 */
    373 static DECLCALLBACK(int) VBoxSeamlessWorker(void *pInstance, bool volatile *pfShutdown)
    374 {
    375     AssertPtrReturn(pInstance, VERR_INVALID_POINTER);
    376     LogFlowFunc(("pInstance=%p\n", pInstance));
     373static DECLCALLBACK(int) VBoxSeamlessWorker(void *pvInstance, bool volatile *pfShutdown)
     374{
     375    AssertPtrReturn(pvInstance, VERR_INVALID_POINTER);
     376    LogFlowFunc(("pvInstance=%p\n", pvInstance));
    377377
    378378    /*
    379      * Tell the control thread that it can continue
    380      * spawning services.
     379     * Tell the control thread that it can continue spawning services.
    381380     */
    382381    RTThreadUserSignal(RTThreadSelf());
    383382
    384     PVBOXSEAMLESSCONTEXT pCtx = (PVBOXSEAMLESSCONTEXT)pInstance;
    385 
    386     HANDLE gVBoxDriver = pCtx->pEnv->hDriver;
    387     VBoxGuestFilterMaskInfo maskInfo;
    388     DWORD cbReturned;
    389     BOOL fWasScreenSaverActive = FALSE, fRet;
    390 
    391     maskInfo.u32OrMask = VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST;
    392     maskInfo.u32NotMask = 0;
    393     if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
    394     {
    395         DWORD dwErr = GetLastError();
    396         LogRel(("Seamless: DeviceIOControl(CtlMask) failed with %ld, exiting ...\n", dwErr));
    397         return RTErrConvertFromWin32(dwErr);
    398     }
    399 
    400     int rc = VINF_SUCCESS;
    401 
     383    int rc = VbglR3CtlFilterMask(VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST, 0 /*fNot*/);
     384    if (RT_FAILURE(rc))
     385    {
     386        LogRel(("Seamless: VbglR3CtlFilterMask(VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST,0) failed with %Rrc, exiting ...\n", rc));
     387        return rc;
     388    }
     389
     390    BOOL fWasScreenSaverActive = FALSE;
    402391    for (;;)
    403392    {
    404         /* wait for a seamless change event */
    405         VBoxGuestWaitEventInfo waitEvent;
    406         waitEvent.u32TimeoutIn = 5000;
    407         waitEvent.u32EventMaskIn = VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST;
    408         if (DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_WAITEVENT, &waitEvent, sizeof(waitEvent), &waitEvent, sizeof(waitEvent), &cbReturned, NULL))
    409         {
    410             /* are we supposed to stop? */
    411             if (*pfShutdown)
    412                 break;
    413 
     393        /*
     394         * Wait for a seamless change event, check for shutdown both before and after.
     395         */
     396        if (*pfShutdown)
     397        {
     398            rc = VINF_SUCCESS;
     399            break;
     400        }
     401
     402        uint32_t fEvent = 0;
     403        rc = VbglR3WaitEvent(VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST, 5000 /*ms*/, &fEvent);
     404
     405        if (*pfShutdown)
     406        {
     407            rc = VINF_SUCCESS;
     408            break;
     409        }
     410
     411        if (RT_SUCCESS(rc))
     412        {
    414413            /* did we get the right event? */
    415             if (waitEvent.u32EventFlagsOut & VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST)
     414            if (fEvent & VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST)
    416415            {
    417                 /* We got at least one event. Read the requested resolution
     416                /*
     417                 * We got at least one event. Read the requested resolution
    418418                 * and try to set it until success. New events will not be seen
    419419                 * but a new resolution will be read in this poll loop.
    … …  
    422422                {
    423423                    /* get the seamless change request */
    424                     VMMDevSeamlessChangeRequest seamlessChangeRequest = {0};
    425                     vmmdevInitRequest((VMMDevRequestHeader*)&seamlessChangeRequest, VMMDevReq_GetSeamlessChangeRequest);
    426                     seamlessChangeRequest.eventAck = VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST;
    427 
    428                     BOOL fSeamlessChangeQueried = DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_VMMREQUEST(sizeof(seamlessChangeRequest)), &seamlessChangeRequest, sizeof(seamlessChangeRequest),
    429                                                                  &seamlessChangeRequest, sizeof(seamlessChangeRequest), &cbReturned, NULL);
    430                     if (fSeamlessChangeQueried)
     424                    VMMDevSeamlessMode enmMode = (VMMDevSeamlessMode)-1;
     425                    rc = VbglR3SeamlessGetLastEvent(&enmMode);
     426                    if (RT_SUCCESS(rc))
    431427                    {
    432                         LogFlowFunc(("Mode changed to %d\n", seamlessChangeRequest.mode));
    433 
    434                         switch(seamlessChangeRequest.mode)
     428                        LogFlowFunc(("Mode changed to %d\n", enmMode));
     429
     430                        BOOL fRet;
     431                        switch (enmMode)
    435432                        {
    436                         case VMMDev_Seamless_Disabled:
    437                             if (fWasScreenSaverActive)
    438                             {
    439                                 LogRel(("Seamless: Re-enabling the screensaver\n"));
    440                                 fRet = SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, TRUE, NULL, 0);
     433                            case VMMDev_Seamless_Disabled:
     434                                if (fWasScreenSaverActive)
     435                                {
     436                                    LogRel(("Seamless: Re-enabling the screensaver\n"));
     437                                    fRet = SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, TRUE, NULL, 0);
     438                                    if (!fRet)
     439                                        LogRel(("Seamless: SystemParametersInfo SPI_SETSCREENSAVEACTIVE failed with %ld\n", GetLastError()));
     440                                }
     441                                PostMessage(g_hwndToolWindow, WM_VBOX_SEAMLESS_DISABLE, 0, 0);
     442                                break;
     443
     444                            case VMMDev_Seamless_Visible_Region:
     445                                fRet = SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, &fWasScreenSaverActive, 0);
     446                                if (!fRet)
     447                                    LogRel(("Seamless: SystemParametersInfo SPI_GETSCREENSAVEACTIVE failed with %ld\n", GetLastError()));
     448
     449                                if (fWasScreenSaverActive)
     450                                    LogRel(("Seamless: Disabling the screensaver\n"));
     451
     452                                fRet = SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE, NULL, 0);
    441453                                if (!fRet)
    442454                                    LogRel(("Seamless: SystemParametersInfo SPI_SETSCREENSAVEACTIVE failed with %ld\n", GetLastError()));
    443                             }
    444                             PostMessage(g_hwndToolWindow, WM_VBOX_SEAMLESS_DISABLE, 0, 0);
    445                             break;
    446 
    447                         case VMMDev_Seamless_Visible_Region:
    448                             fRet = SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, &fWasScreenSaverActive, 0);
    449                             if (!fRet)
    450                                 LogRel(("Seamless: SystemParametersInfo SPI_GETSCREENSAVEACTIVE failed with %ld\n", GetLastError()));
    451 
    452                             if (fWasScreenSaverActive)
    453                                 LogRel(("Seamless: Disabling the screensaver\n"));
    454 
    455                             fRet = SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE, NULL, 0);
    456                             if (!fRet)
    457                                 LogRel(("Seamless: SystemParametersInfo SPI_SETSCREENSAVEACTIVE failed with %ld\n", GetLastError()));
    458                             PostMessage(g_hwndToolWindow, WM_VBOX_SEAMLESS_ENABLE, 0, 0);
    459                             break;
    460 
    461                         case VMMDev_Seamless_Host_Window:
    462                             break;
    463 
    464                         default:
    465                             AssertFailed();
    466                             break;
     455                                PostMessage(g_hwndToolWindow, WM_VBOX_SEAMLESS_ENABLE, 0, 0);
     456                                break;
     457
     458                            case VMMDev_Seamless_Host_Window:
     459                                break;
     460
     461                            default:
     462                                AssertFailed();
     463                                break;
    467464                        }
    468465                        break;
    469466                    }
    470                     else
    471                         LogRel(("Seamless: DeviceIoControl(ChangeReq) failed with %ld\n", GetLastError()));
     467
     468                    LogRel(("Seamless: VbglR3SeamlessGetLastEvent() failed with %Rrc\n", rc));
    472469
    473470                    if (*pfShutdown)
    … …  
    479476            }
    480477        }
    481         else
    482         {
    483             /* sleep a bit to not eat too much CPU in case the above call always fails */
     478        /* sleep a bit to not eat too much CPU in case the above call always fails */
     479        else if (rc != VERR_TIMEOUT)
    484480            RTThreadSleep(10);
    485         }
    486 
    487         if (*pfShutdown)
    488             break;
    489     }
    490 
    491     maskInfo.u32OrMask = 0;
    492     maskInfo.u32NotMask = VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST;
    493     if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
    494         LogRel(("Seamless: DeviceIOControl(CtlMask) failed with %ld\n", GetLastError()));
     481    }
     482
     483    int rc2 = VbglR3CtlFilterMask(0 /*fOk*/, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST);
     484    if (RT_FAILURE(rc2))
     485        LogRel(("Seamless: VbglR3CtlFilterMask(0, VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST) failed with %Rrc\n", rc));
    495486
    496487    LogFlowFuncLeaveRC(rc);

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

    r65442 r68437  
    136136*   Global Variables                                                                                                             *
    137137*********************************************************************************************************************************/
    138 HANDLE                g_hVBoxDriver;
    139138HANDLE                g_hStopSem;
    140139HANDLE                g_hSeamlessWtNotifyEvent = 0;
    … …  
    469468    }
    470469    return false;
    471 }
    472 
    473 static int vboxTrayOpenBaseDriver(void)
    474 {
    475     /* Open VBox guest driver. */
    476     DWORD dwErr = ERROR_SUCCESS;
    477     g_hVBoxDriver = CreateFile(VBOXGUEST_DEVICE_NAME,
    478                              GENERIC_READ | GENERIC_WRITE,
    479                              FILE_SHARE_READ | FILE_SHARE_WRITE,
    480                              NULL,
    481                              OPEN_EXISTING,
    482                              FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
    483                              NULL);
    484     if (g_hVBoxDriver == INVALID_HANDLE_VALUE)
    485     {
    486         dwErr = GetLastError();
    487         LogRel(("Could not open VirtualBox Guest Additions driver! Please install / start it first! Error = %08X\n", dwErr));
    488     }
    489     return RTErrConvertFromWin32(dwErr);
    490 }
    491 
    492 static void vboxTrayCloseBaseDriver(void)
    493 {
    494     if (g_hVBoxDriver)
    495     {
    496         CloseHandle(g_hVBoxDriver);
    497         g_hVBoxDriver = NULL;
    498     }
    499470}
    500471
    … …  
    821792        VBOXSERVICEENV svcEnv;
    822793        svcEnv.hInstance = g_hInstance;
    823         svcEnv.hDriver   = g_hVBoxDriver;
    824794
    825795        /* Initializes disp-if to default (XPDM) mode. */
    … …  
    1003973
    1004974    if (RT_SUCCESS(rc))
    1005     {
    1006975        rc = VbglR3Init();
    1007         if (RT_SUCCESS(rc))
    1008             rc = vboxTrayOpenBaseDriver();
    1009     }
    1010 
    1011976    if (RT_SUCCESS(rc))
    1012977    {
    … …  
    10731038    }
    10741039    LogRel(("Ended\n"));
    1075     vboxTrayCloseBaseDriver();
    10761040
    10771041    /* Release instance mutex. */
    … …  
    16241588static int VBoxAcquireGuestCaps(uint32_t fOr, uint32_t fNot, bool fCfg)
    16251589{
    1626     DWORD cbReturned = 0;
    1627     VBoxGuestCapsAquire Info;
    16281590    Log(("VBoxAcquireGuestCaps or(0x%x), not(0x%x), cfx(%d)\n", fOr, fNot, fCfg));
    1629     Info.enmFlags = fCfg ? VBOXGUESTCAPSACQUIRE_FLAGS_CONFIG_ACQUIRE_MODE : VBOXGUESTCAPSACQUIRE_FLAGS_NONE;
    1630     Info.rc = VERR_NOT_IMPLEMENTED;
    1631     Info.u32OrMask = fOr;
    1632     Info.u32NotMask = fNot;
    1633     if (!DeviceIoControl(g_hVBoxDriver, VBOXGUEST_IOCTL_GUEST_CAPS_ACQUIRE, &Info, sizeof(Info), &Info, sizeof(Info), &cbReturned, NULL))
    1634     {
    1635         DWORD LastErr = GetLastError();
    1636         LogFlowFunc(("DeviceIoControl VBOXGUEST_IOCTL_GUEST_CAPS_ACQUIRE failed LastErr %d\n", LastErr));
    1637         return RTErrConvertFromWin32(LastErr);
    1638     }
    1639 
    1640     int rc = Info.rc;
    1641     if (!RT_SUCCESS(rc))
    1642     {
    1643         LogFlowFunc(("VBOXGUEST_IOCTL_GUEST_CAPS_ACQUIRE failed rc %d\n", rc));
    1644         return rc;
    1645     }
    1646 
     1591    int rc = VbglR3AcquireGuestCaps(fOr, fNot, fCfg);
     1592    if (RT_FAILURE(rc))
     1593        LogFlowFunc(("VBOXGUEST_IOCTL_GUEST_CAPS_ACQUIRE failed: %Rrc\n", rc));
    16471594    return rc;
    16481595}

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxTray.h

    r62865 r68437  
    8282    /** hInstance of VBoxTray. */
    8383    HINSTANCE hInstance;
    84     /** Handle of guest driver. */
    85     HANDLE    hDriver;
    8684    /* Display driver interface, XPDM - WDDM abstraction see VBOXDISPIF** definitions above */
    8785    /** @todo r=andy Argh. Needed by the "display" + "seamless" services (which in turn get called

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxVRDP.cpp

    r63100 r68437  
    330330 * Thread function to wait for and process mode change requests
    331331 */
    332 static DECLCALLBACK(int) VBoxVRDPWorker(void *pInstance, bool volatile *pfShutdown)
    333 {
    334     AssertPtrReturn(pInstance, VERR_INVALID_POINTER);
     332static DECLCALLBACK(int) VBoxVRDPWorker(void *pvInstance, bool volatile *pfShutdown)
     333{
     334    AssertPtrReturn(pvInstance, VERR_INVALID_POINTER);
     335    PVBOXVRDPCONTEXT pCtx = (PVBOXVRDPCONTEXT)pvInstance;
    335336
    336337    LogFlowFuncEnter();
    337338
    338339    /*
    339      * Tell the control thread that it can continue
    340      * spawning services.
     340     * Tell the control thread that it can continue spawning services.
    341341     */
    342342    RTThreadUserSignal(RTThreadSelf());
    343343
    344     PVBOXVRDPCONTEXT pCtx = (PVBOXVRDPCONTEXT)pInstance;
    345     AssertPtr(pCtx);
    346 
    347     HANDLE gVBoxDriver = pCtx->pEnv->hDriver;
    348     VBoxGuestFilterMaskInfo maskInfo;
    349     DWORD cbReturned;
    350 
    351     maskInfo.u32OrMask = VMMDEV_EVENT_VRDP;
    352     maskInfo.u32NotMask = 0;
    353     if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
    354     {
    355         DWORD dwErr = GetLastError();
    356         LogFlowFunc(("DeviceIOControl(CtlMask) failed with %ld, exiting\n", dwErr));
    357         return RTErrConvertFromWin32(dwErr);
    358     }
    359 
    360     int rc = VINF_SUCCESS;
     344    int rc = VbglR3CtlFilterMask(VMMDEV_EVENT_VRDP, 0 /*fNot*/);
     345    if (RT_FAILURE(rc))
     346    {
     347        LogRel(("VbglR3CtlFilterMask(VMMDEV_EVENT_VRDP, 0) failed with %Rrc, exiting...\n"));
     348        return rc;
     349    }
    361350
    362351    for (;;)
    363352    {
    364         /* wait for the event */
    365         VBoxGuestWaitEventInfo waitEvent;
    366         waitEvent.u32TimeoutIn   = 5000;
    367         waitEvent.u32EventMaskIn = VMMDEV_EVENT_VRDP;
    368         if (DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_WAITEVENT, &waitEvent, sizeof(waitEvent), &waitEvent, sizeof(waitEvent), &cbReturned, NULL))
     353        /*
     354         * Wait for the event, checking the shutdown flag both before and after the call.
     355         */
     356        if (*pfShutdown)
    369357        {
    370             /* are we supposed to stop? */
    371             if (*pfShutdown)
    372                 break;
    373 
     358            rc = VINF_SUCCESS;
     359            break;
     360        }
     361
     362        uint32_t fEvent = 0;
     363        rc = VbglR3WaitEvent(VMMDEV_EVENT_VRDP, 5000 /*ms*/, &fEvent);
     364
     365        if (*pfShutdown)
     366        {
     367            rc = VINF_SUCCESS;
     368            break;
     369        }
     370
     371        if (RT_SUCCESS(rc))
     372        {
    374373            /* did we get the right event? */
    375             if (waitEvent.u32EventFlagsOut & VMMDEV_EVENT_VRDP)
     374            if (fEvent & VMMDEV_EVENT_VRDP)
    376375            {
    377                 /* Call the host to get VRDP status and the experience level. */
    378                 VMMDevVRDPChangeRequest vrdpChangeRequest = {0};
    379 
    380                 vrdpChangeRequest.header.size            = sizeof(VMMDevVRDPChangeRequest);
    381                 vrdpChangeRequest.header.version         = VMMDEV_REQUEST_HEADER_VERSION;
    382                 vrdpChangeRequest.header.requestType     = VMMDevReq_GetVRDPChangeRequest;
    383                 vrdpChangeRequest.u8VRDPActive           = 0;
    384                 vrdpChangeRequest.u32VRDPExperienceLevel = 0;
    385 
    386                 if (DeviceIoControl (gVBoxDriver,
    387                                      VBOXGUEST_IOCTL_VMMREQUEST(sizeof(VMMDevVRDPChangeRequest)),
    388                                      &vrdpChangeRequest,
    389                                      sizeof(VMMDevVRDPChangeRequest),
    390                                      &vrdpChangeRequest,
    391                                      sizeof(VMMDevVRDPChangeRequest),
    392                                      &cbReturned, NULL))
    393                 {
    394                     LogFlowFunc(("u8VRDPActive = %d, level %d\n", vrdpChangeRequest.u8VRDPActive, vrdpChangeRequest.u32VRDPExperienceLevel));
    395 
    396                     if (vrdpChangeRequest.u8VRDPActive)
     376                bool     fActive = false;
     377                uint32_t uExperienceLevel = 0;
     378                rc = VbglR3VrdpGetChangeRequest(&fActive, &uExperienceLevel);
     379                if (RT_SUCCESS(rc))
     380                {
     381                    LogFlowFunc(("u8VRDPActive = %d, level %d\n", fActive, uExperienceLevel));
     382
     383                    if (fActive)
    397384                    {
    398                         pCtx->level = vrdpChangeRequest.u32VRDPExperienceLevel;
     385                        pCtx->level = uExperienceLevel;
    399386                        vboxExperienceSet (pCtx->level);
    400387
    … …  
    437424                    /* sleep a bit to not eat too much CPU in case the above call always fails */
    438425                    RTThreadSleep(10);
    439 
    440                     if (*pfShutdown)
    441                         break;
    442426                }
    443427            }
    444428        }
     429        /* sleep a bit to not eat too much CPU in case the above call always fails */
    445430        else
    446         {
    447             /* sleep a bit to not eat too much CPU in case the above call always fails */
    448431            RTThreadSleep(50);
    449 
    450             if (*pfShutdown)
    451                 break;
    452         }
    453     }
    454 
    455     maskInfo.u32OrMask  = 0;
    456     maskInfo.u32NotMask = VMMDEV_EVENT_VRDP;
    457     if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
    458         LogFlowFunc(("DeviceIOControl(CtlMask) failed\n"));
     432    }
     433
     434    int rc2 = VbglR3CtlFilterMask(0 /*fOr*/, VMMDEV_EVENT_VRDP);
     435    if (RT_FAILURE(rc2))
     436        LogRel(("VbglR3CtlFilterMask(0 /*fOr*/, VMMDEV_EVENT_VRDP) failed with %Rrc\n", rc));
    459437
    460438    LogFlowFuncLeaveRC(rc);
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette