dc.c File Reference

#include "precomp.h"

Go to the source code of this file.

Defines
#define	DCX_LEAVEBITS
Functions
__inline VOID	DecrementFreeDCECount (VOID)
__inline VOID	IncrementFreeDCECount (VOID)
void	SetMonitorRegion (PMONITOR pMonitor, HRGN hrgnDst, HRGN hrgnSrc)
VOID	ResetOrg (HRGN hrgn, PDCE pdce, BOOL fSetVisRgn)
HDC	_GetDC (PWND pwnd)
BOOL	_ReleaseDC (HDC hdc)
HDC	_GetWindowDC (PWND pwnd)
VOID	UserSetDCVisRgn (PDCE pdce)
HRGN	UserGetClientRgn (HWND hwnd, LPRECT lprc, BOOL bWindowInsteadOfClient)
BOOL	UserGetHwnd (HDC hdc, HWND *phwnd, PVOID *ppwo, BOOL bCheckStyle)
VOID	UserAssociateHwnd (HWND hwnd, PVOID pwo)
BOOL	UserReleaseDC (HDC hdc)
VOID	InvalidateDce (PDCE pdce)
VOID	DeleteHrgnClip (PDCE pdce)
HDC	_GetDCEx (PWND pwnd, HRGN hrgnClip, DWORD DCX_flags)
UINT	ReleaseCacheDC (HDC hdc, BOOL fEndPaint)
HDC	CreateCacheDC (PWND pwndOrg, DWORD DCX_flags, PMONITOR pMonitor)
PWND	WindowFromCacheDC (HDC hdc)
VOID	DelayedDestroyCacheDC (VOID)
BOOL	DestroyCacheDC (PDCE *ppdce, HDC hdc)
VOID	InvalidateGDIWindows (PWND pwnd)
BOOL	zzzInvalidateDCCache (PWND pwndInvalid, DWORD flags)
PWND	_WindowFromDC (HDC hdc)
PWND	FastWindowFromDC (HDC hdc)
BOOL	GetDCOrgOnScreen (HDC hdc, LPPOINT ppt)
BOOL	UserGetRedirectedWindowOrigin (HDC hdc, LPPOINT ppt)
PDCE	LookupDC (HDC hdc)
HDC	GetMonitorDC (PDCE pdceOrig, PMONITOR pMonitor)

---

Define Documentation

#define DCX_LEAVEBITS

Value: (DCX_WINDOW | DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS | \ DCX_PARENTCLIP | DCX_LOCKWINDOWUPDATE | DCX_NOCLIPCHILDREN | \ DCX_USESTYLE | DCX_EXCLUDEUPDATE | DCX_INTERSECTUPDATE | \ DCX_EXCLUDERGN | DCX_INTERSECTRGN) Definition at line 2146 of file dc.c. Referenced by GetMonitorDC().

---

Function Documentation

HDC _GetDC (  PWND  pwnd  )

Definition at line 148 of file dc.c. References _GetDCEx(), NULL, tagDESKTOP::pDeskInfo, PtiCurrent, and tagDESKTOPINFO::spwnd. Referenced by NtUserGetDC(), UT_InvertCaret(), xxxDesktopWndProc(), xxxMNInvertItem(), and xxxRealizeDesktop(). { /* * Special case for NULL: For backward compatibility we want to return * a window DC for the desktop that does not exclude its children. */ if (pwnd == NULL) { PDESKTOP pdesk = PtiCurrent()->rpdesk; if (pdesk) { return _GetDCEx(pdesk->pDeskInfo->spwnd, NULL, DCX_WINDOW | DCX_CACHE); } /* * The thread has no desktop. Fail the call. */ return NULL; } return _GetDCEx(pwnd, NULL, DCX_USESTYLE); }

HDC _GetDCEx (  PWND  pwnd, HRGN  hrgnClip, DWORD  DCX_flags )

Definition at line 608 of file dc.c. References _GetProp(), BOOL, CalcVisRgn(), CFCLASSDC, CFOWNDC, CFPARENTDC, CopyRgn, CreateCacheDC(), CreateEmptyRgn(), CreateEmptyRgnPublic(), tagDCE::DCX_flags, DecrementFreeDCECount(), DelayedDestroyCacheDC(), DeleteHrgnClip(), DWORD, FALSE, GetLayeredWindow(), GETPTI, ghrgnGDC, gpDispInfo, tagDCE::hdc, tagDISPLAYINFO::hDev, HRGN_FULL, HRGN_SPECIAL_LAST, tagDCE::hrgnClip, tagDCE::hrgnClipPublic, IntersectRgn, IsVisible(), NULL, tagWND::pcls, tagCLS::pdce, tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, tagDCE::pMonitor, PpiCurrent, PROP_LAYER, PtiCurrent, tagDCE::ptiOwner, tagDCE::pwndClip, tagDCE::pwndOrg, tagWND::rcWindow, ResetOrg(), SetEmptyRgn(), SpbCheckDce(), tagWND::spwndParent, SubtractRgn, TestCF, TestWF, TRUE, UpdateLayeredSprite(), WFCLIPCHILDREN, WFCLIPSIBLINGS, WFMINIMIZED, WFVISIBLE, and WFWIN31COMPAT. Referenced by _GetDC(), _GetWindowDC(), _UserSoundSentryWorker(), DrawSwitchWndHilite(), GetTooltipDC(), MNDrawArrow(), MNDrawFullNC(), NtUserGetDCEx(), StopFade(), UserGetDesktopDC(), xxxBeginPaint(), xxxDefWindowProc(), xxxDrawAnimatedRects(), xxxDrawDragRect(), xxxDrawMenuBarUnderlines(), xxxDWP_DoNCActivate(), xxxHotTrackMenu(), xxxMenuWindowProc(), xxxMNCompute(), xxxMoveSwitchWndHilite(), xxxPaintIconsInSwitchWindow(), xxxPaintSwitchWindow(), xxxRedrawHungWindow(), xxxRedrawHungWindowFrame(), xxxScrollWindowEx(), xxxSendEraseBkgnd(), and xxxTrackCaptionButton(). { HRGN hrgn; HDC hdcMatch; PWND pwndClip; PWND pwndOrg; PDCE pdce; PDCE *ppdce; PDCE *ppdceNotInUse; DWORD DCX_flagsMatch; BOOL bpwndOrgVisible; PWND pwndLayer; HBITMAP hbmLayer; BOOL fVisRgnError = FALSE; /* * Lock the device while we're playing with visrgns. */ GreLockDisplay(gpDispInfo->hDev); if (pwnd == NULL) pwnd = PtiCurrent()->rpdesk->pDeskInfo->spwnd; hdcMatch = NULL; pwndOrg = pwndClip = pwnd; bpwndOrgVisible = IsVisible(pwndOrg); if (PpiCurrent()->W32PF_Flags & W32PF_OWNDCCLEANUP) { DelayedDestroyCacheDC(); } /* * If necessary, compute DCX flags from window style. */ if (DCX_flags & DCX_USESTYLE) { DCX_flags &= ~(DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN | DCX_PARENTCLIP); if (!(DCX_flags & DCX_WINDOW)) { if (TestCF(pwndOrg, CFPARENTDC)) DCX_flags |= DCX_PARENTCLIP; /* * If the DCX_CACHE flag is present, override OWNDC/CLASSDC. * Otherwise, calculate from appropriate style bits. */ if (!(DCX_flags & DCX_CACHE) && !TestCF(pwndOrg, CFOWNDC)) { if (TestCF(pwndOrg, CFCLASSDC)) { /* * Look for a non-cache entry that matches hdc... */ if (pwndOrg->pcls->pdce != NULL) { hdcMatch = pwndOrg->pcls->pdce->hdc; } } else { DCX_flags |= DCX_CACHE; } } if (TestWF(pwndOrg, WFCLIPCHILDREN)) DCX_flags |= DCX_CLIPCHILDREN; if (TestWF(pwndOrg, WFCLIPSIBLINGS)) DCX_flags |= DCX_CLIPSIBLINGS; /* * Minimized windows never exclude their children. */ if (TestWF(pwndOrg, WFMINIMIZED)) { DCX_flags &= ~DCX_CLIPCHILDREN; if (pwndOrg->pcls->spicn) DCX_flags |= DCX_CACHE; } } else { if (TestWF(pwndClip, WFCLIPSIBLINGS)) DCX_flags |= DCX_CLIPSIBLINGS; DCX_flags |= DCX_CACHE; /* * Window DCs never exclude children. */ } } /* * Deal with all the Win 3.0-compatible clipping rules: * * DCX_NOCLIPCHILDREN overrides: * DCX_PARENTCLIP/CS_OWNDC/CS_CLASSDC * DCX_PARENTCLIP overrides: * DCX_CLIPSIBLINGS/DCX_CLIPCHILDREN/CS_OWNDC/CS_CLASSDC */ if (DCX_flags & DCX_NOCLIPCHILDREN) { DCX_flags &= ~(DCX_PARENTCLIP | DCX_CLIPCHILDREN); DCX_flags |= DCX_CACHE; } /* * Deal with layered windows. */ if ((pwndLayer = GetLayeredWindow(pwndOrg)) != NULL && (hbmLayer = _GetProp(pwndLayer, PROP_LAYER, TRUE)) != NULL) { /* * Get a layered redirection DC. */ DCX_flags |= DCX_LAYERED; /* * When the window we're getting the DC for is the layered and * redirected window, don't allow to clip to its parent, since * clipping must not exceed the size of the backing bitmap. */ if (pwndOrg == pwndLayer) { DCX_flags &= ~DCX_PARENTCLIP; } /* * Convert hrgnClip from screen to the redirection DC coordinates. */ if (hrgnClip > HRGN_SPECIAL_LAST) { GreOffsetRgn(hrgnClip, -pwndLayer->rcWindow.left, -pwndLayer->rcWindow.top); } } else { pwndLayer = NULL; hbmLayer = NULL; } if (DCX_flags & DCX_PARENTCLIP) { PWND pwndParent; /* * If this window has no parent. This can occur if the app is * calling GetDC in response to a CBT_CREATEWND callback. In this * case, the parent is not yet setup. */ if (pwndOrg->spwndParent == NULL) pwndParent = PtiCurrent()->rpdesk->pDeskInfo->spwnd; else pwndParent = pwndOrg->spwndParent; /* * Always get the DC from the cache. */ DCX_flags |= DCX_CACHE; /* * We can't use a shared DC if the visibility of the * child does not match the parent's, or if a * CLIPSIBLINGS or CLIPCHILDREN DC is requested. * * In 3.1, we pay attention to the CLIPSIBLINGS and CLIPCHILDREN * bits of CS_PARENTDC windows, by overriding CS_PARENTDC if * either of these flags are requested. * * BACKWARD COMPATIBILITY HACK * * If parent is CLIPCHILDREN, get a cache DC, but don't * use parent's DC. Windows PowerPoint depends on this * behavior in order to draw the little gray rect between * its scroll bars correctly. */ if (!(DCX_flags & (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN)) && (TestWF(pwndOrg, WFWIN31COMPAT) || !TestWF(pwndParent, WFCLIPCHILDREN)) && TestWF(pwndParent, WFVISIBLE) == TestWF(pwndOrg, WFVISIBLE)) { pwndClip = pwndParent; #if DBG if (DCX_flags & DCX_CLIPCHILDREN) RIPMSG0(RIP_WARNING, "WS_CLIPCHILDREN overridden by CS_PARENTDC"); if (DCX_flags & DCX_CLIPSIBLINGS) RIPMSG0(RIP_WARNING, "WS_CLIPSIBLINGS overridden by CS_PARENTDC"); #endif /* * Make sure flags reflect hwndClip rather than hwndOrg. * But, we must never clip the children (since that's who * wants to do the drawing!) */ DCX_flags &= ~(DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS); if (TestWF(pwndClip, WFCLIPSIBLINGS)) DCX_flags |= DCX_CLIPSIBLINGS; } } /* * Make sure we don't return an OWNDC if the calling thread didn't * create this window - need to returned cached always in this case. * * Win95 does not contain this code. Why? */ if (!(DCX_flags & DCX_CACHE)) { if (pwndOrg == NULL || GETPTI(pwndOrg) != PtiCurrent()) DCX_flags |= DCX_CACHE; } DCX_flagsMatch = DCX_flags & DCX_MATCHMASK; if (!(DCX_flags & DCX_CACHE)) { /* * Handle CS_OWNDC and CS_CLASSDC cases specially. Based on the * supplied match information, we need to find the appropriate DCE. */ for (ppdce = &gpDispInfo->pdceFirst; (pdce = *ppdce); ppdce = &pdce->pdceNext) { if (pdce->DCX_flags & DCX_CACHE) continue; /* * Look for the entry that matches hdcMatch or pwndOrg... */ if (!(pdce->pwndOrg == pwndOrg || pdce->hdc == hdcMatch)) continue; /* * NOTE: The "Multiple-BeginPaint()-of-OWNDC-Window" Conundrum * * There is a situation having to do with OWNDC or CLASSDC window * DCs that can theoretically arise that is handled specially * here and in ReleaseCacheDC(). These DCs are identified with * the DCX_CACHE bit CLEAR. * * In the case where BeginPaint() (or a similar operation) is * called more than once without an intervening EndPaint(), the * DCX_INTERSECTRGN (or DCX_EXCLUDERGN) bit may already be set * when we get here. * * Theoretically, the correct thing to do is to save the current * hrgnClip, and set up the new one here. In ReleaseCacheDC, the * saved hrgnClip is restored and the visrgn recomputed. * * All of this is only necessary if BOTH calls involve an * hrgnClip that causes the visrgn to be changed (i.e., the * simple hrgnClip test clears the INTERSECTRGN or EXCLUDERGN bit * fails), which is not at all likely. * * When this code encounters this multiple-BeginPaint case it * punts by honoring the new EXCLUDE/INTERSECTRGN bits, but it * first restores the DC to a wide-open visrgn before doing so. * This means that the first EndPaint() will restore the visrgn * to a wide-open DC, rather than clipped to the first * BeginPaint()'s update rgn. This is a good punt, because worst * case an app does a bit more drawing than it should. */ if ((pdce->DCX_flags & (DCX_EXCLUDERGN | DCX_INTERSECTRGN)) && (DCX_flags & (DCX_EXCLUDERGN | DCX_INTERSECTRGN))) { RIPMSG0(RIP_WARNING, "Nested BeginPaint() calls, please fix Your app!"); DeleteHrgnClip(pdce); } if (pdce->DCX_flags & DCX_LAYERED) { /* * We're giving out the same DC again. Since it may not have * been released, transfer any accumulated bits if needed. */ UpdateLayeredSprite(pdce); /* * As this point, the DC may get converted back to a screen * DC, so we must select the screen surface back into the DC. */ UserVerify(GreSelectRedirectionBitmap(pdce->hdc, NULL)); } /* * If we matched exactly, no recomputation necessary * (we found a CS_OWNDC or a CS_CLASSDC that is already set up) * Otherwise, we have a CS_CLASSDC that needs recomputation. */ if ( pdce->pwndOrg == pwndOrg && bpwndOrgVisible && (pdce->DCX_flags & DCX_LAYERED) == (DCX_flags & DCX_LAYERED) && !(pdce->DCX_flags & DCX_PWNDORGINVISIBLE)) { goto HaveComputedEntry; } goto RecomputeEntry; } RIPMSG1(RIP_WARNING, "Couldn't find DC for %p - bad code path", pwndOrg); NullExit: GreUnlockDisplay(gpDispInfo->hDev); return NULL; } else { /* * Make a quick pass through the cache, looking for an * exact match. */ SearchAgain: #if DBG if (fDisableCache) goto SearchFailed; #endif /* * CONSIDER (adams): Put this check into the loop above so we don't * touch all these pages twice? */ for (ppdce = &gpDispInfo->pdceFirst; (pdce = *ppdce); ppdce = &pdce->pdceNext) { /* * If we find an entry that is not in use and whose clip flags * and clip window match, we can use it. * * NOTE: DCX_INTERSECT/EXCLUDERGN cache entries always have * DCX_INUSE set, so we'll never erroneously match one here. */ UserAssert(!(pdce->DCX_flags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN)) || (pdce->DCX_flags & DCX_INUSE)); if ((pdce->pwndClip == pwndClip) && pdce->pMonitor == NULL && (DCX_flagsMatch == (pdce->DCX_flags & (DCX_MATCHMASK | DCX_INUSE | DCX_INVALID)))) { /* * Special case for icon - bug 9103 (win31) */ if (TestWF(pwndClip, WFMINIMIZED) && (pdce->pwndOrg != pdce->pwndClip)) { continue; } /* * If the pwndOrg of the DC we found is not visible and * the pwndOrg we're looking for is visble, then * the visrgn is no good, we can't reuse it so keep * looking. */ if (bpwndOrgVisible && pdce->DCX_flags & DCX_PWNDORGINVISIBLE) { continue; } /* * Set INUSE before performing any GDI operations, just * in case DCHook() has a mind to recalculate the visrgn... */ pdce->DCX_flags |= DCX_INUSE; /* * We found an entry with the proper visrgn. * If the origin doesn't match, update the CE and reset it. */ if (pwndOrg != pdce->pwndOrg) { /* * Need to flush any dirty rectangle stuff now. */ SpbCheckDce(pdce); pdce->pwndOrg = pwndOrg; ResetOrg(NULL, pdce, FALSE); } goto HaveComputedEntry; } } #if DBG SearchFailed: #endif /* * Couldn't find an exact match. Find some invalid or non-inuse * entry we can reuse. */ ppdceNotInUse = NULL; for (ppdce = &gpDispInfo->pdceFirst; (pdce = *ppdce); ppdce = &pdce->pdceNext) { /* * Skip non-cache entries */ if (!(pdce->DCX_flags & DCX_CACHE)) continue; /* * Skip monitor-specific entires */ if (pdce->pMonitor != NULL) continue; if (pdce->DCX_flags & DCX_INVALID) { break; } else if (!(pdce->DCX_flags & DCX_INUSE)) { /* * Remember the non-inuse one, but keep looking for an invalid. */ ppdceNotInUse = ppdce; } } /* * If we broke out of the loop, we found an invalid entry to reuse. * Otherwise see if we found a non-inuse entry to reuse. */ if (pdce == NULL && ((ppdce = ppdceNotInUse) == NULL)) { /* * Create another DCE if we need it. */ if (!CreateCacheDC(pwndOrg, DCX_INVALID | DCX_CACHE | (DCX_flags & DCX_LAYERED), NULL)) { goto NullExit; } goto SearchAgain; } /* * We've chosen an entry to reuse: now fill it in and recompute it. */ pdce = *ppdce; RecomputeEntry: /* * Any non-invalid entries that we reuse might still have some bounds * that need to be used to invalidate SPBs. Apply them here. */ if (!(pdce->DCX_flags & DCX_INVALID)) SpbCheckDce(pdce); /* * We want to compute only the matchable visrgn at first, * so we don't set up hrgnClip, or set the EXCLUDERGN or INTERSECTRGN * bits yet -- we'll deal with those later. */ pdce->DCX_flags = DCX_flagsMatch | DCX_INUSE; #if DBG /* * We're about to select the visrgn into the DC, even though it's * not yet completely setup. Turn off the visrgn validation for now. * It will be turned on before this function returns. */ GreValidateVisrgn(pdce->hdc, FALSE); #endif /* * Now recompute the visrgn (minus any hrgnClip shenanigans) */ hrgn = NULL; if (CalcVisRgn(&hrgn, pwndOrg, pwndClip, DCX_flagsMatch) == FALSE) { pdce->DCX_flags |= DCX_PWNDORGINVISIBLE; } pdce->pwndOrg = pwndOrg; pdce->pwndClip = pwndClip; pdce->hrgnClip = NULL; // Just in case... pdce->hrgnClipPublic = NULL; ResetOrg(hrgn, pdce, TRUE); if (hrgn == NULL) { fVisRgnError = TRUE; } /* * When we arrive here, pdce (and *ppdce) point to * a cache entry whose visrgn and origin are set up. * All that remains to be done is to deal with EXCLUDE/INTERSECTRGN */ HaveComputedEntry: /* * If the window clipping flags have changed in the window * since the last time this dc was invalidated, then recompute * this dc entry. */ if ((pdce->DCX_flags & DCX_MATCHMASK) != (DCX_flags & DCX_MATCHMASK)) goto RecomputeEntry; /* * Let's check these assertions just in case... */ UserAssert(pdce); UserAssert(*ppdce == pdce); UserAssert(pdce->DCX_flags & DCX_INUSE); UserAssert(!(pdce->DCX_flags & DCX_INVALID)); UserAssert((pdce->DCX_flags & DCX_MATCHMASK) == (DCX_flags & DCX_MATCHMASK)); /* * Move the dce to the head of the list so it's easy to find later. */ if (pdce != gpDispInfo->pdceFirst) { *ppdce = pdce->pdceNext; pdce->pdceNext = gpDispInfo->pdceFirst; gpDispInfo->pdceFirst = pdce; } #if DBG /* * We're about to mess with the visrgn in this DC, even though it's * not yet completely setup. Turn off the visrgn validation for now. * It will be turned on before this function returns. */ GreValidateVisrgn(pdce->hdc, FALSE); #endif /* * Time to deal with DCX_INTERSECTRGN or DCX_EXCLUDERGN. * * We handle these two bits specially, because cache entries * with these bits set cannot be reused with the bits set. This * is because the area described in hrgnClip would have to be * compared along with the bit, which is a pain, especially since * they'd never match very often anyhow. * * What we do instead is to save the visrgn of the window before * applying either of these two flags, which is then restored * at ReleaseCacheDC() time, along with the clearing of these bits. * This effectively converts a cache entry with either of these * bits set into a "normal" cache entry that can be matched. */ if (DCX_flags & DCX_INTERSECTRGN) { if (hrgnClip != HRGN_FULL) { SetEmptyRgn(ghrgnGDC); /* * Save the visrgn for reuse on ReleaseDC(). * (do this BEFORE we set hrgnClip & pdce->flag bit, * so that if a DCHook() callback occurs it recalculates * without hrgnClip) */ UserAssertMsg0(!pdce->hrgnSavedVis, "Nested SaveVisRgn attempt in _GetDCEx"); /* * get the current vis region into hrgnSavedVis. Temporarily * store a dummy one in the DC. */ pdce->hrgnSavedVis = CreateEmptyRgn(); GreSelectVisRgn(pdce->hdc,pdce->hrgnSavedVis, SVR_SWAP); pdce->hrgnClip = hrgnClip; if (DCX_flags & DCX_NODELETERGN) pdce->DCX_flags |= DCX_NODELETERGN; pdce->DCX_flags |= DCX_INTERSECTRGN; if (hrgnClip == NULL) { pdce->hrgnClipPublic = NULL; } else { IntersectRgn(ghrgnGDC, pdce->hrgnSavedVis, hrgnClip); /* * Make a copy of the hrgnClip and make it public * so that we can use it in calculations in HungDraw. */ pdce->hrgnClipPublic = CreateEmptyRgnPublic(); CopyRgn(pdce->hrgnClipPublic, hrgnClip); } /* * Clear the SAVEDRGNINVALID bit, since we're just * about to set it properly now. If the dce later * gets invalidated, it'll set this bit so we know * to recompute it when we restore the visrgn. */ pdce->DCX_flags &= ~DCX_SAVEDRGNINVALID; /* * Select in the new region. we use the SWAP_REGION mode * so that ghrgnGDC always has a valid rgn */ GreSelectVisRgn(pdce->hdc, ghrgnGDC, SVR_SWAP); } } else if (DCX_flags & DCX_EXCLUDERGN) { if (hrgnClip != NULL) { SetEmptyRgn(ghrgnGDC); /* * Save the visrgn for reuse on ReleaseDC(). * (do this BEFORE we set hrgnClip & pdce->flag bit, * so that if a DCHook() callback occurs it recalculates * without hrgnClip) */ UserAssertMsg0(!pdce->hrgnSavedVis, "Nested SaveVisRgn attempt in _GetDCEx"); /* * get the current vis region into hrgnSavedVis. Temporarily * store a dummy one in the DC. */ pdce->hrgnSavedVis = CreateEmptyRgn(); GreSelectVisRgn(pdce->hdc,pdce->hrgnSavedVis, SVR_SWAP); pdce->hrgnClip = hrgnClip; if (DCX_flags & DCX_NODELETERGN) pdce->DCX_flags |= DCX_NODELETERGN; pdce->DCX_flags |= DCX_EXCLUDERGN; if (hrgnClip == HRGN_FULL) { pdce->hrgnClipPublic = HRGN_FULL; } else { SubtractRgn(ghrgnGDC, pdce->hrgnSavedVis, hrgnClip); /* * Make a copy of the hrgnClip and make it public * so that we can use it in calculations in HungDraw. */ pdce->hrgnClipPublic = CreateEmptyRgnPublic(); CopyRgn(pdce->hrgnClipPublic, hrgnClip); } /* * Clear the SAVEDRGNINVALID bit, since we're just * about to set it properly now. If the dce later * gets invalidated, it'll set this bit so we know * to recompute it when we restore the visrgn. */ pdce->DCX_flags &= ~DCX_SAVEDRGNINVALID; /* * Select in the new region. we use the SWAP_REGION mode * so that ghrgnGDC always has a valid rgn */ GreSelectVisRgn(pdce->hdc, ghrgnGDC, SVR_SWAP); } } } if (pdce->DCX_flags & DCX_LAYERED) { UserAssert(pwndLayer != NULL); UserAssert(hbmLayer != NULL); UserVerify(GreSelectRedirectionBitmap(pdce->hdc, hbmLayer)); /* * Enable bounds accumulation, so we know if there was any drawing * done into that DC and the actual rect we need to update when * this DC is released. */ GreGetBounds(pdce->hdc, NULL, GGB_ENABLE_WINMGR); /* * In case the visrgn couldn't be allocated, clear it in the * dc again, since we just selected a new surface. */ if (fVisRgnError) { GreSelectVisRgn(pdce->hdc, NULL, SVR_DELETEOLD); } } /* * Whew! Set ownership and return the bloody DC. * Only set ownership for cache dcs. Own dcs have already been owned. * The reason why we don't want to set the ownership over again is * because the console sets its owndcs to PUBLIC so gdisrv can use * them without asserting. We don't want to set the ownership back * again. */ if (pdce->DCX_flags & DCX_CACHE) { if (!GreSetDCOwner(pdce->hdc, OBJECT_OWNER_CURRENT)) { RIPMSG1(RIP_WARNING, "GetDCEx: SetDCOwner Failed %lX", pdce->hdc); } /* * Decrement the Free DCE Count. This should always be >= 0, * since we'll create a new dce if the cache is all in use. */ DecrementFreeDCECount(); pdce->ptiOwner = PtiCurrent(); } #ifdef USE_MIRRORING if (TestWF(pwnd, WEFLAYOUTRTL) && !(DCX_flags & DCX_NOMIRROR)) { GreSetLayout(pdce->hdc, -1, LAYOUT_RTL); } #endif #if DBG GreValidateVisrgn(pdce->hdc, TRUE); #endif GreUnlockDisplay(gpDispInfo->hDev); return pdce->hdc; }

HDC _GetWindowDC (  PWND  pwnd  )

Definition at line 201 of file dc.c. References _GetDCEx(), NULL, TestWF, WFMINIMIZED, and WFWIN40COMPAT. Referenced by _UserSoundSentryWorker(), DrawCtlThumb(), InvertScrollHilite(), NtUserGetWindowDC(), xxxDrawThumb(), xxxEnableWndSBArrows(), xxxMNInvertItem(), xxxMoveThumb(), xxxRedrawTitle(), xxxSBWndProc(), xxxSnapWindow(), and zzzDrawInvertScrollArea(). { #if 0 /* * For WIN31 and previous apps, we want to actually return back a * client DC. Before WIN40, the window rect and client rect were the * same, and there was this terrible hack to grab the window dc when * painting because window DCs never clip anything. Otherwise the * children of the minimized window would be clipped out of the fake * client area. So apps would call GetWindowDC() to redraw their icons, * since GetDC() would clip empty if the window had a class icon. */ if (TestWF(pwnd, WFMINIMIZED) && !TestWF(pwnd, WFWIN40COMPAT)) return(_GetDCEx(pwnd, hrgnClip, DCX_INTERNAL | DCX_CACHE | DCX_USESTYLE)); #endif return _GetDCEx(pwnd, NULL, DCX_WINDOW | DCX_USESTYLE); }

BOOL _ReleaseDC (  HDC  hdc  )

Definition at line 183 of file dc.c. References BOOL, CheckCritIn, DCE_NORELEASE, FALSE, ReleaseCacheDC(), and TRUE. Referenced by _UserSoundSentryWorker(), CreateTooltipBitmap(), DrawCtlThumb(), DrawSwitchWndHilite(), InitTooltipAnimation(), InvertScrollHilite(), MNAnimate(), MNDrawArrow(), MNDrawFullNC(), StopFade(), TooltipAnimate(), TooltipGetSize(), UserReleaseDC(), UT_InvertCaret(), xxxDefWindowProc(), xxxDesktopWndProc(), xxxDrawAnimatedRects(), xxxDrawDragRect(), xxxDrawMenuBarUnderlines(), xxxDrawThumb(), xxxDWP_DoNCActivate(), xxxEnableWndSBArrows(), xxxHotTrackMenu(), xxxMenuWindowProc(), xxxMNCompute(), xxxMNInvertItem(), xxxMoveSwitchWndHilite(), xxxMoveThumb(), xxxPaintIconsInSwitchWindow(), xxxPaintSwitchWindow(), xxxRealizeDesktop(), xxxRedrawHungWindow(), xxxRedrawHungWindowFrame(), xxxRedrawTitle(), xxxSBWndProc(), xxxScrollWindowEx(), xxxSnapWindow(), xxxTrackCaptionButton(), and zzzDrawInvertScrollArea(). { CheckCritIn(); return (ReleaseCacheDC(hdc, FALSE) == DCE_NORELEASE ? FALSE : TRUE); }

PWND _WindowFromDC (  HDC  hdc  )

Definition at line 1995 of file dc.c. References tagDCE::DCX_flags, gpDispInfo, tagDCE::hdc, NULL, tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, and tagDCE::pwndOrg. Referenced by xxxAnimateCaption(). { PDCE pdce; for (pdce = gpDispInfo->pdceFirst; pdce; pdce = pdce->pdceNext) { if (!(pdce->DCX_flags & DCX_INUSE) || (pdce->DCX_flags & DCX_CREATEDC)) continue; if (pdce->hdc == hdc) return pdce->pwndOrg; } return NULL; }

HDC CreateCacheDC (  PWND  pwndOrg, DWORD  DCX_flags, PMONITOR  pMonitor )

Definition at line 1463 of file dc.c. References AnySpbs, CFCLASSDC, DCE, tagDCE::DCX_flags, FALSE, gpDispInfo, tagDCE::hdc, tagDISPLAYINFO::hDev, tagMONITOR::hDev, tagDCE::hrgnClip, tagDCE::hrgnClipPublic, tagDCE::hrgnSavedVis, IncrementFreeDCECount(), InvalidateDce(), NULL, tagWND::pcls, tagCLS::pdce, tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, tagDCE::pMonitor, PtiCurrent, tagDCE::ptiOwner, tagDCE::pwndClip, tagDCE::pwndOrg, and TestCF. Referenced by _GetDCEx(), GetMonitorDC(), InitUserScreen(), and xxxCreateWindowEx(). { PDCE pdce; HDC hdc; HANDLE hDev; if ((pdce = (PDCE)UserAllocPool(sizeof(DCE), TAG_DCE)) == NULL) return NULL; if (pMonitor == NULL) { hDev = gpDispInfo->hDev; } else { hDev = pMonitor->hDev; } if ((hdc = GreCreateDisplayDC(hDev, DCTYPE_DIRECT, FALSE)) == NULL) { UserFreePool(pdce); return NULL; } /* * Link this entry into the cache entry list. */ pdce->pdceNext = gpDispInfo->pdceFirst; gpDispInfo->pdceFirst = pdce; pdce->hdc = hdc; pdce->DCX_flags = DCX_flags; pdce->pwndOrg = pwndOrg; pdce->pwndClip = pwndOrg; pdce->hrgnClip = NULL; pdce->hrgnClipPublic = NULL; pdce->hrgnSavedVis = NULL; pdce->pMonitor = pMonitor; /* * Mark it as undeleteable so no application can delete it out of our * cache! */ GreMarkUndeletableDC(hdc); if (DCX_flags & DCX_OWNDC) { /* * Set the ownership of owndcs immediately: that way console can set * the owernship to PUBLIC when it calls GetDC so that both the input * thread and the service threads can use the same owndc. */ GreSetDCOwner(hdc, OBJECT_OWNER_CURRENT); pdce->ptiOwner = PtiCurrent(); } else { /* * Otherwise it is a cache dc... set its owner to none - nothing * is using it - equivalent of "being in the cache" but unaccessible * to other processes. */ GreSetDCOwner(hdc, OBJECT_OWNER_NONE); pdce->ptiOwner = NULL; /* * Increment the available-cacheDC count. Once this hits our * threshold, then we can free-up some of the entries. */ IncrementFreeDCECount(); } /* * If we're creating a permanent DC, then compute it now. */ if (!(DCX_flags & DCX_CACHE)) { /* * Set up the class DC now... */ if (TestCF(pwndOrg, CFCLASSDC)) pwndOrg->pcls->pdce = pdce; /* * Finish setting up DCE and force eventual visrgn calculation. */ UserAssert(!(DCX_flags & DCX_WINDOW)); pdce->DCX_flags |= DCX_INUSE; InvalidateDce(pdce); } /* * If there are any spb's around then enable bounds accumulation. */ if (AnySpbs()) GreGetBounds(pdce->hdc, NULL, DCB_ENABLE | DCB_SET | DCB_WINDOWMGR); return pdce->hdc; }

__inline VOID DecrementFreeDCECount (  VOID   )

Definition at line 30 of file dc.c. References gnDCECount, and VOID(). Referenced by _GetDCEx(), DestroyCacheDC(), and GetMonitorDC(). { gnDCECount--; UserAssert(gnDCECount >= 0); }

VOID DelayedDestroyCacheDC (  VOID   )

Definition at line 1596 of file dc.c. References tagDCE::DCX_flags, DestroyCacheDC(), gpDispInfo, tagDCE::hdc, NULL, tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, PpiCurrent, and VOID(). Referenced by _GetDCEx(), CleanupGDI(), and DestroyProcessInfo(). { PDCE *ppdce; PDCE pdce; /* * Zip through the cache looking for a DCX_DESTROYTHIS hdc. */ for (ppdce = &gpDispInfo->pdceFirst; *ppdce != NULL; ) { /* * If we found a DCE on this thread that we tried to destroy * earlier, try and destroy it again. */ pdce = *ppdce; if (pdce->DCX_flags & DCX_DESTROYTHIS) 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; } PpiCurrent()->W32PF_Flags &= ~W32PF_OWNDCCLEANUP; }

VOID DeleteHrgnClip (  PDCE  pdce  )

Definition at line 549 of file dc.c. References tagDCE::DCX_flags, DeleteMaybeSpecialRgn(), tagDCE::hdc, tagDCE::hrgnClip, tagDCE::hrgnClipPublic, tagDCE::hrgnSavedVis, InvalidateDce(), NULL, and VOID(). Referenced by _GetDCEx(), ReleaseCacheDC(), and xxxFreeWindow(). { /* * Clear these flags first in case we get a DCHook() callback... */ pdce->DCX_flags &= ~(DCX_EXCLUDERGN | DCX_INTERSECTRGN); /* * Blow away pdce->hrgnClip and clear the associated flags. * Do not delete hrgnClip if DCX_NODELETERGN is set! */ if (!(pdce->DCX_flags & DCX_NODELETERGN)) { DeleteMaybeSpecialRgn(pdce->hrgnClip); } else { pdce->DCX_flags &= ~DCX_NODELETERGN; } DeleteMaybeSpecialRgn(pdce->hrgnClipPublic); pdce->hrgnClip = NULL; pdce->hrgnClipPublic = NULL; /* * If the saved visrgn was invalidated by an InvalidateDce() * while we had it checked out, then invalidate the entry now. */ if (pdce->DCX_flags & DCX_SAVEDRGNINVALID) { InvalidateDce(pdce); /* * We've just gone through InvalidateDce, so the visrgn in the * DC has been properly reset. Simply nuke the old saved visrgn. */ if (pdce->hrgnSavedVis != NULL) { GreDeleteObject(pdce->hrgnSavedVis); pdce->hrgnSavedVis = NULL; } } else { /* * The saved visrgn is still valid, select it back into the * DC so the entry may be re-used without recomputing. */ if (pdce->hrgnSavedVis != NULL) { GreSelectVisRgn(pdce->hdc, pdce->hrgnSavedVis, SVR_DELETEOLD); pdce->hrgnSavedVis = NULL; } } }

BOOL DestroyCacheDC (  PDCE *  ppdce, HDC  hdc )

Definition at line 1638 of file dc.c. References BOOL, tagDCE::DCX_flags, DecrementFreeDCECount(), DeleteMaybeSpecialRgn(), FALSE, gpDispInfo, tagDCE::hdc, tagDCE::hrgnClip, tagDCE::hrgnClipPublic, tagDCE::hrgnSavedVis, NULL, tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, PpiCurrent, tagDCE::pwndClip, tagDCE::pwndOrg, and TRUE. Referenced by DelayedDestroyCacheDC(), DestroyCacheDCEntries(), DestroyClass(), DestroyMonitorDCs(), ReleaseCacheDC(), xxxFreeWindow(), and xxxUserProcessCallout(). { PDCE pdce; /* * Zip through the cache looking for hdc. */ if (ppdce == NULL) { for (ppdce = &gpDispInfo->pdceFirst; (pdce = *ppdce); ppdce = &pdce->pdceNext) { if (pdce->hdc == hdc) break; } } if (ppdce == NULL) return FALSE; /* * Set this here so we know this DCE is supposed to be deleted. */ pdce = *ppdce; pdce->DCX_flags |= DCX_DESTROYTHIS; /* * Free up the dce object and contents. */ if (!(pdce->DCX_flags & DCX_NODELETERGN)) { DeleteMaybeSpecialRgn(pdce->hrgnClip); pdce->hrgnClip = NULL; } if (pdce->hrgnClipPublic != NULL) { GreDeleteObject(pdce->hrgnClipPublic); pdce->hrgnClipPublic = NULL; } if (pdce->hrgnSavedVis != NULL) { GreDeleteObject(pdce->hrgnSavedVis); pdce->hrgnSavedVis = NULL; } /* * If GreSetDCOwner() or GreDeleteDC() fail, the * DC is in-use by another thread. Set * W32PF_OWNDCCLEANUP so we know to scan for and * delete this DCE later. */ if (!GreSetDCOwner(hdc, OBJECT_OWNER_PUBLIC)) { PpiCurrent()->W32PF_Flags |= W32PF_OWNDCCLEANUP; return FALSE; } /* * Set the don't rip flag so our routine RipIfCacheDC() doesn't * rip (called back from gdi). */ #if DBG pdce->DCX_flags |= DCX_DONTRIPONDESTROY; GreMarkDeletableDC(hdc); // So GRE doesn't RIP. #endif if (!GreDeleteDC(hdc)) { #if DBG GreMarkUndeletableDC(hdc); pdce->DCX_flags &= ~DCX_DONTRIPONDESTROY; #endif PpiCurrent()->W32PF_Flags |= W32PF_OWNDCCLEANUP; return FALSE; } /* * Decrement this dc-entry from the free-list count. */ if (pdce->DCX_flags & DCX_CACHE) { if (!(pdce->DCX_flags & DCX_INUSE)) { DecrementFreeDCECount(); } } #if DBG pdce->pwndOrg = NULL; pdce->pwndClip = NULL; #endif /* * Unlink the DCE from the list. */ *ppdce = pdce->pdceNext; UserFreePool(pdce); return TRUE; }

PWND FastWindowFromDC (  HDC  hdc  )

Definition at line 2022 of file dc.c. References tagDCE::DCX_flags, gpDispInfo, tagDCE::hdc, NULL, tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, and tagDCE::pwndOrg. Referenced by _ScrollDC(). { PDCE *ppdce; PDCE pdceT; if ((gpDispInfo->pdceFirst->hdc == hdc) && (gpDispInfo->pdceFirst->DCX_flags & DCX_INUSE)) { return gpDispInfo->pdceFirst->pwndOrg; } for (ppdce = &gpDispInfo->pdceFirst; *ppdce; ppdce = &(*ppdce)->pdceNext) { if (((*ppdce)->hdc == hdc) && ((*ppdce)->DCX_flags & DCX_INUSE)) { /* * Unlink/link to make it first. */ pdceT = *ppdce; *ppdce = pdceT->pdceNext; pdceT->pdceNext = gpDispInfo->pdceFirst; gpDispInfo->pdceFirst = pdceT; return pdceT->pwndOrg; } } return NULL; }

BOOL GetDCOrgOnScreen (  HDC  hdc, LPPOINT  ppt )

Definition at line 2066 of file dc.c. References BOOL, FALSE, TRUE, and UserGetRedirectedWindowOrigin(). Referenced by InternalScrollDC(), and xxxScrollWindowEx(). { if (GreGetDCOrg(hdc, ppt)) { POINT ptScreen; /* * Get the origin of the redirected window in screen coordinates. */ if (UserGetRedirectedWindowOrigin(hdc, &ptScreen)) { ppt->x += ptScreen.x; ppt->y += ptScreen.y; return TRUE; } } return FALSE; }

HDC GetMonitorDC (  PDCE  pdceOrig, PMONITOR  pMonitor )

Definition at line 2151 of file dc.c. References CreateCacheDC(), CreateEmptyRgn(), tagDCE::DCX_flags, DCX_LEAVEBITS, DecrementFreeDCECount(), ghrgnGDC, gpDispInfo, tagDCE::hdc, HRGN_FULL, tagDCE::hrgnClip, NULL, OffsetRect(), tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, tagDCE::pMonitor, tagDCE::ptiOwner, tagDCE::pwndClip, tagDCE::pwndOrg, tagMONITOR::rcMonitor, SetMonitorRegion(), and SpbCheckDce(). Referenced by xxxEnumDisplayMonitors(). { PDCE pdce; POINT pt; RECT rc; TryAgain: for (pdce = gpDispInfo->pdceFirst; pdce != NULL; pdce = pdce->pdceNext) { /* * Find an available DC for this monitor. */ if (pdce->DCX_flags & (DCX_INUSE | DCX_DESTROYTHIS)) continue; if (pdce->pMonitor != pMonitor) continue; if (!(pdce->DCX_flags & DCX_INVALID)) SpbCheckDce(pdce); /* * Copy DC properties and style bits. */ GreSetDCOwner(pdce->hdc, OBJECT_OWNER_CURRENT); pdce->pwndOrg = pdceOrig->pwndOrg; pdce->pwndClip = pdceOrig->pwndClip; pdce->ptiOwner = pdceOrig->ptiOwner; pdce->DCX_flags = (DCX_INUSE | DCX_CACHE) | (pdceOrig->DCX_flags & DCX_LEAVEBITS); if (pdceOrig->hrgnClip > HRGN_FULL) { UserAssert(pdce->hrgnClip == NULL); UserAssert(pdceOrig->DCX_flags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN)); pdce->hrgnClip = CreateEmptyRgn(); SetMonitorRegion(pMonitor, pdce->hrgnClip, pdceOrig->hrgnClip); } else { pdce->hrgnClip = pdceOrig->hrgnClip; } /* * Setup the visrgn clipped to this monitor. */ GreCopyVisRgn(pdceOrig->hdc, ghrgnGDC); SetMonitorRegion(pMonitor, ghrgnGDC, ghrgnGDC); GreSelectVisRgn(pdce->hdc, ghrgnGDC, SVR_COPYNEW); GreGetDCOrgEx(pdceOrig->hdc, &pt, &rc); OffsetRect(&rc, -pMonitor->rcMonitor.left, -pMonitor->rcMonitor.top); GreSetDCOrg(pdce->hdc, rc.left, rc.top, (PRECTL)&rc); /* * Decrement the Free DCE Count. This should always be >= 0, * since we'll create a new dce if the cache is all in use. */ DecrementFreeDCECount(); return pdce->hdc; } /* * If this call succeeds a new DC will be available in the cache, * so the loop will find it and properly set it up. */ if (CreateCacheDC(NULL, DCX_INVALID | DCX_CACHE, pMonitor) == NULL) return NULL; goto TryAgain; }

__inline VOID IncrementFreeDCECount (  VOID   )

Definition at line 41 of file dc.c. References gnDCECount, and VOID(). Referenced by CreateCacheDC(), and ReleaseCacheDC(). { gnDCECount++; UserAssert(gnDCECount >= 0); }

VOID InvalidateDce (  PDCE  pdce  )

Definition at line 470 of file dc.c. References CFPARENTDC, tagDCE::DCX_flags, gpDispInfo, tagDCE::hdc, tagDISPLAYINFO::hDev, tagDCE::hrgnClip, tagDCE::hrgnClipPublic, MarkDCEInvalid(), NULL, tagDCE::pwndClip, tagDCE::pwndOrg, SpbCheckDce(), TestCF, TestWF, UserSetDCVisRgn(), VOID(), WFCLIPCHILDREN, WFCLIPSIBLINGS, WFMINIMIZED, WFVISIBLE, and WFWIN31COMPAT. Referenced by ConvertRedirectionDCs(), CreateCacheDC(), DeleteHrgnClip(), and zzzInvalidateDCCache(). { GreLockDisplay(gpDispInfo->hDev); if (!(pdce->DCX_flags & DCX_INUSE)) { /* * Accumulate any bounds for this CE * since we're about to mark it invalid. */ SpbCheckDce(pdce); MarkDCEInvalid(pdce); pdce->pwndOrg = NULL; pdce->pwndClip = NULL; pdce->hrgnClip = NULL; pdce->hrgnClipPublic = NULL; /* * Remove the vis rgn since it is still owned - if we did not, * gdi would not be able to clean up properly if the app that * owns this vis rgn exist while the vis rgn is still selected. */ GreSelectVisRgn(pdce->hdc, NULL, SVR_DELETEOLD); } else { PWND pwndOrg = pdce->pwndOrg; PWND pwndClip = pdce->pwndClip; /* * In case the window's clipping style bits changed, * reset the DCE flags from the window style bits. * Note that minimized windows never exclude their children. */ pdce->DCX_flags &= ~(DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS); /* * Chicago stuff... */ if (TestCF(pwndOrg, CFPARENTDC) && (TestWF(pwndOrg, WFWIN31COMPAT) || !TestWF(pwndClip, WFCLIPCHILDREN)) && (TestWF(pwndOrg, WFVISIBLE) == TestWF(pwndClip, WFVISIBLE))) { if (TestWF(pwndClip, WFCLIPSIBLINGS)) pdce->DCX_flags |= DCX_CLIPSIBLINGS; } else { if (TestWF(pwndOrg, WFCLIPCHILDREN) && !TestWF(pwndOrg, WFMINIMIZED)) pdce->DCX_flags |= DCX_CLIPCHILDREN; if (TestWF(pwndOrg, WFCLIPSIBLINGS)) pdce->DCX_flags |= DCX_CLIPSIBLINGS; } /* * Mark that any saved visrgn needs to be recomputed. */ pdce->DCX_flags |= DCX_SAVEDRGNINVALID; UserSetDCVisRgn(pdce); } GreUnlockDisplay(gpDispInfo->hDev); }

VOID InvalidateGDIWindows (  PWND  pwnd  )

Definition at line 1746 of file dc.c. References _GetProp(), CalcVisRgn(), NULL, PROP_WNDOBJ, tagWND::rcClient, tagWND::spwndChild, tagWND::spwndNext, TestWF, TRUE, VOID(), and WFCLIPSIBLINGS. Referenced by zzzInvalidateDCCache(). { PVOID pwo; if (pwnd != NULL) { if ((pwo = _GetProp(pwnd, PROP_WNDOBJ, TRUE)) != NULL) { HRGN hrgnClient = NULL; if (GreWindowInsteadOfClient(pwo)) { /* * Never clip children for WO_RGN_WINDOW so that NetMeeting * gets the unioned window area: */ CalcVisRgn(&hrgnClient, pwnd, pwnd, DCX_WINDOW | (TestWF(pwnd, WFCLIPSIBLINGS) ? DCX_CLIPSIBLINGS : 0)); } else { CalcVisRgn(&hrgnClient, pwnd, pwnd, DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS); } GreSetClientRgn(pwo, hrgnClient, &(pwnd->rcClient)); } pwnd = pwnd->spwndChild; while (pwnd != NULL) { InvalidateGDIWindows(pwnd); pwnd = pwnd->spwndNext; } } }

PDCE LookupDC (  HDC  hdc  )

Definition at line 2123 of file dc.c. References tagDCE::DCX_flags, gpDispInfo, tagDCE::hdc, NULL, tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, and tagDCE::pMonitor. Referenced by UserGetRedirectedWindowOrigin(), and xxxEnumDisplayMonitors(). { PDCE pdce; for (pdce = gpDispInfo->pdceFirst; pdce != NULL; pdce = pdce->pdceNext) { if (pdce->DCX_flags & (DCX_INVALID | DCX_DESTROYTHIS)) continue; if (pdce->hdc == hdc && pdce->pMonitor == NULL && (pdce->DCX_flags & DCX_INUSE)) { return pdce; } } return NULL; }

UINT ReleaseCacheDC (  HDC  hdc, BOOL  fEndPaint )

Definition at line 1337 of file dc.c. References DCE_FREED, DCE_NORELEASE, DCE_RELEASED, DCE_SIZE_CACHETHRESHOLD, tagDCE::DCX_flags, DeleteHrgnClip(), DestroyCacheDC(), FALSE, gnDCECount, gpDispInfo, tagDCE::hdc, tagDISPLAYINFO::hDev, IncrementFreeDCECount(), NULL, tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, tagDCE::ptiOwner, UINT, and UpdateLayeredSprite(). Referenced by _ReleaseDC(), xxxEndPaint(), xxxEnumDisplayMonitors(), xxxFreeWindow(), and xxxSendEraseBkgnd(). { PDCE pdce; PDCE *ppdce; for (ppdce = &gpDispInfo->pdceFirst; (pdce = *ppdce); ppdce = &pdce->pdceNext) { if (pdce->hdc == hdc) { /* * Check for redundant releases or release of an invalid entry */ if ((pdce->DCX_flags & (DCX_DESTROYTHIS | DCX_INVALID | DCX_INUSE)) != DCX_INUSE) return DCE_NORELEASE; /* * Lock the display since we may be playing with visrgns. */ GreLockDisplay(gpDispInfo->hDev); if (pdce->DCX_flags & DCX_LAYERED) { UpdateLayeredSprite(pdce); } /* * If this is a permanent DC, then don't reset its state. */ if (pdce->DCX_flags & DCX_CACHE) { /* * Restore the DC state and mark the entry as not in use. * Set owner back to server as well, since it's going back * into the cache. */ if (!(pdce->DCX_flags & DCX_NORESETATTRS)) { /* * If bSetupDC() failed, the DC is busy (ie. in-use * by another thread), so don't release it. */ if ( (!(GreCleanDC(hdc))) || (!(GreSetDCOwner(hdc, OBJECT_OWNER_NONE))) ) { GreUnlockDisplay(gpDispInfo->hDev); return DCE_NORELEASE; } } else if (!GreSetDCOwner(pdce->hdc, OBJECT_OWNER_NONE)) { GreUnlockDisplay(gpDispInfo->hDev); return DCE_NORELEASE; } pdce->ptiOwner = NULL; pdce->DCX_flags &= ~DCX_INUSE; #if DBG /* * Turn off checked only surface validation for now, since * we may select a different surface (screen) in this DC that * may not correspond to the visrgn currently in the DC. When * the DC is given out again, it will be revalidated. */ GreValidateVisrgn(pdce->hdc, FALSE); #endif /* * The DC is no longer in use, so unselect the redirection * bitmap from it. */ if (pdce->DCX_flags & DCX_LAYERED) { UserVerify(GreSelectRedirectionBitmap(pdce->hdc, NULL)); } /* * Increment the Free DCE count. This holds the count * of available DCEs. Check the threshold, and destroy * the dce if it's above the mark. */ IncrementFreeDCECount(); if (gnDCECount > DCE_SIZE_CACHETHRESHOLD) { if (DestroyCacheDC(ppdce, pdce->hdc)) { GreUnlockDisplay(gpDispInfo->hDev); return DCE_FREED; } } } /* * If we have an EXCLUDERGN or INTERSECTRGN cache entry, * convert it back to a "normal" cache entry by restoring * the visrgn and blowing away hrgnClip. * * Note that for non-DCX_CACHE DCs, we only do this if * we're being called from EndPaint(). */ if ((pdce->DCX_flags & (DCX_EXCLUDERGN | DCX_INTERSECTRGN)) && ((pdce->DCX_flags & DCX_CACHE) || fEndPaint)) { DeleteHrgnClip(pdce); } GreUnlockDisplay(gpDispInfo->hDev); return DCE_RELEASED; } } /* * Yell if DC couldn't be found... */ RIPERR1(ERROR_DC_NOT_FOUND, RIP_WARNING, "Invalid device context (DC) handle passed to ReleaseCacheDC (0x%08lx)", hdc); return DCE_NORELEASE; }

VOID ResetOrg (  HRGN  hrgn, PDCE  pdce, BOOL  fSetVisRgn )

Definition at line 73 of file dc.c. References tagDCE::DCX_flags, FNID_DESKTOP, GETFNID, GetLayeredWindow(), tagDCE::hdc, NULL, OffsetRect(), tagDCE::pMonitor, tagDCE::pwndOrg, tagWND::rcClient, tagMONITOR::rcMonitor, tagWND::rcWindow, SetMonitorRegion(), SYSMET, and VOID(). Referenced by _GetDCEx(), and UserSetDCVisRgn(). { RECT rc; PWND pwndLayer; /* * For compatibility purposes, make sure that the DC's for the * desktop windows originate at the primary monitor, i.e. (0,0). */ if (GETFNID(pdce->pwndOrg) == FNID_DESKTOP) { rc.left = rc.top = 0; rc.right = SYSMET(CXVIRTUALSCREEN); rc.bottom = SYSMET(CYVIRTUALSCREEN); } else if (pdce->DCX_flags & DCX_WINDOW) { rc = pdce->pwndOrg->rcWindow; } else { rc = pdce->pwndOrg->rcClient; } if (pdce->pMonitor != NULL) { OffsetRect(&rc, -pdce->pMonitor->rcMonitor.left, -pdce->pMonitor->rcMonitor.top); if (hrgn != NULL) { SetMonitorRegion(pdce->pMonitor, hrgn, hrgn); } } if ((pwndLayer = GetLayeredWindow(pdce->pwndOrg)) != NULL) { if (pdce->DCX_flags & DCX_LAYERED) { int x = pwndLayer->rcWindow.left; int y = pwndLayer->rcWindow.top; /* * For layered redirection DCs, the surface origin is the * window origin, so offset both the rectangle and the * region appropriately. */ OffsetRect(&rc, -x, -y); if (hrgn != NULL) { GreOffsetRgn(hrgn, -x, -y); } } else { /* * Layered windows can only draw to the screen via the redirection * DCs or UpdateLayeredWindow, so select an empty visrgn into this * screen DC. */ if (hrgn != NULL) { GreSetRectRgn(hrgn, 0, 0, 0, 0); } } } else { UserAssert(!(pdce->DCX_flags & DCX_LAYERED)); } GreSetDCOrg(pdce->hdc, rc.left, rc.top, (PRECTL)&rc); if (fSetVisRgn) { GreSelectVisRgn(pdce->hdc, hrgn, SVR_DELETEOLD); } }

void SetMonitorRegion (  PMONITOR  pMonitor, HRGN  hrgnDst, HRGN  hrgnSrc )

Definition at line 53 of file dc.c. References tagMONITOR::hrgnMonitor, IntersectRgn, and tagMONITOR::rcMonitor. Referenced by GetMonitorDC(), and ResetOrg(). { if (IntersectRgn(hrgnDst, hrgnSrc, pMonitor->hrgnMonitor) == ERROR) { GreSetRectRgn(hrgnDst, 0, 0, 0, 0); return; } GreOffsetRgn(hrgnDst, -pMonitor->rcMonitor.left, -pMonitor->rcMonitor.top); }

VOID UserAssociateHwnd (  HWND  hwnd, PVOID  pwo )

Definition at line 415 of file dc.c. References CheckCritIn, gcountPWO, InternalRemoveProp(), InternalSetProp(), NULL, PROP_WNDOBJ, PROPF_INTERNAL, PROPF_NOPOOL, TRUE, ValidateHwnd, and VOID(). { PWND pwnd; /* * Must be in critical section. */ CheckCritIn(); if (pwnd = ValidateHwnd(hwnd)) { if (pwo != NULL) { if (InternalSetProp(pwnd, PROP_WNDOBJ, pwo, PROPF_INTERNAL | PROPF_NOPOOL)) gcountPWO++; } else { if (InternalRemoveProp(pwnd, PROP_WNDOBJ, TRUE)) gcountPWO--; } } }

HRGN UserGetClientRgn (  HWND  hwnd, LPRECT  lprc, BOOL  bWindowInsteadOfClient )

Definition at line 290 of file dc.c. References CalcVisRgn(), CheckCritIn, NULL, tagWND::rcClient, TestWF, ValidateHwnd, and WFCLIPSIBLINGS. { HRGN hrgnClient = (HRGN)NULL; PWND pwnd; /* * Must be in critical section. */ CheckCritIn(); if (pwnd = ValidateHwnd(hwnd)) { if (bWindowInsteadOfClient) { /* * Never clip children for WO_RGN_WINDOW so that NetMeeting * gets the unioned window area: */ CalcVisRgn(&hrgnClient, pwnd, pwnd, DCX_WINDOW | (TestWF(pwnd, WFCLIPSIBLINGS) ? DCX_CLIPSIBLINGS : 0)); } else { CalcVisRgn(&hrgnClient, pwnd, pwnd, DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS); } *lprc = pwnd->rcClient; } return hrgnClient; }

BOOL UserGetHwnd (  HDC  hdc, HWND *  phwnd, PVOID *  ppwo, BOOL  bCheckStyle )

Definition at line 344 of file dc.c. References _GetProp(), BOOL, CFPARENTDC, CheckCritIn, FALSE, gpDispInfo, tagDCE::hdc, HW, NULL, tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, PROP_WNDOBJ, tagDCE::pwndOrg, TestCF, TestWF, TRUE, WFCLIPCHILDREN, and WFCLIPSIBLINGS. { PWND pwnd; PDCE pdce; /* * Must be in critical section. */ CheckCritIn(); /* * Find pdce and pwnd for this DC. * * Note: the SAMEHANDLE macro strips out the user defined bits in the * handle before doing the comparison. This is important because when * GRE calls this function, it may have lost track of the OWNDC bit. */ for (pdce = gpDispInfo->pdceFirst; pdce != NULL; pdce = pdce->pdceNext) { if (pdce->hdc == hdc) // this should be undone once SAMEHANDLE is fixed for kmode break; } /* * Return FALSE If it is not in the pdce list. */ if ((pdce == NULL) || (pdce->pwndOrg == NULL)) return FALSE; pwnd = pdce->pwndOrg; /* * The window style must be clipchildren and clipsiblings. * the window's class must not be parentdc */ if (bCheckStyle) { if ( !TestWF(pwnd, WFCLIPCHILDREN) || !TestWF(pwnd, WFCLIPSIBLINGS) || TestCF(pwnd, CFPARENTDC)) { RIPMSG0(RIP_WARNING, "UserGetHwnd: Bad OpenGL window style or class"); return FALSE; } } /* * Return the hwnd with the correct styles for a device format window. */ *phwnd = HW(pwnd); *ppwo = _GetProp(pwnd, PROP_WNDOBJ, TRUE); return TRUE; }

BOOL UserGetRedirectedWindowOrigin (  HDC  hdc, LPPOINT  ppt )

Definition at line 2096 of file dc.c. References BOOL, tagDCE::DCX_flags, FALSE, GetLayeredWindow(), LookupDC(), NULL, tagDCE::pwndOrg, tagWND::rcWindow, and TRUE. Referenced by GetDCOrgOnScreen(). { PWND pwnd; PDCE pdce; if ((pdce = LookupDC(hdc)) == NULL) return FALSE; if (!(pdce->DCX_flags & DCX_LAYERED)) return FALSE; pwnd = GetLayeredWindow(pdce->pwndOrg); ppt->x = pwnd->rcWindow.left; ppt->y = pwnd->rcWindow.top; return TRUE; }

BOOL UserReleaseDC (  HDC  hdc  )

Definition at line 447 of file dc.c. References _ReleaseDC(), BOOL, EnterCrit, and LeaveCrit. { BOOL b; EnterCrit(); b = _ReleaseDC(hdc); LeaveCrit(); return b; }

VOID UserSetDCVisRgn (  PDCE  pdce  )

Definition at line 237 of file dc.c. References CalcVisRgn(), tagDCE::DCX_flags, HRGN_FULL, tagDCE::hrgnClipPublic, IntersectRgn, NULL, tagDCE::pwndClip, tagDCE::pwndOrg, ResetOrg(), SetEmptyRgn(), SubtractRgn, TRUE, and VOID(). Referenced by InvalidateDce(). { HRGN hrgn = NULL; /* * If the visrgn calculated is empt, set the flag DCX_PWNDORGINVISIBLE, * otherwise clear it (it could've been set earlier on). */ if (!CalcVisRgn(&hrgn, pdce->pwndOrg, pdce->pwndClip, pdce->DCX_flags)) { pdce->DCX_flags |= DCX_PWNDORGINVISIBLE; } else { pdce->DCX_flags &= ~DCX_PWNDORGINVISIBLE; } /* * Deal with INTERSECTRGN and EXCLUDERGN. */ if (pdce->DCX_flags & DCX_INTERSECTRGN) { UserAssert(pdce->hrgnClipPublic != HRGN_FULL); if (pdce->hrgnClipPublic == NULL) { SetEmptyRgn(hrgn); } else { IntersectRgn(hrgn, hrgn, pdce->hrgnClipPublic); } } else if (pdce->DCX_flags & DCX_EXCLUDERGN) { UserAssert(pdce->hrgnClipPublic != NULL); if (pdce->hrgnClipPublic == HRGN_FULL) { SetEmptyRgn(hrgn); } else { SubtractRgn(hrgn, hrgn, pdce->hrgnClipPublic); } } ResetOrg(hrgn, pdce, TRUE); }

PWND WindowFromCacheDC (  HDC  hdc  )

Definition at line 1574 of file dc.c. References tagDCE::DCX_flags, gpDispInfo, tagDCE::hdc, NULL, tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, and tagDCE::pwndOrg. Referenced by _SelectPalette(), and xxxRealizePalette(). { PDCE pdce; for (pdce = gpDispInfo->pdceFirst; pdce; pdce = pdce->pdceNext) { if (pdce->hdc == hdc) return (pdce->DCX_flags & DCX_DESTROYTHIS) ? NULL : pdce->pwndOrg; } return NULL; }

BOOL zzzInvalidateDCCache (  PWND  pwndInvalid, DWORD  flags )

Definition at line 1812 of file dc.c. References BOOL, tagDCE::DCX_flags, gcountPWO, gpDispInfo, tagDISPLAYINFO::hDev, IDC_CHILDRENONLY, IDC_CLIENTONLY, IDC_DEFAULT, IDC_MOVEBLT, IDC_NOMOUSE, InvalidateDce(), InvalidateGDIWindows(), IsGlobalHooked, NULL, tagDISPLAYINFO::pdceFirst, tagDCE::pdceNext, PtiCurrent, tagDCE::pwndClip, PWNDDESKTOP, tagDCE::pwndOrg, tagWND::spwndParent, TestWF, ThreadLockAlwaysWithPti, ThreadUnlock, tagTHREADINFO::TIF_flags, TIF_MOVESIZETRACKING, TRUE, WFCLIPCHILDREN, WFCLIPSIBLINGS, WFMINIMIZED, WHF_FROM_WH, and zzzSetFMouseMoved(). Referenced by LockWindowUpdate2(), ResetSharedDesktops(), UnsetLayeredWindow(), xxxDWP_SetRedraw(), xxxMinimizeHungWindow(), xxxScrollWindowEx(), xxxSetLayeredWindow(), xxxSetParent(), xxxSetWindowStyle(), and zzzBltValidBits(). { PWND pwnd; PDCE pdce; PTHREADINFO ptiCurrent = PtiCurrent(); TL tlpwndInvalid; FLONG fl; /* * Invalidation implies screen real estate is changing so we must * jiggle the mouse, because a different window may be underneath * the mouse, which needs to get a mouse move in order to change the * mouse pointer. * * The check for the tracking is added for full-drag-windows. In doing * full-drag, zzzBltValidBits() is called from setting the window-pos. * This resulted in an extra-mousemove being queued from this routine. * So, when we're tracking, don't queue a mousemove. This pointer is * null when tracking is off, so it won't effect the normal case. */ ThreadLockAlwaysWithPti(ptiCurrent, pwndInvalid, &tlpwndInvalid); if (!(ptiCurrent->TIF_flags & TIF_MOVESIZETRACKING) && !(flags & IDC_NOMOUSE)) { #ifdef REDIRECTION if (!IsGlobalHooked(ptiCurrent, WHF_FROM_WH(WH_HITTEST))) #endif // REDIRECTION zzzSetFMouseMoved(); } /* * The visrgn of pwnd is changing. First see if a change to this * visrgn will also affect other window's visrgns: * * 1) if parent is clipchildren, we need to invalidate parent * 2) if clipsiblings, we need to invalidate our sibling's visrgns. * * We don't optimize the case where we're NOT clipsiblings, and our * parent is clipchildren: very rare case. * We also don't optimize the fact that a clipsiblings window visrgn * change only affects the visrgns of windows BELOW it. */ if (flags & IDC_DEFAULT) { flags = 0; if ((pwndInvalid->spwndParent != NULL) && (pwndInvalid != PWNDDESKTOP(pwndInvalid))) { /* * If the parent is a clip-children window, then * a change to our visrgn will affect his visrgn, and * possibly those of our siblings. So, invalidate starting * from our parent. Note that we don't need to invalidate * any window DCs associated with our parent. */ if (TestWF(pwndInvalid->spwndParent, WFCLIPCHILDREN)) { flags = IDC_CLIENTONLY; pwndInvalid = pwndInvalid->spwndParent; } else if (TestWF(pwndInvalid, WFCLIPSIBLINGS)) { /* * If we are clip-siblings, chances are that our siblings are * too. A change to our visrgn might affect our siblings, * so invalidate all of our siblings. * * NOTE! This code assumes that if pwndInvalid is NOT * CLIPSIBLINGs, that either it does not overlap other * CLIPSIBLINGs windows, or that none of the siblings are * CLIPSIBLINGs. This is a reasonable assumption, because * mixing CLIPSIBLINGs and non CLIPSIBLINGs windows that * overlap is generally unpredictable anyhow. */ flags = IDC_CHILDRENONLY; pwndInvalid = pwndInvalid->spwndParent; } } } /* * Go through the list of DCE's, looking for any that need to be * invalidated or recalculated. Basically, any DCE that contains * a window handle that is equal to pwndInvalid or a child of pwndInvalid * needs to be invalidated. */ for (pdce = gpDispInfo->pdceFirst; pdce; pdce = pdce->pdceNext) { if (pdce->DCX_flags & (DCX_INVALID | DCX_DESTROYTHIS)) continue; /* * HACK ALERT * * A minimized client DC must never exclude its children, even if * its WS_CLIPCHILDREN bit is set. For CS_OWNDC windows we must * update the flags of the DCE to reflect the change in window state * when the visrgn is eventually recomputed. */ if (!(pdce->DCX_flags & (DCX_CACHE | DCX_WINDOW))) { if (TestWF(pdce->pwndOrg, WFCLIPCHILDREN)) pdce->DCX_flags |= DCX_CLIPCHILDREN; if (TestWF(pdce->pwndOrg, WFMINIMIZED)) pdce->DCX_flags &= ~DCX_CLIPCHILDREN; } /* * This code assumes that if pdce->pwndClip != pdce->pwndOrg, * that pdce->pwndClip == pdce->pwndOrg->spwndParent. To ensure * that both windows are visited, we start the walk upwards from * the lower of the two, or pwndOrg. */ UserAssert((pdce->pwndClip == pdce->pwndOrg) || (pdce->pwndClip == pdce->pwndOrg->spwndParent)); /* * Walk upwards from pdce->pwndOrg, to see if we encounter * pwndInvalid. */ for (pwnd = pdce->pwndOrg; pwnd; pwnd = pwnd->spwndParent) { if (pwnd == pwndInvalid) { if (pwndInvalid == pdce->pwndOrg) { /* * Ignore DCEs for pwndInvalid if IDC_CHILDRENONLY. */ if (flags & IDC_CHILDRENONLY) break; /* * Ignore window DCEs for pwndInvalid if IDC_CLIENTONLY */ if ((flags & IDC_CLIENTONLY) && (pdce->DCX_flags & DCX_WINDOW)) break; } InvalidateDce(pdce); break; } } } /* * Update WNDOBJs in gdi if they exist. */ GreLockDisplay(gpDispInfo->hDev); fl = (flags & IDC_MOVEBLT) ? GCR_DELAYFINALUPDATE : 0; if (gcountPWO != 0) { InvalidateGDIWindows(pwndInvalid); fl |= GCR_WNDOBJEXISTS; } GreClientRgnUpdated(fl); GreUpdateSpriteVisRgn(gpDispInfo->hDev); GreUnlockDisplay(gpDispInfo->hDev); ThreadUnlock(&tlpwndInvalid); return TRUE; }

---