/****************************** Module Header ******************************\ * Module Name: fullscr.c * * Copyright (c) 1985 - 1999, Microsoft Corporation * * This module contains all the fullscreen code for Win32k. * * History: * 12-Dec-1991 mikeke Created \***************************************************************************/ #include "precomp.h" #pragma hdrstop /***************************************************************************\ * We can only have one fullscreen window at a time so this information can * be store globally * * We partially use busy waiting to set the state of the hardware. * The problem is that while we are in the middle of a fullscreen switch, * we leave the critical section ! So someone else could come in and change * the state of the fullscreen stuff. * In order to keep the system from getting confused about the state of the * device, we actually "post" the request. * * What we do with external requests for switching, is that we will do busy * waiting on these state variables. * So an app won't be able to request a fullscreen switch while one is under * way. This is a way to make the system completely reentrant for state * switches. * * The state variables themselves can only be touched while owning the * critical section. We are guaranteed that we will not busy wait forever * since the switch operations (although long) will eventually finish. * * 20-Mar-1996 andreva Created \***************************************************************************/ LONG TraceFullscreenSwitch; #define NOSWITCHER ((HANDLE)-1) HANDLE idSwitcher = NOSWITCHER; BOOL fRedoFullScreenSwitch; BOOL fGdiEnabled = TRUE; POINT gptCursorFullScreen; void SetVDMCursorBounds(LPRECT lprc); VOID UserSetDelayedChangeBroadcastForAllDesktops(PDESKTOP pCurrentDesktop); NTSTATUS xxxRequestOutOfFullScreenMode(VOID); VOID UserSetDelayedChangeBroadcastForAllDesktops( PDESKTOP pCurrentDesktop) { PWINDOWSTATION pwinsta; PDESKTOP pdesk; /* * Get a pointer to the windowstation so we can change display * setting for all of its destops. */ if ((pwinsta = grpWinStaList) == NULL) { RIPMSG0(RIP_WARNING, "UserSaveCurrentModeForAllDesktops - No interactive WindowStation!!!\n"); return; } /* * Walk all the desktops of the winstation and, for each of them, * just set its delayed Broadcast indicator to TRUE so that * next switch to that destop will force Display Settings change * messages to be broadcasted to windows of that desktop. */ pdesk = pwinsta->rpdeskList; while (pdesk != NULL) { if (pdesk != pCurrentDesktop) { pdesk->dwDTFlags |= DF_NEWDISPLAYSETTINGS; } pdesk = pdesk->rpdeskNext; } } /***************************************************************************\ * FullScreenCleanup * * This is called during thread cleanup, we test to see if we died during a * full screen switch and switch back to the GDI desktop if we did. * * NOTE: * All the variables touched here are guaranteed to be touched under * the CritSect. * * 12-Dec-1991 mikeke Created \***************************************************************************/ void FullScreenCleanup() { if (PsGetCurrentThreadId() == idSwitcher) { /* * correct the full screen state */ if (fGdiEnabled) { TRACE_SWITCH(("Switching: FullScreenCleanup: Gdi Enabled\n")); /* * gdi is enabled, we are switching away from gdi the only thing we * could have done so far is locking the screen so unlock it. */ CLEAR_PUDF(PUDF_LOCKFULLSCREEN); LockWindowUpdate2(NULL, TRUE); } else { /* * GDI is not enabled . This means we were switching from a full * screen to another fullscreen or back to GDI. Or we could have * disabled gdi and sent a message to the new full screen which * never got completed. * * In any case this probably means the fullscreen guy is gone so * we will switch back to gdi. * * delete any left over saved screen state stuff * set the fullscreen to nothing and then send a message that will * cause us to switch back to the gdi desktop */ TL tlpwndT; TRACE_SWITCH(("Switching: FullScreenCleanup: Gdi Disabled\n")); Unlock(&gspwndFullScreen); gbFullScreen = FULLSCREEN; ThreadLock(grpdeskRitInput->pDeskInfo->spwnd, &tlpwndT); xxxSendNotifyMessage( grpdeskRitInput->pDeskInfo->spwnd, WM_FULLSCREEN, GDIFULLSCREEN, (LPARAM)HW(grpdeskRitInput->pDeskInfo->spwnd)); ThreadUnlock(&tlpwndT); } idSwitcher = NOSWITCHER; fRedoFullScreenSwitch = FALSE; } } /***************************************************************************\ * xxxMakeWindowForegroundWithState * * Syncs the screen graphics mode with the mode of the specified (foreground) * window * * We make sure only one thread is going through this code by checking * idSwitcher. If idSwticher is non-null someone is allready in this code * * 12-Dec-1991 mikeke Created \***************************************************************************/ BOOL xxxMakeWindowForegroundWithState( PWND pwnd, BYTE NewState) { PWND pwndNewFG; TL tlpwndNewFG; TRACE_SWITCH(("Switching: xxxMakeWindowForegroundWithState: Enter\n")); TRACE_SWITCH(("\t \t pwnd = %08lx\n", pwnd)); TRACE_SWITCH(("\t \t NewState = %d\n", NewState)); CheckLock(pwnd); UserAssert(IsWinEventNotifyDeferredOK()); /* * If we should switch to a specific window save that window */ if (pwnd != NULL) { if (NewState == GDIFULLSCREEN) { Lock(&gspwndShouldBeForeground, pwnd); } /* * Change to the new state */ SetFullScreen(pwnd, NewState); if (NewState == FULLSCREEN && (gpqForeground == NULL || gpqForeground->spwndActive != pwnd)) { SetFullScreen(pwnd, FULLSCREENMIN); } } // // Since we leave the critical section during the switch, some other // thread could come into this routine and request a switch. The global // will be reset, and we will use the loop to perform the next switch. // if (idSwitcher != NOSWITCHER) { fRedoFullScreenSwitch = TRUE; TRACE_SWITCH(("Switching: xxxMakeWindowForegroundWithState was posted: Exit\n")); return TRUE; } UserAssert(!fRedoFullScreenSwitch); idSwitcher = PsGetCurrentThreadId(); /* * We loop, switching full screens until all states have stabilized */ while (TRUE) { /* * figure out who should be foreground */ fRedoFullScreenSwitch = FALSE; if (gspwndShouldBeForeground != NULL) { pwndNewFG = gspwndShouldBeForeground; Unlock(&gspwndShouldBeForeground); } else { if (gpqForeground != NULL && gpqForeground->spwndActive != NULL) { pwndNewFG = gpqForeground->spwndActive; if (GetFullScreen(pwndNewFG) == WINDOWED || GetFullScreen(pwndNewFG) == FULLSCREENMIN) { pwndNewFG = PWNDDESKTOP(pwndNewFG); } } else { /* * No active window, switch to current desktop */ pwndNewFG = grpdeskRitInput->pDeskInfo->spwnd; } } /* * We don't need to switch if the right window is already foreground */ if (pwndNewFG == gspwndFullScreen) { break; } ThreadLock(pwndNewFG, &tlpwndNewFG); { BYTE bStateNew = GetFullScreen(pwndNewFG); TL tlpwndOldFG; PWND pwndOldFG = gspwndFullScreen; BYTE bStateOld = gbFullScreen; ThreadLock(pwndOldFG, &tlpwndOldFG); Lock(&gspwndFullScreen, pwndNewFG); gbFullScreen = bStateNew; UserAssert(!HMIsMarkDestroy(gspwndFullScreen)); /* * If the old screen was GDIFULLSCREEN and we are switching to * GDIFULLSCREEN then just repaint */ /* * BUG 231647: For remote sessions it can happen that * pwndOldFG is NULL but the display is enabled therefore a * call to DrvEnableMDEV would confuse the Drv* code. The way * this happens is when gspwndFullScreen was the desktop window * of a desktop that got destroyed after we switched away from it. */ if ((pwndOldFG != NULL || gbRemoteSession) && bStateOld == GDIFULLSCREEN && bStateNew == GDIFULLSCREEN) { xxxRedrawWindow(pwndNewFG, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE | RDW_ERASENOW); ThreadUnlock(&tlpwndOldFG); } else { /* * tell old 'foreground' window it is losing control of the screen */ if (pwndOldFG != NULL) { switch (bStateOld) { case FULLSCREEN: if (GetFullScreen(pwndOldFG) == FULLSCREEN) { SetFullScreen(pwndOldFG, FULLSCREENMIN); } xxxSendMessage(pwndOldFG, WM_FULLSCREEN, FALSE, 0); xxxCapture(GETPTI(pwndOldFG), NULL, FULLSCREEN_CAPTURE); SetVDMCursorBounds(NULL); break; case GDIFULLSCREEN: /* * Lock out other windows from drawing while we are fullscreen */ LockWindowUpdate2(pwndOldFG, TRUE); SET_PUDF(PUDF_LOCKFULLSCREEN); UserAssert(fGdiEnabled == TRUE); if (!SafeDisableMDEV()) { /* * Restore the previous state before bailing. */ CLEAR_PUDF(PUDF_LOCKFULLSCREEN); LockWindowUpdate2(NULL, TRUE); Lock(&gspwndFullScreen, pwndOldFG); gbFullScreen = bStateOld; ThreadUnlock(&tlpwndOldFG); ThreadUnlock(&tlpwndNewFG); idSwitcher = NOSWITCHER; return FALSE; } gptCursorFullScreen = gpsi->ptCursor; fGdiEnabled = FALSE; break; default: RIPMSG0(RIP_ERROR, "xxxMakeWindowForegroundWithState: bad screen state"); break; } } ThreadUnlock(&tlpwndOldFG); switch (bStateNew) { case FULLSCREEN: xxxCapture(GETPTI(pwndNewFG), pwndNewFG, FULLSCREEN_CAPTURE); xxxSendMessage(pwndNewFG, WM_FULLSCREEN, TRUE, 0); break; case GDIFULLSCREEN: if (ISTS() && pwndOldFG != NULL) { UserAssert(fGdiEnabled == FALSE); } SafeEnableMDEV(); fGdiEnabled = TRUE; /* * Return the cursor to it's old state. Reset the screen saver mouse * position or it'll go away by accident. */ gpqCursor = NULL; gpcurPhysCurrent = NULL; gpcurLogCurrent = NULL; SetPointer(FALSE); gptSSCursor = gptCursorFullScreen; /* * No need to DeferWinEventNotify() - we use only globals, * then make an xxx call below. */ zzzInternalSetCursorPos(gptCursorFullScreen.x, gptCursorFullScreen.y ); CLEAR_PUDF(PUDF_LOCKFULLSCREEN); LockWindowUpdate2(NULL, TRUE); xxxRedrawWindow(pwndNewFG, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE | RDW_ERASENOW); break; default: RIPMSG0(RIP_ERROR, "xxxMakeWindowForegroundWithState: bad screen state"); break; } } } ThreadUnlock(&tlpwndNewFG); if (!fRedoFullScreenSwitch) { break; } } TRACE_SWITCH(("Switching: xxxMakeWindowForegroundWithState: Exit\n")); idSwitcher = NOSWITCHER; return TRUE; } /***************************************************************************\ * MonitorFromHdev \***************************************************************************/ PMONITOR MonitorFromHdev(HANDLE hdev) { PMONITOR pMonitor; for (pMonitor = gpDispInfo->pMonitorFirst; pMonitor != NULL; pMonitor = pMonitor->pMonitorNext) { if (pMonitor->hDev == hdev) { return pMonitor; } } return NULL; } /***************************************************************************\ * HdevFromMonitor \***************************************************************************/ ULONG HdevFromMonitor(PMONITOR pMonitor) { PMDEV pmdev = gpDispInfo->pmdev; ULONG i; for (i = 0; i < pmdev->chdev; i++) { if (pmdev->Dev[i].hdev == pMonitor->hDev) { return i; } } return -1; } /***************************************************************************\ * CreateMonitor \***************************************************************************/ PMONITOR CreateMonitor(void) { PMONITOR pMonitor; pMonitor = (PMONITOR)HMAllocObject(NULL, NULL, TYPE_MONITOR, sizeof(MONITOR)); if (pMonitor != NULL) { pMonitor->rcMonitor.left = 0; pMonitor->rcMonitor.top = 0; pMonitor->rcMonitor.right = 0; pMonitor->rcMonitor.bottom = 0; pMonitor->rcWork.left = 0; pMonitor->rcWork.top = 0; pMonitor->rcWork.right = 0; pMonitor->rcWork.bottom = 0; } else { RIPERR0(ERROR_NOT_ENOUGH_MEMORY, RIP_WARNING, "CreateMonitor failed"); } return pMonitor; } /***************************************************************************\ * CreateCachedMonitor \***************************************************************************/ PMONITOR CreateCachedMonitor(VOID) { if (gpMonitorCached == NULL) { gpMonitorCached = CreateMonitor(); } return gpMonitorCached; } /***************************************************************************\ * SetMonitorData \***************************************************************************/ PMONITOR SetMonitorData(PMONITOR pMonitor, ULONG iDev) { PMDEV pmdev = gpDispInfo->pmdev; HDEV hdev = pmdev->Dev[iDev].hdev; BOOL fVisible = TRUE; BOOL fPrimary = FALSE; HDC hdcTmp; UserAssert(iDev < pmdev->chdev); if (hdcTmp = GreCreateDisplayDC(hdev, DCTYPE_DIRECT, FALSE)) { if (GreGetDeviceCaps(hdcTmp, CAPS1) & C1_MIRROR_DEVICE) { fVisible = FALSE; } GreDeleteDC(hdcTmp); } if (fVisible && (pmdev->Dev[iDev].rect.top == 0) && (pmdev->Dev[iDev].rect.left == 0)) { fPrimary = TRUE; } if (pMonitor == NULL) { if (fPrimary) { UserAssert(gpMonitorCached != NULL); pMonitor = gpMonitorCached; gpMonitorCached = NULL; } else { pMonitor = CreateMonitor(); } } if (pMonitor == NULL) { return NULL; } SET_OR_CLEAR_FLAG(pMonitor->dwMONFlags, MONF_VISIBLE, fVisible); /* * When the monitor rect is changing, size the work area so the same * amount as before is clipped off each edge. */ if (!EqualRect(&pMonitor->rcMonitor, &pmdev->Dev[iDev].rect)) { pMonitor->rcWork.left = pmdev->Dev[iDev].rect.left - (pMonitor->rcMonitor.left - pMonitor->rcWork.left); pMonitor->rcWork.top = pmdev->Dev[iDev].rect.top - (pMonitor->rcMonitor.top - pMonitor->rcWork.top); pMonitor->rcWork.right = pmdev->Dev[iDev].rect.right - (pMonitor->rcMonitor.right - pMonitor->rcWork.right); pMonitor->rcWork.bottom = pmdev->Dev[iDev].rect.bottom - (pMonitor->rcMonitor.bottom - pMonitor->rcWork.bottom); } pMonitor->rcMonitor = pmdev->Dev[iDev].rect; pMonitor->hDev = hdev; /* * Make sure that the work area is inside the monitor's bounds. */ if(pMonitor->rcWork.right < pMonitor->rcWork.left) { pMonitor->rcWork.right = pMonitor->rcWork.left; } if(pMonitor->rcWork.bottom < pMonitor->rcWork.top) { pMonitor->rcWork.bottom = pMonitor->rcWork.top; } if (!IntersectRect(&pMonitor->rcWork, &pMonitor->rcWork, &pMonitor->rcMonitor)) { pMonitor->rcWork = pMonitor->rcMonitor; } if (fPrimary) { gpDispInfo->pMonitorPrimary = pMonitor; } return pMonitor; } /***************************************************************************\ * * Is this still TRUE ? * * When a window becomes FULLSCREEN, it is minimized and * treated like any other minimized window. Whenever the * minimized window is restored, by double clicking, menu * or keyboard, it remains minimized and the application * is given control of the screen device. * * 12-Dec-1991 mikeke Created \***************************************************************************/ /***************************************************************************\ * UpdateUserScreen * * Updates USER information associated with the screen * * History: * 28-Sep-1996 adams Created. \***************************************************************************/ BOOL UpdateUserScreen(void) { PMDEV pmdev = gpDispInfo->pmdev; ULONG i; PMONITOR pMonitor; TEXTMETRIC tm; int iRgn; PWINDOWSTATION pwinsta; PDESKTOP pdesk; HRGN hrgn; BOOL fPaletteDisplay; RECT rc; PMONITOR pMonitorNext = gpDispInfo->pMonitorFirst; PMONITOR *ppMonitorLast = &gpDispInfo->pMonitorFirst; TRACE_INIT(("UpdateUserScreen\n")); UserAssert(gpDispInfo->hdcScreen); UserAssert(gpMonitorCached != NULL); /* * Keep HMONITOR for the hdev that is the same. Delete the * monitors that weren't found in the new hdev list. */ while (pMonitorNext != NULL) { pMonitor = pMonitorNext; pMonitorNext = pMonitor->pMonitorNext; if ((i = HdevFromMonitor(pMonitor)) == -1) { DestroyMonitor(pMonitor); } else { SetMonitorData(pMonitor, i); ppMonitorLast = &pMonitor->pMonitorNext; } } /* * Create monitors for the hdevs that aren't yet on the monitor list. */ for (i = 0; i < pmdev->chdev; i++) { if ((pMonitor = MonitorFromHdev(pmdev->Dev[i].hdev)) == NULL) { /* * Try to create a new monitor. */ pMonitor = SetMonitorData(NULL, i); if (pMonitor != NULL) { *ppMonitorLast = pMonitor; ppMonitorLast = &pMonitor->pMonitorNext; } } } UserAssert(gpDispInfo->pMonitorFirst != NULL); UserAssert(gpDispInfo->pMonitorPrimary != NULL); /* * For now, all monitors have the same display format. */ SYSMET(SAMEDISPLAYFORMAT) = (pmdev->ulFlags & MDEV_MISMATCH_COLORDEPTH) ? FALSE : TRUE; fPaletteDisplay = GreGetDeviceCaps(gpDispInfo->hdcScreen, RASTERCAPS) & RC_PALETTE; gpDispInfo->fAnyPalette = !!fPaletteDisplay; /* * Determine the coordinates of the virtual desktop. * Compute cMonitors as the number of visible monitors. */ SetRectEmpty(&rc); gpDispInfo->cMonitors = 0; for (pMonitor = gpDispInfo->pMonitorFirst; pMonitor; pMonitor = pMonitor->pMonitorNext) { /* * Only visible monitors contribute to the desktop area */ if (pMonitor->dwMONFlags & MONF_VISIBLE) { rc.left = min(rc.left, pMonitor->rcMonitor.left); rc.top = min(rc.top, pMonitor->rcMonitor.top); rc.right = max(rc.right, pMonitor->rcMonitor.right); rc.bottom = max(rc.bottom, pMonitor->rcMonitor.bottom); gpDispInfo->cMonitors++; } if (SYSMET(SAMEDISPLAYFORMAT)) { SET_OR_CLEAR_FLAG(pMonitor->dwMONFlags, MONF_PALETTEDISPLAY, fPaletteDisplay); } else { if (GreIsPaletteDisplay(pMonitor->hDev)) { pMonitor->dwMONFlags |= MONF_PALETTEDISPLAY; gpDispInfo->fAnyPalette = TRUE; } } #ifdef SUBPIXEL_MOUSE /* * The new mouse's acceleration curves depend on the screen resolution, * so we rebuild the curves here. */ BuildMouseAccelerationCurve(pMonitor); #endif // SUBPIXEL_MOUSE } UserAssert(gpDispInfo->pMonitorPrimary != NULL); gpDispInfo->rcScreen = rc; /* * Notify the TS service if one coordinate of the virtual screen changed * and we're doing console shadow. */ if (gfRemotingConsole && gpConsoleShadowDisplayChangeEvent && !((SYSMET(XVIRTUALSCREEN) == gpDispInfo->rcScreen.left) && (SYSMET(YVIRTUALSCREEN) == gpDispInfo->rcScreen.top) && (SYSMET(CXVIRTUALSCREEN) == gpDispInfo->rcScreen.right - gpDispInfo->rcScreen.left) && (SYSMET(CYVIRTUALSCREEN) == gpDispInfo->rcScreen.bottom - gpDispInfo->rcScreen.top))) { KeSetEvent(gpConsoleShadowDisplayChangeEvent, EVENT_INCREMENT, FALSE); } /* * Update system metrics */ SYSMET(CXSCREEN) = gpDispInfo->pMonitorPrimary->rcMonitor.right; SYSMET(CYSCREEN) = gpDispInfo->pMonitorPrimary->rcMonitor.bottom; SYSMET(XVIRTUALSCREEN) = gpDispInfo->rcScreen.left; SYSMET(YVIRTUALSCREEN) = gpDispInfo->rcScreen.top; SYSMET(CXVIRTUALSCREEN) = gpDispInfo->rcScreen.right - gpDispInfo->rcScreen.left; SYSMET(CYVIRTUALSCREEN) = gpDispInfo->rcScreen.bottom - gpDispInfo->rcScreen.top; SYSMET(CXMAXTRACK) = SYSMET(CXVIRTUALSCREEN) + (2 * (SYSMET(CXSIZEFRAME) + SYSMET(CXEDGE))); SYSMET(CYMAXTRACK) = SYSMET(CYVIRTUALSCREEN) + (2 * (SYSMET(CYSIZEFRAME) + SYSMET(CYEDGE))); SYSMET(CMONITORS) = gpDispInfo->cMonitors; /* * Bug 281219: flush out the mouse move points if a mode change occured */ RtlZeroMemory(gaptMouse, MAX_MOUSEPOINTS * sizeof(MOUSEMOVEPOINT)); SetDesktopMetrics(); gpDispInfo->dmLogPixels = (WORD)GreGetDeviceCaps(gpDispInfo->hdcScreen, LOGPIXELSY); UserAssert(gpDispInfo->dmLogPixels != 0); /* * Get per-monitor or sum of monitor information, including: * The desktop region. * The region of each monitor. * Min bit counts - Not for NT SP2. * Same color format - Not for NT SP2. */ SetOrCreateRectRgnIndirectPublic(&gpDispInfo->hrgnScreen, PZERO(RECT)); if (gpDispInfo->hrgnScreen) { for (pMonitor = gpDispInfo->pMonitorFirst; pMonitor; pMonitor = pMonitor->pMonitorNext) { /* * We want to set up hrgnMonitor for all monitors, visible or not */ if (SetOrCreateRectRgnIndirectPublic(&pMonitor->hrgnMonitor, &pMonitor->rcMonitor)) { /* * But we want only visible monitors to contribute to hrgnScreen */ if (pMonitor->dwMONFlags & MONF_VISIBLE) { iRgn = UnionRgn(gpDispInfo->hrgnScreen, gpDispInfo->hrgnScreen, pMonitor->hrgnMonitor); } } } gpDispInfo->fDesktopIsRect = (iRgn == SIMPLEREGION); } /* * Reset the window region of desktop windows. */ hrgn = (gpDispInfo->fDesktopIsRect) ? NULL : gpDispInfo->hrgnScreen; for (pwinsta = grpWinStaList; pwinsta; pwinsta = pwinsta->rpwinstaNext) { for (pdesk = pwinsta->rpdeskList; pdesk; pdesk = pdesk->rpdeskNext) { if (pdesk->pDispInfo == gpDispInfo) { pdesk->pDeskInfo->spwnd->hrgnClip = hrgn; } } } /* * Updated information stored in gpsi. */ gpsi->Planes = (BYTE)GreGetDeviceCaps(gpDispInfo->hdcScreen, PLANES); gpsi->BitsPixel = (BYTE)GreGetDeviceCaps(gpDispInfo->hdcScreen, BITSPIXEL); gpsi->BitCount = gpsi->Planes * gpsi->BitsPixel; gpDispInfo->BitCountMax = gpsi->BitCount; SET_OR_CLEAR_PUSIF(PUSIF_PALETTEDISPLAY, fPaletteDisplay); gpsi->dmLogPixels = gpDispInfo->dmLogPixels; gpsi->rcScreen = gpDispInfo->rcScreen; gpsi->cxSysFontChar = GetCharDimensions(HDCBITS(), &tm, &gpsi->cySysFontChar); gpsi->tmSysFont = tm; EnforceColorDependentSettings(); #if DBG VerifyVisibleMonitorCount(); #endif return TRUE; } /**************************************************************************\ * InitUserScreen * * Initializes user variables at startup. * * The caller of this function needs to handle failures. If this is called * as part of the interactive console and it fails, User will currently * bugcheck. If this is called as part of RemoteConnect() for * Terminal Server, the resources will be cleaned up in CleanupGDI() as part * of normal thread cleanup. * * This function only initializes gpDispInfo. If any other DISPLAYINFO's * are created, they must be initialized directly. * * 12-Jan-1994 andreva Created * 23-Jan-1995 ChrisWil ChangeDisplaySettings work. \**************************************************************************/ BOOL InitUserScreen() { int i; TL tlName; PUNICODE_STRING pProfileUserName = CreateProfileUserName(&tlName); BOOL fSuccess = TRUE; TRACE_INIT(("UserInit: Initialize Screen\n")); /* * Create screen and memory dcs. */ gpDispInfo->hdcScreen = GreCreateDisplayDC(gpDispInfo->hDev, DCTYPE_DIRECT, FALSE); if (gpDispInfo->hdcScreen == NULL) { RIPMSG0(RIP_WARNING, "Fail to create gpDispInfo->hdcScreen"); fSuccess = FALSE; goto Exit; } GreSelectFont(gpDispInfo->hdcScreen, GreGetStockObject(SYSTEM_FONT)); GreSetDCOwner(gpDispInfo->hdcScreen, OBJECT_OWNER_PUBLIC); HDCBITS() = GreCreateCompatibleDC(gpDispInfo->hdcScreen); if (HDCBITS() == NULL) { RIPMSG0(RIP_WARNING, "Fail to create HDCBITS()"); fSuccess = FALSE; goto Exit; } GreSelectFont(HDCBITS(), GreGetStockObject(SYSTEM_FONT)); GreSetDCOwner(HDCBITS(), OBJECT_OWNER_PUBLIC); ghdcMem = GreCreateCompatibleDC(gpDispInfo->hdcScreen); fSuccess &= !!ghdcMem; ghdcMem2 = GreCreateCompatibleDC(gpDispInfo->hdcScreen); fSuccess &= !!ghdcMem2; if (!fSuccess) { RIPMSG0(RIP_WARNING, "Fail to create ghdcMem or ghdcMem2"); goto Exit; } GreSetDCOwner(ghdcMem, OBJECT_OWNER_PUBLIC); GreSetDCOwner(ghdcMem2, OBJECT_OWNER_PUBLIC); if (CreateCachedMonitor() == NULL) { fSuccess = FALSE; goto Exit; } if (!UpdateUserScreen()) { RIPMSG0(RIP_WARNING, "UpdateUserScreen failed"); fSuccess = FALSE; goto Exit; } /* * Do some initialization so we create the system colors. */ /* * Set the window sizing border width to something reasonable. */ gpsi->gclBorder = 1; /* * Init InternalInvalidate globals */ ghrgnInv0 = CreateEmptyRgnPublic(); // For InternalInvalidate() fSuccess &= !!ghrgnInv0; ghrgnInv1 = CreateEmptyRgnPublic(); // For InternalInvalidate() fSuccess &= !!ghrgnInv1; ghrgnInv2 = CreateEmptyRgnPublic(); // For InternalInvalidate() fSuccess &= !!ghrgnInv2; /* * Initialize SPB globals */ ghrgnSPB1 = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnSPB1; ghrgnSPB2 = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnSPB2; ghrgnSCR = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnSCR; /* * Initialize ScrollWindow/ScrollDC globals */ ghrgnSW = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnSW; ghrgnScrl1 = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnScrl1; ghrgnScrl2 = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnScrl2; ghrgnScrlVis = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnScrlVis; ghrgnScrlSrc = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnScrlSrc; ghrgnScrlDst = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnScrlDst; ghrgnScrlValid = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnScrlValid; /* * Initialize SetWindowPos() */ ghrgnInvalidSum = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnInvalidSum; ghrgnVisNew = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnVisNew; ghrgnSWP1 = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnSWP1; ghrgnValid = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnValid; ghrgnValidSum = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnValidSum; ghrgnInvalid = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnInvalid; /* * Initialize DC cache */ ghrgnGDC = CreateEmptyRgnPublic(); fSuccess &= !!ghrgnGDC; for (i = 0; i < DCE_SIZE_CACHEINIT; i++) { fSuccess &= !!CreateCacheDC(NULL, DCX_INVALID | DCX_CACHE, NULL); } if (!fSuccess) { RIPMSG0(RIP_WARNING, "CreateCacheDC failed"); goto Exit; } /* * Let engine know that the display must be secure. */ GreMarkDCUnreadable(gpDispInfo->hdcScreen); /* * LATER mikeke - if ghfontsys is changed anywhere but here * we need to fix SetNCFont() */ ghFontSys = (HFONT)GreGetStockObject(SYSTEM_FONT); #if DBG SYSMET(DEBUG) = TRUE; #else SYSMET(DEBUG) = FALSE; #endif SYSMET(CLEANBOOT) = **((PULONG *)&InitSafeBootMode); SYSMET(SLOWMACHINE) = 0; /* * Initialize system colors from registry. */ xxxODI_ColorInit(pProfileUserName); /* * Paint the screen background. */ FillRect(gpDispInfo->hdcScreen, &gpDispInfo->rcScreen, SYSHBR(DESKTOP)); UserAssert(fSuccess); Exit: FreeProfileUserName(pProfileUserName, &tlName); return fSuccess; } /***************************************************************************\ * xxxResetSharedDesktops * * Resets the attributes for other desktops which share the DISPINFO that * was just changed. We need to resize all visrgns of the other desktops * so that clipping is allright. * * NOTE: For now, we have to change all the desktop even though we keep * track of the devmode on a per desktop basis, because we can switch * back to a desktop that has a different resolution and paint it before * we can change the resolution again. * * There is also an issue with CDS_FULLSCREEN where we currently lose track * of whether or not the desktop settings need to be reset or not. [andreva] * * 19-Feb-1996 ChrisWil Created. \***************************************************************************/ VOID ResetSharedDesktops( PDISPLAYINFO pDIChanged, PDESKTOP pdeskChanged) { PWINDOWSTATION pwinsta = _GetProcessWindowStation(NULL); PDESKTOP pdesk; HRGN hrgn; POINT pt; PRECT prc; UserAssert(IsWinEventNotifyDeferredOK()); /* * If this is CSRSS doing the dynamic resolution change then use * WinSta0 since the process windowstation is NULL for CSRSS. */ if ((IsRemoteConnection()) && pwinsta == NULL && PsGetCurrentProcess() == gpepCSRSS) { pwinsta = grpWinStaList; } if (pwinsta == NULL) { if (PtiCurrent()->TIF_flags & (TIF_CSRSSTHREAD|TIF_SYSTEMTHREAD)) { pwinsta = grpdeskRitInput->rpwinstaParent; } else { TRACE_SWITCH(("ResetSharedDesktops - NULL window station !\n")); return; } } for (pdesk = pwinsta->rpdeskList; pdesk; pdesk = pdesk->rpdeskNext) { /* * Make sure this is a shared DISPINFO. */ if (pdesk->pDispInfo == pDIChanged) { #if 0 /* * This is the preferable method to set the desktop-window. * However, this causes synchronization problems where we * leave the critical-section allowing other apps to call * ChangeDisplaySettings() and thus mucking up the works. * * By calculating the vis-rgn ourselves, we can assure that * the clipping is current for the desktop even when we leave * the section. */ { TL tlpwnd; ThreadLockAlways(pdesk->pDeskInfo->spwnd, &tlpwnd); xxxSetWindowPos(pdesk->pDeskInfo->spwnd, PWND_TOP, pDIChanged->rcScreen.left, pDIChanged->rcScreen.top, pDIChanged->rcScreen.right - pDIChanged->rcScreen.left, pDIChanged->rcScreen.bottom - pDIChanged->rcScreen.top, SWP_NOZORDER | SWP_NOACTIVATE); ThreadUnlock(&tlpwnd); } #else CopyRect(&pdesk->pDeskInfo->spwnd->rcWindow, &pDIChanged->rcScreen); CopyRect(&pdesk->pDeskInfo->spwnd->rcClient, &pDIChanged->rcScreen); #endif } } /* * Recalc the desktop visrgn. */ hrgn = CreateEmptyRgn(); CalcVisRgn(&hrgn, pdeskChanged->pDeskInfo->spwnd, pdeskChanged->pDeskInfo->spwnd, DCX_WINDOW); GreSelectVisRgn(pDIChanged->hdcScreen, hrgn, SVR_DELETEOLD); /* * Invalidate all DCE's visrgns. */ zzzInvalidateDCCache(pdeskChanged->pDeskInfo->spwnd, 0); /* * Position mouse so that it is within the new visrgn, once we * recalc it. */ if (grpdeskRitInput->pDispInfo == pDIChanged) { prc = &pDIChanged->pMonitorPrimary->rcMonitor; pt.x = (prc->right - prc->left) / 2; pt.y = (prc->bottom - prc->top) / 2; /* * Remember new mouse pos. Makes sure we don't wake the screensaver. */ gptSSCursor = pt; zzzInternalSetCursorPos(pt.x, pt.y); } } /***************************************************************************\ * DestroyMonitorDCs * * 03/03/1998 vadimg created \***************************************************************************/ void DestroyMonitorDCs(void) { PDCE pdce; PDCE *ppdce; /* * Scan the DC cache to find any monitor DC's that need to be destroyed. */ for (ppdce = &gpDispInfo->pdceFirst; *ppdce != NULL; ) { pdce = *ppdce; if (pdce->pMonitor != NULL) { DestroyCacheDC(ppdce, pdce->hdc); } /* * Step to the next DC. If the DC was deleted, there * is no need to calculate address of the next entry. */ if (pdce == *ppdce) ppdce = &pdce->pdceNext; } } /***************************************************************************\ * ResetSystemColors * * Reset all system colors to make sure magic colors are reset and * solid system colors are indeed solid after a mode change. \***************************************************************************/ VOID ResetSystemColors(VOID) { INT i; INT colorIndex[COLOR_MAX]; COLORREF colorValue[COLOR_MAX]; for (i = 0; i < COLOR_MAX; i++) { colorIndex[i] = i; colorValue[i] = gpsi->argbSystemUnmatched[i]; } BEGINATOMICCHECK(); xxxSetSysColors(NULL, i, colorIndex, colorValue, SSCF_FORCESOLIDCOLOR | SSCF_SETMAGICCOLORS); ENDATOMICCHECK(); } /***************************************************************************\ * xxxResetDisplayDevice * * Resets the user-globals with the new hdev settings. * * 19-Feb-1996 ChrisWil Created. \***************************************************************************/ VOID xxxResetDisplayDevice( PDESKTOP pdesk, PDISPLAYINFO pDI, DWORD CDS_Flags) { WORD wOldBpp; PMONITORRECTS pmr = NULL; TL tlPool; PTHREADINFO ptiCurrent = PtiCurrent(); wOldBpp = gpsi->BitCount; if (!(CDS_Flags & CDS_FULLSCREEN)) { pmr = SnapshotMonitorRects(); if (pmr) { ThreadLockPool(ptiCurrent, pmr, &tlPool); } } /* * Cleanup any monitor specific DCs we gave out. */ DestroyMonitorDCs(); UpdateUserScreen(); ResetSharedDesktops(pDI, pdesk); ResetSystemColors(); if (ghbmCaption) { GreDeleteObject(ghbmCaption); ghbmCaption = CreateCaptionStrip(); } zzzClipCursor(&pDI->rcScreen); /* * Adjust window positions to fit new resolutions and * positions of monitors. * * Don't adjust the windows if we are in a temporary mode change. */ if (pmr) { xxxDesktopRecalc(pmr); ThreadUnlockAndFreePool(PtiCurrent(), &tlPool); } /* * Relead the desktop wallpaper on a video mode change. */ if (ghbmWallpaper) { if (ptiCurrent->TIF_flags & TIF_INCLEANUP) { /* * The thread is being terminated. We cannot transition back to * the client side. So we ask the desktop to do it for us. */ _PostThreadMessage(gTermIO.ptiDesktop, WM_DESKTOPNOTIFY, DESKTOP_RELOADWALLPAPER, 0); } else { TL tlName; PUNICODE_STRING pProfileUserName = CreateProfileUserName(&tlName); xxxSetDeskWallpaper(pProfileUserName, SETWALLPAPER_METRICS); FreeProfileUserName(pProfileUserName, &tlName); } } /* * Recreate cached bitmaps. */ CreateBitmapStrip(); /* * Broadcast that the display has changed resolution. * Also broadcast a color-change if we were not in fullscreen, and a * color-change took effect. */ if (!(CDS_Flags & CDS_FULLSCREEN) && (gpsi->BitCount != wOldBpp)) { xxxBroadcastDisplaySettingsChange(pdesk, TRUE); } else { xxxBroadcastDisplaySettingsChange(pdesk, FALSE); } /* * If the user performed a CTL-ESC, it is possible that the * tray-window is then in the menu-loop. We want to clear this * out so that we don't leave improper menu positioning. */ if (gpqForeground && gpqForeground->spwndCapture) QueueNotifyMessage(gpqForeground->spwndCapture, WM_CANCELMODE, 0, 0l); } /***************************************************************************\ * TrackFullscreenMode * * Remember the process going into the fullscreen mode, so that * the mode can be restored if the process doesn't clean up upon * exit. If some other mode change, clear the global since that * means we're definitely out of the fullscreen mode. * * 1/12/1999 vadimg created \***************************************************************************/ VOID TrackFullscreenMode(DWORD dwFlags) { if (dwFlags & CDS_FULLSCREEN) { gppiFullscreen = PtiCurrent()->ppi; } else { gppiFullscreen = NULL; } } /***************************************************************************\ * NtUserChangeDisplaySettings * * ChangeDisplaySettings API * * 01-Sep-1995 andreva Created * 19-Feb-1996 ChrisWil Implemented Dynamic-Resolution changes. \***************************************************************************/ LONG xxxUserChangeDisplaySettings( IN PUNICODE_STRING pstrDeviceName, IN LPDEVMODEW pDevMode, IN HWND hwnd, IN PDESKTOP pdesk, IN DWORD dwFlags, IN PVOID lParam, IN MODE PreviousMode) { BOOL bSwitchMode; PDESKTOP pdesktop; LONG status; PMDEV pmdev; /* * NOTE: The lParam has NOT been properly captured. It is not used in * this function, but is passed onto other called functions. Once the * correct type is determined and it is to be used, it must be properly * captured. */ TRACE_INIT(("ChangeDisplaySettings - Entering\n")); TRACE_SWITCH(("ChangeDisplaySettings - Entering\n")); TRACE_INIT((" Flags -")); if (dwFlags & CDS_UPDATEREGISTRY) TRACE_INIT((" CDS_UPDATEREGISTRY - ")); if (dwFlags & CDS_TEST) TRACE_INIT((" CDS_TEST - ")); if (dwFlags & CDS_FULLSCREEN) TRACE_INIT((" CDS_FULLSCREEN - ")); if (dwFlags & CDS_GLOBAL) TRACE_INIT((" CDS_GLOBAL - ")); if (dwFlags & CDS_SET_PRIMARY) TRACE_INIT((" CDS_SET_PRIMARY - ")); if (dwFlags & CDS_RESET) TRACE_INIT((" CDS_RESET - ")); if (dwFlags & CDS_NORESET) TRACE_INIT((" CDS_NORESET - ")); if (dwFlags & CDS_VIDEOPARAMETERS) TRACE_INIT((" CDS_VIDEOPARAMETERS - ")); TRACE_INIT(("\n")); #if ((DISP_CHANGE_SUCCESSFUL != GRE_DISP_CHANGE_SUCCESSFUL) || \ (DISP_CHANGE_RESTART != GRE_DISP_CHANGE_RESTART) || \ (DISP_CHANGE_FAILED != GRE_DISP_CHANGE_FAILED) || \ (DISP_CHANGE_BADMODE != GRE_DISP_CHANGE_BADMODE) || \ (DISP_CHANGE_NOTUPDATED != GRE_DISP_CHANGE_NOTUPDATED) || \ (DISP_CHANGE_BADFLAGS != GRE_DISP_CHANGE_BADFLAGS) || \ (DISP_CHANGE_BADPARAM != GRE_DISP_CHANGE_BADPARAM)) #error "inconsistent header files" #endif /* * Perform Error Checking to verify flag combinations are valid. */ if (dwFlags & (~CDS_VALID)) { return DISP_CHANGE_BADFLAGS; } if (DrvQueryMDEVPowerState(gpDispInfo->pmdev) == FALSE) { RIPMSG0(RIP_WARNING, "ChangeDisplaySettings failed because the device is powered off"); return DISP_CHANGE_BADPARAM; } if (gbMDEVDisabled) { RIPMSG0(RIP_WARNING, "ChangeDisplaySettings failed because the MDEV is already disabled"); return GRE_DISP_CHANGE_FAILED; } /* * CDS_GLOBAL and CDS_NORESET can only be specified if UPDAREREGISTRY * is specified. */ if ((dwFlags & (CDS_GLOBAL | CDS_NORESET)) && (!(dwFlags & CDS_UPDATEREGISTRY))) { return DISP_CHANGE_BADFLAGS; } if ((dwFlags & CDS_NORESET) && (dwFlags & CDS_RESET)) { return DISP_CHANGE_BADFLAGS; } if ((dwFlags & CDS_EXCLUSIVE) && (dwFlags & CDS_FULLSCREEN) && (dwFlags & CDS_RESET)) { return DISP_CHANGE_BADFLAGS; } if (hwnd) { return DISP_CHANGE_BADPARAM; } /* * Allow mode change if this is a CSRSS of a remote * session. This means we are changing display settings when * reconnecting a session with a diferent resolution. */ if (TEST_PUDF(PUDF_LOCKFULLSCREEN)) { if (!(ISCSRSS() && (IsRemoteConnection()))) { return DISP_CHANGE_FAILED; } } /* * If the modeset is being done on a non-active desktop, we don't want * it too happen. * * PtiCurrent()->rpdesk can be NULL !!! (in the case of thread shutdown). */ if (pdesk) { pdesktop = pdesk; } else { pdesktop = PtiCurrent()->rpdesk; } if (pdesktop != grpdeskRitInput) { RIPMSG0(RIP_WARNING, "ChangeDisplaySettings on wrong desktop pdesk\n"); return DISP_CHANGE_FAILED; } bSwitchMode = !(dwFlags & (CDS_NORESET | CDS_TEST)); /* * Turn off cursor and free the spb's prior to calling the mode-change. * This will make sure off-screen memory is cleaned up for gdi. * while mucking with the resolution changes. */ if (bSwitchMode) { if (CreateCachedMonitor() == NULL) { return DISP_CHANGE_FAILED; } SetPointer(FALSE); FreeAllSpbs(); } /* * Before calling gdi to change the mode, we should kill the fade sprite. This is * so that we won't keep pointers to gdi sprites during the mode change because * the sprites could be reallocated. */ if (gfade.hbm != NULL) { StopFade(); } /* * Similarly, we should kill the sprites associated with the drag rect (if any * exist) before the mode change. */ bSetDevDragRect(gpDispInfo->hDev, NULL, NULL); /* * Lets capture our parameters. They are both required. * * If the input string is not NULL, then we are trying to affect another * Device. The device name is the same as for EnumDisplaySettings. */ status = DrvChangeDisplaySettings(pstrDeviceName, gpDispInfo->pMonitorPrimary->hDev, pDevMode, LongToPtr( pdesktop->dwDesktopId ), PreviousMode, (dwFlags & CDS_UPDATEREGISTRY), bSwitchMode, gpDispInfo->pmdev, &pmdev, (dwFlags & CDS_RAWMODE) ? GRE_RAWMODE : GRE_DEFAULT, (dwFlags & CDS_TRYCLOSEST)); if (bSwitchMode) { /* * If the caller wanted a reset, but the mode is identical, just * reset the current mode. */ if (status == GRE_DISP_CHANGE_NO_CHANGE) { TrackFullscreenMode(dwFlags); if (pmdev != NULL) { GreFreePool(pmdev); } if (dwFlags & CDS_RESET) { if (SafeDisableMDEV()) { SafeEnableMDEV(); } xxxUserResetDisplayDevice(); } status = DISP_CHANGE_SUCCESSFUL; } else if (status == DISP_CHANGE_SUCCESSFUL) { ResetRedirectedWindows(); TrackFullscreenMode(dwFlags); /* * ChangeDisplaySettings automatically destroys the old MDEV. * We only have to delete it here. */ GreFreePool(gpDispInfo->pmdev); gpDispInfo->pmdev = pmdev; xxxResetDisplayDevice(pdesktop, gpDispInfo, dwFlags); /* * set delayed change indicator for * currently background desktops. */ UserSetDelayedChangeBroadcastForAllDesktops(pdesktop); } else if (status < DISP_CHANGE_SUCCESSFUL) { UserAssert(pmdev == NULL); xxxUserResetDisplayDevice(); } /* * Inline so we can specify which desktop this should happen on. * xxxRedrawScreen(); */ xxxInternalInvalidate(pdesktop->pDeskInfo->spwnd, HRGN_FULL, RDW_INVALIDATE | RDW_ERASE | RDW_FRAME | RDW_ALLCHILDREN); /* * Bring back the cursor-shape. */ SetPointer(TRUE); zzzUpdateCursorImage(); } /* * TV-Out Support */ if (NT_SUCCESS(status) && (dwFlags & CDS_VIDEOPARAMETERS)) { if (lParam == NULL) { status = DISP_CHANGE_BADPARAM; } else { status = DrvSetVideoParameters(pstrDeviceName, gpDispInfo->pMonitorPrimary->hDev, PreviousMode, lParam); } } TRACE_INIT(("ChangeDisplaySettings - Leaving, Status = %d\n", status)); return status; } /***************************************************************************\ * xxxbFullscreenSwitch * * Switch in and out of fullscreen console mode * * 15-Apr-1997 andreva Created \***************************************************************************/ BOOL xxxbFullscreenSwitch( BOOL bFullscreenSwitch, HWND hwnd) { PWND pwnd; TL tlpwnd; BOOL bStat = TRUE; pwnd = ValidateHwnd(hwnd); if (!pwnd) { return DISP_CHANGE_BADPARAM; } /* * Lock the PWND, if it is provided */ ThreadLock(pwnd, &tlpwnd); /* * We don't want our mode switch to be posted on the looping thread. * So let's loop until the system has settled down and no mode switch * is currently occuring. */ while (idSwitcher != NOSWITCHER) { /* * Make sure we aren't blocking anyone who's sending us a message. * They can have idSwitcher and never release it because they are * waiting on us to process the sent message. And we're waiting on * idSwitcher, hence a deadlock. */ xxxSleepThread(0, 1, FALSE); } /* * Syncronize with session switching. */ if (gfSwitchInProgress || IsRemoteConnection() || gfSessionSwitchBlock) { ThreadUnlock(&tlpwnd); return FALSE; } else { gfSessionSwitchBlock = TRUE; } /* * If there is a window, we want to check the state of the window. * For most calls, we want to ensure we are in windowed mode. * However, for Console, we want to make sure we are in fullscreen mode. * So differentiate between the two. We will check if the TEXTMODE * flag is passed in the DEVMODE. */ if (bFullscreenSwitch) { if (GetFullScreen(pwnd) != FULLSCREEN) { xxxShowWindow(pwnd, SW_SHOWMINIMIZED | TEST_PUDF(PUDF_ANIMATE)); xxxUpdateWindow(pwnd); } if (!xxxMakeWindowForegroundWithState(pwnd, FULLSCREEN)) { goto FullscreenSwitchFailed; } if ((idSwitcher != NOSWITCHER) || (gbFullScreen != FULLSCREEN)) { goto FullscreenSwitchFailed; } } else { /* * For the console windows, we want to call with WINDOWED */ if (!xxxMakeWindowForegroundWithState(pwnd, WINDOWED)) { goto FullscreenSwitchFailed; } if ((idSwitcher != NOSWITCHER) || (gbFullScreen != GDIFULLSCREEN)) { FullscreenSwitchFailed: TRACE_INIT(("ChangeDisplaySettings: Can not switch out of fullscreen\n")); bStat = FALSE; } } ThreadUnlock(&tlpwnd); gfSessionSwitchBlock = FALSE; return bStat; } NTSTATUS RemoteRedrawRectangle( WORD Left, WORD Top, WORD Right, WORD Bottom) { TL tlpwnd; RECT rcl; CheckCritIn(); TRACE_HYDAPI(("RemoteRedrawRectangle\n")); UserAssert(ISCSRSS()); /* * If xxxRemoteStopScreenUpdates has not been called, * then just repaint the current foreground window. */ if (gspdeskShouldBeForeground == NULL) { if (gspwndFullScreen) { ThreadLock(gspwndFullScreen, &tlpwnd); rcl.left = Left; rcl.top = Top; rcl.right = Right; rcl.bottom = Bottom; vDrvInvalidateRect(gpDispInfo->hDev, &rcl); xxxRedrawWindow(gspwndFullScreen, &rcl, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE | RDW_ERASENOW); ThreadUnlock(&tlpwnd); } } return STATUS_SUCCESS; } NTSTATUS RemoteRedrawScreen( VOID) { TL tlpdesk; PWINDOWSTATION pwinsta; PTHREADINFO ptiCurrent; TRACE_HYDAPI(("RemoteRedrawScreen\n")); CheckCritIn(); if (!gbFreezeScreenUpdates) return STATUS_SUCCESS; ptiCurrent = PtiCurrentShared(); gbFreezeScreenUpdates = FALSE; /* * Switch back to the previous desktop */ if (gspdeskShouldBeForeground == NULL) { RIPMSG0(RIP_WARNING, "RemoteRedrawScreen called with no gspdeskShouldBeForeground"); return STATUS_SUCCESS; } gbDesktopLocked = FALSE; pwinsta = gspdeskShouldBeForeground->rpwinstaParent; /* * Switch back to previous desktop */ if (!(gspdeskShouldBeForeground->dwDTFlags & DF_DESTROYED)) { ThreadLockDesktop(ptiCurrent, gspdeskShouldBeForeground, &tlpdesk, LDLT_FN_CTXREDRAWSCREEN); xxxSwitchDesktop(pwinsta, gspdeskShouldBeForeground, SDF_SLOVERRIDE); ThreadUnlockDesktop(ptiCurrent, &tlpdesk, LDUT_FN_CTXREDRAWSCREEN); } LockDesktop(&gspdeskShouldBeForeground, NULL, LDL_DESKSHOULDBEFOREGROUND2, 0 ); return STATUS_SUCCESS; } NTSTATUS RemoteDisableScreen( VOID) { TL tlpdesk; PTHREADINFO ptiCurrent; PWINDOWSTATION pwinsta; NTSTATUS Status = STATUS_SUCCESS; CheckCritIn(); TRACE_HYDAPI(("RemoteDisableScreen\n")); ptiCurrent = PtiCurrentShared(); if (grpdeskRitInput != gspdeskDisconnect && gspdeskDisconnect != NULL) { pwinsta = gspdeskDisconnect->rpwinstaParent; /* * Save current desktop */ UserAssert(grpdeskRitInput == pwinsta->pdeskCurrent); LockDesktop(&gspdeskShouldBeForeground, grpdeskRitInput, LDL_DESKSHOULDBEFOREGROUND3, 0); gbDesktopLocked = TRUE; /* * Switch to Disconnected desktop */ ThreadLockDesktop(ptiCurrent, gspdeskDisconnect, &tlpdesk, LDLT_FN_CTXDISABLESCREEN); xxxSwitchDesktop(pwinsta, gspdeskDisconnect, SDF_SLOVERRIDE); ThreadUnlockDesktop(ptiCurrent, &tlpdesk, LDUT_FN_CTXDISABLESCREEN); } else if (gspdeskDisconnect != NULL) { /* * For some reason the disconnected desktop was the current desktop. * Now prevent switching from it. */ gbDesktopLocked = TRUE; } return Status; } VOID xxxBroadcastDisplaySettingsChange( PDESKTOP pdesk, BOOL bBroadcastColorChange) { /* * Broadcast that the display has changed resolution. We are going * to specify the desktop for the changing-desktop. That way we * don't get confused as to what desktop to broadcast to. */ xxxBroadcastMessage(pdesk->pDeskInfo->spwnd, WM_DISPLAYCHANGE, gpsi->BitCount, MAKELONG(SYSMET(CXSCREEN), SYSMET(CYSCREEN)), BMSG_SENDNOTIFYMSG, NULL); /* * Broadcast a color-change if requested to do so. */ if (bBroadcastColorChange){ #if 1 // We might want to remove this call, since color-change seems // to provide apps the notification. Need to review // chriswil - 06/11/96 xxxBroadcastMessage(pdesk->pDeskInfo->spwnd, WM_SETTINGCHANGE, 0, 0, BMSG_SENDNOTIFYMSG, NULL); #endif xxxBroadcastMessage(pdesk->pDeskInfo->spwnd, WM_SYSCOLORCHANGE, 0, 0, BMSG_SENDNOTIFYMSG, NULL); } } NTSTATUS xxxRequestOutOfFullScreenMode( VOID) { TL tlpwndT; NTSTATUS Status = STATUS_SUCCESS; if (gspwndFullScreen) { /* * Give the console window a chance to orderly exit full screen mode. */ ThreadLock(gspwndFullScreen, &tlpwndT); xxxSendMessage(gspwndFullScreen, CM_MODE_TRANSITION, (WPARAM)WINDOWED, (LPARAM)0); ThreadUnlock(&tlpwndT); /* * Let's loop until the system has settled down and no mode switch * is currently occuring. */ while (idSwitcher != NOSWITCHER) { /* * Make sure we aren't blocking anyone who's sending us a message. * They can have idSwitcher and never release it because they are * waiting on us to process the sent message. And we're waiting on * idSwitcher, hence a deadlock. */ xxxSleepThread(0, 1, FALSE); } /* * See if the fullscreen window did exit fullscreen mode gracefuly. */ if (gspwndFullScreen && (gbFullScreen == FULLSCREEN)) { Status = STATUS_UNSUCCESSFUL; } } return Status; }