ReactOS 0.4.15-dev-5667-ged97270
winpos.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  _CVR
 
struct  _SMWP
 

Typedefs

typedef struct _CVR CVR
 
typedef struct _CVRPCVR
 
typedef struct _SMWP SMWP
 
typedef struct _SMWPPSMWP
 

Functions

FORCEINLINE BOOL IntPtInWindow (PWND pwnd, INT x, INT y)
 
FORCEINLINE BOOL IntEqualRect (RECTL *lprc1, RECTL *lprc2)
 
BOOL FASTCALL ActivateOtherWindowMin (PWND)
 
UINT FASTCALL co_WinPosArrangeIconicWindows (PWND parent)
 
BOOL FASTCALL IntGetClientOrigin (PWND Window, LPPOINT Point)
 
LRESULT FASTCALL co_WinPosGetNonClientSize (PWND Window, RECTL *WindowRect, RECTL *ClientRect)
 
UINT FASTCALL co_WinPosGetMinMaxInfo (PWND Window, POINT *MaxSize, POINT *MaxPos, POINT *MinTrack, POINT *MaxTrack)
 
UINT FASTCALL co_WinPosMinMaximize (PWND WindowObject, UINT ShowFlag, RECTL *NewPos)
 
BOOLEAN FASTCALL co_WinPosSetWindowPos (PWND Wnd, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
 
BOOLEAN FASTCALL co_WinPosShowWindow (PWND Window, INT Cmd)
 
void FASTCALL co_WinPosSendSizeMove (PWND Window)
 
PWND APIENTRY co_WinPosWindowFromPoint (IN PWND ScopeWin, IN POINT *WinPoint, IN OUT USHORT *HitTest, IN BOOL Ignore)
 
VOID FASTCALL co_WinPosActivateOtherWindow (PWND)
 
PWND FASTCALL IntRealChildWindowFromPoint (PWND, LONG, LONG)
 
BOOL FASTCALL IntScreenToClient (PWND, LPPOINT)
 
BOOL FASTCALL IntClientToScreen (PWND, LPPOINT)
 
BOOL FASTCALL IntGetWindowRect (PWND, RECTL *)
 
BOOL UserHasWindowEdge (DWORD, DWORD)
 
VOID UserGetWindowBorders (DWORD, DWORD, SIZE *, BOOL)
 

Typedef Documentation

◆ CVR

typedef struct _CVR CVR

◆ PCVR

typedef struct _CVR * PCVR

◆ PSMWP

typedef struct _SMWP * PSMWP

◆ SMWP

typedef struct _SMWP SMWP

Function Documentation

◆ ActivateOtherWindowMin()

BOOL FASTCALL ActivateOtherWindowMin ( PWND  Wnd)

Definition at line 284 of file winpos.c.

285{
286 BOOL ActivePrev, FindTopWnd;
287 PWND pWndTopMost, pWndChild, pWndSetActive, pWndTemp, pWndDesk;
290
291 //ERR("AOWM 1 %p\n",Wnd->head.h);
292 ActivePrev = (pti->MessageQueue->spwndActivePrev != NULL);
293 FindTopWnd = TRUE;
294
295 if ((pWndTopMost = IntGetLastTopMostWindow()))
296 pWndChild = pWndTopMost->spwndNext;
297 else
298 pWndChild = Wnd->spwndParent->spwndChild;
299
300 for (;;)
301 {
302 if ( ActivePrev )
303 pWndSetActive = pti->MessageQueue->spwndActivePrev;
304 else
305 pWndSetActive = pWndChild;
306
307 pWndTemp = NULL;
308
309 while(pWndSetActive)
310 {
311 if ( VerifyWnd(pWndSetActive) &&
312 !(pWndSetActive->ExStyle & WS_EX_NOACTIVATE) &&
313 (pWndSetActive->style & (WS_VISIBLE|WS_DISABLED)) == WS_VISIBLE &&
314 (!(pWndSetActive->style & WS_ICONIC) /* FIXME MinMax pos? */ ) )
315 {
316 if (!(pWndSetActive->ExStyle & WS_EX_TOOLWINDOW) )
317 {
318 UserRefObjectCo(pWndSetActive, &Ref);
319 //ERR("ActivateOtherWindowMin Set FG 1\n");
320 co_IntSetForegroundWindow(pWndSetActive);
321 UserDerefObjectCo(pWndSetActive);
322 //ERR("AOWM 2 Exit Good %p\n",pWndSetActive->head.h);
323 return TRUE;
324 }
325 if (!pWndTemp ) pWndTemp = pWndSetActive;
326 }
327 if ( ActivePrev )
328 {
329 ActivePrev = FALSE;
330 pWndSetActive = pWndChild;
331 }
332 else
333 pWndSetActive = pWndSetActive->spwndNext;
334 }
335
336 if ( !FindTopWnd ) break;
337 FindTopWnd = FALSE;
338
339 if ( pWndChild )
340 {
341 pWndChild = pWndChild->spwndParent->spwndChild;
342 continue;
343 }
344
345 if (!(pWndDesk = IntGetThreadDesktopWindow(pti)))
346 {
347 pWndChild = NULL;
348 continue;
349 }
350 pWndChild = pWndDesk->spwndChild;
351 }
352
353 if ((pWndSetActive = pWndTemp))
354 {
355 UserRefObjectCo(pWndSetActive, &Ref);
356 //ERR("ActivateOtherWindowMin Set FG 2\n");
357 co_IntSetForegroundWindow(pWndSetActive);
358 UserDerefObjectCo(pWndSetActive);
359 //ERR("AOWM 3 Exit Good %p\n",pWndSetActive->head.h);
360 return TRUE;
361 }
362 //ERR("AOWM 4 Bad\n");
363 return FALSE;
364}
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
BOOL FASTCALL co_IntSetForegroundWindow(PWND Window)
Definition: focus.c:1550
#define for
Definition: utility.h:88
PWND FASTCALL IntGetLastTopMostWindow(VOID)
Definition: winpos.c:237
PTHREADINFO gptiCurrent
Definition: ntuser.c:15
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:40
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:27
#define WS_ICONIC
Definition: pedump.c:641
#define WS_VISIBLE
Definition: pedump.c:620
#define WS_DISABLED
Definition: pedump.c:621
struct _USER_MESSAGE_QUEUE * MessageQueue
Definition: win32.h:89
Definition: object.h:4
Definition: ntuser.h:689
DWORD ExStyle
Definition: ntuser.h:699
DWORD style
Definition: ntuser.h:701
struct _WND * spwndChild
Definition: ntuser.h:709
struct _WND * spwndNext
Definition: ntuser.h:706
struct _WND * spwndParent
Definition: ntuser.h:708
PWND FASTCALL IntGetThreadDesktopWindow(PTHREADINFO pti)
Definition: desktop.c:1359
PWND FASTCALL VerifyWnd(PWND pWnd)
Definition: window.c:86
#define WS_EX_NOACTIVATE
Definition: winuser.h:395
#define WS_EX_TOOLWINDOW
Definition: winuser.h:404

Referenced by co_WinPosShowWindow(), and UserSetActiveWindow().

◆ co_WinPosActivateOtherWindow()

VOID FASTCALL co_WinPosActivateOtherWindow ( PWND  Wnd)

Definition at line 396 of file winpos.c.

397{
398 PWND WndTo = NULL;
400
401 ASSERT_REFS_CO(Wnd);
402
403 if (IntIsDesktopWindow(Wnd))
404 {
405 //ERR("WinPosActivateOtherWindow Set Focus Msg Q No window!\n");
407 return;
408 }
409
410 /* If this is popup window, try to activate the owner first. */
411 if ((Wnd->style & WS_POPUP) && (WndTo = Wnd->spwndOwner))
412 {
413 TRACE("WPAOW Popup with Owner\n");
414 WndTo = UserGetAncestor( WndTo, GA_ROOT );
415 if (can_activate_window(WndTo)) goto done;
416 }
417
418 /* Pick a next top-level window. */
419 /* FIXME: Search for non-tooltip windows first. */
420 WndTo = Wnd;
421 for (;;)
422 {
423 if (!(WndTo = WndTo->spwndNext)) break;
424 if (can_activate_window( WndTo )) goto done;
425 }
426
427 /*
428 Fixes wine win.c:test_SetParent last ShowWindow test after popup dies.
429 Check for previous active window to bring to top.
430 */
431 if (Wnd)
432 {
433 WndTo = Wnd->head.pti->MessageQueue->spwndActivePrev;
434 if (can_activate_window( WndTo )) goto done;
435 }
436
437 // Find any window to bring to top. Works Okay for wine since it does not see X11 windows.
438 WndTo = UserGetDesktopWindow();
439 if ((WndTo == NULL) || (WndTo->spwndChild == NULL))
440 {
441 //ERR("WinPosActivateOtherWindow No window!\n");
442 return;
443 }
444 WndTo = WndTo->spwndChild;
445 for (;;)
446 {
447 if (WndTo == Wnd)
448 {
449 WndTo = NULL;
450 break;
451 }
452 if (can_activate_window( WndTo )) goto done;
453 if (!(WndTo = WndTo->spwndNext)) break;
454 }
455
456done:
457 if (WndTo) UserRefObjectCo(WndTo, &Ref);
458
460 {
461 /* ReactOS can pass WndTo = NULL to co_IntSetForegroundWindow and returns FALSE. */
462 //ERR("WinPosActivateOtherWindow Set FG 0x%p hWnd %p\n",WndTo, WndTo ? WndTo->head.h : 0);
463 if (co_IntSetForegroundWindow(WndTo))
464 {
465 if (WndTo) UserDerefObjectCo(WndTo);
466 return;
467 }
468 }
469 //ERR("WinPosActivateOtherWindow Set Active 0x%p\n",WndTo);
470 if (!UserSetActiveWindow(WndTo)) /* Ok for WndTo to be NULL here */
471 {
472 //ERR("WPAOW SA 1\n");
474 }
475 if (WndTo) UserDerefObjectCo(WndTo);
476}
BOOL FASTCALL UserSetActiveWindow(_In_opt_ PWND Wnd)
Definition: focus.c:1260
PUSER_MESSAGE_QUEUE gpqForeground
Definition: focus.c:13
static BOOL FASTCALL can_activate_window(PWND Wnd OPTIONAL)
Definition: winpos.c:372
#define WS_POPUP
Definition: pedump.c:616
#define TRACE(s)
Definition: solgame.cpp:4
struct _WND * spwndOwner
Definition: ntuser.h:710
THRDESKHEAD head
Definition: ntuser.h:690
PWND FASTCALL UserGetAncestor(PWND Wnd, UINT Type)
Definition: window.c:3335
#define ASSERT_REFS_CO(_obj_)
Definition: userfuncs.h:14
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1386
VOID FASTCALL IntSetFocusMessageQueue(PUSER_MESSAGE_QUEUE NewQueue)
Definition: desktop.c:1319
#define IntIsDesktopWindow(WndObj)
Definition: window.h:25
#define GA_ROOT
Definition: winuser.h:2779

Referenced by co_WinPosShowWindow(), IntSendDestroyMsg(), and UserSetActiveWindow().

◆ co_WinPosArrangeIconicWindows()

UINT FASTCALL co_WinPosArrangeIconicWindows ( PWND  parent)

Definition at line 730 of file winpos.c.

731{
732 RECTL rectParent;
733 PWND Child;
734 INT x, y, xspacing, yspacing, sx, sy;
735
737
738 IntGetClientRect( parent, &rectParent );
739 // FIXME: Support Minimize Metrics gspv.mm.iArrange.
740 // Default: ARW_BOTTOMLEFT
741 x = rectParent.left;
742 y = rectParent.bottom;
743
746
747 Child = parent->spwndChild;
748 while(Child)
749 {
750 if((Child->style & WS_MINIMIZE) != 0 )
751 {
753 UserRefObjectCo(Child, &Ref);
754
756 sy = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
757
758 Child->InternalPos.IconPos.x = sx;
759 Child->InternalPos.IconPos.y = sy;
760 Child->InternalPos.flags |= WPF_MININIT;
761
763
765
766 if (x <= rectParent.right - xspacing)
767 x += xspacing;
768 else
769 {
770 x = rectParent.left;
771 y -= yspacing;
772 }
773 }
774 Child = Child->spwndNext;
775 }
776 return yspacing;
777}
r parent
Definition: btrfs.c:3010
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define WPF_MININIT
Definition: ntuser.h:681
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1748
VOID FASTCALL IntGetClientRect(PWND Wnd, RECTL *Rect)
Definition: winpos.c:91
#define WS_MINIMIZE
Definition: pedump.c:622
long bottom
Definition: polytest.cpp:53
long right
Definition: polytest.cpp:53
long left
Definition: polytest.cpp:53
int32_t INT
Definition: typedefs.h:58
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFDEVICE Child
Definition: wdffdo.h:536
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:208
#define SM_CXMINIMIZED
Definition: winuser.h:1014
#define SWP_NOACTIVATE
Definition: winuser.h:1232
#define SM_CYMINIMIZED
Definition: winuser.h:1015
#define SWP_ASYNCWINDOWPOS
Definition: winuser.h:1243
#define SM_CYBORDER
Definition: winuser.h:959
#define SWP_NOCOPYBITS
Definition: winuser.h:1233
#define SM_CXBORDER
Definition: winuser.h:958
#define SWP_NOZORDER
Definition: winuser.h:1237

Referenced by NtUserCallHwndLock().

◆ co_WinPosGetMinMaxInfo()

UINT FASTCALL co_WinPosGetMinMaxInfo ( PWND  Window,
POINT MaxSize,
POINT MaxPos,
POINT MinTrack,
POINT MaxTrack 
)

Definition at line 933 of file winpos.c.

935{
936 MINMAXINFO MinMax;
937 PMONITOR monitor;
938 INT xinc, yinc;
939 LONG style = Window->style;
940 LONG adjustedStyle;
941 LONG exstyle = Window->ExStyle;
942 RECT rc;
943 DWORD adjust;
944
946
947 /* Compute default values */
948
949 rc = Window->rcWindow;
950 MinMax.ptReserved.x = rc.left;
951 MinMax.ptReserved.y = rc.top;
952
953 if ((style & WS_CAPTION) == WS_CAPTION)
954 adjustedStyle = style & ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
955 else
956 adjustedStyle = style;
957
958 if (Window->spwndParent)
959 IntGetClientRect(Window->spwndParent, &rc);
960
961 adjust = IntGetWindowBorders(adjustedStyle, exstyle);
962
963 // Handle special case while maximized. CORE-15893
964 if ((adjustedStyle & WS_THICKFRAME) && !(adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
965 adjust += 1;
966
967 xinc = yinc = adjust;
968
969 if ((adjustedStyle & WS_THICKFRAME) && (adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
970 {
973 }
974
978
979 xinc = -rc.left;
980 yinc = -rc.top;
981
982 MinMax.ptMaxSize.x = rc.right - rc.left;
983 MinMax.ptMaxSize.y = rc.bottom - rc.top;
984 if (style & (WS_DLGFRAME | WS_BORDER))
985 {
988 }
989 else
990 {
991 MinMax.ptMinTrackSize.x = 2 * xinc;
992 MinMax.ptMinTrackSize.y = 2 * yinc;
993 }
996 MinMax.ptMaxPosition.x = -xinc;
997 MinMax.ptMaxPosition.y = -yinc;
998
999 if (!EMPTYPOINT(Window->InternalPos.MaxPos)) MinMax.ptMaxPosition = Window->InternalPos.MaxPos;
1000
1001 co_IntSendMessage(Window->head.h, WM_GETMINMAXINFO, 0, (LPARAM)&MinMax);
1002
1003 /* if the app didn't change the values, adapt them for the current monitor */
1004 if ((monitor = UserGetPrimaryMonitor()))
1005 {
1006 RECT rc_work;
1007
1008 rc_work = monitor->rcMonitor;
1009
1010 if (style & WS_MAXIMIZEBOX)
1011 {
1012 if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP)))
1013 rc_work = monitor->rcWork;
1014 }
1015
1016 if (MinMax.ptMaxSize.x == UserGetSystemMetrics(SM_CXSCREEN) + 2 * xinc &&
1017 MinMax.ptMaxSize.y == UserGetSystemMetrics(SM_CYSCREEN) + 2 * yinc)
1018 {
1019 MinMax.ptMaxSize.x = (rc_work.right - rc_work.left) + 2 * xinc;
1020 MinMax.ptMaxSize.y = (rc_work.bottom - rc_work.top) + 2 * yinc;
1021 }
1022 if (MinMax.ptMaxPosition.x == -xinc && MinMax.ptMaxPosition.y == -yinc)
1023 {
1024 MinMax.ptMaxPosition.x = rc_work.left - xinc;
1025 MinMax.ptMaxPosition.y = rc_work.top - yinc;
1026 }
1027 if (MinMax.ptMaxSize.x >= (monitor->rcMonitor.right - monitor->rcMonitor.left) &&
1028 MinMax.ptMaxSize.y >= (monitor->rcMonitor.bottom - monitor->rcMonitor.top) )
1029 {
1031 }
1032 else
1033 Window->state &= ~WNDS_MAXIMIZESTOMONITOR;
1034 }
1035
1036
1037 MinMax.ptMaxTrackSize.x = max(MinMax.ptMaxTrackSize.x,
1038 MinMax.ptMinTrackSize.x);
1039 MinMax.ptMaxTrackSize.y = max(MinMax.ptMaxTrackSize.y,
1040 MinMax.ptMinTrackSize.y);
1041
1042 if (MaxSize)
1043 *MaxSize = MinMax.ptMaxSize;
1044 if (MaxPos)
1045 *MaxPos = MinMax.ptMaxPosition;
1046 if (MinTrack)
1047 *MinTrack = MinMax.ptMinTrackSize;
1048 if (MaxTrack)
1049 *MaxTrack = MinMax.ptMaxTrackSize;
1050
1051 return 0; // FIXME: What does it return? Wine returns MINMAXINFO.
1052}
Arabic default style
Definition: afstyles.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
#define WNDS_MAXIMIZESTOMONITOR
Definition: ntuser.h:630
#define EMPTYPOINT(pt)
Definition: winpos.c:28
DWORD IntGetWindowBorders(DWORD Style, DWORD ExStyle)
Definition: winpos.c:914
#define WS_CHILD
Definition: pedump.c:617
#define WS_CAPTION
Definition: pedump.c:624
#define WS_MAXIMIZEBOX
Definition: pedump.c:632
#define WS_BORDER
Definition: pedump.c:625
long LONG
Definition: pedump.c:60
#define WS_DLGFRAME
Definition: pedump.c:626
#define WS_THICKFRAME
Definition: pedump.c:630
Definition: window.c:28
RECT rcWork
Definition: monitor.h:19
RECT rcMonitor
Definition: monitor.h:18
POINT ptMaxPosition
Definition: winuser.h:3619
POINT ptMaxSize
Definition: winuser.h:3618
POINT ptMinTrackSize
Definition: winuser.h:3620
POINT ptReserved
Definition: winuser.h:3617
POINT ptMaxTrackSize
Definition: winuser.h:3621
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
#define max(a, b)
Definition: svc.c:63
VOID FASTCALL RECTL_vInflateRect(_Inout_ RECTL *rect, _In_ INT dx, _In_ INT dy)
Definition: rect.c:101
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1446
PMONITOR NTAPI UserGetPrimaryMonitor(VOID)
Definition: monitor.c:102
LONG_PTR LPARAM
Definition: windef.h:208
#define SM_CYSCREEN
Definition: winuser.h:954
#define SM_CXMINTRACK
Definition: winuser.h:991
#define SM_CXFRAME
Definition: winuser.h:988
#define SM_CYFRAME
Definition: winuser.h:990
#define SM_CXMAXTRACK
Definition: winuser.h:1016
#define WM_GETMINMAXINFO
Definition: winuser.h:1630
#define SM_CYMAXTRACK
Definition: winuser.h:1017
#define SM_CXDLGFRAME
Definition: winuser.h:960
#define SM_CYDLGFRAME
Definition: winuser.h:962
#define SM_CXSCREEN
Definition: winuser.h:953
#define SM_CYMINTRACK
Definition: winuser.h:992

Referenced by co_UserCreateWindowEx(), co_WinPosMinMaximize(), DefWndDoSizeMove(), and DefWndHandleWindowPosChanging().

◆ co_WinPosGetNonClientSize()

LRESULT FASTCALL co_WinPosGetNonClientSize ( PWND  Window,
RECTL WindowRect,
RECTL ClientRect 
)

◆ co_WinPosMinMaximize()

UINT FASTCALL co_WinPosMinMaximize ( PWND  WindowObject,
UINT  ShowFlag,
RECTL NewPos 
)

◆ co_WinPosSendSizeMove()

void FASTCALL co_WinPosSendSizeMove ( PWND  Window)

Definition at line 2337 of file winpos.c.

2338{
2339 RECTL Rect;
2340 LPARAM lParam;
2342
2343 IntGetClientRect(Wnd, &Rect);
2344 lParam = MAKELONG(Rect.right-Rect.left, Rect.bottom-Rect.top);
2345
2346 Wnd->state &= ~WNDS_SENDSIZEMOVEMSGS;
2347
2348 if (Wnd->style & WS_MAXIMIZE)
2349 {
2351 }
2352 else if (Wnd->style & WS_MINIMIZE)
2353 {
2355 lParam = 0;
2356 }
2357
2359
2360 if (UserIsDesktopWindow(Wnd->spwndParent))
2361 lParam = MAKELONG(Wnd->rcClient.left, Wnd->rcClient.top);
2362 else
2363 lParam = MAKELONG(Wnd->rcClient.left-Wnd->spwndParent->rcClient.left, Wnd->rcClient.top-Wnd->spwndParent->rcClient.top);
2364
2366
2368}
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
VOID FASTCALL IntEngWindowChanged(_In_ struct _WND *Window, _In_ FLONG flChanged)
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define WS_MAXIMIZE
Definition: pedump.c:623
#define MAKELONG(a, b)
Definition: typedefs.h:249
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:194
LRESULT FASTCALL co_IntSendMessageNoWait(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1710
#define WOC_RGN_CLIENT
Definition: winddi.h:1265
UINT_PTR WPARAM
Definition: windef.h:207
#define WM_SIZE
Definition: winuser.h:1601
#define SIZE_MINIMIZED
Definition: winuser.h:2496
#define SIZE_MAXIMIZED
Definition: winuser.h:2497
#define WM_MOVE
Definition: winuser.h:1600
#define SIZE_RESTORED
Definition: winuser.h:2495

Referenced by co_UserCreateWindowEx(), and co_WinPosShowWindow().

◆ co_WinPosSetWindowPos()

BOOLEAN FASTCALL co_WinPosSetWindowPos ( PWND  Wnd,
HWND  WndInsertAfter,
INT  x,
INT  y,
INT  cx,
INT  cy,
UINT  flags 
)

Definition at line 1748 of file winpos.c.

1757{
1758 WINDOWPOS WinPos;
1759 RECTL NewWindowRect;
1760 RECTL NewClientRect;
1761 RECTL valid_rects[2];
1762 PREGION VisBefore = NULL;
1763 PREGION VisBeforeJustClient = NULL;
1764 PREGION VisAfter = NULL;
1766 ULONG WvrFlags = 0;
1767 RECTL OldWindowRect, OldClientRect;
1768 int RgnType;
1769 HDC Dc;
1771 PWND Ancestor;
1772 BOOL bPointerInWindow, PosChanged = FALSE;
1774
1776
1777 TRACE("pwnd %p, after %p, %d,%d (%dx%d), flags 0x%x\n",
1778 Window, WndInsertAfter, x, y, cx, cy, flags);
1779#if DBG
1780 dump_winpos_flags(flags);
1781#endif
1782
1783 /* FIXME: Get current active window from active queue. Why? since r2915. */
1784
1785 bPointerInWindow = IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y);
1786
1787 WinPos.hwnd = Window->head.h;
1788 WinPos.hwndInsertAfter = WndInsertAfter;
1789 WinPos.x = x;
1790 WinPos.y = y;
1791 WinPos.cx = cx;
1792 WinPos.cy = cy;
1793 WinPos.flags = flags;
1794
1795 if ( flags & SWP_ASYNCWINDOWPOS )
1796 {
1797 LRESULT lRes;
1799 if ( ppos )
1800 {
1801 WinPos.flags &= ~SWP_ASYNCWINDOWPOS; // Clear flag.
1802 *ppos = WinPos;
1803 /* Yes it's a pointer inside Win32k! */
1804 lRes = co_IntSendMessageNoWait( WinPos.hwnd, WM_ASYNC_SETWINDOWPOS, 0, (LPARAM)ppos);
1805 /* We handle this the same way as Event Hooks and Hooks. */
1806 if ( !lRes )
1807 {
1809 return FALSE;
1810 }
1811 return TRUE;
1812 }
1813 return FALSE;
1814 }
1815
1816 co_WinPosDoWinPosChanging(Window, &WinPos, &NewWindowRect, &NewClientRect);
1817
1818 /* Does the window still exist? */
1819 if (!IntIsWindow(WinPos.hwnd))
1820 {
1821 TRACE("WinPosSetWindowPos: Invalid handle 0x%p!\n",WinPos.hwnd);
1823 return FALSE;
1824 }
1825
1826 /* Fix up the flags. */
1827 if (!WinPosFixupFlags(&WinPos, Window))
1828 {
1829 // See Note.
1830 return TRUE;
1831 }
1832
1833 Ancestor = UserGetAncestor(Window, GA_PARENT);
1834 if ( (WinPos.flags & (SWP_NOZORDER | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) != SWP_NOZORDER &&
1835 Ancestor && Ancestor->head.h == IntGetDesktopWindow() )
1836 {
1838 }
1839
1840 if (!(WinPos.flags & SWP_NOREDRAW))
1841 {
1842 /* Compute the visible region before the window position is changed */
1843 if (!(WinPos.flags & SWP_SHOWWINDOW) &&
1844 (WinPos.flags & (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1847 {
1849 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1850
1851 if ( VisBefore != NULL &&
1852 REGION_Complexity(VisBefore) == NULLREGION )
1853 {
1854 REGION_Delete(VisBefore);
1855 VisBefore = NULL;
1856 }
1857 else if(VisBefore)
1858 {
1859 REGION_bOffsetRgn(VisBefore, -Window->rcWindow.left, -Window->rcWindow.top);
1860 }
1861
1862 /* Calculate the non client area for resizes, as this is used in the copy region */
1863 if ((WinPos.flags & (SWP_NOSIZE | SWP_FRAMECHANGED)) != SWP_NOSIZE)
1864 {
1865 VisBeforeJustClient = VIS_ComputeVisibleRegion(Window, TRUE, FALSE,
1866 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1867
1868 if ( VisBeforeJustClient != NULL &&
1869 REGION_Complexity(VisBeforeJustClient) == NULLREGION )
1870 {
1871 REGION_Delete(VisBeforeJustClient);
1872 VisBeforeJustClient = NULL;
1873 }
1874 else if(VisBeforeJustClient)
1875 {
1876 REGION_bOffsetRgn(VisBeforeJustClient, -Window->rcWindow.left, -Window->rcWindow.top);
1877 }
1878 }
1879 }
1880 }
1881
1883 if (Window->hrgnNewFrame)
1884 {
1885 SelectWindowRgn( Window, Window->hrgnNewFrame ); // Should be PSMWP->acvr->hrgnClip
1886 Window->hrgnNewFrame = NULL;
1887 }
1888
1889 WvrFlags = co_WinPosDoNCCALCSize(Window, &WinPos, &NewWindowRect, &NewClientRect, valid_rects);
1890
1891// ERR("co_WinPosDoNCCALCSize returned 0x%x\n valid dest: %d %d %d %d\n valid src : %d %d %d %d\n", WvrFlags,
1892// valid_rects[0].left,valid_rects[0].top,valid_rects[0].right,valid_rects[0].bottom,
1893// valid_rects[1].left,valid_rects[1].top,valid_rects[1].right,valid_rects[1].bottom);
1894
1895 /* Validate link windows. (also take into account shell window in hwndShellWindow) */
1896 if (!(WinPos.flags & SWP_NOZORDER) && WinPos.hwnd != UserGetShellWindow())
1897 {
1899 }
1900
1901 OldWindowRect = Window->rcWindow;
1902 OldClientRect = Window->rcClient;
1903
1904 if (NewClientRect.left != OldClientRect.left ||
1905 NewClientRect.top != OldClientRect.top)
1906 {
1907 // Move child window if their parent is moved. Keep Child window relative to Parent...
1909 NewClientRect.left - OldClientRect.left,
1910 NewClientRect.top - OldClientRect.top);
1911 PosChanged = TRUE;
1912 }
1913
1914 Window->rcWindow = NewWindowRect;
1915 Window->rcClient = NewClientRect;
1916
1917 /* erase parent when hiding or resizing child */
1918 if (WinPos.flags & SWP_HIDEWINDOW)
1919 {
1920 /* Clear the update region */
1922 NULL,
1923 0,
1925
1926 if (UserIsDesktopWindow(Window->spwndParent))
1928
1929 Window->style &= ~WS_VISIBLE; //IntSetStyle( Window, 0, WS_VISIBLE );
1930 Window->head.pti->cVisWindows--;
1932 }
1933 else if (WinPos.flags & SWP_SHOWWINDOW)
1934 {
1935 if (Window->style & WS_CHILD)
1936 {
1937 if ((Window->style & WS_POPUP) && (Window->ExStyle & WS_EX_APPWINDOW))
1938 {
1940 if (!(WinPos.flags & SWP_NOACTIVATE))
1942 }
1943 }
1944 else if ((Window->ExStyle & WS_EX_APPWINDOW) ||
1945 (!(Window->ExStyle & WS_EX_TOOLWINDOW) && !Window->spwndOwner &&
1946 (!Window->spwndParent || UserIsDesktopWindow(Window->spwndParent))))
1947 {
1949 {
1951 if (!(WinPos.flags & SWP_NOACTIVATE))
1953 }
1954 }
1955
1956 Window->style |= WS_VISIBLE; //IntSetStyle( Window, WS_VISIBLE, 0 );
1957 Window->head.pti->cVisWindows++;
1959 }
1960 else
1961 {
1963 }
1964
1965 if (Window->hrgnUpdate != NULL && Window->hrgnUpdate != HRGN_WINDOW)
1966 {
1967 NtGdiOffsetRgn(Window->hrgnUpdate,
1968 NewWindowRect.left - OldWindowRect.left,
1969 NewWindowRect.top - OldWindowRect.top);
1970 }
1971
1972 DceResetActiveDCEs(Window); // For WS_VISIBLE changes.
1973
1974 // Change or update, set send non-client paint flag.
1975 if ( Window->style & WS_VISIBLE &&
1976 (WinPos.flags & SWP_STATECHANGED || (!(Window->state2 & WNDS2_WIN31COMPAT) && WinPos.flags & SWP_NOREDRAW ) ) )
1977 {
1978 TRACE("Set WNDS_SENDNCPAINT %p\n",Window);
1979 Window->state |= WNDS_SENDNCPAINT;
1980 }
1981
1982 if (!(WinPos.flags & SWP_NOREDRAW))
1983 {
1984 /* Determine the new visible region */
1986 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1987
1988 if ( VisAfter != NULL &&
1989 REGION_Complexity(VisAfter) == NULLREGION )
1990 {
1991 REGION_Delete(VisAfter);
1992 VisAfter = NULL;
1993 }
1994 else if(VisAfter)
1995 {
1996 REGION_bOffsetRgn(VisAfter, -Window->rcWindow.left, -Window->rcWindow.top);
1997 }
1998
1999 /*
2000 * Determine which pixels can be copied from the old window position
2001 * to the new. Those pixels must be visible in both the old and new
2002 * position. Also, check the class style to see if the windows of this
2003 * class need to be completely repainted on (horizontal/vertical) size
2004 * change.
2005 */
2006 if ( ( VisBefore != NULL &&
2007 VisAfter != NULL &&
2008 !(WinPos.flags & SWP_NOCOPYBITS) &&
2009 ((WinPos.flags & SWP_NOSIZE) || !(WvrFlags & WVR_REDRAW)) &&
2010 !(Window->ExStyle & WS_EX_TRANSPARENT) ) )
2011 {
2012
2013 /*
2014 * If this is (also) a window resize, the whole nonclient area
2015 * needs to be repainted. So we limit the copy to the client area,
2016 * 'cause there is no use in copying it (would possibly cause
2017 * "flashing" too). However, if the copy region is already empty,
2018 * we don't have to crop (can't take anything away from an empty
2019 * region...)
2020 */
2021
2022 CopyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2023 if ((WinPos.flags & SWP_NOSIZE) && (WinPos.flags & SWP_NOCLIENTSIZE))
2024 RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBefore, RGN_AND);
2025 else if (VisBeforeJustClient != NULL)
2026 {
2027 RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBeforeJustClient, RGN_AND);
2028 }
2029
2030 if (VisBeforeJustClient != NULL)
2031 {
2032 REGION_Delete(VisBeforeJustClient);
2033 }
2034
2035 /* Now use in copying bits which are in the update region. */
2036 if (Window->hrgnUpdate != NULL)
2037 {
2038 PREGION RgnUpdate = REGION_LockRgn(Window->hrgnUpdate);
2039 if (RgnUpdate)
2040 {
2041 REGION_bOffsetRgn(CopyRgn, NewWindowRect.left, NewWindowRect.top);
2043 REGION_bOffsetRgn(CopyRgn, -NewWindowRect.left, -NewWindowRect.top);
2044 REGION_UnlockRgn(RgnUpdate);
2045 }
2046 }
2047
2048 /*
2049 * Now, get the bounding box of the copy region. If it's empty
2050 * there's nothing to copy. Also, it's no use copying bits onto
2051 * themselves.
2052 */
2054 {
2055 /* Nothing to copy, clean up */
2057 CopyRgn = NULL;
2058 }
2059 else if ( OldWindowRect.left != NewWindowRect.left ||
2060 OldWindowRect.top != NewWindowRect.top ||
2061 (WinPos.flags & SWP_FRAMECHANGED) )
2062 {
2063 HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
2064 PREGION DcRgnObj = REGION_LockRgn(DcRgn);
2065
2066 /*
2067 * Small trick here: there is no function to bitblt a region. So
2068 * we set the region as the clipping region, take the bounding box
2069 * of the region and bitblt that. Since nothing outside the clipping
2070 * region is copied, this has the effect of bitblt'ing the region.
2071 *
2072 * Since NtUserGetDCEx takes ownership of the clip region, we need
2073 * to create a copy of CopyRgn and pass that. We need CopyRgn later
2074 */
2076 REGION_bOffsetRgn(DcRgnObj, NewWindowRect.left, NewWindowRect.top);
2077 REGION_UnlockRgn(DcRgnObj);
2078 Dc = UserGetDCEx( Window,
2079 DcRgn,
2080 DCX_WINDOW|DCX_CACHE|DCX_INTERSECTRGN|DCX_CLIPSIBLINGS|DCX_KEEPCLIPRGN); // DCX_WINDOW will set first, go read WinDC.c.
2081 NtGdiBitBlt( Dc,
2082 CopyRect.left, CopyRect.top,
2083 CopyRect.right - CopyRect.left,
2084 CopyRect.bottom - CopyRect.top,
2085 Dc,
2086 CopyRect.left + (OldWindowRect.left - NewWindowRect.left),
2087 CopyRect.top + (OldWindowRect.top - NewWindowRect.top),
2088 SRCCOPY,
2089 0,
2090 0);
2091
2094 GreDeleteObject(DcRgn);
2095 }
2096 }
2097 else
2098 {
2099 CopyRgn = NULL;
2100 }
2101
2102 /* We need to redraw what wasn't visible before or force a redraw */
2103 if ((WinPos.flags & (SWP_FRAMECHANGED | SWP_SHOWWINDOW)) ||
2104 (((WinPos.flags & SWP_AGG_NOGEOMETRYCHANGE) != SWP_AGG_NOGEOMETRYCHANGE) && VisAfter != NULL))
2105 {
2106 PREGION DirtyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2107 if (DirtyRgn)
2108 {
2109 if (CopyRgn != NULL)
2110 {
2111 RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, CopyRgn, RGN_DIFF);
2112 }
2113 else
2114 {
2115 RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, 0, RGN_COPY);
2116 }
2117
2118 if (RgnType != ERROR && RgnType != NULLREGION) // Regions moved.
2119 {
2120 /* old code
2121 NtGdiOffsetRgn(DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
2122 IntInvalidateWindows( Window,
2123 DirtyRgn,
2124 RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
2125 }
2126 GreDeleteObject(DirtyRgn);
2127 */
2128
2129 PWND Parent = Window->spwndParent;
2130
2131 REGION_bOffsetRgn( DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
2132
2133 if ( (Window->style & WS_CHILD) && (Parent) && !(Parent->style & WS_CLIPCHILDREN))
2134 {
2137 }
2139 }
2140 else if ( RgnType != ERROR && RgnType == NULLREGION ) // Must be the same. See CORE-7166 & CORE-15934, NC HACK fix.
2141 {
2142 if ( !PosChanged &&
2143 !(WinPos.flags & SWP_DEFERERASE) &&
2144 (WinPos.flags & SWP_FRAMECHANGED) )
2145 {
2146 PWND pwnd = Window;
2147 PWND Parent = Window->spwndParent;
2148
2149 if ( pwnd->style & WS_CHILD ) // Fix ProgMan menu bar drawing.
2150 {
2151 TRACE("SWP_FRAMECHANGED win child %p Parent %p\n",pwnd,Parent);
2152 pwnd = Parent ? Parent : pwnd;
2153 }
2154
2155 if ( !(pwnd->style & WS_CHILD) )
2156 {
2157 /*
2158 * Check if we have these specific windows style bits set/reset.
2159 * FIXME: There may be other combinations of styles that need this handling as well.
2160 * This fixes the ReactOS Calculator buttons disappearing in CORE-16827.
2161 */
2162 if ((Window->style & WS_CLIPSIBLINGS) && !(Window->style & (WS_POPUP | WS_CLIPCHILDREN | WS_SIZEBOX)))
2163 {
2164 IntSendNCPaint(pwnd, HRGN_WINDOW); // Paint the whole frame.
2165 }
2166 else // Use region handling
2167 {
2168 HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
2169 PREGION DcRgnObj = REGION_LockRgn(DcRgn);
2170 TRACE("SWP_FRAMECHANGED win %p hRgn %p\n",pwnd, DcRgn);
2171 IntGdiCombineRgn(DcRgnObj, VisBefore, NULL, RGN_COPY);
2172 REGION_UnlockRgn(DcRgnObj);
2173 ForceNCPaintErase(pwnd, DcRgn, DcRgnObj);
2174 GreDeleteObject(DcRgn);
2175 }
2176 }
2177 }
2178 }
2179 REGION_Delete(DirtyRgn);
2180 }
2181 }
2182
2183 if (CopyRgn != NULL)
2184 {
2186 }
2187
2188 /* Expose what was covered before but not covered anymore */
2189 if ( VisBefore != NULL )
2190 {
2191 PREGION ExposedRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2192 if (ExposedRgn)
2193 {
2194 RgnType = IntGdiCombineRgn(ExposedRgn, VisBefore, NULL, RGN_COPY);
2195 REGION_bOffsetRgn(ExposedRgn,
2196 OldWindowRect.left - NewWindowRect.left,
2197 OldWindowRect.top - NewWindowRect.top);
2198
2199 if ( VisAfter != NULL )
2200 RgnType = IntGdiCombineRgn(ExposedRgn, ExposedRgn, VisAfter, RGN_DIFF);
2201
2202 if (RgnType != ERROR && RgnType != NULLREGION)
2203 {
2205 }
2206 REGION_Delete(ExposedRgn);
2207 }
2208 REGION_Delete(VisBefore);
2209 }
2210
2211 if (VisAfter != NULL)
2212 {
2213 REGION_Delete(VisAfter);
2214 }
2215 }
2216
2217 if (!(WinPos.flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)))
2218 {
2219 if ((Window->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
2220 {
2222 }
2223 else
2224 {
2225 //ERR("SetWindowPos Set FG Window!\n");
2226 if ( pti->MessageQueue->spwndActive != Window ||
2227 pti->MessageQueue != gpqForeground )
2228 {
2229 //ERR("WPSWP : set active window\n");
2230 if (!(Window->state & WNDS_BEINGACTIVATED)) // Inside SAW?
2231 {
2232 co_IntSetForegroundWindow(Window); // Fixes SW_HIDE issues. Wine win test_SetActiveWindow & test_SetForegroundWindow.
2233 }
2234 }
2235 }
2236 }
2237
2238 if ( !PosChanged &&
2239 (WinPos.flags & SWP_FRAMECHANGED) &&
2240 !(WinPos.flags & SWP_DEFERERASE) && // Prevent sending WM_SYNCPAINT message.
2241 VisAfter )
2242 {
2243 PWND Parent = Window->spwndParent;
2244 if ( !(Window->style & WS_CHILD) && (Parent) && (Parent->style & WS_CLIPCHILDREN))
2245 {
2246 TRACE("SWP_FRAMECHANGED Parent %p WS_CLIPCHILDREN %p\n",Parent,Window);
2247 UserSyncAndPaintWindows( Parent, RDW_CLIPCHILDREN); // NC should redraw here, see NC HACK fix.
2248 }
2249 }
2250
2251 // Fix wine msg test_SetFocus, prevents sending WM_WINDOWPOSCHANGED.
2252 if ( VisBefore == NULL &&
2253 VisBeforeJustClient == NULL &&
2254 !(Window->ExStyle & WS_EX_TOPMOST) &&
2256 {
2257 TRACE("No drawing, set no Z order and no redraw!\n");
2259 }
2260
2261 if(!(flags & SWP_DEFERERASE))
2262 {
2263 /* erase parent when hiding or resizing child */
2264 if ((flags & SWP_HIDEWINDOW) ||
2265 (!(flags & SWP_SHOWWINDOW) &&
2267 {
2268 PWND Parent = Window->spwndParent;
2271 }
2272
2273 /* Give newly shown windows a chance to redraw */
2276 {
2278 }
2279 }
2280
2281 /* And last, send the WM_WINDOWPOSCHANGED message */
2282
2283 TRACE("\tstatus hwnd %p flags = %04x\n",Window?Window->head.h:NULL,WinPos.flags & SWP_AGG_STATUSFLAGS);
2284
2287 {
2288 /* WM_WINDOWPOSCHANGED is sent even if SWP_NOSENDCHANGING is set
2289 and always contains final window position.
2290 */
2291 WinPos.x = NewWindowRect.left;
2292 WinPos.y = NewWindowRect.top;
2293 WinPos.cx = NewWindowRect.right - NewWindowRect.left;
2294 WinPos.cy = NewWindowRect.bottom - NewWindowRect.top;
2295 TRACE("WM_WINDOWPOSCHANGED hwnd %p Flags %04x\n",WinPos.hwnd,WinPos.flags);
2297 }
2298
2299 if ( WinPos.flags & SWP_FRAMECHANGED || WinPos.flags & SWP_STATECHANGED ||
2300 !(WinPos.flags & SWP_NOCLIENTSIZE) || !(WinPos.flags & SWP_NOCLIENTMOVE) )
2301 {
2302 PWND pWnd = ValidateHwndNoErr(WinPos.hwnd);
2303 if (pWnd)
2304 IntNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, pWnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
2305 }
2306
2307 if(bPointerInWindow != IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y))
2308 {
2309 /* Generate mouse move message */
2310 MSG msg;
2311 msg.message = WM_MOUSEMOVE;
2312 msg.wParam = UserGetMouseButtonsState();
2313 msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
2314 msg.pt = gpsi->ptCursor;
2316 }
2317
2318 return TRUE;
2319}
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:732
#define msg(x)
Definition: auth_time.c:54
#define SWP_NOCLIENTSIZE
Definition: msg.h:29
#define SWP_NOCLIENTMOVE
Definition: msg.h:30
VOID FASTCALL DceResetActiveDCEs(PWND Window)
Definition: windc.c:816
PSERVERINFO gpsi
Definition: imm.c:18
#define ValidateHwndNoErr(hwnd)
Definition: precomp.h:84
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PagedPool
Definition: env_spec_w32.h:308
#define ERROR(name)
Definition: error_private.h:53
BOOL FASTCALL IntCheckFullscreen(PWND Window)
Definition: focus.c:79
VOID FASTCALL UpdateShellHook(PWND Window)
Definition: focus.c:99
GLbitfield flags
Definition: glext.h:7161
#define WNDS2_WIN31COMPAT
Definition: ntuser.h:644
#define WNDS_BEINGACTIVATED
Definition: ntuser.h:620
#define WNDS_SENDNCPAINT
Definition: ntuser.h:611
#define WEF_SETBYWNDPTI
Definition: ntuser.h:235
#define HRGN_WINDOW
Definition: ntuser.h:356
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
static HDC
Definition: imagelist.c:92
#define SWP_STATECHANGED
Definition: msg.c:42
VOID FASTCALL co_MsqInsertMouseMessage(MSG *Msg, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook)
Definition: msgqueue.c:580
@ WM_ASYNC_SETWINDOWPOS
Definition: msgqueue.h:118
__kernel_entry W32KAPI BOOL APIENTRY NtGdiBitBlt(_In_ HDC hdcDst, _In_ INT x, _In_ INT y, _In_ INT cx, _In_ INT cy, _In_opt_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ DWORD rop4, _In_ DWORD crBackColor, _In_ FLONG fl)
__kernel_entry W32KAPI HRGN APIENTRY NtGdiCreateRectRgn(_In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
__kernel_entry W32KAPI INT APIENTRY NtGdiOffsetRgn(_In_ HRGN hrgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:3980
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
static BOOL FASTCALL co_WinPosDoWinPosChanging(PWND Window, PWINDOWPOS WinPos, PRECTL WindowRect, PRECTL ClientRect)
Definition: winpos.c:1266
static BOOL FASTCALL WinPosFixupFlags(WINDOWPOS *WinPos, PWND Wnd)
Definition: winpos.c:1550
VOID ForceNCPaintErase(PWND Wnd, HRGN hRgn, PREGION pRgn)
Definition: winpos.c:1690
#define SWP_AGG_STATUSFLAGS
Definition: winpos.c:23
static VOID FASTCALL WinPosInternalMoveWindow(PWND Window, INT MoveX, INT MoveY)
Definition: winpos.c:1520
static BOOL IntValidateParent(PWND Child, PREGION ValidateRgn)
Definition: winpos.c:1056
#define SWP_AGG_NOCLIENTCHANGE
Definition: winpos.c:25
static HWND FASTCALL WinPosDoOwnedPopups(PWND Window, HWND hWndInsertAfter)
Definition: winpos.c:1354
#define SWP_AGG_NOGEOMETRYCHANGE
Definition: winpos.c:19
#define SWP_AGG_NOPOSCHANGE
Definition: winpos.c:21
VOID SelectWindowRgn(PWND Window, HRGN hRgnClip)
Definition: winpos.c:258
static LONG FASTCALL co_WinPosDoNCCALCSize(PWND Window, PWINDOWPOS WinPos, RECTL *WindowRect, RECTL *ClientRect, RECTL *validRects)
Definition: winpos.c:1179
#define RDW_CLIPCHILDREN
Definition: painting.h:15
#define WS_SIZEBOX
Definition: pedump.c:642
#define WS_EX_TOPMOST
Definition: pedump.c:647
#define WS_EX_TRANSPARENT
Definition: pedump.c:649
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
#define WS_CLIPCHILDREN
Definition: pedump.c:619
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:586
_Out_opt_ int * cx
Definition: commctrl.h:585
long top
Definition: polytest.cpp:53
Definition: region.h:8
HWND hwnd
Definition: winuser.h:3578
UINT flags
Definition: winuser.h:3584
HWND hwndInsertAfter
Definition: winuser.h:3579
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
uint32_t ULONG
Definition: typedefs.h:59
#define DCX_KEEPCLIPRGN
Definition: undocuser.h:68
VOID FASTCALL UserSyncAndPaintWindows(PWND pWnd, ULONG Flags)
Definition: painting.c:620
VOID FASTCALL IntSendNCPaint(PWND pWnd, HRGN hRgn)
Definition: painting.c:348
VOID FASTCALL co_IntPaintWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
Definition: painting.c:403
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:888
VOID FASTCALL IntInvalidateWindows(PWND Wnd, PREGION Rgn, ULONG Flags)
Definition: painting.c:642
HWND FASTCALL UserGetShellWindow(VOID)
Definition: window.c:3679
INT FASTCALL UserReleaseDC(PWND Window, HDC hDc, BOOL EndPaint)
Definition: windc.c:918
HDC FASTCALL UserGetDCEx(PWND Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
PREGION FASTCALL VIS_ComputeVisibleRegion(PWND Wnd, BOOLEAN ClientArea, BOOLEAN ClipChildren, BOOLEAN ClipSiblings)
Definition: vis.c:13
VOID FASTCALL co_VIS_WindowLayoutChanged(PWND Wnd, PREGION NewlyExposed)
Definition: vis.c:145
BOOL NTAPI GreDeleteObject(HGDIOBJ hobj)
Definition: gdiobj.c:1158
INT FASTCALL REGION_Complexity(PREGION prgn)
Definition: region.c:564
VOID FASTCALL REGION_Delete(PREGION pRgn)
Definition: region.c:2465
PREGION FASTCALL REGION_LockRgn(_In_ HRGN hrgn)
Definition: region.c:2374
VOID FASTCALL REGION_UnlockRgn(_In_ PREGION prgn)
Definition: region.c:2389
INT FASTCALL REGION_GetRgnBox(PREGION Rgn, PRECTL pRect)
Definition: region.c:2559
PREGION FASTCALL IntSysCreateRectpRgn(INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
Definition: region.c:2423
BOOL FASTCALL REGION_bOffsetRgn(_Inout_ PREGION prgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:2724
INT FASTCALL IntGdiCombineRgn(PREGION prgnDest, PREGION prgnSrc1, PREGION prgnSrc2, INT iCombineMode)
Definition: region.c:2503
HWND FASTCALL IntGetDesktopWindow(VOID)
Definition: desktop.c:1374
VOID co_IntShellHookNotify(WPARAM Message, WPARAM wParam, LPARAM lParam)
Definition: desktop.c:1692
VOID FASTCALL IntNotifyWinEvent(DWORD Event, PWND pWnd, LONG idObject, LONG idChild, DWORD flags)
Definition: event.c:179
WORD FASTCALL UserGetMouseButtonsState(VOID)
Definition: mouse.c:22
#define USERTAG_SWP
Definition: tags.h:281
BOOL FASTCALL IntIsWindow(HWND hWnd)
Definition: window.c:188
VOID FASTCALL IntLinkHwnd(PWND Wnd, HWND hWndPrev)
Definition: window.c:980
#define OBJID_WINDOW
Definition: winable.h:15
#define CHILDID_SELF
Definition: winable.h:14
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:28
LONG_PTR LRESULT
Definition: windef.h:209
#define CopyRgn(hrgnDst, hrgnSrc)
Definition: windowsx.h:73
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881
#define RGN_DIFF
Definition: wingdi.h:358
#define NULLREGION
Definition: wingdi.h:361
#define RGN_COPY
Definition: wingdi.h:357
#define RGN_AND
Definition: wingdi.h:356
#define SRCCOPY
Definition: wingdi.h:333
FORCEINLINE BOOL IntPtInWindow(PWND pwnd, INT x, INT y)
Definition: winpos.h:30
BOOL WINAPI CopyRect(_Out_ LPRECT, _In_ LPCRECT)
#define SWP_NOREDRAW
Definition: winuser.h:1236
#define SWP_FRAMECHANGED
Definition: winuser.h:1230
#define MAKELPARAM(l, h)
Definition: winuser.h:3998
#define DCX_CACHE
Definition: winuser.h:2104
#define DCX_WINDOW
Definition: winuser.h:2103
#define HSHELL_WINDOWDESTROYED
Definition: winuser.h:1246
#define WM_CHILDACTIVATE
Definition: winuser.h:1628
#define WS_EX_APPWINDOW
Definition: winuser.h:383
#define HSHELL_WINDOWCREATED
Definition: winuser.h:1245
#define SWP_NOMOVE
Definition: winuser.h:1234
#define RDW_NOINTERNALPAINT
Definition: winuser.h:1207
#define GA_PARENT
Definition: winuser.h:2778
#define SWP_NOSIZE
Definition: winuser.h:1235
#define WM_MOUSEMOVE
Definition: winuser.h:1765
#define RDW_ERASE
Definition: winuser.h:1201
#define RDW_NOCHILDREN
Definition: winuser.h:1212
#define SWP_DEFERERASE
Definition: winuser.h:1242
#define DCX_CLIPSIBLINGS
Definition: winuser.h:2106
#define DCX_INTERSECTRGN
Definition: winuser.h:2112
#define WVR_REDRAW
Definition: winuser.h:2511
#define RDW_ALLCHILDREN
Definition: winuser.h:1211
#define RDW_ERASENOW
Definition: winuser.h:1209
#define RDW_FRAME
Definition: winuser.h:1202
#define SWP_SHOWWINDOW
Definition: winuser.h:1238
#define SWP_HIDEWINDOW
Definition: winuser.h:1231
#define RDW_NOFRAME
Definition: winuser.h:1206
#define RDW_NOERASE
Definition: winuser.h:1205
#define RDW_VALIDATE
Definition: winuser.h:1208
#define WM_WINDOWPOSCHANGED
Definition: winuser.h:1652
#define RDW_INVALIDATE
Definition: winuser.h:1204

Referenced by co_IntSendActivateMessages(), co_IntSetForegroundMessageQueue(), co_IntSetParent(), co_IntShowDesktop(), co_UserCreateWindowEx(), co_UserDestroyWindow(), co_UserShowScrollBar(), co_WinPosArrangeIconicWindows(), co_WinPosShowWindow(), DefWndDoSizeMove(), DefWndHandleSetCursor(), DesktopWindowProc(), handle_internal_message(), IntActivateWindow(), IntDefWindowProc(), IntEndDeferWindowPosEx(), IntSetWindowPlacement(), IntUpdateLayeredWindowI(), MENU_ShowPopup(), NC_HandleNCLButtonDblClk(), NtUserCallHwndLock(), NtUserCallTwoParam(), NtUserSetMenu(), NtUserSetShellWindowEx(), NtUserSetWindowPos(), NtUserSetWindowRgn(), SpiNotifyNCMetricsChanged(), and WinPosDoOwnedPopups().

◆ co_WinPosShowWindow()

BOOLEAN FASTCALL co_WinPosShowWindow ( PWND  Window,
INT  Cmd 
)

Definition at line 2522 of file winpos.c.

2523{
2524 BOOLEAN WasVisible;
2525 UINT Swp = 0, EventMsg = 0;
2526 RECTL NewPos = {0, 0, 0, 0};
2527 BOOLEAN ShowFlag;
2528 LONG style;
2529 PWND Parent;
2530 PTHREADINFO pti;
2531 //HRGN VisibleRgn;
2532 BOOL ShowOwned = FALSE;
2533 BOOL FirstTime = FALSE;
2534 ASSERT_REFS_CO(Wnd);
2535 //KeRosDumpStackFrames(NULL, 20);
2537 WasVisible = (Wnd->style & WS_VISIBLE) != 0;
2538 style = Wnd->style;
2539
2540 TRACE("co_WinPosShowWindow START hwnd %p Cmd %d usicmd %u\n",
2541 Wnd->head.h, Cmd, pti->ppi->usi.wShowWindow);
2542
2543 if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
2544 {
2545 if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD)
2546 {
2547 if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
2548 {
2549 if (Wnd->spwndOwner == NULL)
2550 {
2551 if ( Cmd == SW_SHOWNORMAL || Cmd == SW_SHOW)
2552 {
2554 }
2555 FirstTime = TRUE;
2556 TRACE("co_WPSW FT 1\n");
2557 }
2558 }
2559 }
2560 }
2561
2562 if ( Cmd == SW_SHOWDEFAULT )
2563 {
2564 if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
2565 {
2566 Cmd = pti->ppi->usi.wShowWindow;
2567 FirstTime = TRUE;
2568 TRACE("co_WPSW FT 2\n");
2569 }
2570 }
2571
2572 if (FirstTime)
2573 {
2575 }
2576
2577 switch (Cmd)
2578 {
2579 case SW_HIDE:
2580 {
2581 if (!WasVisible)
2582 {
2583 //ERR("co_WinPosShowWindow Exit Bad\n");
2584 return FALSE;
2585 }
2587 if (Wnd != pti->MessageQueue->spwndActive)
2589 break;
2590 }
2591
2592 case SW_FORCEMINIMIZE: /* FIXME: Does not work if thread is hung. */
2593 case SW_SHOWMINNOACTIVE:
2595 /* Fall through. */
2596 case SW_SHOWMINIMIZED:
2597 case SW_MINIMIZE: /* CORE-15669: SW_MINIMIZE also shows */
2598 Swp |= SWP_SHOWWINDOW;
2599 {
2600 Swp |= SWP_NOACTIVATE;
2601 if (!(style & WS_MINIMIZE))
2602 {
2604 // Fix wine Win test_SetFocus todo #1 & #2,
2605 if (Cmd == SW_SHOWMINIMIZED)
2606 {
2607 //ERR("co_WinPosShowWindow Set focus 1\n");
2608 if ((style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
2609 co_UserSetFocus(Wnd->spwndParent);
2610 else
2611 co_UserSetFocus(0);
2612 }
2613
2614 Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
2615
2616 EventMsg = EVENT_SYSTEM_MINIMIZESTART;
2617 }
2618 else
2619 {
2620 if (WasVisible)
2621 {
2622 //ERR("co_WinPosShowWindow Exit Good\n");
2623 return TRUE;
2624 }
2625 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2626 }
2627 break;
2628 }
2629
2630 case SW_SHOWMAXIMIZED:
2631 {
2632 Swp |= SWP_SHOWWINDOW;
2633 if (!(style & WS_MAXIMIZE))
2634 {
2635 ShowOwned = TRUE;
2636
2637 Swp |= co_WinPosMinMaximize(Wnd, SW_MAXIMIZE, &NewPos);
2638
2639 EventMsg = EVENT_SYSTEM_MINIMIZEEND;
2640 }
2641 else
2642 {
2643 if (WasVisible)
2644 {
2645 //ERR("co_WinPosShowWindow Exit Good 1\n");
2646 return TRUE;
2647 }
2648 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2649 }
2650 break;
2651 }
2652
2653 case SW_SHOWNA:
2655 if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOZORDER;
2656 break;
2657 case SW_SHOW:
2658 if (WasVisible) return(TRUE); // Nothing to do!
2660 /* Don't activate the topmost window. */
2661 if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2662 break;
2663
2664 case SW_SHOWNOACTIVATE:
2666 /* Fall through. */
2667 case SW_SHOWNORMAL:
2668 case SW_SHOWDEFAULT:
2669 case SW_RESTORE:
2670 if (!WasVisible) Swp |= SWP_SHOWWINDOW;
2671 if (style & (WS_MINIMIZE | WS_MAXIMIZE))
2672 {
2673 Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
2674 if (style & WS_MINIMIZE) EventMsg = EVENT_SYSTEM_MINIMIZEEND;
2675 }
2676 else
2677 {
2678 if (WasVisible)
2679 {
2680 //ERR("co_WinPosShowWindow Exit Good 3\n");
2681 return TRUE;
2682 }
2683 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2684 }
2685 if ( style & WS_CHILD &&
2686 !(Wnd->ExStyle & WS_EX_MDICHILD) &&
2687 !(Swp & SWP_STATECHANGED))
2689 break;
2690
2691 default:
2692 //ERR("co_WinPosShowWindow Exit Good 4\n");
2693 return FALSE;
2694 }
2695
2696 ShowFlag = (Cmd != SW_HIDE);
2697
2698 if ((ShowFlag != WasVisible || Cmd == SW_SHOWNA) && Cmd != SW_SHOWMAXIMIZED && !(Swp & SWP_STATECHANGED))
2699 {
2700 co_IntSendMessageNoWait(Wnd->head.h, WM_SHOWWINDOW, ShowFlag, 0);
2701#if 0 // Fix wine msg test_SetParent:WmSetParentSeq_1:2
2702 if (!(Wnd->state2 & WNDS2_WIN31COMPAT)) // <------------- XP sets this bit!
2703 co_IntSendMessageNoWait(Wnd->head.h, WM_SETVISIBLE, ShowFlag, 0);
2704#endif
2705 if (!VerifyWnd(Wnd)) return WasVisible;
2706 }
2707
2708 /* We can't activate a child window */
2709 if ((Wnd->style & WS_CHILD) &&
2710 !(Wnd->ExStyle & WS_EX_MDICHILD) &&
2711 Cmd != SW_SHOWNA)
2712 {
2713 //ERR("SWP Child No active and ZOrder\n");
2715 }
2716
2717#if 0 // Explorer issues with common controls? Someone does not know how CS_SAVEBITS works.
2718 // Breaks startup and shutdown active window...
2719 if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
2720 Wnd->pcls->style & CS_SAVEBITS &&
2721 ((Cmd == SW_SHOW) || (Cmd == SW_NORMAL)))
2722 {
2723 ERR("WinPosShowWindow Set active\n");
2724 //UserSetActiveWindow(Wnd);
2725 co_IntSetForegroundWindow(Wnd); // HACK
2727 }
2728#endif
2729
2730 if (IsChildVisible(Wnd) || Swp & SWP_STATECHANGED)
2731 {
2732 TRACE("Child is Vis %s or State changed %s. ShowFlag %s Swp %04x\n",
2733 (IsChildVisible(Wnd) ? "TRUE" : "FALSE"), (Swp & SWP_STATECHANGED ? "TRUE" : "FALSE"),
2734 (ShowFlag ? "TRUE" : "FALSE"),LOWORD(Swp));
2736 0 != (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOPMOST : HWND_TOP,
2737 NewPos.left,
2738 NewPos.top,
2739 NewPos.right, // NewPos.right - NewPos.left, when minimized and restore, the window becomes smaller.
2740 NewPos.bottom,// NewPos.bottom - NewPos.top,
2741 LOWORD(Swp));
2742 }
2743 else
2744 {
2745 TRACE("Parent Vis?\n");
2746 /* if parent is not visible simply toggle WS_VISIBLE and return */
2747 if (ShowFlag) IntSetStyle( Wnd, WS_VISIBLE, 0 );
2748 else IntSetStyle( Wnd, 0, WS_VISIBLE );
2749 }
2750
2751 if ( EventMsg ) IntNotifyWinEvent(EventMsg, Wnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
2752
2753 if ( ShowOwned ) IntShowOwnedPopups(Wnd, TRUE );
2754
2755 if ((Cmd == SW_HIDE) || (Cmd == SW_MINIMIZE))
2756 {
2757 if ( Wnd == pti->MessageQueue->spwndActive && pti->MessageQueue == IntGetFocusMessageQueue() )
2758 {
2759 if (UserIsDesktopWindow(Wnd->spwndParent))
2760 {
2761 if (!ActivateOtherWindowMin(Wnd))
2762 {
2764 }
2765 }
2766 else
2767 {
2769 }
2770 }
2771
2772 /* Revert focus to parent */
2773 if (Wnd == pti->MessageQueue->spwndFocus)
2774 {
2775 Parent = Wnd->spwndParent;
2776 if (UserIsDesktopWindow(Wnd->spwndParent))
2777 Parent = 0;
2779 }
2780 // Hide, just return.
2781 if (Cmd == SW_HIDE) return WasVisible;
2782 }
2783
2784 /* FIXME: Check for window destruction. */
2785
2786 if ((Wnd->state & WNDS_SENDSIZEMOVEMSGS) &&
2787 !(Wnd->state2 & WNDS2_INDESTROY))
2788 {
2790 }
2791
2792 /* if previous state was minimized Windows sets focus to the window */
2793 if (style & WS_MINIMIZE)
2794 {
2795 co_UserSetFocus(Wnd);
2796 // Fix wine Win test_SetFocus todo #3,
2798 }
2799 //ERR("co_WinPosShowWindow EXIT\n");
2800 return WasVisible;
2801}
unsigned char BOOLEAN
#define ERR(fmt,...)
Definition: debug.h:110
HWND FASTCALL co_UserSetFocus(PWND Window)
Definition: focus.c:1314
#define WNDS2_INDESTROY
Definition: ntuser.h:643
#define WNDS_SENDSIZEMOVEMSGS
Definition: ntuser.h:604
unsigned int UINT
Definition: ndis.h:50
UINT FASTCALL co_WinPosMinMaximize(PWND Wnd, UINT ShowFlag, RECT *NewPos)
Definition: winpos.c:2371
VOID FASTCALL co_WinPosActivateOtherWindow(PWND Wnd)
Definition: winpos.c:396
BOOL FASTCALL IsChildVisible(PWND pWnd)
Definition: winpos.c:225
BOOL FASTCALL ActivateOtherWindowMin(PWND Wnd)
Definition: winpos.c:284
void FASTCALL co_WinPosSendSizeMove(PWND Wnd)
Definition: winpos.c:2337
#define LOWORD(l)
Definition: pedump.c:82
@ Cmd
Definition: sacdrv.h:278
USERSTARTUPINFO usi
Definition: win32.h:278
PPROCESSINFO ppi
Definition: win32.h:88
WORD wShowWindow
Definition: win32.h:219
#define WM_SETVISIBLE
Definition: undocuser.h:31
PUSER_MESSAGE_QUEUE FASTCALL IntGetFocusMessageQueue(VOID)
Definition: desktop.c:1307
ULONG FASTCALL IntSetStyle(PWND pwnd, ULONG set_bits, ULONG clear_bits)
Definition: window.c:155
BOOL FASTCALL IntShowOwnedPopups(PWND OwnerWnd, BOOL fShow)
Definition: window.c:4660
#define STARTF_USEPOSITION
Definition: winbase.h:493
#define STARTF_USESHOWWINDOW
Definition: winbase.h:491
#define STARTF_USESIZE
Definition: winbase.h:492
#define SW_SHOWNORMAL
Definition: winuser.h:764
#define SW_SHOWMAXIMIZED
Definition: winuser.h:767
#define SW_HIDE
Definition: winuser.h:762
#define HWND_TOPMOST
Definition: winuser.h:1198
#define SW_MINIMIZE
Definition: winuser.h:770
#define SW_SHOWNOACTIVATE
Definition: winuser.h:768
#define WM_ACTIVATE
Definition: winuser.h:1602
#define WM_SHOWWINDOW
Definition: winuser.h:1618
#define SW_SHOWDEFAULT
Definition: winuser.h:774
#define SW_SHOWMINIMIZED
Definition: winuser.h:765
#define SW_FORCEMINIMIZE
Definition: winuser.h:775
#define HWND_TOP
Definition: winuser.h:1197
#define WS_EX_MDICHILD
Definition: winuser.h:394
#define SW_SHOWNA
Definition: winuser.h:772
#define WA_ACTIVE
Definition: winuser.h:2613
#define CS_SAVEBITS
Definition: winuser.h:652
#define SW_RESTORE
Definition: winuser.h:773
#define SW_SHOW
Definition: winuser.h:769
#define SW_MAXIMIZE
Definition: winuser.h:766
#define SW_NORMAL
Definition: winuser.h:763
#define SW_SHOWMINNOACTIVE
Definition: winuser.h:771

Referenced by co_IntSetParent(), co_UserCreateWindowEx(), co_UserDestroyWindow(), co_UserShowScrollBar(), DefWndHandleSysCommand(), handle_internal_message(), IntDefWindowProc(), IntSetWindowPlacement(), NtUserMinMaximize(), and NtUserShowWindow().

◆ co_WinPosWindowFromPoint()

PWND APIENTRY co_WinPosWindowFromPoint ( IN PWND  ScopeWin,
IN POINT WinPoint,
IN OUT USHORT HitTest,
IN BOOL  Ignore 
)

Definition at line 2889 of file winpos.c.

2894{
2895 PWND Window;
2896 POINT Point = *WinPoint;
2898
2899 if( ScopeWin == NULL )
2900 {
2901 ScopeWin = UserGetDesktopWindow();
2902 if(ScopeWin == NULL)
2903 return NULL;
2904 }
2905
2906 *HitTest = HTNOWHERE;
2907
2908 ASSERT_REFS_CO(ScopeWin);
2909 UserRefObjectCo(ScopeWin, &Ref);
2910
2911 Window = co_WinPosSearchChildren(ScopeWin, &Point, HitTest, Ignore);
2912
2913 UserDerefObjectCo(ScopeWin);
2914 if (Window)
2916 ASSERT_REFS_CO(ScopeWin);
2917
2918 return Window;
2919}
static PWND co_WinPosSearchChildren(IN PWND ScopeWin, IN POINT *Point, IN OUT USHORT *HitTest, IN BOOL Ignore)
Definition: winpos.c:2804
#define HTNOWHERE
Definition: winuser.h:2464

Referenced by co_IntProcessMouseMessage(), and NtUserWindowFromPoint().

◆ IntClientToScreen()

BOOL FASTCALL IntClientToScreen ( PWND  Wnd,
LPPOINT  lpPoint 
)

Definition at line 198 of file winpos.c.

199{
200 if (Wnd && Wnd->fnid != FNID_DESKTOP )
201 {
202 if (Wnd->ExStyle & WS_EX_LAYOUTRTL)
203 lpPoint->x = Wnd->rcClient.right - lpPoint->x;
204 else
205 lpPoint->x += Wnd->rcClient.left;
206 lpPoint->y += Wnd->rcClient.top;
207 }
208 return TRUE;
209}
#define FNID_DESKTOP
Definition: ntuser.h:857
DWORD fnid
Definition: ntuser.h:704
RECT rcClient
Definition: ntuser.h:712
#define WS_EX_LAYOUTRTL
Definition: winuser.h:390

Referenced by IntDefWindowProc(), NC_GetSysPopupPos(), and WinPosFixupFlags().

◆ IntEqualRect()

FORCEINLINE BOOL IntEqualRect ( RECTL lprc1,
RECTL lprc2 
)

Definition at line 48 of file winpos.h.

49{
50 if (lprc1 == NULL || lprc2 == NULL)
51 return FALSE;
52
53 return (lprc1->left == lprc2->left) && (lprc1->top == lprc2->top) &&
54 (lprc1->right == lprc2->right) && (lprc1->bottom == lprc2->bottom);
55}

Referenced by DefWndDoSizeMove(), IntDefWindowProc(), IntGetNCUpdateRgn(), and NC_DoNCPaint().

◆ IntGetClientOrigin()

BOOL FASTCALL IntGetClientOrigin ( PWND  Window,
LPPOINT  Point 
)

Definition at line 70 of file winpos.c.

71{
73 if (Window == NULL)
74 {
75 Point->x = Point->y = 0;
76 return FALSE;
77 }
78 Point->x = Window->rcClient.left;
79 Point->y = Window->rcClient.top;
80
81 return TRUE;
82}

Referenced by co_IntFixCaret(), and IntScrollWindowEx().

◆ IntGetWindowRect()

BOOL FASTCALL IntGetWindowRect ( PWND  Wnd,
RECTL Rect 
)

Definition at line 120 of file winpos.c.

121{
122 ASSERT( Wnd );
123 ASSERT( Rect );
124 if (!Wnd) return FALSE;
125 if (!UserIsDesktopWindow(Wnd))
126 {
127 *Rect = Wnd->rcWindow;
128 }
129 else
130 {
131 Rect->left = Rect->top = 0;
132 Rect->right = Wnd->rcWindow.right;
133 Rect->bottom = Wnd->rcWindow.bottom;
134/* Do this until Init bug is fixed. This sets 640x480, see InitMetrics.
135 Rect->right = GetSystemMetrics(SM_CXSCREEN);
136 Rect->bottom = GetSystemMetrics(SM_CYSCREEN);
137*/ }
138 return TRUE;
139}
#define ASSERT(a)
Definition: mode.c:44
RECT rcWindow
Definition: ntuser.h:711

Referenced by DefWndScreenshot(), IntGetNCUpdateRgn(), IntIsWindowFullscreen(), MENU_FindItemByCoords(), MENU_ShowSubPopup(), NC_DoNCPaint(), NC_GetSysPopupPos(), UserDrawCaptionBar(), and UserDrawCaptionButtonWnd().

◆ IntPtInWindow()

FORCEINLINE BOOL IntPtInWindow ( PWND  pwnd,
INT  x,
INT  y 
)

Definition at line 30 of file winpos.h.

31{
32 if(!RECTL_bPointInRect(&pwnd->rcWindow, x, y))
33 {
34 return FALSE;
35 }
36
37 if(!pwnd->hrgnClip || pwnd->style & WS_MINIMIZE)
38 {
39 return TRUE;
40 }
41
42 return NtGdiPtInRegion(pwnd->hrgnClip,
43 x - pwnd->rcWindow.left,
44 y - pwnd->rcWindow.top);
45}
__kernel_entry W32KAPI BOOL APIENTRY NtGdiPtInRegion(_In_ HRGN hrgn, _In_ INT x, _In_ INT y)
Definition: region.c:4015
HRGN hrgnClip
Definition: ntuser.h:728
FORCEINLINE BOOL RECTL_bPointInRect(_In_ const RECTL *prcl, _In_ INT x, _In_ INT y)
Definition: rect.h:52

Referenced by co_WinPosSearchChildren(), co_WinPosSetWindowPos(), IntChildWindowFromPointEx(), IntRealChildWindowFromPoint(), and IntTopLevelWindowFromPoint().

◆ IntRealChildWindowFromPoint()

PWND FASTCALL IntRealChildWindowFromPoint ( PWND  Parent,
LONG  x,
LONG  y 
)

Definition at line 2922 of file winpos.c.

2923{
2924 POINTL Pt;
2925 HWND *List, *phWnd;
2926 PWND pwndHit = NULL;
2927
2928 Pt.x = x;
2929 Pt.y = y;
2930
2932 {
2933 Pt.x += Parent->rcClient.left;
2934 Pt.y += Parent->rcClient.top;
2935 }
2936
2937 if (!IntPtInWindow(Parent, Pt.x, Pt.y)) return NULL;
2938
2940 {
2941 for (phWnd = List; *phWnd; phWnd++)
2942 {
2943 PWND Child;
2944 if ((Child = ValidateHwndNoErr(*phWnd)))
2945 {
2946 if ( Child->style & WS_VISIBLE && IntPtInWindow(Child, Pt.x, Pt.y) )
2947 {
2948 if ( Child->pcls->atomClassName != gpsi->atomSysClass[ICLS_BUTTON] ||
2949 (Child->style & BS_TYPEMASK) != BS_GROUPBOX )
2950 {
2952 return Child;
2953 }
2954 pwndHit = Child;
2955 }
2956 }
2957 }
2959 }
2960 return pwndHit ? pwndHit : Parent;
2961}
#define ICLS_BUTTON
Definition: ntuser.h:907
#define BS_GROUPBOX
Definition: pedump.c:658
LONG y
Definition: windef.h:330
LONG x
Definition: windef.h:329
ATOM atomSysClass[ICLS_NOTUSED+1]
Definition: ntuser.h:1055
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
#define USERTAG_WINDOWLIST
Definition: tags.h:298
HWND *FASTCALL IntWinListChildren(PWND Window)
Definition: window.c:286
#define BS_TYPEMASK
Definition: winuser.h:270

Referenced by NtUserRealChildWindowFromPoint().

◆ IntScreenToClient()

BOOL FASTCALL IntScreenToClient ( PWND  Wnd,
LPPOINT  lpPoint 
)

Definition at line 212 of file winpos.c.

213{
214 if (Wnd && Wnd->fnid != FNID_DESKTOP )
215 {
216 if (Wnd->ExStyle & WS_EX_LAYOUTRTL)
217 lpPoint->x = Wnd->rcClient.right - lpPoint->x;
218 else
219 lpPoint->x -= Wnd->rcClient.left;
220 lpPoint->y -= Wnd->rcClient.top;
221 }
222 return TRUE;
223}

Referenced by co_IntSetParent(), IntDefWindowProc(), and MENU_TrackMouseMenuBar().

◆ UserGetWindowBorders()

VOID UserGetWindowBorders ( DWORD  Style,
DWORD  ExStyle,
SIZE Size,
BOOL  WithClient 
)

Definition at line 887 of file winpos.c.

888{
889 DWORD Border = 0;
890
892 Border += 2;
894 Border += 1; /* for the outer frame always present */
895 if ((ExStyle & WS_EX_CLIENTEDGE) && WithClient)
896 Border += 2;
898 Border ++; /* The other border */
899 Size->cx = Size->cy = Border;
900 if ((Style & WS_THICKFRAME) && !(Style & WS_MINIMIZE)) /* The resize border */
901 {
904 }
907}
const DWORD Style
Definition: appswitch.c:71
const DWORD ExStyle
Definition: appswitch.c:72
BOOL UserHasWindowEdge(DWORD Style, DWORD ExStyle)
Definition: winpos.c:843
#define WS_EX_DLGMODALFRAME
Definition: pedump.c:645
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
#define WS_EX_STATICEDGE
Definition: winuser.h:403
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384

◆ UserHasWindowEdge()

BOOL UserHasWindowEdge ( DWORD  Style,
DWORD  ExStyle 
)

Definition at line 843 of file winpos.c.

844{
845 if (Style & WS_MINIMIZE)
846 return TRUE;
848 return TRUE;
850 return FALSE;
851 if (Style & WS_THICKFRAME)
852 return TRUE;
853 Style &= WS_CAPTION;
854 if (Style == WS_DLGFRAME || Style == WS_CAPTION)
855 return TRUE;
856 return FALSE;
857}

Referenced by UserGetWindowBorders().