ReactOS  0.4.15-dev-4574-g434cf85
winpos.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS kernel
4  * PURPOSE: Windows
5  * FILE: win32ss/user/ntuser/winpos.c
6  * PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
7  */
8 
9 #include <win32k.h>
10 DBG_DEFAULT_CHANNEL(UserWinpos);
11 
12 /* GLOBALS *******************************************************************/
13 
14 #define MINMAX_NOSWP (0x00010000)
15 
16 #define SWP_EX_NOCOPY 0x0001
17 #define SWP_EX_PAINTSELF 0x0002
18 
19 #define SWP_AGG_NOGEOMETRYCHANGE \
20  (SWP_NOSIZE | SWP_NOCLIENTSIZE | SWP_NOZORDER)
21 #define SWP_AGG_NOPOSCHANGE \
22  (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER)
23 #define SWP_AGG_STATUSFLAGS \
24  (SWP_AGG_NOPOSCHANGE | SWP_FRAMECHANGED | SWP_HIDEWINDOW | SWP_SHOWWINDOW)
25 #define SWP_AGG_NOCLIENTCHANGE \
26  (SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE)
27 
28 #define EMPTYPOINT(pt) ((pt).x == -1 && (pt).y == -1)
29 #define PLACE_MIN 0x0001
30 #define PLACE_MAX 0x0002
31 #define PLACE_RECT 0x0004
32 
33 /* FUNCTIONS *****************************************************************/
34 
35 #if DBG
36 /***********************************************************************
37  * dump_winpos_flags
38  */
39 static void dump_winpos_flags(UINT flags)
40 {
41  static const DWORD dumped_flags = (SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOREDRAW |
46  TRACE("flags:");
47  if(flags & SWP_NOSIZE) TRACE(" SWP_NOSIZE");
48  if(flags & SWP_NOMOVE) TRACE(" SWP_NOMOVE");
49  if(flags & SWP_NOZORDER) TRACE(" SWP_NOZORDER");
50  if(flags & SWP_NOREDRAW) TRACE(" SWP_NOREDRAW");
51  if(flags & SWP_NOACTIVATE) TRACE(" SWP_NOACTIVATE");
52  if(flags & SWP_FRAMECHANGED) TRACE(" SWP_FRAMECHANGED");
53  if(flags & SWP_SHOWWINDOW) TRACE(" SWP_SHOWWINDOW");
54  if(flags & SWP_HIDEWINDOW) TRACE(" SWP_HIDEWINDOW");
55  if(flags & SWP_NOCOPYBITS) TRACE(" SWP_NOCOPYBITS");
56  if(flags & SWP_NOOWNERZORDER) TRACE(" SWP_NOOWNERZORDER");
57  if(flags & SWP_NOSENDCHANGING) TRACE(" SWP_NOSENDCHANGING");
58  if(flags & SWP_DEFERERASE) TRACE(" SWP_DEFERERASE");
59  if(flags & SWP_ASYNCWINDOWPOS) TRACE(" SWP_ASYNCWINDOWPOS");
60  if(flags & SWP_NOCLIENTSIZE) TRACE(" SWP_NOCLIENTSIZE");
61  if(flags & SWP_NOCLIENTMOVE) TRACE(" SWP_NOCLIENTMOVE");
62  if(flags & SWP_STATECHANGED) TRACE(" SWP_STATECHANGED");
63 
64  if(flags & ~dumped_flags) TRACE(" %08x", flags & ~dumped_flags);
65  TRACE("\n");
66 }
67 #endif
68 
71 {
73  if (Window == NULL)
74  {
75  Point->x = Point->y = 0;
76  return FALSE;
77  }
78  Point->x = Window->rcClient.left;
79  Point->y = Window->rcClient.top;
80 
81  return TRUE;
82 }
83 
92 {
93  ASSERT( Wnd );
94  ASSERT( Rect );
95  if (Wnd->style & WS_MINIMIZED)
96  {
97  Rect->left = Rect->top = 0;
100  return;
101  }
102  if (!UserIsDesktopWindow(Wnd))
103  {
104  *Rect = Wnd->rcClient;
106  }
107  else
108  {
109  Rect->left = Rect->top = 0;
110  Rect->right = Wnd->rcClient.right;
111  Rect->bottom = Wnd->rcClient.bottom;
112  /* Do this until Init bug is fixed. This sets 640x480, see InitMetrics.
113  Rect->right = UserGetSystemMetrics(SM_CXSCREEN);
114  Rect->bottom = UserGetSystemMetrics(SM_CYSCREEN);
115  */
116  }
117 }
118 
121 {
122  ASSERT( Wnd );
123  ASSERT( Rect );
124  if (!Wnd) return FALSE;
125  if (!UserIsDesktopWindow(Wnd))
126  {
127  *Rect = Wnd->rcWindow;
128  }
129  else
130  {
131  Rect->left = Rect->top = 0;
132  Rect->right = Wnd->rcWindow.right;
133  Rect->bottom = Wnd->rcWindow.bottom;
134 /* Do this until Init bug is fixed. This sets 640x480, see InitMetrics.
135  Rect->right = GetSystemMetrics(SM_CXSCREEN);
136  Rect->bottom = GetSystemMetrics(SM_CYSCREEN);
137 */ }
138  return TRUE;
139 }
140 
141 
143 IntMapWindowPoints(PWND FromWnd, PWND ToWnd, LPPOINT lpPoints, UINT cPoints)
144 {
145  BOOL mirror_from, mirror_to;
146  POINT Delta;
147  UINT i;
148  int Change = 1;
149 
150  /* Note: Desktop Top and Left is always 0! */
151  Delta.x = Delta.y = 0;
152  mirror_from = mirror_to = FALSE;
153 
154  if (FromWnd && !UserIsDesktopWindow(FromWnd))
155  {
156  if (FromWnd->ExStyle & WS_EX_LAYOUTRTL)
157  {
158  mirror_from = TRUE;
159  Change = -Change;
160  Delta.x = -FromWnd->rcClient.right;
161  }
162  else
163  Delta.x = FromWnd->rcClient.left;
164  Delta.y = FromWnd->rcClient.top;
165  }
166 
167  if (ToWnd && !UserIsDesktopWindow(ToWnd))
168  {
169  if (ToWnd->ExStyle & WS_EX_LAYOUTRTL)
170  {
171  mirror_to = TRUE;
172  Change = -Change;
173  Delta.x += Change * ToWnd->rcClient.right;
174  }
175  else
176  Delta.x -= Change * ToWnd->rcClient.left;
177  Delta.y -= ToWnd->rcClient.top;
178  }
179 
180  for (i = 0; i != cPoints; i++)
181  {
182  lpPoints[i].x += Delta.x;
183  lpPoints[i].x *= Change;
184  lpPoints[i].y += Delta.y;
185  }
186 
187  if ((mirror_from || mirror_to) && cPoints == 2) /* special case for rectangle */
188  {
189  int tmp = min(lpPoints[0].x, lpPoints[1].x);
190  lpPoints[1].x = max(lpPoints[0].x, lpPoints[1].x);
191  lpPoints[0].x = tmp;
192  }
193 
194  return MAKELONG(LOWORD(Delta.x), LOWORD(Delta.y));
195 }
196 
199 {
200  if (Wnd && Wnd->fnid != FNID_DESKTOP )
201  {
202  if (Wnd->ExStyle & WS_EX_LAYOUTRTL)
203  lpPoint->x = Wnd->rcClient.right - lpPoint->x;
204  else
205  lpPoint->x += Wnd->rcClient.left;
206  lpPoint->y += Wnd->rcClient.top;
207  }
208  return TRUE;
209 }
210 
213 {
214  if (Wnd && Wnd->fnid != FNID_DESKTOP )
215  {
216  if (Wnd->ExStyle & WS_EX_LAYOUTRTL)
217  lpPoint->x = Wnd->rcClient.right - lpPoint->x;
218  else
219  lpPoint->x -= Wnd->rcClient.left;
220  lpPoint->y -= Wnd->rcClient.top;
221  }
222  return TRUE;
223 }
224 
226 {
227  do
228  {
229  if ( (pWnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD ||
230  !(pWnd = pWnd->spwndParent) )
231  return TRUE;
232  }
233  while (pWnd->style & WS_VISIBLE);
234  return FALSE;
235 }
236 
238 {
239  PWND pWnd;
240  PDESKTOP rpdesk = gptiCurrent->rpdesk;
241 
242  if ( rpdesk &&
243  (pWnd = rpdesk->pDeskInfo->spwnd->spwndChild) &&
244  pWnd->ExStyle & WS_EX_TOPMOST)
245  {
246  for (;;)
247  {
248  if (!pWnd->spwndNext) break;
249  if (!(pWnd->spwndNext->ExStyle & WS_EX_TOPMOST)) break;
250  pWnd = pWnd->spwndNext;
251  }
252  return pWnd;
253  }
254  return NULL;
255 }
256 
257 VOID
258 SelectWindowRgn(PWND Window, HRGN hRgnClip)
259 {
260  if (Window->hrgnClip)
261  {
262  /* Delete no longer needed region handle */
264  GreDeleteObject(Window->hrgnClip);
265  Window->hrgnClip = NULL;
266  }
267 
268  if (hRgnClip > HRGN_WINDOW)
269  {
270  /*if (!UserIsDesktopWindow(Window))
271  {
272  NtGdiOffsetRgn(hRgnClip, Window->rcWindow.left, Window->rcWindow.top);
273  }*/
274  /* Set public ownership */
276 
277  Window->hrgnClip = hRgnClip;
278  }
279 }
280 
281 //
282 // This helps with CORE-6129 forcing modal dialog active when another app is minimized or closed.
283 //
285 {
286  BOOL ActivePrev, FindTopWnd;
287  PWND pWndTopMost, pWndChild, pWndSetActive, pWndTemp, pWndDesk;
289  PTHREADINFO pti = gptiCurrent;
290 
291  //ERR("AOWM 1 %p\n",Wnd->head.h);
292  ActivePrev = (pti->MessageQueue->spwndActivePrev != NULL);
293  FindTopWnd = TRUE;
294 
295  if ((pWndTopMost = IntGetLastTopMostWindow()))
296  pWndChild = pWndTopMost->spwndNext;
297  else
298  pWndChild = Wnd->spwndParent->spwndChild;
299 
300  for (;;)
301  {
302  if ( ActivePrev )
303  pWndSetActive = pti->MessageQueue->spwndActivePrev;
304  else
305  pWndSetActive = pWndChild;
306 
307  pWndTemp = NULL;
308 
309  while(pWndSetActive)
310  {
311  if ( VerifyWnd(pWndSetActive) &&
312  !(pWndSetActive->ExStyle & WS_EX_NOACTIVATE) &&
313  (pWndSetActive->style & (WS_VISIBLE|WS_DISABLED)) == WS_VISIBLE &&
314  (!(pWndSetActive->style & WS_ICONIC) /* FIXME MinMax pos? */ ) )
315  {
316  if (!(pWndSetActive->ExStyle & WS_EX_TOOLWINDOW) )
317  {
318  UserRefObjectCo(pWndSetActive, &Ref);
319  //ERR("ActivateOtherWindowMin Set FG 1\n");
320  co_IntSetForegroundWindow(pWndSetActive);
321  UserDerefObjectCo(pWndSetActive);
322  //ERR("AOWM 2 Exit Good %p\n",pWndSetActive->head.h);
323  return TRUE;
324  }
325  if (!pWndTemp ) pWndTemp = pWndSetActive;
326  }
327  if ( ActivePrev )
328  {
329  ActivePrev = FALSE;
330  pWndSetActive = pWndChild;
331  }
332  else
333  pWndSetActive = pWndSetActive->spwndNext;
334  }
335 
336  if ( !FindTopWnd ) break;
337  FindTopWnd = FALSE;
338 
339  if ( pWndChild )
340  {
341  pWndChild = pWndChild->spwndParent->spwndChild;
342  continue;
343  }
344 
345  if (!(pWndDesk = IntGetThreadDesktopWindow(pti)))
346  {
347  pWndChild = NULL;
348  continue;
349  }
350  pWndChild = pWndDesk->spwndChild;
351  }
352 
353  if ((pWndSetActive = pWndTemp))
354  {
355  UserRefObjectCo(pWndSetActive, &Ref);
356  //ERR("ActivateOtherWindowMin Set FG 2\n");
357  co_IntSetForegroundWindow(pWndSetActive);
358  UserDerefObjectCo(pWndSetActive);
359  //ERR("AOWM 3 Exit Good %p\n",pWndSetActive->head.h);
360  return TRUE;
361  }
362  //ERR("AOWM 4 Bad\n");
363  return FALSE;
364 }
365 
366 /*******************************************************************
367  * can_activate_window
368  *
369  * Check if we can activate the specified window.
370  */
371 static
373 {
374  LONG style;
375 
376  if (!Wnd) return FALSE;
377 
378  style = Wnd->style;
379  if (!(style & WS_VISIBLE)) return FALSE;
380  if (style & WS_MINIMIZE) return FALSE;
381  if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return FALSE;
382  return TRUE;
383  /* FIXME: This window could be disable because the child that closed
384  was a popup. */
385  //return !(style & WS_DISABLED);
386 }
387 
388 
389 /*******************************************************************
390  * WinPosActivateOtherWindow
391  *
392  * Activates window other than pWnd.
393  */
396 {
397  PWND WndTo = NULL;
399 
400  ASSERT_REFS_CO(Wnd);
401 
402  if (IntIsDesktopWindow(Wnd))
403  {
404  //ERR("WinPosActivateOtherWindow Set Focus Msg Q No window!\n");
406  return;
407  }
408 
409  /* If this is popup window, try to activate the owner first. */
410  if ((Wnd->style & WS_POPUP) && (WndTo = Wnd->spwndOwner))
411  {
412  TRACE("WPAOW Popup with Owner\n");
413  WndTo = UserGetAncestor( WndTo, GA_ROOT );
414  if (can_activate_window(WndTo)) goto done;
415  }
416 
417  /* Pick a next top-level window. */
418  /* FIXME: Search for non-tooltip windows first. */
419  WndTo = Wnd;
420  for (;;)
421  {
422  if (!(WndTo = WndTo->spwndNext)) break;
423  if (can_activate_window( WndTo )) goto done;
424  }
425 
426  /*
427  Fixes wine win.c:test_SetParent last ShowWindow test after popup dies.
428  Check for previous active window to bring to top.
429  */
430  if (Wnd)
431  {
432  WndTo = Wnd->head.pti->MessageQueue->spwndActivePrev;
433  if (can_activate_window( WndTo )) goto done;
434  }
435 
436  // Find any window to bring to top. Works Okay for wine since it does not see X11 windows.
437  WndTo = UserGetDesktopWindow();
438  WndTo = WndTo->spwndChild;
439  if ( WndTo == NULL )
440  {
441  //ERR("WinPosActivateOtherWindow No window!\n");
442  return;
443  }
444  for (;;)
445  {
446  if (WndTo == Wnd)
447  {
448  WndTo = NULL;
449  break;
450  }
451  if (can_activate_window( WndTo )) goto done;
452  if (!(WndTo = WndTo->spwndNext)) break;
453  }
454 
455 done:
456  if (WndTo) UserRefObjectCo(WndTo, &Ref);
457 
459  {
460  /* ReactOS can pass WndTo = NULL to co_IntSetForegroundWindow and returns FALSE. */
461  //ERR("WinPosActivateOtherWindow Set FG 0x%p hWnd %p\n",WndTo, WndTo ? WndTo->head.h : 0);
462  if (co_IntSetForegroundWindow(WndTo))
463  {
464  if (WndTo) UserDerefObjectCo(WndTo);
465  return;
466  }
467  }
468  //ERR("WinPosActivateOtherWindow Set Active 0x%p\n",WndTo);
469  if (!UserSetActiveWindow(WndTo)) /* Ok for WndTo to be NULL here */
470  {
471  //ERR("WPAOW SA 1\n");
473  }
474  if (WndTo) UserDerefObjectCo(WndTo);
475 }
476 
478 WinPosInitInternalPos(PWND Wnd, RECTL *RestoreRect)
479 {
480  POINT Size;
481  RECTL Rect = *RestoreRect;
482 
483  if (Wnd->spwndParent && !UserIsDesktopWindow(Wnd->spwndParent))
484  {
486  -Wnd->spwndParent->rcClient.left,
487  -Wnd->spwndParent->rcClient.top);
488  }
489 
490  Size.x = Rect.left;
491  Size.y = Rect.top;
492 
493  if (!Wnd->InternalPosInitialized)
494  {
495  // FIXME: Use check point Atom..
496  Wnd->InternalPos.flags = 0;
497  Wnd->InternalPos.MaxPos.x = Wnd->InternalPos.MaxPos.y = -1;
498  Wnd->InternalPos.IconPos.x = Wnd->InternalPos.IconPos.y = -1;
499  Wnd->InternalPos.NormalRect = Rect;
501  }
502 
503  if (Wnd->style & WS_MINIMIZE)
504  {
505  Wnd->InternalPos.IconPos = Size;
506  Wnd->InternalPos.flags |= WPF_MININIT;
507  }
508  else if (Wnd->style & WS_MAXIMIZE)
509  {
510  Wnd->InternalPos.flags |= WPF_MAXINIT;
511 
512  if ( Wnd->spwndParent == Wnd->head.rpdesk->pDeskInfo->spwnd )
513  {
514  if (Wnd->state & WNDS_MAXIMIZESTOMONITOR)
515  {
516  Wnd->InternalPos.flags &= ~WPF_MAXINIT;
517  Wnd->InternalPos.MaxPos.x = Wnd->InternalPos.MaxPos.y = -1;
518  }
519  else
520  {
521  RECTL WorkArea;
522  PMONITOR pmonitor = UserMonitorFromRect(&Rect, MONITOR_DEFAULTTOPRIMARY );
523  // FIXME: support DPI aware, rcWorkDPI/Real etc..
524  WorkArea = pmonitor->rcMonitor;
525 
526  if (Wnd->style & WS_MAXIMIZEBOX)
527  { // Support (Wnd->state & WNDS_HASCAPTION) || pmonitor->cFullScreen too.
528  if ((Wnd->style & WS_CAPTION) == WS_CAPTION || !(Wnd->style & (WS_CHILD | WS_POPUP)))
529  {
530  WorkArea = pmonitor->rcWork;
531  //ERR("rcWork\n");
532  }
533  }
534 
535  Wnd->InternalPos.MaxPos.x = Rect.left - WorkArea.left;
536  Wnd->InternalPos.MaxPos.y = Rect.top - WorkArea.top;
537 
538  /*ERR("WinPosIP 2 X %d = R.l %d - W.l %d | Y %d = R.t %d - W.t %d\n",
539  Wnd->InternalPos.MaxPos.x,
540  Rect.left, WorkArea.left,
541  Wnd->InternalPos.MaxPos.y,
542  Rect.top, WorkArea.top);*/
543  }
544  }
545  else
546  Wnd->InternalPos.MaxPos = Size;
547  }
548  else
549  {
550  Wnd->InternalPos.NormalRect = Rect;
551  }
552 }
553 
554 // Win: _GetWindowPlacement
555 BOOL
556 FASTCALL
558 {
559  if (!Wnd) return FALSE;
560 
561  if(lpwndpl->length != sizeof(WINDOWPLACEMENT))
562  {
563  return FALSE;
564  }
565 
566  lpwndpl->flags = 0;
567 
568  WinPosInitInternalPos(Wnd, &Wnd->rcWindow);
569 
570  lpwndpl->showCmd = SW_HIDE;
571 
572  if ( Wnd->style & WS_MINIMIZE )
573  lpwndpl->showCmd = SW_SHOWMINIMIZED;
574  else
575  lpwndpl->showCmd = ( Wnd->style & WS_MAXIMIZE ) ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL ;
576 
577  lpwndpl->rcNormalPosition = Wnd->InternalPos.NormalRect;
578 
579  if (Wnd->InternalPos.flags & WPF_MININIT) // Return if it was set!
580  {
581  lpwndpl->ptMinPosition.x = Wnd->InternalPos.IconPos.x;
582  lpwndpl->ptMinPosition.y = Wnd->InternalPos.IconPos.y;
583  }
584  else
585  lpwndpl->ptMinPosition.x = lpwndpl->ptMinPosition.y = -1;
586 
587  if ( Wnd->InternalPos.flags & WPF_MAXINIT && // Return if set and not maximized to monitor!
588  !(Wnd->state & WNDS_MAXIMIZESTOMONITOR))
589  {
590  lpwndpl->ptMaxPosition.x = Wnd->InternalPos.MaxPos.x;
591  lpwndpl->ptMaxPosition.y = Wnd->InternalPos.MaxPos.y;
592  }
593  else
594  lpwndpl->ptMaxPosition.x = lpwndpl->ptMaxPosition.y = -1;
595 
596  if ( Wnd->spwndParent == Wnd->head.rpdesk->pDeskInfo->spwnd &&
597  !(Wnd->ExStyle & WS_EX_TOOLWINDOW))
598  {
599  PMONITOR pmonitor = UserMonitorFromRect(&lpwndpl->rcNormalPosition, MONITOR_DEFAULTTOPRIMARY );
600 
601  // FIXME: support DPI aware, rcWorkDPI/Real etc..
602  if (Wnd->InternalPos.flags & WPF_MININIT)
603  {
604  lpwndpl->ptMinPosition.x -= (pmonitor->rcWork.left - pmonitor->rcMonitor.left);
605  lpwndpl->ptMinPosition.y -= (pmonitor->rcWork.top - pmonitor->rcMonitor.top);
606  }
608  pmonitor->rcMonitor.left - pmonitor->rcWork.left,
609  pmonitor->rcMonitor.top - pmonitor->rcWork.top);
610  }
611 
612  if ( Wnd->InternalPos.flags & WPF_RESTORETOMAXIMIZED || Wnd->style & WS_MAXIMIZE )
613  lpwndpl->flags |= WPF_RESTORETOMAXIMIZED;
614 
615  if ( ((Wnd->style & (WS_CHILD|WS_POPUP)) == WS_CHILD) && Wnd->InternalPos.flags & WPF_SETMINPOSITION)
616  lpwndpl->flags |= WPF_SETMINPOSITION;
617 
618  return TRUE;
619 }
620 
621 /* make sure the specified rect is visible on screen */
622 static void make_rect_onscreen( RECT *rect )
623 {
624  PMONITOR pmonitor = UserMonitorFromRect( rect, MONITOR_DEFAULTTONEAREST ); // Wine uses this.
625 
626  // FIXME: support DPI aware, rcWorkDPI/Real etc..
627  if (!pmonitor) return;
628  /* FIXME: map coordinates from rcWork to rcMonitor */
629  if (rect->right <= pmonitor->rcWork.left)
630  {
631  rect->right += pmonitor->rcWork.left - rect->left;
632  rect->left = pmonitor->rcWork.left;
633  }
634  else if (rect->left >= pmonitor->rcWork.right)
635  {
636  rect->left += pmonitor->rcWork.right - rect->right;
637  rect->right = pmonitor->rcWork.right;
638  }
639  if (rect->bottom <= pmonitor->rcWork.top)
640  {
641  rect->bottom += pmonitor->rcWork.top - rect->top;
642  rect->top = pmonitor->rcWork.top;
643  }
644  else if (rect->top >= pmonitor->rcWork.bottom)
645  {
646  rect->top += pmonitor->rcWork.bottom - rect->bottom;
647  rect->bottom = pmonitor->rcWork.bottom;
648  }
649 }
650 
651 /* make sure the specified point is visible on screen */
652 static void make_point_onscreen( POINT *pt )
653 {
654  RECT rect;
655 
656  RECTL_vSetRect( &rect, pt->x, pt->y, pt->x + 1, pt->y + 1 );
658  pt->x = rect.left;
659  pt->y = rect.top;
660 }
661 
664 {
665  BOOL sAsync;
666  UINT SWP_Flags;
667 
671 
672  if (!Wnd || Wnd == Wnd->head.rpdesk->pDeskInfo->spwnd) return FALSE;
673 
674  if ( Flags & PLACE_MIN ) Wnd->InternalPos.IconPos = wpl->ptMinPosition;
675  if ( Flags & PLACE_MAX ) Wnd->InternalPos.MaxPos = wpl->ptMaxPosition;
676  if ( Flags & PLACE_RECT) Wnd->InternalPos.NormalRect = wpl->rcNormalPosition;
677 
678  SWP_Flags = SWP_NOZORDER | SWP_NOACTIVATE | ((wpl->flags & WPF_ASYNCWINDOWPLACEMENT) ? SWP_ASYNCWINDOWPOS : 0);
679 
680  if (Wnd->style & WS_MINIMIZE )
681  {
682  if (Flags & PLACE_MIN || Wnd->InternalPos.flags & WPF_SETMINPOSITION)
683  {
685  wpl->ptMinPosition.x, wpl->ptMinPosition.y, 0, 0,
686  SWP_NOSIZE | SWP_Flags);
687  Wnd->InternalPos.flags |= WPF_MININIT;
688  }
689  }
690  else if (Wnd->style & WS_MAXIMIZE )
691  {
692  if (Flags & PLACE_MAX)
693  {
695  wpl->ptMaxPosition.x, wpl->ptMaxPosition.y, 0, 0,
696  SWP_NOSIZE | SWP_Flags);
697  Wnd->InternalPos.flags |= WPF_MAXINIT;
698  }
699  }
700  else if (Flags & PLACE_RECT)
701  {
706  SWP_Flags);
707  }
708 
709  sAsync = (Wnd->head.pti->MessageQueue != gptiCurrent->MessageQueue && wpl->flags & WPF_ASYNCWINDOWPLACEMENT);
710 
711  if ( sAsync )
713  else
714  co_WinPosShowWindow(Wnd, wpl->showCmd);
715 
716  if ( Wnd->style & WS_MINIMIZE && !sAsync )
717  {
718  if ( wpl->flags & WPF_SETMINPOSITION )
719  Wnd->InternalPos.flags |= WPF_SETMINPOSITION;
720 
721  if ( wpl->flags & WPF_RESTORETOMAXIMIZED )
722  Wnd->InternalPos.flags |= WPF_RESTORETOMAXIMIZED;
723  }
724  return TRUE;
725 }
726 
727 UINT
728 FASTCALL
730 {
731  RECTL rectParent;
732  PWND Child;
733  INT x, y, xspacing, yspacing, sx, sy;
734 
736 
737  IntGetClientRect( parent, &rectParent );
738  // FIXME: Support Minimize Metrics gspv.mm.iArrange.
739  // Default: ARW_BOTTOMLEFT
740  x = rectParent.left;
741  y = rectParent.bottom;
742 
745 
746  Child = parent->spwndChild;
747  while(Child)
748  {
749  if((Child->style & WS_MINIMIZE) != 0 )
750  {
752  UserRefObjectCo(Child, &Ref);
753 
755  sy = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
756 
757  Child->InternalPos.IconPos.x = sx;
758  Child->InternalPos.IconPos.y = sy;
759  Child->InternalPos.flags |= WPF_MININIT;
760 
762 
764 
765  if (x <= rectParent.right - xspacing)
766  x += xspacing;
767  else
768  {
769  x = rectParent.left;
770  y -= yspacing;
771  }
772  }
773  Child = Child->spwndNext;
774  }
775  return yspacing;
776 }
777 
778 static VOID FASTCALL
780 {
781  RECT rectParent;
782  PWND pwndChild, pwndParent;
783  int x, y, xspacing, yspacing;
784 
785  pwndParent = Window->spwndParent;
786  if (UserIsDesktopWindow(pwndParent))
787  {
788  ERR("FIXME: Parent is Desktop, Min off screen!\n");
789  /* FIXME: ReactOS doesn't support iconic minimize to desktop */
790  Pos->x = Pos->y = -32000;
791  Window->InternalPos.flags |= WPF_MININIT;
792  Window->InternalPos.IconPos.x = Pos->x;
793  Window->InternalPos.IconPos.y = Pos->y;
794  return;
795  }
796 
797  IntGetClientRect( pwndParent, &rectParent );
798  // FIXME: Support Minimize Metrics gspv.mm.iArrange.
799  // Default: ARW_BOTTOMLEFT
800  x = rectParent.left;
801  y = rectParent.bottom;
802 
805 
806  // Set to default position when minimized.
808  Pos->y = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
809 
810  for (pwndChild = pwndParent->spwndChild; pwndChild; pwndChild = pwndChild->spwndNext)
811  {
812  if (pwndChild == Window) continue;
813 
814  if ((pwndChild->style & (WS_VISIBLE|WS_MINIMIZE)) != (WS_VISIBLE|WS_MINIMIZE) )
815  {
816  continue;
817  }
818 
819  if ( pwndChild->InternalPos.IconPos.x != Pos->x && pwndChild->InternalPos.IconPos.y != Pos->y )
820  {
821  break;
822  }
823  if (x <= rectParent.right - xspacing)
824  x += xspacing;
825  else
826  {
827  x = rectParent.left;
828  y -= yspacing;
829  }
831  Pos->y = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
832  }
833 
834  Window->InternalPos.IconPos.x = Pos->x;
835  Window->InternalPos.IconPos.y = Pos->y;
836  Window->InternalPos.flags |= WPF_MININIT;
837  TRACE("Position is set! X:%d Y:%d\n",Pos->x,Pos->y);
838  return;
839 }
840 
841 BOOL
843 {
844  if (Style & WS_MINIMIZE)
845  return TRUE;
847  return TRUE;
849  return FALSE;
850  if (Style & WS_THICKFRAME)
851  return TRUE;
852  Style &= WS_CAPTION;
853  if (Style == WS_DLGFRAME || Style == WS_CAPTION)
854  return TRUE;
855  return FALSE;
856 }
857 
860 {
861  if(HAS_DLGFRAME(Wnd->style, Wnd->ExStyle) && !(Wnd->style & WS_MINIMIZE))
862  {
865  }
866  else
867  {
868  if(HAS_THICKFRAME(Wnd->style, Wnd->ExStyle)&& !(Wnd->style & WS_MINIMIZE))
869  {
872  }
873  else if(HAS_THINFRAME(Wnd->style, Wnd->ExStyle))
874  {
877  }
878  else
879  {
880  *cx = *cy = 0;
881  }
882  }
883 }
884 
885 VOID
887 {
888  DWORD Border = 0;
889 
891  Border += 2;
893  Border += 1; /* for the outer frame always present */
894  if ((ExStyle & WS_EX_CLIENTEDGE) && WithClient)
895  Border += 2;
897  Border ++; /* The other border */
898  Size->cx = Size->cy = Border;
899  if ((Style & WS_THICKFRAME) && !(Style & WS_MINIMIZE)) /* The resize border */
900  {
903  }
906 }
907 
908 //
909 // Fix CORE-5177
910 // See winetests:user32:win.c:wine_AdjustWindowRectEx,
911 // Simplified version.
912 //
914 {
915  DWORD adjust = 0;
916 
917  if ( ExStyle & WS_EX_WINDOWEDGE ) // 1st
918  adjust = 2; /* outer */
919  else if ( ExStyle & WS_EX_STATICEDGE ) // 2nd
920  adjust = 1; /* for the outer frame always present */
921 
923  adjust += 2;
924 
926  adjust++; /* The other border */
927 
928  return adjust;
929 }
930 
933  POINT* MinTrack, POINT* MaxTrack)
934 {
935  MINMAXINFO MinMax;
936  PMONITOR monitor;
937  INT xinc, yinc;
938  LONG style = Window->style;
939  LONG adjustedStyle;
940  LONG exstyle = Window->ExStyle;
941  RECT rc;
942  DWORD adjust;
943 
945 
946  /* Compute default values */
947 
948  rc = Window->rcWindow;
949  MinMax.ptReserved.x = rc.left;
950  MinMax.ptReserved.y = rc.top;
951 
952  if ((style & WS_CAPTION) == WS_CAPTION)
953  adjustedStyle = style & ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
954  else
955  adjustedStyle = style;
956 
957  if (Window->spwndParent)
958  IntGetClientRect(Window->spwndParent, &rc);
959 
960  adjust = IntGetWindowBorders(adjustedStyle, exstyle);
961 
962  // Handle special case while maximized. CORE-15893
963  if ((adjustedStyle & WS_THICKFRAME) && !(adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
964  adjust += 1;
965 
966  xinc = yinc = adjust;
967 
968  if ((adjustedStyle & WS_THICKFRAME) && (adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
969  {
972  }
973 
974  RECTL_vInflateRect( &rc,
977 
978  xinc = -rc.left;
979  yinc = -rc.top;
980 
981  MinMax.ptMaxSize.x = rc.right - rc.left;
982  MinMax.ptMaxSize.y = rc.bottom - rc.top;
983  if (style & (WS_DLGFRAME | WS_BORDER))
984  {
987  }
988  else
989  {
990  MinMax.ptMinTrackSize.x = 2 * xinc;
991  MinMax.ptMinTrackSize.y = 2 * yinc;
992  }
995  MinMax.ptMaxPosition.x = -xinc;
996  MinMax.ptMaxPosition.y = -yinc;
997 
998  if (!EMPTYPOINT(Window->InternalPos.MaxPos)) MinMax.ptMaxPosition = Window->InternalPos.MaxPos;
999 
1000  co_IntSendMessage(Window->head.h, WM_GETMINMAXINFO, 0, (LPARAM)&MinMax);
1001 
1002  /* if the app didn't change the values, adapt them for the current monitor */
1003  if ((monitor = UserGetPrimaryMonitor()))
1004  {
1005  RECT rc_work;
1006 
1007  rc_work = monitor->rcMonitor;
1008 
1009  if (style & WS_MAXIMIZEBOX)
1010  {
1011  if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP)))
1012  rc_work = monitor->rcWork;
1013  }
1014 
1015  if (MinMax.ptMaxSize.x == UserGetSystemMetrics(SM_CXSCREEN) + 2 * xinc &&
1016  MinMax.ptMaxSize.y == UserGetSystemMetrics(SM_CYSCREEN) + 2 * yinc)
1017  {
1018  MinMax.ptMaxSize.x = (rc_work.right - rc_work.left) + 2 * xinc;
1019  MinMax.ptMaxSize.y = (rc_work.bottom - rc_work.top) + 2 * yinc;
1020  }
1021  if (MinMax.ptMaxPosition.x == -xinc && MinMax.ptMaxPosition.y == -yinc)
1022  {
1023  MinMax.ptMaxPosition.x = rc_work.left - xinc;
1024  MinMax.ptMaxPosition.y = rc_work.top - yinc;
1025  }
1026  if (MinMax.ptMaxSize.x >= (monitor->rcMonitor.right - monitor->rcMonitor.left) &&
1027  MinMax.ptMaxSize.y >= (monitor->rcMonitor.bottom - monitor->rcMonitor.top) )
1028  {
1029  Window->state |= WNDS_MAXIMIZESTOMONITOR;
1030  }
1031  else
1032  Window->state &= ~WNDS_MAXIMIZESTOMONITOR;
1033  }
1034 
1035 
1036  MinMax.ptMaxTrackSize.x = max(MinMax.ptMaxTrackSize.x,
1037  MinMax.ptMinTrackSize.x);
1038  MinMax.ptMaxTrackSize.y = max(MinMax.ptMaxTrackSize.y,
1039  MinMax.ptMinTrackSize.y);
1040 
1041  if (MaxSize)
1042  *MaxSize = MinMax.ptMaxSize;
1043  if (MaxPos)
1044  *MaxPos = MinMax.ptMaxPosition;
1045  if (MinTrack)
1046  *MinTrack = MinMax.ptMinTrackSize;
1047  if (MaxTrack)
1048  *MaxTrack = MinMax.ptMaxTrackSize;
1049 
1050  return 0; // FIXME: What does it return? Wine returns MINMAXINFO.
1051 }
1052 
1053 static
1054 BOOL
1056 {
1057  PWND ParentWnd = Child->spwndParent;
1058 
1059  while (ParentWnd)
1060  {
1061  if (ParentWnd->style & WS_CLIPCHILDREN)
1062  break;
1063 
1064  if (ParentWnd->hrgnUpdate != 0)
1065  {
1066  IntInvalidateWindows( ParentWnd,
1067  ValidateRgn,
1069  }
1070 
1071  ParentWnd = ParentWnd->spwndParent;
1072  }
1073 
1074  return TRUE;
1075 }
1076 
1077 static
1078 VOID FASTCALL
1079 FixClientRect(PRECTL ClientRect, PRECTL WindowRect)
1080 {
1081  if (ClientRect->left < WindowRect->left)
1082  {
1083  ClientRect->left = WindowRect->left;
1084  }
1085  else if (WindowRect->right < ClientRect->left)
1086  {
1087  ClientRect->left = WindowRect->right;
1088  }
1089  if (ClientRect->right < WindowRect->left)
1090  {
1091  ClientRect->right = WindowRect->left;
1092  }
1093  else if (WindowRect->right < ClientRect->right)
1094  {
1095  ClientRect->right = WindowRect->right;
1096  }
1097  if (ClientRect->top < WindowRect->top)
1098  {
1099  ClientRect->top = WindowRect->top;
1100  }
1101  else if (WindowRect->bottom < ClientRect->top)
1102  {
1103  ClientRect->top = WindowRect->bottom;
1104  }
1105  if (ClientRect->bottom < WindowRect->top)
1106  {
1107  ClientRect->bottom = WindowRect->top;
1108  }
1109  else if (WindowRect->bottom < ClientRect->bottom)
1110  {
1111  ClientRect->bottom = WindowRect->bottom;
1112  }
1113 }
1114 /***********************************************************************
1115  * get_valid_rects
1116  *
1117  * Compute the valid rects from the old and new client rect and WVR_* flags.
1118  * Helper for WM_NCCALCSIZE handling.
1119  */
1120 static
1121 VOID FASTCALL
1122 get_valid_rects( RECTL *old_client, RECTL *new_client, UINT flags, RECTL *valid )
1123 {
1124  int cx, cy;
1125 
1126  if (flags & WVR_REDRAW)
1127  {
1128  RECTL_vSetEmptyRect( &valid[0] );
1129  RECTL_vSetEmptyRect( &valid[1] );
1130  return;
1131  }
1132 
1133  if (flags & WVR_VALIDRECTS)
1134  {
1135  if (!RECTL_bIntersectRect( &valid[0], &valid[0], new_client ) ||
1136  !RECTL_bIntersectRect( &valid[1], &valid[1], old_client ))
1137  {
1138  RECTL_vSetEmptyRect( &valid[0] );
1139  RECTL_vSetEmptyRect( &valid[1] );
1140  return;
1141  }
1143  }
1144  else
1145  {
1146  valid[0] = *new_client;
1147  valid[1] = *old_client;
1148  }
1149 
1150  /* make sure the rectangles have the same size */
1151  cx = min( valid[0].right - valid[0].left, valid[1].right - valid[1].left );
1152  cy = min( valid[0].bottom - valid[0].top, valid[1].bottom - valid[1].top );
1153 
1154  if (flags & WVR_ALIGNBOTTOM)
1155  {
1156  valid[0].top = valid[0].bottom - cy;
1157  valid[1].top = valid[1].bottom - cy;
1158  }
1159  else
1160  {
1161  valid[0].bottom = valid[0].top + cy;
1162  valid[1].bottom = valid[1].top + cy;
1163  }
1164  if (flags & WVR_ALIGNRIGHT)
1165  {
1166  valid[0].left = valid[0].right - cx;
1167  valid[1].left = valid[1].right - cx;
1168  }
1169  else
1170  {
1171  valid[0].right = valid[0].left + cx;
1172  valid[1].right = valid[1].left + cx;
1173  }
1174 }
1175 
1176 static
1177 LONG FASTCALL
1178 co_WinPosDoNCCALCSize(PWND Window, PWINDOWPOS WinPos, RECTL* WindowRect, RECTL* ClientRect, RECTL* validRects)
1179 {
1180  PWND Parent;
1181  UINT wvrFlags = 0;
1182 
1184 
1185  /* Send WM_NCCALCSIZE message to get new client area */
1186  if ((WinPos->flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE)
1187  {
1189  WINDOWPOS winposCopy;
1190 
1191  params.rgrc[0] = *WindowRect; // new coordinates of a window that has been moved or resized
1192  params.rgrc[1] = Window->rcWindow; // window before it was moved or resized
1193  params.rgrc[2] = Window->rcClient; // client area before the window was moved or resized
1194 
1195  Parent = Window->spwndParent;
1196  if (0 != (Window->style & WS_CHILD) && Parent)
1197  {
1198  RECTL_vOffsetRect(&(params.rgrc[0]), - Parent->rcClient.left, - Parent->rcClient.top);
1199  RECTL_vOffsetRect(&(params.rgrc[1]), - Parent->rcClient.left, - Parent->rcClient.top);
1200  RECTL_vOffsetRect(&(params.rgrc[2]), - Parent->rcClient.left, - Parent->rcClient.top);
1201  }
1202 
1203  params.lppos = &winposCopy;
1204  winposCopy = *WinPos;
1205 
1206  wvrFlags = co_IntSendMessage(Window->head.h, WM_NCCALCSIZE, TRUE, (LPARAM) &params);
1207 
1208  /* If the application send back garbage, ignore it */
1209  if (params.rgrc[0].left <= params.rgrc[0].right &&
1210  params.rgrc[0].top <= params.rgrc[0].bottom)
1211  {
1212  *ClientRect = params.rgrc[0]; // First rectangle contains the coordinates of the new client rectangle resulting from the move or resize
1213  if ((Window->style & WS_CHILD) && Parent)
1214  {
1215  RECTL_vOffsetRect(ClientRect, Parent->rcClient.left, Parent->rcClient.top);
1216  }
1217  FixClientRect(ClientRect, WindowRect);
1218  }
1219 
1220  if (ClientRect->left != Window->rcClient.left ||
1221  ClientRect->top != Window->rcClient.top)
1222  {
1223  WinPos->flags &= ~SWP_NOCLIENTMOVE;
1224  }
1225 
1226  if (ClientRect->right - ClientRect->left != Window->rcClient.right - Window->rcClient.left)
1227  {
1228  WinPos->flags &= ~SWP_NOCLIENTSIZE;
1229  }
1230  else
1231  wvrFlags &= ~WVR_HREDRAW;
1232 
1233  if (ClientRect->bottom - ClientRect->top != Window->rcClient.bottom - Window->rcClient.top)
1234  {
1235  WinPos->flags &= ~SWP_NOCLIENTSIZE;
1236  }
1237  else
1238  wvrFlags &= ~WVR_VREDRAW;
1239 
1240  validRects[0] = params.rgrc[1]; // second rectangle contains the valid destination rectangle
1241  validRects[1] = params.rgrc[2]; // third rectangle contains the valid source rectangle
1242  }
1243  else
1244  {
1245  if (!(WinPos->flags & SWP_NOMOVE) &&
1246  (ClientRect->left != Window->rcClient.left ||
1247  ClientRect->top != Window->rcClient.top))
1248  {
1249  WinPos->flags &= ~SWP_NOCLIENTMOVE;
1250  }
1251  }
1252 
1254  {
1255  RECTL_vSetEmptyRect( &validRects[0] );
1256  RECTL_vSetEmptyRect( &validRects[1] );
1257  }
1258  else get_valid_rects( &Window->rcClient, ClientRect, wvrFlags, validRects );
1259 
1260  return wvrFlags;
1261 }
1262 
1263 static
1264 BOOL FASTCALL
1266  PWINDOWPOS WinPos,
1267  PRECTL WindowRect,
1268  PRECTL ClientRect)
1269 {
1271 
1272  /* Send WM_WINDOWPOSCHANGING message */
1273 
1274  if (!(WinPos->flags & SWP_NOSENDCHANGING)
1275  && !((WinPos->flags & SWP_AGG_NOCLIENTCHANGE) && (WinPos->flags & SWP_SHOWWINDOW)))
1276  {
1277  TRACE("Sending WM_WINDOWPOSCHANGING to hwnd %p flags %04x.\n", Window->head.h,WinPos->flags);
1278  co_IntSendMessage(Window->head.h, WM_WINDOWPOSCHANGING, 0, (LPARAM) WinPos);
1279  }
1280 
1281  /* Calculate new position and size */
1282 
1283  *WindowRect = Window->rcWindow;
1284  *ClientRect = (Window->style & WS_MINIMIZE) ? Window->rcWindow : Window->rcClient;
1285 
1286  if (!(WinPos->flags & SWP_NOSIZE))
1287  {
1288  if (Window->style & WS_MINIMIZE)
1289  {
1290  WindowRect->right = WindowRect->left + UserGetSystemMetrics(SM_CXMINIMIZED);
1291  WindowRect->bottom = WindowRect->top + UserGetSystemMetrics(SM_CYMINIMIZED);
1292  }
1293  else
1294  {
1295  WindowRect->right = WindowRect->left + WinPos->cx;
1296  WindowRect->bottom = WindowRect->top + WinPos->cy;
1297  }
1298  }
1299 
1300  if (!(WinPos->flags & SWP_NOMOVE))
1301  {
1302  INT X, Y;
1303  PWND Parent;
1304  X = WinPos->x;
1305  Y = WinPos->y;
1306 
1307  Parent = Window->spwndParent;
1308 
1309  // Parent child position issue is in here. SetParent_W7 test CORE-6651.
1310  if (//((Window->style & WS_CHILD) != 0) && <- Fixes wine msg test_SetParent: "rects do not match", the last test.
1311  Parent &&
1312  Parent != Window->head.rpdesk->pDeskInfo->spwnd)
1313  {
1314  TRACE("Not SWP_NOMOVE 1 Parent client offset X %d Y %d\n",X,Y);
1315  X += Parent->rcClient.left;
1316  Y += Parent->rcClient.top;
1317  TRACE("Not SWP_NOMOVE 2 Parent client offset X %d Y %d\n",X,Y);
1318  }
1319 
1320  WindowRect->left = X;
1321  WindowRect->top = Y;
1322  WindowRect->right += X - Window->rcWindow.left;
1323  WindowRect->bottom += Y - Window->rcWindow.top;
1324 
1325  RECTL_vOffsetRect(ClientRect, X - Window->rcWindow.left,
1326  Y - Window->rcWindow.top);
1327  }
1329 
1330  TRACE( "hwnd %p, after %p, swp %d,%d %dx%d flags %08x\n",
1331  WinPos->hwnd, WinPos->hwndInsertAfter, WinPos->x, WinPos->y,
1332  WinPos->cx, WinPos->cy, WinPos->flags );
1333  TRACE("WindowRect: %d %d %d %d\n", WindowRect->left,WindowRect->top,WindowRect->right,WindowRect->bottom);
1334  TRACE("ClientRect: %d %d %d %d\n", ClientRect->left,ClientRect->top,ClientRect->right,ClientRect->bottom);
1335 
1336  return TRUE;
1337 }
1338 
1339 /*
1340  * Fix Z order taking into account owned popups -
1341  * basically we need to maintain them above the window that owns them
1342  *
1343  * FIXME: hide/show owned popups when owner visibility changes.
1344  *
1345  * ReactOS: See bug CORE-6129 and CORE-6554.
1346  *
1347  */
1349  // Pass all the win:test_children/popup_zorder tests except "move hwnd_F and its popups down" which is if'ed out.
1350  // Side effect, breaks more of the DeferWindowPos api tests, but wine breaks more!!!!
1351 static
1352 HWND FASTCALL
1354 {
1355  HWND *List = NULL;
1356  HWND Owner;
1357  LONG Style;
1358  PWND DesktopWindow, ChildObject;
1359  int i;
1360 
1361  TRACE("(%p) hInsertAfter = %p\n", Window, hWndInsertAfter );
1362 
1363  Style = Window->style;
1364 
1365  if (Style & WS_CHILD)
1366  {
1367  TRACE("Window is child\n");
1368  return hWndInsertAfter;
1369  }
1370 
1371  Owner = Window->spwndOwner ? Window->spwndOwner->head.h : NULL;
1372 
1373  if (Owner)
1374  {
1375  /* Make sure this popup stays above the owner */
1376 
1377  if (hWndInsertAfter != HWND_TOPMOST)
1378  {
1381 
1382  if (List != NULL)
1383  {
1384  for (i = 0; List[i]; i++)
1385  {
1386  BOOL topmost = FALSE;
1387 
1388  ChildObject = ValidateHwndNoErr(List[i]);
1389  if (ChildObject)
1390  {
1391  topmost = (ChildObject->ExStyle & WS_EX_TOPMOST) != 0;
1392  }
1393 
1394  if (List[i] == Owner)
1395  {
1396  if (i > 0) hWndInsertAfter = List[i-1];
1397  else hWndInsertAfter = topmost ? HWND_TOPMOST : HWND_TOP;
1398  break;
1399  }
1400 
1401  if (hWndInsertAfter == HWND_TOP || hWndInsertAfter == HWND_NOTOPMOST)
1402  {
1403  if (!topmost) break;
1404  }
1405  else if (List[i] == hWndInsertAfter) break;
1406  }
1407  }
1408  else
1409  return hWndInsertAfter;
1410  }
1411  }
1412 
1413  if (hWndInsertAfter == HWND_BOTTOM)
1414  {
1415  ERR("Window is HWND_BOTTOM hwnd %p\n",hWndInsertAfter);
1417  goto done;
1418  }
1419 
1420  if (!List)
1421  {
1424  }
1425 
1426  if (List != NULL)
1427  {
1428  i = 0;
1429 
1430  if (hWndInsertAfter == HWND_TOP || hWndInsertAfter == HWND_NOTOPMOST)
1431  {
1432  if (hWndInsertAfter == HWND_NOTOPMOST || !(Window->ExStyle & WS_EX_TOPMOST))
1433  {
1434  TRACE("skip all the topmost windows\n");
1435  /* skip all the topmost windows */
1436  while (List[i] &&
1437  (ChildObject = ValidateHwndNoErr(List[i])) &&
1438  (ChildObject->ExStyle & WS_EX_TOPMOST)) i++;
1439  }
1440  }
1441  else if (hWndInsertAfter != HWND_TOPMOST)
1442  {
1443  /* skip windows that are already placed correctly */
1444  for (i = 0; List[i]; i++)
1445  {
1446  if (List[i] == hWndInsertAfter) break;
1447  if (List[i] == UserHMGetHandle(Window))
1448  {
1450  goto done; /* nothing to do if window is moving backwards in z-order */
1451  }
1452  }
1453  }
1454 
1455  for (; List[i]; i++)
1456  {
1457  PWND Wnd;
1459 
1460  if (List[i] == UserHMGetHandle(Window))
1461  break;
1462 
1463  if (!(Wnd = ValidateHwndNoErr(List[i])))
1464  continue;
1465 
1466  Owner = Wnd->spwndOwner ? Wnd->spwndOwner->head.h : NULL;
1467 
1468  if (Owner != UserHMGetHandle(Window)) continue;
1469 
1470  UserRefObjectCo(Wnd, &Ref);
1471  TRACE( "moving %p owned by %p after %p\n", List[i], UserHMGetHandle(Window), hWndInsertAfter );
1472  co_WinPosSetWindowPos(Wnd, hWndInsertAfter, 0, 0, 0, 0,
1474 
1475  UserDerefObjectCo(Wnd);
1476  hWndInsertAfter = List[i];
1477  }
1479  }
1480 done:
1481  return hWndInsertAfter;
1482 }
1484 
1485 /***********************************************************************
1486  * WinPosInternalMoveWindow
1487  *
1488  * Update WindowRect and ClientRect of Window and all of its children
1489  * We keep both WindowRect and ClientRect in screen coordinates internally
1490  */
1491 static
1492 VOID FASTCALL
1494 {
1495  PWND Child;
1496 
1497  ASSERT(Window != Window->spwndChild);
1498  TRACE("InternalMoveWin X %d Y %d\n", MoveX, MoveY);
1499 
1500  Window->rcWindow.left += MoveX;
1501  Window->rcWindow.right += MoveX;
1502  Window->rcWindow.top += MoveY;
1503  Window->rcWindow.bottom += MoveY;
1504 
1505  Window->rcClient.left += MoveX;
1506  Window->rcClient.right += MoveX;
1507  Window->rcClient.top += MoveY;
1508  Window->rcClient.bottom += MoveY;
1509 
1510  for(Child = Window->spwndChild; Child; Child = Child->spwndNext)
1511  {
1512  WinPosInternalMoveWindow(Child, MoveX, MoveY);
1513  }
1514 }
1515 
1516 /*
1517  * WinPosFixupSWPFlags
1518  *
1519  * Fix redundant flags and values in the WINDOWPOS structure.
1520  */
1521 static
1522 BOOL FASTCALL
1524 {
1525  PWND Parent;
1526  POINT pt;
1527 
1528  /* Finally make sure that all coordinates are valid */
1529  if (WinPos->x < -32768) WinPos->x = -32768;
1530  else if (WinPos->x > 32767) WinPos->x = 32767;
1531  if (WinPos->y < -32768) WinPos->y = -32768;
1532  else if (WinPos->y > 32767) WinPos->y = 32767;
1533 
1534  WinPos->cx = max(WinPos->cx, 0);
1535  WinPos->cy = max(WinPos->cy, 0);
1536 
1537  Parent = UserGetAncestor( Wnd, GA_PARENT );
1538  if (!IntIsWindowVisible( Parent ) &&
1539  /* Fix B : wine msg test_SetParent:WmSetParentSeq_2:25 wParam bits! */
1540  (WinPos->flags & SWP_AGG_STATUSFLAGS) == SWP_AGG_NOPOSCHANGE) WinPos->flags |= SWP_NOREDRAW;
1541 
1542  if (Wnd->style & WS_VISIBLE) WinPos->flags &= ~SWP_SHOWWINDOW;
1543  else
1544  {
1545  WinPos->flags &= ~SWP_HIDEWINDOW;
1546  if (!(WinPos->flags & SWP_SHOWWINDOW)) WinPos->flags |= SWP_NOREDRAW;
1547  }
1548 
1549  /* Check for right size */
1550  if (Wnd->rcWindow.right - Wnd->rcWindow.left == WinPos->cx &&
1551  Wnd->rcWindow.bottom - Wnd->rcWindow.top == WinPos->cy)
1552  {
1553  WinPos->flags |= SWP_NOSIZE;
1554  }
1555 
1556  pt.x = WinPos->x;
1557  pt.y = WinPos->y;
1559  TRACE("WPFU C2S wpx %d wpy %d ptx %d pty %d\n",WinPos->x,WinPos->y,pt.x,pt.y);
1560  /* Check for right position */
1561  if (Wnd->rcWindow.left == pt.x && Wnd->rcWindow.top == pt.y)
1562  {
1563  //ERR("In right pos\n");
1564  WinPos->flags |= SWP_NOMOVE;
1565  }
1566 
1567  if ( WinPos->hwnd != UserGetForegroundWindow() && (Wnd->style & (WS_POPUP | WS_CHILD)) != WS_CHILD)
1568  {
1569  /* Bring to the top when activating */
1570  if (!(WinPos->flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)) &&
1571  (WinPos->flags & SWP_NOZORDER ||
1572  (WinPos->hwndInsertAfter != HWND_TOPMOST && WinPos->hwndInsertAfter != HWND_NOTOPMOST)))
1573  {
1574  WinPos->flags &= ~SWP_NOZORDER;
1575  WinPos->hwndInsertAfter = (0 != (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOPMOST : HWND_TOP);
1576  }
1577  }
1578 
1579  /* Check hwndInsertAfter */
1580  if (!(WinPos->flags & SWP_NOZORDER))
1581  {
1582  /* Fix sign extension */
1583  if (WinPos->hwndInsertAfter == (HWND)0xffff)
1584  {
1585  WinPos->hwndInsertAfter = HWND_TOPMOST;
1586  }
1587  else if (WinPos->hwndInsertAfter == (HWND)0xfffe)
1588  {
1589  WinPos->hwndInsertAfter = HWND_NOTOPMOST;
1590  }
1591 
1592  if (WinPos->hwndInsertAfter == HWND_TOP)
1593  {
1594  /* Keep it topmost when it's already topmost */
1595  if ((Wnd->ExStyle & WS_EX_TOPMOST) != 0)
1596  WinPos->hwndInsertAfter = HWND_TOPMOST;
1597 
1598  if (IntGetWindow(WinPos->hwnd, GW_HWNDFIRST) == WinPos->hwnd)
1599  {
1600  WinPos->flags |= SWP_NOZORDER;
1601  }
1602  }
1603  else if (WinPos->hwndInsertAfter == HWND_BOTTOM)
1604  {
1605  if (!(Wnd->ExStyle & WS_EX_TOPMOST) && IntGetWindow(WinPos->hwnd, GW_HWNDLAST) == WinPos->hwnd)
1606  WinPos->flags |= SWP_NOZORDER;
1607  }
1608  else if (WinPos->hwndInsertAfter == HWND_TOPMOST)
1609  {
1610  if ((Wnd->ExStyle & WS_EX_TOPMOST) && IntGetWindow(WinPos->hwnd, GW_HWNDFIRST) == WinPos->hwnd)
1611  WinPos->flags |= SWP_NOZORDER;
1612  }
1613  else if (WinPos->hwndInsertAfter == HWND_NOTOPMOST)
1614  {
1615  if (!(Wnd->ExStyle & WS_EX_TOPMOST))
1616  WinPos->flags |= SWP_NOZORDER;
1617  }
1618  else /* hwndInsertAfter must be a sibling of the window */
1619  {
1620  PWND InsAfterWnd;
1621 
1622  InsAfterWnd = ValidateHwndNoErr(WinPos->hwndInsertAfter);
1623  if(!InsAfterWnd)
1624  {
1625  return TRUE;
1626  }
1627 
1628  if (InsAfterWnd->spwndParent != Wnd->spwndParent)
1629  {
1630  /* Note from wine User32 Win test_SetWindowPos:
1631  "Returns TRUE also for windows that are not siblings"
1632  "Does not seem to do anything even without passing flags, still returns TRUE"
1633  "Same thing the other way around."
1634  ".. and with these windows."
1635  */
1636  return FALSE;
1637  }
1638  else
1639  {
1640  /*
1641  * We don't need to change the Z order of hwnd if it's already
1642  * inserted after hwndInsertAfter or when inserting hwnd after
1643  * itself.
1644  */
1645  if ((WinPos->hwnd == WinPos->hwndInsertAfter) ||
1646  ((InsAfterWnd->spwndNext) && (WinPos->hwnd == InsAfterWnd->spwndNext->head.h)))
1647  {
1648  WinPos->flags |= SWP_NOZORDER;
1649  }
1650  }
1651  }
1652  }
1653 
1654  return TRUE;
1655 }
1656 
1657 //
1658 // This is a NC HACK fix for forcing painting of non client areas.
1659 // Further troubleshooting in painting.c is required to remove this hack.
1660 // See CORE-7166 & CORE-15934
1661 //
1662 VOID
1664 {
1665  HDC hDC;
1666  PREGION RgnUpdate;
1667  UINT RgnType;
1668  BOOL Create = FALSE;
1669 
1670  if (Wnd->hrgnUpdate == NULL)
1671  {
1672  Wnd->hrgnUpdate = NtGdiCreateRectRgn(0, 0, 0, 0);
1674  Create = TRUE;
1675  }
1676 
1677  if (Wnd->hrgnUpdate != HRGN_WINDOW)
1678  {
1679  RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
1680  if (RgnUpdate)
1681  {
1682  RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, pRgn, RGN_OR);
1683  REGION_UnlockRgn(RgnUpdate);
1684  if (RgnType == NULLREGION)
1685  {
1688  Wnd->hrgnUpdate = NULL;
1689  Create = FALSE;
1690  }
1691  }
1692  }
1693 
1694  IntSendNCPaint( Wnd, hRgn ); // Region can be deleted by the application.
1695 
1696  if (Wnd->hrgnUpdate)
1697  {
1698  hDC = UserGetDCEx( Wnd,
1699  Wnd->hrgnUpdate,
1701 
1703  // Kill the loop, so Clear before we send.
1705  {
1707  }
1708  UserReleaseDC(Wnd, hDC, FALSE);
1709  }
1710 
1711  if (Create)
1712  {
1715  Wnd->hrgnUpdate = NULL;
1716  }
1717 }
1718 
1719 /* x and y are always screen relative */
1722  PWND Window,
1723  HWND WndInsertAfter,
1724  INT x,
1725  INT y,
1726  INT cx,
1727  INT cy,
1728  UINT flags
1729  )
1730 {
1731  WINDOWPOS WinPos;
1732  RECTL NewWindowRect;
1733  RECTL NewClientRect;
1734  RECTL valid_rects[2];
1735  PREGION VisBefore = NULL;
1736  PREGION VisBeforeJustClient = NULL;
1737  PREGION VisAfter = NULL;
1738  PREGION CopyRgn = NULL;
1739  ULONG WvrFlags = 0;
1740  RECTL OldWindowRect, OldClientRect;
1741  int RgnType;
1742  HDC Dc;
1743  RECTL CopyRect;
1744  PWND Ancestor;
1745  BOOL bPointerInWindow, PosChanged = FALSE;
1747 
1749 
1750  TRACE("pwnd %p, after %p, %d,%d (%dx%d), flags 0x%x\n",
1751  Window, WndInsertAfter, x, y, cx, cy, flags);
1752 #if DBG
1753  dump_winpos_flags(flags);
1754 #endif
1755 
1756  /* FIXME: Get current active window from active queue. Why? since r2915. */
1757 
1758  bPointerInWindow = IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y);
1759 
1760  WinPos.hwnd = Window->head.h;
1761  WinPos.hwndInsertAfter = WndInsertAfter;
1762  WinPos.x = x;
1763  WinPos.y = y;
1764  WinPos.cx = cx;
1765  WinPos.cy = cy;
1766  WinPos.flags = flags;
1767 
1768  if ( flags & SWP_ASYNCWINDOWPOS )
1769  {
1770  LRESULT lRes;
1772  if ( ppos )
1773  {
1774  WinPos.flags &= ~SWP_ASYNCWINDOWPOS; // Clear flag.
1775  *ppos = WinPos;
1776  /* Yes it's a pointer inside Win32k! */
1777  lRes = co_IntSendMessageNoWait( WinPos.hwnd, WM_ASYNC_SETWINDOWPOS, 0, (LPARAM)ppos);
1778  /* We handle this the same way as Event Hooks and Hooks. */
1779  if ( !lRes )
1780  {
1782  return FALSE;
1783  }
1784  return TRUE;
1785  }
1786  return FALSE;
1787  }
1788 
1789  co_WinPosDoWinPosChanging(Window, &WinPos, &NewWindowRect, &NewClientRect);
1790 
1791  /* Does the window still exist? */
1792  if (!IntIsWindow(WinPos.hwnd))
1793  {
1794  TRACE("WinPosSetWindowPos: Invalid handle 0x%p!\n",WinPos.hwnd);
1796  return FALSE;
1797  }
1798 
1799  /* Fix up the flags. */
1800  if (!WinPosFixupFlags(&WinPos, Window))
1801  {
1802  // See Note.
1803  return TRUE;
1804  }
1805 
1806  Ancestor = UserGetAncestor(Window, GA_PARENT);
1807  if ( (WinPos.flags & (SWP_NOZORDER | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) != SWP_NOZORDER &&
1808  Ancestor && Ancestor->head.h == IntGetDesktopWindow() )
1809  {
1811  }
1812 
1813  if (!(WinPos.flags & SWP_NOREDRAW))
1814  {
1815  /* Compute the visible region before the window position is changed */
1816  if (!(WinPos.flags & SWP_SHOWWINDOW) &&
1817  (WinPos.flags & (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1820  {
1822  (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1823 
1824  if ( VisBefore != NULL &&
1825  REGION_Complexity(VisBefore) == NULLREGION )
1826  {
1827  REGION_Delete(VisBefore);
1828  VisBefore = NULL;
1829  }
1830  else if(VisBefore)
1831  {
1832  REGION_bOffsetRgn(VisBefore, -Window->rcWindow.left, -Window->rcWindow.top);
1833  }
1834 
1835  /* Calculate the non client area for resizes, as this is used in the copy region */
1836  if ((WinPos.flags & (SWP_NOSIZE | SWP_FRAMECHANGED)) != SWP_NOSIZE)
1837  {
1838  VisBeforeJustClient = VIS_ComputeVisibleRegion(Window, TRUE, FALSE,
1839  (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1840 
1841  if ( VisBeforeJustClient != NULL &&
1842  REGION_Complexity(VisBeforeJustClient) == NULLREGION )
1843  {
1844  REGION_Delete(VisBeforeJustClient);
1845  VisBeforeJustClient = NULL;
1846  }
1847  else if(VisBeforeJustClient)
1848  {
1849  REGION_bOffsetRgn(VisBeforeJustClient, -Window->rcWindow.left, -Window->rcWindow.top);
1850  }
1851  }
1852  }
1853  }
1854 
1856  if (Window->hrgnNewFrame)
1857  {
1858  SelectWindowRgn( Window, Window->hrgnNewFrame ); // Should be PSMWP->acvr->hrgnClip
1859  Window->hrgnNewFrame = NULL;
1860  }
1861 
1862  WvrFlags = co_WinPosDoNCCALCSize(Window, &WinPos, &NewWindowRect, &NewClientRect, valid_rects);
1863 
1864 // ERR("co_WinPosDoNCCALCSize returned 0x%x\n valid dest: %d %d %d %d\n valid src : %d %d %d %d\n", WvrFlags,
1865 // valid_rects[0].left,valid_rects[0].top,valid_rects[0].right,valid_rects[0].bottom,
1866 // valid_rects[1].left,valid_rects[1].top,valid_rects[1].right,valid_rects[1].bottom);
1867 
1868  /* Validate link windows. (also take into account shell window in hwndShellWindow) */
1869  if (!(WinPos.flags & SWP_NOZORDER) && WinPos.hwnd != UserGetShellWindow())
1870  {
1872  }
1873 
1874  OldWindowRect = Window->rcWindow;
1875  OldClientRect = Window->rcClient;
1876 
1877  if (NewClientRect.left != OldClientRect.left ||
1878  NewClientRect.top != OldClientRect.top)
1879  {
1880  // Move child window if their parent is moved. Keep Child window relative to Parent...
1882  NewClientRect.left - OldClientRect.left,
1883  NewClientRect.top - OldClientRect.top);
1884  PosChanged = TRUE;
1885  }
1886 
1887  Window->rcWindow = NewWindowRect;
1888  Window->rcClient = NewClientRect;
1889 
1890  /* erase parent when hiding or resizing child */
1891  if (WinPos.flags & SWP_HIDEWINDOW)
1892  {
1893  /* Clear the update region */
1895  NULL,
1896  0,
1898 
1899  if (UserIsDesktopWindow(Window->spwndParent))
1901 
1902  Window->style &= ~WS_VISIBLE; //IntSetStyle( Window, 0, WS_VISIBLE );
1903  Window->head.pti->cVisWindows--;
1905  }
1906  else if (WinPos.flags & SWP_SHOWWINDOW)
1907  {
1908  if (Window->style & WS_CHILD)
1909  {
1910  if ((Window->style & WS_POPUP) && (Window->ExStyle & WS_EX_APPWINDOW))
1911  {
1913  if (!(WinPos.flags & SWP_NOACTIVATE))
1915  }
1916  }
1917  else if ((Window->ExStyle & WS_EX_APPWINDOW) ||
1918  (!(Window->ExStyle & WS_EX_TOOLWINDOW) && !Window->spwndOwner &&
1919  (!Window->spwndParent || UserIsDesktopWindow(Window->spwndParent))))
1920  {
1922  if (!(WinPos.flags & SWP_NOACTIVATE))
1924  }
1925 
1926  Window->style |= WS_VISIBLE; //IntSetStyle( Window, WS_VISIBLE, 0 );
1927  Window->head.pti->cVisWindows++;
1929  }
1930  else
1931  {
1933  }
1934 
1935  if (Window->hrgnUpdate != NULL && Window->hrgnUpdate != HRGN_WINDOW)
1936  {
1937  NtGdiOffsetRgn(Window->hrgnUpdate,
1938  NewWindowRect.left - OldWindowRect.left,
1939  NewWindowRect.top - OldWindowRect.top);
1940  }
1941 
1942  DceResetActiveDCEs(Window); // For WS_VISIBLE changes.
1943 
1944  // Change or update, set send non-client paint flag.
1945  if ( Window->style & WS_VISIBLE &&
1946  (WinPos.flags & SWP_STATECHANGED || (!(Window->state2 & WNDS2_WIN31COMPAT) && WinPos.flags & SWP_NOREDRAW ) ) )
1947  {
1948  TRACE("Set WNDS_SENDNCPAINT %p\n",Window);
1949  Window->state |= WNDS_SENDNCPAINT;
1950  }
1951 
1952  if (!(WinPos.flags & SWP_NOREDRAW))
1953  {
1954  /* Determine the new visible region */
1956  (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1957 
1958  if ( VisAfter != NULL &&
1959  REGION_Complexity(VisAfter) == NULLREGION )
1960  {
1961  REGION_Delete(VisAfter);
1962  VisAfter = NULL;
1963  }
1964  else if(VisAfter)
1965  {
1966  REGION_bOffsetRgn(VisAfter, -Window->rcWindow.left, -Window->rcWindow.top);
1967  }
1968 
1969  /*
1970  * Determine which pixels can be copied from the old window position
1971  * to the new. Those pixels must be visible in both the old and new
1972  * position. Also, check the class style to see if the windows of this
1973  * class need to be completely repainted on (horizontal/vertical) size
1974  * change.
1975  */
1976  if ( ( VisBefore != NULL &&
1977  VisAfter != NULL &&
1978  !(WinPos.flags & SWP_NOCOPYBITS) &&
1979  ((WinPos.flags & SWP_NOSIZE) || !(WvrFlags & WVR_REDRAW)) &&
1980  !(Window->ExStyle & WS_EX_TRANSPARENT) ) )
1981  {
1982 
1983  /*
1984  * If this is (also) a window resize, the whole nonclient area
1985  * needs to be repainted. So we limit the copy to the client area,
1986  * 'cause there is no use in copying it (would possibly cause
1987  * "flashing" too). However, if the copy region is already empty,
1988  * we don't have to crop (can't take anything away from an empty
1989  * region...)
1990  */
1991 
1992  CopyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
1993  if ((WinPos.flags & SWP_NOSIZE) && (WinPos.flags & SWP_NOCLIENTSIZE))
1994  RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBefore, RGN_AND);
1995  else if (VisBeforeJustClient != NULL)
1996  {
1997  RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBeforeJustClient, RGN_AND);
1998  }
1999 
2000  if (VisBeforeJustClient != NULL)
2001  {
2002  REGION_Delete(VisBeforeJustClient);
2003  }
2004 
2005  /* Now use in copying bits which are in the update region. */
2006  if (Window->hrgnUpdate != NULL)
2007  {
2008  PREGION RgnUpdate = REGION_LockRgn(Window->hrgnUpdate);
2009  if (RgnUpdate)
2010  {
2011  REGION_bOffsetRgn(CopyRgn, NewWindowRect.left, NewWindowRect.top);
2012  IntGdiCombineRgn(CopyRgn, CopyRgn, RgnUpdate, RGN_DIFF);
2013  REGION_bOffsetRgn(CopyRgn, -NewWindowRect.left, -NewWindowRect.top);
2014  REGION_UnlockRgn(RgnUpdate);
2015  }
2016  }
2017 
2018  /*
2019  * Now, get the bounding box of the copy region. If it's empty
2020  * there's nothing to copy. Also, it's no use copying bits onto
2021  * themselves.
2022  */
2024  {
2025  /* Nothing to copy, clean up */
2027  CopyRgn = NULL;
2028  }
2029  else if ( OldWindowRect.left != NewWindowRect.left ||
2030  OldWindowRect.top != NewWindowRect.top ||
2031  (WinPos.flags & SWP_FRAMECHANGED) )
2032  {
2033  HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
2034  PREGION DcRgnObj = REGION_LockRgn(DcRgn);
2035 
2036  /*
2037  * Small trick here: there is no function to bitblt a region. So
2038  * we set the region as the clipping region, take the bounding box
2039  * of the region and bitblt that. Since nothing outside the clipping
2040  * region is copied, this has the effect of bitblt'ing the region.
2041  *
2042  * Since NtUserGetDCEx takes ownership of the clip region, we need
2043  * to create a copy of CopyRgn and pass that. We need CopyRgn later
2044  */
2045  IntGdiCombineRgn(DcRgnObj, CopyRgn, NULL, RGN_COPY);
2046  REGION_bOffsetRgn(DcRgnObj, NewWindowRect.left, NewWindowRect.top);
2047  REGION_UnlockRgn(DcRgnObj);
2048  Dc = UserGetDCEx( Window,
2049  DcRgn,
2050  DCX_WINDOW|DCX_CACHE|DCX_INTERSECTRGN|DCX_CLIPSIBLINGS|DCX_KEEPCLIPRGN); // DCX_WINDOW will set first, go read WinDC.c.
2051  NtGdiBitBlt( Dc,
2052  CopyRect.left, CopyRect.top,
2053  CopyRect.right - CopyRect.left,
2054  CopyRect.bottom - CopyRect.top,
2055  Dc,
2056  CopyRect.left + (OldWindowRect.left - NewWindowRect.left),
2057  CopyRect.top + (OldWindowRect.top - NewWindowRect.top),
2058  SRCCOPY,
2059  0,
2060  0);
2061 
2062  UserReleaseDC(Window, Dc, FALSE);
2064  GreDeleteObject(DcRgn);
2065  }
2066  }
2067  else
2068  {
2069  CopyRgn = NULL;
2070  }
2071 
2072  /* We need to redraw what wasn't visible before or force a redraw */
2073  if (VisAfter != NULL)
2074  {
2075  PREGION DirtyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2076  if (DirtyRgn)
2077  {
2078  if (CopyRgn != NULL)
2079  {
2080  RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, CopyRgn, RGN_DIFF);
2081  }
2082  else
2083  {
2084  RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, 0, RGN_COPY);
2085  }
2086 
2087  if (RgnType != ERROR && RgnType != NULLREGION) // Regions moved.
2088  {
2089  /* old code
2090  NtGdiOffsetRgn(DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
2091  IntInvalidateWindows( Window,
2092  DirtyRgn,
2093  RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
2094  }
2095  GreDeleteObject(DirtyRgn);
2096  */
2097 
2098  PWND Parent = Window->spwndParent;
2099 
2100  REGION_bOffsetRgn( DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
2101 
2102  if ( (Window->style & WS_CHILD) && (Parent) && !(Parent->style & WS_CLIPCHILDREN))
2103  {
2106  }
2108  }
2109  else if ( RgnType != ERROR && RgnType == NULLREGION ) // Must be the same. See CORE-7166 & CORE-15934, NC HACK fix.
2110  {
2111  if ( !PosChanged &&
2112  !(WinPos.flags & SWP_DEFERERASE) &&
2113  (WinPos.flags & SWP_FRAMECHANGED) )
2114  {
2115  PWND pwnd = Window;
2116  PWND Parent = Window->spwndParent;
2117 
2118  if ( pwnd->style & WS_CHILD ) // Fix ProgMan menu bar drawing.
2119  {
2120  TRACE("SWP_FRAMECHANGED win child %p Parent %p\n",pwnd,Parent);
2121  pwnd = Parent ? Parent : pwnd;
2122  }
2123 
2124  if ( !(pwnd->style & WS_CHILD) )
2125  {
2126  /*
2127  * Check if we have these specific windows style bits set/reset.
2128  * FIXME: There may be other combinations of styles that need this handling as well.
2129  * This fixes the ReactOS Calculator buttons disappearing in CORE-16827.
2130  */
2131  if ((Window->style & WS_CLIPSIBLINGS) && !(Window->style & (WS_POPUP | WS_CLIPCHILDREN | WS_SIZEBOX)))
2132  {
2133  IntSendNCPaint(pwnd, HRGN_WINDOW); // Paint the whole frame.
2134  }
2135  else // Use region handling
2136  {
2137  HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
2138  PREGION DcRgnObj = REGION_LockRgn(DcRgn);
2139  TRACE("SWP_FRAMECHANGED win %p hRgn %p\n",pwnd, DcRgn);
2140  IntGdiCombineRgn(DcRgnObj, VisBefore, NULL, RGN_COPY);
2141  REGION_UnlockRgn(DcRgnObj);
2142  ForceNCPaintErase(pwnd, DcRgn, DcRgnObj);
2143  GreDeleteObject(DcRgn);
2144  }
2145  }
2146  }
2147  }
2148  REGION_Delete(DirtyRgn);
2149  }
2150  }
2151 
2152  if (CopyRgn != NULL)
2153  {
2155  }
2156 
2157  /* Expose what was covered before but not covered anymore */
2158  if ( VisBefore != NULL )
2159  {
2160  PREGION ExposedRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2161  if (ExposedRgn)
2162  {
2163  RgnType = IntGdiCombineRgn(ExposedRgn, VisBefore, NULL, RGN_COPY);
2164  REGION_bOffsetRgn(ExposedRgn,
2165  OldWindowRect.left - NewWindowRect.left,
2166  OldWindowRect.top - NewWindowRect.top);
2167 
2168  if ( VisAfter != NULL )
2169  RgnType = IntGdiCombineRgn(ExposedRgn, ExposedRgn, VisAfter, RGN_DIFF);
2170 
2171  if (RgnType != ERROR && RgnType != NULLREGION)
2172  {
2173  co_VIS_WindowLayoutChanged(Window, ExposedRgn);
2174  }
2175  REGION_Delete(ExposedRgn);
2176  }
2177  REGION_Delete(VisBefore);
2178  }
2179 
2180  if (VisAfter != NULL)
2181  {
2182  REGION_Delete(VisAfter);
2183  }
2184  }
2185 
2186  if (!(WinPos.flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)))
2187  {
2188  if ((Window->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
2189  {
2191  }
2192  else
2193  {
2194  //ERR("SetWindowPos Set FG Window!\n");
2195  if ( pti->MessageQueue->spwndActive != Window ||
2196  pti->MessageQueue != gpqForeground )
2197  {
2198  //ERR("WPSWP : set active window\n");
2199  if (!(Window->state & WNDS_BEINGACTIVATED)) // Inside SAW?
2200  {
2201  co_IntSetForegroundWindow(Window); // Fixes SW_HIDE issues. Wine win test_SetActiveWindow & test_SetForegroundWindow.
2202  }
2203  }
2204  }
2205  }
2206 
2207  if ( !PosChanged &&
2208  (WinPos.flags & SWP_FRAMECHANGED) &&
2209  !(WinPos.flags & SWP_DEFERERASE) && // Prevent sending WM_SYNCPAINT message.
2210  VisAfter )
2211  {
2212  PWND Parent = Window->spwndParent;
2213  if ( !(Window->style & WS_CHILD) && (Parent) && (Parent->style & WS_CLIPCHILDREN))
2214  {
2215  TRACE("SWP_FRAMECHANGED Parent %p WS_CLIPCHILDREN %p\n",Parent,Window);
2216  UserSyncAndPaintWindows( Parent, RDW_CLIPCHILDREN); // NC should redraw here, see NC HACK fix.
2217  }
2218  }
2219 
2220  // Fix wine msg test_SetFocus, prevents sending WM_WINDOWPOSCHANGED.
2221  if ( VisBefore == NULL &&
2222  VisBeforeJustClient == NULL &&
2223  !(Window->ExStyle & WS_EX_TOPMOST) &&
2225  {
2226  TRACE("No drawing, set no Z order and no redraw!\n");
2227  WinPos.flags |= SWP_NOZORDER|SWP_NOREDRAW;
2228  }
2229 
2230  if(!(flags & SWP_DEFERERASE))
2231  {
2232  /* erase parent when hiding or resizing child */
2233  if ((flags & SWP_HIDEWINDOW) ||
2234  (!(flags & SWP_SHOWWINDOW) &&
2236  {
2237  PWND Parent = Window->spwndParent;
2240  }
2241 
2242  /* Give newly shown windows a chance to redraw */
2243  if(((WinPos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE)
2245  {
2247  }
2248  }
2249 
2250  /* And last, send the WM_WINDOWPOSCHANGED message */
2251 
2252  TRACE("\tstatus hwnd %p flags = %04x\n",Window?Window->head.h:NULL,WinPos.flags & SWP_AGG_STATUSFLAGS);
2253 
2254  if (((WinPos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE)
2256  {
2257  /* WM_WINDOWPOSCHANGED is sent even if SWP_NOSENDCHANGING is set
2258  and always contains final window position.
2259  */
2260  WinPos.x = NewWindowRect.left;
2261  WinPos.y = NewWindowRect.top;
2262  WinPos.cx = NewWindowRect.right - NewWindowRect.left;
2263  WinPos.cy = NewWindowRect.bottom - NewWindowRect.top;
2264  TRACE("WM_WINDOWPOSCHANGED hwnd %p Flags %04x\n",WinPos.hwnd,WinPos.flags);
2265  co_IntSendMessageNoWait(WinPos.hwnd, WM_WINDOWPOSCHANGED, 0, (LPARAM) &WinPos);
2266  }
2267 
2268  if ( WinPos.flags & SWP_FRAMECHANGED || WinPos.flags & SWP_STATECHANGED ||
2269  !(WinPos.flags & SWP_NOCLIENTSIZE) || !(WinPos.flags & SWP_NOCLIENTMOVE) )
2270  {
2271  PWND pWnd = ValidateHwndNoErr(WinPos.hwnd);
2272  if (pWnd)
2273  IntNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, pWnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
2274  }
2275 
2276  if(bPointerInWindow != IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y))
2277  {
2278  /* Generate mouse move message */
2279  MSG msg;
2280  msg.message = WM_MOUSEMOVE;
2281  msg.wParam = UserGetMouseButtonsState();
2282  msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
2283  msg.pt = gpsi->ptCursor;
2285  }
2286 
2287  return TRUE;
2288 }
2289 
2291 co_WinPosGetNonClientSize(PWND Window, RECT* WindowRect, RECT* ClientRect)
2292 {
2293  LRESULT Result;
2294 
2296 
2297  *ClientRect = *WindowRect;
2298  Result = co_IntSendMessageNoWait(Window->head.h, WM_NCCALCSIZE, FALSE, (LPARAM) ClientRect);
2299 
2300  FixClientRect(ClientRect, WindowRect);
2301 
2302  return Result;
2303 }
2304 
2305 void FASTCALL
2307 {
2308  RECTL Rect;
2309  LPARAM lParam;
2311 
2312  IntGetClientRect(Wnd, &Rect);
2313  lParam = MAKELONG(Rect.right-Rect.left, Rect.bottom-Rect.top);
2314 
2315  Wnd->state &= ~WNDS_SENDSIZEMOVEMSGS;
2316 
2317  if (Wnd->style & WS_MAXIMIZE)
2318  {
2320  }
2321  else if (Wnd->style & WS_MINIMIZE)
2322  {
2324  lParam = 0;
2325  }
2326 
2328 
2329  if (UserIsDesktopWindow(Wnd->spwndParent))
2330  lParam = MAKELONG(Wnd->rcClient.left, Wnd->rcClient.top);
2331  else
2332  lParam = MAKELONG(Wnd->rcClient.left-Wnd->spwndParent->rcClient.left, Wnd->rcClient.top-Wnd->spwndParent->rcClient.top);
2333 
2335 
2337 }
2338 
2339 UINT FASTCALL
2340 co_WinPosMinMaximize(PWND Wnd, UINT ShowFlag, RECT* NewPos)
2341 {
2342  POINT Size;
2343  WINDOWPLACEMENT wpl;
2344  LONG old_style;
2345  UINT SwpFlags = 0;
2346 
2347  ASSERT_REFS_CO(Wnd);
2348 
2349  wpl.length = sizeof(wpl);
2350  IntGetWindowPlacement( Wnd, &wpl );
2351 
2352  if (co_HOOK_CallHooks( WH_CBT, HCBT_MINMAX, (WPARAM)Wnd->head.h, ShowFlag))
2353  {
2354  ERR("WinPosMinMaximize WH_CBT Call Hook return!\n");
2355  return SWP_NOSIZE | SWP_NOMOVE;
2356  }
2357  if (Wnd->style & WS_MINIMIZE)
2358  {
2359  switch (ShowFlag)
2360  {
2361  case SW_MINIMIZE:
2362  case SW_SHOWMINNOACTIVE:
2363  case SW_SHOWMINIMIZED:
2364  case SW_FORCEMINIMIZE:
2365  return SWP_NOSIZE | SWP_NOMOVE;
2366  }
2367  if (!co_IntSendMessageNoWait(Wnd->head.h, WM_QUERYOPEN, 0, 0))
2368  {
2369  return(SWP_NOSIZE | SWP_NOMOVE);
2370  }
2371  SwpFlags |= SWP_NOCOPYBITS;
2372  }
2373  switch (ShowFlag)
2374  {
2375  case SW_MINIMIZE:
2376  case SW_SHOWMINNOACTIVE:
2377  case SW_SHOWMINIMIZED:
2378  case SW_FORCEMINIMIZE:
2379  {
2380  //ERR("MinMaximize Minimize\n");
2381  if (Wnd->style & WS_MAXIMIZE)
2382  {
2383  Wnd->InternalPos.flags |= WPF_RESTORETOMAXIMIZED;
2384  }
2385  else
2386  {
2387  Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
2388  }
2389 
2390  old_style = IntSetStyle( Wnd, WS_MINIMIZE, WS_MAXIMIZE );
2391 
2393 
2394  if (!(Wnd->InternalPos.flags & WPF_SETMINPOSITION))
2395  Wnd->InternalPos.flags &= ~WPF_MININIT;
2396 
2397  WinPosFindIconPos(Wnd, &wpl.ptMinPosition);
2398 
2399  if (!(old_style & WS_MINIMIZE))
2400  {
2401  SwpFlags |= SWP_STATECHANGED;
2402  IntShowOwnedPopups(Wnd, FALSE);
2403  }
2404 
2405  RECTL_vSetRect(NewPos, wpl.ptMinPosition.x, wpl.ptMinPosition.y,
2408  SwpFlags |= SWP_NOCOPYBITS;
2409  break;
2410  }
2411 
2412  case SW_MAXIMIZE:
2413  {
2414  //ERR("MinMaximize Maximize\n");
2415  if ((Wnd->style & WS_MAXIMIZE) && (Wnd->style & WS_VISIBLE))
2416  {
2417  SwpFlags = SWP_NOSIZE | SWP_NOMOVE;
2418  break;
2419  }
2421 
2422  /*ERR("Maximize: %d,%d %dx%d\n",
2423  wpl.ptMaxPosition.x, wpl.ptMaxPosition.y, Size.x, Size.y);
2424  */
2425  old_style = IntSetStyle( Wnd, WS_MAXIMIZE, WS_MINIMIZE );
2426  /*if (old_style & WS_MINIMIZE)
2427  {
2428  IntShowOwnedPopups(Wnd, TRUE);
2429  }*/
2430 
2431  if (!(old_style & WS_MAXIMIZE)) SwpFlags |= SWP_STATECHANGED;
2432  RECTL_vSetRect(NewPos, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
2433  //wpl.ptMaxPosition.x + Size.x, wpl.ptMaxPosition.y + Size.y);
2434  Size.x, Size.y);
2435  break;
2436  }
2437 
2438  case SW_SHOWNOACTIVATE:
2439  Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
2440  /* fall through */
2441  case SW_SHOWNORMAL:
2442  case SW_RESTORE:
2443  case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
2444  {
2445  //ERR("MinMaximize Restore\n");
2446  old_style = IntSetStyle( Wnd, 0, WS_MINIMIZE | WS_MAXIMIZE );
2447  if (old_style & WS_MINIMIZE)
2448  {
2449  IntShowOwnedPopups(Wnd, TRUE);
2450 
2451  if (Wnd->InternalPos.flags & WPF_RESTORETOMAXIMIZED)
2452  {
2454  IntSetStyle( Wnd, WS_MAXIMIZE, 0 );
2455  SwpFlags |= SWP_STATECHANGED;
2456  RECTL_vSetRect(NewPos, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
2457  wpl.ptMaxPosition.x + Size.x, wpl.ptMaxPosition.y + Size.y);
2458  break;
2459  }
2460  else
2461  {
2462  *NewPos = wpl.rcNormalPosition;
2463  NewPos->right -= NewPos->left;
2464  NewPos->bottom -= NewPos->top;
2465  break;
2466  }
2467  }
2468  else
2469  {
2470  if (!(old_style & WS_MAXIMIZE))
2471  {
2472  break;
2473  }
2474  SwpFlags |= SWP_STATECHANGED;
2475  Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
2476  *NewPos = wpl.rcNormalPosition;
2477  NewPos->right -= NewPos->left;
2478  NewPos->bottom -= NewPos->top;
2479  break;
2480  }
2481  }
2482  }
2483  return SwpFlags;
2484 }
2485 
2486 /*
2487  ShowWindow does not set SWP_FRAMECHANGED!!! Fix wine msg test_SetParent:WmSetParentSeq_2:23 wParam bits!
2488  Win: xxxShowWindow
2489  */
2492 {
2493  BOOLEAN WasVisible;
2494  UINT Swp = 0, EventMsg = 0;
2495  RECTL NewPos = {0, 0, 0, 0};
2496  BOOLEAN ShowFlag;
2497  LONG style;
2498  PWND Parent;
2499  PTHREADINFO pti;
2500  //HRGN VisibleRgn;
2501  BOOL ShowOwned = FALSE;
2502  BOOL FirstTime = FALSE;
2503  ASSERT_REFS_CO(Wnd);
2504  //KeRosDumpStackFrames(NULL, 20);
2506  WasVisible = (Wnd->style & WS_VISIBLE) != 0;
2507  style = Wnd->style;
2508 
2509  TRACE("co_WinPosShowWindow START hwnd %p Cmd %d usicmd %u\n",
2510  Wnd->head.h, Cmd, pti->ppi->usi.wShowWindow);
2511 
2512  if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
2513  {
2514  if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD)
2515  {
2516  if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
2517  {
2518  if (Wnd->spwndOwner == NULL)
2519  {
2520  if ( Cmd == SW_SHOWNORMAL || Cmd == SW_SHOW)
2521  {
2522  Cmd = SW_SHOWDEFAULT;
2523  }
2524  FirstTime = TRUE;
2525  TRACE("co_WPSW FT 1\n");
2526  }
2527  }
2528  }
2529  }
2530 
2531  if ( Cmd == SW_SHOWDEFAULT )
2532  {
2533  if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
2534  {
2535  Cmd = pti->ppi->usi.wShowWindow;
2536  FirstTime = TRUE;
2537  TRACE("co_WPSW FT 2\n");
2538  }
2539  }
2540 
2541  if (FirstTime)
2542  {
2544  }
2545 
2546  switch (Cmd)
2547  {
2548  case SW_HIDE:
2549  {
2550  if (!WasVisible)
2551  {
2552  //ERR("co_WinPosShowWindow Exit Bad\n");
2553  return FALSE;
2554  }
2556  if (Wnd != pti->MessageQueue->spwndActive)
2557  Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2558  break;
2559  }
2560 
2561  case SW_FORCEMINIMIZE: /* FIXME: Does not work if thread is hung. */
2562  case SW_SHOWMINNOACTIVE:
2563  Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2564  /* Fall through. */
2565  case SW_SHOWMINIMIZED:
2566  case SW_MINIMIZE: /* CORE-15669: SW_MINIMIZE also shows */
2567  Swp |= SWP_SHOWWINDOW;
2568  {
2569  Swp |= SWP_NOACTIVATE;
2570  if (!(style & WS_MINIMIZE))
2571  {
2572  IntShowOwnedPopups(Wnd, FALSE );
2573  // Fix wine Win test_SetFocus todo #1 & #2,
2574  if (Cmd == SW_SHOWMINIMIZED)
2575  {
2576  //ERR("co_WinPosShowWindow Set focus 1\n");
2577  if ((style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
2579  else
2580  co_UserSetFocus(0);
2581  }
2582 
2583  Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
2584 
2585  EventMsg = EVENT_SYSTEM_MINIMIZESTART;
2586  }
2587  else
2588  {
2589  if (WasVisible)
2590  {
2591  //ERR("co_WinPosShowWindow Exit Good\n");
2592  return TRUE;
2593  }
2594  Swp |= SWP_NOSIZE | SWP_NOMOVE;
2595  }
2596  break;
2597  }
2598 
2599  case SW_SHOWMAXIMIZED:
2600  {
2601  Swp |= SWP_SHOWWINDOW;
2602  if (!(style & WS_MAXIMIZE))
2603  {
2604  ShowOwned = TRUE;
2605 
2606  Swp |= co_WinPosMinMaximize(Wnd, SW_MAXIMIZE, &NewPos);
2607 
2608  EventMsg = EVENT_SYSTEM_MINIMIZEEND;
2609  }
2610  else
2611  {
2612  if (WasVisible)
2613  {
2614  //ERR("co_WinPosShowWindow Exit Good 1\n");
2615  return TRUE;
2616  }
2617  Swp |= SWP_NOSIZE | SWP_NOMOVE;
2618  }
2619  break;
2620  }
2621 
2622  case SW_SHOWNA:
2624  if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOZORDER;
2625  break;
2626  case SW_SHOW:
2627  if (WasVisible) return(TRUE); // Nothing to do!
2629  /* Don't activate the topmost window. */
2630  if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2631  break;
2632 
2633  case SW_SHOWNOACTIVATE:
2634  Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2635  /* Fall through. */
2636  case SW_SHOWNORMAL:
2637  case SW_SHOWDEFAULT:
2638  case SW_RESTORE:
2639  if (!WasVisible) Swp |= SWP_SHOWWINDOW;
2640  if (style & (WS_MINIMIZE | WS_MAXIMIZE))
2641  {
2642  Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
2643  if (style & WS_MINIMIZE) EventMsg = EVENT_SYSTEM_MINIMIZEEND;
2644  }
2645  else
2646  {
2647  if (WasVisible)
2648  {
2649  //ERR("co_WinPosShowWindow Exit Good 3\n");
2650  return TRUE;
2651  }
2652  Swp |= SWP_NOSIZE | SWP_NOMOVE;
2653  }
2654  if ( style & WS_CHILD &&
2655  !(Wnd->ExStyle & WS_EX_MDICHILD) &&
2656  !(Swp & SWP_STATECHANGED))
2657  Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2658  break;
2659 
2660  default:
2661  //ERR("co_WinPosShowWindow Exit Good 4\n");
2662  return FALSE;
2663  }
2664 
2665  ShowFlag = (Cmd != SW_HIDE);
2666 
2667  if ((ShowFlag != WasVisible || Cmd == SW_SHOWNA) && Cmd != SW_SHOWMAXIMIZED && !(Swp & SWP_STATECHANGED))
2668  {
2669  co_IntSendMessageNoWait(Wnd->head.h, WM_SHOWWINDOW, ShowFlag, 0);
2670 #if 0 // Fix wine msg test_SetParent:WmSetParentSeq_1:2
2671  if (!(Wnd->state2 & WNDS2_WIN31COMPAT)) // <------------- XP sets this bit!
2672  co_IntSendMessageNoWait(Wnd->head.h, WM_SETVISIBLE, ShowFlag, 0);
2673 #endif
2674  if (!VerifyWnd(Wnd)) return WasVisible;
2675  }
2676 
2677  /* We can't activate a child window */
2678  if ((Wnd->style & WS_CHILD) &&
2679  !(Wnd->ExStyle & WS_EX_MDICHILD) &&
2680  Cmd != SW_SHOWNA)
2681  {
2682  //ERR("SWP Child No active and ZOrder\n");
2683  Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2684  }
2685 
2686 #if 0 // Explorer issues with common controls? Someone does not know how CS_SAVEBITS works.
2687  // Breaks startup and shutdown active window...
2688  if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
2689  Wnd->pcls->style & CS_SAVEBITS &&
2690  ((Cmd == SW_SHOW) || (Cmd == SW_NORMAL)))
2691  {
2692  ERR("WinPosShowWindow Set active\n");
2693  //UserSetActiveWindow(Wnd);
2694  co_IntSetForegroundWindow(Wnd); // HACK
2695  Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2696  }
2697 #endif
2698 
2699  if (IsChildVisible(Wnd) || Swp & SWP_STATECHANGED)
2700  {
2701  TRACE("Child is Vis %s or State changed %s. ShowFlag %s Swp %04x\n",
2702  (IsChildVisible(Wnd) ? "TRUE" : "FALSE"), (Swp & SWP_STATECHANGED ? "TRUE" : "FALSE"),
2703  (ShowFlag ? "TRUE" : "FALSE"),LOWORD(Swp));
2704  co_WinPosSetWindowPos( Wnd,
2705  0 != (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOPMOST : HWND_TOP,
2706  NewPos.left,
2707  NewPos.top,
2708  NewPos.right, // NewPos.right - NewPos.left, when minimized and restore, the window becomes smaller.
2709  NewPos.bottom,// NewPos.bottom - NewPos.top,
2710  LOWORD(Swp));
2711  }
2712  else
2713  {
2714  TRACE("Parent Vis?\n");
2715  /* if parent is not visible simply toggle WS_VISIBLE and return */
2716  if (ShowFlag) IntSetStyle( Wnd, WS_VISIBLE, 0 );
2717  else IntSetStyle( Wnd, 0, WS_VISIBLE );
2718  }
2719 
2720  if ( EventMsg ) IntNotifyWinEvent(EventMsg, Wnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
2721 
2722  if ( ShowOwned ) IntShowOwnedPopups(Wnd, TRUE );
2723 
2724  if ((Cmd == SW_HIDE) || (Cmd == SW_MINIMIZE))
2725  {
2726  if ( Wnd == pti->MessageQueue->spwndActive && pti->MessageQueue == IntGetFocusMessageQueue() )
2727  {
2728  if (UserIsDesktopWindow(Wnd->spwndParent))
2729  {
2730  if (!ActivateOtherWindowMin(Wnd))
2731  {
2733  }
2734  }
2735  else
2736  {
2738  }
2739  }
2740 
2741  /* Revert focus to parent */
2742  if (Wnd == pti->MessageQueue->spwndFocus)
2743  {
2744  Parent = Wnd->spwndParent;
2745  if (UserIsDesktopWindow(Wnd->spwndParent))
2746  Parent = 0;
2748  }
2749  // Hide, just return.
2750  if (Cmd == SW_HIDE) return WasVisible;
2751  }
2752 
2753  /* FIXME: Check for window destruction. */
2754 
2755  if ((Wnd->state & WNDS_SENDSIZEMOVEMSGS) &&
2756  !(Wnd->state2 & WNDS2_INDESTROY))
2757  {
2758  co_WinPosSendSizeMove(Wnd);
2759  }
2760 
2761  /* if previous state was minimized Windows sets focus to the window */
2762  if (style & WS_MINIMIZE)
2763  {
2764  co_UserSetFocus(Wnd);
2765  // Fix wine Win test_SetFocus todo #3,
2767  }
2768  //ERR("co_WinPosShowWindow EXIT\n");
2769  return WasVisible;
2770 }
2771 
2772 static PWND
2774  IN PWND ScopeWin,
2775  IN POINT *Point,
2776  IN OUT USHORT *HitTest,
2777  IN BOOL Ignore
2778  )
2779 {
2780  HWND *List, *phWnd;
2781  PWND pwndChild = NULL;
2782 
2783  /* not visible */
2784  if (!(ScopeWin->style & WS_VISIBLE))
2785  {
2786  return NULL;
2787  }
2788 
2789  /* not in window or in window region */
2790  if (!IntPtInWindow(ScopeWin, Point->x, Point->y))
2791  {
2792  return NULL;
2793  }
2794 
2795  /* transparent */
2796  if ((ScopeWin->ExStyle & (WS_EX_LAYERED|WS_EX_TRANSPARENT)) == (WS_EX_LAYERED|WS_EX_TRANSPARENT))
2797  {
2798  return NULL;
2799  }
2800 
2801  if (!Ignore && (ScopeWin->style & WS_DISABLED))
2802  { /* disabled child */
2803  if ((ScopeWin->style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return NULL;
2804  /* process the hit error */
2805  *HitTest = HTERROR;
2806  return ScopeWin;
2807  }
2808 
2809  /* not minimized and check if point is inside the window */
2810  if (!(ScopeWin->style & WS_MINIMIZE) &&
2811  RECTL_bPointInRect(&ScopeWin->rcClient, Point->x, Point->y) )
2812  {
2813  UserReferenceObject(ScopeWin);
2814 
2815  List = IntWinListChildren(ScopeWin);
2816  if (List)
2817  {
2818  for (phWnd = List; *phWnd; ++phWnd)
2819  {
2820  if (!(pwndChild = ValidateHwndNoErr(*phWnd)))
2821  {
2822  continue;
2823  }
2824 
2825  pwndChild = co_WinPosSearchChildren(pwndChild, Point, HitTest, Ignore);
2826 
2827  if (pwndChild != NULL)
2828  {
2829  /* We found a window. Don't send any more WM_NCHITTEST messages */
2831  UserDereferenceObject(ScopeWin);
2832  return pwndChild;
2833  }
2834  }
2836  }
2837  UserDereferenceObject(ScopeWin);
2838  }
2839 
2840  if (ScopeWin->head.pti == PsGetCurrentThreadWin32Thread())
2841  {
2842  *HitTest = (USHORT)co_IntSendMessage(ScopeWin->head.h, WM_NCHITTEST, 0, MAKELONG(Point->x, Point->y));
2843 
2844  if ((*HitTest) == (USHORT)HTTRANSPARENT)
2845  {
2846  return NULL;
2847  }
2848  }
2849  else
2850  {
2851  if (*HitTest == HTNOWHERE && pwndChild == NULL) *HitTest = HTCLIENT;
2852  }
2853 
2854  return ScopeWin;
2855 }
2856 
2857 PWND APIENTRY
2859  IN PWND ScopeWin,
2860  IN POINT *WinPoint,
2861  IN OUT USHORT* HitTest,
2862  IN BOOL Ignore)
2863 {
2864  PWND Window;
2865  POINT Point = *WinPoint;
2867 
2868  if( ScopeWin == NULL )
2869  {
2870  ScopeWin = UserGetDesktopWindow();
2871  if(ScopeWin == NULL)
2872  return NULL;
2873  }
2874 
2875  *HitTest = HTNOWHERE;
2876 
2877  ASSERT_REFS_CO(ScopeWin);
2878  UserRefObjectCo(ScopeWin, &Ref);
2879 
2880  Window = co_WinPosSearchChildren(ScopeWin, &Point, HitTest, Ignore);
2881 
2882  UserDerefObjectCo(ScopeWin);
2883  if (Window)
2885  ASSERT_REFS_CO(ScopeWin);
2886 
2887  return Window;
2888 }
2889 
2890 PWND FASTCALL
2892 {
2893  POINTL Pt;
2894  HWND *List, *phWnd;
2895  PWND pwndHit = NULL;
2896 
2897  Pt.x = x;
2898  Pt.y = y;
2899 
2901  {
2902  Pt.x += Parent->rcClient.left;
2903  Pt.y += Parent->rcClient.top;
2904  }
2905 
2906  if (!IntPtInWindow(Parent, Pt.x, Pt.y)) return NULL;
2907 
2908  if ((List = IntWinListChildren(Parent)))
2909  {
2910  for (phWnd = List; *phWnd; phWnd++)
2911  {
2912  PWND Child;
2913  if ((Child = ValidateHwndNoErr(*phWnd)))
2914  {
2915  if ( Child->style & WS_VISIBLE && IntPtInWindow(Child, Pt.x, Pt.y) )
2916  {
2917  if ( Child->pcls->atomClassName != gpsi->atomSysClass[ICLS_BUTTON] ||
2918  (Child->style & BS_TYPEMASK) != BS_GROUPBOX )
2919  {
2921  return Child;
2922  }
2923  pwndHit = Child;
2924  }
2925  }
2926  }
2928  }
2929  return pwndHit ? pwndHit : Parent;
2930 }
2931 
2932 PWND APIENTRY
2934 {
2935  POINTL Pt;
2936  HWND *List, *phWnd;
2937  PWND pwndHit = NULL;
2938 
2939  Pt.x = x;
2940  Pt.y = y;
2941 
2943  {
2944  if (Parent->ExStyle & WS_EX_LAYOUTRTL)
2945  Pt.x = Parent->rcClient.right - Pt.x;
2946  else
2947  Pt.x += Parent->rcClient.left;
2948  Pt.y += Parent->rcClient.top;
2949  }
2950 
2951  if (!IntPtInWindow(Parent, Pt.x, Pt.y)) return NULL;
2952 
2953  if ((List = IntWinListChildren(Parent)))
2954  {
2955  for (phWnd = List; *phWnd; phWnd++)
2956  {
2957  PWND Child;
2958  if ((Child = ValidateHwndNoErr(*phWnd)))
2959  {
2960  if (uiFlags & (CWP_SKIPINVISIBLE|CWP_SKIPDISABLED))
2961  {
2962  if (!(Child->style & WS_VISIBLE) && (uiFlags & CWP_SKIPINVISIBLE)) continue;
2963  if ((Child->style & WS_DISABLED) && (uiFlags & CWP_SKIPDISABLED)) continue;
2964  }
2965 
2966  if (uiFlags & CWP_SKIPTRANSPARENT)
2967  {
2968  if (Child->ExStyle & WS_EX_TRANSPARENT) continue;
2969  }
2970 
2971  if (IntPtInWindow(Child, Pt.x, Pt.y))
2972  {
2973  pwndHit = Child;
2974  break;
2975  }
2976  }
2977  }
2979  }
2980  return pwndHit ? pwndHit : Parent;
2981 }
2982 
2983 HDWP
2984 FASTCALL
2986  HWND hwnd,
2987  HWND hwndAfter,
2988  INT x,
2989  INT y,
2990  INT cx,
2991  INT cy,
2992  UINT flags )
2993 {
2994  PSMWP pDWP;
2995  int i;
2996  HDWP retvalue = hdwp;
2997 
2998  TRACE("hdwp %p, hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
2999  hdwp, hwnd, hwndAfter, x, y, cx, cy, flags);
3000 
3001  if (flags & ~(SWP_NOSIZE | SWP_NOMOVE |
3006  {
3008  return NULL;
3009  }
3010 
3011  if (!(pDWP = (PSMWP)UserGetObject(gHandleTable, hdwp, TYPE_SETWINDOWPOS)))
3012  {
3014  return NULL;
3015  }
3016 
3017  for (i = 0; i < pDWP->ccvr; i++)
3018  {
3019  if (pDWP->acvr[i].pos.hwnd == hwnd)
3020  {
3021  /* Merge with the other changes */
3022  if (!(flags & SWP_NOZORDER))
3023  {
3024  pDWP->acvr[i].pos.hwndInsertAfter = hwndAfter;
3025  }
3026  if (!(flags & SWP_NOMOVE))
3027  {
3028  pDWP->acvr[i].pos.x = x;
3029  pDWP->acvr[i].pos.y = y;
3030  }
3031  if (!(flags & SWP_NOSIZE))
3032  {
3033  pDWP->acvr[i].pos.cx = cx;
3034  pDWP->acvr[i].pos.cy = cy;
3035  }
3036  pDWP->acvr[i].pos.flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
3040  pDWP->acvr[i].pos.flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
3042  goto END;
3043  }
3044  }
3045  if (pDWP->ccvr >= pDWP->ccvrAlloc)
3046  {
3047  PCVR newpos = ExAllocatePoolWithTag(PagedPool, pDWP->ccvrAlloc * 2 * sizeof(CVR), USERTAG_SWP);
3048  if (!newpos)
3049  {
3050  retvalue = NULL;
3051  goto END;
3052  }
3053  RtlZeroMemory(newpos, pDWP->ccvrAlloc * 2 * sizeof(CVR));
3054  RtlCopyMemory(newpos, pDWP->acvr, pDWP->ccvrAlloc * sizeof(CVR));
3056  pDWP->ccvrAlloc *= 2;
3057  pDWP->acvr = newpos;
3058  }
3059  pDWP->acvr[pDWP->ccvr].pos.hwnd = hwnd;
3060  pDWP->acvr[pDWP->ccvr].pos.hwndInsertAfter = hwndAfter;
3061  pDWP->acvr[pDWP->ccvr].pos.x = x;
3062  pDWP->acvr[pDWP->ccvr].pos.y = y;
3063  pDWP->acvr[pDWP->ccvr].pos.cx = cx;
3064  pDWP->acvr[pDWP->ccvr].pos.cy = cy;
3065  pDWP->acvr[pDWP->ccvr].pos.flags = flags;
3066  pDWP->acvr[pDWP->ccvr].hrgnClip = NULL;
3067  pDWP->acvr[pDWP->ccvr].hrgnInterMonitor = NULL;
3068  pDWP->ccvr++;
3069 END:
3070  return retvalue;
3071 }
3072 
3074 {
3075  PSMWP pDWP;
3076  PCVR winpos;
3077  BOOL res = TRUE;
3078  int i;
3079 
3080  TRACE("%p\n", hdwp);
3081 
3082  if (!(pDWP = (PSMWP)UserGetObject(gHandleTable, hdwp, TYPE_SETWINDOWPOS)))
3083  {
3085  return FALSE;
3086  }
3087 
3088  for (i = 0, winpos = pDWP->acvr; res && i < pDWP->ccvr; i++, winpos++)
3089  {
3090  PWND pwnd;
3092 
3093  TRACE("hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
3094  winpos->pos.hwnd, winpos->pos.hwndInsertAfter, winpos->pos.x, winpos->pos.y,
3095  winpos->pos.cx, winpos->pos.cy, winpos->pos.flags);
3096 
3097  pwnd = ValidateHwndNoErr(winpos->pos.hwnd);
3098  if (!pwnd)
3099  continue;
3100 
3101  UserRefObjectCo(pwnd, &Ref);
3102 
3103  if ( sAsync )
3104  {
3105  LRESULT lRes;
3107  if ( ppos )
3108  {
3109  *ppos = winpos->pos;
3110  /* Yes it's a pointer inside Win32k! */
3111  lRes = co_IntSendMessageNoWait( winpos->pos.hwnd, WM_ASYNC_SETWINDOWPOS, 0, (LPARAM)ppos);
3112  /* We handle this the same way as Event Hooks and Hooks. */
3113  if ( !lRes )
3114  {
3116  }
3117  }
3118  }
3119  else
3120  res = co_WinPosSetWindowPos( pwnd,
3121  winpos->pos.hwndInsertAfter,
3122  winpos->pos.x,
3123  winpos->pos.y,
3124  winpos->pos.cx,
3125  winpos->pos.cy,
3126  winpos->pos.flags);
3127 
3128  // Hack to pass tests.... Must have some work to do so clear the error.
3129  if (res && (winpos->pos.flags & (SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER)) == SWP_NOZORDER )
3131 
3132  UserDerefObjectCo(pwnd);
3133  }
3135  UserDereferenceObject(pDWP);
3137  return res;
3138 }
3139 
3140 /*
3141  * @implemented
3142  */
3143 HWND APIENTRY
3145  LONG x,
3146  LONG y,
3147  UINT uiFlags)
3148 {
3149  PWND pwndParent;
3150  TRACE("Enter NtUserChildWindowFromPointEx\n");
3152  if ((pwndParent = UserGetWindowObject(hwndParent)))
3153  {
3154  pwndParent = IntChildWindowFromPointEx(pwndParent, x, y, uiFlags);
3155  }
3156  UserLeave();
3157  TRACE("Leave NtUserChildWindowFromPointEx\n");
3158  return pwndParent ? UserHMGetHandle(pwndParent) : NULL;
3159 }
3160 
3161 /*
3162  * @implemented
3163  */
3164 BOOL APIENTRY
3166  BOOL bAsync)
3167 {
3168  BOOL Ret;
3169  TRACE("Enter NtUserEndDeferWindowPosEx\n");
3171  Ret = IntEndDeferWindowPosEx(WinPosInfo, bAsync);
3172  TRACE("Leave NtUserEndDeferWindowPosEx, ret=%i\n", Ret);
3173  UserLeave();
3174  return Ret;
3175 }
3176 
3177 /*
3178  * @implemented
3179  */
3180 HDWP APIENTRY
3181 NtUserDeferWindowPos(HDWP WinPosInfo,
3182  HWND Wnd,
3183  HWND WndInsertAfter,
3184  int x,
3185  int y,
3186  int cx,
3187  int cy,
3188  UINT Flags)
3189 {
3190  PWND pWnd, pWndIA;
3191  HDWP Ret = NULL;
3195 
3196  TRACE("Enter NtUserDeferWindowPos\n");
3198 
3199  if ( Flags & Tmp )
3200  {
3202  goto Exit;
3203  }
3204 
3205  pWnd = UserGetWindowObject(Wnd);
3206  if (!pWnd || UserIsDesktopWindow(pWnd) || UserIsMessageWindow(pWnd))
3207  {
3208  goto Exit;
3209  }
3210 
3211  if ( WndInsertAfter &&
3212  WndInsertAfter != HWND_BOTTOM &&
3213  WndInsertAfter != HWND_TOPMOST &&
3214  WndInsertAfter != HWND_NOTOPMOST )
3215  {
3216  pWndIA = UserGetWindowObject(WndInsertAfter);
3217  if (!pWndIA || UserIsDesktopWindow(pWndIA) || UserIsMessageWindow(pWndIA))
3218  {
3219  goto Exit;
3220  }
3221  }
3222 
3223  Ret = IntDeferWindowPos(WinPosInfo, Wnd, WndInsertAfter, x, y, cx, cy, Flags);
3224 
3225 Exit:
3226  TRACE("Leave NtUserDeferWindowPos, ret=%p\n", Ret);
3227  UserLeave();
3228  return Ret;
3229 }
3230 
3231 /*
3232  * @implemented
3233  */
3236  LPRECT rectWnd,
3237  LPPOINT ptIcon)
3238 {
3239  PWND Window;
3240  DWORD Ret = 0;
3241  BOOL Hit = FALSE;
3242  WINDOWPLACEMENT wndpl;
3243 
3244  UserEnterShared();
3245 
3246  if (!(Window = UserGetWindowObject(hWnd)))
3247  {
3248  Hit = FALSE;
3249  goto Exit;
3250  }
3251 
3252  _SEH2_TRY
3253  {
3254  if(rectWnd)
3255  {
3256  ProbeForWrite(rectWnd,
3257  sizeof(RECT),
3258  1);
3259  }
3260  if(ptIcon)
3261  {
3262  ProbeForWrite(ptIcon,
3263  sizeof(POINT),
3264  1);
3265  }
3266 
3267  }
3269  {
3271  Hit = TRUE;
3272  }
3273  _SEH2_END;
3274 
3275  wndpl.length = sizeof(WINDOWPLACEMENT);
3276 
3277  if (IntGetWindowPlacement(Window, &wndpl) && !Hit)
3278  {
3279  _SEH2_TRY
3280  {
3281  if (rectWnd)
3282  {
3283  RtlCopyMemory(rectWnd, &wndpl.rcNormalPosition , sizeof(RECT));
3284  }
3285  if (ptIcon)
3286  {
3287  RtlCopyMemory(ptIcon, &wndpl.ptMinPosition, sizeof(POINT));
3288  }
3289 
3290  }
3292  {
3294  Hit = TRUE;
3295  }
3296  _SEH2_END;
3297 
3298  if (!Hit) Ret = wndpl.showCmd;
3299  }
3300 Exit:
3301  UserLeave();
3302  return Ret;
3303 }
3304 
3305 /*
3306  * @implemented
3307  */
3308 BOOL APIENTRY
3310  WINDOWPLACEMENT *lpwndpl)
3311 {
3312  PWND Wnd;
3313  WINDOWPLACEMENT Safepl;
3314  NTSTATUS Status;
3316 
3317  TRACE("Enter NtUserGetWindowPlacement\n");
3318  UserEnterShared();
3319 
3320  if (!(Wnd = UserGetWindowObject(hWnd)))
3321  {
3322  RETURN( FALSE);
3323  }
3324 
3325  Status = MmCopyFromCaller(&Safepl, lpwndpl, sizeof(WINDOWPLACEMENT));
3326  if (!NT_SUCCESS(Status))
3327  {
3329  RETURN( FALSE);
3330  }
3331 
3332  Safepl.length = sizeof(WINDOWPLACEMENT);
3333 
3334  IntGetWindowPlacement(Wnd, &Safepl);
3335 
3336  Status = MmCopyToCaller(lpwndpl, &Safepl, sizeof(WINDOWPLACEMENT));
3337  if (!NT_SUCCESS(Status))
3338  {
3340  RETURN( FALSE);
3341  }
3342 
3343  RETURN( TRUE);
3344 
3345 CLEANUP:
3346  TRACE("Leave NtUserGetWindowPlacement, ret=%i\n",_ret_);
3347  UserLeave();
3348  END_CLEANUP;
3349 }
3350 
3351 DWORD
3352 APIENTRY
3354  HWND hWnd,
3355  UINT cmd, // Wine SW_ commands
3356  BOOL Hide)
3357 {
3358  PWND pWnd;
3359 
3360  TRACE("Enter NtUserMinMaximize\n");
3362 
3363  pWnd = UserGetWindowObject(hWnd);
3364  if (!pWnd || UserIsDesktopWindow(pWnd) || UserIsMessageWindow(pWnd))
3365  {
3366  goto Exit;
3367  }
3368 
3369  if ( cmd > SW_MAX || pWnd->state2 & WNDS2_INDESTROY)
3370  {
3372  goto Exit;
3373  }
3374 
3375  cmd |= Hide ? SW_HIDE : 0;
3376 
3377  co_WinPosShowWindow(pWnd, cmd);
3378 
3379 Exit:
3380  TRACE("Leave NtUserMinMaximize\n");
3381  UserLeave();
3382  return 0; // Always NULL?
3383 }
3384 
3385 /*
3386  * @implemented
3387  */
3388 BOOL APIENTRY
3390  HWND hWnd,
3391  int X,
3392  int Y,
3393  int nWidth,
3394  int nHeight,
3395  BOOL bRepaint)
3396 {
3397  return NtUserSetWindowPos(hWnd, 0, X, Y, nWidth, nHeight,
3398  (bRepaint ? SWP_NOZORDER | SWP_NOACTIVATE :
3400 }
3401 
3402 /*
3403  * @implemented
3404  */
3405 HWND APIENTRY
3407  LONG x,
3408  LONG y)
3409 {
3410  PWND pwndParent;
3411  TRACE("Enter NtUserRealChildWindowFromPoint\n");
3412  UserEnterShared();
3413  if ((pwndParent = UserGetWindowObject(Parent)))
3414  {
3415  pwndParent = IntRealChildWindowFromPoint(pwndParent, x, y);
3416  }
3417  UserLeave();
3418  TRACE("Leave NtUserRealChildWindowFromPoint\n");
3419  return pwndParent ? UserHMGetHandle(pwndParent) : NULL;
3420 }
3421 
3422 /*
3423  * @implemented
3424  */
3425 BOOL APIENTRY
3427  HWND hWnd,
3428  HWND hWndInsertAfter,
3429  int X,
3430  int Y,
3431  int cx,
3432  int cy,
3433  UINT uFlags)
3434 {
3436  PWND Window, pWndIA;
3437  BOOL ret;
3439 
3440  TRACE("Enter NtUserSetWindowPos\n");
3442 
3443  if (!(Window = UserGetWindowObject(hWnd)) ||
3445  {
3446  ERR("NtUserSetWindowPos bad window handle!\n");
3447  RETURN(FALSE);
3448  }
3449 
3450  if ( hWndInsertAfter != HWND_TOP &&
3451  hWndInsertAfter != HWND_BOTTOM &&
3452  hWndInsertAfter != HWND_TOPMOST &&
3453  hWndInsertAfter != HWND_NOTOPMOST )
3454  {
3455  if (!(pWndIA = UserGetWindowObject(hWndInsertAfter)) ||
3456  UserIsDesktopWindow(pWndIA) || UserIsMessageWindow(pWndIA))
3457  {
3458  ERR("NtUserSetWindowPos bad insert window handle!\n");
3459  RETURN(FALSE);
3460  }
3461  }
3462 
3463  /* First make sure that coordinates are valid for WM_WINDOWPOSCHANGING */
3464  if (!(uFlags & SWP_NOMOVE))
3465  {
3466  if (X < -32768) X = -32768;
3467  else if (X > 32767) X = 32767;
3468  if (Y < -32768) Y = -32768;
3469  else if (Y > 32767) Y = 32767;
3470  }
3471  if (!(uFlags & SWP_NOSIZE))
3472  {
3473  if (cx < 0) cx = 0;
3474  else if (cx > 32767) cx = 32767;
3475  if (cy < 0) cy = 0;
3476  else if (cy > 32767) cy = 32767;
3477  }
3478 
3479  UserRefObjectCo(Window, &Ref);
3480  ret = co_WinPosSetWindowPos(Window, hWndInsertAfter, X, Y, cx, cy, uFlags);
3482 
3483  RETURN(ret);
3484 
3485 CLEANUP:
3486  TRACE("Leave NtUserSetWindowPos, ret=%i\n",_ret_);
3487  UserLeave();
3488  END_CLEANUP;
3489 }
3490 
3491 /*
3492  * @implemented
3493  */
3494 INT APIENTRY
3496  HWND hWnd,
3497  HRGN hRgn,
3498  BOOL bRedraw)
3499 {
3500  HRGN hrgnCopy = NULL;
3501  PWND Window;
3503  BOOLEAN Ret = FALSE;
3505 
3506  TRACE("Enter NtUserSetWindowRgn\n");
3508 
3509  if (!(Window = UserGetWindowObject(hWnd)) ||
3511  {
3512  RETURN( 0);
3513  }
3514 
3515  if (hRgn) // The region will be deleted in user32.
3516  {
3517  if (GreIsHandleValid(hRgn))
3518  {
3519  hrgnCopy = NtGdiCreateRectRgn(0, 0, 0, 0);
3520  /* The coordinates of a window's window region are relative to the
3521  upper-left corner of the window, not the client area of the window. */
3522  NtGdiCombineRgn( hrgnCopy, hRgn, 0, RGN_COPY);
3523  }
3524  else
3525  RETURN( 0);
3526  }
3527 
3529  if (hrgnCopy)
3530  {
3531  Window->hrgnNewFrame = hrgnCopy; // Should be PSMWP->acvr->hrgnClip
3532  }
3533  else
3534  {
3535  Window->hrgnNewFrame = HRGN_WINDOW;
3536  }
3538  Ret = co_WinPosSetWindowPos(Window, HWND_TOP, 0, 0, 0, 0, bRedraw ? flags : (flags|SWP_NOREDRAW) );
3539 
3540  RETURN( (INT)Ret);
3541 
3542 CLEANUP:
3543  TRACE("Leave NtUserSetWindowRgn, ret=%i\n",_ret_);
3544  UserLeave();
3545  END_CLEANUP;
3546 }
3547 
3548 /*
3549  * @implemented
3550  */
3553  HWND hwnd,
3554  UINT showCmd,
3555  LPRECT lprect,
3556  LPPOINT lppt)
3557 {
3558  WINDOWPLACEMENT wndpl;
3559  UINT flags;
3560  PWND Wnd;
3561  RECT rect;
3562  POINT pt = {0};
3565 
3566  TRACE("Enter NtUserSetWindowPlacement\n");
3568 
3569  if (!(Wnd = UserGetWindowObject(hwnd)) || // FIXME:
3571  {
3572  RETURN( FALSE);
3573  }
3574 
3575  _SEH2_TRY
3576  {
3577  if (lppt)
3578  {
3579  ProbeForRead(lppt, sizeof(POINT), 1);
3580  RtlCopyMemory(&pt, lppt, sizeof(POINT));
3581  }
3582  if (lprect)
3583  {
3584  ProbeForRead(lprect, sizeof(RECT), 1);
3585  RtlCopyMemory(&rect, lprect, sizeof(RECT));
3586  }
3587  }
3589  {
3592  }
3593  _SEH2_END
3594 
3595  wndpl.length = sizeof(wndpl);
3596  wndpl.showCmd = showCmd;
3597  wndpl.flags = flags = 0;
3598 
3599  if ( lppt )
3600  {
3601  flags |= PLACE_MIN;
3602  wndpl.flags |= WPF_SETMINPOSITION;
3603  wndpl.ptMinPosition = pt;
3604  }
3605  if ( lprect )
3606  {
3607  flags |= PLACE_RECT;
3608  wndpl.rcNormalPosition = rect;
3609  }
3610 
3611  UserRefObjectCo(Wnd, &Ref);
3612  IntSetWindowPlacement(Wnd, &wndpl, flags);
3613  UserDerefObjectCo(Wnd);
3614  RETURN(TRUE);
3615 
3616 CLEANUP:
3617  TRACE("Leave NtUserSetWindowPlacement, ret=%i\n",_ret_);
3618  UserLeave();
3619  END_CLEANUP;
3620 }
3621 
3622 /*
3623  * @implemented
3624  */
3625 BOOL APIENTRY
3627  WINDOWPLACEMENT *lpwndpl)
3628 {
3629  PWND Wnd;
3630  WINDOWPLACEMENT Safepl;
3631  UINT Flags;
3634 
3635  TRACE("Enter NtUserSetWindowPlacement\n");
3637 
3638  if (!(Wnd = UserGetWindowObject(hWnd)) ||
3640  {
3641  RETURN( FALSE);
3642  }
3643 
3644  _SEH2_TRY
3645  {
3646  ProbeForRead(lpwndpl, sizeof(WINDOWPLACEMENT), 1);
3647  RtlCopyMemory(&Safepl, lpwndpl, sizeof(WINDOWPLACEMENT));
3648  }
3650  {
3653  }
3654  _SEH2_END
3655 
3656  if(Safepl.length != sizeof(WINDOWPLACEMENT))
3657  {
3658  RETURN( FALSE);
3659  }
3660 
3662  if (Safepl.flags & WPF_SETMINPOSITION) Flags |= PLACE_MIN;
3663  UserRefObjectCo(Wnd, &Ref);
3664  IntSetWindowPlacement(Wnd, &Safepl, Flags);
3665  UserDerefObjectCo(Wnd);
3666  RETURN(TRUE);
3667 
3668 CLEANUP:
3669  TRACE("Leave NtUserSetWindowPlacement, ret=%i\n",_ret_);
3670  UserLeave();
3671  END_CLEANUP;
3672 }
3673 
3674 /*
3675  * @implemented
3676  */
3677 BOOL APIENTRY
3679 {
3680  PWND Window;
3681  BOOL ret;
3684 
3685  TRACE("Enter NtUserShowWindowAsync\n");
3687 
3688  if (!(Window = UserGetWindowObject(hWnd)) ||
3690  {
3691  RETURN(FALSE);
3692  }
3693 
3694  if ( nCmdShow > SW_MAX )
3695  {
3697  RETURN(FALSE);
3698  }
3699 
3700  UserRefObjectCo(Window, &Ref);
3703  if (-1 == (int) ret || !ret) ret = FALSE;
3704 
3705  RETURN(ret);
3706 
3707 CLEANUP:
3708  TRACE("Leave NtUserShowWindowAsync, ret=%i\n",_ret_);
3709  UserLeave();
3710  END_CLEANUP;
3711 }
3712 
3713 /*
3714  * @implemented
3715  */
3716 BOOL APIENTRY
3718 {
3719  PWND Window;
3720  BOOL ret;
3723 
3724  TRACE("Enter NtUserShowWindow hWnd %p SW_ %d\n",hWnd, nCmdShow);
3726 
3727  if (!(Window = UserGetWindowObject(hWnd)) ||
3729  {
3730  RETURN(FALSE);
3731  }
3732 
3733  if ( nCmdShow > SW_MAX || Window->state2 & WNDS2_INDESTROY)
3734  {
3736  RETURN(FALSE);
3737  }
3738 
3739  UserRefObjectCo(Window, &Ref);
3740  ret = co_WinPosShowWindow(Window, nCmdShow);
3742 
3743  RETURN(ret);
3744 
3745 CLEANUP:
3746  TRACE("Leave NtUserShowWindow, ret=%i\n",_ret_);
3747  UserLeave();
3748  END_CLEANUP;
3749 }
3750 
3751 
3752 /*
3753  * @implemented
3754  */
3755 HWND APIENTRY
3757 {
3758  POINT pt;
3759  HWND Ret;
3761  USHORT hittest;
3764 
3765  TRACE("Enter NtUserWindowFromPoint\n");
3767 
3769  {
3770  //PTHREADINFO pti;
3771 
3772  pt.x = X;
3773  pt.y = Y;
3774 
3775  // Hmm... Threads live on desktops thus we have a reference on the desktop and indirectly the desktop window.
3776  // It is possible this referencing is useless, though it should not hurt...
3778 
3779  //pti = PsGetCurrentThreadWin32Thread();
3781 
3782  if (Window)
3783  {
3784  Ret = UserHMGetHandle(Window);
3785 
3786  RETURN( Ret);
3787  }
3788  }
3789 
3790  RETURN( NULL);
3791 
3792 CLEANUP:
3794 
3795  TRACE("Leave NtUserWindowFromPoint, ret=%p\n", _ret_);
3796  UserLeave();
3797  END_CLEANUP;
3798 }
3799 
3800 /* EOF */
#define RDW_NOINTERNALPAINT
Definition: winuser.h:1207
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
#define RDW_NOCHILDREN
Definition: winuser.h:1212
static VOID FASTCALL WinPosFindIconPos(PWND Window, POINT *Pos)
Definition: winpos.c:779
POINT ptMinTrackSize
Definition: winuser.h:3610
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
PUSER_MESSAGE_QUEUE gpqForeground
Definition: focus.c:13
#define WS_DISABLED
Definition: pedump.c:621
#define GA_ROOT
Definition: winuser.h:2769
__kernel_entry W32KAPI HRGN APIENTRY NtGdiCreateRectRgn(_In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
#define SW_MAX
Definition: winuser.h:776
#define WS_THICKFRAME
Definition: pedump.c:630
BOOL WINAPI ValidateRgn(_In_ HWND, _In_opt_ HRGN)
USERSTARTUPINFO usi
Definition: win32.h:274
VOID FASTCALL UserEnterShared(VOID)
Definition: ntuser.c:242
PWND APIENTRY IntChildWindowFromPointEx(PWND Parent, LONG x, LONG y, UINT uiFlags)
Definition: winpos.c:2933
BOOL APIENTRY NtUserGetWindowPlacement(HWND hWnd, WINDOWPLACEMENT *lpwndpl)
Definition: winpos.c:3309
#define WS_EX_WINDOWEDGE
Definition: winuser.h:407
#define SW_SHOWDEFAULT
Definition: winuser.h:774
#define IN
Definition: typedefs.h:39
#define SW_NORMAL
Definition: winuser.h:763
BOOL APIENTRY NtUserShowWindowAsync(HWND hWnd, LONG nCmdShow)
Definition: winpos.c:3678
#define max(a, b)
Definition: svc.c:63
BOOL APIENTRY NtUserShowWindow(HWND hWnd, LONG nCmdShow)
Definition: winpos.c:3717
DWORD ExStyle
Definition: ntuser.h:683
#define ERROR_INVALID_DWP_HANDLE
Definition: winerror.h:886
BOOL FASTCALL UserDeleteObject(HANDLE h, HANDLE_TYPE type)
Definition: object.c:717
BOOL NTAPI GreDeleteObject(HGDIOBJ hobj)
Definition: gdiobj.c:1158
#define HTTRANSPARENT
Definition: winuser.h:2453
VOID FASTCALL co_MsqInsertMouseMessage(MSG *Msg, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook)
Definition: msgqueue.c:580
HRGN hrgnClip
Definition: winpos.h:16
#define DCX_CLIPSIBLINGS
Definition: winuser.h:2103
BOOL APIENTRY NtUserMoveWindow(HWND hWnd, int X, int Y, int nWidth, int nHeight, BOOL bRepaint)
Definition: winpos.c:3389
PDESKTOPINFO pDeskInfo
Definition: desktop.h:8
#define CLEANUP
Definition: ntuser.h:5
#define WVR_ALIGNRIGHT
Definition: winuser.h:2498
BOOL NTAPI GreIsHandleValid(HGDIOBJ hobj)
Definition: gdiobj.c:1146
VOID FASTCALL UserSyncAndPaintWindows(PWND pWnd, ULONG Flags)
Definition: painting.c:620
struct _WINDOWPLACEMENT WINDOWPLACEMENT
struct _DESKTOP * rpdesk
Definition: ntuser.h:186
VOID FASTCALL WinPosInitInternalPos(PWND Wnd, RECTL *RestoreRect)
Definition: winpos.c:478
#define SW_SHOWNOACTIVATE
Definition: winuser.h:768
long y
Definition: polytest.cpp:48
POINT ptReserved
Definition: winuser.h:3607
BOOL FASTCALL IntClientToScreen(PWND Wnd, LPPOINT lpPoint)
Definition: winpos.c:198
#define ERROR_SUCCESS
Definition: deptool.c:10
BOOL FASTCALL IsChildVisible(PWND pWnd)
Definition: winpos.c:225
static void make_rect_onscreen(RECT *rect)
Definition: winpos.c:622
VOID FASTCALL co_VIS_WindowLayoutChanged(PWND Wnd, PREGION NewlyExposed)
Definition: vis.c:145
FORCEINLINE VOID RECTL_vSetEmptyRect(_Out_ RECTL *prcl)
Definition: rect.h:20
POINT ptMaxSize
Definition: winuser.h:3608
#define Y(I)
HWND FASTCALL co_UserSetFocus(PWND Window)
Definition: focus.c:1309
#define SM_CYMINTRACK
Definition: winuser.h:992
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:194
long x
Definition: polytest.cpp:48
VOID FASTCALL RECTL_vInflateRect(_Inout_ RECTL *rect, _In_ INT dx, _In_ INT dy)
Definition: rect.c:101
Definition: ftp_var.h:139
#define SIZE_MAXIMIZED
Definition: winuser.h:2487
#define TRUE
Definition: types.h:120
#define pt(x, y)
Definition: drawing.c:79
#define SM_CXMINIMIZED
Definition: winuser.h:1014
#define SW_HIDE
Definition: winuser.h:762
#define CWP_SKIPTRANSPARENT
Definition: winuser.h:210
static void make_point_onscreen(POINT *pt)
Definition: winpos.c:652
#define ERROR(name)
Definition: error_private.h:53
#define SW_SHOWMAXIMIZED
Definition: winuser.h:767
_In_ BOOLEAN Create
Definition: pstypes.h:527
#define ASSERT_REFS_CO(_obj_)
Definition: userfuncs.h:14
#define WM_NCCALCSIZE
Definition: winuser.h:1672
VOID UserGetWindowBorders(DWORD Style, DWORD ExStyle, SIZE *Size, BOOL WithClient)
Definition: winpos.c:886
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1827
#define WNDS_SENDNCPAINT
Definition: ntuser.h:599
VOID FASTCALL IntNotifyWinEvent(DWORD Event, PWND pWnd, LONG idObject, LONG idChild, DWORD flags)
Definition: event.c:179
DWORD IntGetWindowBorders(DWORD Style, DWORD ExStyle)
Definition: winpos.c:913
#define MAKELPARAM(l, h)
Definition: winuser.h:3988
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
#define SIZE_RESTORED
Definition: winuser.h:2485
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1721
LONG NTSTATUS
Definition: precomp.h:26
VOID FASTCALL IntSendNCPaint(PWND pWnd, HRGN hRgn)
Definition: painting.c:348
static HDC
Definition: imagelist.c:92
PSERVERINFO gpsi
Definition: imm.c:17
#define SWP_AGG_STATUSFLAGS
Definition: winpos.c:23
ush Pos
Definition: deflate.h:92
#define OBJID_WINDOW
Definition: winable.h:15
#define SW_SHOWMINNOACTIVE
Definition: winuser.h:771
HWND hWnd
Definition: settings.c:17
BOOL FASTCALL IntGetWindowPlacement(PWND Wnd, WINDOWPLACEMENT *lpwndpl)
Definition: winpos.c:557
#define WS_EX_TRANSPARENT
Definition: pedump.c:649
#define NULLREGION
Definition: wingdi.h:361
BOOL APIENTRY NtUserSetWindowPos(HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags)
Definition: winpos.c:3426
LONG top
Definition: windef.h:307
#define WS_EX_LAYOUTRTL
Definition: winuser.h:390
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:27
#define HSHELL_WINDOWCREATED
Definition: winuser.h:1245
long bottom
Definition: polytest.cpp:53
static BOOL IntValidateParent(PWND Child, PREGION ValidateRgn)
Definition: winpos.c:1055
BOOL FASTCALL UserSetActiveWindow(_In_opt_ PWND Wnd)
Definition: focus.c:1255
static HRGN hRgn
Definition: mapping.c:33
#define DCX_USESTYLE
Definition: GetDCEx.c:10
#define WS_DLGFRAME
Definition: pedump.c:626
#define WM_SHOWWINDOW
Definition: winuser.h:1615
HWND hwndInsertAfter
Definition: winuser.h:3569
#define STARTF_USEPOSITION
Definition: winbase.h:490
BOOL FASTCALL IntShowOwnedPopups(PWND OwnerWnd, BOOL fShow)
Definition: window.c:4647
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
#define WM_MOVE
Definition: winuser.h:1597
#define WS_SIZEBOX
Definition: pedump.c:642
#define HWND_TOPMOST
Definition: winuser.h:1198
#define HWND_TOP
Definition: winuser.h:1197
#define MmCopyFromCaller
Definition: polytest.cpp:29
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
#define PLACE_MIN
Definition: winpos.c:29
HDC FASTCALL UserGetDCEx(PWND Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:644
BOOL FASTCALL IntEndDeferWindowPosEx(HDWP hdwp, BOOL sAsync)
Definition: winpos.c:3073
static BOOL FASTCALL co_WinPosDoWinPosChanging(PWND Window, PWINDOWPOS WinPos, PRECTL WindowRect, PRECTL ClientRect)
Definition: winpos.c:1265
#define MmCopyToCaller(x, y, z)
Definition: mmcopy.h:19
#define WM_NCHITTEST
Definition: winuser.h:1673
UINT_PTR WPARAM
Definition: windef.h:207
#define WNDS_SENDSIZEMOVEMSGS
Definition: ntuser.h:592
BOOL FASTCALL REGION_bOffsetRgn(_Inout_ PREGION prgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:2727
#define WPF_RESTORETOMAXIMIZED
Definition: winuser.h:2512
#define WS_CHILD
Definition: pedump.c:617
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical 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:728
#define SM_CYMAXTRACK
Definition: winuser.h:1017
RECT rcClient
Definition: ntuser.h:696
#define RDW_FRAME
Definition: winuser.h:1202
LONG left
Definition: windef.h:306
FORCEINLINE BOOL IntPtInWindow(PWND pwnd, INT x, INT y)
Definition: winpos.h:30
#define SWP_NOZORDER
Definition: winuser.h:1237
struct _WND::@4879 InternalPos
UINT uFlags
Definition: api.c:59
#define SM_CYFRAME
Definition: winuser.h:990
#define SM_CXFRAME
Definition: winuser.h:988
if(dx==0 &&dy==0)
Definition: linetemp.h:174
#define SW_SHOWMINIMIZED
Definition: winuser.h:765
INT APIENTRY NtUserSetWindowRgn(HWND hWnd, HRGN hRgn, BOOL bRedraw)
Definition: winpos.c:3495
#define WS_CLIPCHILDREN
Definition: pedump.c:619
#define SW_RESTORE
Definition: winuser.h:773
VOID FASTCALL co_WinPosActivateOtherWindow(PWND Wnd)
Definition: winpos.c:395
DWORD APIENTRY NtUserGetInternalWindowPos(HWND hWnd, LPRECT rectWnd, LPPOINT ptIcon)
Definition: winpos.c:3235
LONG right
Definition: windef.h:308
PREGION FASTCALL REGION_LockRgn(_In_ HRGN hrgn)
Definition: region.c:2377
#define FASTCALL
Definition: nt_native.h:50
#define HTNOWHERE
Definition: winuser.h:2454
#define WS_EX_TOOLWINDOW
Definition: winuser.h:404
PUSER_MESSAGE_QUEUE FASTCALL IntGetFocusMessageQueue(VOID)
Definition: desktop.c:1310
struct _DESKTOP * rpdesk
Definition: win32.h:93
int32_t INT
Definition: typedefs.h:58
#define BS_GROUPBOX
Definition: pedump.c:658
#define SWP_NOSENDCHANGING
Definition: winuser.h:1241
HWND APIENTRY NtUserWindowFromPoint(LONG X, LONG Y)
Definition: winpos.c:3756
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
& rect
Definition: startmenu.cpp:1413
WPARAM wParam
Definition: combotst.c:138
WORD FASTCALL UserGetMouseButtonsState(VOID)
Definition: mouse.c:22
#define DCX_INTERSECTRGN
Definition: winuser.h:2109
#define RETURN(x)
RECT rcWork
Definition: monitor.h:19
#define DCX_WINDOW
Definition: winuser.h:2100
#define WVR_ALIGNLEFT
Definition: winuser.h:2496
LONG y
Definition: windef.h:330
WINDOWPOS pos
Definition: winpos.h:5
_SEH2_TRY
Definition: create.c:4226
#define SWP_HIDEWINDOW
Definition: winuser.h:1231
#define WNDS_BEINGACTIVATED
Definition: ntuser.h:608
PPROCESSINFO ppi
Definition: win32.h:89
HDWP APIENTRY NtUserDeferWindowPos(HDWP WinPosInfo, HWND Wnd, HWND WndInsertAfter, int x, int y, int cx, int cy, UINT Flags)
Definition: winpos.c:3181
PMONITOR NTAPI UserMonitorFromRect(PRECTL pRect, DWORD dwFlags)
Definition: monitor.c:405
#define RGN_AND
Definition: wingdi.h:356
#define EMPTYPOINT(pt)
Definition: winpos.c:28
#define SWP_NOCOPYBITS
Definition: winuser.h:1233
long right
Definition: polytest.cpp:53
#define WVR_ALIGNTOP
Definition: winuser.h:2495
#define SM_CXSCREEN
Definition: winuser.h:953
Definition: window.c:28
#define WS_EX_MDICHILD
Definition: winuser.h:394
PREGION FASTCALL IntSysCreateRectpRgn(INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
Definition: region.c:2426
UINT style
Definition: ntuser.h:563
VOID FASTCALL IntLinkHwnd(PWND Wnd, HWND hWndPrev)
Definition: window.c:971
#define FALSE
Definition: types.h:117
HWND APIENTRY NtUserChildWindowFromPointEx(HWND hwndParent, LONG x, LONG y, UINT uiFlags)
Definition: winpos.c:3144
GLenum const GLfloat * params
Definition: glext.h:5645
DBG_DEFAULT_CHANNEL(UserWinpos)
#define WS_MINIMIZE
Definition: pedump.c:622
DWORD fnid
Definition: ntuser.h:688
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFDEVICE Child
Definition: wdffdo.h:533
INT ccvr
Definition: winpos.h:25
#define WM_CHILDACTIVATE
Definition: winuser.h:1625
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
HWND APIENTRY NtUserRealChildWindowFromPoint(HWND Parent, LONG x, LONG y)
Definition: winpos.c:3406
#define FNID_DESKTOP
Definition: ntuser.h:841
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:40
#define GA_PARENT
Definition: winuser.h:2768
HWND FASTCALL UserGetShellWindow(VOID)
Definition: window.c:3666
DWORD APIENTRY NtUserSetInternalWindowPos(HWND hwnd, UINT showCmd, LPRECT lprect, LPPOINT lppt)
Definition: winpos.c:3552
long top
Definition: polytest.cpp:53
#define CWP_SKIPINVISIBLE
Definition: winuser.h:208
#define SM_CYDLGFRAME
Definition: winuser.h:962
#define CWP_SKIPDISABLED
Definition: winuser.h:209
static HWND FASTCALL WinPosDoOwnedPopups(PWND Window, HWND hWndInsertAfter)
Definition: winpos.c:1353
#define CHILDID_SELF
Definition: winable.h:14
struct _WND * spwndOwner
Definition: ntuser.h:694
BOOL FASTCALL IntGetClientOrigin(PWND Window OPTIONAL, LPPOINT Point)
Definition: winpos.c:70
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:585
THRDESKHEAD head
Definition: ntuser.h:674
static LONG FASTCALL co_WinPosDoNCCALCSize(PWND Window, PWINDOWPOS WinPos, RECTL *WindowRect, RECTL *ClientRect, RECTL *validRects)
Definition: winpos.c:1178
static PWND co_WinPosSearchChildren(IN PWND ScopeWin, IN POINT *Point, IN OUT USHORT *HitTest, IN BOOL Ignore)
Definition: winpos.c:2773
Definition: object.h:3
#define MAKELONG(a, b)
Definition: typedefs.h:249
unsigned char BOOLEAN
#define DCX_KEEPCLIPRGN
Definition: undocuser.h:67
#define HAS_THINFRAME(Style, ExStyle)
Definition: window.h:16
#define HAS_THICKFRAME(Style, ExStyle)
Definition: window.h:12
#define WS_EX_DLGMODALFRAME
Definition: pedump.c:645
static HWND hwndParent
Definition: cryptui.c:300
DWORD APIENTRY NtUserMinMaximize(HWND hWnd, UINT cmd, BOOL Hide)
Definition: winpos.c:3353
#define HRGN_WINDOW
Definition: ntuser.h:344
#define SWP_ASYNCWINDOWPOS
Definition: winuser.h:1243
#define RGN_OR
Definition: wingdi.h:359
_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:426
__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)
LONG_PTR LPARAM
Definition: windef.h:208
GLint GLint bottom
Definition: glext.h:7726
#define WH_CBT
Definition: winuser.h:35
PTHREADINFO gptiCurrent
Definition: ntuser.c:15
#define WS_EX_NOACTIVATE
Definition: winuser.h:395
struct _WND * spwndNext
Definition: ntuser.h:690
Definition: region.h:7
UINT flags
Definition: winuser.h:3574
#define WEF_SETBYWNDPTI
Definition: ntuser.h:227
#define HTERROR
Definition: winuser.h:2452
#define STARTF_USESHOWWINDOW
Definition: winbase.h:488
#define SW_SHOW
Definition: winuser.h:769
PWND FASTCALL IntGetLastTopMostWindow(VOID)
Definition: winpos.c:237
#define WOC_RGN_CLIENT
Definition: winddi.h:1265
#define WS_MAXIMIZEBOX
Definition: pedump.c:632
#define SWP_AGG_NOGEOMETRYCHANGE
Definition: winpos.c:19
long left
Definition: polytest.cpp:53
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:126
INT FASTCALL IntGdiCombineRgn(PREGION prgnDest, PREGION prgnSrc1, PREGION prgnSrc2, INT iCombineMode)
Definition: region.c:2506
HWND FASTCALL UserGetForegroundWindow(VOID)
Definition: focus.c:1416
BOOL FASTCALL IntCheckFullscreen(PWND Window)
Definition: focus.c:79
Definition: infcodes.c:25
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:194
UINT FASTCALL co_WinPosGetMinMaxInfo(PWND Window, POINT *MaxSize, POINT *MaxPos, POINT *MinTrack, POINT *MaxTrack)
Definition: winpos.c:932
#define WS_MINIMIZED
Definition: undocuser.h:18
BOOLEAN FASTCALL co_WinPosShowWindow(PWND Wnd, INT Cmd)
Definition: winpos.c:2491
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:249
Status
Definition: gdiplustypes.h:24
#define UserHMGetHandle(obj)
Definition: ntuser.h:222
static BOOL FASTCALL WinPosFixupFlags(WINDOWPOS *WinPos, PWND Wnd)
Definition: winpos.c:1523
#define WS_CAPTION
Definition: pedump.c:624
VOID SelectWindowRgn(PWND Window, HRGN hRgnClip)
Definition: winpos.c:258
BOOL APIENTRY NtUserSetWindowPlacement(HWND hWnd, WINDOWPLACEMENT *lpwndpl)
Definition: winpos.c:3626
#define SM_CYSCREEN
Definition: winuser.h:954
#define HWND_BOTTOM
Definition: winuser.h:1195
#define TRACE(s)
Definition: solgame.cpp:4
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
const DWORD Style
Definition: appswitch.c:71
HRGN hrgnInterMonitor
Definition: winpos.h:17
#define ASSERT(a)
Definition: mode.c:44
r parent
Definition: btrfs.c:2979
UINT FASTCALL co_WinPosArrangeIconicWindows(PWND parent)
Definition: winpos.c:729
#define WS_ICONIC
Definition: pedump.c:641
Implementation of the Explorer desktop window.
Definition: desktop.h:51
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define WM_SIZE
Definition: winuser.h:1598
UINT InternalPosInitialized
Definition: ntuser.h:736
#define SM_CXDLGFRAME
Definition: winuser.h:960
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define SWP_NOACTIVATE
Definition: winuser.h:1232
static void Exit(void)
Definition: sock.c:1331
#define RDW_ERASE
Definition: winuser.h:1201
#define SWP_STATECHANGED
Definition: msg.c:42
BOOL FASTCALL IntGdiSetRegionOwner(HRGN hRgn, DWORD OwnerMask)
Definition: region.c:2478
#define ValidateHwndNoErr(hwnd)
Definition: precomp.h:84
#define WM_WINDOWPOSCHANGING
Definition: winuser.h:1648
#define WA_ACTIVE
Definition: winuser.h:2603
VOID FASTCALL co_IntPaintWindows(PWND Wnd, ULONG Flags, BOOL Recurse)
Definition: painting.c:403
#define SM_CXMINTRACK
Definition: winuser.h:991
Definition: winpos.h:3
#define GW_HWNDLAST
Definition: winuser.h:760
#define WPF_SETMINPOSITION
Definition: winuser.h:2513
#define WS_EX_LAYERED
Definition: winuser.h:389
BOOL FASTCALL RECTL_bIntersectRect(_Out_ RECTL *prclDst, _In_ const RECTL *prcl1, _In_ const RECTL *prcl2)
Definition: rect.c:55
void FASTCALL co_WinPosSendSizeMove(PWND Wnd)
Definition: winpos.c:2306
HRGN hrgnUpdate
Definition: ntuser.h:700
#define for
Definition: utility.h:88
unsigned long DWORD
Definition: ntddk_ex.h:95
#define DECLARE_RETURN(type)
Definition: ntuser.h:3
GLint left
Definition: glext.h:7726
LONG x
Definition: windef.h:329
Definition: winpos.h:20
#define SIZE_MINIMIZED
Definition: winuser.h:2486
BOOL FASTCALL IntIsWindow(HWND hWnd)
Definition: window.c:180
GLdouble GLdouble right
Definition: glext.h:10859
#define WVR_VALIDRECTS
Definition: winuser.h:2502
#define UserIsMessageWindow(pWnd)
Definition: desktop.h:197
#define SW_MINIMIZE
Definition: winuser.h:770
int Window
Definition: x11stubs.h:26
GLbitfield flags
Definition: glext.h:7161
#define CS_SAVEBITS
Definition: winuser.h:652
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
__kernel_entry W32KAPI INT APIENTRY NtGdiOffsetRgn(_In_ HRGN hrgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:3981
POINT ptMaxPosition
Definition: winuser.h:3609
LRESULT APIENTRY co_HOOK_CallHooks(INT HookId, INT Code, WPARAM wParam, LPARAM lParam)
Definition: hook.c:1103
#define WPF_MAXINIT
Definition: ntuser.h:670
FORCEINLINE BOOL RECTL_bPointInRect(_In_ const RECTL *prcl, _In_ INT x, _In_ INT y)
Definition: rect.h:52
VOID FASTCALL IntInvalidateWindows(PWND Wnd, PREGION Rgn, ULONG Flags)
Definition: painting.c:642
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1389
#define RDW_VALIDATE
Definition: winuser.h:1208
#define SM_CYBORDER
Definition: winuser.h:959
#define WPF_MININIT
Definition: ntuser.h:669
int ret
BOOL FASTCALL IntIsWindowVisible(PWND Wnd)
Definition: window.c:193
VOID FASTCALL DceResetActiveDCEs(PWND Window)
Definition: windc.c:816
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define SM_CYMINIMIZED
Definition: winuser.h:1015
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1446
Definition: sacdrv.h:278
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
#define SM_CXBORDER
Definition: winuser.h:958
static VOID FASTCALL WinPosInternalMoveWindow(PWND Window, INT MoveX, INT MoveY)
Definition: winpos.c:1493
#define RDW_NOERASE
Definition: winuser.h:1205
#define SWP_FRAMECHANGED
Definition: winuser.h:1230
HWND *FASTCALL IntWinListChildren(PWND Window)
Definition: window.c:278
#define WS_EX_TOPMOST
Definition: pedump.c:647
#define WM_SETVISIBLE
Definition: undocuser.h:31
BOOL FASTCALL IntScreenToClient(PWND Wnd, LPPOINT lpPoint)
Definition: winpos.c:212
RECT rcWindow
Definition: ntuser.h:695
#define GDI_OBJ_HMGR_POWNED
Definition: ntgdihdl.h:117
struct _WND * spwnd
Definition: ntuser.h:133
#define PLACE_MAX
Definition: winpos.c:30
BOOL UserHasWindowEdge(DWORD Style, DWORD ExStyle)
Definition: winpos.c:842
#define GW_HWNDFIRST
Definition: winuser.h:759
BOOLEAN valid
VOID FASTCALL SetLastNtError(NTSTATUS Status)
Definition: error.c:37
#define RDW_NOFRAME
Definition: winuser.h:1206
#define SW_SHOWNA
Definition: winuser.h:772
__kernel_entry W32KAPI INT APIENTRY NtGdiCombineRgn(_In_ HRGN hrgnDst, _In_ HRGN hrgnSrc1, _In_opt_ HRGN hrgnSrc2, _In_ INT iMode)
PWND FASTCALL UserGetAncestor(PWND Wnd, UINT Type)
Definition: window.c:3322
#define HSHELL_WINDOWDESTROYED
Definition: winuser.h:1246
#define RGN_COPY
Definition: wingdi.h:357
BOOL FASTCALL ActivateOtherWindowMin(PWND Wnd)
Definition: winpos.c:284
#define HCBT_MINMAX
Definition: winuser.h:56
#define SWP_NOSIZE
Definition: winuser.h:1235
#define ERR(fmt,...)
Definition: debug.h:110
Definition: ntuser.h:672
struct _USER_MESSAGE_QUEUE * MessageQueue
Definition: win32.h:90
FORCEINLINE VOID RECTL_vOffsetRect(_Inout_ RECTL *prcl, _In_ INT cx, _In_ INT cy)
Definition: rect.h:31
#define PLACE_RECT
Definition: winpos.c:31
POINT ptMinPosition
Definition: winuser.h:3273
INT FASTCALL IntMapWindowPoints(PWND FromWnd, PWND ToWnd, LPPOINT lpPoints, UINT cPoints)
Definition: winpos.c:143
#define WVR_REDRAW
Definition: winuser.h:2501
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:258
HWND FASTCALL IntGetDesktopWindow(VOID)
Definition: desktop.c:1377
static HDC hDC
Definition: 3dtext.c:33
FORCEINLINE VOID RECTL_vSetRect(_Out_ RECTL *prcl, _In_ LONG left, _In_ LONG top, _In_ LONG right, _In_ LONG bottom)
Definition: rect.h:5
#define DCX_CACHE
Definition: winuser.h:2101
VOID FASTCALL IntSetFocusMessageQueue(PUSER_MESSAGE_QUEUE NewQueue)
Definition: desktop.c:1322
HDWP FASTCALL IntDeferWindowPos(HDWP hdwp, HWND hwnd, HWND hwndAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:2985
#define SW_SHOWNORMAL
Definition: winuser.h:764
static VOID FASTCALL FixClientRect(PRECTL ClientRect, PRECTL WindowRect)
Definition: winpos.c:1079
#define IntIsDesktopWindow(WndObj)
Definition: window.h:24
_SEH2_END
Definition: create.c:4400
#define WS_BORDER
Definition: pedump.c:625
#define WS_EX_CLIENTEDGE
Definition: winuser.h:384
#define WM_ACTIVATE
Definition: winuser.h:1599
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
POINT ptMaxPosition
Definition: winuser.h:3274
PVOID UserGetObject(PUSER_HANDLE_TABLE ht, HANDLE handle, HANDLE_TYPE type)
Definition: object.c:495
#define SWP_AGG_NOCLIENTCHANGE
Definition: winpos.c:25
#define RGN_DIFF
Definition: wingdi.h:358
unsigned short USHORT
Definition: pedump.c:61
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:888
#define RDW_ALLCHILDREN
Definition: winuser.h:1211
#define WVR_HREDRAW
Definition: winuser.h:2499
#define BS_TYPEMASK
Definition: winuser.h:270
INT ccvrAlloc
Definition: winpos.h:26
VOID FASTCALL IntGetWindowBorderMeasures(PWND Wnd, UINT *cx, UINT *cy)
Definition: winpos.c:859
static ULONG Delta
Definition: xboxvideo.c:33
LRESULT FASTCALL co_IntSendMessageNoWait(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1710
DWORD state
Definition: ntuser.h:680
#define WNDS2_WIN31COMPAT
Definition: ntuser.h:632
#define GDI_OBJ_HMGR_PUBLIC
Definition: ntgdihdl.h:116
#define min(a, b)
Definition: monoChain.cc:55
#define WS_POPUP
Definition: pedump.c:616
_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:1556
#define STARTF_USESIZE
Definition: winbase.h:489
unsigned int UINT
Definition: ndis.h:50
#define WM_MOUSEMOVE
Definition: winuser.h:1762
#define NULL
Definition: types.h:112
VOID FASTCALL IntEngWindowChanged(_In_ struct _WND *Window, _In_ FLONG flChanged)
INT FASTCALL UserReleaseDC(PWND Window, HDC hDc, BOOL EndPaint)
Definition: windc.c:918
#define WVR_VREDRAW
Definition: winuser.h:2500
HWND FASTCALL IntGetWindow(HWND hWnd, UINT uCmd)
Definition: window.c:376
#define SWP_SHOWWINDOW
Definition: winuser.h:1238
#define SWP_NOREDRAW
Definition: winuser.h:1236
#define SWP_DEFERERASE
Definition: winuser.h:1242
VOID co_IntShellHookNotify(WPARAM Message, WPARAM wParam, LPARAM lParam)
Definition: desktop.c:1695
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define USERTAG_SWP
Definition: tags.h:281
PREGION FASTCALL VIS_ComputeVisibleRegion(PWND Wnd, BOOLEAN ClientArea, BOOLEAN ClipChildren, BOOLEAN ClipSiblings)
Definition: vis.c:13
#define WNDS_SENDERASEBACKGROUND
Definition: ntuser.h:597
WORD wShowWindow
Definition: win32.h:219
RECT rcNormalPosition
Definition: winuser.h:3275
#define WM_WINDOWPOSCHANGED
Definition: winuser.h:1649
#define msg(x)
Definition: auth_time.c:54
#define WNDS_MAXIMIZESTOMONITOR
Definition: ntuser.h:618
UINT FASTCALL co_WinPosMinMaximize(PWND Wnd, UINT ShowFlag, RECT *NewPos)
Definition: winpos.c:2340
VOID FASTCALL REGION_UnlockRgn(_In_ PREGION prgn)
Definition: region.c:2392
PMONITOR NTAPI UserGetPrimaryMonitor(VOID)
Definition: monitor.c:102
_Out_opt_ int * cx
Definition: commctrl.h:585
#define RDW_ERASENOW
Definition: winuser.h:1209
#define SWP_NOREPOSITION
Definition: winuser.h:1240
#define SM_CXMAXTRACK
Definition: winuser.h:1016
#define OUT
Definition: typedefs.h:40
GLuint res
Definition: glext.h:9613
#define WVR_ALIGNBOTTOM
Definition: winuser.h:2497
BOOL WINAPI CopyRect(_Out_ LPRECT, _In_ LPCRECT)
#define RDW_CLIPCHILDREN
Definition: painting.h:15
PCVR acvr
Definition: winpos.h:27
VOID ForceNCPaintErase(PWND Wnd, HRGN hRgn, PREGION pRgn)
Definition: winpos.c:1663
struct _WND * spwndParent
Definition: ntuser.h:692
BOOL FASTCALL IntSetWindowPlacement(PWND Wnd, WINDOWPLACEMENT *wpl, UINT Flags)
Definition: winpos.c:663
ULONG FASTCALL IntSetStyle(PWND pwnd, ULONG set_bits, ULONG clear_bits)
Definition: window.c:147
RECT rcMonitor
Definition: monitor.h:18
#define WNDS_ERASEBACKGROUND
Definition: ntuser.h:598
unsigned int ULONG
Definition: retypes.h:1
#define SWP_NOCLIENTMOVE
Definition: msg.h:30
#define HAS_DLGFRAME(Style, ExStyle)
Definition: window.h:8
DWORD state2
Definition: ntuser.h:681
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
LONG bottom
Definition: windef.h:309
#define ICLS_BUTTON
Definition: ntuser.h:891
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define SWP_NOMOVE
Definition: winuser.h:1234
#define SWP_AGG_NOPOSCHANGE
Definition: winpos.c:21
BOOL APIENTRY NtUserEndDeferWindowPosEx(HDWP WinPosInfo, BOOL bAsync)
Definition: winpos.c:3165
#define HWND_NOTOPMOST
Definition: winuser.h:1196