winmgr.c File Reference

Go to the source code of this file.

Functions
int	FindNCHit (PWND pwnd, LONG lPt)
BOOL	_FChildVisible (PWND pwnd)
int	_MapWindowPoints (PWND pwndFrom, PWND pwndTo, LPPOINT lppt, DWORD cpt)
void	GetRealClientRect (PWND pwnd, LPRECT prc, UINT uFlags, PMONITOR pMonitor)
PWND	_GetLastActivePopup (PWND pwnd)
BOOL	_IsDescendant (PWND pwndParent, PWND pwndChild)
BOOL	IsVisible (PWND pwnd)
int	GetWindowBorders (LONG lStyle, DWORD dwExStyle, BOOL fWindow, BOOL fClient)
PWND	SizeBoxHwnd (PWND pwnd)
BOOL	NeedsWindowEdge (DWORD dwStyle, DWORD dwExStyle, BOOL fNewApp)
BOOL	_HasCaptionIcon (PWND pwnd)
PWND	GetTopLevelWindow (PWND pwnd)
void	GetRect (PWND pwnd, LPRECT lprc, UINT uCoords)

---

Function Documentation

BOOL _FChildVisible (  PWND  pwnd  )

Definition at line 294 of file rtl/winmgr.c. References BOOL, FALSE, NULL, REBASEPWND, TestWF, TestwndChild, TRUE, and WFVISIBLE. Referenced by FChildVisible(), xxxCalcValidRects(), xxxSBWndProc(), and xxxShowWindow(). { while (TestwndChild(pwnd)) { pwnd = REBASEPWND(pwnd, spwndParent); if (pwnd == NULL) break; if (!TestWF(pwnd, WFVISIBLE)) return FALSE; } return TRUE; }

PWND _GetLastActivePopup (  PWND  pwnd  )

Definition at line 490 of file rtl/winmgr.c. References NULL, REBASEPWND, and tagWND::spwndLastActive. Referenced by GetLastActivePopup(), and xxxSysCommand(). { if (pwnd->spwndLastActive == NULL) return pwnd; return REBASEPWND(pwnd, spwndLastActive); }

BOOL _HasCaptionIcon (  PWND  pwnd  )

Definition at line 763 of file rtl/winmgr.c. References _GetProp(), tagSERVERINFO::atomIconProp, tagSERVERINFO::atomIconSmProp, BOOL, BYTE, DIALOGCLASS, FALSE, gpsi, HMObjectFromHandle, LOBYTE, MAKEINTATOM, REBASEALWAYS, TestWF, TRUE, WEFDLGMODALFRAME, WEFTOOLWINDOW, WFBORDERMASK, WFDLGFRAME, and WFWIN40COMPAT. Referenced by FindNCHit(), xxxDrawCaptionTemp(), xxxGetMenuBarInfo(), xxxGetTitleBarInfo(), xxxInitSendValidateMinMaxInfo(), and xxxMNFindWindowFromPoint(). { HICON hIcon; PCLS pcls; if (TestWF(pwnd, WEFTOOLWINDOW)) // it's a tool window -- it doesn't get an icon return(FALSE); if ((TestWF(pwnd, WFBORDERMASK) != (BYTE)LOBYTE(WFDLGFRAME)) && !TestWF(pwnd, WEFDLGMODALFRAME)) // they are not trying to look like a dialog, they get an icon return TRUE; if (!TestWF(pwnd, WFWIN40COMPAT) && (((PCLS)REBASEALWAYS(pwnd, pcls))->atomClassName == (ATOM)(ULONG_PTR)DIALOGCLASS)) // it's an older REAL dialog -- it doesn't get an icon return(FALSE); hIcon = (HICON) _GetProp(pwnd, MAKEINTATOM(gpsi->atomIconSmProp), TRUE); if (hIcon) { // it's a 4.0 dialog with a small icon -- if that small icon is // something other than the generic small windows icon, it gets an icon return(hIcon != gpsi->hIconSmWindows); } hIcon = (HICON) _GetProp(pwnd, MAKEINTATOM(gpsi->atomIconProp), TRUE); if (hIcon && (hIcon != gpsi->hIcoWindows)) // it's a 4.0 dialog with no small icon, but instead a large icon // that's not the generic windows icon -- it gets an icon return(TRUE); pcls = REBASEALWAYS(pwnd, pcls); if (pcls->spicnSm) { if (pcls->spicnSm != HMObjectFromHandle(gpsi->hIconSmWindows)) { // it's a 4.0 dialog with a class icon that's not the generic windows // icon -- it gets an icon return(TRUE); } } // it's a 4.0 dialog with no small or large icon -- it doesn't get an icon return(FALSE); }

BOOL _IsDescendant (  PWND  pwndParent, PWND  pwndChild )

Definition at line 513 of file rtl/winmgr.c. References BOOL, FALSE, FNID_DESKTOP, GETFNID, REBASEPWND, and TRUE. Referenced by _GetNextDlgTabItem(), _NextControl(), CalcVisRgn(), GetNextDlgHelpItem(), PWInsertAfter(), xxxDefWindowProc(), and xxxScrollWindowEx(). { while (1) { if (pwndParent == pwndChild) return TRUE; if (GETFNID(pwndChild) == FNID_DESKTOP) break; pwndChild = REBASEPWND(pwndChild, spwndParent); } return FALSE; }

int _MapWindowPoints (  PWND  pwndFrom, PWND  pwndTo, LPPOINT  lppt, DWORD  cpt )

Definition at line 316 of file rtl/winmgr.c. References BOOL, FALSE, FNID_DESKTOP, GETFNID, max, min, NULL, PZERO, tagWND::rcClient, and TestWF. Referenced by MapWindowPoints(). { #ifdef USE_MIRRORING int dx = 0, dy = 0; int SaveLeft, Sign = 1; RECT *pR = (RECT *)lppt; BOOL bMirrored = FALSE; #else int dx, dy; LPPOINT pptFrom, pptTo; #endif /* * If a window is NULL, use the desktop window. * If the window is the desktop, don't offset by * the client rect, since it won't work if the screen * origin is not (0,0) - use zero instead. */ /* * Compute deltas */ #ifdef USE_MIRRORING if (pwndFrom && GETFNID(pwndFrom) != FNID_DESKTOP) { if (TestWF(pwndFrom, WEFLAYOUTRTL)) { Sign = -Sign; dx = -pwndFrom->rcClient.right; bMirrored = (cpt == 2); } else { dx = pwndFrom->rcClient.left; } dy = pwndFrom->rcClient.top; } if (pwndTo && GETFNID(pwndTo) != FNID_DESKTOP) { if (TestWF(pwndTo, WEFLAYOUTRTL)) { Sign = -Sign; dx = dx + Sign * pwndTo->rcClient.right; bMirrored = (cpt == 2); } else { dx = dx - Sign * pwndTo->rcClient.left; } dy = dy - pwndTo->rcClient.top; } #else if (pwndFrom == NULL || GETFNID(pwndFrom) == FNID_DESKTOP) { pptFrom = PZERO(POINT); } else { pptFrom = (LPPOINT) &pwndFrom->rcClient; } if (pwndTo == NULL || GETFNID(pwndTo) == FNID_DESKTOP) { pptTo = PZERO(POINT); } else { pptTo = (LPPOINT) &pwndTo->rcClient; } dx = pptFrom->x - pptTo->x; dy = pptFrom->y - pptTo->y; #endif /* * Map the points */ while (cpt--) { lppt->x += dx; #ifdef USE_MIRRORING lppt->x *= Sign; #endif lppt->y += dy; ++lppt; } #ifdef USE_MIRRORING if (bMirrored) { //Special case for Rect SaveLeft = min (pR->left, pR->right); pR->right = max (pR->left, pR->right); pR->left = SaveLeft; } #endif return MAKELONG(dx, dy); }

int FindNCHit (  PWND  pwnd, LONG  lPt )

Definition at line 19 of file rtl/winmgr.c. References _HasCaptionIcon(), CopyInflateRect(), FALSE, GET_X_LPARAM, GET_Y_LPARAM, GetWindowBorders(), InflateRect(), LOBYTE, PtInRect(), tagWND::rcClient, tagWND::rcWindow, SizeBoxHwnd(), SYSMETRTL, TestWF, TRUE, WEFCLIENTEDGE, WEFCONTEXTHELP, WEFDLGMODALFRAME, WEFLEFTSCROLL, WEFTOOLWINDOW, WFBORDERMASK, WFCAPTION, WFDLGFRAME, WFHPRESENT, WFMAXBOX, WFMINBOX, WFMINIMIZED, WFMPRESENT, WFSIZEBOX, WFSYSMENU, WFVPRESENT, and WFWIN40COMPAT. Referenced by DefWindowProcWorker(), EditWndProc(), WinHelpA(), xxxDefWindowProc(), xxxDesktopThread(), xxxMNLoop(), and xxxTrackInitSize(). { POINT pt; RECT rcWindow; RECT rcClient; RECT rcClientAdj; int cBorders; int dxButton; pt.x = GET_X_LPARAM(lPt); pt.y = GET_Y_LPARAM(lPt); if (!PtInRect(&((WND *)pwnd)->rcWindow, pt)) return HTNOWHERE; if (TestWF(pwnd, WFMINIMIZED)) { CopyInflateRect(&rcWindow, &((WND *)pwnd)->rcWindow, -(SYSMETRTL(CXFIXEDFRAME) + SYSMETRTL(CXBORDER)), -(SYSMETRTL(CYFIXEDFRAME) + SYSMETRTL(CYBORDER))); if (!PtInRect(&rcWindow, pt)) return HTCAPTION; goto CaptionHit; } // Get client rectangle rcClient = pwnd->rcClient; if (PtInRect(&rcClient, pt)) return HTCLIENT; // Are we in "pseudo" client, i.e. the client & scrollbars & border if (TestWF(pwnd, WEFCLIENTEDGE)) CopyInflateRect(&rcClientAdj, &rcClient, SYSMETRTL(CXEDGE), SYSMETRTL(CYEDGE)); else rcClientAdj = rcClient; if (TestWF(pwnd, WFVPRESENT)) { #ifdef USE_MIRRORING if ((!!TestWF(pwnd, WEFLEFTSCROLL)) ^ (!!TestWF(pwnd, WEFLAYOUTRTL))) #else if (TestWF(pwnd, WEFLEFTSCROLL)) #endif rcClientAdj.left -= SYSMETRTL(CXVSCROLL); else rcClientAdj.right += SYSMETRTL(CXVSCROLL); } if (TestWF(pwnd, WFHPRESENT)) rcClientAdj.bottom += SYSMETRTL(CYHSCROLL); if (!PtInRect(&rcClientAdj, pt)) { // Subtract out window borders cBorders = GetWindowBorders(pwnd->style, pwnd->ExStyle, TRUE, FALSE); CopyInflateRect(&rcWindow, &((WND *)pwnd)->rcWindow, -cBorders*SYSMETRTL(CXBORDER), -cBorders*SYSMETRTL(CYBORDER)); // Are we on the border? if (!PtInRect(&rcWindow, pt)) { // On a sizing border? if (!TestWF(pwnd, WFSIZEBOX)) { // // Old compatibility thing: For 3.x windows that just had // a border, we returned HTNOWHERE, believe it or not, // because our hit-testing code was so brain dead. // if (!TestWF(pwnd, WFWIN40COMPAT) && !TestWF(pwnd, WFDLGFRAME) && !TestWF(pwnd, WEFDLGMODALFRAME)) { return(HTNOWHERE); } else { return(HTBORDER); // We are on a dlg frame. } } else { int ht; // // Note this improvement. The HT codes are numbered so that // if you subtract HTSIZEFIRST-1 from them all, they sum up. I.E., // (HTLEFT - HTSIZEFIRST + 1) + (HTTOP - HTSIZEFIRST + 1) == // (HTTOPLEFT - HTSIZEFIRST + 1). // if (TestWF(pwnd, WEFTOOLWINDOW)) InflateRect(&rcWindow, -SYSMETRTL(CXSMSIZE), -SYSMETRTL(CYSMSIZE)); else InflateRect(&rcWindow, -SYSMETRTL(CXSIZE), -SYSMETRTL(CYSIZE)); if (pt.y < rcWindow.top) ht = (HTTOP - HTSIZEFIRST + 1); else if (pt.y >= rcWindow.bottom) ht = (HTBOTTOM - HTSIZEFIRST + 1); else ht = 0; if (pt.x < rcWindow.left) ht += (HTLEFT - HTSIZEFIRST + 1); else if (pt.x >= rcWindow.right) ht += (HTRIGHT - HTSIZEFIRST + 1); return (ht + HTSIZEFIRST - 1); } } // Are we above the client area? if (pt.y < rcClientAdj.top) { // Are we in the caption? if (TestWF(pwnd, WFBORDERMASK) == LOBYTE(WFCAPTION)) { CaptionHit: #ifdef USE_MIRRORING if (TestWF(pwnd, WEFLAYOUTRTL)) { pt.x = pwnd->rcWindow.right - (pt.x - pwnd->rcWindow.left); } #endif if (pt.y >= rcWindow.top) { if (TestWF(pwnd, WEFTOOLWINDOW)) { rcWindow.top += SYSMETRTL(CYSMCAPTION); dxButton = SYSMETRTL(CXSMSIZE); } else { rcWindow.top += SYSMETRTL(CYCAPTION); dxButton = SYSMETRTL(CXSIZE); } if ((pt.y >= rcWindow.top) && TestWF(pwnd, WFMPRESENT)) return(HTMENU); if ((pt.x >= rcWindow.left) && (pt.x < rcWindow.right) && (pt.y < rcWindow.top)) { // Are we in the window menu? if (TestWF(pwnd, WFSYSMENU)) { rcWindow.left += dxButton; if (pt.x < rcWindow.left) { if (!_HasCaptionIcon(pwnd)) // iconless windows have no sysmenu hit rect return(HTCAPTION); return(HTSYSMENU); } } else if (TestWF(pwnd, WFWIN40COMPAT)) return(HTCAPTION); // only a close button if window has a system menu // Are we in the close button? rcWindow.right -= dxButton; if (pt.x >= rcWindow.right) return HTCLOSE; if ((pt.x < rcWindow.right) && !TestWF(pwnd, WEFTOOLWINDOW)) { // Are we in the maximize/restore button? if (TestWF(pwnd, (WFMAXBOX | WFMINBOX))) { // Note that sizing buttons are same width for both // big captions and small captions. rcWindow.right -= dxButton; if (pt.x >= rcWindow.right) return HTZOOM; // Are we in the minimize button? rcWindow.right -= dxButton; if (pt.x >= rcWindow.right) return HTREDUCE; } else if (TestWF(pwnd, WEFCONTEXTHELP)) { rcWindow.right -= dxButton; if (pt.x >= rcWindow.right) return HTHELP; } } } } // We're in the caption proper return HTCAPTION; } // // Are we in the menu? // if (TestWF(pwnd, WFMPRESENT)) return HTMENU; } } else { // // NOTE: // We can only be here if we are on the client edge, horz scroll, // sizebox, or vert scroll. Hence, if we are not on the first 3, // we must be on the last one. // // // Are we on the client edge? // if (TestWF(pwnd, WEFCLIENTEDGE)) { InflateRect(&rcClientAdj, -SYSMETRTL(CXEDGE), -SYSMETRTL(CYEDGE)); if (!PtInRect(&rcClientAdj, pt)) return(HTBORDER); } // // Are we on the scrollbars? // if (TestWF(pwnd, WFHPRESENT) && (pt.y >= rcClient.bottom)) { int iHitTest=HTHSCROLL; UserAssert(pt.y < rcClientAdj.bottom); if (TestWF(pwnd, WFVPRESENT)) { PWND pwndSizeBox = SizeBoxHwnd(pwnd); if(pt.x >= rcClient.right) return(pwndSizeBox ? HTBOTTOMRIGHT : HTGROWBOX); #ifdef USE_MIRRORING // // Mirror the grip box location so that it becomes // on the bottom-left side if this is a RTL mirrrored // windows. // else if (TestWF(pwnd, WEFLAYOUTRTL) && (pt.x < rcClient.left)) return(pwndSizeBox ? HTBOTTOMLEFT : HTGROWBOX); #endif } return(iHitTest); } else { UserAssert(TestWF(pwnd, WFVPRESENT)); #ifdef USE_MIRRORING if ((!!TestWF(pwnd, WEFLEFTSCROLL)) ^ (!!TestWF(pwnd, WEFLAYOUTRTL))) { #else if (TestWF(pwnd, WEFLEFTSCROLL)) { #endif UserAssert(pt.x < rcClient.left); UserAssert(pt.x >= rcClientAdj.left); } else { UserAssert(pt.x >= rcClient.right); UserAssert(pt.x < rcClientAdj.right); } return(HTVSCROLL); } } // // We give up. // // Win31 returned HTNOWHERE in this case; For compatibility, we will // keep it that way. // return(HTNOWHERE); }

void GetRealClientRect (  PWND  pwnd, LPRECT  prc, UINT  uFlags, PMONITOR  pMonitor )

Definition at line 417 of file rtl/winmgr.c. References FNID_DESKTOP, GETFNID, GetPrimaryMonitor(), GetRect(), GRC_FULLSCREEN, GRC_MINWNDS, GRC_SCROLLS, GRECT_CLIENT, GRECT_CLIENTCOORDS, tagMONITOR::rcMonitor, tagMONITOR::rcWork, SYSMETRTL, TestWF, WFHPRESENT, and WFVPRESENT. Referenced by GetParentArrangeRect(), ParkIcon(), SetTiledRect(), and xxxArrangeIconicWindows(). { if (GETFNID(pwnd) == FNID_DESKTOP) { if (!pMonitor) { pMonitor = GetPrimaryMonitor(); } *prc = (uFlags & GRC_FULLSCREEN) ? pMonitor->rcMonitor : pMonitor->rcWork; } else { GetRect(pwnd, prc, GRECT_CLIENT | GRECT_CLIENTCOORDS); if (uFlags & GRC_SCROLLS) { if (TestWF(pwnd, WFHPRESENT)){ prc->bottom += SYSMETRTL(CYHSCROLL); } if (TestWF(pwnd, WFVPRESENT)) { prc->right += SYSMETRTL(CXVSCROLL); } } } if (uFlags & GRC_MINWNDS) { switch (SYSMETRTL(ARRANGE) & ~ARW_HIDE) { case ARW_TOPLEFT | ARW_RIGHT: case ARW_TOPRIGHT | ARW_LEFT: // // Leave space on top for one row of min windows // prc->top += SYSMETRTL(CYMINSPACING); break; case ARW_TOPLEFT | ARW_DOWN: case ARW_BOTTOMLEFT | ARW_UP: // // Leave space on left for one column of min windows // prc->left += SYSMETRTL(CXMINSPACING); break; case ARW_TOPRIGHT | ARW_DOWN: case ARW_BOTTOMRIGHT | ARW_UP: // // Leave space on right for one column of min windows // prc->right -= SYSMETRTL(CXMINSPACING); break; case ARW_BOTTOMLEFT | ARW_RIGHT: case ARW_BOTTOMRIGHT | ARW_LEFT: // // Leave space on bottom for one row of min windows // prc->bottom -= SYSMETRTL(CYMINSPACING); break; } } }

void GetRect (  PWND  pwnd, LPRECT  lprc, UINT  uCoords )

Definition at line 856 of file rtl/winmgr.c. References FNID_DESKTOP, GETFNID, GRECT_CLIENTCOORDS, GRECT_COORDMASK, GRECT_PARENTCOORDS, GRECT_RECTMASK, GRECT_WINDOW, GRECT_WINDOWCOORDS, OffsetRect(), tagWND::rcClient, tagWND::rcWindow, REBASEPWND, TestWF, and WFCHILD. Referenced by _GetScrollBarInfo(), CalcSBStuff(), GetRealClientRect(), MDICheckCascadeRect(), ParkIcon(), SBCtlSetup(), UpdateCheckpoint(), UT_GetParentDCClipBox(), xxxCalcValidRects(), xxxDrawCaptionBar(), xxxDrawWindowFrame(), xxxMinMaximize(), xxxScrollWindowEx(), and xxxSetStaticImage(). { PWND pwndParent; LPRECT lprcOffset; UserAssert(lprc); UserAssert((uCoords & ~(GRECT_COORDMASK | GRECT_RECTMASK)) == 0); UserAssert(uCoords & GRECT_COORDMASK); UserAssert(uCoords & GRECT_RECTMASK); *lprc = (uCoords & GRECT_WINDOW) ? pwnd->rcWindow : pwnd->rcClient; /* * If this is the desktop window, we have what we want, whether we * are asking for GRECT_PARENTCOORDS, WINDOWCOORD or CLIENTCOORDS */ if (GETFNID(pwnd) == FNID_DESKTOP) return; switch (uCoords & GRECT_COORDMASK) { case GRECT_PARENTCOORDS: pwndParent = REBASEPWND(pwnd, spwndParent); if (GETFNID(pwndParent) == FNID_DESKTOP) return; lprcOffset = &pwndParent->rcClient; #if defined(USE_MIRRORING) // // Let's mirror the edges of the child's window since the parent // is mirrored, so should the child window be. [samera] // if (TestWF(pwndParent,WEFLAYOUTRTL) && (uCoords & GRECT_WINDOW) && (TestWF(pwnd,WFCHILD))) { int iLeft; // // I am using OffsetRect instead of implementing a new // OffsetMirrorRect API since this is the only place I am // doing it in. // // Since screen coordinates are not mirrored, the rect offsetting // should be done relative to prcOffset->right since it is the // leading edge for mirrored windows. [samera] // UserVerify(OffsetRect(lprc, -lprcOffset->right, -lprcOffset->top)); iLeft = lprc->left; lprc->left = (lprc->right * -1); lprc->right = (iLeft * -1); return; } #endif break; case GRECT_WINDOWCOORDS: lprcOffset = &pwnd->rcWindow; break; case GRECT_CLIENTCOORDS: lprcOffset = &pwnd->rcClient; break; default: UserAssert(0 && "Logic error in _GetRect - invalid uCoords"); } UserVerify(OffsetRect(lprc, -lprcOffset->left, -lprcOffset->top)); }

PWND GetTopLevelWindow (  PWND  pwnd  )

Definition at line 817 of file rtl/winmgr.c. References NULL, REBASEPWND, and TestwndChild. Referenced by _GetNextQueueWindow(), _SelectPalette(), ConvertRedirectionDCs(), GetLayeredWindow(), ImeSetContextHandler(), InternalDialogBox(), NtUserSetImeOwnerWindow(), RecreateRedirectionBitmap(), WinHelpA(), xxxActivateThisWindow(), xxxButtonEvent(), xxxCreateWindowEx(), xxxDefWindowProc(), xxxDesktopWndProc(), xxxDrawMenuBarUnderlines(), xxxDWP_ProcessVirtKey(), xxxHandleNCMouseGuys(), xxxNextWindow(), and xxxSetForegroundWindow(). { if (pwnd != NULL) { while (TestwndChild(pwnd)) pwnd = REBASEPWND(pwnd, spwndParent); } return pwnd; }

int GetWindowBorders (  LONG  lStyle, DWORD  dwExStyle, BOOL  fWindow, BOOL  fClient )

Definition at line 582 of file rtl/winmgr.c. References gpsi. Referenced by _AdjustWindowRectEx(), DefFrameProcWorker(), FindNCHit(), GetWindowInfo(), MNPositionSysMenu(), xxxAnimateCaption(), xxxCalcCaptionButton(), xxxCalcClientRect(), xxxCheckFullScreen(), xxxDrawCaptionBar(), xxxDrawWindowFrame(), xxxDWP_DoNCActivate(), xxxGetMenuBarInfo(), xxxGetTitleBarInfo(), xxxHelpLoop(), xxxInitSendValidateMinMaxInfo(), xxxLBSize(), xxxMNFindWindowFromPoint(), and xxxMNRecomputeBarIfNeeded(). { int cBorders = 0; if (fWindow) { // // Is there a 3D border around the window? // if (dwExStyle & WS_EX_WINDOWEDGE) cBorders += 2; else if (dwExStyle & WS_EX_STATICEDGE) ++cBorders; // // Is there a single flat border around the window? This is true for // WS_BORDER, WS_DLGFRAME, and WS_EX_DLGMODALFRAME windows. // if ( (lStyle & WS_CAPTION) || (dwExStyle & WS_EX_DLGMODALFRAME) ) ++cBorders; // // Is there a sizing flat border around the window? // if (lStyle & WS_SIZEBOX) cBorders += gpsi->gclBorder; } if (fClient) { // // Is there a 3D border around the client? // if (dwExStyle & WS_EX_CLIENTEDGE) cBorders += 2; } return(cBorders); }

BOOL IsVisible (  PWND  pwnd  )

Definition at line 537 of file rtl/winmgr.c. References BOOL, FALSE, FNID_DESKTOP, GETFNID, REBASEPWND, TestWF, TRUE, WFMINIMIZED, and WFVISIBLE. Referenced by _GetDCEx(), BNSetFont(), ButtonWndProcWorker(), CalcVisRgn(), EnumPwndDlgChildProc(), FBitsTouch(), RestoreSpb(), SpbCheckRect(), StaticRepaint(), StaticWndProcWorker(), UT_InvertCaret(), xxxActivateThisWindow(), xxxBNGetDC(), xxxDrawCaptionBar(), xxxDrawWindowFrame(), xxxEnableSBCtlArrows(), xxxEnableWndSBArrows(), xxxLBResetContent(), xxxMinMaximize(), xxxRedrawWindow(), xxxScrollWindowEx(), and xxxSetScrollBar(). { PWND pwndT; for (pwndT = pwnd; pwndT; pwndT = REBASEPWND(pwndT, spwndParent)) { /* * Invisible windows are always invisible */ if (!TestWF(pwndT, WFVISIBLE)) return FALSE; if (TestWF(pwndT, WFMINIMIZED)) { /* * Children of minimized windows are always invisible. */ if (pwndT != pwnd) return FALSE; } /* * If we're at the desktop, then we don't want to go any further. */ if (GETFNID(pwndT) == FNID_DESKTOP) break; } return TRUE; }

BOOL NeedsWindowEdge (  DWORD  dwStyle, DWORD  dwExStyle, BOOL  fNewApp )

Definition at line 727 of file rtl/winmgr.c. References BOOL, FALSE, and TRUE. Referenced by _AdjustWindowRectEx(), xxxCreateWindowEx(), and xxxSetWindowStyle(). { BOOL fGetsWindowEdge; fGetsWindowEdge = FALSE; if (dwExStyle & WS_EX_DLGMODALFRAME) fGetsWindowEdge = TRUE; else if (dwExStyle & WS_EX_STATICEDGE) fGetsWindowEdge = FALSE; else if (dwStyle & WS_THICKFRAME) fGetsWindowEdge = TRUE; else switch (dwStyle & WS_CAPTION) { case WS_DLGFRAME: fGetsWindowEdge = TRUE; break; case WS_CAPTION: fGetsWindowEdge = fNewApp; break; } return(fGetsWindowEdge); }

PWND SizeBoxHwnd (  PWND  pwnd  )

Definition at line 636 of file rtl/winmgr.c. References BOOL, FNID_DESKTOP, GETFNID, NULL, tagWND::rcClient, tagWND::rcWindow, REBASEPWND, SYSMETRTL, TestWF, WFCHILD, WFCPRESENT, WFMAXIMIZED, and WFSIZEBOX. Referenced by DrawSize(), FindNCHit(), and xxxWindowHitTest2(). { #ifdef USE_MIRRORING BOOL bMirroredSizeBox = (BOOL) TestWF(pwnd, WEFLAYOUTRTL); #endif int xbrChild; int ybrChild = pwnd->rcWindow.bottom; #ifdef USE_MIRRORING if (bMirroredSizeBox) { xbrChild = pwnd->rcWindow.left; } else #endif { xbrChild = pwnd->rcWindow.right; } while (GETFNID(pwnd) != FNID_DESKTOP) { if (TestWF(pwnd, WFSIZEBOX)) { // First sizeable parent found int xbrParent; int ybrParent; if (TestWF(pwnd, WFMAXIMIZED)) return(NULL); #ifdef USE_MIRRORING if (bMirroredSizeBox) { xbrParent = pwnd->rcClient.left; } else #endif { xbrParent = pwnd->rcClient.right; } ybrParent = pwnd->rcClient.bottom; /* If the sizebox dude is within an EDGE of the client's bottom * right corner (left corner for mirrored windows), let this succeed. * That way people who draw their own sunken clients will be happy. */ #ifdef USE_MIRRORING if (bMirroredSizeBox) { if ((xbrChild - SYSMETRTL(CXEDGE) > xbrParent) || (ybrChild + SYSMETRTL(CYEDGE) < ybrParent)) { // // Child's bottom, left corner of SIZEBOX isn't close enough // to bottom left of parent's client. // return(NULL); } } else #endif { if ((xbrChild + SYSMETRTL(CXEDGE) < xbrParent) || (ybrChild + SYSMETRTL(CYEDGE) < ybrParent)) { // // Child's bottom, right corner of SIZEBOX isn't close enough // to bottom right of parent's client. // return(NULL); } } return(pwnd); } if (!TestWF(pwnd, WFCHILD) || TestWF(pwnd, WFCPRESENT)) break; pwnd = REBASEPWND(pwnd, spwndParent); } return(NULL); }

---