/****************************** 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 stored 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 \***************************************************************************/ #if DBG LONG TraceFullscreenSwitch; #endif HANDLE ghSwitcher; BOOL gfRedoFullScreenSwitch, gfGdiEnabled = TRUE; POINT gptCursorFullScreen; VOID SetVDMCursorBounds(LPRECT lprc); 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) { RIPMSGF0(RIP_ERROR, "No interactive WindowStation"); 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( VOID) { if (PsGetCurrentThreadId() == ghSwitcher) { /* * Correct the full screen state. */ if (gfGdiEnabled) { TRACE_SWITCH(("Switching: FullScreenCleanup: Gdi Enabled\n")); /* * Gdi is enabled; since 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); } ghSwitcher = NULL; gfRedoFullScreenSwitch = 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 * ghSwitcher. If ghSwitcher is non-NULL someone is already 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 (ghSwitcher != NULL) { gfRedoFullScreenSwitch = TRUE; TRACE_SWITCH(("Switching: xxxMakeWindowForegroundWithState was posted: Exit\n")); return TRUE; } UserAssert(!gfRedoFullScreenSwitch); ghSwitcher = PsGetCurrentThreadId(); /* * We loop, switching full screens until all states have stabilized */ while (TRUE) { /* * Figure out who should be foreground. */ gfRedoFullScreenSwitch = 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(gfGdiEnabled == TRUE); /* * We are about to switch to FULLSCREEN mode. * * IsRemoteConnection() == TRUE indicates that we * are on a remote session. Switching to FULLSCREEN * mode is not supported on remote sessions. * * gfSwitchInProgress flag means that we are * currently in process of disconnecting the * session, so even if it is not remote right now it * is about to go remote. In these cases we must not * switch to FULLSCREEN mode. */ if (IsRemoteConnection() || gfSwitchInProgress || !SafeDisableMDEV()) { /* * Restore the previous state before bailing. */ CLEAR_PUDF(PUDF_LOCKFULLSCREEN); LockWindowUpdate2(NULL, TRUE); Lock(&gspwndFullScreen, pwndOldFG); gbFullScreen = bStateOld; ThreadUnlock(&tlpwndOldFG); ThreadUnlock(&tlpwndNewFG); ghSwitcher = NULL; return FALSE; } gptCursorFullScreen = gpsi->ptCursor; gfGdiEnabled = 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(gfGdiEnabled == FALSE); } SafeEnableMDEV(); gfGdiEnabled = 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 (!gfRedoFullScreenSwitch) { break; } } TRACE_SWITCH(("Switching: xxxMakeWindowForegroundWithState: Exit\n")); ghSwitcher = NULL; 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 \***************************************************************************/ DWORD gdwMonitorBusy; /***************************************************************************\ * xxxUpdateUserScreen * * Updates USER information associated with the screen * * History: * 28-Sep-1996 adams Created. \***************************************************************************/ BOOL xxxUpdateUserScreen( BOOL fInitializeTime) { PMDEV pmdev = gpDispInfo->pmdev; ULONG i; PMONITOR pMonitor; TEXTMETRIC tm; PWINDOWSTATION pwinsta; PDESKTOP pdesk; HRGN hrgn; BOOL fPaletteDisplay; RECT rc; PMONITOR pMonitorNext = gpDispInfo->pMonitorFirst; PMONITOR *ppMonitorLast = &gpDispInfo->pMonitorFirst; TRACE_INIT(("xxxUpdateUserScreen\n")); UserAssert(gpDispInfo->hdcScreen); UserAssert(gpMonitorCached != NULL); CheckCritIn(); if (!fInitializeTime) { /* * Wait until the unprotected code goes through the monitor reference. * We skip this if it's initializing the session to avoid leaving the * critical section. */ while (InterlockedCompareExchange(&gdwMonitorBusy, TRUE, FALSE) != FALSE) { UserAssert(gdwMonitorBusy == TRUE); RIPMSGF0(RIP_VERBOSE, "Monitor is busy referenced by the mouse input."); LeaveCrit(); UserSleep(1); EnterCrit(); } } /* * 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; if (!fInitializeTime) { /* * Release the monitor busy lock, so that the * mouse cursor update can resume. */ UserAssert(gdwMonitorBusy == TRUE); InterlockedExchange(&gdwMonitorBusy, FALSE); } /* * 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) { int iRgn = RGN_ERROR; 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(); VerifyVisibleMonitorCount(); 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. * * 12-Jan-1994 andreva Created * 23-Jan-1995 ChrisWil ChangeDisplaySettings work. \**************************************************************************/ BOOL InitUserScreen( VOID) { 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; } /* * N.b. although it's xxx, this function does not * leave the critical section if fInitializeTime is TRUE. */ BEGINATOMICCHECK(); if (!xxxUpdateUserScreen(TRUE)) { RIPMSG0(RIP_WARNING, "xxxUpdateUserScreen failed"); fSuccess = FALSE; goto Exit; } ENDATOMICCHECK(); /* * 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, 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(); xxxUpdateUserScreen(FALSE); 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) { UserAssert(gpszWall); 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, 0); } } /***************************************************************************\ * 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 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")); /* * Perform Error Checking to verify flag combinations are valid. */ if (dwFlags & ~CDS_VALID) { return GRE_DISP_CHANGE_BADFLAGS; } if (DrvQueryMDEVPowerState(gpDispInfo->pmdev) == FALSE) { RIPMSG0(RIP_WARNING, "ChangeDisplaySettings failed because the device is powered off"); return GRE_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 UPDATEREGISTRY * is specified. */ if ((dwFlags & (CDS_GLOBAL | CDS_NORESET)) && (!(dwFlags & CDS_UPDATEREGISTRY))) { return GRE_DISP_CHANGE_BADFLAGS; } if ((dwFlags & CDS_NORESET) && (dwFlags & CDS_RESET)) { return GRE_DISP_CHANGE_BADFLAGS; } if ((dwFlags & CDS_EXCLUSIVE) && (dwFlags & CDS_FULLSCREEN) && (dwFlags & CDS_RESET)) { return GRE_DISP_CHANGE_BADFLAGS; } /* * 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 GRE_DISP_CHANGE_FAILED; } } /* * If the modeset is being done on a non-active desktop, we don't want * it to 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 GRE_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 GRE_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); /* * Let's 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 = GRE_DISP_CHANGE_SUCCESSFUL; } else if (status == GRE_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 < GRE_DISP_CHANGE_SUCCESSFUL) { UserAssert(pmdev == NULL); xxxUserResetDisplayDevice(); } 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 = GRE_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 GRE_DISP_CHANGE_BADPARAM; } /* * 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. */ ThreadLock(pwnd, &tlpwnd); UserAssert(ghSwitcher != PsGetCurrentThreadId()); while (ghSwitcher != NULL) { /* * Make sure we aren't blocking anyone who's sending us a message. * They can have ghSwitcher and never release it because they are * waiting on us to process the sent message. And we're waiting on * ghSwitcher, 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 (ghSwitcher != NULL || gbFullScreen != FULLSCREEN) { goto FullscreenSwitchFailed; } } else { /* * For the console windows, we want to call with WINDOWED. */ if (!xxxMakeWindowForegroundWithState(pwnd, WINDOWED)) { goto FullscreenSwitchFailed; } if (ghSwitcher != NULL || 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) { 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) { TL tlpwnd; RECT rcl; 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 the 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) { xxxBroadcastMessage(pdesk->pDeskInfo->spwnd, WM_SETTINGCHANGE, 0, 0, BMSG_SENDNOTIFYMSG, NULL); 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 (ghSwitcher != NULL) { /* * Make sure we aren't blocking anyone who's sending us a * message. They can have ghSwitcher and never release it * because they are waiting on us to process the sent message. * And we're waiting on ghSwitcher, hence a deadlock. */ xxxSleepThread(0, 1, FALSE); } /* * See if the fullscreen window didn't exit fullscreen mode * gracefully. */ if (gspwndFullScreen && (gbFullScreen == FULLSCREEN)) { Status = STATUS_UNSUCCESSFUL; } } return Status; }