ReactOS 0.4.15-dev-8408-g466a198
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 285 of file winpos.c.

286{
287 BOOL ActivePrev, FindTopWnd;
288 PWND pWndTopMost, pWndChild, pWndSetActive, pWndTemp, pWndDesk;
291
292 //ERR("AOWM 1 %p\n", UserHMGetHandle(Wnd));
293 ActivePrev = (pti->MessageQueue->spwndActivePrev != NULL);
294 FindTopWnd = TRUE;
295
296 if ((pWndTopMost = IntGetLastTopMostWindow()))
297 pWndChild = pWndTopMost->spwndNext;
298 else
299 pWndChild = Wnd->spwndParent->spwndChild;
300
301 for (;;)
302 {
303 if ( ActivePrev )
304 pWndSetActive = pti->MessageQueue->spwndActivePrev;
305 else
306 pWndSetActive = pWndChild;
307
308 pWndTemp = NULL;
309
310 while(pWndSetActive)
311 {
312 if ( VerifyWnd(pWndSetActive) &&
313 !(pWndSetActive->ExStyle & WS_EX_NOACTIVATE) &&
314 (pWndSetActive->style & (WS_VISIBLE|WS_DISABLED)) == WS_VISIBLE &&
315 (!(pWndSetActive->style & WS_ICONIC) /* FIXME MinMax pos? */ ) )
316 {
317 if (!(pWndSetActive->ExStyle & WS_EX_TOOLWINDOW) )
318 {
319 UserRefObjectCo(pWndSetActive, &Ref);
320 //ERR("ActivateOtherWindowMin Set FG 1\n");
321 co_IntSetForegroundWindow(pWndSetActive);
322 UserDerefObjectCo(pWndSetActive);
323 //ERR("AOWM 2 Exit Good %p\n", UserHMGetHandle(pWndSetActive));
324 return TRUE;
325 }
326 if (!pWndTemp ) pWndTemp = pWndSetActive;
327 }
328 if ( ActivePrev )
329 {
330 ActivePrev = FALSE;
331 pWndSetActive = pWndChild;
332 }
333 else
334 pWndSetActive = pWndSetActive->spwndNext;
335 }
336
337 if ( !FindTopWnd ) break;
338 FindTopWnd = FALSE;
339
340 if ( pWndChild )
341 {
342 pWndChild = pWndChild->spwndParent->spwndChild;
343 continue;
344 }
345
346 if (!(pWndDesk = IntGetThreadDesktopWindow(pti)))
347 {
348 pWndChild = NULL;
349 continue;
350 }
351 pWndChild = pWndDesk->spwndChild;
352 }
353
354 if ((pWndSetActive = pWndTemp))
355 {
356 UserRefObjectCo(pWndSetActive, &Ref);
357 //ERR("ActivateOtherWindowMin Set FG 2\n");
358 co_IntSetForegroundWindow(pWndSetActive);
359 UserDerefObjectCo(pWndSetActive);
360 //ERR("AOWM 3 Exit Good %p\n", UserHMGetHandle(pWndSetActive));
361 return TRUE;
362 }
363 //ERR("AOWM 4 Bad\n");
364 return FALSE;
365}
#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:1552
#define for
Definition: utility.h:88
PWND FASTCALL IntGetLastTopMostWindow(VOID)
Definition: winpos.c:238
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:694
DWORD ExStyle
Definition: ntuser.h:704
DWORD style
Definition: ntuser.h:706
struct _WND * spwndChild
Definition: ntuser.h:714
struct _WND * spwndNext
Definition: ntuser.h:711
struct _WND * spwndParent
Definition: ntuser.h:713
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 397 of file winpos.c.

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

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

◆ co_WinPosArrangeIconicWindows()

UINT FASTCALL co_WinPosArrangeIconicWindows ( PWND  parent)

Definition at line 731 of file winpos.c.

732{
733 RECTL rectParent;
734 PWND Child;
735 INT x, y, xspacing, yspacing, sx, sy;
736
738
739 IntGetClientRect( parent, &rectParent );
740 // FIXME: Support Minimize Metrics gspv.mm.iArrange.
741 // Default: ARW_BOTTOMLEFT
742 x = rectParent.left;
743 y = rectParent.bottom;
744
747
748 Child = parent->spwndChild;
749 while(Child)
750 {
751 if((Child->style & WS_MINIMIZE) != 0 )
752 {
754 UserRefObjectCo(Child, &Ref);
755
757 sy = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
758
759 Child->InternalPos.IconPos.x = sx;
760 Child->InternalPos.IconPos.y = sy;
761 Child->InternalPos.flags |= WPF_MININIT;
762
764
766
767 if (x <= rectParent.right - xspacing)
768 x += xspacing;
769 else
770 {
771 x = rectParent.left;
772 y -= yspacing;
773 }
774 }
775 Child = Child->spwndNext;
776 }
777 return yspacing;
778}
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:686
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1786
VOID FASTCALL IntGetClientRect(PWND Wnd, RECTL *Rect)
Definition: winpos.c:92
#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:214
#define SM_CXMINIMIZED
Definition: winuser.h:1020
#define SWP_NOACTIVATE
Definition: winuser.h:1242
#define SM_CYMINIMIZED
Definition: winuser.h:1021
#define SWP_ASYNCWINDOWPOS
Definition: winuser.h:1253
#define SM_CYBORDER
Definition: winuser.h:965
#define SWP_NOCOPYBITS
Definition: winuser.h:1243
#define SM_CXBORDER
Definition: winuser.h:964
#define SWP_NOZORDER
Definition: winuser.h:1247

Referenced by NtUserCallHwndLock().

◆ co_WinPosGetMinMaxInfo()

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

Definition at line 934 of file winpos.c.

936{
937 MINMAXINFO MinMax;
938 PMONITOR monitor;
939 INT xinc, yinc;
940 LONG style = Window->style;
941 LONG adjustedStyle;
942 LONG exstyle = Window->ExStyle;
943 RECT rc;
944 DWORD adjust;
945
947
948 /* Compute default values */
949
950 rc = Window->rcWindow;
951 MinMax.ptReserved.x = rc.left;
952 MinMax.ptReserved.y = rc.top;
953
954 if ((style & WS_CAPTION) == WS_CAPTION)
955 adjustedStyle = style & ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
956 else
957 adjustedStyle = style;
958
959 if (Window->spwndParent)
960 IntGetClientRect(Window->spwndParent, &rc);
961
962 adjust = IntGetWindowBorders(adjustedStyle, exstyle);
963
964 // Handle special case while maximized. CORE-15893
965 if ((adjustedStyle & WS_THICKFRAME) && !(adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
966 adjust += 1;
967
968 xinc = yinc = adjust;
969
970 if ((adjustedStyle & WS_THICKFRAME) && (adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
971 {
974 }
975
979
980 xinc = -rc.left;
981 yinc = -rc.top;
982
983 MinMax.ptMaxSize.x = rc.right - rc.left;
984 MinMax.ptMaxSize.y = rc.bottom - rc.top;
985 if (style & (WS_DLGFRAME | WS_BORDER))
986 {
989 }
990 else
991 {
992 MinMax.ptMinTrackSize.x = 2 * xinc;
993 MinMax.ptMinTrackSize.y = 2 * yinc;
994 }
997 MinMax.ptMaxPosition.x = -xinc;
998 MinMax.ptMaxPosition.y = -yinc;
999
1000 if (!EMPTYPOINT(Window->InternalPos.MaxPos)) MinMax.ptMaxPosition = Window->InternalPos.MaxPos;
1001
1003
1004 /* if the app didn't change the values, adapt them for the current monitor */
1005 if ((monitor = UserGetPrimaryMonitor()))
1006 {
1007 RECT rc_work;
1008
1009 rc_work = monitor->rcMonitor;
1010
1011 if (style & WS_MAXIMIZEBOX)
1012 {
1013 if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP)))
1014 rc_work = monitor->rcWork;
1015 }
1016
1017 if (MinMax.ptMaxSize.x == UserGetSystemMetrics(SM_CXSCREEN) + 2 * xinc &&
1018 MinMax.ptMaxSize.y == UserGetSystemMetrics(SM_CYSCREEN) + 2 * yinc)
1019 {
1020 MinMax.ptMaxSize.x = (rc_work.right - rc_work.left) + 2 * xinc;
1021 MinMax.ptMaxSize.y = (rc_work.bottom - rc_work.top) + 2 * yinc;
1022 }
1023 if (MinMax.ptMaxPosition.x == -xinc && MinMax.ptMaxPosition.y == -yinc)
1024 {
1025 MinMax.ptMaxPosition.x = rc_work.left - xinc;
1026 MinMax.ptMaxPosition.y = rc_work.top - yinc;
1027 }
1028 if (MinMax.ptMaxSize.x >= (monitor->rcMonitor.right - monitor->rcMonitor.left) &&
1029 MinMax.ptMaxSize.y >= (monitor->rcMonitor.bottom - monitor->rcMonitor.top) )
1030 {
1032 }
1033 else
1034 Window->state &= ~WNDS_MAXIMIZESTOMONITOR;
1035 }
1036
1037
1038 MinMax.ptMaxTrackSize.x = max(MinMax.ptMaxTrackSize.x,
1039 MinMax.ptMinTrackSize.x);
1040 MinMax.ptMaxTrackSize.y = max(MinMax.ptMaxTrackSize.y,
1041 MinMax.ptMinTrackSize.y);
1042
1043 if (MaxSize)
1044 *MaxSize = MinMax.ptMaxSize;
1045 if (MaxPos)
1046 *MaxPos = MinMax.ptMaxPosition;
1047 if (MinTrack)
1048 *MinTrack = MinMax.ptMinTrackSize;
1049 if (MaxTrack)
1050 *MaxTrack = MinMax.ptMaxTrackSize;
1051
1052 return 0; // FIXME: What does it return? Wine returns MINMAXINFO.
1053}
Arabic default style
Definition: afstyles.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define WNDS_MAXIMIZESTOMONITOR
Definition: ntuser.h:635
#define EMPTYPOINT(pt)
Definition: winpos.c:29
DWORD IntGetWindowBorders(DWORD Style, DWORD ExStyle)
Definition: winpos.c:915
#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:3629
POINT ptMaxSize
Definition: winuser.h:3628
POINT ptMinTrackSize
Definition: winuser.h:3630
POINT ptReserved
Definition: winuser.h:3627
POINT ptMaxTrackSize
Definition: winuser.h:3631
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:1445
PMONITOR NTAPI UserGetPrimaryMonitor(VOID)
Definition: monitor.c:102
LONG_PTR LPARAM
Definition: windef.h:208
#define SM_CYSCREEN
Definition: winuser.h:960
#define SM_CXMINTRACK
Definition: winuser.h:997
#define SM_CXFRAME
Definition: winuser.h:994
#define SM_CYFRAME
Definition: winuser.h:996
#define SM_CXMAXTRACK
Definition: winuser.h:1022
#define WM_GETMINMAXINFO
Definition: winuser.h:1640
#define SM_CYMAXTRACK
Definition: winuser.h:1023
#define SM_CXDLGFRAME
Definition: winuser.h:966
#define SM_CYDLGFRAME
Definition: winuser.h:968
#define SM_CXSCREEN
Definition: winuser.h:959
#define SM_CYMINTRACK
Definition: winuser.h:998

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 2381 of file winpos.c.

2382{
2383 RECTL Rect;
2384 LPARAM lParam;
2386
2387 IntGetClientRect(Wnd, &Rect);
2388 lParam = MAKELONG(Rect.right-Rect.left, Rect.bottom-Rect.top);
2389
2390 Wnd->state &= ~WNDS_SENDSIZEMOVEMSGS;
2391
2392 if (Wnd->style & WS_MAXIMIZE)
2393 {
2395 }
2396 else if (Wnd->style & WS_MINIMIZE)
2397 {
2399 lParam = 0;
2400 }
2401
2403
2404 if (UserIsDesktopWindow(Wnd->spwndParent))
2405 lParam = MAKELONG(Wnd->rcClient.left, Wnd->rcClient.top);
2406 else
2407 lParam = MAKELONG(Wnd->rcClient.left-Wnd->spwndParent->rcClient.left, Wnd->rcClient.top-Wnd->spwndParent->rcClient.top);
2408
2410
2412}
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
VOID FASTCALL IntEngWindowChanged(_In_ struct _WND *Window, _In_ FLONG flChanged)
#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:1713
#define WOC_RGN_CLIENT
Definition: winddi.h:1265
UINT_PTR WPARAM
Definition: windef.h:207
#define WM_SIZE
Definition: winuser.h:1611
#define SIZE_MINIMIZED
Definition: winuser.h:2506
#define SIZE_MAXIMIZED
Definition: winuser.h:2507
#define WM_MOVE
Definition: winuser.h:1610
#define SIZE_RESTORED
Definition: winuser.h:2505

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 1786 of file winpos.c.

1795{
1796 WINDOWPOS WinPos;
1797 RECTL NewWindowRect;
1798 RECTL NewClientRect;
1799 RECTL valid_rects[2];
1800 PREGION VisBefore = NULL;
1801 PREGION VisBeforeJustClient = NULL;
1802 PREGION VisAfter = NULL;
1804 ULONG WvrFlags = 0;
1805 RECTL OldWindowRect, OldClientRect;
1806 int RgnType;
1807 HDC Dc;
1809 PWND Ancestor;
1810 BOOL bPointerInWindow, PosChanged = FALSE;
1812
1814
1815 TRACE("pwnd %p, after %p, %d,%d (%dx%d), flags 0x%x\n",
1816 Window, WndInsertAfter, x, y, cx, cy, flags);
1817#if DBG
1818 dump_winpos_flags(flags);
1819#endif
1820
1821 /* FIXME: Get current active window from active queue. Why? since r2915. */
1822
1823 bPointerInWindow = IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y);
1824
1825 WinPos.hwnd = UserHMGetHandle(Window);
1826 WinPos.hwndInsertAfter = WndInsertAfter;
1827 WinPos.x = x;
1828 WinPos.y = y;
1829 WinPos.cx = cx;
1830 WinPos.cy = cy;
1831 WinPos.flags = flags;
1832
1833 if ( flags & SWP_ASYNCWINDOWPOS )
1834 {
1835 LRESULT lRes;
1837 if ( ppos )
1838 {
1839 WinPos.flags &= ~SWP_ASYNCWINDOWPOS; // Clear flag.
1840 *ppos = WinPos;
1841 /* Yes it's a pointer inside Win32k! */
1842 lRes = co_IntSendMessageNoWait( WinPos.hwnd, WM_ASYNC_SETWINDOWPOS, 0, (LPARAM)ppos);
1843 /* We handle this the same way as Event Hooks and Hooks. */
1844 if ( !lRes )
1845 {
1847 return FALSE;
1848 }
1849 return TRUE;
1850 }
1851 return FALSE;
1852 }
1853
1854 co_WinPosDoWinPosChanging(Window, &WinPos, &NewWindowRect, &NewClientRect);
1855
1856 /* Does the window still exist? */
1857 if (!IntIsWindow(WinPos.hwnd))
1858 {
1859 TRACE("WinPosSetWindowPos: Invalid handle 0x%p!\n",WinPos.hwnd);
1861 return FALSE;
1862 }
1863
1864 /* Fix up the flags. */
1865 if (!WinPosFixupFlags(&WinPos, Window))
1866 {
1867 // See Note.
1868 return TRUE;
1869 }
1870
1871 Ancestor = UserGetAncestor(Window, GA_PARENT);
1872 if ( (WinPos.flags & (SWP_NOZORDER | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) != SWP_NOZORDER &&
1873 Ancestor && UserHMGetHandle(Ancestor) == IntGetDesktopWindow() )
1874 {
1876 }
1877
1878 if (!(WinPos.flags & SWP_NOREDRAW))
1879 {
1880 /* Compute the visible region before the window position is changed */
1881 if (!(WinPos.flags & SWP_SHOWWINDOW) &&
1882 (WinPos.flags & (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1885 {
1887 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1888
1889 if ( VisBefore != NULL &&
1890 REGION_Complexity(VisBefore) == NULLREGION )
1891 {
1892 REGION_Delete(VisBefore);
1893 VisBefore = NULL;
1894 }
1895 else if(VisBefore)
1896 {
1897 REGION_bOffsetRgn(VisBefore, -Window->rcWindow.left, -Window->rcWindow.top);
1898 }
1899
1900 /* Calculate the non client area for resizes, as this is used in the copy region */
1901 if ((WinPos.flags & (SWP_NOSIZE | SWP_FRAMECHANGED)) != SWP_NOSIZE)
1902 {
1903 VisBeforeJustClient = VIS_ComputeVisibleRegion(Window, TRUE, FALSE,
1904 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1905
1906 if ( VisBeforeJustClient != NULL &&
1907 REGION_Complexity(VisBeforeJustClient) == NULLREGION )
1908 {
1909 REGION_Delete(VisBeforeJustClient);
1910 VisBeforeJustClient = NULL;
1911 }
1912 else if(VisBeforeJustClient)
1913 {
1914 REGION_bOffsetRgn(VisBeforeJustClient, -Window->rcWindow.left, -Window->rcWindow.top);
1915 }
1916 }
1917 }
1918 }
1919
1921 if (Window->hrgnNewFrame)
1922 {
1923 SelectWindowRgn( Window, Window->hrgnNewFrame ); // Should be PSMWP->acvr->hrgnClip
1924 Window->hrgnNewFrame = NULL;
1925 }
1926
1927 WvrFlags = co_WinPosDoNCCALCSize(Window, &WinPos, &NewWindowRect, &NewClientRect, valid_rects);
1928
1929// ERR("co_WinPosDoNCCALCSize returned 0x%x\n valid dest: %d %d %d %d\n valid src : %d %d %d %d\n", WvrFlags,
1930// valid_rects[0].left,valid_rects[0].top,valid_rects[0].right,valid_rects[0].bottom,
1931// valid_rects[1].left,valid_rects[1].top,valid_rects[1].right,valid_rects[1].bottom);
1932
1933 /* Validate link windows. (also take into account shell window in hwndShellWindow) */
1934 if (!(WinPos.flags & SWP_NOZORDER) && WinPos.hwnd != UserGetShellWindow())
1935 {
1937 }
1938
1939 OldWindowRect = Window->rcWindow;
1940 OldClientRect = Window->rcClient;
1941
1942 if (NewClientRect.left != OldClientRect.left ||
1943 NewClientRect.top != OldClientRect.top)
1944 {
1945 // Move child window if their parent is moved. Keep Child window relative to Parent...
1947 NewClientRect.left - OldClientRect.left,
1948 NewClientRect.top - OldClientRect.top);
1949 PosChanged = TRUE;
1950 }
1951
1952 Window->rcWindow = NewWindowRect;
1953 Window->rcClient = NewClientRect;
1954
1955 /* erase parent when hiding or resizing child */
1956 if (WinPos.flags & SWP_HIDEWINDOW)
1957 {
1958 /* Clear the update region */
1960 NULL,
1961 0,
1963
1964 if (UserIsDesktopWindow(Window->spwndParent))
1966
1967 Window->style &= ~WS_VISIBLE; //IntSetStyle( Window, 0, WS_VISIBLE );
1968 Window->head.pti->cVisWindows--;
1970 }
1971 else if (WinPos.flags & SWP_SHOWWINDOW)
1972 {
1973 if (Window->style & WS_CHILD)
1974 {
1975 if ((Window->style & WS_POPUP) && (Window->ExStyle & WS_EX_APPWINDOW))
1976 {
1978 if (!(WinPos.flags & SWP_NOACTIVATE))
1980 }
1981 }
1982 else if ((Window->ExStyle & WS_EX_APPWINDOW) ||
1983 (!(Window->ExStyle & WS_EX_TOOLWINDOW) && !Window->spwndOwner &&
1984 (!Window->spwndParent || UserIsDesktopWindow(Window->spwndParent))))
1985 {
1987 {
1989 if (!(WinPos.flags & SWP_NOACTIVATE))
1991 }
1992 }
1993
1994 Window->style |= WS_VISIBLE; //IntSetStyle( Window, WS_VISIBLE, 0 );
1995 Window->head.pti->cVisWindows++;
1997 }
1998 else
1999 {
2001 }
2002
2003 if (Window->hrgnUpdate != NULL && Window->hrgnUpdate != HRGN_WINDOW)
2004 {
2005 NtGdiOffsetRgn(Window->hrgnUpdate,
2006 NewWindowRect.left - OldWindowRect.left,
2007 NewWindowRect.top - OldWindowRect.top);
2008 }
2009
2010 DceResetActiveDCEs(Window); // For WS_VISIBLE changes.
2011
2012 // Change or update, set send non-client paint flag.
2013 if ( Window->style & WS_VISIBLE &&
2014 (WinPos.flags & SWP_STATECHANGED || (!(Window->state2 & WNDS2_WIN31COMPAT) && WinPos.flags & SWP_NOREDRAW ) ) )
2015 {
2016 TRACE("Set WNDS_SENDNCPAINT %p\n",Window);
2017 Window->state |= WNDS_SENDNCPAINT;
2018 }
2019
2020 if (!(WinPos.flags & SWP_NOREDRAW) && ((WinPos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE))
2021 {
2022 /* Determine the new visible region */
2024 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
2025
2026 if ( VisAfter != NULL &&
2027 REGION_Complexity(VisAfter) == NULLREGION )
2028 {
2029 REGION_Delete(VisAfter);
2030 VisAfter = NULL;
2031 }
2032 else if(VisAfter)
2033 {
2034 REGION_bOffsetRgn(VisAfter, -Window->rcWindow.left, -Window->rcWindow.top);
2035 }
2036
2037 /*
2038 * Determine which pixels can be copied from the old window position
2039 * to the new. Those pixels must be visible in both the old and new
2040 * position. Also, check the class style to see if the windows of this
2041 * class need to be completely repainted on (horizontal/vertical) size
2042 * change.
2043 */
2044 if ( ( VisBefore != NULL &&
2045 VisAfter != NULL &&
2046 !(WinPos.flags & SWP_NOCOPYBITS) &&
2047 ((WinPos.flags & SWP_NOSIZE) || !(WvrFlags & WVR_REDRAW)) &&
2048 !(Window->ExStyle & WS_EX_TRANSPARENT) ) )
2049 {
2050
2051 /*
2052 * If this is (also) a window resize, the whole nonclient area
2053 * needs to be repainted. So we limit the copy to the client area,
2054 * 'cause there is no use in copying it (would possibly cause
2055 * "flashing" too). However, if the copy region is already empty,
2056 * we don't have to crop (can't take anything away from an empty
2057 * region...)
2058 */
2059
2060 CopyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2061 if ((WinPos.flags & SWP_NOSIZE) && (WinPos.flags & SWP_NOCLIENTSIZE))
2062 RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBefore, RGN_AND);
2063 else if (VisBeforeJustClient != NULL)
2064 {
2065 RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBeforeJustClient, RGN_AND);
2066 }
2067
2068 if (VisBeforeJustClient != NULL)
2069 {
2070 REGION_Delete(VisBeforeJustClient);
2071 }
2072
2073 /* Now use in copying bits which are in the update region. */
2074 if (Window->hrgnUpdate != NULL)
2075 {
2076 PREGION RgnUpdate = REGION_LockRgn(Window->hrgnUpdate);
2077 if (RgnUpdate)
2078 {
2079 REGION_bOffsetRgn(CopyRgn, NewWindowRect.left, NewWindowRect.top);
2081 REGION_bOffsetRgn(CopyRgn, -NewWindowRect.left, -NewWindowRect.top);
2082 REGION_UnlockRgn(RgnUpdate);
2083 }
2084 }
2085
2086 /*
2087 * Now, get the bounding box of the copy region. If it's empty
2088 * there's nothing to copy. Also, it's no use copying bits onto
2089 * themselves.
2090 */
2092 {
2093 /* Nothing to copy, clean up */
2095 CopyRgn = NULL;
2096 }
2097 else if ( OldWindowRect.left != NewWindowRect.left ||
2098 OldWindowRect.top != NewWindowRect.top ||
2099 (WinPos.flags & SWP_FRAMECHANGED) )
2100 {
2101 HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
2102 PREGION DcRgnObj = REGION_LockRgn(DcRgn);
2103
2104 /*
2105 * Small trick here: there is no function to bitblt a region. So
2106 * we set the region as the clipping region, take the bounding box
2107 * of the region and bitblt that. Since nothing outside the clipping
2108 * region is copied, this has the effect of bitblt'ing the region.
2109 *
2110 * Since NtUserGetDCEx takes ownership of the clip region, we need
2111 * to create a copy of CopyRgn and pass that. We need CopyRgn later
2112 */
2114 REGION_bOffsetRgn(DcRgnObj, NewWindowRect.left, NewWindowRect.top);
2115 REGION_UnlockRgn(DcRgnObj);
2116 Dc = UserGetDCEx( Window,
2117 DcRgn,
2118 DCX_WINDOW|DCX_CACHE|DCX_INTERSECTRGN|DCX_CLIPSIBLINGS|DCX_KEEPCLIPRGN); // DCX_WINDOW will set first, go read WinDC.c.
2119 NtGdiBitBlt( Dc,
2120 CopyRect.left, CopyRect.top,
2121 CopyRect.right - CopyRect.left,
2122 CopyRect.bottom - CopyRect.top,
2123 Dc,
2124 CopyRect.left + (OldWindowRect.left - NewWindowRect.left),
2125 CopyRect.top + (OldWindowRect.top - NewWindowRect.top),
2126 SRCCOPY,
2127 0,
2128 0);
2129
2132 GreDeleteObject(DcRgn);
2133 }
2134 }
2135 else
2136 {
2137 CopyRgn = NULL;
2138 }
2139
2140 /* We need to redraw what wasn't visible before or force a redraw */
2141 if (VisAfter != NULL)
2142 {
2143 PREGION DirtyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2144 if (DirtyRgn)
2145 {
2146 if (CopyRgn != NULL)
2147 {
2148 RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, CopyRgn, RGN_DIFF);
2149 }
2150 else
2151 {
2152 RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, 0, RGN_COPY);
2153 }
2154
2155 if (RgnType != ERROR && RgnType != NULLREGION) // Regions moved.
2156 {
2157 /* old code
2158 NtGdiOffsetRgn(DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
2159 IntInvalidateWindows( Window,
2160 DirtyRgn,
2161 RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
2162 }
2163 GreDeleteObject(DirtyRgn);
2164 */
2165
2166 PWND Parent = Window->spwndParent;
2167
2168 REGION_bOffsetRgn( DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
2169
2170 if ( (Window->style & WS_CHILD) && (Parent) && !(Parent->style & WS_CLIPCHILDREN))
2171 {
2174 }
2176 }
2177 else if (RgnType != ERROR && RgnType == NULLREGION) // Must be the same. See CORE-7166 & CORE-15934, NC HACK fix.
2178 {
2179 if ( !PosChanged &&
2180 !(WinPos.flags & SWP_DEFERERASE) &&
2181 (WinPos.flags & SWP_FRAMECHANGED) )
2182 {
2183 PWND pwnd = Window;
2184 PWND Parent = Window->spwndParent;
2185
2186 if ( pwnd->style & WS_CHILD ) // Fix ProgMan menu bar drawing.
2187 {
2188 TRACE("SWP_FRAMECHANGED win child %p Parent %p\n",pwnd,Parent);
2189 pwnd = Parent ? Parent : pwnd;
2190 }
2191
2192 if ( !(pwnd->style & WS_CHILD) )
2193 {
2194 /*
2195 * Check if we have these specific windows style bits set/reset.
2196 * FIXME: There may be other combinations of styles that need this handling as well.
2197 * This fixes the ReactOS Calculator buttons disappearing in CORE-16827.
2198 */
2199 if ((Window->style & WS_CLIPSIBLINGS) && !(Window->style & (WS_POPUP | WS_CLIPCHILDREN | WS_SIZEBOX)))
2200 {
2201 IntSendNCPaint(pwnd, HRGN_WINDOW); // Paint the whole frame.
2202 }
2203 else // Use region handling
2204 {
2205 HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
2206 PREGION DcRgnObj = REGION_LockRgn(DcRgn);
2207 TRACE("SWP_FRAMECHANGED win %p hRgn %p\n",pwnd, DcRgn);
2208 IntGdiCombineRgn(DcRgnObj, VisBefore, NULL, RGN_COPY);
2209 REGION_UnlockRgn(DcRgnObj);
2210 ForceNCPaintErase(pwnd, DcRgn, DcRgnObj);
2211 GreDeleteObject(DcRgn);
2212 }
2213 }
2214 }
2215 }
2216 REGION_Delete(DirtyRgn);
2217 }
2218 }
2219
2220 if (CopyRgn != NULL)
2221 {
2223 }
2224
2225 /* Expose what was covered before but not covered anymore */
2226 if (VisBefore != NULL)
2227 {
2228 PREGION ExposedRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2229 if (ExposedRgn)
2230 {
2231 RgnType = IntGdiCombineRgn(ExposedRgn, VisBefore, NULL, RGN_COPY);
2232 REGION_bOffsetRgn(ExposedRgn,
2233 OldWindowRect.left - NewWindowRect.left,
2234 OldWindowRect.top - NewWindowRect.top);
2235
2236 if (VisAfter != NULL)
2237 RgnType = IntGdiCombineRgn(ExposedRgn, ExposedRgn, VisAfter, RGN_DIFF);
2238
2239 if (RgnType != ERROR && RgnType != NULLREGION)
2240 {
2242 }
2243 REGION_Delete(ExposedRgn);
2244 }
2245 REGION_Delete(VisBefore);
2246 }
2247
2248 if (VisAfter != NULL)
2249 {
2250 REGION_Delete(VisAfter);
2251 }
2252 }
2253
2254 if (!(WinPos.flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)))
2255 {
2256 if ((Window->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
2257 {
2259 }
2260 else
2261 {
2262 //ERR("SetWindowPos Set FG Window!\n");
2263 if ( pti->MessageQueue->spwndActive != Window ||
2264 pti->MessageQueue != gpqForeground )
2265 {
2266 //ERR("WPSWP : set active window\n");
2267 if (!(Window->state & WNDS_BEINGACTIVATED)) // Inside SAW?
2268 {
2269 co_IntSetForegroundWindow(Window); // Fixes SW_HIDE issues. Wine win test_SetActiveWindow & test_SetForegroundWindow.
2270 }
2271 }
2272 }
2273 }
2274
2275 if ( !PosChanged &&
2276 (WinPos.flags & SWP_FRAMECHANGED) &&
2277 !(WinPos.flags & SWP_DEFERERASE) && // Prevent sending WM_SYNCPAINT message.
2278 VisAfter )
2279 {
2280 PWND Parent = Window->spwndParent;
2281 if ( !(Window->style & WS_CHILD) && (Parent) && (Parent->style & WS_CLIPCHILDREN))
2282 {
2283 TRACE("SWP_FRAMECHANGED Parent %p WS_CLIPCHILDREN %p\n",Parent,Window);
2284 UserSyncAndPaintWindows(Parent, RDW_CLIPCHILDREN); // NC should redraw here, see NC HACK fix.
2285 }
2286 }
2287
2288 // Fix wine msg test_SetFocus, prevents sending WM_WINDOWPOSCHANGED.
2289 if ( VisBefore == NULL &&
2290 VisBeforeJustClient == NULL &&
2291 !(Window->ExStyle & WS_EX_TOPMOST) &&
2293 {
2294 TRACE("No drawing, set no Z order and no redraw!\n");
2296 }
2297
2298 if(!(flags & SWP_DEFERERASE))
2299 {
2300 /* erase parent when hiding or resizing child */
2301 if ((flags & SWP_HIDEWINDOW) ||
2302 (!(flags & SWP_SHOWWINDOW) &&
2304 {
2305 PWND Parent = Window->spwndParent;
2308 }
2309
2310 /* Give newly shown windows a chance to redraw */
2313 {
2315 }
2316 }
2317
2318 /* And last, send the WM_WINDOWPOSCHANGED message */
2319
2320 TRACE("\tstatus hwnd %p flags = %04x\n", Window ? UserHMGetHandle(Window) : NULL, WinPos.flags & SWP_AGG_STATUSFLAGS);
2321
2324 {
2325 /* WM_WINDOWPOSCHANGED is sent even if SWP_NOSENDCHANGING is set
2326 and always contains final window position.
2327 */
2328 WinPos.x = NewWindowRect.left;
2329 WinPos.y = NewWindowRect.top;
2330 WinPos.cx = NewWindowRect.right - NewWindowRect.left;
2331 WinPos.cy = NewWindowRect.bottom - NewWindowRect.top;
2332 TRACE("WM_WINDOWPOSCHANGED hwnd %p Flags %04x\n",WinPos.hwnd,WinPos.flags);
2334 }
2335
2336 if ( WinPos.flags & SWP_FRAMECHANGED || WinPos.flags & SWP_STATECHANGED ||
2337 !(WinPos.flags & SWP_NOCLIENTSIZE) || !(WinPos.flags & SWP_NOCLIENTMOVE) )
2338 {
2339 PWND pWnd = ValidateHwndNoErr(WinPos.hwnd);
2340 if (pWnd)
2341 IntNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, pWnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
2342 }
2343
2344 /* Send WM_IME_SYSTEM:IMS_UPDATEIMEUI to the IME windows if necessary */
2345 if ((WinPos.flags & (SWP_NOMOVE | SWP_NOSIZE)) != (SWP_NOMOVE | SWP_NOSIZE))
2346 {
2347 if (IS_IMM_MODE())
2349 }
2350
2351 if(bPointerInWindow != IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y))
2352 {
2353 /* Generate mouse move message */
2354 MSG msg;
2355 msg.message = WM_MOUSEMOVE;
2356 msg.wParam = UserGetMouseButtonsState();
2357 msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
2358 msg.pt = gpsi->ptCursor;
2360 }
2361
2362 return TRUE;
2363}
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:649
#define WNDS_BEINGACTIVATED
Definition: ntuser.h:625
#define WNDS_SENDNCPAINT
Definition: ntuser.h:616
#define IS_IMM_MODE()
Definition: ntuser.h:1209
#define WEF_SETBYWNDPTI
Definition: ntuser.h:236
#define HRGN_WINDOW
Definition: ntuser.h:361
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
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:3961
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
static BOOL FASTCALL co_WinPosDoWinPosChanging(PWND Window, PWINDOWPOS WinPos, PRECTL WindowRect, PRECTL ClientRect)
Definition: winpos.c:1267
static BOOL FASTCALL WinPosFixupFlags(WINDOWPOS *WinPos, PWND Wnd)
Definition: winpos.c:1551
VOID ForceNCPaintErase(PWND Wnd, HRGN hRgn, PREGION pRgn)
Definition: winpos.c:1691
#define SWP_AGG_STATUSFLAGS
Definition: winpos.c:24
static VOID FASTCALL WinPosInternalMoveWindow(PWND Window, INT MoveX, INT MoveY)
Definition: winpos.c:1521
static BOOL IntValidateParent(PWND Child, PREGION ValidateRgn)
Definition: winpos.c:1057
#define SWP_AGG_NOCLIENTCHANGE
Definition: winpos.c:26
static HWND FASTCALL WinPosDoOwnedPopups(PWND Window, HWND hWndInsertAfter)
Definition: winpos.c:1355
#define SWP_AGG_NOGEOMETRYCHANGE
Definition: winpos.c:20
#define SWP_AGG_NOPOSCHANGE
Definition: winpos.c:22
VOID SelectWindowRgn(PWND Window, HRGN hRgnClip)
Definition: winpos.c:259
static LONG FASTCALL co_WinPosDoNCCALCSize(PWND Window, PWINDOWPOS WinPos, RECTL *WindowRect, RECTL *ClientRect, RECTL *validRects)
Definition: winpos.c:1180
static VOID FASTCALL IntImeWindowPosChanged(VOID)
Definition: winpos.c:1747
#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:3588
UINT flags
Definition: winuser.h:3594
HWND hwndInsertAfter
Definition: winuser.h:3589
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:894
VOID FASTCALL IntInvalidateWindows(PWND Wnd, PREGION Rgn, ULONG Flags)
Definition: painting.c:642
HWND FASTCALL UserGetShellWindow(VOID)
Definition: window.c:3681
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:554
VOID FASTCALL REGION_Delete(PREGION pRgn)
Definition: region.c:2449
PREGION FASTCALL REGION_LockRgn(_In_ HRGN hrgn)
Definition: region.c:2358
VOID FASTCALL REGION_UnlockRgn(_In_ PREGION prgn)
Definition: region.c:2373
INT FASTCALL REGION_GetRgnBox(PREGION Rgn, PRECTL pRect)
Definition: region.c:2543
PREGION FASTCALL IntSysCreateRectpRgn(INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
Definition: region.c:2407
BOOL FASTCALL REGION_bOffsetRgn(_Inout_ PREGION prgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:2707
INT FASTCALL IntGdiCombineRgn(PREGION prgnDest, PREGION prgnSrc1, PREGION prgnSrc2, INT iCombineMode)
Definition: region.c:2487
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:178
WORD FASTCALL UserGetMouseButtonsState(VOID)
Definition: mouse.c:22
#define USERTAG_SWP
Definition: tags.h:281
BOOL FASTCALL IntIsWindow(HWND hWnd)
Definition: window.c:176
VOID FASTCALL IntLinkHwnd(PWND Wnd, HWND hWndPrev)
Definition: window.c:983
#define OBJID_WINDOW
Definition: winable.h:15
#define CHILDID_SELF
Definition: winable.h:14
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22
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:1246
#define SWP_FRAMECHANGED
Definition: winuser.h:1240
#define MAKELPARAM(l, h)
Definition: winuser.h:4008
#define DCX_CACHE
Definition: winuser.h:2114
#define DCX_WINDOW
Definition: winuser.h:2113
#define HSHELL_WINDOWDESTROYED
Definition: winuser.h:1256
#define WM_CHILDACTIVATE
Definition: winuser.h:1638
#define WS_EX_APPWINDOW
Definition: winuser.h:383
#define HSHELL_WINDOWCREATED
Definition: winuser.h:1255
#define SWP_NOMOVE
Definition: winuser.h:1244
#define RDW_NOINTERNALPAINT
Definition: winuser.h:1217
#define GA_PARENT
Definition: winuser.h:2788
#define SWP_NOSIZE
Definition: winuser.h:1245
#define WM_MOUSEMOVE
Definition: winuser.h:1775
#define RDW_ERASE
Definition: winuser.h:1211
#define RDW_NOCHILDREN
Definition: winuser.h:1222
#define SWP_DEFERERASE
Definition: winuser.h:1252
#define DCX_CLIPSIBLINGS
Definition: winuser.h:2116
#define DCX_INTERSECTRGN
Definition: winuser.h:2122
#define WVR_REDRAW
Definition: winuser.h:2521
#define RDW_ALLCHILDREN
Definition: winuser.h:1221
#define RDW_ERASENOW
Definition: winuser.h:1219
#define RDW_FRAME
Definition: winuser.h:1212
#define SWP_SHOWWINDOW
Definition: winuser.h:1248
#define SWP_HIDEWINDOW
Definition: winuser.h:1241
#define RDW_NOFRAME
Definition: winuser.h:1216
#define RDW_NOERASE
Definition: winuser.h:1215
#define RDW_VALIDATE
Definition: winuser.h:1218
#define WM_WINDOWPOSCHANGED
Definition: winuser.h:1662
#define RDW_INVALIDATE
Definition: winuser.h:1214

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 2566 of file winpos.c.

2567{
2568 BOOLEAN WasVisible;
2569 UINT Swp = 0, EventMsg = 0;
2570 RECTL NewPos = {0, 0, 0, 0};
2571 BOOLEAN ShowFlag;
2572 LONG style;
2573 PWND Parent;
2574 PTHREADINFO pti;
2575 //HRGN VisibleRgn;
2576 BOOL ShowOwned = FALSE;
2577 BOOL FirstTime = FALSE;
2578 ASSERT_REFS_CO(Wnd);
2579 //KeRosDumpStackFrames(NULL, 20);
2581 WasVisible = (Wnd->style & WS_VISIBLE) != 0;
2582 style = Wnd->style;
2583
2584 TRACE("co_WinPosShowWindow START hwnd %p Cmd %d usicmd %u\n",
2585 UserHMGetHandle(Wnd), Cmd, pti->ppi->usi.wShowWindow);
2586
2587 if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
2588 {
2589 if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD)
2590 {
2591 if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
2592 {
2593 if (Wnd->spwndOwner == NULL)
2594 {
2595 if ( Cmd == SW_SHOWNORMAL || Cmd == SW_SHOW)
2596 {
2598 }
2599 FirstTime = TRUE;
2600 TRACE("co_WPSW FT 1\n");
2601 }
2602 }
2603 }
2604 }
2605
2606 if ( Cmd == SW_SHOWDEFAULT )
2607 {
2608 if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
2609 {
2610 Cmd = pti->ppi->usi.wShowWindow;
2611 FirstTime = TRUE;
2612 TRACE("co_WPSW FT 2\n");
2613 }
2614 }
2615
2616 if (FirstTime)
2617 {
2619 }
2620
2621 switch (Cmd)
2622 {
2623 case SW_HIDE:
2624 {
2625 if (!WasVisible)
2626 {
2627 //ERR("co_WinPosShowWindow Exit Bad\n");
2628 return FALSE;
2629 }
2631 if (Wnd != pti->MessageQueue->spwndActive)
2633 break;
2634 }
2635
2636 case SW_FORCEMINIMIZE: /* FIXME: Does not work if thread is hung. */
2637 case SW_SHOWMINNOACTIVE:
2639 /* Fall through. */
2640 case SW_SHOWMINIMIZED:
2641 case SW_MINIMIZE: /* CORE-15669: SW_MINIMIZE also shows */
2642 Swp |= SWP_SHOWWINDOW;
2643 {
2644 Swp |= SWP_NOACTIVATE;
2645 if (!(style & WS_MINIMIZE))
2646 {
2648 // Fix wine Win test_SetFocus todo #1 & #2,
2649 if (Cmd == SW_SHOWMINIMIZED)
2650 {
2651 //ERR("co_WinPosShowWindow Set focus 1\n");
2652 if ((style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
2653 co_UserSetFocus(Wnd->spwndParent);
2654 else
2655 co_UserSetFocus(0);
2656 }
2657
2658 Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
2659
2660 EventMsg = EVENT_SYSTEM_MINIMIZESTART;
2661 }
2662 else
2663 {
2664 if (WasVisible)
2665 {
2666 //ERR("co_WinPosShowWindow Exit Good\n");
2667 return TRUE;
2668 }
2669 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2670 }
2671 break;
2672 }
2673
2674 case SW_SHOWMAXIMIZED:
2675 {
2676 Swp |= SWP_SHOWWINDOW;
2677 if (!(style & WS_MAXIMIZE))
2678 {
2679 ShowOwned = TRUE;
2680
2681 Swp |= co_WinPosMinMaximize(Wnd, SW_MAXIMIZE, &NewPos);
2682
2683 EventMsg = EVENT_SYSTEM_MINIMIZEEND;
2684 }
2685 else
2686 {
2687 if (WasVisible)
2688 {
2689 //ERR("co_WinPosShowWindow Exit Good 1\n");
2690 return TRUE;
2691 }
2692 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2693 }
2694 break;
2695 }
2696
2697 case SW_SHOWNA:
2699 if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOZORDER;
2700 break;
2701 case SW_SHOW:
2702 if (WasVisible) return(TRUE); // Nothing to do!
2704 /* Don't activate the topmost window. */
2705 if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2706 break;
2707
2708 case SW_SHOWNOACTIVATE:
2710 /* Fall through. */
2711 case SW_SHOWNORMAL:
2712 case SW_SHOWDEFAULT:
2713 case SW_RESTORE:
2714 if (!WasVisible) Swp |= SWP_SHOWWINDOW;
2715 if (style & (WS_MINIMIZE | WS_MAXIMIZE))
2716 {
2717 Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
2718 if (style & WS_MINIMIZE) EventMsg = EVENT_SYSTEM_MINIMIZEEND;
2719 }
2720 else
2721 {
2722 if (WasVisible)
2723 {
2724 //ERR("co_WinPosShowWindow Exit Good 3\n");
2725 return TRUE;
2726 }
2727 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2728 }
2729 if ( style & WS_CHILD &&
2730 !(Wnd->ExStyle & WS_EX_MDICHILD) &&
2731 !(Swp & SWP_STATECHANGED))
2733 break;
2734
2735 default:
2736 //ERR("co_WinPosShowWindow Exit Good 4\n");
2737 return FALSE;
2738 }
2739
2740 ShowFlag = (Cmd != SW_HIDE);
2741
2742 if ((ShowFlag != WasVisible || Cmd == SW_SHOWNA) && Cmd != SW_SHOWMAXIMIZED && !(Swp & SWP_STATECHANGED))
2743 {
2745#if 0 // Fix wine msg test_SetParent:WmSetParentSeq_1:2
2746 if (!(Wnd->state2 & WNDS2_WIN31COMPAT)) // <------------- XP sets this bit!
2748#endif
2749 if (!VerifyWnd(Wnd)) return WasVisible;
2750 }
2751
2752 /* We can't activate a child window */
2753 if ((Wnd->style & WS_CHILD) &&
2754 !(Wnd->ExStyle & WS_EX_MDICHILD) &&
2755 Cmd != SW_SHOWNA)
2756 {
2757 //ERR("SWP Child No active and ZOrder\n");
2759 }
2760
2761#if 0 // Explorer issues with common controls? Someone does not know how CS_SAVEBITS works.
2762 // Breaks startup and shutdown active window...
2763 if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
2764 Wnd->pcls->style & CS_SAVEBITS &&
2765 ((Cmd == SW_SHOW) || (Cmd == SW_NORMAL)))
2766 {
2767 ERR("WinPosShowWindow Set active\n");
2768 //UserSetActiveWindow(Wnd);
2769 co_IntSetForegroundWindow(Wnd); // HACK
2771 }
2772#endif
2773
2774 if (IsChildVisible(Wnd) || Swp & SWP_STATECHANGED)
2775 {
2776 TRACE("Child is Vis %s or State changed %s. ShowFlag %s Swp %04x\n",
2777 (IsChildVisible(Wnd) ? "TRUE" : "FALSE"), (Swp & SWP_STATECHANGED ? "TRUE" : "FALSE"),
2778 (ShowFlag ? "TRUE" : "FALSE"),LOWORD(Swp));
2780 0 != (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOPMOST : HWND_TOP,
2781 NewPos.left,
2782 NewPos.top,
2783 NewPos.right, // NewPos.right - NewPos.left, when minimized and restore, the window becomes smaller.
2784 NewPos.bottom,// NewPos.bottom - NewPos.top,
2785 LOWORD(Swp));
2786 }
2787 else
2788 {
2789 TRACE("Parent Vis?\n");
2790 /* if parent is not visible simply toggle WS_VISIBLE and return */
2791 if (ShowFlag) IntSetStyle( Wnd, WS_VISIBLE, 0 );
2792 else IntSetStyle( Wnd, 0, WS_VISIBLE );
2793 }
2794
2795 if ( EventMsg ) IntNotifyWinEvent(EventMsg, Wnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
2796
2797 if ( ShowOwned ) IntShowOwnedPopups(Wnd, TRUE );
2798
2799 if ((Cmd == SW_HIDE) || (Cmd == SW_MINIMIZE))
2800 {
2801 if ( Wnd == pti->MessageQueue->spwndActive && pti->MessageQueue == IntGetFocusMessageQueue() )
2802 {
2803 if (UserIsDesktopWindow(Wnd->spwndParent))
2804 {
2805 if (!ActivateOtherWindowMin(Wnd))
2806 {
2808 }
2809 }
2810 else
2811 {
2813 }
2814 }
2815
2816 /* Revert focus to parent */
2817 if (Wnd == pti->MessageQueue->spwndFocus)
2818 {
2819 Parent = Wnd->spwndParent;
2820 if (UserIsDesktopWindow(Wnd->spwndParent))
2821 Parent = 0;
2823 }
2824 // Hide, just return.
2825 if (Cmd == SW_HIDE) return WasVisible;
2826 }
2827
2828 /* FIXME: Check for window destruction. */
2829
2830 if ((Wnd->state & WNDS_SENDSIZEMOVEMSGS) &&
2831 !(Wnd->state2 & WNDS2_INDESTROY))
2832 {
2834 }
2835
2836 /* if previous state was minimized Windows sets focus to the window */
2837 if (style & WS_MINIMIZE)
2838 {
2839 co_UserSetFocus(Wnd);
2840 // Fix wine Win test_SetFocus todo #3,
2842 }
2843 //ERR("co_WinPosShowWindow EXIT\n");
2844 return WasVisible;
2845}
unsigned char BOOLEAN
#define ERR(fmt,...)
Definition: precomp.h:57
HWND FASTCALL co_UserSetFocus(PWND Window)
Definition: focus.c:1317
#define WNDS2_INDESTROY
Definition: ntuser.h:648
#define WNDS_SENDSIZEMOVEMSGS
Definition: ntuser.h:609
unsigned int UINT
Definition: ndis.h:50
UINT FASTCALL co_WinPosMinMaximize(PWND Wnd, UINT ShowFlag, RECT *NewPos)
Definition: winpos.c:2415
VOID FASTCALL co_WinPosActivateOtherWindow(PWND Wnd)
Definition: winpos.c:397
BOOL FASTCALL IsChildVisible(PWND pWnd)
Definition: winpos.c:226
BOOL FASTCALL ActivateOtherWindowMin(PWND Wnd)
Definition: winpos.c:285
void FASTCALL co_WinPosSendSizeMove(PWND Wnd)
Definition: winpos.c:2381
#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:143
BOOL FASTCALL IntShowOwnedPopups(PWND OwnerWnd, BOOL fShow)
Definition: window.c:4649
#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:770
#define SW_SHOWMAXIMIZED
Definition: winuser.h:773
#define SW_HIDE
Definition: winuser.h:768
#define HWND_TOPMOST
Definition: winuser.h:1208
#define SW_MINIMIZE
Definition: winuser.h:776
#define SW_SHOWNOACTIVATE
Definition: winuser.h:774
#define WM_ACTIVATE
Definition: winuser.h:1612
#define WM_SHOWWINDOW
Definition: winuser.h:1628
#define SW_SHOWDEFAULT
Definition: winuser.h:780
#define SW_SHOWMINIMIZED
Definition: winuser.h:771
#define SW_FORCEMINIMIZE
Definition: winuser.h:781
#define HWND_TOP
Definition: winuser.h:1207
#define WS_EX_MDICHILD
Definition: winuser.h:394
#define SW_SHOWNA
Definition: winuser.h:778
#define WA_ACTIVE
Definition: winuser.h:2623
#define CS_SAVEBITS
Definition: winuser.h:657
#define SW_RESTORE
Definition: winuser.h:779
#define SW_SHOW
Definition: winuser.h:775
#define SW_MAXIMIZE
Definition: winuser.h:772
#define SW_NORMAL
Definition: winuser.h:769
#define SW_SHOWMINNOACTIVE
Definition: winuser.h:777

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 2933 of file winpos.c.

2938{
2939 PWND Window;
2940 POINT Point = *WinPoint;
2942
2943 if( ScopeWin == NULL )
2944 {
2945 ScopeWin = UserGetDesktopWindow();
2946 if(ScopeWin == NULL)
2947 return NULL;
2948 }
2949
2950 *HitTest = HTNOWHERE;
2951
2952 ASSERT_REFS_CO(ScopeWin);
2953 UserRefObjectCo(ScopeWin, &Ref);
2954
2955 Window = co_WinPosSearchChildren(ScopeWin, &Point, HitTest, Ignore);
2956
2957 UserDerefObjectCo(ScopeWin);
2958 if (Window)
2960 ASSERT_REFS_CO(ScopeWin);
2961
2962 return Window;
2963}
static PWND co_WinPosSearchChildren(IN PWND ScopeWin, IN POINT *Point, IN OUT USHORT *HitTest, IN BOOL Ignore)
Definition: winpos.c:2848
#define HTNOWHERE
Definition: winuser.h:2474

Referenced by co_IntProcessMouseMessage(), and NtUserWindowFromPoint().

◆ IntClientToScreen()

BOOL FASTCALL IntClientToScreen ( PWND  Wnd,
LPPOINT  lpPoint 
)

Definition at line 199 of file winpos.c.

200{
201 if (Wnd && Wnd->fnid != FNID_DESKTOP )
202 {
203 if (Wnd->ExStyle & WS_EX_LAYOUTRTL)
204 lpPoint->x = Wnd->rcClient.right - lpPoint->x;
205 else
206 lpPoint->x += Wnd->rcClient.left;
207 lpPoint->y += Wnd->rcClient.top;
208 }
209 return TRUE;
210}
#define FNID_DESKTOP
Definition: ntuser.h:862
DWORD fnid
Definition: ntuser.h:709
RECT rcClient
Definition: ntuser.h:717
#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 71 of file winpos.c.

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

Referenced by co_IntFixCaret(), and IntScrollWindowEx().

◆ IntGetWindowRect()

BOOL FASTCALL IntGetWindowRect ( PWND  Wnd,
RECTL Rect 
)

Definition at line 121 of file winpos.c.

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

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:3996
HRGN hrgnClip
Definition: ntuser.h:733
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 2967 of file winpos.c.

2968{
2969 POINTL Pt;
2970 HWND *List, *phWnd;
2971 PWND pwndHit = NULL;
2972
2973 Pt.x = x;
2974 Pt.y = y;
2975
2977 {
2978 Pt.x += Parent->rcClient.left;
2979 Pt.y += Parent->rcClient.top;
2980 }
2981
2982 if (!IntPtInWindow(Parent, Pt.x, Pt.y)) return NULL;
2983
2985 {
2986 for (phWnd = List; *phWnd; phWnd++)
2987 {
2988 PWND Child;
2989 if ((Child = ValidateHwndNoErr(*phWnd)))
2990 {
2991 if ( Child->style & WS_VISIBLE && IntPtInWindow(Child, Pt.x, Pt.y) )
2992 {
2993 if ( Child->pcls->atomClassName != gpsi->atomSysClass[ICLS_BUTTON] ||
2994 (Child->style & BS_TYPEMASK) != BS_GROUPBOX )
2995 {
2997 return Child;
2998 }
2999 pwndHit = Child;
3000 }
3001 }
3002 }
3004 }
3005 return pwndHit ? pwndHit : Parent;
3006}
#define ICLS_BUTTON
Definition: ntuser.h:912
#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:1060
_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:274
#define BS_TYPEMASK
Definition: winuser.h:270

Referenced by NtUserRealChildWindowFromPoint().

◆ IntScreenToClient()

BOOL FASTCALL IntScreenToClient ( PWND  Wnd,
LPPOINT  lpPoint 
)

Definition at line 213 of file winpos.c.

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

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

◆ UserGetWindowBorders()

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

Definition at line 888 of file winpos.c.

889{
890 DWORD Border = 0;
891
893 Border += 2;
895 Border += 1; /* for the outer frame always present */
896 if ((ExStyle & WS_EX_CLIENTEDGE) && WithClient)
897 Border += 2;
899 Border ++; /* The other border */
900 Size->cx = Size->cy = Border;
901 if ((Style & WS_THICKFRAME) && !(Style & WS_MINIMIZE)) /* The resize border */
902 {
905 }
908}
const DWORD Style
Definition: appswitch.c:71
const DWORD ExStyle
Definition: appswitch.c:72
BOOL UserHasWindowEdge(DWORD Style, DWORD ExStyle)
Definition: winpos.c:844
#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 844 of file winpos.c.

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

Referenced by UserGetWindowBorders().