ReactOS 0.4.16-dev-820-g96aa1ee
winpos.c File Reference
#include <win32k.h>
#include <immdev.h>
Include dependency graph for winpos.c:

Go to the source code of this file.

Macros

#define MINMAX_NOSWP   (0x00010000)
 
#define SWP_EX_NOCOPY   0x0001
 
#define SWP_EX_PAINTSELF   0x0002
 
#define SWP_AGG_NOGEOMETRYCHANGE    (SWP_NOSIZE | SWP_NOCLIENTSIZE | SWP_NOZORDER)
 
#define SWP_AGG_NOPOSCHANGE    (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER)
 
#define SWP_AGG_STATUSFLAGS    (SWP_AGG_NOPOSCHANGE | SWP_FRAMECHANGED | SWP_HIDEWINDOW | SWP_SHOWWINDOW)
 
#define SWP_AGG_NOCLIENTCHANGE    (SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE)
 
#define EMPTYPOINT(pt)   ((pt).x == -1 && (pt).y == -1)
 
#define PLACE_MIN   0x0001
 
#define PLACE_MAX   0x0002
 
#define PLACE_RECT   0x0004
 

Functions

 DBG_DEFAULT_CHANNEL (UserWinpos)
 
BOOL FASTCALL IntGetClientOrigin (PWND Window OPTIONAL, LPPOINT Point)
 
VOID FASTCALL IntGetClientRect (PWND Wnd, RECTL *Rect)
 
BOOL FASTCALL IntGetWindowRect (PWND Wnd, RECTL *Rect)
 
INT FASTCALL IntMapWindowPoints (PWND FromWnd, PWND ToWnd, LPPOINT lpPoints, UINT cPoints)
 
BOOL FASTCALL IntClientToScreen (PWND Wnd, LPPOINT lpPoint)
 
BOOL FASTCALL IntScreenToClient (PWND Wnd, LPPOINT lpPoint)
 
BOOL FASTCALL IsChildVisible (PWND pWnd)
 
PWND FASTCALL IntGetLastTopMostWindow (VOID)
 
VOID SelectWindowRgn (PWND Window, HRGN hRgnClip)
 
BOOL FASTCALL ActivateOtherWindowMin (PWND Wnd)
 
static BOOL FASTCALL can_activate_window (PWND Wnd OPTIONAL)
 
VOID FASTCALL co_WinPosActivateOtherWindow (PWND Wnd)
 
VOID FASTCALL WinPosInitInternalPos (PWND Wnd, RECTL *RestoreRect)
 
BOOL FASTCALL IntGetWindowPlacement (PWND Wnd, WINDOWPLACEMENT *lpwndpl)
 
static void make_rect_onscreen (RECT *rect)
 
static void make_point_onscreen (POINT *pt)
 
BOOL FASTCALL IntSetWindowPlacement (PWND Wnd, WINDOWPLACEMENT *wpl, UINT Flags)
 
UINT FASTCALL co_WinPosArrangeIconicWindows (PWND parent)
 
static VOID FASTCALL WinPosFindIconPos (PWND Window, POINT *Pos)
 
BOOL UserHasWindowEdge (DWORD Style, DWORD ExStyle)
 
VOID FASTCALL IntGetWindowBorderMeasures (PWND Wnd, UINT *cx, UINT *cy)
 
VOID UserGetWindowBorders (DWORD Style, DWORD ExStyle, SIZE *Size, BOOL WithClient)
 
DWORD IntGetWindowBorders (DWORD Style, DWORD ExStyle)
 
UINT FASTCALL co_WinPosGetMinMaxInfo (PWND Window, POINT *MaxSize, POINT *MaxPos, POINT *MinTrack, POINT *MaxTrack)
 
static BOOL IntValidateParent (PWND Child, PREGION ValidateRgn)
 
static VOID FASTCALL FixClientRect (PRECTL ClientRect, PRECTL WindowRect)
 
static VOID FASTCALL get_valid_rects (RECTL *old_client, RECTL *new_client, UINT flags, RECTL *valid)
 
static LONG FASTCALL co_WinPosDoNCCALCSize (PWND Window, PWINDOWPOS WinPos, RECTL *WindowRect, RECTL *ClientRect, RECTL *validRects)
 
static BOOL FASTCALL co_WinPosDoWinPosChanging (PWND Window, PWINDOWPOS WinPos, PRECTL WindowRect, PRECTL ClientRect)
 
static HWND FASTCALL WinPosDoOwnedPopups (PWND Window, HWND hWndInsertAfter)
 
static VOID FASTCALL WinPosInternalMoveWindow (PWND Window, INT MoveX, INT MoveY)
 
static BOOL FASTCALL WinPosFixupFlags (WINDOWPOS *WinPos, PWND Wnd)
 
VOID ForceNCPaintErase (PWND Wnd, HRGN hRgn, PREGION pRgn)
 
static VOID FASTCALL IntImeWindowPosChanged (VOID)
 
BOOLEAN FASTCALL co_WinPosSetWindowPos (PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
 
LRESULT FASTCALL co_WinPosGetNonClientSize (PWND Window, RECT *WindowRect, RECT *ClientRect)
 
void FASTCALL co_WinPosSendSizeMove (PWND Wnd)
 
UINT FASTCALL co_WinPosMinMaximize (PWND Wnd, UINT ShowFlag, RECT *NewPos)
 
BOOLEAN FASTCALL co_WinPosShowWindow (PWND Wnd, INT Cmd)
 
static PWND co_WinPosSearchChildren (IN PWND ScopeWin, IN POINT *Point, IN OUT USHORT *HitTest, IN BOOL Ignore)
 
PWND APIENTRY co_WinPosWindowFromPoint (IN PWND ScopeWin, IN POINT *WinPoint, IN OUT USHORT *HitTest, IN BOOL Ignore)
 
PWND FASTCALL IntRealChildWindowFromPoint (PWND Parent, LONG x, LONG y)
 
PWND APIENTRY IntChildWindowFromPointEx (PWND Parent, LONG x, LONG y, UINT uiFlags)
 
HDWP FASTCALL IntDeferWindowPos (HDWP hdwp, HWND hwnd, HWND hwndAfter, INT x, INT y, INT cx, INT cy, UINT flags)
 
BOOL FASTCALL IntEndDeferWindowPosEx (HDWP hdwp, BOOL bAsync)
 
HWND APIENTRY NtUserChildWindowFromPointEx (HWND hwndParent, LONG x, LONG y, UINT uiFlags)
 
BOOL APIENTRY NtUserEndDeferWindowPosEx (HDWP WinPosInfo, BOOL bAsync)
 
HDWP APIENTRY NtUserDeferWindowPos (HDWP WinPosInfo, HWND Wnd, HWND WndInsertAfter, int x, int y, int cx, int cy, UINT Flags)
 
DWORD APIENTRY NtUserGetInternalWindowPos (HWND hWnd, LPRECT rectWnd, LPPOINT ptIcon)
 
BOOL APIENTRY NtUserGetWindowPlacement (HWND hWnd, WINDOWPLACEMENT *lpwndpl)
 
DWORD APIENTRY NtUserMinMaximize (HWND hWnd, UINT cmd, BOOL Hide)
 
BOOL APIENTRY NtUserMoveWindow (HWND hWnd, int X, int Y, int nWidth, int nHeight, BOOL bRepaint)
 
HWND APIENTRY NtUserRealChildWindowFromPoint (HWND Parent, LONG x, LONG y)
 
BOOL APIENTRY NtUserSetWindowPos (HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags)
 
INT APIENTRY NtUserSetWindowRgn (HWND hWnd, HRGN hRgn, BOOL bRedraw)
 
DWORD APIENTRY NtUserSetInternalWindowPos (HWND hwnd, UINT showCmd, LPRECT lprect, LPPOINT lppt)
 
BOOL APIENTRY NtUserSetWindowPlacement (HWND hWnd, WINDOWPLACEMENT *lpwndpl)
 
BOOL APIENTRY NtUserShowWindowAsync (HWND hWnd, LONG nCmdShow)
 
BOOL APIENTRY NtUserShowWindow (HWND hWnd, LONG nCmdShow)
 
HWND APIENTRY NtUserWindowFromPoint (LONG X, LONG Y)
 
UINT FASTCALL IntGetWindowSnapEdge (PWND Wnd)
 
VOID FASTCALL co_IntCalculateSnapPosition (PWND Wnd, UINT Edge, OUT RECT *Pos)
 
VOID FASTCALL co_IntSnapWindow (PWND Wnd, UINT Edge)
 
VOID FASTCALL IntSetSnapEdge (PWND Wnd, UINT Edge)
 
VOID FASTCALL IntSetSnapInfo (PWND Wnd, UINT Edge, IN const RECT *Pos OPTIONAL)
 

Macro Definition Documentation

◆ EMPTYPOINT

#define EMPTYPOINT (   pt)    ((pt).x == -1 && (pt).y == -1)

Definition at line 29 of file winpos.c.

◆ MINMAX_NOSWP

#define MINMAX_NOSWP   (0x00010000)

Definition at line 15 of file winpos.c.

◆ PLACE_MAX

#define PLACE_MAX   0x0002

Definition at line 31 of file winpos.c.

◆ PLACE_MIN

#define PLACE_MIN   0x0001

Definition at line 30 of file winpos.c.

◆ PLACE_RECT

#define PLACE_RECT   0x0004

Definition at line 32 of file winpos.c.

◆ SWP_AGG_NOCLIENTCHANGE

#define SWP_AGG_NOCLIENTCHANGE    (SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE)

Definition at line 26 of file winpos.c.

◆ SWP_AGG_NOGEOMETRYCHANGE

#define SWP_AGG_NOGEOMETRYCHANGE    (SWP_NOSIZE | SWP_NOCLIENTSIZE | SWP_NOZORDER)

Definition at line 20 of file winpos.c.

◆ SWP_AGG_NOPOSCHANGE

Definition at line 22 of file winpos.c.

◆ SWP_AGG_STATUSFLAGS

Definition at line 24 of file winpos.c.

◆ SWP_EX_NOCOPY

#define SWP_EX_NOCOPY   0x0001

Definition at line 17 of file winpos.c.

◆ SWP_EX_PAINTSELF

#define SWP_EX_PAINTSELF   0x0002

Definition at line 18 of file winpos.c.

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:43
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:1376
PWND FASTCALL VerifyWnd(PWND pWnd)
Definition: window.c:88
#define WS_EX_NOACTIVATE
Definition: winuser.h:395
#define WS_EX_TOOLWINDOW
Definition: winuser.h:404

Referenced by co_WinPosShowWindow(), and UserSetActiveWindow().

◆ can_activate_window()

static BOOL FASTCALL can_activate_window ( PWND Wnd  OPTIONAL)
static

Definition at line 373 of file winpos.c.

374{
375 LONG style;
376
377 if (!Wnd) return FALSE;
378
379 style = Wnd->style;
380 if (!(style & WS_VISIBLE)) return FALSE;
381 if (style & WS_MINIMIZE) return FALSE;
382 if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return FALSE;
383 if (Wnd->ExStyle & WS_EX_NOACTIVATE) return FALSE;
384 return TRUE;
385 /* FIXME: This window could be disable because the child that closed
386 was a popup. */
387 //return !(style & WS_DISABLED);
388}
Arabic default style
Definition: afstyles.h:94
#define WS_CHILD
Definition: pedump.c:617
#define WS_POPUP
Definition: pedump.c:616
#define WS_MINIMIZE
Definition: pedump.c:622
long LONG
Definition: pedump.c:60

Referenced by co_WinPosActivateOtherWindow().

◆ co_IntCalculateSnapPosition()

VOID FASTCALL co_IntCalculateSnapPosition ( PWND  Wnd,
UINT  Edge,
OUT RECT Pos 
)

Definition at line 3912 of file winpos.c.

3913{
3914 POINT maxs, mint, maxt;
3915 UINT width, height;
3916 UserSystemParametersInfo(SPI_GETWORKAREA, 0, Pos, 0); /* FIXME: MultiMon of PWND */
3917
3918 co_WinPosGetMinMaxInfo(Wnd, &maxs, NULL, &mint, &maxt);
3919 width = Pos->right - Pos->left;
3920 width = min(min(max(width / 2, mint.x), maxt.x), width);
3921 height = Pos->bottom - Pos->top;
3922 height = min(max(height, mint.y), maxt.y);
3923
3924 switch (Edge)
3925 {
3926 case HTTOP: /* Maximized (Calculate RECT snap preview for SC_MOVE) */
3927 height = min(Pos->bottom - Pos->top, maxs.y);
3928 break;
3929 case HTLEFT:
3930 Pos->right = width;
3931 break;
3932 case HTRIGHT:
3933 Pos->left = Pos->right - width;
3934 break;
3935 default:
3936 ERR("Unexpected snap edge %#x\n", Edge);
3937 }
3938 Pos->bottom = Pos->top + height;
3939}
#define ERR(fmt,...)
Definition: precomp.h:57
ush Pos
Definition: deflate.h:92
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
#define min(a, b)
Definition: monoChain.cc:55
unsigned int UINT
Definition: ndis.h:50
UINT FASTCALL co_WinPosGetMinMaxInfo(PWND Window, POINT *MaxSize, POINT *MaxPos, POINT *MinTrack, POINT *MaxTrack)
Definition: winpos.c:940
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
#define max(a, b)
Definition: svc.c:63
BOOL FASTCALL UserSystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
Definition: sysparams.c:2105
#define HTRIGHT
Definition: winuser.h:2492
#define HTTOP
Definition: winuser.h:2493
#define HTLEFT
Definition: winuser.h:2490

Referenced by co_IntSnapWindow(), co_WinPosMinMaximize(), DefWndDoSizeMove(), and IntDefWindowProc().

◆ co_IntSnapWindow()

VOID FASTCALL co_IntSnapWindow ( PWND  Wnd,
UINT  Edge 
)

Definition at line 3942 of file winpos.c.

3943{
3944 RECT newPos;
3945 BOOLEAN wasSnapped = IntIsWindowSnapped(Wnd);
3946 UINT normal = !(Wnd->style & (WS_MAXIMIZE | WS_MINIMIZE));
3948 BOOLEAN hasRef = FALSE;
3949
3950 if (Edge == HTTOP)
3951 {
3953 return;
3954 }
3955 else if (Edge != HTNOWHERE)
3956 {
3957 UserRefObjectCo(Wnd, &ref);
3958 hasRef = TRUE;
3959 co_IntCalculateSnapPosition(Wnd, Edge, &newPos);
3960 IntSetSnapInfo(Wnd, Edge, (wasSnapped || !normal) ? NULL : &Wnd->rcWindow);
3961 }
3962 else if (wasSnapped)
3963 {
3964 if (!normal)
3965 {
3967 return;
3968 }
3969 newPos = Wnd->InternalPos.NormalRect; /* Copy RECT now before it is lost */
3971 }
3972 else
3973 {
3974 return; /* Already unsnapped, do nothing */
3975 }
3976
3977 TRACE("WindowSnap: %d->%d\n", IntGetWindowSnapEdge(Wnd), Edge);
3979 newPos.left,
3980 newPos.top,
3981 newPos.right - newPos.left,
3982 newPos.bottom - newPos.top,
3983 0);
3984 if (hasRef)
3985 UserDerefObjectCo(Wnd);
3986}
unsigned char BOOLEAN
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
VOID FASTCALL IntSetSnapInfo(PWND Wnd, UINT Edge, IN const RECT *Pos OPTIONAL)
Definition: winpos.c:4014
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1792
VOID FASTCALL co_IntCalculateSnapPosition(PWND Wnd, UINT Edge, OUT RECT *Pos)
Definition: winpos.c:3912
UINT FASTCALL IntGetWindowSnapEdge(PWND Wnd)
Definition: winpos.c:3904
VOID FASTCALL IntSetSnapEdge(PWND Wnd, UINT Edge)
Definition: winpos.c:3989
@ normal
Definition: optimize.h:166
#define WS_MAXIMIZE
Definition: pedump.c:623
#define TRACE(s)
Definition: solgame.cpp:4
struct _WND::@5203 InternalPos
RECT rcWindow
Definition: ntuser.h:716
Definition: send.c: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
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1495
FORCEINLINE BOOLEAN IntIsWindowSnapped(PWND Wnd)
Definition: winpos.h:88
#define WM_SYSCOMMAND
Definition: winuser.h:1744
#define HWND_TOP
Definition: winuser.h:1210
#define HTNOWHERE
Definition: winuser.h:2477
#define SC_MAXIMIZE
Definition: winuser.h:2591

Referenced by co_IntUnsnapWindow(), DefWndDoSizeMove(), and IntDefWindowProc().

◆ 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
struct _WND * spwndOwner
Definition: ntuser.h:715
THRDESKHEAD head
Definition: ntuser.h:695
PWND FASTCALL UserGetAncestor(PWND Wnd, UINT Type)
Definition: window.c:3344
#define ASSERT_REFS_CO(_obj_)
Definition: userfuncs.h:14
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1403
VOID FASTCALL IntSetFocusMessageQueue(PUSER_MESSAGE_QUEUE NewQueue)
Definition: desktop.c:1336
#define IntIsDesktopWindow(WndObj)
Definition: window.h:25
#define GA_ROOT
Definition: winuser.h:2792

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

◆ co_WinPosArrangeIconicWindows()

UINT FASTCALL co_WinPosArrangeIconicWindows ( PWND  parent)

Definition at line 737 of file winpos.c.

738{
739 RECTL rectParent;
740 PWND Child;
741 INT x, y, xspacing, yspacing, sx, sy;
742
744
745 IntGetClientRect( parent, &rectParent );
746 // FIXME: Support Minimize Metrics gspv.mm.iArrange.
747 // Default: ARW_BOTTOMLEFT
748 x = rectParent.left;
749 y = rectParent.bottom;
750
753
754 Child = parent->spwndChild;
755 while(Child)
756 {
757 if((Child->style & WS_MINIMIZE) != 0 )
758 {
760 UserRefObjectCo(Child, &Ref);
761
763 sy = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
764
765 Child->InternalPos.IconPos.x = sx;
766 Child->InternalPos.IconPos.y = sy;
767 Child->InternalPos.flags |= WPF_MININIT;
768
770
772
773 if (x <= rectParent.right - xspacing)
774 x += xspacing;
775 else
776 {
777 x = rectParent.left;
778 y -= yspacing;
779 }
780 }
781 Child = Child->spwndNext;
782 }
783 return yspacing;
784}
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
VOID FASTCALL IntGetClientRect(PWND Wnd, RECTL *Rect)
Definition: winpos.c:92
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:1023
#define SWP_NOACTIVATE
Definition: winuser.h:1245
#define SM_CYMINIMIZED
Definition: winuser.h:1024
#define SWP_ASYNCWINDOWPOS
Definition: winuser.h:1256
#define SM_CYBORDER
Definition: winuser.h:968
#define SWP_NOCOPYBITS
Definition: winuser.h:1246
#define SM_CXBORDER
Definition: winuser.h:967
#define SWP_NOZORDER
Definition: winuser.h:1250

Referenced by NtUserCallHwndLock().

◆ co_WinPosDoNCCALCSize()

static LONG FASTCALL co_WinPosDoNCCALCSize ( PWND  Window,
PWINDOWPOS  WinPos,
RECTL WindowRect,
RECTL ClientRect,
RECTL validRects 
)
static

Definition at line 1186 of file winpos.c.

1187{
1188 PWND Parent;
1189 UINT wvrFlags = 0;
1190
1192
1193 /* Send WM_NCCALCSIZE message to get new client area */
1194 if ((WinPos->flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE)
1195 {
1197 WINDOWPOS winposCopy;
1198
1199 params.rgrc[0] = *WindowRect; // new coordinates of a window that has been moved or resized
1200 params.rgrc[1] = Window->rcWindow; // window before it was moved or resized
1201 params.rgrc[2] = Window->rcClient; // client area before the window was moved or resized
1202
1203 Parent = Window->spwndParent;
1204 if (0 != (Window->style & WS_CHILD) && Parent)
1205 {
1206 RECTL_vOffsetRect(&(params.rgrc[0]), - Parent->rcClient.left, - Parent->rcClient.top);
1207 RECTL_vOffsetRect(&(params.rgrc[1]), - Parent->rcClient.left, - Parent->rcClient.top);
1208 RECTL_vOffsetRect(&(params.rgrc[2]), - Parent->rcClient.left, - Parent->rcClient.top);
1209 }
1210
1211 params.lppos = &winposCopy;
1212 winposCopy = *WinPos;
1213
1215
1216 /* If the application send back garbage, ignore it */
1217 if (params.rgrc[0].left <= params.rgrc[0].right &&
1218 params.rgrc[0].top <= params.rgrc[0].bottom)
1219 {
1220 *ClientRect = params.rgrc[0]; // First rectangle contains the coordinates of the new client rectangle resulting from the move or resize
1221 if ((Window->style & WS_CHILD) && Parent)
1222 {
1223 RECTL_vOffsetRect(ClientRect, Parent->rcClient.left, Parent->rcClient.top);
1224 }
1225 FixClientRect(ClientRect, WindowRect);
1226 }
1227
1228 if (ClientRect->left != Window->rcClient.left ||
1229 ClientRect->top != Window->rcClient.top)
1230 {
1231 WinPos->flags &= ~SWP_NOCLIENTMOVE;
1232 }
1233
1234 if (ClientRect->right - ClientRect->left != Window->rcClient.right - Window->rcClient.left)
1235 {
1236 WinPos->flags &= ~SWP_NOCLIENTSIZE;
1237 }
1238 else
1239 wvrFlags &= ~WVR_HREDRAW;
1240
1241 if (ClientRect->bottom - ClientRect->top != Window->rcClient.bottom - Window->rcClient.top)
1242 {
1243 WinPos->flags &= ~SWP_NOCLIENTSIZE;
1244 }
1245 else
1246 wvrFlags &= ~WVR_VREDRAW;
1247
1248 validRects[0] = params.rgrc[1]; // second rectangle contains the valid destination rectangle
1249 validRects[1] = params.rgrc[2]; // third rectangle contains the valid source rectangle
1250 }
1251 else
1252 {
1253 if (!(WinPos->flags & SWP_NOMOVE) &&
1254 (ClientRect->left != Window->rcClient.left ||
1255 ClientRect->top != Window->rcClient.top))
1256 {
1257 WinPos->flags &= ~SWP_NOCLIENTMOVE;
1258 }
1259 }
1260
1262 {
1263 RECTL_vSetEmptyRect( &validRects[0] );
1264 RECTL_vSetEmptyRect( &validRects[1] );
1265 }
1266 else get_valid_rects( &Window->rcClient, ClientRect, wvrFlags, validRects );
1267
1268 return wvrFlags;
1269}
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
GLenum const GLfloat * params
Definition: glext.h:5645
static VOID FASTCALL FixClientRect(PRECTL ClientRect, PRECTL WindowRect)
Definition: winpos.c:1087
static VOID FASTCALL get_valid_rects(RECTL *old_client, RECTL *new_client, UINT flags, RECTL *valid)
Definition: winpos.c:1130
long top
Definition: polytest.cpp:53
Definition: window.c:28
UINT flags
Definition: winuser.h:3597
FORCEINLINE VOID RECTL_vOffsetRect(_Inout_ RECTL *prcl, _In_ INT cx, _In_ INT cy)
Definition: rect.h:31
FORCEINLINE VOID RECTL_vSetEmptyRect(_Out_ RECTL *prcl)
Definition: rect.h:20
LONG_PTR LPARAM
Definition: windef.h:208
#define SWP_NOREDRAW
Definition: winuser.h:1249
#define SWP_FRAMECHANGED
Definition: winuser.h:1243
#define SWP_NOMOVE
Definition: winuser.h:1247
#define SWP_NOSIZE
Definition: winuser.h:1248
#define SWP_SHOWWINDOW
Definition: winuser.h:1251
#define SWP_HIDEWINDOW
Definition: winuser.h:1244
#define WM_NCCALCSIZE
Definition: winuser.h:1688

Referenced by co_WinPosSetWindowPos().

◆ co_WinPosDoWinPosChanging()

static BOOL FASTCALL co_WinPosDoWinPosChanging ( PWND  Window,
PWINDOWPOS  WinPos,
PRECTL  WindowRect,
PRECTL  ClientRect 
)
static

Definition at line 1273 of file winpos.c.

1277{
1279
1280 /* Send WM_WINDOWPOSCHANGING message */
1281
1282 if (!(WinPos->flags & SWP_NOSENDCHANGING)
1283 && !((WinPos->flags & SWP_AGG_NOCLIENTCHANGE) && (WinPos->flags & SWP_SHOWWINDOW)))
1284 {
1285 TRACE("Sending WM_WINDOWPOSCHANGING to hwnd %p flags %04x.\n", UserHMGetHandle(Window), WinPos->flags);
1287 }
1288
1289 /* Calculate new position and size */
1290
1291 *WindowRect = Window->rcWindow;
1292 *ClientRect = (Window->style & WS_MINIMIZE) ? Window->rcWindow : Window->rcClient;
1293
1294 if (!(WinPos->flags & SWP_NOSIZE))
1295 {
1296 if (Window->style & WS_MINIMIZE)
1297 {
1298 WindowRect->right = WindowRect->left + UserGetSystemMetrics(SM_CXMINIMIZED);
1299 WindowRect->bottom = WindowRect->top + UserGetSystemMetrics(SM_CYMINIMIZED);
1300 }
1301 else
1302 {
1303 WindowRect->right = WindowRect->left + WinPos->cx;
1304 WindowRect->bottom = WindowRect->top + WinPos->cy;
1305 }
1306 }
1307
1308 if (!(WinPos->flags & SWP_NOMOVE))
1309 {
1310 INT X, Y;
1311 PWND Parent;
1312 X = WinPos->x;
1313 Y = WinPos->y;
1314
1315 Parent = Window->spwndParent;
1316
1317 // Parent child position issue is in here. SetParent_W7 test CORE-6651.
1318 if (//((Window->style & WS_CHILD) != 0) && <- Fixes wine msg test_SetParent: "rects do not match", the last test.
1319 Parent &&
1320 Parent != Window->head.rpdesk->pDeskInfo->spwnd)
1321 {
1322 TRACE("Not SWP_NOMOVE 1 Parent client offset X %d Y %d\n",X,Y);
1323 X += Parent->rcClient.left;
1324 Y += Parent->rcClient.top;
1325 TRACE("Not SWP_NOMOVE 2 Parent client offset X %d Y %d\n",X,Y);
1326 }
1327
1328 WindowRect->left = X;
1329 WindowRect->top = Y;
1330 WindowRect->right += X - Window->rcWindow.left;
1331 WindowRect->bottom += Y - Window->rcWindow.top;
1332
1333 RECTL_vOffsetRect(ClientRect, X - Window->rcWindow.left,
1334 Y - Window->rcWindow.top);
1335 }
1337
1338 TRACE( "hwnd %p, after %p, swp %d,%d %dx%d flags %08x\n",
1339 WinPos->hwnd, WinPos->hwndInsertAfter, WinPos->x, WinPos->y,
1340 WinPos->cx, WinPos->cy, WinPos->flags );
1341 TRACE("WindowRect: %d %d %d %d\n", WindowRect->left,WindowRect->top,WindowRect->right,WindowRect->bottom);
1342 TRACE("ClientRect: %d %d %d %d\n", ClientRect->left,ClientRect->top,ClientRect->right,ClientRect->bottom);
1343
1344 return TRUE;
1345}
#define SWP_NOCLIENTSIZE
Definition: msg.h:31
#define SWP_NOCLIENTMOVE
Definition: msg.h:32
#define Y(I)
#define X(b, s)
if(dx< 0)
Definition: linetemp.h:194
#define SWP_AGG_NOCLIENTCHANGE
Definition: winpos.c:26
HWND hwnd
Definition: winuser.h:3591
HWND hwndInsertAfter
Definition: winuser.h:3592
#define WM_WINDOWPOSCHANGING
Definition: winuser.h:1664
#define SWP_NOSENDCHANGING
Definition: winuser.h:1254

Referenced by co_WinPosSetWindowPos().

◆ co_WinPosGetMinMaxInfo()

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

Definition at line 940 of file winpos.c.

942{
943 MINMAXINFO MinMax;
944 PMONITOR monitor;
945 INT xinc, yinc;
946 LONG style = Window->style;
947 LONG adjustedStyle;
948 LONG exstyle = Window->ExStyle;
949 RECT rc;
950 DWORD adjust;
951
953
954 /* Compute default values */
955
956 rc = Window->rcWindow;
957 MinMax.ptReserved.x = rc.left;
958 MinMax.ptReserved.y = rc.top;
959
960 if ((style & WS_CAPTION) == WS_CAPTION)
961 adjustedStyle = style & ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
962 else
963 adjustedStyle = style;
964
965 if (Window->spwndParent)
966 IntGetClientRect(Window->spwndParent, &rc);
967
968 adjust = IntGetWindowBorders(adjustedStyle, exstyle);
969
970 // Handle special case while maximized. CORE-15893
971 if ((adjustedStyle & WS_THICKFRAME) && !(adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
972 adjust += 1;
973
974 xinc = yinc = adjust;
975
976 if ((adjustedStyle & WS_THICKFRAME) && (adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
977 {
980 }
981
985
986 xinc = -rc.left;
987 yinc = -rc.top;
988
989 MinMax.ptMaxSize.x = rc.right - rc.left;
990 MinMax.ptMaxSize.y = rc.bottom - rc.top;
991 if (style & (WS_DLGFRAME | WS_BORDER))
992 {
995 }
996 else
997 {
998 MinMax.ptMinTrackSize.x = 2 * xinc;
999 MinMax.ptMinTrackSize.y = 2 * yinc;
1000 }
1003 MinMax.ptMaxPosition.x = -xinc;
1004 MinMax.ptMaxPosition.y = -yinc;
1005
1006 if (!EMPTYPOINT(Window->InternalPos.MaxPos)) MinMax.ptMaxPosition = Window->InternalPos.MaxPos;
1007
1009
1010 /* if the app didn't change the values, adapt them for the current monitor */
1011 if ((monitor = UserGetPrimaryMonitor()))
1012 {
1013 RECT rc_work;
1014
1015 rc_work = monitor->rcMonitor;
1016
1017 if (style & WS_MAXIMIZEBOX)
1018 {
1019 if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP)))
1020 rc_work = monitor->rcWork;
1021 }
1022
1023 if (MinMax.ptMaxSize.x == UserGetSystemMetrics(SM_CXSCREEN) + 2 * xinc &&
1024 MinMax.ptMaxSize.y == UserGetSystemMetrics(SM_CYSCREEN) + 2 * yinc)
1025 {
1026 MinMax.ptMaxSize.x = (rc_work.right - rc_work.left) + 2 * xinc;
1027 MinMax.ptMaxSize.y = (rc_work.bottom - rc_work.top) + 2 * yinc;
1028 }
1029 if (MinMax.ptMaxPosition.x == -xinc && MinMax.ptMaxPosition.y == -yinc)
1030 {
1031 MinMax.ptMaxPosition.x = rc_work.left - xinc;
1032 MinMax.ptMaxPosition.y = rc_work.top - yinc;
1033 }
1034 if (MinMax.ptMaxSize.x >= (monitor->rcMonitor.right - monitor->rcMonitor.left) &&
1035 MinMax.ptMaxSize.y >= (monitor->rcMonitor.bottom - monitor->rcMonitor.top) )
1036 {
1038 }
1039 else
1040 Window->state &= ~WNDS_MAXIMIZESTOMONITOR;
1041 }
1042
1043
1044 MinMax.ptMaxTrackSize.x = max(MinMax.ptMaxTrackSize.x,
1045 MinMax.ptMinTrackSize.x);
1046 MinMax.ptMaxTrackSize.y = max(MinMax.ptMaxTrackSize.y,
1047 MinMax.ptMinTrackSize.y);
1048
1049 if (MaxSize)
1050 *MaxSize = MinMax.ptMaxSize;
1051 if (MaxPos)
1052 *MaxPos = MinMax.ptMaxPosition;
1053 if (MinTrack)
1054 *MinTrack = MinMax.ptMinTrackSize;
1055 if (MaxTrack)
1056 *MaxTrack = MinMax.ptMaxTrackSize;
1057
1058 return 0; // FIXME: What does it return? Wine returns MINMAXINFO.
1059}
unsigned long DWORD
Definition: ntddk_ex.h:95
#define WNDS_MAXIMIZESTOMONITOR
Definition: ntuser.h:635
#define EMPTYPOINT(pt)
Definition: winpos.c:29
DWORD IntGetWindowBorders(DWORD Style, DWORD ExStyle)
Definition: winpos.c:921
#define WS_CAPTION
Definition: pedump.c:624
#define WS_MAXIMIZEBOX
Definition: pedump.c:632
#define WS_BORDER
Definition: pedump.c:625
#define WS_DLGFRAME
Definition: pedump.c:626
#define WS_THICKFRAME
Definition: pedump.c:630
RECT rcWork
Definition: monitor.h:19
RECT rcMonitor
Definition: monitor.h:18
POINT ptMaxPosition
Definition: winuser.h:3632
POINT ptMaxSize
Definition: winuser.h:3631
POINT ptMinTrackSize
Definition: winuser.h:3633
POINT ptReserved
Definition: winuser.h:3630
POINT ptMaxTrackSize
Definition: winuser.h:3634
VOID FASTCALL RECTL_vInflateRect(_Inout_ RECTL *rect, _In_ INT dx, _In_ INT dy)
Definition: rect.c:101
PMONITOR NTAPI UserGetPrimaryMonitor(VOID)
Definition: monitor.c:102
#define SM_CYSCREEN
Definition: winuser.h:963
#define SM_CXMINTRACK
Definition: winuser.h:1000
#define SM_CXFRAME
Definition: winuser.h:997
#define SM_CYFRAME
Definition: winuser.h:999
#define SM_CXMAXTRACK
Definition: winuser.h:1025
#define WM_GETMINMAXINFO
Definition: winuser.h:1643
#define SM_CYMAXTRACK
Definition: winuser.h:1026
#define SM_CXDLGFRAME
Definition: winuser.h:969
#define SM_CYDLGFRAME
Definition: winuser.h:971
#define SM_CXSCREEN
Definition: winuser.h:962
#define SM_CYMINTRACK
Definition: winuser.h:1001

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

◆ co_WinPosGetNonClientSize()

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

Definition at line 2387 of file winpos.c.

2388{
2390
2392
2393 *ClientRect = *WindowRect;
2395
2396 FixClientRect(ClientRect, WindowRect);
2397
2398 return Result;
2399}
LRESULT FASTCALL co_IntSendMessageNoWait(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1763
LONG_PTR LRESULT
Definition: windef.h:209
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409

Referenced by co_IntCreateScrollBars(), and co_UserCreateWindowEx().

◆ co_WinPosMinMaximize()

UINT FASTCALL co_WinPosMinMaximize ( PWND  Wnd,
UINT  ShowFlag,
RECT NewPos 
)

Definition at line 2436 of file winpos.c.

2437{
2438 POINT Size;
2439 WINDOWPLACEMENT wpl;
2440 LONG old_style;
2441 UINT SwpFlags = 0;
2442
2443 ASSERT_REFS_CO(Wnd);
2444
2445 wpl.length = sizeof(wpl);
2446 IntGetWindowPlacement( Wnd, &wpl );
2447
2449 {
2450 ERR("WinPosMinMaximize WH_CBT Call Hook return!\n");
2451 return SWP_NOSIZE | SWP_NOMOVE;
2452 }
2453 if (Wnd->style & WS_MINIMIZE)
2454 {
2455 switch (ShowFlag)
2456 {
2457 case SW_MINIMIZE:
2458 case SW_SHOWMINNOACTIVE:
2459 case SW_SHOWMINIMIZED:
2460 case SW_FORCEMINIMIZE:
2461 return SWP_NOSIZE | SWP_NOMOVE;
2462 }
2464 {
2465 return(SWP_NOSIZE | SWP_NOMOVE);
2466 }
2467 SwpFlags |= SWP_NOCOPYBITS;
2468 }
2469 switch (ShowFlag)
2470 {
2471 case SW_MINIMIZE:
2472 case SW_SHOWMINNOACTIVE:
2473 case SW_SHOWMINIMIZED:
2474 case SW_FORCEMINIMIZE:
2475 {
2476 //ERR("MinMaximize Minimize\n");
2477 if (Wnd->style & WS_MAXIMIZE)
2478 {
2479 Wnd->InternalPos.flags |= WPF_RESTORETOMAXIMIZED;
2480 }
2481 else
2482 {
2483 Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
2484 }
2485
2486 old_style = IntSetStyle( Wnd, WS_MINIMIZE, WS_MAXIMIZE );
2487
2489
2490 if (!(Wnd->InternalPos.flags & WPF_SETMINPOSITION))
2491 Wnd->InternalPos.flags &= ~WPF_MININIT;
2492
2494
2495 if (!(old_style & WS_MINIMIZE))
2496 {
2497 SwpFlags |= SWP_STATECHANGED;
2499 }
2500
2501 RECTL_vSetRect(NewPos, wpl.ptMinPosition.x, wpl.ptMinPosition.y,
2504 SwpFlags |= SWP_NOCOPYBITS;
2505 break;
2506 }
2507
2508 case SW_MAXIMIZE:
2509 {
2510 //ERR("MinMaximize Maximize\n");
2511 IntSetSnapEdge(Wnd, HTNOWHERE); /* Mark as not snapped (for Win+Left,Up,Down) */
2512 if ((Wnd->style & WS_MAXIMIZE) && (Wnd->style & WS_VISIBLE))
2513 {
2514 SwpFlags = SWP_NOSIZE | SWP_NOMOVE;
2515 break;
2516 }
2518
2519 /*ERR("Maximize: %d,%d %dx%d\n",
2520 wpl.ptMaxPosition.x, wpl.ptMaxPosition.y, Size.x, Size.y);
2521 */
2522 old_style = IntSetStyle( Wnd, WS_MAXIMIZE, WS_MINIMIZE );
2523 /*if (old_style & WS_MINIMIZE)
2524 {
2525 IntShowOwnedPopups(Wnd, TRUE);
2526 }*/
2527
2528 if (!(old_style & WS_MAXIMIZE)) SwpFlags |= SWP_STATECHANGED;
2529 RECTL_vSetRect(NewPos, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
2530 //wpl.ptMaxPosition.x + Size.x, wpl.ptMaxPosition.y + Size.y);
2531 Size.x, Size.y);
2532 break;
2533 }
2534
2535 case SW_SHOWNOACTIVATE:
2536 Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
2537 /* fall through */
2538 case SW_SHOWNORMAL:
2539 case SW_RESTORE:
2540 case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
2541 {
2542 //ERR("MinMaximize Restore\n");
2543 old_style = IntSetStyle( Wnd, 0, WS_MINIMIZE | WS_MAXIMIZE );
2544 if (old_style & WS_MINIMIZE)
2545 {
2547
2548 if (Wnd->InternalPos.flags & WPF_RESTORETOMAXIMIZED)
2549 {
2551 IntSetStyle( Wnd, WS_MAXIMIZE, 0 );
2552 SwpFlags |= SWP_STATECHANGED;
2553 RECTL_vSetRect(NewPos, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
2554 wpl.ptMaxPosition.x + Size.x, wpl.ptMaxPosition.y + Size.y);
2555 break;
2556 }
2557 else
2558 {
2559 *NewPos = wpl.rcNormalPosition;
2560 if (ShowFlag != SW_SHOWNORMAL && ShowFlag != SW_SHOWDEFAULT)
2561 {
2562 UINT edge = IntGetWindowSnapEdge(Wnd);
2563 if (edge)
2564 co_IntCalculateSnapPosition(Wnd, edge, NewPos);
2565 }
2566 NewPos->right -= NewPos->left;
2567 NewPos->bottom -= NewPos->top;
2568 break;
2569 }
2570 }
2571 else
2572 {
2573 if (!(old_style & WS_MAXIMIZE))
2574 {
2575 break;
2576 }
2577 SwpFlags |= SWP_STATECHANGED;
2578 Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
2579 *NewPos = wpl.rcNormalPosition;
2580 NewPos->right -= NewPos->left;
2581 NewPos->bottom -= NewPos->top;
2582 break;
2583 }
2584 }
2585 }
2586 return SwpFlags;
2587}
#define SWP_STATECHANGED
Definition: msg.c:42
LRESULT APIENTRY co_HOOK_CallHooks(INT HookId, INT Code, WPARAM wParam, LPARAM lParam)
Definition: hook.c:1102
BOOL FASTCALL IntGetWindowPlacement(PWND Wnd, WINDOWPLACEMENT *lpwndpl)
Definition: winpos.c:564
static VOID FASTCALL WinPosFindIconPos(PWND Window, POINT *Pos)
Definition: winpos.c:787
POINT ptMaxPosition
Definition: winuser.h:3297
RECT rcNormalPosition
Definition: winuser.h:3298
POINT ptMinPosition
Definition: winuser.h:3296
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:895
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
FORCEINLINE VOID RECTL_vSetRect(_Out_ RECTL *prcl, _In_ LONG left, _In_ LONG top, _In_ LONG right, _In_ LONG bottom)
Definition: rect.h:5
ULONG FASTCALL IntSetStyle(PWND pwnd, ULONG set_bits, ULONG clear_bits)
Definition: window.c:145
BOOL FASTCALL IntShowOwnedPopups(PWND OwnerWnd, BOOL fShow)
Definition: window.c:4654
UINT_PTR WPARAM
Definition: windef.h:207
#define SW_SHOWNORMAL
Definition: winuser.h:773
#define HCBT_MINMAX
Definition: winuser.h:56
#define WM_QUERYOPEN
Definition: winuser.h:1627
#define SW_MINIMIZE
Definition: winuser.h:779
#define RDW_NOINTERNALPAINT
Definition: winuser.h:1220
#define SW_SHOWNOACTIVATE
Definition: winuser.h:777
#define WH_CBT
Definition: winuser.h:35
#define SW_SHOWDEFAULT
Definition: winuser.h:783
#define SW_SHOWMINIMIZED
Definition: winuser.h:774
#define SW_FORCEMINIMIZE
Definition: winuser.h:784
#define WPF_RESTORETOMAXIMIZED
Definition: winuser.h:2535
#define SW_RESTORE
Definition: winuser.h:782
#define SW_MAXIMIZE
Definition: winuser.h:775
#define RDW_NOERASE
Definition: winuser.h:1218
#define RDW_VALIDATE
Definition: winuser.h:1221
#define WPF_SETMINPOSITION
Definition: winuser.h:2536
#define SW_SHOWMINNOACTIVE
Definition: winuser.h:780

Referenced by co_UserCreateWindowEx(), and co_WinPosShowWindow().

◆ co_WinPosSearchChildren()

static PWND co_WinPosSearchChildren ( IN PWND  ScopeWin,
IN POINT Point,
IN OUT USHORT HitTest,
IN BOOL  Ignore 
)
static

Definition at line 2876 of file winpos.c.

2882{
2883 HWND *List, *phWnd;
2884 PWND pwndChild = NULL;
2885
2886 /* not visible */
2887 if (!(ScopeWin->style & WS_VISIBLE))
2888 {
2889 return NULL;
2890 }
2891
2892 /* not in window or in window region */
2893 if (!IntPtInWindow(ScopeWin, Point->x, Point->y))
2894 {
2895 return NULL;
2896 }
2897
2898 /* transparent */
2899 if ((ScopeWin->ExStyle & (WS_EX_LAYERED|WS_EX_TRANSPARENT)) == (WS_EX_LAYERED|WS_EX_TRANSPARENT))
2900 {
2901 return NULL;
2902 }
2903
2904 if (!Ignore && (ScopeWin->style & WS_DISABLED))
2905 { /* disabled child */
2906 if ((ScopeWin->style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return NULL;
2907 /* process the hit error */
2908 *HitTest = HTERROR;
2909 return ScopeWin;
2910 }
2911
2912 /* not minimized and check if point is inside the window */
2913 if (!(ScopeWin->style & WS_MINIMIZE) &&
2914 RECTL_bPointInRect(&ScopeWin->rcClient, Point->x, Point->y) )
2915 {
2916 UserReferenceObject(ScopeWin);
2917
2918 List = IntWinListChildren(ScopeWin);
2919 if (List)
2920 {
2921 for (phWnd = List; *phWnd; ++phWnd)
2922 {
2923 if (!(pwndChild = ValidateHwndNoErr(*phWnd)))
2924 {
2925 continue;
2926 }
2927
2928 pwndChild = co_WinPosSearchChildren(pwndChild, Point, HitTest, Ignore);
2929
2930 if (pwndChild != NULL)
2931 {
2932 /* We found a window. Don't send any more WM_NCHITTEST messages */
2934 UserDereferenceObject(ScopeWin);
2935 return pwndChild;
2936 }
2937 }
2939 }
2940 UserDereferenceObject(ScopeWin);
2941 }
2942
2943 if (ScopeWin->head.pti == PsGetCurrentThreadWin32Thread())
2944 {
2945 *HitTest = (USHORT)co_IntSendMessage(UserHMGetHandle(ScopeWin), WM_NCHITTEST, 0, MAKELONG(Point->x, Point->y));
2946
2947 if ((*HitTest) == (USHORT)HTTRANSPARENT)
2948 {
2949 return NULL;
2950 }
2951 }
2952 else
2953 {
2954 if (*HitTest == HTNOWHERE && pwndChild == NULL) *HitTest = HTCLIENT;
2955 }
2956
2957 return ScopeWin;
2958}
#define ValidateHwndNoErr(hwnd)
Definition: precomp.h:84
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
static PWND co_WinPosSearchChildren(IN PWND ScopeWin, IN POINT *Point, IN OUT USHORT *HitTest, IN BOOL Ignore)
Definition: winpos.c:2876
#define WS_EX_TRANSPARENT
Definition: pedump.c:649
unsigned short USHORT
Definition: pedump.c:61
#define MAKELONG(a, b)
Definition: typedefs.h:249
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
FORCEINLINE BOOL RECTL_bPointInRect(_In_ const RECTL *prcl, _In_ INT x, _In_ INT y)
Definition: rect.h:52
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:644
VOID FASTCALL UserReferenceObject(PVOID obj)
Definition: object.c:731
#define USERTAG_WINDOWLIST
Definition: tags.h:298
HWND *FASTCALL IntWinListChildren(PWND Window)
Definition: window.c:276
FORCEINLINE BOOL IntPtInWindow(PWND pwnd, INT x, INT y)
Definition: winpos.h:30
#define HTERROR
Definition: winuser.h:2475
#define WM_NCHITTEST
Definition: winuser.h:1689
#define HTCLIENT
Definition: winuser.h:2478
#define WS_EX_LAYERED
Definition: winuser.h:389
#define HTTRANSPARENT
Definition: winuser.h:2476

Referenced by co_WinPosSearchChildren(), and co_WinPosWindowFromPoint().

◆ co_WinPosSendSizeMove()

void FASTCALL co_WinPosSendSizeMove ( PWND  Wnd)

Definition at line 2402 of file winpos.c.

2403{
2404 RECTL Rect;
2405 LPARAM lParam;
2407
2408 IntGetClientRect(Wnd, &Rect);
2409 lParam = MAKELONG(Rect.right-Rect.left, Rect.bottom-Rect.top);
2410
2411 Wnd->state &= ~WNDS_SENDSIZEMOVEMSGS;
2412
2413 if (Wnd->style & WS_MAXIMIZE)
2414 {
2416 }
2417 else if (Wnd->style & WS_MINIMIZE)
2418 {
2420 lParam = 0;
2421 }
2422
2424
2426 lParam = MAKELONG(Wnd->rcClient.left, Wnd->rcClient.top);
2427 else
2428 lParam = MAKELONG(Wnd->rcClient.left-Wnd->spwndParent->rcClient.left, Wnd->rcClient.top-Wnd->spwndParent->rcClient.top);
2429
2431
2433}
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
VOID FASTCALL IntEngWindowChanged(_In_ struct _WND *Window, _In_ FLONG flChanged)
RECT rcClient
Definition: ntuser.h:717
DWORD state
Definition: ntuser.h:701
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:194
#define WOC_RGN_CLIENT
Definition: winddi.h:1265
#define WM_SIZE
Definition: winuser.h:1614
#define SIZE_MINIMIZED
Definition: winuser.h:2509
#define SIZE_MAXIMIZED
Definition: winuser.h:2510
#define WM_MOVE
Definition: winuser.h:1613
#define SIZE_RESTORED
Definition: winuser.h:2508

Referenced by co_UserCreateWindowEx(), and co_WinPosShowWindow().

◆ co_WinPosSetWindowPos()

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

Definition at line 1792 of file winpos.c.

1801{
1802 WINDOWPOS WinPos;
1803 RECTL NewWindowRect;
1804 RECTL NewClientRect;
1805 RECTL valid_rects[2];
1806 PREGION VisBefore = NULL;
1807 PREGION VisBeforeJustClient = NULL;
1808 PREGION VisAfter = NULL;
1810 ULONG WvrFlags = 0;
1811 RECTL OldWindowRect, OldClientRect;
1812 int RgnType;
1813 HDC Dc;
1815 PWND Ancestor;
1816 BOOL bPointerInWindow, PosChanged = FALSE;
1818
1820
1821 TRACE("pwnd %p, after %p, %d,%d (%dx%d), flags 0x%x\n",
1822 Window, WndInsertAfter, x, y, cx, cy, flags);
1823#if DBG
1824 dump_winpos_flags(flags);
1825#endif
1826
1827 /* FIXME: Get current active window from active queue. Why? since r2915. */
1828
1829 bPointerInWindow = IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y);
1830
1831 WinPos.hwnd = UserHMGetHandle(Window);
1832 WinPos.hwndInsertAfter = WndInsertAfter;
1833 WinPos.x = x;
1834 WinPos.y = y;
1835 WinPos.cx = cx;
1836 WinPos.cy = cy;
1837 WinPos.flags = flags;
1838
1839 if ( flags & SWP_ASYNCWINDOWPOS )
1840 {
1841 LRESULT lRes;
1843 if ( ppos )
1844 {
1845 WinPos.flags &= ~SWP_ASYNCWINDOWPOS; // Clear flag.
1846 *ppos = WinPos;
1847 /* Yes it's a pointer inside Win32k! */
1848 lRes = co_IntSendMessageNoWait( WinPos.hwnd, WM_ASYNC_SETWINDOWPOS, 0, (LPARAM)ppos);
1849 /* We handle this the same way as Event Hooks and Hooks. */
1850 if ( !lRes )
1851 {
1853 return FALSE;
1854 }
1855 return TRUE;
1856 }
1857 return FALSE;
1858 }
1859
1860 co_WinPosDoWinPosChanging(Window, &WinPos, &NewWindowRect, &NewClientRect);
1861
1862 /* Does the window still exist? */
1863 if (!IntIsWindow(WinPos.hwnd))
1864 {
1865 TRACE("WinPosSetWindowPos: Invalid handle 0x%p!\n",WinPos.hwnd);
1867 return FALSE;
1868 }
1869
1870 /* Fix up the flags. */
1871 if (!WinPosFixupFlags(&WinPos, Window))
1872 {
1873 // See Note.
1874 return TRUE;
1875 }
1876
1877 Ancestor = UserGetAncestor(Window, GA_PARENT);
1878 if ( (WinPos.flags & (SWP_NOZORDER | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) != SWP_NOZORDER &&
1879 Ancestor && UserHMGetHandle(Ancestor) == IntGetDesktopWindow() )
1880 {
1882 }
1883
1884 if (!(WinPos.flags & SWP_NOREDRAW))
1885 {
1886 /* Compute the visible region before the window position is changed */
1887 if (!(WinPos.flags & SWP_SHOWWINDOW) &&
1888 (WinPos.flags & (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1891 {
1893 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1894
1895 if ( VisBefore != NULL &&
1896 REGION_Complexity(VisBefore) == NULLREGION )
1897 {
1898 REGION_Delete(VisBefore);
1899 VisBefore = NULL;
1900 }
1901 else if(VisBefore)
1902 {
1903 REGION_bOffsetRgn(VisBefore, -Window->rcWindow.left, -Window->rcWindow.top);
1904 }
1905
1906 /* Calculate the non client area for resizes, as this is used in the copy region */
1907 if ((WinPos.flags & (SWP_NOSIZE | SWP_FRAMECHANGED)) != SWP_NOSIZE)
1908 {
1909 VisBeforeJustClient = VIS_ComputeVisibleRegion(Window, TRUE, FALSE,
1910 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1911
1912 if ( VisBeforeJustClient != NULL &&
1913 REGION_Complexity(VisBeforeJustClient) == NULLREGION )
1914 {
1915 REGION_Delete(VisBeforeJustClient);
1916 VisBeforeJustClient = NULL;
1917 }
1918 else if(VisBeforeJustClient)
1919 {
1920 REGION_bOffsetRgn(VisBeforeJustClient, -Window->rcWindow.left, -Window->rcWindow.top);
1921 }
1922 }
1923 }
1924 }
1925
1927 if (Window->hrgnNewFrame)
1928 {
1929 SelectWindowRgn( Window, Window->hrgnNewFrame ); // Should be PSMWP->acvr->hrgnClip
1930 Window->hrgnNewFrame = NULL;
1931 }
1932
1933 WvrFlags = co_WinPosDoNCCALCSize(Window, &WinPos, &NewWindowRect, &NewClientRect, valid_rects);
1934
1935// ERR("co_WinPosDoNCCALCSize returned 0x%x\n valid dest: %d %d %d %d\n valid src : %d %d %d %d\n", WvrFlags,
1936// valid_rects[0].left,valid_rects[0].top,valid_rects[0].right,valid_rects[0].bottom,
1937// valid_rects[1].left,valid_rects[1].top,valid_rects[1].right,valid_rects[1].bottom);
1938
1939 /* Validate link windows. (also take into account shell window in hwndShellWindow) */
1940 if (!(WinPos.flags & SWP_NOZORDER) && WinPos.hwnd != UserGetShellWindow())
1941 {
1943 }
1944
1945 OldWindowRect = Window->rcWindow;
1946 OldClientRect = Window->rcClient;
1947
1948 if (NewClientRect.left != OldClientRect.left ||
1949 NewClientRect.top != OldClientRect.top)
1950 {
1951 // Move child window if their parent is moved. Keep Child window relative to Parent...
1953 NewClientRect.left - OldClientRect.left,
1954 NewClientRect.top - OldClientRect.top);
1955 PosChanged = TRUE;
1956 }
1957
1958 Window->rcWindow = NewWindowRect;
1959 Window->rcClient = NewClientRect;
1960
1961 /* erase parent when hiding or resizing child */
1962 if (WinPos.flags & SWP_HIDEWINDOW)
1963 {
1964 /* Clear the update region */
1966 NULL,
1967 0,
1969
1970 if (UserIsDesktopWindow(Window->spwndParent))
1972
1973 Window->style &= ~WS_VISIBLE; //IntSetStyle( Window, 0, WS_VISIBLE );
1974 Window->head.pti->cVisWindows--;
1976 }
1977 else if (WinPos.flags & SWP_SHOWWINDOW)
1978 {
1979 if (Window->style & WS_CHILD)
1980 {
1981 if ((Window->style & WS_POPUP) && (Window->ExStyle & WS_EX_APPWINDOW))
1982 {
1984 if (!(WinPos.flags & SWP_NOACTIVATE))
1986 }
1987 }
1988 else if ((Window->ExStyle & WS_EX_APPWINDOW) ||
1989 (!(Window->ExStyle & WS_EX_TOOLWINDOW) && !Window->spwndOwner &&
1990 (!Window->spwndParent || UserIsDesktopWindow(Window->spwndParent))))
1991 {
1993 {
1995 if (!(WinPos.flags & SWP_NOACTIVATE))
1997 }
1998 }
1999
2000 Window->style |= WS_VISIBLE; //IntSetStyle( Window, WS_VISIBLE, 0 );
2001 Window->head.pti->cVisWindows++;
2003 }
2004 else
2005 {
2007 }
2008
2009 if (Window->hrgnUpdate != NULL && Window->hrgnUpdate != HRGN_WINDOW)
2010 {
2011 NtGdiOffsetRgn(Window->hrgnUpdate,
2012 NewWindowRect.left - OldWindowRect.left,
2013 NewWindowRect.top - OldWindowRect.top);
2014 }
2015
2016 DceResetActiveDCEs(Window); // For WS_VISIBLE changes.
2017
2018 // Change or update, set send non-client paint flag.
2019 if ( Window->style & WS_VISIBLE &&
2020 (WinPos.flags & SWP_STATECHANGED || (!(Window->state2 & WNDS2_WIN31COMPAT) && WinPos.flags & SWP_NOREDRAW ) ) )
2021 {
2022 TRACE("Set WNDS_SENDNCPAINT %p\n",Window);
2023 Window->state |= WNDS_SENDNCPAINT;
2024 }
2025
2026 if (!(WinPos.flags & SWP_NOREDRAW) && ((WinPos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE))
2027 {
2028 /* Determine the new visible region */
2030 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
2031
2032 if ( VisAfter != NULL &&
2033 REGION_Complexity(VisAfter) == NULLREGION )
2034 {
2035 REGION_Delete(VisAfter);
2036 VisAfter = NULL;
2037 }
2038 else if(VisAfter)
2039 {
2040 /* Clip existing update region to new window size */
2041 if (Window->hrgnUpdate != NULL)
2042 {
2043 PREGION RgnUpdate = REGION_LockRgn(Window->hrgnUpdate);
2044 if (RgnUpdate)
2045 {
2046 RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, VisAfter, RGN_AND);
2047 REGION_UnlockRgn(RgnUpdate);
2048 }
2049 }
2050 REGION_bOffsetRgn(VisAfter, -Window->rcWindow.left, -Window->rcWindow.top);
2051 }
2052
2053 /*
2054 * Determine which pixels can be copied from the old window position
2055 * to the new. Those pixels must be visible in both the old and new
2056 * position. Also, check the class style to see if the windows of this
2057 * class need to be completely repainted on (horizontal/vertical) size
2058 * change.
2059 */
2060 if (VisBefore != NULL &&
2061 VisAfter != NULL &&
2062 !(WvrFlags & WVR_REDRAW) &&
2063 !(WinPos.flags & SWP_NOCOPYBITS) &&
2064 !(Window->ExStyle & WS_EX_TRANSPARENT))
2065 {
2066
2067 /*
2068 * If this is (also) a window resize, the whole nonclient area
2069 * needs to be repainted. So we limit the copy to the client area,
2070 * 'cause there is no use in copying it (would possibly cause
2071 * "flashing" too). However, if the copy region is already empty,
2072 * we don't have to crop (can't take anything away from an empty
2073 * region...)
2074 */
2075
2076 CopyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2077 if ((WinPos.flags & SWP_NOSIZE) && (WinPos.flags & SWP_NOCLIENTSIZE))
2078 RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBefore, RGN_AND);
2079 else if (VisBeforeJustClient != NULL)
2080 {
2081 RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBeforeJustClient, RGN_AND);
2082 }
2083
2084 /* Now use in copying bits which are in the update region. */
2085 if (Window->hrgnUpdate != NULL)
2086 {
2087 PREGION RgnUpdate = REGION_LockRgn(Window->hrgnUpdate);
2088 if (RgnUpdate)
2089 {
2090 REGION_bOffsetRgn(CopyRgn, NewWindowRect.left, NewWindowRect.top);
2092 REGION_bOffsetRgn(CopyRgn, -NewWindowRect.left, -NewWindowRect.top);
2093 REGION_UnlockRgn(RgnUpdate);
2094 }
2095 }
2096
2097 /*
2098 * Now, get the bounding box of the copy region. If it's empty
2099 * there's nothing to copy. Also, it's no use copying bits onto
2100 * themselves.
2101 */
2103 {
2104 /* Nothing to copy, clean up */
2106 CopyRgn = NULL;
2107 }
2108 else if ( OldWindowRect.left != NewWindowRect.left ||
2109 OldWindowRect.top != NewWindowRect.top ||
2110 (WinPos.flags & SWP_FRAMECHANGED) )
2111 {
2112 HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
2113 PREGION DcRgnObj = REGION_LockRgn(DcRgn);
2114
2115 /*
2116 * Small trick here: there is no function to bitblt a region. So
2117 * we set the region as the clipping region, take the bounding box
2118 * of the region and bitblt that. Since nothing outside the clipping
2119 * region is copied, this has the effect of bitblt'ing the region.
2120 *
2121 * Since NtUserGetDCEx takes ownership of the clip region, we need
2122 * to create a copy of CopyRgn and pass that. We need CopyRgn later
2123 */
2125 REGION_bOffsetRgn(DcRgnObj, NewWindowRect.left, NewWindowRect.top);
2126 REGION_UnlockRgn(DcRgnObj);
2127 Dc = UserGetDCEx( Window,
2128 DcRgn,
2129 DCX_WINDOW|DCX_CACHE|DCX_INTERSECTRGN|DCX_CLIPSIBLINGS|DCX_KEEPCLIPRGN); // DCX_WINDOW will set first, go read WinDC.c.
2130 NtGdiBitBlt( Dc,
2131 CopyRect.left, CopyRect.top,
2132 CopyRect.right - CopyRect.left,
2133 CopyRect.bottom - CopyRect.top,
2134 Dc,
2135 CopyRect.left + (OldWindowRect.left - NewWindowRect.left),
2136 CopyRect.top + (OldWindowRect.top - NewWindowRect.top),
2137 SRCCOPY,
2138 0,
2139 0);
2140
2143 GreDeleteObject(DcRgn);
2144 }
2145 }
2146 else
2147 {
2148 CopyRgn = NULL;
2149 }
2150
2151 /* We need to redraw what wasn't visible before or force a redraw */
2152 if (VisAfter != NULL)
2153 {
2154 PREGION DirtyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2155 if (DirtyRgn)
2156 {
2157 if (CopyRgn != NULL)
2158 {
2159 RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, CopyRgn, RGN_DIFF);
2160 }
2161 else
2162 {
2163 RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, 0, RGN_COPY);
2164 }
2165
2166 if (RgnType != ERROR && RgnType != NULLREGION) // Regions moved.
2167 {
2168 /* old code
2169 NtGdiOffsetRgn(DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
2170 IntInvalidateWindows( Window,
2171 DirtyRgn,
2172 RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
2173 }
2174 GreDeleteObject(DirtyRgn);
2175 */
2176
2177 PWND Parent = Window->spwndParent;
2178
2179 REGION_bOffsetRgn( DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
2180
2181 if ( (Window->style & WS_CHILD) && (Parent) && !(Parent->style & WS_CLIPCHILDREN))
2182 {
2185 }
2187 }
2188 else if (RgnType != ERROR && RgnType == NULLREGION) // Must be the same. See CORE-7166 & CORE-15934, NC HACK fix.
2189 {
2190 if ( !PosChanged &&
2191 !(WinPos.flags & SWP_DEFERERASE) &&
2192 (WinPos.flags & SWP_FRAMECHANGED) )
2193 {
2194 PWND pwnd = Window;
2195 PWND Parent = Window->spwndParent;
2196
2197 if ( pwnd->style & WS_CHILD ) // Fix ProgMan menu bar drawing.
2198 {
2199 TRACE("SWP_FRAMECHANGED win child %p Parent %p\n",pwnd,Parent);
2200 pwnd = Parent ? Parent : pwnd;
2201 }
2202
2203 if ( !(pwnd->style & WS_CHILD) )
2204 {
2205 /*
2206 * Check if we have these specific windows style bits set/reset.
2207 * FIXME: There may be other combinations of styles that need this handling as well.
2208 * This fixes the ReactOS Calculator buttons disappearing in CORE-16827.
2209 */
2210 if ((Window->style & WS_CLIPSIBLINGS) && !(Window->style & (WS_POPUP | WS_CLIPCHILDREN | WS_SIZEBOX)))
2211 {
2212 IntSendNCPaint(pwnd, HRGN_WINDOW); // Paint the whole frame.
2213 }
2214 else // Use region handling
2215 {
2216 HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
2217 PREGION DcRgnObj = REGION_LockRgn(DcRgn);
2218 TRACE("SWP_FRAMECHANGED win %p hRgn %p\n",pwnd, DcRgn);
2219 IntGdiCombineRgn(DcRgnObj, VisBefore, NULL, RGN_COPY);
2220 REGION_UnlockRgn(DcRgnObj);
2221 ForceNCPaintErase(pwnd, DcRgn, DcRgnObj);
2222 GreDeleteObject(DcRgn);
2223 }
2224 }
2225 }
2226 }
2227 REGION_Delete(DirtyRgn);
2228 }
2229 }
2230
2231 /* Expose what was covered before but not covered anymore */
2232 if (VisBefore != NULL)
2233 {
2234 PREGION ExposedRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2235 if (ExposedRgn)
2236 {
2237 RgnType = IntGdiCombineRgn(ExposedRgn, VisBefore, NULL, RGN_COPY);
2238 REGION_bOffsetRgn(ExposedRgn,
2239 OldWindowRect.left - NewWindowRect.left,
2240 OldWindowRect.top - NewWindowRect.top);
2241
2242 if (VisAfter != NULL)
2243 RgnType = IntGdiCombineRgn(ExposedRgn, ExposedRgn, VisAfter, RGN_DIFF);
2244
2245 if (RgnType != ERROR && RgnType != NULLREGION)
2246 {
2248 }
2249 REGION_Delete(ExposedRgn);
2250 }
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 (VisBefore != NULL)
2299 {
2300 REGION_Delete(VisBefore);
2301 VisBefore = NULL;
2302 }
2303 if (VisBeforeJustClient != NULL)
2304 {
2305 REGION_Delete(VisBeforeJustClient);
2306 VisBeforeJustClient = NULL;
2307 }
2308 if (VisAfter != NULL)
2309 {
2310 REGION_Delete(VisAfter);
2311 VisAfter = NULL;
2312 }
2313 if (CopyRgn != NULL)
2314 {
2316 CopyRgn = NULL;
2317 }
2318
2319 if(!(flags & SWP_DEFERERASE))
2320 {
2321 /* erase parent when hiding or resizing child */
2322 if ((flags & SWP_HIDEWINDOW) ||
2323 (!(flags & SWP_SHOWWINDOW) &&
2325 {
2326 PWND Parent = Window->spwndParent;
2329 }
2330
2331 /* Give newly shown windows a chance to redraw */
2334 {
2336 }
2337 }
2338
2339 /* And last, send the WM_WINDOWPOSCHANGED message */
2340
2341 TRACE("\tstatus hwnd %p flags = %04x\n", Window ? UserHMGetHandle(Window) : NULL, WinPos.flags & SWP_AGG_STATUSFLAGS);
2342
2345 {
2346 /* WM_WINDOWPOSCHANGED is sent even if SWP_NOSENDCHANGING is set
2347 and always contains final window position.
2348 */
2349 WinPos.x = NewWindowRect.left;
2350 WinPos.y = NewWindowRect.top;
2351 WinPos.cx = NewWindowRect.right - NewWindowRect.left;
2352 WinPos.cy = NewWindowRect.bottom - NewWindowRect.top;
2353 TRACE("WM_WINDOWPOSCHANGED hwnd %p Flags %04x\n",WinPos.hwnd,WinPos.flags);
2355 }
2356
2357 if ( WinPos.flags & SWP_FRAMECHANGED || WinPos.flags & SWP_STATECHANGED ||
2358 !(WinPos.flags & SWP_NOCLIENTSIZE) || !(WinPos.flags & SWP_NOCLIENTMOVE) )
2359 {
2360 PWND pWnd = ValidateHwndNoErr(WinPos.hwnd);
2361 if (pWnd)
2362 IntNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, pWnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
2363 }
2364
2365 /* Send WM_IME_SYSTEM:IMS_UPDATEIMEUI to the IME windows if necessary */
2366 if ((WinPos.flags & (SWP_NOMOVE | SWP_NOSIZE)) != (SWP_NOMOVE | SWP_NOSIZE))
2367 {
2368 if (IS_IMM_MODE())
2370 }
2371
2372 if(bPointerInWindow != IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y))
2373 {
2374 /* Generate mouse move message */
2375 MSG msg;
2376 msg.message = WM_MOUSEMOVE;
2377 msg.wParam = UserGetMouseButtonsState();
2378 msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
2379 msg.pt = gpsi->ptCursor;
2381 }
2382
2383 return TRUE;
2384}
#define msg(x)
Definition: auth_time.c:54
VOID FASTCALL DceResetActiveDCEs(PWND Window)
Definition: windc.c:816
PSERVERINFO gpsi
Definition: imm.c:18
#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
static HDC
Definition: imagelist.c:88
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
static BOOL FASTCALL co_WinPosDoWinPosChanging(PWND Window, PWINDOWPOS WinPos, PRECTL WindowRect, PRECTL ClientRect)
Definition: winpos.c:1273
static BOOL FASTCALL WinPosFixupFlags(WINDOWPOS *WinPos, PWND Wnd)
Definition: winpos.c:1557
VOID ForceNCPaintErase(PWND Wnd, HRGN hRgn, PREGION pRgn)
Definition: winpos.c:1697
#define SWP_AGG_STATUSFLAGS
Definition: winpos.c:24
static VOID FASTCALL WinPosInternalMoveWindow(PWND Window, INT MoveX, INT MoveY)
Definition: winpos.c:1527
static BOOL IntValidateParent(PWND Child, PREGION ValidateRgn)
Definition: winpos.c:1063
static HWND FASTCALL WinPosDoOwnedPopups(PWND Window, HWND hWndInsertAfter)
Definition: winpos.c:1361
#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:1186
static VOID FASTCALL IntImeWindowPosChanged(VOID)
Definition: winpos.c:1753
#define RDW_CLIPCHILDREN
Definition: painting.h:15
#define WS_SIZEBOX
Definition: pedump.c:642
#define WS_EX_TOPMOST
Definition: pedump.c:647
#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
Definition: region.h:8
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:621
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
VOID FASTCALL IntInvalidateWindows(PWND Wnd, PREGION Rgn, ULONG Flags)
Definition: painting.c:643
HWND FASTCALL UserGetShellWindow(VOID)
Definition: window.c:3684
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:1391
VOID co_IntShellHookNotify(WPARAM Message, WPARAM wParam, LPARAM lParam)
Definition: desktop.c:1709
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:178
VOID FASTCALL IntLinkHwnd(PWND Wnd, HWND hWndPrev)
Definition: window.c:986
#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
#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
BOOL WINAPI CopyRect(_Out_ LPRECT, _In_ LPCRECT)
#define MAKELPARAM(l, h)
Definition: winuser.h:4011
#define DCX_CACHE
Definition: winuser.h:2117
#define DCX_WINDOW
Definition: winuser.h:2116
#define HSHELL_WINDOWDESTROYED
Definition: winuser.h:1259
#define WM_CHILDACTIVATE
Definition: winuser.h:1641
#define WS_EX_APPWINDOW
Definition: winuser.h:383
#define HSHELL_WINDOWCREATED
Definition: winuser.h:1258
#define GA_PARENT
Definition: winuser.h:2791
#define WM_MOUSEMOVE
Definition: winuser.h:1778
#define RDW_ERASE
Definition: winuser.h:1214
#define RDW_NOCHILDREN
Definition: winuser.h:1225
#define SWP_DEFERERASE
Definition: winuser.h:1255
#define DCX_CLIPSIBLINGS
Definition: winuser.h:2119
#define DCX_INTERSECTRGN
Definition: winuser.h:2125
#define WVR_REDRAW
Definition: winuser.h:2524
#define RDW_ALLCHILDREN
Definition: winuser.h:1224
#define RDW_ERASENOW
Definition: winuser.h:1222
#define RDW_FRAME
Definition: winuser.h:1215
#define RDW_NOFRAME
Definition: winuser.h:1219
#define WM_WINDOWPOSCHANGED
Definition: winuser.h:1665
#define RDW_INVALIDATE
Definition: winuser.h:1217

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

◆ co_WinPosShowWindow()

BOOLEAN FASTCALL co_WinPosShowWindow ( PWND  Wnd,
INT  Cmd 
)

Definition at line 2594 of file winpos.c.

2595{
2596 BOOLEAN WasVisible;
2597 UINT Swp = 0, EventMsg = 0;
2598 RECTL NewPos = {0, 0, 0, 0};
2599 BOOLEAN ShowFlag;
2600 LONG style;
2601 PWND Parent;
2602 PTHREADINFO pti;
2603 //HRGN VisibleRgn;
2604 BOOL ShowOwned = FALSE;
2605 BOOL FirstTime = FALSE;
2606 ASSERT_REFS_CO(Wnd);
2607 //KeRosDumpStackFrames(NULL, 20);
2609 WasVisible = (Wnd->style & WS_VISIBLE) != 0;
2610 style = Wnd->style;
2611
2612 TRACE("co_WinPosShowWindow START hwnd %p Cmd %d usicmd %u\n",
2613 UserHMGetHandle(Wnd), Cmd, pti->ppi->usi.wShowWindow);
2614
2615 if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
2616 {
2617 if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD)
2618 {
2619 if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
2620 {
2621 if (Wnd->spwndOwner == NULL)
2622 {
2623 if ( Cmd == SW_SHOWNORMAL || Cmd == SW_SHOW)
2624 {
2626 }
2627 FirstTime = TRUE;
2628 TRACE("co_WPSW FT 1\n");
2629 }
2630 }
2631 }
2632 }
2633
2634 if ( Cmd == SW_SHOWDEFAULT )
2635 {
2636 if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
2637 {
2638 Cmd = pti->ppi->usi.wShowWindow;
2639 FirstTime = TRUE;
2640 TRACE("co_WPSW FT 2\n");
2641 }
2642 }
2643
2644 if (FirstTime)
2645 {
2647 }
2648
2649 switch (Cmd)
2650 {
2651 case SW_HIDE:
2652 {
2653 if (!WasVisible)
2654 {
2655 //ERR("co_WinPosShowWindow Exit Bad\n");
2656 return FALSE;
2657 }
2659 if (Wnd != pti->MessageQueue->spwndActive)
2661 break;
2662 }
2663
2664 case SW_FORCEMINIMIZE: /* FIXME: Does not work if thread is hung. */
2665 case SW_SHOWMINNOACTIVE:
2667 /* Fall through. */
2668 case SW_SHOWMINIMIZED:
2669 case SW_MINIMIZE: /* CORE-15669: SW_MINIMIZE also shows */
2670 Swp |= SWP_SHOWWINDOW;
2671 {
2672 Swp |= SWP_NOACTIVATE;
2673 if (!(style & WS_MINIMIZE))
2674 {
2676 // Fix wine Win test_SetFocus todo #1 & #2,
2677 if (Cmd == SW_SHOWMINIMIZED)
2678 {
2679 //ERR("co_WinPosShowWindow Set focus 1\n");
2680 if ((style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
2682 else
2683 co_UserSetFocus(0);
2684 }
2685
2686 Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
2687
2688 EventMsg = EVENT_SYSTEM_MINIMIZESTART;
2689 }
2690 else
2691 {
2692 if (WasVisible)
2693 {
2694 //ERR("co_WinPosShowWindow Exit Good\n");
2695 return TRUE;
2696 }
2697 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2698 }
2699 break;
2700 }
2701
2702 case SW_SHOWMAXIMIZED:
2703 {
2704 Swp |= SWP_SHOWWINDOW;
2705 if (!(style & WS_MAXIMIZE))
2706 {
2707 ShowOwned = TRUE;
2708
2709 Swp |= co_WinPosMinMaximize(Wnd, SW_MAXIMIZE, &NewPos);
2710
2711 EventMsg = EVENT_SYSTEM_MINIMIZEEND;
2712 }
2713 else
2714 {
2715 if (WasVisible)
2716 {
2717 //ERR("co_WinPosShowWindow Exit Good 1\n");
2718 return TRUE;
2719 }
2720 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2721 }
2722 break;
2723 }
2724
2725 case SW_SHOWNA:
2727 if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOZORDER;
2728 break;
2729 case SW_SHOW:
2730 if (WasVisible) return(TRUE); // Nothing to do!
2732 /* Don't activate the topmost window. */
2733 if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2734 break;
2735
2736 case SW_SHOWNOACTIVATE:
2738 /* Fall through. */
2739 case SW_SHOWNORMAL:
2740 case SW_SHOWDEFAULT:
2741 case SW_RESTORE:
2742 if (!WasVisible) Swp |= SWP_SHOWWINDOW;
2743 if (style & (WS_MINIMIZE | WS_MAXIMIZE))
2744 {
2745 Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
2746 if (style & WS_MINIMIZE) EventMsg = EVENT_SYSTEM_MINIMIZEEND;
2747 }
2748 else
2749 {
2750 if (WasVisible)
2751 {
2752 //ERR("co_WinPosShowWindow Exit Good 3\n");
2753 return TRUE;
2754 }
2755 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2756 }
2757 if ( style & WS_CHILD &&
2758 !(Wnd->ExStyle & WS_EX_MDICHILD) &&
2759 !(Swp & SWP_STATECHANGED))
2761 break;
2762
2763 default:
2764 //ERR("co_WinPosShowWindow Exit Good 4\n");
2765 return FALSE;
2766 }
2767
2768 ShowFlag = (Cmd != SW_HIDE);
2769
2770 if ((ShowFlag != WasVisible || Cmd == SW_SHOWNA) && Cmd != SW_SHOWMAXIMIZED && !(Swp & SWP_STATECHANGED))
2771 {
2773#if 0 // Fix wine msg test_SetParent:WmSetParentSeq_1:2
2774 if (!(Wnd->state2 & WNDS2_WIN31COMPAT)) // <------------- XP sets this bit!
2776#endif
2777 if (!VerifyWnd(Wnd)) return WasVisible;
2778 }
2779
2780 /* We can't activate a child window */
2781 if ((Wnd->style & WS_CHILD) &&
2782 !(Wnd->ExStyle & WS_EX_MDICHILD) &&
2783 Cmd != SW_SHOWNA)
2784 {
2785 //ERR("SWP Child No active and ZOrder\n");
2787 }
2788
2789#if 0 // Explorer issues with common controls? Someone does not know how CS_SAVEBITS works.
2790 // Breaks startup and shutdown active window...
2791 if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
2792 Wnd->pcls->style & CS_SAVEBITS &&
2793 ((Cmd == SW_SHOW) || (Cmd == SW_NORMAL)))
2794 {
2795 ERR("WinPosShowWindow Set active\n");
2796 //UserSetActiveWindow(Wnd);
2797 co_IntSetForegroundWindow(Wnd); // HACK
2799 }
2800#endif
2801
2802 if (IsChildVisible(Wnd) || Swp & SWP_STATECHANGED)
2803 {
2804 TRACE("Child is Vis %s or State changed %s. ShowFlag %s Swp %04x\n",
2805 (IsChildVisible(Wnd) ? "TRUE" : "FALSE"), (Swp & SWP_STATECHANGED ? "TRUE" : "FALSE"),
2806 (ShowFlag ? "TRUE" : "FALSE"),LOWORD(Swp));
2808 0 != (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOPMOST : HWND_TOP,
2809 NewPos.left,
2810 NewPos.top,
2811 NewPos.right, // NewPos.right - NewPos.left, when minimized and restore, the window becomes smaller.
2812 NewPos.bottom,// NewPos.bottom - NewPos.top,
2813 LOWORD(Swp));
2814 }
2815 else
2816 {
2817 TRACE("Parent Vis?\n");
2818 /* if parent is not visible simply toggle WS_VISIBLE and return */
2819 if (ShowFlag) IntSetStyle( Wnd, WS_VISIBLE, 0 );
2820 else IntSetStyle( Wnd, 0, WS_VISIBLE );
2821 }
2822
2823 if ( EventMsg ) IntNotifyWinEvent(EventMsg, Wnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
2824
2825 if ( ShowOwned ) IntShowOwnedPopups(Wnd, TRUE );
2826
2827 if ((Cmd == SW_HIDE) || (Cmd == SW_MINIMIZE))
2828 {
2829 if ( Wnd == pti->MessageQueue->spwndActive && pti->MessageQueue == IntGetFocusMessageQueue() )
2830 {
2832 {
2833 if (!ActivateOtherWindowMin(Wnd))
2834 {
2836 }
2837 }
2838 else
2839 {
2841 }
2842 }
2843
2844 /* Revert focus to parent */
2845 if (Wnd == pti->MessageQueue->spwndFocus)
2846 {
2847 Parent = Wnd->spwndParent;
2849 Parent = 0;
2851 }
2852 // Hide, just return.
2853 if (Cmd == SW_HIDE) return WasVisible;
2854 }
2855
2856 /* FIXME: Check for window destruction. */
2857
2858 if ((Wnd->state & WNDS_SENDSIZEMOVEMSGS) &&
2859 !(Wnd->state2 & WNDS2_INDESTROY))
2860 {
2862 }
2863
2864 /* if previous state was minimized Windows sets focus to the window */
2865 if (style & WS_MINIMIZE)
2866 {
2867 co_UserSetFocus(Wnd);
2868 // Fix wine Win test_SetFocus todo #3,
2870 }
2871 //ERR("co_WinPosShowWindow EXIT\n");
2872 return WasVisible;
2873}
HWND FASTCALL co_UserSetFocus(PWND Window)
Definition: focus.c:1317
#define WNDS2_INDESTROY
Definition: ntuser.h:648
#define WNDS_SENDSIZEMOVEMSGS
Definition: ntuser.h:609
UINT FASTCALL co_WinPosMinMaximize(PWND Wnd, UINT ShowFlag, RECT *NewPos)
Definition: winpos.c:2436
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:2402
#define LOWORD(l)
Definition: pedump.c:82
@ Cmd
Definition: sacdrv.h:278
UINT style
Definition: ntuser.h:580
USERSTARTUPINFO usi
Definition: win32.h:279
PPROCESSINFO ppi
Definition: win32.h:88
PCLS pcls
Definition: ntuser.h:720
DWORD state2
Definition: ntuser.h:702
WORD wShowWindow
Definition: win32.h:220
#define WM_SETVISIBLE
Definition: undocuser.h:31
PUSER_MESSAGE_QUEUE FASTCALL IntGetFocusMessageQueue(VOID)
Definition: desktop.c:1324
#define STARTF_USEPOSITION
Definition: winbase.h:519
#define STARTF_USESHOWWINDOW
Definition: winbase.h:517
#define STARTF_USESIZE
Definition: winbase.h:518
#define SW_SHOWMAXIMIZED
Definition: winuser.h:776
#define SW_HIDE
Definition: winuser.h:771
#define HWND_TOPMOST
Definition: winuser.h:1211
#define WM_ACTIVATE
Definition: winuser.h:1615
#define WM_SHOWWINDOW
Definition: winuser.h:1631
#define WS_EX_MDICHILD
Definition: winuser.h:394
#define SW_SHOWNA
Definition: winuser.h:781
#define WA_ACTIVE
Definition: winuser.h:2626
#define CS_SAVEBITS
Definition: winuser.h:657
#define SW_SHOW
Definition: winuser.h:778
#define SW_NORMAL
Definition: winuser.h:772

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

2966{
2967 PWND Window;
2968 POINT Point = *WinPoint;
2970
2971 if( ScopeWin == NULL )
2972 {
2973 ScopeWin = UserGetDesktopWindow();
2974 if(ScopeWin == NULL)
2975 return NULL;
2976 }
2977
2978 *HitTest = HTNOWHERE;
2979
2980 ASSERT_REFS_CO(ScopeWin);
2981 UserRefObjectCo(ScopeWin, &Ref);
2982
2983 Window = co_WinPosSearchChildren(ScopeWin, &Point, HitTest, Ignore);
2984
2985 UserDerefObjectCo(ScopeWin);
2986 if (Window)
2988 ASSERT_REFS_CO(ScopeWin);
2989
2990 return Window;
2991}

Referenced by co_IntProcessMouseMessage(), and NtUserWindowFromPoint().

◆ DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL ( UserWinpos  )

◆ FixClientRect()

static VOID FASTCALL FixClientRect ( PRECTL  ClientRect,
PRECTL  WindowRect 
)
static

Definition at line 1087 of file winpos.c.

1088{
1089 if (ClientRect->left < WindowRect->left)
1090 {
1091 ClientRect->left = WindowRect->left;
1092 }
1093 else if (WindowRect->right < ClientRect->left)
1094 {
1095 ClientRect->left = WindowRect->right;
1096 }
1097 if (ClientRect->right < WindowRect->left)
1098 {
1099 ClientRect->right = WindowRect->left;
1100 }
1101 else if (WindowRect->right < ClientRect->right)
1102 {
1103 ClientRect->right = WindowRect->right;
1104 }
1105 if (ClientRect->top < WindowRect->top)
1106 {
1107 ClientRect->top = WindowRect->top;
1108 }
1109 else if (WindowRect->bottom < ClientRect->top)
1110 {
1111 ClientRect->top = WindowRect->bottom;
1112 }
1113 if (ClientRect->bottom < WindowRect->top)
1114 {
1115 ClientRect->bottom = WindowRect->top;
1116 }
1117 else if (WindowRect->bottom < ClientRect->bottom)
1118 {
1119 ClientRect->bottom = WindowRect->bottom;
1120 }
1121}

Referenced by co_WinPosDoNCCALCSize(), and co_WinPosGetNonClientSize().

◆ ForceNCPaintErase()

VOID ForceNCPaintErase ( PWND  Wnd,
HRGN  hRgn,
PREGION  pRgn 
)

Definition at line 1697 of file winpos.c.

1698{
1699 HDC hDC;
1700 PREGION RgnUpdate;
1701 UINT RgnType;
1702 BOOL Create = FALSE;
1703
1704 if (Wnd->hrgnUpdate == NULL)
1705 {
1706 Wnd->hrgnUpdate = NtGdiCreateRectRgn(0, 0, 0, 0);
1708 Create = TRUE;
1709 }
1710
1711 if (Wnd->hrgnUpdate != HRGN_WINDOW)
1712 {
1713 RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
1714 if (RgnUpdate)
1715 {
1716 RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, pRgn, RGN_OR);
1717 REGION_UnlockRgn(RgnUpdate);
1718 if (RgnType == NULLREGION)
1719 {
1722 Wnd->hrgnUpdate = NULL;
1723 Create = FALSE;
1724 }
1725 }
1726 }
1727
1728 IntSendNCPaint( Wnd, hRgn ); // Region can be deleted by the application.
1729
1730 if (Wnd->hrgnUpdate)
1731 {
1732 hDC = UserGetDCEx( Wnd,
1733 Wnd->hrgnUpdate,
1735
1737 // Kill the loop, so Clear before we send.
1739 {
1741 }
1742 UserReleaseDC(Wnd, hDC, FALSE);
1743 }
1744
1745 if (Create)
1746 {
1749 Wnd->hrgnUpdate = NULL;
1750 }
1751}
static HDC hDC
Definition: 3dtext.c:33
#define DCX_USESTYLE
Definition: GetDCEx.c:10
@ Create
Definition: registry.c:563
#define WNDS_ERASEBACKGROUND
Definition: ntuser.h:615
#define WNDS_SENDERASEBACKGROUND
Definition: ntuser.h:614
static HRGN hRgn
Definition: mapping.c:33
#define GDI_OBJ_HMGR_POWNED
Definition: ntgdihdl.h:117
#define GDI_OBJ_HMGR_PUBLIC
Definition: ntgdihdl.h:116
HRGN hrgnUpdate
Definition: ntuser.h:721
BOOL FASTCALL IntGdiSetRegionOwner(HRGN hRgn, DWORD OwnerMask)
Definition: region.c:2459
#define RGN_OR
Definition: wingdi.h:359
#define WM_ERASEBKGND
Definition: winuser.h:1628

Referenced by co_WinPosSetWindowPos().

◆ get_valid_rects()

static VOID FASTCALL get_valid_rects ( RECTL old_client,
RECTL new_client,
UINT  flags,
RECTL valid 
)
static

Definition at line 1130 of file winpos.c.

1131{
1132 int cx, cy;
1133
1134 if (flags & WVR_REDRAW)
1135 {
1138 return;
1139 }
1140
1141 if (flags & WVR_VALIDRECTS)
1142 {
1143 if (!RECTL_bIntersectRect( &valid[0], &valid[0], new_client ) ||
1144 !RECTL_bIntersectRect( &valid[1], &valid[1], old_client ))
1145 {
1148 return;
1149 }
1151 }
1152 else
1153 {
1154 valid[0] = *new_client;
1155 valid[1] = *old_client;
1156 }
1157
1158 /* make sure the rectangles have the same size */
1159 cx = min( valid[0].right - valid[0].left, valid[1].right - valid[1].left );
1160 cy = min( valid[0].bottom - valid[0].top, valid[1].bottom - valid[1].top );
1161
1162 if (flags & WVR_ALIGNBOTTOM)
1163 {
1164 valid[0].top = valid[0].bottom - cy;
1165 valid[1].top = valid[1].bottom - cy;
1166 }
1167 else
1168 {
1169 valid[0].bottom = valid[0].top + cy;
1170 valid[1].bottom = valid[1].top + cy;
1171 }
1172 if (flags & WVR_ALIGNRIGHT)
1173 {
1174 valid[0].left = valid[0].right - cx;
1175 valid[1].left = valid[1].right - cx;
1176 }
1177 else
1178 {
1179 valid[0].right = valid[0].left + cx;
1180 valid[1].right = valid[1].left + cx;
1181 }
1182}
BOOLEAN valid
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
GLdouble GLdouble right
Definition: glext.h:10859
GLint left
Definition: glext.h:7726
GLint GLint bottom
Definition: glext.h:7726
BOOL FASTCALL RECTL_bIntersectRect(_Out_ RECTL *prclDst, _In_ const RECTL *prcl1, _In_ const RECTL *prcl2)
Definition: rect.c:55
#define WVR_VALIDRECTS
Definition: winuser.h:2525
#define WVR_ALIGNTOP
Definition: winuser.h:2518
#define WVR_ALIGNLEFT
Definition: winuser.h:2519
#define WVR_ALIGNRIGHT
Definition: winuser.h:2521
#define WVR_ALIGNBOTTOM
Definition: winuser.h:2520

Referenced by co_WinPosDoNCCALCSize().

◆ IntChildWindowFromPointEx()

PWND APIENTRY IntChildWindowFromPointEx ( PWND  Parent,
LONG  x,
LONG  y,
UINT  uiFlags 
)

Definition at line 3038 of file winpos.c.

3039{
3040 POINTL Pt;
3041 HWND *List, *phWnd;
3042 PWND pwndHit = NULL;
3043
3044 Pt.x = x;
3045 Pt.y = y;
3046
3048 {
3049 if (Parent->ExStyle & WS_EX_LAYOUTRTL)
3050 Pt.x = Parent->rcClient.right - Pt.x;
3051 else
3052 Pt.x += Parent->rcClient.left;
3053 Pt.y += Parent->rcClient.top;
3054 }
3055
3056 if (!IntPtInWindow(Parent, Pt.x, Pt.y)) return NULL;
3057
3059 {
3060 for (phWnd = List; *phWnd; phWnd++)
3061 {
3062 PWND Child;
3063 if ((Child = ValidateHwndNoErr(*phWnd)))
3064 {
3065 if (uiFlags & (CWP_SKIPINVISIBLE|CWP_SKIPDISABLED))
3066 {
3067 if (!(Child->style & WS_VISIBLE) && (uiFlags & CWP_SKIPINVISIBLE)) continue;
3068 if ((Child->style & WS_DISABLED) && (uiFlags & CWP_SKIPDISABLED)) continue;
3069 }
3070
3071 if (uiFlags & CWP_SKIPTRANSPARENT)
3072 {
3073 if (Child->ExStyle & WS_EX_TRANSPARENT) continue;
3074 }
3075
3076 if (IntPtInWindow(Child, Pt.x, Pt.y))
3077 {
3078 pwndHit = Child;
3079 break;
3080 }
3081 }
3082 }
3084 }
3085 return pwndHit ? pwndHit : Parent;
3086}
LONG y
Definition: windef.h:330
LONG x
Definition: windef.h:329
#define WS_EX_LAYOUTRTL
Definition: winuser.h:390
#define CWP_SKIPTRANSPARENT
Definition: winuser.h:210
#define CWP_SKIPDISABLED
Definition: winuser.h:209
#define CWP_SKIPINVISIBLE
Definition: winuser.h:208

Referenced by NtUserChildWindowFromPointEx().

◆ 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

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

◆ IntDeferWindowPos()

HDWP FASTCALL IntDeferWindowPos ( HDWP  hdwp,
HWND  hwnd,
HWND  hwndAfter,
INT  x,
INT  y,
INT  cx,
INT  cy,
UINT  flags 
)

Definition at line 3091 of file winpos.c.

3099{
3100 PSMWP pDWP;
3101 int i;
3102 HDWP retvalue = hdwp;
3103
3104 TRACE("hdwp %p, hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
3105 hdwp, hwnd, hwndAfter, x, y, cx, cy, flags);
3106
3107 if (flags & ~(SWP_NOSIZE | SWP_NOMOVE |
3112 {
3114 return NULL;
3115 }
3116
3117 if (!(pDWP = (PSMWP)UserGetObject(gHandleTable, hdwp, TYPE_SETWINDOWPOS)))
3118 {
3120 return NULL;
3121 }
3122
3123 for (i = 0; i < pDWP->ccvr; i++)
3124 {
3125 if (pDWP->acvr[i].pos.hwnd == hwnd)
3126 {
3127 /* Merge with the other changes */
3128 if (!(flags & SWP_NOZORDER))
3129 {
3130 pDWP->acvr[i].pos.hwndInsertAfter = hwndAfter;
3131 }
3132 if (!(flags & SWP_NOMOVE))
3133 {
3134 pDWP->acvr[i].pos.x = x;
3135 pDWP->acvr[i].pos.y = y;
3136 }
3137 if (!(flags & SWP_NOSIZE))
3138 {
3139 pDWP->acvr[i].pos.cx = cx;
3140 pDWP->acvr[i].pos.cy = cy;
3141 }
3142 pDWP->acvr[i].pos.flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
3148 goto END;
3149 }
3150 }
3151 if (pDWP->ccvr >= pDWP->ccvrAlloc)
3152 {
3153 PCVR newpos = ExAllocatePoolWithTag(PagedPool, pDWP->ccvrAlloc * 2 * sizeof(CVR), USERTAG_SWP);
3154 if (!newpos)
3155 {
3156 retvalue = NULL;
3157 goto END;
3158 }
3159 RtlZeroMemory(newpos, pDWP->ccvrAlloc * 2 * sizeof(CVR));
3160 RtlCopyMemory(newpos, pDWP->acvr, pDWP->ccvrAlloc * sizeof(CVR));
3162 pDWP->ccvrAlloc *= 2;
3163 pDWP->acvr = newpos;
3164 }
3165 pDWP->acvr[pDWP->ccvr].pos.hwnd = hwnd;
3166 pDWP->acvr[pDWP->ccvr].pos.hwndInsertAfter = hwndAfter;
3167 pDWP->acvr[pDWP->ccvr].pos.x = x;
3168 pDWP->acvr[pDWP->ccvr].pos.y = y;
3169 pDWP->acvr[pDWP->ccvr].pos.cx = cx;
3170 pDWP->acvr[pDWP->ccvr].pos.cy = cy;
3171 pDWP->acvr[pDWP->ccvr].pos.flags = flags;
3172 pDWP->acvr[pDWP->ccvr].hrgnClip = NULL;
3173 pDWP->acvr[pDWP->ccvr].hrgnInterMonitor = NULL;
3174 pDWP->ccvr++;
3175END:
3176 return retvalue;
3177}
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
@ TYPE_SETWINDOWPOS
Definition: ntuser.h:44
#define END
Definition: options.h:105
Definition: winpos.h:4
WINDOWPOS pos
Definition: winpos.h:5
HRGN hrgnClip
Definition: winpos.h:16
HRGN hrgnInterMonitor
Definition: winpos.h:17
Definition: winpos.h:21
PCVR acvr
Definition: winpos.h:27
INT ccvr
Definition: winpos.h:25
INT ccvrAlloc
Definition: winpos.h:26
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
PVOID UserGetObject(PUSER_HANDLE_TABLE ht, HANDLE handle, HANDLE_TYPE type)
Definition: object.c:495
PUSER_HANDLE_TABLE gHandleTable
Definition: object.c:13
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
#define ERROR_INVALID_DWP_HANDLE
Definition: winerror.h:886
#define SWP_NOOWNERZORDER
Definition: winuser.h:1252

Referenced by NtUserDeferWindowPos().

◆ IntEndDeferWindowPosEx()

BOOL FASTCALL IntEndDeferWindowPosEx ( HDWP  hdwp,
BOOL  bAsync 
)

Definition at line 3180 of file winpos.c.

3181{
3182 PSMWP pDWP;
3183 PCVR winpos;
3184 BOOL res = TRUE;
3185 int i;
3186
3187 TRACE("%p\n", hdwp);
3188
3189 if (!(pDWP = (PSMWP)UserGetObject(gHandleTable, hdwp, TYPE_SETWINDOWPOS)))
3190 {
3192 return FALSE;
3193 }
3194
3195 for (i = 0, winpos = pDWP->acvr; res && i < pDWP->ccvr; i++, winpos++)
3196 {
3197 PWND pwnd;
3199
3200 TRACE("hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
3201 winpos->pos.hwnd, winpos->pos.hwndInsertAfter, winpos->pos.x, winpos->pos.y,
3202 winpos->pos.cx, winpos->pos.cy, winpos->pos.flags);
3203
3204 pwnd = ValidateHwndNoErr(winpos->pos.hwnd);
3205 if (!pwnd)
3206 continue;
3207
3208 UserRefObjectCo(pwnd, &Ref);
3209
3210 if (bAsync)
3211 {
3212 LRESULT lRes;
3214 if ( ppos )
3215 {
3216 *ppos = winpos->pos;
3217 /* Yes it's a pointer inside Win32k! */
3218 lRes = co_IntSendMessageNoWait( winpos->pos.hwnd, WM_ASYNC_SETWINDOWPOS, 0, (LPARAM)ppos);
3219 /* We handle this the same way as Event Hooks and Hooks. */
3220 if ( !lRes )
3221 {
3223 }
3224 }
3225 }
3226 else
3227 res = co_WinPosSetWindowPos( pwnd,
3228 winpos->pos.hwndInsertAfter,
3229 winpos->pos.x,
3230 winpos->pos.y,
3231 winpos->pos.cx,
3232 winpos->pos.cy,
3233 winpos->pos.flags);
3234
3235 // Hack to pass tests.... Must have some work to do so clear the error.
3236 if (res && (winpos->pos.flags & (SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER)) == SWP_NOZORDER )
3238
3239 UserDerefObjectCo(pwnd);
3240 }
3241
3245 return res;
3246}
#define ERROR_SUCCESS
Definition: deptool.c:10
GLuint res
Definition: glext.h:9613
BOOL FASTCALL UserDeleteObject(HANDLE h, HANDLE_TYPE type)
Definition: object.c:717

Referenced by NtUserEndDeferWindowPosEx().

◆ IntGetClientOrigin()

BOOL FASTCALL IntGetClientOrigin ( PWND Window  OPTIONAL,
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().

◆ IntGetClientRect()

VOID FASTCALL IntGetClientRect ( PWND  Wnd,
RECTL Rect 
)

Internal function. Returns client window rectangle relative to the upper-left corner of client area.

Note
Does not check the validity of the parameters

Definition at line 92 of file winpos.c.

93{
94 ASSERT( Wnd );
95 ASSERT( Rect );
96 if (Wnd->style & WS_MINIMIZED)
97 {
98 Rect->left = Rect->top = 0;
101 return;
102 }
103 if (!UserIsDesktopWindow(Wnd))
104 {
105 *Rect = Wnd->rcClient;
107 }
108 else
109 {
110 Rect->left = Rect->top = 0;
111 Rect->right = Wnd->rcClient.right;
112 Rect->bottom = Wnd->rcClient.bottom;
113 /* Do this until Init bug is fixed. This sets 640x480, see InitMetrics.
114 Rect->right = UserGetSystemMetrics(SM_CXSCREEN);
115 Rect->bottom = UserGetSystemMetrics(SM_CYSCREEN);
116 */
117 }
118}
#define ASSERT(a)
Definition: mode.c:44
#define WS_MINIMIZED
Definition: undocuser.h:18

Referenced by co_IntDrawCaret(), co_WinPosArrangeIconicWindows(), co_WinPosGetMinMaxInfo(), co_WinPosSendSizeMove(), DefWndDoSizeMove(), DefWndHandleWindowPosChanged(), IntBeginPaint(), IntCalculateThumb(), IntDefWindowProc(), IntFillWindow(), IntGetScrollBarRect(), IntScrollWindowEx(), MENU_DrawPopupMenu(), MENU_EnsureMenuItemVisible(), NC_DoNCPaint(), and WinPosFindIconPos().

◆ IntGetLastTopMostWindow()

PWND FASTCALL IntGetLastTopMostWindow ( VOID  )

Definition at line 238 of file winpos.c.

239{
240 PWND pWnd;
241 PDESKTOP rpdesk = gptiCurrent->rpdesk;
242
243 if ( rpdesk &&
244 (pWnd = rpdesk->pDeskInfo->spwnd->spwndChild) &&
245 pWnd->ExStyle & WS_EX_TOPMOST)
246 {
247 for (;;)
248 {
249 if (!pWnd->spwndNext) break;
250 if (!(pWnd->spwndNext->ExStyle & WS_EX_TOPMOST)) break;
251 pWnd = pWnd->spwndNext;
252 }
253 return pWnd;
254 }
255 return NULL;
256}
struct _WND * spwnd
Definition: ntuser.h:137
PDESKTOPINFO pDeskInfo
Definition: desktop.h:8
struct _DESKTOP * rpdesk
Definition: win32.h:92

Referenced by ActivateOtherWindowMin().

◆ IntGetWindowBorderMeasures()

VOID FASTCALL IntGetWindowBorderMeasures ( PWND  Wnd,
UINT cx,
UINT cy 
)

Definition at line 867 of file winpos.c.

868{
869 if(HAS_DLGFRAME(Wnd->style, Wnd->ExStyle) && !(Wnd->style & WS_MINIMIZE))
870 {
873 }
874 else
875 {
876 if(HAS_THICKFRAME(Wnd->style, Wnd->ExStyle)&& !(Wnd->style & WS_MINIMIZE))
877 {
880 }
881 else if(HAS_THINFRAME(Wnd->style, Wnd->ExStyle))
882 {
885 }
886 else
887 {
888 *cx = *cy = 0;
889 }
890 }
891}
#define HAS_DLGFRAME(Style, ExStyle)
Definition: window.h:9
#define HAS_THINFRAME(Style, ExStyle)
Definition: window.h:17
#define HAS_THICKFRAME(Style, ExStyle)
Definition: window.h:13

◆ IntGetWindowBorders()

DWORD IntGetWindowBorders ( DWORD  Style,
DWORD  ExStyle 
)

Definition at line 921 of file winpos.c.

922{
923 DWORD adjust = 0;
924
925 if ( ExStyle & WS_EX_WINDOWEDGE ) // 1st
926 adjust = 2; /* outer */
927 else if ( ExStyle & WS_EX_STATICEDGE ) // 2nd
928 adjust = 1; /* for the outer frame always present */
929
931 adjust += 2;
932
934 adjust++; /* The other border */
935
936 return adjust;
937}
const DWORD Style
Definition: appswitch.c:71
const DWORD ExStyle
Definition: appswitch.c:72
#define WS_EX_DLGMODALFRAME
Definition: pedump.c:645
#define WS_EX_STATICEDGE
Definition: winuser.h:403
#define WS_EX_WINDOWEDGE
Definition: winuser.h:407
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384

Referenced by co_WinPosGetMinMaxInfo().

◆ IntGetWindowPlacement()

BOOL FASTCALL IntGetWindowPlacement ( PWND  Wnd,
WINDOWPLACEMENT lpwndpl 
)

Definition at line 564 of file winpos.c.

565{
566 if (!Wnd) return FALSE;
567
568 if(lpwndpl->length != sizeof(WINDOWPLACEMENT))
569 {
570 ERR("length mismatch: %u\n", lpwndpl->length);
571 return FALSE;
572 }
573
574 lpwndpl->flags = 0;
575
577
578 lpwndpl->showCmd = SW_HIDE;
579
580 if ( Wnd->style & WS_MINIMIZE )
581 lpwndpl->showCmd = SW_SHOWMINIMIZED;
582 else
583 lpwndpl->showCmd = ( Wnd->style & WS_MAXIMIZE ) ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL ;
584
585 lpwndpl->rcNormalPosition = Wnd->InternalPos.NormalRect;
586
587 if (Wnd->InternalPos.flags & WPF_MININIT) // Return if it was set!
588 {
589 lpwndpl->ptMinPosition.x = Wnd->InternalPos.IconPos.x;
590 lpwndpl->ptMinPosition.y = Wnd->InternalPos.IconPos.y;
591 }
592 else
593 lpwndpl->ptMinPosition.x = lpwndpl->ptMinPosition.y = -1;
594
595 if ( Wnd->InternalPos.flags & WPF_MAXINIT && // Return if set and not maximized to monitor!
597 {
598 lpwndpl->ptMaxPosition.x = Wnd->InternalPos.MaxPos.x;
599 lpwndpl->ptMaxPosition.y = Wnd->InternalPos.MaxPos.y;
600 }
601 else
602 lpwndpl->ptMaxPosition.x = lpwndpl->ptMaxPosition.y = -1;
603
604 if ( Wnd->spwndParent == Wnd->head.rpdesk->pDeskInfo->spwnd &&
605 !(Wnd->ExStyle & WS_EX_TOOLWINDOW))
606 {
607 PMONITOR pmonitor = UserMonitorFromRect(&lpwndpl->rcNormalPosition, MONITOR_DEFAULTTOPRIMARY );
608
609 // FIXME: support DPI aware, rcWorkDPI/Real etc..
610 if (Wnd->InternalPos.flags & WPF_MININIT)
611 {
612 lpwndpl->ptMinPosition.x -= (pmonitor->rcWork.left - pmonitor->rcMonitor.left);
613 lpwndpl->ptMinPosition.y -= (pmonitor->rcWork.top - pmonitor->rcMonitor.top);
614 }
616 pmonitor->rcMonitor.left - pmonitor->rcWork.left,
617 pmonitor->rcMonitor.top - pmonitor->rcWork.top);
618 }
619
620 if ( Wnd->InternalPos.flags & WPF_RESTORETOMAXIMIZED || Wnd->style & WS_MAXIMIZE )
621 lpwndpl->flags |= WPF_RESTORETOMAXIMIZED;
622
623 if ( ((Wnd->style & (WS_CHILD|WS_POPUP)) == WS_CHILD) && Wnd->InternalPos.flags & WPF_SETMINPOSITION)
624 lpwndpl->flags |= WPF_SETMINPOSITION;
625
626 return TRUE;
627}
#define WPF_MAXINIT
Definition: ntuser.h:687
VOID FASTCALL WinPosInitInternalPos(PWND Wnd, RECTL *RestoreRect)
Definition: winpos.c:480
struct _DESKTOP * rpdesk
Definition: ntuser.h:194
PMONITOR NTAPI UserMonitorFromRect(PRECTL pRect, DWORD dwFlags)
Definition: monitor.c:405

Referenced by co_WinPosMinMaximize(), NtUserGetInternalWindowPos(), and NtUserGetWindowPlacement().

◆ 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}

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

◆ IntGetWindowSnapEdge()

UINT FASTCALL IntGetWindowSnapEdge ( PWND  Wnd)

Definition at line 3904 of file winpos.c.

3905{
3908 return HTNOWHERE;
3909}
#define WS_EX2_VERTICALLYMAXIMIZEDLEFT
Definition: ntuser.h:680
#define WS_EX2_VERTICALLYMAXIMIZEDRIGHT
Definition: ntuser.h:681
DWORD ExStyle2
Definition: ntuser.h:745

Referenced by co_IntSnapWindow(), co_WinPosMinMaximize(), DefWndDoSizeMove(), and IntDefWindowProc().

◆ IntImeWindowPosChanged()

static VOID FASTCALL IntImeWindowPosChanged ( VOID  )
static

Definition at line 1753 of file winpos.c.

1754{
1755 HWND *phwnd;
1756 PWND pwndNode, pwndDesktop = UserGetDesktopWindow();
1757 PWINDOWLIST pWL;
1759
1760 if (!pwndDesktop)
1761 return;
1762
1763 /* Enumerate the windows to get the IME windows (of default and non-default) */
1764 pWL = IntBuildHwndList(pwndDesktop->spwndChild, IACE_LIST, gptiCurrent);
1765 if (!pWL)
1766 return;
1767
1768 for (phwnd = pWL->ahwnd; *phwnd != HWND_TERMINATOR; ++phwnd)
1769 {
1771 break;
1772
1773 pwndNode = ValidateHwndNoErr(*phwnd);
1774 if (pwndNode == NULL ||
1775 pwndNode->head.pti != gptiCurrent ||
1777 {
1778 continue;
1779 }
1780
1781 /* Now hwndNode is an IME window of the current thread */
1782 UserRefObjectCo(pwndNode, &Ref);
1784 UserDerefObjectCo(pwndNode);
1785 }
1786
1787 IntFreeHwndList(pWL);
1788}
#define IMS_UPDATEIMEUI
Definition: immdev.h:99
#define ICLS_IME
Definition: ntuser.h:927
#define TIF_INCLEANUP
Definition: ntuser.h:263
RTL_ATOM atomClassName
Definition: ntuser.h:568
FLONG TIF_flags
Definition: win32.h:95
ATOM atomSysClass[ICLS_NOTUSED+1]
Definition: ntuser.h:1060
HWND ahwnd[ANYSIZE_ARRAY]
Definition: window.h:91
#define WM_IME_SYSTEM
Definition: undocuser.h:60
VOID FASTCALL IntFreeHwndList(PWINDOWLIST pwlTarget)
Definition: window.c:1473
PWINDOWLIST FASTCALL IntBuildHwndList(PWND pwnd, DWORD dwFlags, PTHREADINFO pti)
Definition: window.c:1427
#define HWND_TERMINATOR
Definition: window.h:83
#define IACE_LIST
Definition: window.h:106

Referenced by co_WinPosSetWindowPos().

◆ IntMapWindowPoints()

INT FASTCALL IntMapWindowPoints ( PWND  FromWnd,
PWND  ToWnd,
LPPOINT  lpPoints,
UINT  cPoints 
)

Definition at line 144 of file winpos.c.

145{
146 BOOL mirror_from, mirror_to;
147 POINT Delta;
148 UINT i;
149 int Change = 1;
150
151 /* Note: Desktop Top and Left is always 0! */
152 Delta.x = Delta.y = 0;
153 mirror_from = mirror_to = FALSE;
154
155 if (FromWnd && !UserIsDesktopWindow(FromWnd))
156 {
157 if (FromWnd->ExStyle & WS_EX_LAYOUTRTL)
158 {
159 mirror_from = TRUE;
160 Change = -Change;
161 Delta.x = -FromWnd->rcClient.right;
162 }
163 else
164 Delta.x = FromWnd->rcClient.left;
165 Delta.y = FromWnd->rcClient.top;
166 }
167
168 if (ToWnd && !UserIsDesktopWindow(ToWnd))
169 {
170 if (ToWnd->ExStyle & WS_EX_LAYOUTRTL)
171 {
172 mirror_to = TRUE;
173 Change = -Change;
174 Delta.x += Change * ToWnd->rcClient.right;
175 }
176 else
177 Delta.x -= Change * ToWnd->rcClient.left;
178 Delta.y -= ToWnd->rcClient.top;
179 }
180
181 for (i = 0; i != cPoints; i++)
182 {
183 lpPoints[i].x += Delta.x;
184 lpPoints[i].x *= Change;
185 lpPoints[i].y += Delta.y;
186 }
187
188 if ((mirror_from || mirror_to) && cPoints == 2) /* special case for rectangle */
189 {
190 int tmp = min(lpPoints[0].x, lpPoints[1].x);
191 lpPoints[1].x = max(lpPoints[0].x, lpPoints[1].x);
192 lpPoints[0].x = tmp;
193 }
194
195 return MAKELONG(LOWORD(Delta.x), LOWORD(Delta.y));
196}
static ULONG Delta
Definition: xboxvideo.c:33

Referenced by DefWndDoSizeMove(), and DefWndHandleWindowPosChanged().

◆ IntRealChildWindowFromPoint()

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

Definition at line 2995 of file winpos.c.

2996{
2997 POINTL Pt;
2998 HWND *List, *phWnd;
2999 PWND pwndHit = NULL;
3000
3001 Pt.x = x;
3002 Pt.y = y;
3003
3005 {
3006 Pt.x += Parent->rcClient.left;
3007 Pt.y += Parent->rcClient.top;
3008 }
3009
3010 if (!IntPtInWindow(Parent, Pt.x, Pt.y)) return NULL;
3011
3013 {
3014 for (phWnd = List; *phWnd; phWnd++)
3015 {
3016 PWND Child;
3017 if ((Child = ValidateHwndNoErr(*phWnd)))
3018 {
3019 if ( Child->style & WS_VISIBLE && IntPtInWindow(Child, Pt.x, Pt.y) )
3020 {
3021 if ( Child->pcls->atomClassName != gpsi->atomSysClass[ICLS_BUTTON] ||
3022 (Child->style & BS_TYPEMASK) != BS_GROUPBOX )
3023 {
3025 return Child;
3026 }
3027 pwndHit = Child;
3028 }
3029 }
3030 }
3032 }
3033 return pwndHit ? pwndHit : Parent;
3034}
#define ICLS_BUTTON
Definition: ntuser.h:912
#define BS_GROUPBOX
Definition: pedump.c:658
#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().

◆ IntSetSnapEdge()

VOID FASTCALL IntSetSnapEdge ( PWND  Wnd,
UINT  Edge 
)

Definition at line 3989 of file winpos.c.

3990{
3992 UINT style = 0;
3993 switch (Edge)
3994 {
3995 case HTNOWHERE:
3996 style = 0;
3997 break;
3998 case HTTOP: /* Maximize throws away the snap */
3999 style = 0;
4000 break;
4001 case HTLEFT:
4003 break;
4004 case HTRIGHT:
4006 break;
4007 default:
4008 ERR("Unexpected snap edge %#x\n", Edge);
4009 }
4010 Wnd->ExStyle2 = (Wnd->ExStyle2 & ~styleMask) | style;
4011}

Referenced by co_IntSnapWindow(), co_WinPosMinMaximize(), DefWndDoSizeMove(), IntDefWindowProc(), and IntSetSnapInfo().

◆ IntSetSnapInfo()

VOID FASTCALL IntSetSnapInfo ( PWND  Wnd,
UINT  Edge,
IN const RECT *Pos  OPTIONAL 
)

Definition at line 4014 of file winpos.c.

4015{
4016 RECT r;
4017 IntSetSnapEdge(Wnd, Edge);
4018 if (Edge == HTNOWHERE)
4019 {
4021 Pos = (Wnd->style & WS_MINIMIZE) ? NULL : &r;
4022 }
4023 if (Pos)
4024 {
4025 Wnd->InternalPos.NormalRect = *Pos;
4026 }
4027}
GLdouble GLdouble GLdouble r
Definition: gl.h:2055

Referenced by co_IntSnapWindow(), DefWndDoSizeMove(), and IntDefWindowProc().

◆ IntSetWindowPlacement()

BOOL FASTCALL IntSetWindowPlacement ( PWND  Wnd,
WINDOWPLACEMENT wpl,
UINT  Flags 
)

Definition at line 671 of file winpos.c.

672{
673 BOOL sAsync;
674 UINT SWP_Flags;
675
679
680 if (!Wnd || Wnd == Wnd->head.rpdesk->pDeskInfo->spwnd) return FALSE;
681
682 if ( Flags & PLACE_MIN ) Wnd->InternalPos.IconPos = wpl->ptMinPosition;
683 if ( Flags & PLACE_MAX ) Wnd->InternalPos.MaxPos = wpl->ptMaxPosition;
684 if ( Flags & PLACE_RECT) Wnd->InternalPos.NormalRect = wpl->rcNormalPosition;
685
686 SWP_Flags = SWP_NOZORDER | SWP_NOACTIVATE | ((wpl->flags & WPF_ASYNCWINDOWPLACEMENT) ? SWP_ASYNCWINDOWPOS : 0);
687
688 if (Wnd->style & WS_MINIMIZE )
689 {
690 if (Flags & PLACE_MIN || Wnd->InternalPos.flags & WPF_SETMINPOSITION)
691 {
693 wpl->ptMinPosition.x, wpl->ptMinPosition.y, 0, 0,
694 SWP_NOSIZE | SWP_Flags);
695 Wnd->InternalPos.flags |= WPF_MININIT;
696 }
697 }
698 else if (Wnd->style & WS_MAXIMIZE )
699 {
700 if (Flags & PLACE_MAX)
701 {
703 wpl->ptMaxPosition.x, wpl->ptMaxPosition.y, 0, 0,
704 SWP_NOSIZE | SWP_Flags);
705 Wnd->InternalPos.flags |= WPF_MAXINIT;
706 }
707 }
708 else if (Flags & PLACE_RECT)
709 {
714 SWP_Flags);
715 }
716
717 sAsync = (Wnd->head.pti->MessageQueue != gptiCurrent->MessageQueue && wpl->flags & WPF_ASYNCWINDOWPLACEMENT);
718
719 if ( sAsync )
721 else
722 co_WinPosShowWindow(Wnd, wpl->showCmd);
723
724 if ( Wnd->style & WS_MINIMIZE && !sAsync )
725 {
726 if ( wpl->flags & WPF_SETMINPOSITION )
727 Wnd->InternalPos.flags |= WPF_SETMINPOSITION;
728
729 if ( wpl->flags & WPF_RESTORETOMAXIMIZED )
731 }
732 return TRUE;
733}
@ WM_ASYNC_SHOWWINDOW
Definition: msgqueue.h:117
static void make_point_onscreen(POINT *pt)
Definition: winpos.c:660
static void make_rect_onscreen(RECT *rect)
Definition: winpos.c:630
#define PLACE_RECT
Definition: winpos.c:32
#define PLACE_MAX
Definition: winpos.c:31
BOOLEAN FASTCALL co_WinPosShowWindow(PWND Wnd, INT Cmd)
Definition: winpos.c:2594
#define PLACE_MIN
Definition: winpos.c:30
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

Referenced by NtUserSetInternalWindowPos(), and NtUserSetWindowPlacement().

◆ IntValidateParent()

static BOOL IntValidateParent ( PWND  Child,
PREGION  ValidateRgn 
)
static

Definition at line 1063 of file winpos.c.

1064{
1065 PWND ParentWnd = Child->spwndParent;
1066
1067 while (ParentWnd)
1068 {
1069 if (ParentWnd->style & WS_CLIPCHILDREN)
1070 break;
1071
1072 if (ParentWnd->hrgnUpdate != 0)
1073 {
1074 IntInvalidateWindows( ParentWnd,
1077 }
1078
1079 ParentWnd = ParentWnd->spwndParent;
1080 }
1081
1082 return TRUE;
1083}
BOOL WINAPI ValidateRgn(_In_ HWND, _In_opt_ HRGN)

Referenced by co_WinPosSetWindowPos().

◆ IsChildVisible()

BOOL FASTCALL IsChildVisible ( PWND  pWnd)

Definition at line 226 of file winpos.c.

227{
228 do
229 {
230 if ( (pWnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD ||
231 !(pWnd = pWnd->spwndParent) )
232 return TRUE;
233 }
234 while (pWnd->style & WS_VISIBLE);
235 return FALSE;
236}

Referenced by co_WinPosShowWindow().

◆ make_point_onscreen()

static void make_point_onscreen ( POINT pt)
static

Definition at line 660 of file winpos.c.

661{
662 RECT rect;
663
664 RECTL_vSetRect( &rect, pt->x, pt->y, pt->x + 1, pt->y + 1 );
666 pt->x = rect.left;
667 pt->y = rect.top;
668}
#define pt(x, y)
Definition: drawing.c:79
& rect
Definition: startmenu.cpp:1413

Referenced by IntSetWindowPlacement().

◆ make_rect_onscreen()

static void make_rect_onscreen ( RECT rect)
static

Definition at line 630 of file winpos.c.

631{
632 PMONITOR pmonitor = UserMonitorFromRect( rect, MONITOR_DEFAULTTONEAREST ); // Wine uses this.
633
634 // FIXME: support DPI aware, rcWorkDPI/Real etc..
635 if (!pmonitor) return;
636 /* FIXME: map coordinates from rcWork to rcMonitor */
637 if (rect->right <= pmonitor->rcWork.left)
638 {
639 rect->right += pmonitor->rcWork.left - rect->left;
640 rect->left = pmonitor->rcWork.left;
641 }
642 else if (rect->left >= pmonitor->rcWork.right)
643 {
644 rect->left += pmonitor->rcWork.right - rect->right;
645 rect->right = pmonitor->rcWork.right;
646 }
647 if (rect->bottom <= pmonitor->rcWork.top)
648 {
649 rect->bottom += pmonitor->rcWork.top - rect->top;
650 rect->top = pmonitor->rcWork.top;
651 }
652 else if (rect->top >= pmonitor->rcWork.bottom)
653 {
654 rect->top += pmonitor->rcWork.bottom - rect->bottom;
655 rect->bottom = pmonitor->rcWork.bottom;
656 }
657}

Referenced by IntSetWindowPlacement(), and make_point_onscreen().

◆ NtUserChildWindowFromPointEx()

HWND APIENTRY NtUserChildWindowFromPointEx ( HWND  hwndParent,
LONG  x,
LONG  y,
UINT  uiFlags 
)

Definition at line 3252 of file winpos.c.

3256{
3257 PWND pwndParent;
3258 TRACE("Enter NtUserChildWindowFromPointEx\n");
3260 if ((pwndParent = UserGetWindowObject(hwndParent)))
3261 {
3262 pwndParent = IntChildWindowFromPointEx(pwndParent, x, y, uiFlags);
3263 }
3264 UserLeave();
3265 TRACE("Leave NtUserChildWindowFromPointEx\n");
3266 return pwndParent ? UserHMGetHandle(pwndParent) : NULL;
3267}
static HWND hwndParent
Definition: cryptui.c:300
PWND APIENTRY IntChildWindowFromPointEx(PWND Parent, LONG x, LONG y, UINT uiFlags)
Definition: winpos.c:3038
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:258
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:249
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:124

Referenced by ChildWindowFromPoint(), and ChildWindowFromPointEx().

◆ NtUserDeferWindowPos()

HDWP APIENTRY NtUserDeferWindowPos ( HDWP  WinPosInfo,
HWND  Wnd,
HWND  WndInsertAfter,
int  x,
int  y,
int  cx,
int  cy,
UINT  Flags 
)

Definition at line 3289 of file winpos.c.

3297{
3298 PWND pWnd, pWndIA;
3299 HDWP Ret = NULL;
3303
3304 TRACE("Enter NtUserDeferWindowPos\n");
3306
3307 if ( Flags & Tmp )
3308 {
3310 goto Exit;
3311 }
3312
3313 pWnd = UserGetWindowObject(Wnd);
3314 if (!pWnd || UserIsDesktopWindow(pWnd) || UserIsMessageWindow(pWnd))
3315 {
3316 goto Exit;
3317 }
3318
3319 if ( WndInsertAfter &&
3320 WndInsertAfter != HWND_BOTTOM &&
3321 WndInsertAfter != HWND_TOPMOST &&
3322 WndInsertAfter != HWND_NOTOPMOST )
3323 {
3324 pWndIA = UserGetWindowObject(WndInsertAfter);
3325 if (!pWndIA || UserIsDesktopWindow(pWndIA) || UserIsMessageWindow(pWndIA))
3326 {
3327 goto Exit;
3328 }
3329 }
3330
3331 Ret = IntDeferWindowPos(WinPosInfo, Wnd, WndInsertAfter, x, y, cx, cy, Flags);
3332
3333Exit:
3334 TRACE("Leave NtUserDeferWindowPos, ret=%p\n", Ret);
3335 UserLeave();
3336 return Ret;
3337}
HDWP FASTCALL IntDeferWindowPos(HDWP hdwp, HWND hwnd, HWND hwndAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:3091
static void Exit(void)
Definition: sock.c:1330
#define UserIsMessageWindow(pWnd)
Definition: desktop.h:197
#define ERROR_INVALID_FLAGS
Definition: winerror.h:583
#define SWP_NOREPOSITION
Definition: winuser.h:1253
#define HWND_NOTOPMOST
Definition: winuser.h:1209
#define HWND_BOTTOM
Definition: winuser.h:1208

Referenced by DeferWindowPos().

◆ NtUserEndDeferWindowPosEx()

BOOL APIENTRY NtUserEndDeferWindowPosEx ( HDWP  WinPosInfo,
BOOL  bAsync 
)

Definition at line 3273 of file winpos.c.

3275{
3276 BOOL Ret;
3277 TRACE("Enter NtUserEndDeferWindowPosEx\n");
3279 Ret = IntEndDeferWindowPosEx(WinPosInfo, bAsync);
3280 TRACE("Leave NtUserEndDeferWindowPosEx, ret=%i\n", Ret);
3281 UserLeave();
3282 return Ret;
3283}
BOOL FASTCALL IntEndDeferWindowPosEx(HDWP hdwp, BOOL bAsync)
Definition: winpos.c:3180

Referenced by CascadeWindows(), EndDeferWindowPos(), and TileWindows().

◆ NtUserGetInternalWindowPos()

DWORD APIENTRY NtUserGetInternalWindowPos ( HWND  hWnd,
LPRECT  rectWnd,
LPPOINT  ptIcon 
)

Definition at line 3343 of file winpos.c.

3346{
3347 PWND Window;
3348 DWORD Ret = 0;
3349 BOOL Hit = FALSE;
3350 WINDOWPLACEMENT wndpl;
3351
3353
3355 {
3356 Hit = FALSE;
3357 goto Exit;
3358 }
3359
3360 _SEH2_TRY
3361 {
3362 if(rectWnd)
3363 {
3364 ProbeForWrite(rectWnd,
3365 sizeof(RECT),
3366 1);
3367 }
3368 if(ptIcon)
3369 {
3370 ProbeForWrite(ptIcon,
3371 sizeof(POINT),
3372 1);
3373 }
3374
3375 }
3377 {
3379 Hit = TRUE;
3380 }
3381 _SEH2_END;
3382
3383 wndpl.length = sizeof(WINDOWPLACEMENT);
3384
3385 if (IntGetWindowPlacement(Window, &wndpl) && !Hit)
3386 {
3387 _SEH2_TRY
3388 {
3389 if (rectWnd)
3390 {
3391 RtlCopyMemory(rectWnd, &wndpl.rcNormalPosition , sizeof(RECT));
3392 }
3393 if (ptIcon)
3394 {
3395 RtlCopyMemory(ptIcon, &wndpl.ptMinPosition, sizeof(POINT));
3396 }
3397
3398 }
3400 {
3402 Hit = TRUE;
3403 }
3404 _SEH2_END;
3405
3406 if (!Hit) Ret = wndpl.showCmd;
3407 }
3408Exit:
3409 UserLeave();
3410 return Ret;
3411}
HWND hWnd
Definition: settings.c:17
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
VOID FASTCALL UserEnterShared(VOID)
Definition: ntuser.c:242
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
#define _SEH2_END
Definition: pseh2_64.h:155
#define _SEH2_TRY
Definition: pseh2_64.h:55
VOID FASTCALL SetLastNtError(_In_ NTSTATUS Status)
Definition: error.c:31
struct _WINDOWPLACEMENT WINDOWPLACEMENT

◆ NtUserGetWindowPlacement()

BOOL APIENTRY NtUserGetWindowPlacement ( HWND  hWnd,
WINDOWPLACEMENT lpwndpl 
)

Definition at line 3417 of file winpos.c.

3419{
3420 PWND Wnd;
3421 WINDOWPLACEMENT Safepl;
3423 BOOL Ret = FALSE;
3424
3425 TRACE("Enter NtUserGetWindowPlacement\n");
3427
3428 if (!(Wnd = UserGetWindowObject(hWnd)))
3429 goto Exit; // Return FALSE
3430
3431 Status = MmCopyFromCaller(&Safepl, lpwndpl, sizeof(WINDOWPLACEMENT));
3432 if (!NT_SUCCESS(Status))
3433 {
3435 goto Exit; // Return FALSE
3436 }
3437
3438 // This function doesn't check the length. Just overwrite it
3439 Safepl.length = sizeof(WINDOWPLACEMENT);
3440
3441 IntGetWindowPlacement(Wnd, &Safepl);
3442
3443 Status = MmCopyToCaller(lpwndpl, &Safepl, sizeof(WINDOWPLACEMENT));
3444 if (!NT_SUCCESS(Status))
3445 {
3447 goto Exit; // Return FALSE
3448 }
3449
3450 Ret = TRUE;
3451
3452Exit:
3453 TRACE("Leave NtUserGetWindowPlacement, ret=%i\n", Ret);
3454 UserLeave();
3455 return Ret;
3456}
LONG NTSTATUS
Definition: precomp.h:26
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
Status
Definition: gdiplustypes.h:25
#define MmCopyToCaller(x, y, z)
Definition: mmcopy.h:19
#define MmCopyFromCaller
Definition: polytest.cpp:29

Referenced by GetWindowPlacement().

◆ NtUserMinMaximize()

DWORD APIENTRY NtUserMinMaximize ( HWND  hWnd,
UINT  cmd,
BOOL  Hide 
)

Definition at line 3460 of file winpos.c.

3464{
3465 PWND pWnd;
3466
3467 TRACE("Enter NtUserMinMaximize\n");
3469
3470 pWnd = UserGetWindowObject(hWnd);
3471 if (!pWnd || UserIsDesktopWindow(pWnd) || UserIsMessageWindow(pWnd))
3472 {
3473 goto Exit;
3474 }
3475
3476 if ( cmd > SW_MAX || pWnd->state2 & WNDS2_INDESTROY)
3477 {
3479 goto Exit;
3480 }
3481
3482 cmd |= Hide ? SW_HIDE : 0;
3483
3484 co_WinPosShowWindow(pWnd, cmd);
3485
3486Exit:
3487 TRACE("Leave NtUserMinMaximize\n");
3488 UserLeave();
3489 return 0; // Always NULL?
3490}
Definition: ftp_var.h:139
#define SW_MAX
Definition: winuser.h:785

◆ NtUserMoveWindow()

BOOL APIENTRY NtUserMoveWindow ( HWND  hWnd,
int  X,
int  Y,
int  nWidth,
int  nHeight,
BOOL  bRepaint 
)

Definition at line 3496 of file winpos.c.

3503{
3504 return NtUserSetWindowPos(hWnd, 0, X, Y, nWidth, nHeight,
3505 (bRepaint ? SWP_NOZORDER | SWP_NOACTIVATE :
3507}
BOOL APIENTRY NtUserSetWindowPos(HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags)
Definition: winpos.c:3533

Referenced by MoveWindow().

◆ NtUserRealChildWindowFromPoint()

HWND APIENTRY NtUserRealChildWindowFromPoint ( HWND  Parent,
LONG  x,
LONG  y 
)

Definition at line 3513 of file winpos.c.

3516{
3517 PWND pwndParent;
3518 TRACE("Enter NtUserRealChildWindowFromPoint\n");
3520 if ((pwndParent = UserGetWindowObject(Parent)))
3521 {
3522 pwndParent = IntRealChildWindowFromPoint(pwndParent, x, y);
3523 }
3524 UserLeave();
3525 TRACE("Leave NtUserRealChildWindowFromPoint\n");
3526 return pwndParent ? UserHMGetHandle(pwndParent) : NULL;
3527}
PWND FASTCALL IntRealChildWindowFromPoint(PWND Parent, LONG x, LONG y)
Definition: winpos.c:2995

Referenced by RealChildWindowFromPoint().

◆ NtUserSetInternalWindowPos()

DWORD APIENTRY NtUserSetInternalWindowPos ( HWND  hwnd,
UINT  showCmd,
LPRECT  lprect,
LPPOINT  lppt 
)

Definition at line 3653 of file winpos.c.

3658{
3659 WINDOWPLACEMENT wndpl;
3660 UINT flags;
3661 PWND Wnd;
3662 RECT rect;
3663 POINT pt = {0};
3664 BOOL Ret = FALSE;
3666
3667 TRACE("Enter NtUserSetWindowPlacement\n");
3669
3670 if (!(Wnd = UserGetWindowObject(hwnd)) || // FIXME:
3672 {
3673 goto Exit; // Return FALSE
3674 }
3675
3676 _SEH2_TRY
3677 {
3678 if (lppt)
3679 {
3680 ProbeForRead(lppt, sizeof(POINT), 1);
3681 RtlCopyMemory(&pt, lppt, sizeof(POINT));
3682 }
3683 if (lprect)
3684 {
3685 ProbeForRead(lprect, sizeof(RECT), 1);
3686 RtlCopyMemory(&rect, lprect, sizeof(RECT));
3687 }
3688 }
3690 {
3692 _SEH2_YIELD(goto Exit); // Return FALSE
3693 }
3694 _SEH2_END
3695
3696 wndpl.length = sizeof(wndpl);
3697 wndpl.showCmd = showCmd;
3698 wndpl.flags = flags = 0;
3699
3700 if ( lppt )
3701 {
3702 flags |= PLACE_MIN;
3703 wndpl.flags |= WPF_SETMINPOSITION;
3704 wndpl.ptMinPosition = pt;
3705 }
3706 if ( lprect )
3707 {
3708 flags |= PLACE_RECT;
3709 wndpl.rcNormalPosition = rect;
3710 }
3711
3712 UserRefObjectCo(Wnd, &Ref);
3713 IntSetWindowPlacement(Wnd, &wndpl, flags);
3714 UserDerefObjectCo(Wnd);
3715 Ret = TRUE;
3716
3717Exit:
3718 TRACE("Leave NtUserSetWindowPlacement, ret=%i\n", Ret);
3719 UserLeave();
3720 return Ret;
3721}
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
BOOL FASTCALL IntSetWindowPlacement(PWND Wnd, WINDOWPLACEMENT *wpl, UINT Flags)
Definition: winpos.c:671
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168

◆ NtUserSetWindowPlacement()

BOOL APIENTRY NtUserSetWindowPlacement ( HWND  hWnd,
WINDOWPLACEMENT lpwndpl 
)

Definition at line 3727 of file winpos.c.

3729{
3730 PWND Wnd;
3731 WINDOWPLACEMENT Safepl;
3732 UINT Flags;
3733 BOOL Ret = FALSE;
3735
3736 TRACE("Enter NtUserSetWindowPlacement\n");
3738
3739 _SEH2_TRY
3740 {
3741 ProbeForRead(lpwndpl, sizeof(*lpwndpl), 1);
3742 Safepl = *lpwndpl;
3743 }
3745 {
3747 _SEH2_YIELD(goto Exit); // Return FALSE
3748 }
3749 _SEH2_END
3750
3751 /* Backwards-compatibility: Win 3.x doesn't check the length */
3753 Safepl.length = sizeof(Safepl);
3754
3755 if (Safepl.length != sizeof(Safepl))
3756 {
3758 goto Exit;
3759 }
3760
3762 if (Safepl.flags & WPF_SETMINPOSITION)
3763 Flags |= PLACE_MIN;
3764
3766 if (!Wnd)
3767 goto Exit; // Return FALSE
3768
3769 UserRefObjectCo(Wnd, &Ref);
3770 if (!UserIsDesktopWindow(Wnd) && !UserIsMessageWindow(Wnd))
3771 Ret = IntSetWindowPlacement(Wnd, &Safepl, Flags);
3772 UserDerefObjectCo(Wnd);
3773
3774Exit:
3775 TRACE("Leave NtUserSetWindowPlacement, ret=%i\n", Ret);
3776 UserLeave();
3777 return Ret;
3778}
DWORD dwExpWinVer
Definition: win32.h:112
#define WINVER_WINNT4
Definition: window.h:57

Referenced by SetWindowPlacement().

◆ NtUserSetWindowPos()

BOOL APIENTRY NtUserSetWindowPos ( HWND  hWnd,
HWND  hWndInsertAfter,
int  X,
int  Y,
int  cx,
int  cy,
UINT  uFlags 
)

Definition at line 3533 of file winpos.c.

3541{
3542 PWND Window, pWndIA;
3543 BOOL ret = FALSE;
3545
3546 TRACE("Enter NtUserSetWindowPos\n");
3548
3549 if (!(Window = UserGetWindowObject(hWnd)) ||
3551 {
3552 ERR("NtUserSetWindowPos bad window handle!\n");
3553 goto Exit; // Return FALSE
3554 }
3555
3556 if ( hWndInsertAfter != HWND_TOP &&
3557 hWndInsertAfter != HWND_BOTTOM &&
3558 hWndInsertAfter != HWND_TOPMOST &&
3559 hWndInsertAfter != HWND_NOTOPMOST )
3560 {
3561 if (!(pWndIA = UserGetWindowObject(hWndInsertAfter)) ||
3562 UserIsDesktopWindow(pWndIA) || UserIsMessageWindow(pWndIA))
3563 {
3564 ERR("NtUserSetWindowPos bad insert window handle!\n");
3565 goto Exit; // Return FALSE
3566 }
3567 }
3568
3569 /* First make sure that coordinates are valid for WM_WINDOWPOSCHANGING */
3570 if (!(uFlags & SWP_NOMOVE))
3571 {
3572 if (X < -32768) X = -32768;
3573 else if (X > 32767) X = 32767;
3574 if (Y < -32768) Y = -32768;
3575 else if (Y > 32767) Y = 32767;
3576 }
3577 if (!(uFlags & SWP_NOSIZE))
3578 {
3579 if (cx < 0) cx = 0;
3580 else if (cx > 32767) cx = 32767;
3581 if (cy < 0) cy = 0;
3582 else if (cy > 32767) cy = 32767;
3583 }
3584
3585 UserRefObjectCo(Window, &Ref);
3586 ret = co_WinPosSetWindowPos(Window, hWndInsertAfter, X, Y, cx, cy, uFlags);
3588
3589Exit:
3590 TRACE("Leave NtUserSetWindowPos, ret=%i\n", ret);
3591 UserLeave();
3592 return ret;
3593}
UINT uFlags
Definition: api.c:59
int ret

Referenced by BringWindowToTop(), NtUserMoveWindow(), and SetWindowPos().

◆ NtUserSetWindowRgn()

INT APIENTRY NtUserSetWindowRgn ( HWND  hWnd,
HRGN  hRgn,
BOOL  bRedraw 
)

Definition at line 3599 of file winpos.c.

3603{
3604 HRGN hrgnCopy = NULL;
3605 PWND Window;
3607 INT Ret = 0;
3608
3609 TRACE("Enter NtUserSetWindowRgn\n");
3611
3612 if (!(Window = UserGetWindowObject(hWnd)) ||
3614 {
3615 goto Exit; // Return 0
3616 }
3617
3618 if (hRgn) // The region will be deleted in user32.
3619 {
3621 {
3622 hrgnCopy = NtGdiCreateRectRgn(0, 0, 0, 0);
3623 /* The coordinates of a window's window region are relative to the
3624 upper-left corner of the window, not the client area of the window. */
3625 NtGdiCombineRgn( hrgnCopy, hRgn, 0, RGN_COPY);
3626 }
3627 else
3628 goto Exit; // Return 0
3629 }
3630
3632 if (hrgnCopy)
3633 {
3634 Window->hrgnNewFrame = hrgnCopy; // Should be PSMWP->acvr->hrgnClip
3635 }
3636 else
3637 {
3638 Window->hrgnNewFrame = HRGN_WINDOW;
3639 }
3641 Ret = (INT)co_WinPosSetWindowPos(Window, HWND_TOP, 0, 0, 0, 0, bRedraw ? flags : (flags | SWP_NOREDRAW));
3642
3643Exit:
3644 TRACE("Leave NtUserSetWindowRgn, ret=%i\n", Ret);
3645 UserLeave();
3646 return Ret;
3647}
__kernel_entry W32KAPI INT APIENTRY NtGdiCombineRgn(_In_ HRGN hrgnDst, _In_ HRGN hrgnSrc1, _In_opt_ HRGN hrgnSrc2, _In_ INT iMode)
#define INT
Definition: polytest.cpp:20
BOOL NTAPI GreIsHandleValid(HGDIOBJ hobj)
Definition: gdiobj.c:1146

Referenced by ResetUserApiHook(), and SetWindowRgn().

◆ NtUserShowWindow()

BOOL APIENTRY NtUserShowWindow ( HWND  hWnd,
LONG  nCmdShow 
)

Definition at line 3821 of file winpos.c.

3822{
3823 PWND Window;
3824 BOOL ret = FALSE;
3826
3827 TRACE("Enter NtUserShowWindow hWnd %p SW_ %d\n",hWnd, nCmdShow);
3829
3830 if (!(Window = UserGetWindowObject(hWnd)) ||
3832 {
3833 goto Exit; // Return FALSE
3834 }
3835
3836 if ( nCmdShow > SW_MAX || Window->state2 & WNDS2_INDESTROY)
3837 {
3839 goto Exit; // Return FALSE
3840 }
3841
3842 UserRefObjectCo(Window, &Ref);
3843 ret = co_WinPosShowWindow(Window, nCmdShow);
3845
3846Exit:
3847 TRACE("Leave NtUserShowWindow, ret=%i\n", ret);
3848 UserLeave();
3849 return ret;
3850}

Referenced by AnimateWindow(), CloseWindow(), OpenIcon(), ShowWindow(), SwitchToThisWindow(), and WIN_CreateWindowEx().

◆ NtUserShowWindowAsync()

BOOL APIENTRY NtUserShowWindowAsync ( HWND  hWnd,
LONG  nCmdShow 
)

Definition at line 3784 of file winpos.c.

3785{
3786 PWND Window;
3788 BOOL ret = FALSE;
3790
3791 TRACE("Enter NtUserShowWindowAsync\n");
3793
3794 if (!(Window = UserGetWindowObject(hWnd)) ||
3796 {
3797 goto Exit; // Return FALSE
3798 }
3799
3800 if ( nCmdShow > SW_MAX )
3801 {
3803 goto Exit; // Return FALSE
3804 }
3805
3806 UserRefObjectCo(Window, &Ref);
3809 if (Result != -1 && Result != 0) ret = TRUE;
3810
3811Exit:
3812 TRACE("Leave NtUserShowWindowAsync, ret=%i\n", ret);
3813 UserLeave();
3814 return ret;
3815}

Referenced by ShowWindowAsync().

◆ NtUserWindowFromPoint()

HWND APIENTRY NtUserWindowFromPoint ( LONG  X,
LONG  Y 
)

Definition at line 3857 of file winpos.c.

3858{
3859 POINT pt;
3860 HWND Ret = NULL;
3862 USHORT hittest;
3864
3865 TRACE("Enter NtUserWindowFromPoint\n");
3867
3869 {
3870 //PTHREADINFO pti;
3871
3872 pt.x = X;
3873 pt.y = Y;
3874
3875 // Hmm... Threads live on desktops thus we have a reference on the desktop and indirectly the desktop window.
3876 // It is possible this referencing is useless, though it should not hurt...
3878
3879 //pti = PsGetCurrentThreadWin32Thread();
3881 if (Window)
3882 {
3883 Ret = UserHMGetHandle(Window);
3884 }
3885
3887 }
3888
3889 TRACE("Leave NtUserWindowFromPoint, ret=%p\n", Ret);
3890 UserLeave();
3891 return Ret;
3892}
PWND APIENTRY co_WinPosWindowFromPoint(IN PWND ScopeWin, IN POINT *WinPoint, IN OUT USHORT *HitTest, IN BOOL Ignore)
Definition: winpos.c:2961
Implementation of the Explorer desktop window.
Definition: desktop.h:52

Referenced by WindowFromPoint().

◆ SelectWindowRgn()

VOID SelectWindowRgn ( PWND  Window,
HRGN  hRgnClip 
)

Definition at line 259 of file winpos.c.

260{
261 if (Window->hrgnClip)
262 {
263 /* Delete no longer needed region handle */
265 GreDeleteObject(Window->hrgnClip);
266 Window->hrgnClip = NULL;
267 }
268
269 if (hRgnClip > HRGN_WINDOW)
270 {
271 /*if (!UserIsDesktopWindow(Window))
272 {
273 NtGdiOffsetRgn(hRgnClip, Window->rcWindow.left, Window->rcWindow.top);
274 }*/
275 /* Set public ownership */
277
278 Window->hrgnClip = hRgnClip;
279 }
280}

Referenced by co_WinPosSetWindowPos().

◆ UserGetWindowBorders()

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

Definition at line 894 of file winpos.c.

895{
896 DWORD Border = 0;
897
899 Border += 2;
901 Border += 1; /* for the outer frame always present */
902 if ((ExStyle & WS_EX_CLIENTEDGE) && WithClient)
903 Border += 2;
905 Border ++; /* The other border */
906 Size->cx = Size->cy = Border;
907 if ((Style & WS_THICKFRAME) && !(Style & WS_MINIMIZE)) /* The resize border */
908 {
911 }
914}
BOOL UserHasWindowEdge(DWORD Style, DWORD ExStyle)
Definition: winpos.c:850

Referenced by GetWindowInfo(), NC_HandleNCCalcSize(), RealAdjustWindowRectEx(), and UserDrawCaptionButtonWnd().

◆ UserHasWindowEdge()

BOOL UserHasWindowEdge ( DWORD  Style,
DWORD  ExStyle 
)

Definition at line 850 of file winpos.c.

851{
852 if (Style & WS_MINIMIZE)
853 return TRUE;
855 return TRUE;
857 return FALSE;
858 if (Style & WS_THICKFRAME)
859 return TRUE;
860 Style &= WS_CAPTION;
861 if (Style == WS_DLGFRAME || Style == WS_CAPTION)
862 return TRUE;
863 return FALSE;
864}

Referenced by UserGetWindowBorders().

◆ WinPosDoOwnedPopups()

static HWND FASTCALL WinPosDoOwnedPopups ( PWND  Window,
HWND  hWndInsertAfter 
)
static

Definition at line 1361 of file winpos.c.

1362{
1363 HWND *List = NULL;
1364 HWND Owner;
1365 LONG Style;
1366 PWND DesktopWindow, ChildObject;
1367 int i;
1368
1369 TRACE("(%p) hInsertAfter = %p\n", Window, hWndInsertAfter );
1370
1371 Style = Window->style;
1372
1373 if (Style & WS_CHILD)
1374 {
1375 TRACE("Window is child\n");
1376 return hWndInsertAfter;
1377 }
1378
1379 Owner = (Window->spwndOwner ? UserHMGetHandle(Window->spwndOwner) : NULL);
1380
1381 if (Owner)
1382 {
1383 /* Make sure this popup stays above the owner */
1384
1385 if (hWndInsertAfter != HWND_TOPMOST)
1386 {
1389
1390 if (List != NULL)
1391 {
1392 for (i = 0; List[i]; i++)
1393 {
1394 BOOL topmost = FALSE;
1395
1396 ChildObject = ValidateHwndNoErr(List[i]);
1397 if (ChildObject)
1398 {
1399 topmost = (ChildObject->ExStyle & WS_EX_TOPMOST) != 0;
1400 }
1401
1402 if (List[i] == Owner)
1403 {
1404 /* We found its Owner, so we must handle it here. */
1405 if (i > 0)
1406 {
1407 if (List[i - 1] != UserHMGetHandle(Window))
1408 {
1409 /*
1410 * If the popup to be inserted is not already just
1411 * before the Owner, insert it there. The modified
1412 * hWndInsertAfter will be handled below.
1413 *
1414 * (NOTE: Do not allow hWndInsertAfter to become equal
1415 * to the popup's window handle, as this would cause
1416 * the popup to link to itself).
1417 */
1418 hWndInsertAfter = List[i - 1];
1419 }
1420 else
1421 {
1422 /* If the popup to be inserted is already
1423 * before the Owner, we are done. */
1425 return hWndInsertAfter;
1426 }
1427 }
1428 else
1429 {
1430 hWndInsertAfter = topmost ? HWND_TOPMOST : HWND_TOP;
1431 }
1432 break;
1433 }
1434
1435 if (hWndInsertAfter == HWND_TOP || hWndInsertAfter == HWND_NOTOPMOST)
1436 {
1437 if (!topmost) break;
1438 }
1439 else if (List[i] == hWndInsertAfter) break;
1440 }
1441 }
1442 else
1443 return hWndInsertAfter;
1444 }
1445 }
1446
1447 if (hWndInsertAfter == HWND_BOTTOM)
1448 {
1449 ERR("Window is HWND_BOTTOM hwnd %p\n",hWndInsertAfter);
1451 goto done;
1452 }
1453
1454 if (!List)
1455 {
1458 }
1459
1460 if (List != NULL)
1461 {
1462 i = 0;
1463
1464 if (hWndInsertAfter == HWND_TOP || hWndInsertAfter == HWND_NOTOPMOST)
1465 {
1466 if (hWndInsertAfter == HWND_NOTOPMOST || !(Window->ExStyle & WS_EX_TOPMOST))
1467 {
1468 TRACE("skip all the topmost windows\n");
1469 /* skip all the topmost windows */
1470 while (List[i] &&
1471 (ChildObject = ValidateHwndNoErr(List[i])) &&
1472 (ChildObject->ExStyle & WS_EX_TOPMOST)) i++;
1473 }
1474 }
1475 else if (hWndInsertAfter != HWND_TOPMOST)
1476 {
1477 /* skip windows that are already placed correctly */
1478 for (i = 0; List[i]; i++)
1479 {
1480 if (List[i] == hWndInsertAfter) break;
1481 if (List[i] == UserHMGetHandle(Window))
1482 {
1484 goto done; /* nothing to do if window is moving backwards in z-order */
1485 }
1486 }
1487 }
1488
1489 for (; List[i]; i++)
1490 {
1491 PWND Wnd;
1493
1494 if (List[i] == UserHMGetHandle(Window))
1495 break;
1496
1497 if (!(Wnd = ValidateHwndNoErr(List[i])))
1498 continue;
1499
1500 Owner = (Wnd->spwndOwner ? UserHMGetHandle(Wnd->spwndOwner) : NULL);
1501
1502 if (Owner != UserHMGetHandle(Window)) continue;
1503
1504 UserRefObjectCo(Wnd, &Ref);
1505 TRACE( "moving %p owned by %p after %p\n", List[i], UserHMGetHandle(Window), hWndInsertAfter );
1506 co_WinPosSetWindowPos(Wnd, hWndInsertAfter, 0, 0, 0, 0,
1508
1509 UserDerefObjectCo(Wnd);
1510 hWndInsertAfter = List[i];
1511 }
1513 }
1514done:
1515 return hWndInsertAfter;
1516}
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID Owner
Definition: rtlfuncs.h:1621

Referenced by co_WinPosSetWindowPos().

◆ WinPosFindIconPos()

static VOID FASTCALL WinPosFindIconPos ( PWND  Window,
POINT Pos 
)
static

Definition at line 787 of file winpos.c.

788{
789 RECT rectParent;
790 PWND pwndChild, pwndParent;
791 int x, y, xspacing, yspacing;
792
793 pwndParent = Window->spwndParent;
794 if (UserIsDesktopWindow(pwndParent))
795 {
796 ERR("FIXME: Parent is Desktop, Min off screen!\n");
797 /* FIXME: ReactOS doesn't support iconic minimize to desktop */
798 Pos->x = Pos->y = -32000;
799 Window->InternalPos.flags |= WPF_MININIT;
800 Window->InternalPos.IconPos.x = Pos->x;
801 Window->InternalPos.IconPos.y = Pos->y;
802 return;
803 }
804
805 IntGetClientRect( pwndParent, &rectParent );
806 // FIXME: Support Minimize Metrics gspv.mm.iArrange.
807 // Default: ARW_BOTTOMLEFT
808 x = rectParent.left;
809 y = rectParent.bottom;
810
813
814 // Set to default position when minimized.
816 Pos->y = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
817
818 for (pwndChild = pwndParent->spwndChild; pwndChild; pwndChild = pwndChild->spwndNext)
819 {
820 if (pwndChild == Window) continue;
821
822 if ((pwndChild->style & (WS_VISIBLE|WS_MINIMIZE)) != (WS_VISIBLE|WS_MINIMIZE) )
823 {
824 continue;
825 }
826
827 if ( pwndChild->InternalPos.IconPos.x != Pos->x && pwndChild->InternalPos.IconPos.y != Pos->y )
828 {
829 break;
830 }
831 if (x <= rectParent.right - xspacing)
832 x += xspacing;
833 else
834 {
835 x = rectParent.left;
836 y -= yspacing;
837 }
839 Pos->y = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
840 }
841
842 Window->InternalPos.IconPos.x = Pos->x;
843 Window->InternalPos.IconPos.y = Pos->y;
844 Window->InternalPos.flags |= WPF_MININIT;
845 TRACE("Position is set! X:%d Y:%d\n",Pos->x,Pos->y);
846 return;
847}

Referenced by co_WinPosMinMaximize().

◆ WinPosFixupFlags()

static BOOL FASTCALL WinPosFixupFlags ( WINDOWPOS WinPos,
PWND  Wnd 
)
static

Definition at line 1557 of file winpos.c.

1558{
1559 PWND Parent;
1560 POINT pt;
1561
1562 /* Finally make sure that all coordinates are valid */
1563 if (WinPos->x < -32768) WinPos->x = -32768;
1564 else if (WinPos->x > 32767) WinPos->x = 32767;
1565 if (WinPos->y < -32768) WinPos->y = -32768;
1566 else if (WinPos->y > 32767) WinPos->y = 32767;
1567
1568 WinPos->cx = max(WinPos->cx, 0);
1569 WinPos->cy = max(WinPos->cy, 0);
1570
1572 if (!IntIsWindowVisible( Parent ) &&
1573 /* Fix B : wine msg test_SetParent:WmSetParentSeq_2:25 wParam bits! */
1575
1576 if (Wnd->style & WS_VISIBLE) WinPos->flags &= ~SWP_SHOWWINDOW;
1577 else
1578 {
1579 WinPos->flags &= ~SWP_HIDEWINDOW;
1580 if (!(WinPos->flags & SWP_SHOWWINDOW)) WinPos->flags |= SWP_NOREDRAW;
1581 }
1582
1583 /* Check for right size */
1584 if (Wnd->rcWindow.right - Wnd->rcWindow.left == WinPos->cx &&
1585 Wnd->rcWindow.bottom - Wnd->rcWindow.top == WinPos->cy)
1586 {
1587 WinPos->flags |= SWP_NOSIZE;
1588 }
1589
1590 pt.x = WinPos->x;
1591 pt.y = WinPos->y;
1593 TRACE("WPFU C2S wpx %d wpy %d ptx %d pty %d\n",WinPos->x,WinPos->y,pt.x,pt.y);
1594 /* Check for right position */
1595 if (Wnd->rcWindow.left == pt.x && Wnd->rcWindow.top == pt.y)
1596 {
1597 //ERR("In right pos\n");
1598 WinPos->flags |= SWP_NOMOVE;
1599 }
1600
1601 if ( WinPos->hwnd != UserGetForegroundWindow() && (Wnd->style & (WS_POPUP | WS_CHILD)) != WS_CHILD)
1602 {
1603 /* Bring to the top when activating */
1604 if (!(WinPos->flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)) &&
1605 (WinPos->flags & SWP_NOZORDER ||
1606 (WinPos->hwndInsertAfter != HWND_TOPMOST && WinPos->hwndInsertAfter != HWND_NOTOPMOST)))
1607 {
1608 WinPos->flags &= ~SWP_NOZORDER;
1609 WinPos->hwndInsertAfter = (0 != (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOPMOST : HWND_TOP);
1610 }
1611 }
1612
1613 /* Check hwndInsertAfter */
1614 if (!(WinPos->flags & SWP_NOZORDER))
1615 {
1616 /* Fix sign extension */
1617 if (WinPos->hwndInsertAfter == (HWND)0xffff)
1618 {
1619 WinPos->hwndInsertAfter = HWND_TOPMOST;
1620 }
1621 else if (WinPos->hwndInsertAfter == (HWND)0xfffe)
1622 {
1624 }
1625
1626 if (WinPos->hwndInsertAfter == HWND_TOP)
1627 {
1628 /* Keep it topmost when it's already topmost */
1629 if ((Wnd->ExStyle & WS_EX_TOPMOST) != 0)
1630 WinPos->hwndInsertAfter = HWND_TOPMOST;
1631
1632 if (IntGetWindow(WinPos->hwnd, GW_HWNDFIRST) == WinPos->hwnd)
1633 {
1634 WinPos->flags |= SWP_NOZORDER;
1635 }
1636 }
1637 else if (WinPos->hwndInsertAfter == HWND_BOTTOM)
1638 {
1639 if (!(Wnd->ExStyle & WS_EX_TOPMOST) && IntGetWindow(WinPos->hwnd, GW_HWNDLAST) == WinPos->hwnd)
1640 WinPos->flags |= SWP_NOZORDER;
1641 }
1642 else if (WinPos->hwndInsertAfter == HWND_TOPMOST)
1643 {
1644 if ((Wnd->ExStyle & WS_EX_TOPMOST) && IntGetWindow(WinPos->hwnd, GW_HWNDFIRST) == WinPos->hwnd)
1645 WinPos->flags |= SWP_NOZORDER;
1646 }
1647 else if (WinPos->hwndInsertAfter == HWND_NOTOPMOST)
1648 {
1649 if (!(Wnd->ExStyle & WS_EX_TOPMOST))
1650 WinPos->flags |= SWP_NOZORDER;
1651 }
1652 else /* hwndInsertAfter must be a sibling of the window */
1653 {
1654 PWND InsAfterWnd;
1655
1656 InsAfterWnd = ValidateHwndNoErr(WinPos->hwndInsertAfter);
1657 if(!InsAfterWnd)
1658 {
1659 return TRUE;
1660 }
1661
1662 if (InsAfterWnd->spwndParent != Wnd->spwndParent)
1663 {
1664 /* Note from wine User32 Win test_SetWindowPos:
1665 "Returns TRUE also for windows that are not siblings"
1666 "Does not seem to do anything even without passing flags, still returns TRUE"
1667 "Same thing the other way around."
1668 ".. and with these windows."
1669 */
1670 return FALSE;
1671 }
1672 else
1673 {
1674 /*
1675 * We don't need to change the Z order of hwnd if it's already
1676 * inserted after hwndInsertAfter or when inserting hwnd after
1677 * itself.
1678 */
1679 if ((WinPos->hwnd == WinPos->hwndInsertAfter) ||
1680 ((InsAfterWnd->spwndNext) && (WinPos->hwnd == UserHMGetHandle(InsAfterWnd->spwndNext))))
1681 {
1682 WinPos->flags |= SWP_NOZORDER;
1683 }
1684 }
1685 }
1686 }
1687
1688 return TRUE;
1689}
HWND FASTCALL UserGetForegroundWindow(VOID)
Definition: focus.c:1424
BOOL FASTCALL IntClientToScreen(PWND Wnd, LPPOINT lpPoint)
Definition: winpos.c:199
HWND FASTCALL IntGetWindow(HWND hWnd, UINT uCmd)
Definition: window.c:383
BOOL FASTCALL IntIsWindowVisible(PWND Wnd)
Definition: window.c:191
#define GW_HWNDFIRST
Definition: winuser.h:767
#define GW_HWNDLAST
Definition: winuser.h:768

Referenced by co_WinPosSetWindowPos().

◆ WinPosInitInternalPos()

VOID FASTCALL WinPosInitInternalPos ( PWND  Wnd,
RECTL RestoreRect 
)

Definition at line 480 of file winpos.c.

481{
482 POINT Size;
483 RECTL Rect = *RestoreRect;
484
486 {
488 -Wnd->spwndParent->rcClient.left,
489 -Wnd->spwndParent->rcClient.top);
490 }
491
492 Size.x = Rect.left;
493 Size.y = Rect.top;
494
495 if (!Wnd->InternalPosInitialized)
496 {
497 // FIXME: Use check point Atom..
498 Wnd->InternalPos.flags = 0;
499 Wnd->InternalPos.MaxPos.x = Wnd->InternalPos.MaxPos.y = -1;
500 Wnd->InternalPos.IconPos.x = Wnd->InternalPos.IconPos.y = -1;
501 Wnd->InternalPos.NormalRect = Rect;
503 }
504
505 if (Wnd->style & WS_MINIMIZE)
506 {
507 Wnd->InternalPos.IconPos = Size;
508 Wnd->InternalPos.flags |= WPF_MININIT;
509 }
510 else if (Wnd->style & WS_MAXIMIZE)
511 {
512 Wnd->InternalPos.flags |= WPF_MAXINIT;
513
514 if ( Wnd->spwndParent == Wnd->head.rpdesk->pDeskInfo->spwnd )
515 {
517 {
518 Wnd->InternalPos.flags &= ~WPF_MAXINIT;
519 Wnd->InternalPos.MaxPos.x = Wnd->InternalPos.MaxPos.y = -1;
520 }
521 else
522 {
523 RECTL WorkArea;
524 PMONITOR pmonitor = UserMonitorFromRect(&Rect, MONITOR_DEFAULTTOPRIMARY );
525 // FIXME: support DPI aware, rcWorkDPI/Real etc..
526 WorkArea = pmonitor->rcMonitor;
527
528 if (Wnd->style & WS_MAXIMIZEBOX)
529 { // Support (Wnd->state & WNDS_HASCAPTION) || pmonitor->cFullScreen too.
530 if ((Wnd->style & WS_CAPTION) == WS_CAPTION || !(Wnd->style & (WS_CHILD | WS_POPUP)))
531 {
532 WorkArea = pmonitor->rcWork;
533 //ERR("rcWork\n");
534 }
535 }
536
537 Wnd->InternalPos.MaxPos.x = Rect.left - WorkArea.left;
538 Wnd->InternalPos.MaxPos.y = Rect.top - WorkArea.top;
539
540 /*ERR("WinPosIP 2 X %d = R.l %d - W.l %d | Y %d = R.t %d - W.t %d\n",
541 Wnd->InternalPos.MaxPos.x,
542 Rect.left, WorkArea.left,
543 Wnd->InternalPos.MaxPos.y,
544 Rect.top, WorkArea.top);*/
545 }
546 }
547 else
548 Wnd->InternalPos.MaxPos = Size;
549 }
550 else
551 {
552 /* Lie about the snap; Windows does this so applications don't save their
553 * position as a snap but rather the unsnapped "real" position. */
554 if (!IntIsWindowSnapped(Wnd) ||
555 RECTL_bIsEmptyRect(&Wnd->InternalPos.NormalRect))
556 {
557 Wnd->InternalPos.NormalRect = Rect;
558 }
559 }
560}
UINT InternalPosInitialized
Definition: ntuser.h:757
FORCEINLINE BOOL RECTL_bIsEmptyRect(_In_ const RECTL *prcl)
Definition: rect.h:44

Referenced by IntGetWindowPlacement().

◆ WinPosInternalMoveWindow()

static VOID FASTCALL WinPosInternalMoveWindow ( PWND  Window,
INT  MoveX,
INT  MoveY 
)
static

Definition at line 1527 of file winpos.c.

1528{
1529 PWND Child;
1530
1531 ASSERT(Window != Window->spwndChild);
1532 TRACE("InternalMoveWin X %d Y %d\n", MoveX, MoveY);
1533
1534 Window->rcWindow.left += MoveX;
1535 Window->rcWindow.right += MoveX;
1536 Window->rcWindow.top += MoveY;
1537 Window->rcWindow.bottom += MoveY;
1538
1539 Window->rcClient.left += MoveX;
1540 Window->rcClient.right += MoveX;
1541 Window->rcClient.top += MoveY;
1542 Window->rcClient.bottom += MoveY;
1543
1544 for(Child = Window->spwndChild; Child; Child = Child->spwndNext)
1545 {
1546 WinPosInternalMoveWindow(Child, MoveX, MoveY);
1547 }
1548}

Referenced by co_WinPosSetWindowPos(), and WinPosInternalMoveWindow().