ReactOS 0.4.15-dev-5667-ged97270
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>
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 */
39static 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
143IntMapWindowPoints(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
257VOID
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;
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 */
371static
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 if (Wnd->ExStyle & WS_EX_NOACTIVATE) return FALSE;
383 return TRUE;
384 /* FIXME: This window could be disable because the child that closed
385 was a popup. */
386 //return !(style & WS_DISABLED);
387}
388
389
390/*******************************************************************
391 * WinPosActivateOtherWindow
392 *
393 * Activates window other than pWnd.
394 */
397{
398 PWND WndTo = NULL;
400
401 ASSERT_REFS_CO(Wnd);
402
403 if (IntIsDesktopWindow(Wnd))
404 {
405 //ERR("WinPosActivateOtherWindow Set Focus Msg Q No window!\n");
407 return;
408 }
409
410 /* If this is popup window, try to activate the owner first. */
411 if ((Wnd->style & WS_POPUP) && (WndTo = Wnd->spwndOwner))
412 {
413 TRACE("WPAOW Popup with Owner\n");
414 WndTo = UserGetAncestor( WndTo, GA_ROOT );
415 if (can_activate_window(WndTo)) goto done;
416 }
417
418 /* Pick a next top-level window. */
419 /* FIXME: Search for non-tooltip windows first. */
420 WndTo = Wnd;
421 for (;;)
422 {
423 if (!(WndTo = WndTo->spwndNext)) break;
424 if (can_activate_window( WndTo )) goto done;
425 }
426
427 /*
428 Fixes wine win.c:test_SetParent last ShowWindow test after popup dies.
429 Check for previous active window to bring to top.
430 */
431 if (Wnd)
432 {
433 WndTo = Wnd->head.pti->MessageQueue->spwndActivePrev;
434 if (can_activate_window( WndTo )) goto done;
435 }
436
437 // Find any window to bring to top. Works Okay for wine since it does not see X11 windows.
438 WndTo = UserGetDesktopWindow();
439 if ((WndTo == NULL) || (WndTo->spwndChild == NULL))
440 {
441 //ERR("WinPosActivateOtherWindow No window!\n");
442 return;
443 }
444 WndTo = WndTo->spwndChild;
445 for (;;)
446 {
447 if (WndTo == Wnd)
448 {
449 WndTo = NULL;
450 break;
451 }
452 if (can_activate_window( WndTo )) goto done;
453 if (!(WndTo = WndTo->spwndNext)) break;
454 }
455
456done:
457 if (WndTo) UserRefObjectCo(WndTo, &Ref);
458
460 {
461 /* ReactOS can pass WndTo = NULL to co_IntSetForegroundWindow and returns FALSE. */
462 //ERR("WinPosActivateOtherWindow Set FG 0x%p hWnd %p\n",WndTo, WndTo ? WndTo->head.h : 0);
463 if (co_IntSetForegroundWindow(WndTo))
464 {
465 if (WndTo) UserDerefObjectCo(WndTo);
466 return;
467 }
468 }
469 //ERR("WinPosActivateOtherWindow Set Active 0x%p\n",WndTo);
470 if (!UserSetActiveWindow(WndTo)) /* Ok for WndTo to be NULL here */
471 {
472 //ERR("WPAOW SA 1\n");
474 }
475 if (WndTo) UserDerefObjectCo(WndTo);
476}
477
480{
481 POINT Size;
482 RECTL Rect = *RestoreRect;
483
485 {
487 -Wnd->spwndParent->rcClient.left,
488 -Wnd->spwndParent->rcClient.top);
489 }
490
491 Size.x = Rect.left;
492 Size.y = Rect.top;
493
494 if (!Wnd->InternalPosInitialized)
495 {
496 // FIXME: Use check point Atom..
497 Wnd->InternalPos.flags = 0;
498 Wnd->InternalPos.MaxPos.x = Wnd->InternalPos.MaxPos.y = -1;
499 Wnd->InternalPos.IconPos.x = Wnd->InternalPos.IconPos.y = -1;
500 Wnd->InternalPos.NormalRect = Rect;
502 }
503
504 if (Wnd->style & WS_MINIMIZE)
505 {
506 Wnd->InternalPos.IconPos = Size;
507 Wnd->InternalPos.flags |= WPF_MININIT;
508 }
509 else if (Wnd->style & WS_MAXIMIZE)
510 {
511 Wnd->InternalPos.flags |= WPF_MAXINIT;
512
513 if ( Wnd->spwndParent == Wnd->head.rpdesk->pDeskInfo->spwnd )
514 {
516 {
517 Wnd->InternalPos.flags &= ~WPF_MAXINIT;
518 Wnd->InternalPos.MaxPos.x = Wnd->InternalPos.MaxPos.y = -1;
519 }
520 else
521 {
522 RECTL WorkArea;
523 PMONITOR pmonitor = UserMonitorFromRect(&Rect, MONITOR_DEFAULTTOPRIMARY );
524 // FIXME: support DPI aware, rcWorkDPI/Real etc..
525 WorkArea = pmonitor->rcMonitor;
526
527 if (Wnd->style & WS_MAXIMIZEBOX)
528 { // Support (Wnd->state & WNDS_HASCAPTION) || pmonitor->cFullScreen too.
529 if ((Wnd->style & WS_CAPTION) == WS_CAPTION || !(Wnd->style & (WS_CHILD | WS_POPUP)))
530 {
531 WorkArea = pmonitor->rcWork;
532 //ERR("rcWork\n");
533 }
534 }
535
536 Wnd->InternalPos.MaxPos.x = Rect.left - WorkArea.left;
537 Wnd->InternalPos.MaxPos.y = Rect.top - WorkArea.top;
538
539 /*ERR("WinPosIP 2 X %d = R.l %d - W.l %d | Y %d = R.t %d - W.t %d\n",
540 Wnd->InternalPos.MaxPos.x,
541 Rect.left, WorkArea.left,
542 Wnd->InternalPos.MaxPos.y,
543 Rect.top, WorkArea.top);*/
544 }
545 }
546 else
547 Wnd->InternalPos.MaxPos = Size;
548 }
549 else
550 {
551 Wnd->InternalPos.NormalRect = Rect;
552 }
553}
554
555// Win: _GetWindowPlacement
556BOOL
559{
560 if (!Wnd) return FALSE;
561
562 if(lpwndpl->length != sizeof(WINDOWPLACEMENT))
563 {
564 return FALSE;
565 }
566
567 lpwndpl->flags = 0;
568
570
571 lpwndpl->showCmd = SW_HIDE;
572
573 if ( Wnd->style & WS_MINIMIZE )
574 lpwndpl->showCmd = SW_SHOWMINIMIZED;
575 else
576 lpwndpl->showCmd = ( Wnd->style & WS_MAXIMIZE ) ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL ;
577
578 lpwndpl->rcNormalPosition = Wnd->InternalPos.NormalRect;
579
580 if (Wnd->InternalPos.flags & WPF_MININIT) // Return if it was set!
581 {
582 lpwndpl->ptMinPosition.x = Wnd->InternalPos.IconPos.x;
583 lpwndpl->ptMinPosition.y = Wnd->InternalPos.IconPos.y;
584 }
585 else
586 lpwndpl->ptMinPosition.x = lpwndpl->ptMinPosition.y = -1;
587
588 if ( Wnd->InternalPos.flags & WPF_MAXINIT && // Return if set and not maximized to monitor!
590 {
591 lpwndpl->ptMaxPosition.x = Wnd->InternalPos.MaxPos.x;
592 lpwndpl->ptMaxPosition.y = Wnd->InternalPos.MaxPos.y;
593 }
594 else
595 lpwndpl->ptMaxPosition.x = lpwndpl->ptMaxPosition.y = -1;
596
597 if ( Wnd->spwndParent == Wnd->head.rpdesk->pDeskInfo->spwnd &&
598 !(Wnd->ExStyle & WS_EX_TOOLWINDOW))
599 {
600 PMONITOR pmonitor = UserMonitorFromRect(&lpwndpl->rcNormalPosition, MONITOR_DEFAULTTOPRIMARY );
601
602 // FIXME: support DPI aware, rcWorkDPI/Real etc..
603 if (Wnd->InternalPos.flags & WPF_MININIT)
604 {
605 lpwndpl->ptMinPosition.x -= (pmonitor->rcWork.left - pmonitor->rcMonitor.left);
606 lpwndpl->ptMinPosition.y -= (pmonitor->rcWork.top - pmonitor->rcMonitor.top);
607 }
609 pmonitor->rcMonitor.left - pmonitor->rcWork.left,
610 pmonitor->rcMonitor.top - pmonitor->rcWork.top);
611 }
612
613 if ( Wnd->InternalPos.flags & WPF_RESTORETOMAXIMIZED || Wnd->style & WS_MAXIMIZE )
614 lpwndpl->flags |= WPF_RESTORETOMAXIMIZED;
615
616 if ( ((Wnd->style & (WS_CHILD|WS_POPUP)) == WS_CHILD) && Wnd->InternalPos.flags & WPF_SETMINPOSITION)
617 lpwndpl->flags |= WPF_SETMINPOSITION;
618
619 return TRUE;
620}
621
622/* make sure the specified rect is visible on screen */
624{
625 PMONITOR pmonitor = UserMonitorFromRect( rect, MONITOR_DEFAULTTONEAREST ); // Wine uses this.
626
627 // FIXME: support DPI aware, rcWorkDPI/Real etc..
628 if (!pmonitor) return;
629 /* FIXME: map coordinates from rcWork to rcMonitor */
630 if (rect->right <= pmonitor->rcWork.left)
631 {
632 rect->right += pmonitor->rcWork.left - rect->left;
633 rect->left = pmonitor->rcWork.left;
634 }
635 else if (rect->left >= pmonitor->rcWork.right)
636 {
637 rect->left += pmonitor->rcWork.right - rect->right;
638 rect->right = pmonitor->rcWork.right;
639 }
640 if (rect->bottom <= pmonitor->rcWork.top)
641 {
642 rect->bottom += pmonitor->rcWork.top - rect->top;
643 rect->top = pmonitor->rcWork.top;
644 }
645 else if (rect->top >= pmonitor->rcWork.bottom)
646 {
647 rect->top += pmonitor->rcWork.bottom - rect->bottom;
648 rect->bottom = pmonitor->rcWork.bottom;
649 }
650}
651
652/* make sure the specified point is visible on screen */
654{
655 RECT rect;
656
657 RECTL_vSetRect( &rect, pt->x, pt->y, pt->x + 1, pt->y + 1 );
659 pt->x = rect.left;
660 pt->y = rect.top;
661}
662
665{
666 BOOL sAsync;
667 UINT SWP_Flags;
668
672
673 if (!Wnd || Wnd == Wnd->head.rpdesk->pDeskInfo->spwnd) return FALSE;
674
675 if ( Flags & PLACE_MIN ) Wnd->InternalPos.IconPos = wpl->ptMinPosition;
676 if ( Flags & PLACE_MAX ) Wnd->InternalPos.MaxPos = wpl->ptMaxPosition;
677 if ( Flags & PLACE_RECT) Wnd->InternalPos.NormalRect = wpl->rcNormalPosition;
678
679 SWP_Flags = SWP_NOZORDER | SWP_NOACTIVATE | ((wpl->flags & WPF_ASYNCWINDOWPLACEMENT) ? SWP_ASYNCWINDOWPOS : 0);
680
681 if (Wnd->style & WS_MINIMIZE )
682 {
683 if (Flags & PLACE_MIN || Wnd->InternalPos.flags & WPF_SETMINPOSITION)
684 {
686 wpl->ptMinPosition.x, wpl->ptMinPosition.y, 0, 0,
687 SWP_NOSIZE | SWP_Flags);
688 Wnd->InternalPos.flags |= WPF_MININIT;
689 }
690 }
691 else if (Wnd->style & WS_MAXIMIZE )
692 {
693 if (Flags & PLACE_MAX)
694 {
696 wpl->ptMaxPosition.x, wpl->ptMaxPosition.y, 0, 0,
697 SWP_NOSIZE | SWP_Flags);
698 Wnd->InternalPos.flags |= WPF_MAXINIT;
699 }
700 }
701 else if (Flags & PLACE_RECT)
702 {
707 SWP_Flags);
708 }
709
710 sAsync = (Wnd->head.pti->MessageQueue != gptiCurrent->MessageQueue && wpl->flags & WPF_ASYNCWINDOWPLACEMENT);
711
712 if ( sAsync )
714 else
715 co_WinPosShowWindow(Wnd, wpl->showCmd);
716
717 if ( Wnd->style & WS_MINIMIZE && !sAsync )
718 {
719 if ( wpl->flags & WPF_SETMINPOSITION )
720 Wnd->InternalPos.flags |= WPF_SETMINPOSITION;
721
722 if ( wpl->flags & WPF_RESTORETOMAXIMIZED )
724 }
725 return TRUE;
726}
727
728UINT
731{
732 RECTL rectParent;
733 PWND Child;
734 INT x, y, xspacing, yspacing, sx, sy;
735
737
738 IntGetClientRect( parent, &rectParent );
739 // FIXME: Support Minimize Metrics gspv.mm.iArrange.
740 // Default: ARW_BOTTOMLEFT
741 x = rectParent.left;
742 y = rectParent.bottom;
743
746
747 Child = parent->spwndChild;
748 while(Child)
749 {
750 if((Child->style & WS_MINIMIZE) != 0 )
751 {
753 UserRefObjectCo(Child, &Ref);
754
756 sy = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
757
758 Child->InternalPos.IconPos.x = sx;
759 Child->InternalPos.IconPos.y = sy;
760 Child->InternalPos.flags |= WPF_MININIT;
761
763
765
766 if (x <= rectParent.right - xspacing)
767 x += xspacing;
768 else
769 {
770 x = rectParent.left;
771 y -= yspacing;
772 }
773 }
774 Child = Child->spwndNext;
775 }
776 return yspacing;
777}
778
779static VOID FASTCALL
781{
782 RECT rectParent;
783 PWND pwndChild, pwndParent;
784 int x, y, xspacing, yspacing;
785
786 pwndParent = Window->spwndParent;
787 if (UserIsDesktopWindow(pwndParent))
788 {
789 ERR("FIXME: Parent is Desktop, Min off screen!\n");
790 /* FIXME: ReactOS doesn't support iconic minimize to desktop */
791 Pos->x = Pos->y = -32000;
792 Window->InternalPos.flags |= WPF_MININIT;
793 Window->InternalPos.IconPos.x = Pos->x;
794 Window->InternalPos.IconPos.y = Pos->y;
795 return;
796 }
797
798 IntGetClientRect( pwndParent, &rectParent );
799 // FIXME: Support Minimize Metrics gspv.mm.iArrange.
800 // Default: ARW_BOTTOMLEFT
801 x = rectParent.left;
802 y = rectParent.bottom;
803
806
807 // Set to default position when minimized.
809 Pos->y = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
810
811 for (pwndChild = pwndParent->spwndChild; pwndChild; pwndChild = pwndChild->spwndNext)
812 {
813 if (pwndChild == Window) continue;
814
815 if ((pwndChild->style & (WS_VISIBLE|WS_MINIMIZE)) != (WS_VISIBLE|WS_MINIMIZE) )
816 {
817 continue;
818 }
819
820 if ( pwndChild->InternalPos.IconPos.x != Pos->x && pwndChild->InternalPos.IconPos.y != Pos->y )
821 {
822 break;
823 }
824 if (x <= rectParent.right - xspacing)
825 x += xspacing;
826 else
827 {
828 x = rectParent.left;
829 y -= yspacing;
830 }
832 Pos->y = y - yspacing - UserGetSystemMetrics(SM_CYBORDER);
833 }
834
835 Window->InternalPos.IconPos.x = Pos->x;
836 Window->InternalPos.IconPos.y = Pos->y;
837 Window->InternalPos.flags |= WPF_MININIT;
838 TRACE("Position is set! X:%d Y:%d\n",Pos->x,Pos->y);
839 return;
840}
841
842BOOL
844{
845 if (Style & WS_MINIMIZE)
846 return TRUE;
848 return TRUE;
850 return FALSE;
851 if (Style & WS_THICKFRAME)
852 return TRUE;
853 Style &= WS_CAPTION;
854 if (Style == WS_DLGFRAME || Style == WS_CAPTION)
855 return TRUE;
856 return FALSE;
857}
858
861{
862 if(HAS_DLGFRAME(Wnd->style, Wnd->ExStyle) && !(Wnd->style & WS_MINIMIZE))
863 {
866 }
867 else
868 {
869 if(HAS_THICKFRAME(Wnd->style, Wnd->ExStyle)&& !(Wnd->style & WS_MINIMIZE))
870 {
873 }
874 else if(HAS_THINFRAME(Wnd->style, Wnd->ExStyle))
875 {
878 }
879 else
880 {
881 *cx = *cy = 0;
882 }
883 }
884}
885
886VOID
888{
889 DWORD Border = 0;
890
892 Border += 2;
894 Border += 1; /* for the outer frame always present */
895 if ((ExStyle & WS_EX_CLIENTEDGE) && WithClient)
896 Border += 2;
898 Border ++; /* The other border */
899 Size->cx = Size->cy = Border;
900 if ((Style & WS_THICKFRAME) && !(Style & WS_MINIMIZE)) /* The resize border */
901 {
904 }
907}
908
909//
910// Fix CORE-5177
911// See winetests:user32:win.c:wine_AdjustWindowRectEx,
912// Simplified version.
913//
915{
916 DWORD adjust = 0;
917
918 if ( ExStyle & WS_EX_WINDOWEDGE ) // 1st
919 adjust = 2; /* outer */
920 else if ( ExStyle & WS_EX_STATICEDGE ) // 2nd
921 adjust = 1; /* for the outer frame always present */
922
924 adjust += 2;
925
927 adjust++; /* The other border */
928
929 return adjust;
930}
931
934 POINT* MinTrack, POINT* MaxTrack)
935{
936 MINMAXINFO MinMax;
937 PMONITOR monitor;
938 INT xinc, yinc;
939 LONG style = Window->style;
940 LONG adjustedStyle;
941 LONG exstyle = Window->ExStyle;
942 RECT rc;
943 DWORD adjust;
944
946
947 /* Compute default values */
948
949 rc = Window->rcWindow;
950 MinMax.ptReserved.x = rc.left;
951 MinMax.ptReserved.y = rc.top;
952
953 if ((style & WS_CAPTION) == WS_CAPTION)
954 adjustedStyle = style & ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
955 else
956 adjustedStyle = style;
957
958 if (Window->spwndParent)
959 IntGetClientRect(Window->spwndParent, &rc);
960
961 adjust = IntGetWindowBorders(adjustedStyle, exstyle);
962
963 // Handle special case while maximized. CORE-15893
964 if ((adjustedStyle & WS_THICKFRAME) && !(adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
965 adjust += 1;
966
967 xinc = yinc = adjust;
968
969 if ((adjustedStyle & WS_THICKFRAME) && (adjustedStyle & WS_CHILD) && !(adjustedStyle & WS_MINIMIZE))
970 {
973 }
974
978
979 xinc = -rc.left;
980 yinc = -rc.top;
981
982 MinMax.ptMaxSize.x = rc.right - rc.left;
983 MinMax.ptMaxSize.y = rc.bottom - rc.top;
984 if (style & (WS_DLGFRAME | WS_BORDER))
985 {
988 }
989 else
990 {
991 MinMax.ptMinTrackSize.x = 2 * xinc;
992 MinMax.ptMinTrackSize.y = 2 * yinc;
993 }
996 MinMax.ptMaxPosition.x = -xinc;
997 MinMax.ptMaxPosition.y = -yinc;
998
999 if (!EMPTYPOINT(Window->InternalPos.MaxPos)) MinMax.ptMaxPosition = Window->InternalPos.MaxPos;
1000
1001 co_IntSendMessage(Window->head.h, WM_GETMINMAXINFO, 0, (LPARAM)&MinMax);
1002
1003 /* if the app didn't change the values, adapt them for the current monitor */
1004 if ((monitor = UserGetPrimaryMonitor()))
1005 {
1006 RECT rc_work;
1007
1008 rc_work = monitor->rcMonitor;
1009
1010 if (style & WS_MAXIMIZEBOX)
1011 {
1012 if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP)))
1013 rc_work = monitor->rcWork;
1014 }
1015
1016 if (MinMax.ptMaxSize.x == UserGetSystemMetrics(SM_CXSCREEN) + 2 * xinc &&
1017 MinMax.ptMaxSize.y == UserGetSystemMetrics(SM_CYSCREEN) + 2 * yinc)
1018 {
1019 MinMax.ptMaxSize.x = (rc_work.right - rc_work.left) + 2 * xinc;
1020 MinMax.ptMaxSize.y = (rc_work.bottom - rc_work.top) + 2 * yinc;
1021 }
1022 if (MinMax.ptMaxPosition.x == -xinc && MinMax.ptMaxPosition.y == -yinc)
1023 {
1024 MinMax.ptMaxPosition.x = rc_work.left - xinc;
1025 MinMax.ptMaxPosition.y = rc_work.top - yinc;
1026 }
1027 if (MinMax.ptMaxSize.x >= (monitor->rcMonitor.right - monitor->rcMonitor.left) &&
1028 MinMax.ptMaxSize.y >= (monitor->rcMonitor.bottom - monitor->rcMonitor.top) )
1029 {
1031 }
1032 else
1033 Window->state &= ~WNDS_MAXIMIZESTOMONITOR;
1034 }
1035
1036
1037 MinMax.ptMaxTrackSize.x = max(MinMax.ptMaxTrackSize.x,
1038 MinMax.ptMinTrackSize.x);
1039 MinMax.ptMaxTrackSize.y = max(MinMax.ptMaxTrackSize.y,
1040 MinMax.ptMinTrackSize.y);
1041
1042 if (MaxSize)
1043 *MaxSize = MinMax.ptMaxSize;
1044 if (MaxPos)
1045 *MaxPos = MinMax.ptMaxPosition;
1046 if (MinTrack)
1047 *MinTrack = MinMax.ptMinTrackSize;
1048 if (MaxTrack)
1049 *MaxTrack = MinMax.ptMaxTrackSize;
1050
1051 return 0; // FIXME: What does it return? Wine returns MINMAXINFO.
1052}
1053
1054static
1055BOOL
1057{
1058 PWND ParentWnd = Child->spwndParent;
1059
1060 while (ParentWnd)
1061 {
1062 if (ParentWnd->style & WS_CLIPCHILDREN)
1063 break;
1064
1065 if (ParentWnd->hrgnUpdate != 0)
1066 {
1067 IntInvalidateWindows( ParentWnd,
1070 }
1071
1072 ParentWnd = ParentWnd->spwndParent;
1073 }
1074
1075 return TRUE;
1076}
1077
1078static
1080FixClientRect(PRECTL ClientRect, PRECTL WindowRect)
1081{
1082 if (ClientRect->left < WindowRect->left)
1083 {
1084 ClientRect->left = WindowRect->left;
1085 }
1086 else if (WindowRect->right < ClientRect->left)
1087 {
1088 ClientRect->left = WindowRect->right;
1089 }
1090 if (ClientRect->right < WindowRect->left)
1091 {
1092 ClientRect->right = WindowRect->left;
1093 }
1094 else if (WindowRect->right < ClientRect->right)
1095 {
1096 ClientRect->right = WindowRect->right;
1097 }
1098 if (ClientRect->top < WindowRect->top)
1099 {
1100 ClientRect->top = WindowRect->top;
1101 }
1102 else if (WindowRect->bottom < ClientRect->top)
1103 {
1104 ClientRect->top = WindowRect->bottom;
1105 }
1106 if (ClientRect->bottom < WindowRect->top)
1107 {
1108 ClientRect->bottom = WindowRect->top;
1109 }
1110 else if (WindowRect->bottom < ClientRect->bottom)
1111 {
1112 ClientRect->bottom = WindowRect->bottom;
1113 }
1114}
1115/***********************************************************************
1116 * get_valid_rects
1117 *
1118 * Compute the valid rects from the old and new client rect and WVR_* flags.
1119 * Helper for WM_NCCALCSIZE handling.
1120 */
1121static
1123get_valid_rects( RECTL *old_client, RECTL *new_client, UINT flags, RECTL *valid )
1124{
1125 int cx, cy;
1126
1127 if (flags & WVR_REDRAW)
1128 {
1131 return;
1132 }
1133
1134 if (flags & WVR_VALIDRECTS)
1135 {
1136 if (!RECTL_bIntersectRect( &valid[0], &valid[0], new_client ) ||
1137 !RECTL_bIntersectRect( &valid[1], &valid[1], old_client ))
1138 {
1141 return;
1142 }
1144 }
1145 else
1146 {
1147 valid[0] = *new_client;
1148 valid[1] = *old_client;
1149 }
1150
1151 /* make sure the rectangles have the same size */
1152 cx = min( valid[0].right - valid[0].left, valid[1].right - valid[1].left );
1153 cy = min( valid[0].bottom - valid[0].top, valid[1].bottom - valid[1].top );
1154
1155 if (flags & WVR_ALIGNBOTTOM)
1156 {
1157 valid[0].top = valid[0].bottom - cy;
1158 valid[1].top = valid[1].bottom - cy;
1159 }
1160 else
1161 {
1162 valid[0].bottom = valid[0].top + cy;
1163 valid[1].bottom = valid[1].top + cy;
1164 }
1165 if (flags & WVR_ALIGNRIGHT)
1166 {
1167 valid[0].left = valid[0].right - cx;
1168 valid[1].left = valid[1].right - cx;
1169 }
1170 else
1171 {
1172 valid[0].right = valid[0].left + cx;
1173 valid[1].right = valid[1].left + cx;
1174 }
1175}
1176
1177static
1179co_WinPosDoNCCALCSize(PWND Window, PWINDOWPOS WinPos, RECTL* WindowRect, RECTL* ClientRect, RECTL* validRects)
1180{
1181 PWND Parent;
1182 UINT wvrFlags = 0;
1183
1185
1186 /* Send WM_NCCALCSIZE message to get new client area */
1187 if ((WinPos->flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE)
1188 {
1190 WINDOWPOS winposCopy;
1191
1192 params.rgrc[0] = *WindowRect; // new coordinates of a window that has been moved or resized
1193 params.rgrc[1] = Window->rcWindow; // window before it was moved or resized
1194 params.rgrc[2] = Window->rcClient; // client area before the window was moved or resized
1195
1196 Parent = Window->spwndParent;
1197 if (0 != (Window->style & WS_CHILD) && Parent)
1198 {
1199 RECTL_vOffsetRect(&(params.rgrc[0]), - Parent->rcClient.left, - Parent->rcClient.top);
1200 RECTL_vOffsetRect(&(params.rgrc[1]), - Parent->rcClient.left, - Parent->rcClient.top);
1201 RECTL_vOffsetRect(&(params.rgrc[2]), - Parent->rcClient.left, - Parent->rcClient.top);
1202 }
1203
1204 params.lppos = &winposCopy;
1205 winposCopy = *WinPos;
1206
1207 wvrFlags = co_IntSendMessage(Window->head.h, WM_NCCALCSIZE, TRUE, (LPARAM) &params);
1208
1209 /* If the application send back garbage, ignore it */
1210 if (params.rgrc[0].left <= params.rgrc[0].right &&
1211 params.rgrc[0].top <= params.rgrc[0].bottom)
1212 {
1213 *ClientRect = params.rgrc[0]; // First rectangle contains the coordinates of the new client rectangle resulting from the move or resize
1214 if ((Window->style & WS_CHILD) && Parent)
1215 {
1216 RECTL_vOffsetRect(ClientRect, Parent->rcClient.left, Parent->rcClient.top);
1217 }
1218 FixClientRect(ClientRect, WindowRect);
1219 }
1220
1221 if (ClientRect->left != Window->rcClient.left ||
1222 ClientRect->top != Window->rcClient.top)
1223 {
1224 WinPos->flags &= ~SWP_NOCLIENTMOVE;
1225 }
1226
1227 if (ClientRect->right - ClientRect->left != Window->rcClient.right - Window->rcClient.left)
1228 {
1229 WinPos->flags &= ~SWP_NOCLIENTSIZE;
1230 }
1231 else
1232 wvrFlags &= ~WVR_HREDRAW;
1233
1234 if (ClientRect->bottom - ClientRect->top != Window->rcClient.bottom - Window->rcClient.top)
1235 {
1236 WinPos->flags &= ~SWP_NOCLIENTSIZE;
1237 }
1238 else
1239 wvrFlags &= ~WVR_VREDRAW;
1240
1241 validRects[0] = params.rgrc[1]; // second rectangle contains the valid destination rectangle
1242 validRects[1] = params.rgrc[2]; // third rectangle contains the valid source rectangle
1243 }
1244 else
1245 {
1246 if (!(WinPos->flags & SWP_NOMOVE) &&
1247 (ClientRect->left != Window->rcClient.left ||
1248 ClientRect->top != Window->rcClient.top))
1249 {
1250 WinPos->flags &= ~SWP_NOCLIENTMOVE;
1251 }
1252 }
1253
1255 {
1256 RECTL_vSetEmptyRect( &validRects[0] );
1257 RECTL_vSetEmptyRect( &validRects[1] );
1258 }
1259 else get_valid_rects( &Window->rcClient, ClientRect, wvrFlags, validRects );
1260
1261 return wvrFlags;
1262}
1263
1264static
1267 PWINDOWPOS WinPos,
1268 PRECTL WindowRect,
1269 PRECTL ClientRect)
1270{
1272
1273 /* Send WM_WINDOWPOSCHANGING message */
1274
1275 if (!(WinPos->flags & SWP_NOSENDCHANGING)
1276 && !((WinPos->flags & SWP_AGG_NOCLIENTCHANGE) && (WinPos->flags & SWP_SHOWWINDOW)))
1277 {
1278 TRACE("Sending WM_WINDOWPOSCHANGING to hwnd %p flags %04x.\n", Window->head.h,WinPos->flags);
1279 co_IntSendMessage(Window->head.h, WM_WINDOWPOSCHANGING, 0, (LPARAM) WinPos);
1280 }
1281
1282 /* Calculate new position and size */
1283
1284 *WindowRect = Window->rcWindow;
1285 *ClientRect = (Window->style & WS_MINIMIZE) ? Window->rcWindow : Window->rcClient;
1286
1287 if (!(WinPos->flags & SWP_NOSIZE))
1288 {
1289 if (Window->style & WS_MINIMIZE)
1290 {
1291 WindowRect->right = WindowRect->left + UserGetSystemMetrics(SM_CXMINIMIZED);
1292 WindowRect->bottom = WindowRect->top + UserGetSystemMetrics(SM_CYMINIMIZED);
1293 }
1294 else
1295 {
1296 WindowRect->right = WindowRect->left + WinPos->cx;
1297 WindowRect->bottom = WindowRect->top + WinPos->cy;
1298 }
1299 }
1300
1301 if (!(WinPos->flags & SWP_NOMOVE))
1302 {
1303 INT X, Y;
1304 PWND Parent;
1305 X = WinPos->x;
1306 Y = WinPos->y;
1307
1308 Parent = Window->spwndParent;
1309
1310 // Parent child position issue is in here. SetParent_W7 test CORE-6651.
1311 if (//((Window->style & WS_CHILD) != 0) && <- Fixes wine msg test_SetParent: "rects do not match", the last test.
1312 Parent &&
1313 Parent != Window->head.rpdesk->pDeskInfo->spwnd)
1314 {
1315 TRACE("Not SWP_NOMOVE 1 Parent client offset X %d Y %d\n",X,Y);
1316 X += Parent->rcClient.left;
1317 Y += Parent->rcClient.top;
1318 TRACE("Not SWP_NOMOVE 2 Parent client offset X %d Y %d\n",X,Y);
1319 }
1320
1321 WindowRect->left = X;
1322 WindowRect->top = Y;
1323 WindowRect->right += X - Window->rcWindow.left;
1324 WindowRect->bottom += Y - Window->rcWindow.top;
1325
1326 RECTL_vOffsetRect(ClientRect, X - Window->rcWindow.left,
1327 Y - Window->rcWindow.top);
1328 }
1330
1331 TRACE( "hwnd %p, after %p, swp %d,%d %dx%d flags %08x\n",
1332 WinPos->hwnd, WinPos->hwndInsertAfter, WinPos->x, WinPos->y,
1333 WinPos->cx, WinPos->cy, WinPos->flags );
1334 TRACE("WindowRect: %d %d %d %d\n", WindowRect->left,WindowRect->top,WindowRect->right,WindowRect->bottom);
1335 TRACE("ClientRect: %d %d %d %d\n", ClientRect->left,ClientRect->top,ClientRect->right,ClientRect->bottom);
1336
1337 return TRUE;
1338}
1339
1340/*
1341 * Fix Z order taking into account owned popups -
1342 * basically we need to maintain them above the window that owns them
1343 *
1344 * FIXME: hide/show owned popups when owner visibility changes.
1345 *
1346 * ReactOS: See bug CORE-6129 and CORE-6554.
1347 *
1348 */
1350 // Pass all the win:test_children/popup_zorder tests except "move hwnd_F and its popups down" which is if'ed out.
1351 // Side effect, breaks more of the DeferWindowPos api tests, but wine breaks more!!!!
1352static
1355{
1356 HWND *List = NULL;
1357 HWND Owner;
1358 LONG Style;
1359 PWND DesktopWindow, ChildObject;
1360 int i;
1361
1362 TRACE("(%p) hInsertAfter = %p\n", Window, hWndInsertAfter );
1363
1364 Style = Window->style;
1365
1366 if (Style & WS_CHILD)
1367 {
1368 TRACE("Window is child\n");
1369 return hWndInsertAfter;
1370 }
1371
1372 Owner = Window->spwndOwner ? Window->spwndOwner->head.h : NULL;
1373
1374 if (Owner)
1375 {
1376 /* Make sure this popup stays above the owner */
1377
1378 if (hWndInsertAfter != HWND_TOPMOST)
1379 {
1382
1383 if (List != NULL)
1384 {
1385 for (i = 0; List[i]; i++)
1386 {
1387 BOOL topmost = FALSE;
1388
1389 ChildObject = ValidateHwndNoErr(List[i]);
1390 if (ChildObject)
1391 {
1392 topmost = (ChildObject->ExStyle & WS_EX_TOPMOST) != 0;
1393 }
1394
1395 if (List[i] == Owner)
1396 {
1397 /* We found its Owner, so we must handle it here. */
1398 if (i > 0)
1399 {
1400 if (List[i - 1] != UserHMGetHandle(Window))
1401 {
1402 /*
1403 * If the popup to be inserted is not already just
1404 * before the Owner, insert it there. The modified
1405 * hWndInsertAfter will be handled below.
1406 *
1407 * (NOTE: Do not allow hWndInsertAfter to become equal
1408 * to the popup's window handle, as this would cause
1409 * the popup to link to itself).
1410 */
1411 hWndInsertAfter = List[i - 1];
1412 }
1413 else
1414 {
1415 /* If the popup to be inserted is already
1416 * before the Owner, we are done. */
1418 return hWndInsertAfter;
1419 }
1420 }
1421 else
1422 {
1423 hWndInsertAfter = topmost ? HWND_TOPMOST : HWND_TOP;
1424 }
1425 break;
1426 }
1427
1428 if (hWndInsertAfter == HWND_TOP || hWndInsertAfter == HWND_NOTOPMOST)
1429 {
1430 if (!topmost) break;
1431 }
1432 else if (List[i] == hWndInsertAfter) break;
1433 }
1434 }
1435 else
1436 return hWndInsertAfter;
1437 }
1438 }
1439
1440 if (hWndInsertAfter == HWND_BOTTOM)
1441 {
1442 ERR("Window is HWND_BOTTOM hwnd %p\n",hWndInsertAfter);
1444 goto done;
1445 }
1446
1447 if (!List)
1448 {
1451 }
1452
1453 if (List != NULL)
1454 {
1455 i = 0;
1456
1457 if (hWndInsertAfter == HWND_TOP || hWndInsertAfter == HWND_NOTOPMOST)
1458 {
1459 if (hWndInsertAfter == HWND_NOTOPMOST || !(Window->ExStyle & WS_EX_TOPMOST))
1460 {
1461 TRACE("skip all the topmost windows\n");
1462 /* skip all the topmost windows */
1463 while (List[i] &&
1464 (ChildObject = ValidateHwndNoErr(List[i])) &&
1465 (ChildObject->ExStyle & WS_EX_TOPMOST)) i++;
1466 }
1467 }
1468 else if (hWndInsertAfter != HWND_TOPMOST)
1469 {
1470 /* skip windows that are already placed correctly */
1471 for (i = 0; List[i]; i++)
1472 {
1473 if (List[i] == hWndInsertAfter) break;
1474 if (List[i] == UserHMGetHandle(Window))
1475 {
1477 goto done; /* nothing to do if window is moving backwards in z-order */
1478 }
1479 }
1480 }
1481
1482 for (; List[i]; i++)
1483 {
1484 PWND Wnd;
1486
1487 if (List[i] == UserHMGetHandle(Window))
1488 break;
1489
1490 if (!(Wnd = ValidateHwndNoErr(List[i])))
1491 continue;
1492
1493 Owner = Wnd->spwndOwner ? Wnd->spwndOwner->head.h : NULL;
1494
1495 if (Owner != UserHMGetHandle(Window)) continue;
1496
1497 UserRefObjectCo(Wnd, &Ref);
1498 TRACE( "moving %p owned by %p after %p\n", List[i], UserHMGetHandle(Window), hWndInsertAfter );
1499 co_WinPosSetWindowPos(Wnd, hWndInsertAfter, 0, 0, 0, 0,
1501
1502 UserDerefObjectCo(Wnd);
1503 hWndInsertAfter = List[i];
1504 }
1506 }
1507done:
1508 return hWndInsertAfter;
1509}
1511
1512/***********************************************************************
1513 * WinPosInternalMoveWindow
1514 *
1515 * Update WindowRect and ClientRect of Window and all of its children
1516 * We keep both WindowRect and ClientRect in screen coordinates internally
1517 */
1518static
1521{
1522 PWND Child;
1523
1524 ASSERT(Window != Window->spwndChild);
1525 TRACE("InternalMoveWin X %d Y %d\n", MoveX, MoveY);
1526
1527 Window->rcWindow.left += MoveX;
1528 Window->rcWindow.right += MoveX;
1529 Window->rcWindow.top += MoveY;
1530 Window->rcWindow.bottom += MoveY;
1531
1532 Window->rcClient.left += MoveX;
1533 Window->rcClient.right += MoveX;
1534 Window->rcClient.top += MoveY;
1535 Window->rcClient.bottom += MoveY;
1536
1537 for(Child = Window->spwndChild; Child; Child = Child->spwndNext)
1538 {
1539 WinPosInternalMoveWindow(Child, MoveX, MoveY);
1540 }
1541}
1542
1543/*
1544 * WinPosFixupSWPFlags
1545 *
1546 * Fix redundant flags and values in the WINDOWPOS structure.
1547 */
1548static
1551{
1552 PWND Parent;
1553 POINT pt;
1554
1555 /* Finally make sure that all coordinates are valid */
1556 if (WinPos->x < -32768) WinPos->x = -32768;
1557 else if (WinPos->x > 32767) WinPos->x = 32767;
1558 if (WinPos->y < -32768) WinPos->y = -32768;
1559 else if (WinPos->y > 32767) WinPos->y = 32767;
1560
1561 WinPos->cx = max(WinPos->cx, 0);
1562 WinPos->cy = max(WinPos->cy, 0);
1563
1565 if (!IntIsWindowVisible( Parent ) &&
1566 /* Fix B : wine msg test_SetParent:WmSetParentSeq_2:25 wParam bits! */
1568
1569 if (Wnd->style & WS_VISIBLE) WinPos->flags &= ~SWP_SHOWWINDOW;
1570 else
1571 {
1572 WinPos->flags &= ~SWP_HIDEWINDOW;
1573 if (!(WinPos->flags & SWP_SHOWWINDOW)) WinPos->flags |= SWP_NOREDRAW;
1574 }
1575
1576 /* Check for right size */
1577 if (Wnd->rcWindow.right - Wnd->rcWindow.left == WinPos->cx &&
1578 Wnd->rcWindow.bottom - Wnd->rcWindow.top == WinPos->cy)
1579 {
1580 WinPos->flags |= SWP_NOSIZE;
1581 }
1582
1583 pt.x = WinPos->x;
1584 pt.y = WinPos->y;
1586 TRACE("WPFU C2S wpx %d wpy %d ptx %d pty %d\n",WinPos->x,WinPos->y,pt.x,pt.y);
1587 /* Check for right position */
1588 if (Wnd->rcWindow.left == pt.x && Wnd->rcWindow.top == pt.y)
1589 {
1590 //ERR("In right pos\n");
1591 WinPos->flags |= SWP_NOMOVE;
1592 }
1593
1594 if ( WinPos->hwnd != UserGetForegroundWindow() && (Wnd->style & (WS_POPUP | WS_CHILD)) != WS_CHILD)
1595 {
1596 /* Bring to the top when activating */
1597 if (!(WinPos->flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)) &&
1598 (WinPos->flags & SWP_NOZORDER ||
1599 (WinPos->hwndInsertAfter != HWND_TOPMOST && WinPos->hwndInsertAfter != HWND_NOTOPMOST)))
1600 {
1601 WinPos->flags &= ~SWP_NOZORDER;
1602 WinPos->hwndInsertAfter = (0 != (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOPMOST : HWND_TOP);
1603 }
1604 }
1605
1606 /* Check hwndInsertAfter */
1607 if (!(WinPos->flags & SWP_NOZORDER))
1608 {
1609 /* Fix sign extension */
1610 if (WinPos->hwndInsertAfter == (HWND)0xffff)
1611 {
1612 WinPos->hwndInsertAfter = HWND_TOPMOST;
1613 }
1614 else if (WinPos->hwndInsertAfter == (HWND)0xfffe)
1615 {
1617 }
1618
1619 if (WinPos->hwndInsertAfter == HWND_TOP)
1620 {
1621 /* Keep it topmost when it's already topmost */
1622 if ((Wnd->ExStyle & WS_EX_TOPMOST) != 0)
1623 WinPos->hwndInsertAfter = HWND_TOPMOST;
1624
1625 if (IntGetWindow(WinPos->hwnd, GW_HWNDFIRST) == WinPos->hwnd)
1626 {
1627 WinPos->flags |= SWP_NOZORDER;
1628 }
1629 }
1630 else if (WinPos->hwndInsertAfter == HWND_BOTTOM)
1631 {
1632 if (!(Wnd->ExStyle & WS_EX_TOPMOST) && IntGetWindow(WinPos->hwnd, GW_HWNDLAST) == WinPos->hwnd)
1633 WinPos->flags |= SWP_NOZORDER;
1634 }
1635 else if (WinPos->hwndInsertAfter == HWND_TOPMOST)
1636 {
1637 if ((Wnd->ExStyle & WS_EX_TOPMOST) && IntGetWindow(WinPos->hwnd, GW_HWNDFIRST) == WinPos->hwnd)
1638 WinPos->flags |= SWP_NOZORDER;
1639 }
1640 else if (WinPos->hwndInsertAfter == HWND_NOTOPMOST)
1641 {
1642 if (!(Wnd->ExStyle & WS_EX_TOPMOST))
1643 WinPos->flags |= SWP_NOZORDER;
1644 }
1645 else /* hwndInsertAfter must be a sibling of the window */
1646 {
1647 PWND InsAfterWnd;
1648
1649 InsAfterWnd = ValidateHwndNoErr(WinPos->hwndInsertAfter);
1650 if(!InsAfterWnd)
1651 {
1652 return TRUE;
1653 }
1654
1655 if (InsAfterWnd->spwndParent != Wnd->spwndParent)
1656 {
1657 /* Note from wine User32 Win test_SetWindowPos:
1658 "Returns TRUE also for windows that are not siblings"
1659 "Does not seem to do anything even without passing flags, still returns TRUE"
1660 "Same thing the other way around."
1661 ".. and with these windows."
1662 */
1663 return FALSE;
1664 }
1665 else
1666 {
1667 /*
1668 * We don't need to change the Z order of hwnd if it's already
1669 * inserted after hwndInsertAfter or when inserting hwnd after
1670 * itself.
1671 */
1672 if ((WinPos->hwnd == WinPos->hwndInsertAfter) ||
1673 ((InsAfterWnd->spwndNext) && (WinPos->hwnd == InsAfterWnd->spwndNext->head.h)))
1674 {
1675 WinPos->flags |= SWP_NOZORDER;
1676 }
1677 }
1678 }
1679 }
1680
1681 return TRUE;
1682}
1683
1684//
1685// This is a NC HACK fix for forcing painting of non client areas.
1686// Further troubleshooting in painting.c is required to remove this hack.
1687// See CORE-7166 & CORE-15934
1688//
1689VOID
1691{
1692 HDC hDC;
1693 PREGION RgnUpdate;
1694 UINT RgnType;
1695 BOOL Create = FALSE;
1696
1697 if (Wnd->hrgnUpdate == NULL)
1698 {
1699 Wnd->hrgnUpdate = NtGdiCreateRectRgn(0, 0, 0, 0);
1701 Create = TRUE;
1702 }
1703
1704 if (Wnd->hrgnUpdate != HRGN_WINDOW)
1705 {
1706 RgnUpdate = REGION_LockRgn(Wnd->hrgnUpdate);
1707 if (RgnUpdate)
1708 {
1709 RgnType = IntGdiCombineRgn(RgnUpdate, RgnUpdate, pRgn, RGN_OR);
1710 REGION_UnlockRgn(RgnUpdate);
1711 if (RgnType == NULLREGION)
1712 {
1715 Wnd->hrgnUpdate = NULL;
1716 Create = FALSE;
1717 }
1718 }
1719 }
1720
1721 IntSendNCPaint( Wnd, hRgn ); // Region can be deleted by the application.
1722
1723 if (Wnd->hrgnUpdate)
1724 {
1725 hDC = UserGetDCEx( Wnd,
1726 Wnd->hrgnUpdate,
1728
1730 // Kill the loop, so Clear before we send.
1732 {
1734 }
1735 UserReleaseDC(Wnd, hDC, FALSE);
1736 }
1737
1738 if (Create)
1739 {
1742 Wnd->hrgnUpdate = NULL;
1743 }
1744}
1745
1746/* x and y are always screen relative */
1749 PWND Window,
1750 HWND WndInsertAfter,
1751 INT x,
1752 INT y,
1753 INT cx,
1754 INT cy,
1755 UINT flags
1756 )
1757{
1758 WINDOWPOS WinPos;
1759 RECTL NewWindowRect;
1760 RECTL NewClientRect;
1761 RECTL valid_rects[2];
1762 PREGION VisBefore = NULL;
1763 PREGION VisBeforeJustClient = NULL;
1764 PREGION VisAfter = NULL;
1766 ULONG WvrFlags = 0;
1767 RECTL OldWindowRect, OldClientRect;
1768 int RgnType;
1769 HDC Dc;
1771 PWND Ancestor;
1772 BOOL bPointerInWindow, PosChanged = FALSE;
1774
1776
1777 TRACE("pwnd %p, after %p, %d,%d (%dx%d), flags 0x%x\n",
1778 Window, WndInsertAfter, x, y, cx, cy, flags);
1779#if DBG
1780 dump_winpos_flags(flags);
1781#endif
1782
1783 /* FIXME: Get current active window from active queue. Why? since r2915. */
1784
1785 bPointerInWindow = IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y);
1786
1787 WinPos.hwnd = Window->head.h;
1788 WinPos.hwndInsertAfter = WndInsertAfter;
1789 WinPos.x = x;
1790 WinPos.y = y;
1791 WinPos.cx = cx;
1792 WinPos.cy = cy;
1793 WinPos.flags = flags;
1794
1795 if ( flags & SWP_ASYNCWINDOWPOS )
1796 {
1797 LRESULT lRes;
1799 if ( ppos )
1800 {
1801 WinPos.flags &= ~SWP_ASYNCWINDOWPOS; // Clear flag.
1802 *ppos = WinPos;
1803 /* Yes it's a pointer inside Win32k! */
1804 lRes = co_IntSendMessageNoWait( WinPos.hwnd, WM_ASYNC_SETWINDOWPOS, 0, (LPARAM)ppos);
1805 /* We handle this the same way as Event Hooks and Hooks. */
1806 if ( !lRes )
1807 {
1809 return FALSE;
1810 }
1811 return TRUE;
1812 }
1813 return FALSE;
1814 }
1815
1816 co_WinPosDoWinPosChanging(Window, &WinPos, &NewWindowRect, &NewClientRect);
1817
1818 /* Does the window still exist? */
1819 if (!IntIsWindow(WinPos.hwnd))
1820 {
1821 TRACE("WinPosSetWindowPos: Invalid handle 0x%p!\n",WinPos.hwnd);
1823 return FALSE;
1824 }
1825
1826 /* Fix up the flags. */
1827 if (!WinPosFixupFlags(&WinPos, Window))
1828 {
1829 // See Note.
1830 return TRUE;
1831 }
1832
1833 Ancestor = UserGetAncestor(Window, GA_PARENT);
1834 if ( (WinPos.flags & (SWP_NOZORDER | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) != SWP_NOZORDER &&
1835 Ancestor && Ancestor->head.h == IntGetDesktopWindow() )
1836 {
1838 }
1839
1840 if (!(WinPos.flags & SWP_NOREDRAW))
1841 {
1842 /* Compute the visible region before the window position is changed */
1843 if (!(WinPos.flags & SWP_SHOWWINDOW) &&
1844 (WinPos.flags & (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1847 {
1849 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1850
1851 if ( VisBefore != NULL &&
1852 REGION_Complexity(VisBefore) == NULLREGION )
1853 {
1854 REGION_Delete(VisBefore);
1855 VisBefore = NULL;
1856 }
1857 else if(VisBefore)
1858 {
1859 REGION_bOffsetRgn(VisBefore, -Window->rcWindow.left, -Window->rcWindow.top);
1860 }
1861
1862 /* Calculate the non client area for resizes, as this is used in the copy region */
1863 if ((WinPos.flags & (SWP_NOSIZE | SWP_FRAMECHANGED)) != SWP_NOSIZE)
1864 {
1865 VisBeforeJustClient = VIS_ComputeVisibleRegion(Window, TRUE, FALSE,
1866 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1867
1868 if ( VisBeforeJustClient != NULL &&
1869 REGION_Complexity(VisBeforeJustClient) == NULLREGION )
1870 {
1871 REGION_Delete(VisBeforeJustClient);
1872 VisBeforeJustClient = NULL;
1873 }
1874 else if(VisBeforeJustClient)
1875 {
1876 REGION_bOffsetRgn(VisBeforeJustClient, -Window->rcWindow.left, -Window->rcWindow.top);
1877 }
1878 }
1879 }
1880 }
1881
1883 if (Window->hrgnNewFrame)
1884 {
1885 SelectWindowRgn( Window, Window->hrgnNewFrame ); // Should be PSMWP->acvr->hrgnClip
1886 Window->hrgnNewFrame = NULL;
1887 }
1888
1889 WvrFlags = co_WinPosDoNCCALCSize(Window, &WinPos, &NewWindowRect, &NewClientRect, valid_rects);
1890
1891// ERR("co_WinPosDoNCCALCSize returned 0x%x\n valid dest: %d %d %d %d\n valid src : %d %d %d %d\n", WvrFlags,
1892// valid_rects[0].left,valid_rects[0].top,valid_rects[0].right,valid_rects[0].bottom,
1893// valid_rects[1].left,valid_rects[1].top,valid_rects[1].right,valid_rects[1].bottom);
1894
1895 /* Validate link windows. (also take into account shell window in hwndShellWindow) */
1896 if (!(WinPos.flags & SWP_NOZORDER) && WinPos.hwnd != UserGetShellWindow())
1897 {
1899 }
1900
1901 OldWindowRect = Window->rcWindow;
1902 OldClientRect = Window->rcClient;
1903
1904 if (NewClientRect.left != OldClientRect.left ||
1905 NewClientRect.top != OldClientRect.top)
1906 {
1907 // Move child window if their parent is moved. Keep Child window relative to Parent...
1909 NewClientRect.left - OldClientRect.left,
1910 NewClientRect.top - OldClientRect.top);
1911 PosChanged = TRUE;
1912 }
1913
1914 Window->rcWindow = NewWindowRect;
1915 Window->rcClient = NewClientRect;
1916
1917 /* erase parent when hiding or resizing child */
1918 if (WinPos.flags & SWP_HIDEWINDOW)
1919 {
1920 /* Clear the update region */
1922 NULL,
1923 0,
1925
1926 if (UserIsDesktopWindow(Window->spwndParent))
1928
1929 Window->style &= ~WS_VISIBLE; //IntSetStyle( Window, 0, WS_VISIBLE );
1930 Window->head.pti->cVisWindows--;
1932 }
1933 else if (WinPos.flags & SWP_SHOWWINDOW)
1934 {
1935 if (Window->style & WS_CHILD)
1936 {
1937 if ((Window->style & WS_POPUP) && (Window->ExStyle & WS_EX_APPWINDOW))
1938 {
1940 if (!(WinPos.flags & SWP_NOACTIVATE))
1942 }
1943 }
1944 else if ((Window->ExStyle & WS_EX_APPWINDOW) ||
1945 (!(Window->ExStyle & WS_EX_TOOLWINDOW) && !Window->spwndOwner &&
1946 (!Window->spwndParent || UserIsDesktopWindow(Window->spwndParent))))
1947 {
1949 {
1951 if (!(WinPos.flags & SWP_NOACTIVATE))
1953 }
1954 }
1955
1956 Window->style |= WS_VISIBLE; //IntSetStyle( Window, WS_VISIBLE, 0 );
1957 Window->head.pti->cVisWindows++;
1959 }
1960 else
1961 {
1963 }
1964
1965 if (Window->hrgnUpdate != NULL && Window->hrgnUpdate != HRGN_WINDOW)
1966 {
1967 NtGdiOffsetRgn(Window->hrgnUpdate,
1968 NewWindowRect.left - OldWindowRect.left,
1969 NewWindowRect.top - OldWindowRect.top);
1970 }
1971
1972 DceResetActiveDCEs(Window); // For WS_VISIBLE changes.
1973
1974 // Change or update, set send non-client paint flag.
1975 if ( Window->style & WS_VISIBLE &&
1976 (WinPos.flags & SWP_STATECHANGED || (!(Window->state2 & WNDS2_WIN31COMPAT) && WinPos.flags & SWP_NOREDRAW ) ) )
1977 {
1978 TRACE("Set WNDS_SENDNCPAINT %p\n",Window);
1979 Window->state |= WNDS_SENDNCPAINT;
1980 }
1981
1982 if (!(WinPos.flags & SWP_NOREDRAW))
1983 {
1984 /* Determine the new visible region */
1986 (Window->style & WS_CLIPSIBLINGS) ? TRUE : FALSE);
1987
1988 if ( VisAfter != NULL &&
1989 REGION_Complexity(VisAfter) == NULLREGION )
1990 {
1991 REGION_Delete(VisAfter);
1992 VisAfter = NULL;
1993 }
1994 else if(VisAfter)
1995 {
1996 REGION_bOffsetRgn(VisAfter, -Window->rcWindow.left, -Window->rcWindow.top);
1997 }
1998
1999 /*
2000 * Determine which pixels can be copied from the old window position
2001 * to the new. Those pixels must be visible in both the old and new
2002 * position. Also, check the class style to see if the windows of this
2003 * class need to be completely repainted on (horizontal/vertical) size
2004 * change.
2005 */
2006 if ( ( VisBefore != NULL &&
2007 VisAfter != NULL &&
2008 !(WinPos.flags & SWP_NOCOPYBITS) &&
2009 ((WinPos.flags & SWP_NOSIZE) || !(WvrFlags & WVR_REDRAW)) &&
2010 !(Window->ExStyle & WS_EX_TRANSPARENT) ) )
2011 {
2012
2013 /*
2014 * If this is (also) a window resize, the whole nonclient area
2015 * needs to be repainted. So we limit the copy to the client area,
2016 * 'cause there is no use in copying it (would possibly cause
2017 * "flashing" too). However, if the copy region is already empty,
2018 * we don't have to crop (can't take anything away from an empty
2019 * region...)
2020 */
2021
2022 CopyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2023 if ((WinPos.flags & SWP_NOSIZE) && (WinPos.flags & SWP_NOCLIENTSIZE))
2024 RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBefore, RGN_AND);
2025 else if (VisBeforeJustClient != NULL)
2026 {
2027 RgnType = IntGdiCombineRgn(CopyRgn, VisAfter, VisBeforeJustClient, RGN_AND);
2028 }
2029
2030 if (VisBeforeJustClient != NULL)
2031 {
2032 REGION_Delete(VisBeforeJustClient);
2033 }
2034
2035 /* Now use in copying bits which are in the update region. */
2036 if (Window->hrgnUpdate != NULL)
2037 {
2038 PREGION RgnUpdate = REGION_LockRgn(Window->hrgnUpdate);
2039 if (RgnUpdate)
2040 {
2041 REGION_bOffsetRgn(CopyRgn, NewWindowRect.left, NewWindowRect.top);
2043 REGION_bOffsetRgn(CopyRgn, -NewWindowRect.left, -NewWindowRect.top);
2044 REGION_UnlockRgn(RgnUpdate);
2045 }
2046 }
2047
2048 /*
2049 * Now, get the bounding box of the copy region. If it's empty
2050 * there's nothing to copy. Also, it's no use copying bits onto
2051 * themselves.
2052 */
2054 {
2055 /* Nothing to copy, clean up */
2057 CopyRgn = NULL;
2058 }
2059 else if ( OldWindowRect.left != NewWindowRect.left ||
2060 OldWindowRect.top != NewWindowRect.top ||
2061 (WinPos.flags & SWP_FRAMECHANGED) )
2062 {
2063 HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
2064 PREGION DcRgnObj = REGION_LockRgn(DcRgn);
2065
2066 /*
2067 * Small trick here: there is no function to bitblt a region. So
2068 * we set the region as the clipping region, take the bounding box
2069 * of the region and bitblt that. Since nothing outside the clipping
2070 * region is copied, this has the effect of bitblt'ing the region.
2071 *
2072 * Since NtUserGetDCEx takes ownership of the clip region, we need
2073 * to create a copy of CopyRgn and pass that. We need CopyRgn later
2074 */
2076 REGION_bOffsetRgn(DcRgnObj, NewWindowRect.left, NewWindowRect.top);
2077 REGION_UnlockRgn(DcRgnObj);
2078 Dc = UserGetDCEx( Window,
2079 DcRgn,
2080 DCX_WINDOW|DCX_CACHE|DCX_INTERSECTRGN|DCX_CLIPSIBLINGS|DCX_KEEPCLIPRGN); // DCX_WINDOW will set first, go read WinDC.c.
2081 NtGdiBitBlt( Dc,
2082 CopyRect.left, CopyRect.top,
2083 CopyRect.right - CopyRect.left,
2084 CopyRect.bottom - CopyRect.top,
2085 Dc,
2086 CopyRect.left + (OldWindowRect.left - NewWindowRect.left),
2087 CopyRect.top + (OldWindowRect.top - NewWindowRect.top),
2088 SRCCOPY,
2089 0,
2090 0);
2091
2094 GreDeleteObject(DcRgn);
2095 }
2096 }
2097 else
2098 {
2099 CopyRgn = NULL;
2100 }
2101
2102 /* We need to redraw what wasn't visible before or force a redraw */
2103 if ((WinPos.flags & (SWP_FRAMECHANGED | SWP_SHOWWINDOW)) ||
2104 (((WinPos.flags & SWP_AGG_NOGEOMETRYCHANGE) != SWP_AGG_NOGEOMETRYCHANGE) && VisAfter != NULL))
2105 {
2106 PREGION DirtyRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2107 if (DirtyRgn)
2108 {
2109 if (CopyRgn != NULL)
2110 {
2111 RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, CopyRgn, RGN_DIFF);
2112 }
2113 else
2114 {
2115 RgnType = IntGdiCombineRgn(DirtyRgn, VisAfter, 0, RGN_COPY);
2116 }
2117
2118 if (RgnType != ERROR && RgnType != NULLREGION) // Regions moved.
2119 {
2120 /* old code
2121 NtGdiOffsetRgn(DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
2122 IntInvalidateWindows( Window,
2123 DirtyRgn,
2124 RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
2125 }
2126 GreDeleteObject(DirtyRgn);
2127 */
2128
2129 PWND Parent = Window->spwndParent;
2130
2131 REGION_bOffsetRgn( DirtyRgn, Window->rcWindow.left, Window->rcWindow.top);
2132
2133 if ( (Window->style & WS_CHILD) && (Parent) && !(Parent->style & WS_CLIPCHILDREN))
2134 {
2137 }
2139 }
2140 else if ( RgnType != ERROR && RgnType == NULLREGION ) // Must be the same. See CORE-7166 & CORE-15934, NC HACK fix.
2141 {
2142 if ( !PosChanged &&
2143 !(WinPos.flags & SWP_DEFERERASE) &&
2144 (WinPos.flags & SWP_FRAMECHANGED) )
2145 {
2146 PWND pwnd = Window;
2147 PWND Parent = Window->spwndParent;
2148
2149 if ( pwnd->style & WS_CHILD ) // Fix ProgMan menu bar drawing.
2150 {
2151 TRACE("SWP_FRAMECHANGED win child %p Parent %p\n",pwnd,Parent);
2152 pwnd = Parent ? Parent : pwnd;
2153 }
2154
2155 if ( !(pwnd->style & WS_CHILD) )
2156 {
2157 /*
2158 * Check if we have these specific windows style bits set/reset.
2159 * FIXME: There may be other combinations of styles that need this handling as well.
2160 * This fixes the ReactOS Calculator buttons disappearing in CORE-16827.
2161 */
2162 if ((Window->style & WS_CLIPSIBLINGS) && !(Window->style & (WS_POPUP | WS_CLIPCHILDREN | WS_SIZEBOX)))
2163 {
2164 IntSendNCPaint(pwnd, HRGN_WINDOW); // Paint the whole frame.
2165 }
2166 else // Use region handling
2167 {
2168 HRGN DcRgn = NtGdiCreateRectRgn(0, 0, 0, 0);
2169 PREGION DcRgnObj = REGION_LockRgn(DcRgn);
2170 TRACE("SWP_FRAMECHANGED win %p hRgn %p\n",pwnd, DcRgn);
2171 IntGdiCombineRgn(DcRgnObj, VisBefore, NULL, RGN_COPY);
2172 REGION_UnlockRgn(DcRgnObj);
2173 ForceNCPaintErase(pwnd, DcRgn, DcRgnObj);
2174 GreDeleteObject(DcRgn);
2175 }
2176 }
2177 }
2178 }
2179 REGION_Delete(DirtyRgn);
2180 }
2181 }
2182
2183 if (CopyRgn != NULL)
2184 {
2186 }
2187
2188 /* Expose what was covered before but not covered anymore */
2189 if ( VisBefore != NULL )
2190 {
2191 PREGION ExposedRgn = IntSysCreateRectpRgn(0, 0, 0, 0);
2192 if (ExposedRgn)
2193 {
2194 RgnType = IntGdiCombineRgn(ExposedRgn, VisBefore, NULL, RGN_COPY);
2195 REGION_bOffsetRgn(ExposedRgn,
2196 OldWindowRect.left - NewWindowRect.left,
2197 OldWindowRect.top - NewWindowRect.top);
2198
2199 if ( VisAfter != NULL )
2200 RgnType = IntGdiCombineRgn(ExposedRgn, ExposedRgn, VisAfter, RGN_DIFF);
2201
2202 if (RgnType != ERROR && RgnType != NULLREGION)
2203 {
2205 }
2206 REGION_Delete(ExposedRgn);
2207 }
2208 REGION_Delete(VisBefore);
2209 }
2210
2211 if (VisAfter != NULL)
2212 {
2213 REGION_Delete(VisAfter);
2214 }
2215 }
2216
2217 if (!(WinPos.flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)))
2218 {
2219 if ((Window->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
2220 {
2222 }
2223 else
2224 {
2225 //ERR("SetWindowPos Set FG Window!\n");
2226 if ( pti->MessageQueue->spwndActive != Window ||
2227 pti->MessageQueue != gpqForeground )
2228 {
2229 //ERR("WPSWP : set active window\n");
2230 if (!(Window->state & WNDS_BEINGACTIVATED)) // Inside SAW?
2231 {
2232 co_IntSetForegroundWindow(Window); // Fixes SW_HIDE issues. Wine win test_SetActiveWindow & test_SetForegroundWindow.
2233 }
2234 }
2235 }
2236 }
2237
2238 if ( !PosChanged &&
2239 (WinPos.flags & SWP_FRAMECHANGED) &&
2240 !(WinPos.flags & SWP_DEFERERASE) && // Prevent sending WM_SYNCPAINT message.
2241 VisAfter )
2242 {
2243 PWND Parent = Window->spwndParent;
2244 if ( !(Window->style & WS_CHILD) && (Parent) && (Parent->style & WS_CLIPCHILDREN))
2245 {
2246 TRACE("SWP_FRAMECHANGED Parent %p WS_CLIPCHILDREN %p\n",Parent,Window);
2247 UserSyncAndPaintWindows( Parent, RDW_CLIPCHILDREN); // NC should redraw here, see NC HACK fix.
2248 }
2249 }
2250
2251 // Fix wine msg test_SetFocus, prevents sending WM_WINDOWPOSCHANGED.
2252 if ( VisBefore == NULL &&
2253 VisBeforeJustClient == NULL &&
2254 !(Window->ExStyle & WS_EX_TOPMOST) &&
2256 {
2257 TRACE("No drawing, set no Z order and no redraw!\n");
2259 }
2260
2261 if(!(flags & SWP_DEFERERASE))
2262 {
2263 /* erase parent when hiding or resizing child */
2264 if ((flags & SWP_HIDEWINDOW) ||
2265 (!(flags & SWP_SHOWWINDOW) &&
2267 {
2268 PWND Parent = Window->spwndParent;
2271 }
2272
2273 /* Give newly shown windows a chance to redraw */
2276 {
2278 }
2279 }
2280
2281 /* And last, send the WM_WINDOWPOSCHANGED message */
2282
2283 TRACE("\tstatus hwnd %p flags = %04x\n",Window?Window->head.h:NULL,WinPos.flags & SWP_AGG_STATUSFLAGS);
2284
2287 {
2288 /* WM_WINDOWPOSCHANGED is sent even if SWP_NOSENDCHANGING is set
2289 and always contains final window position.
2290 */
2291 WinPos.x = NewWindowRect.left;
2292 WinPos.y = NewWindowRect.top;
2293 WinPos.cx = NewWindowRect.right - NewWindowRect.left;
2294 WinPos.cy = NewWindowRect.bottom - NewWindowRect.top;
2295 TRACE("WM_WINDOWPOSCHANGED hwnd %p Flags %04x\n",WinPos.hwnd,WinPos.flags);
2297 }
2298
2299 if ( WinPos.flags & SWP_FRAMECHANGED || WinPos.flags & SWP_STATECHANGED ||
2300 !(WinPos.flags & SWP_NOCLIENTSIZE) || !(WinPos.flags & SWP_NOCLIENTMOVE) )
2301 {
2302 PWND pWnd = ValidateHwndNoErr(WinPos.hwnd);
2303 if (pWnd)
2304 IntNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, pWnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
2305 }
2306
2307 if(bPointerInWindow != IntPtInWindow(Window, gpsi->ptCursor.x, gpsi->ptCursor.y))
2308 {
2309 /* Generate mouse move message */
2310 MSG msg;
2311 msg.message = WM_MOUSEMOVE;
2312 msg.wParam = UserGetMouseButtonsState();
2313 msg.lParam = MAKELPARAM(gpsi->ptCursor.x, gpsi->ptCursor.y);
2314 msg.pt = gpsi->ptCursor;
2316 }
2317
2318 return TRUE;
2319}
2320
2323{
2325
2327
2328 *ClientRect = *WindowRect;
2330
2331 FixClientRect(ClientRect, WindowRect);
2332
2333 return Result;
2334}
2335
2336void FASTCALL
2338{
2339 RECTL Rect;
2340 LPARAM lParam;
2342
2343 IntGetClientRect(Wnd, &Rect);
2344 lParam = MAKELONG(Rect.right-Rect.left, Rect.bottom-Rect.top);
2345
2346 Wnd->state &= ~WNDS_SENDSIZEMOVEMSGS;
2347
2348 if (Wnd->style & WS_MAXIMIZE)
2349 {
2351 }
2352 else if (Wnd->style & WS_MINIMIZE)
2353 {
2355 lParam = 0;
2356 }
2357
2359
2361 lParam = MAKELONG(Wnd->rcClient.left, Wnd->rcClient.top);
2362 else
2363 lParam = MAKELONG(Wnd->rcClient.left-Wnd->spwndParent->rcClient.left, Wnd->rcClient.top-Wnd->spwndParent->rcClient.top);
2364
2366
2368}
2369
2371co_WinPosMinMaximize(PWND Wnd, UINT ShowFlag, RECT* NewPos)
2372{
2373 POINT Size;
2374 WINDOWPLACEMENT wpl;
2375 LONG old_style;
2376 UINT SwpFlags = 0;
2377
2378 ASSERT_REFS_CO(Wnd);
2379
2380 wpl.length = sizeof(wpl);
2381 IntGetWindowPlacement( Wnd, &wpl );
2382
2383 if (co_HOOK_CallHooks( WH_CBT, HCBT_MINMAX, (WPARAM)Wnd->head.h, ShowFlag))
2384 {
2385 ERR("WinPosMinMaximize WH_CBT Call Hook return!\n");
2386 return SWP_NOSIZE | SWP_NOMOVE;
2387 }
2388 if (Wnd->style & WS_MINIMIZE)
2389 {
2390 switch (ShowFlag)
2391 {
2392 case SW_MINIMIZE:
2393 case SW_SHOWMINNOACTIVE:
2394 case SW_SHOWMINIMIZED:
2395 case SW_FORCEMINIMIZE:
2396 return SWP_NOSIZE | SWP_NOMOVE;
2397 }
2398 if (!co_IntSendMessageNoWait(Wnd->head.h, WM_QUERYOPEN, 0, 0))
2399 {
2400 return(SWP_NOSIZE | SWP_NOMOVE);
2401 }
2402 SwpFlags |= SWP_NOCOPYBITS;
2403 }
2404 switch (ShowFlag)
2405 {
2406 case SW_MINIMIZE:
2407 case SW_SHOWMINNOACTIVE:
2408 case SW_SHOWMINIMIZED:
2409 case SW_FORCEMINIMIZE:
2410 {
2411 //ERR("MinMaximize Minimize\n");
2412 if (Wnd->style & WS_MAXIMIZE)
2413 {
2414 Wnd->InternalPos.flags |= WPF_RESTORETOMAXIMIZED;
2415 }
2416 else
2417 {
2418 Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
2419 }
2420
2421 old_style = IntSetStyle( Wnd, WS_MINIMIZE, WS_MAXIMIZE );
2422
2424
2425 if (!(Wnd->InternalPos.flags & WPF_SETMINPOSITION))
2426 Wnd->InternalPos.flags &= ~WPF_MININIT;
2427
2429
2430 if (!(old_style & WS_MINIMIZE))
2431 {
2432 SwpFlags |= SWP_STATECHANGED;
2434 }
2435
2436 RECTL_vSetRect(NewPos, wpl.ptMinPosition.x, wpl.ptMinPosition.y,
2439 SwpFlags |= SWP_NOCOPYBITS;
2440 break;
2441 }
2442
2443 case SW_MAXIMIZE:
2444 {
2445 //ERR("MinMaximize Maximize\n");
2446 if ((Wnd->style & WS_MAXIMIZE) && (Wnd->style & WS_VISIBLE))
2447 {
2448 SwpFlags = SWP_NOSIZE | SWP_NOMOVE;
2449 break;
2450 }
2452
2453 /*ERR("Maximize: %d,%d %dx%d\n",
2454 wpl.ptMaxPosition.x, wpl.ptMaxPosition.y, Size.x, Size.y);
2455 */
2456 old_style = IntSetStyle( Wnd, WS_MAXIMIZE, WS_MINIMIZE );
2457 /*if (old_style & WS_MINIMIZE)
2458 {
2459 IntShowOwnedPopups(Wnd, TRUE);
2460 }*/
2461
2462 if (!(old_style & WS_MAXIMIZE)) SwpFlags |= SWP_STATECHANGED;
2463 RECTL_vSetRect(NewPos, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
2464 //wpl.ptMaxPosition.x + Size.x, wpl.ptMaxPosition.y + Size.y);
2465 Size.x, Size.y);
2466 break;
2467 }
2468
2469 case SW_SHOWNOACTIVATE:
2470 Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
2471 /* fall through */
2472 case SW_SHOWNORMAL:
2473 case SW_RESTORE:
2474 case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
2475 {
2476 //ERR("MinMaximize Restore\n");
2477 old_style = IntSetStyle( Wnd, 0, WS_MINIMIZE | WS_MAXIMIZE );
2478 if (old_style & WS_MINIMIZE)
2479 {
2481
2482 if (Wnd->InternalPos.flags & WPF_RESTORETOMAXIMIZED)
2483 {
2485 IntSetStyle( Wnd, WS_MAXIMIZE, 0 );
2486 SwpFlags |= SWP_STATECHANGED;
2487 RECTL_vSetRect(NewPos, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
2488 wpl.ptMaxPosition.x + Size.x, wpl.ptMaxPosition.y + Size.y);
2489 break;
2490 }
2491 else
2492 {
2493 *NewPos = wpl.rcNormalPosition;
2494 NewPos->right -= NewPos->left;
2495 NewPos->bottom -= NewPos->top;
2496 break;
2497 }
2498 }
2499 else
2500 {
2501 if (!(old_style & WS_MAXIMIZE))
2502 {
2503 break;
2504 }
2505 SwpFlags |= SWP_STATECHANGED;
2506 Wnd->InternalPos.flags &= ~WPF_RESTORETOMAXIMIZED;
2507 *NewPos = wpl.rcNormalPosition;
2508 NewPos->right -= NewPos->left;
2509 NewPos->bottom -= NewPos->top;
2510 break;
2511 }
2512 }
2513 }
2514 return SwpFlags;
2515}
2516
2517/*
2518 ShowWindow does not set SWP_FRAMECHANGED!!! Fix wine msg test_SetParent:WmSetParentSeq_2:23 wParam bits!
2519 Win: xxxShowWindow
2520 */
2523{
2524 BOOLEAN WasVisible;
2525 UINT Swp = 0, EventMsg = 0;
2526 RECTL NewPos = {0, 0, 0, 0};
2527 BOOLEAN ShowFlag;
2528 LONG style;
2529 PWND Parent;
2530 PTHREADINFO pti;
2531 //HRGN VisibleRgn;
2532 BOOL ShowOwned = FALSE;
2533 BOOL FirstTime = FALSE;
2534 ASSERT_REFS_CO(Wnd);
2535 //KeRosDumpStackFrames(NULL, 20);
2537 WasVisible = (Wnd->style & WS_VISIBLE) != 0;
2538 style = Wnd->style;
2539
2540 TRACE("co_WinPosShowWindow START hwnd %p Cmd %d usicmd %u\n",
2541 Wnd->head.h, Cmd, pti->ppi->usi.wShowWindow);
2542
2543 if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
2544 {
2545 if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD)
2546 {
2547 if ((Wnd->style & WS_CAPTION) == WS_CAPTION)
2548 {
2549 if (Wnd->spwndOwner == NULL)
2550 {
2551 if ( Cmd == SW_SHOWNORMAL || Cmd == SW_SHOW)
2552 {
2554 }
2555 FirstTime = TRUE;
2556 TRACE("co_WPSW FT 1\n");
2557 }
2558 }
2559 }
2560 }
2561
2562 if ( Cmd == SW_SHOWDEFAULT )
2563 {
2564 if ( pti->ppi->usi.dwFlags & STARTF_USESHOWWINDOW )
2565 {
2566 Cmd = pti->ppi->usi.wShowWindow;
2567 FirstTime = TRUE;
2568 TRACE("co_WPSW FT 2\n");
2569 }
2570 }
2571
2572 if (FirstTime)
2573 {
2575 }
2576
2577 switch (Cmd)
2578 {
2579 case SW_HIDE:
2580 {
2581 if (!WasVisible)
2582 {
2583 //ERR("co_WinPosShowWindow Exit Bad\n");
2584 return FALSE;
2585 }
2587 if (Wnd != pti->MessageQueue->spwndActive)
2589 break;
2590 }
2591
2592 case SW_FORCEMINIMIZE: /* FIXME: Does not work if thread is hung. */
2593 case SW_SHOWMINNOACTIVE:
2595 /* Fall through. */
2596 case SW_SHOWMINIMIZED:
2597 case SW_MINIMIZE: /* CORE-15669: SW_MINIMIZE also shows */
2598 Swp |= SWP_SHOWWINDOW;
2599 {
2600 Swp |= SWP_NOACTIVATE;
2601 if (!(style & WS_MINIMIZE))
2602 {
2604 // Fix wine Win test_SetFocus todo #1 & #2,
2605 if (Cmd == SW_SHOWMINIMIZED)
2606 {
2607 //ERR("co_WinPosShowWindow Set focus 1\n");
2608 if ((style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
2610 else
2611 co_UserSetFocus(0);
2612 }
2613
2614 Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
2615
2616 EventMsg = EVENT_SYSTEM_MINIMIZESTART;
2617 }
2618 else
2619 {
2620 if (WasVisible)
2621 {
2622 //ERR("co_WinPosShowWindow Exit Good\n");
2623 return TRUE;
2624 }
2625 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2626 }
2627 break;
2628 }
2629
2630 case SW_SHOWMAXIMIZED:
2631 {
2632 Swp |= SWP_SHOWWINDOW;
2633 if (!(style & WS_MAXIMIZE))
2634 {
2635 ShowOwned = TRUE;
2636
2637 Swp |= co_WinPosMinMaximize(Wnd, SW_MAXIMIZE, &NewPos);
2638
2639 EventMsg = EVENT_SYSTEM_MINIMIZEEND;
2640 }
2641 else
2642 {
2643 if (WasVisible)
2644 {
2645 //ERR("co_WinPosShowWindow Exit Good 1\n");
2646 return TRUE;
2647 }
2648 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2649 }
2650 break;
2651 }
2652
2653 case SW_SHOWNA:
2655 if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOZORDER;
2656 break;
2657 case SW_SHOW:
2658 if (WasVisible) return(TRUE); // Nothing to do!
2660 /* Don't activate the topmost window. */
2661 if (style & WS_CHILD && !(Wnd->ExStyle & WS_EX_MDICHILD)) Swp |= SWP_NOACTIVATE | SWP_NOZORDER;
2662 break;
2663
2664 case SW_SHOWNOACTIVATE:
2666 /* Fall through. */
2667 case SW_SHOWNORMAL:
2668 case SW_SHOWDEFAULT:
2669 case SW_RESTORE:
2670 if (!WasVisible) Swp |= SWP_SHOWWINDOW;
2671 if (style & (WS_MINIMIZE | WS_MAXIMIZE))
2672 {
2673 Swp |= co_WinPosMinMaximize(Wnd, Cmd, &NewPos);
2674 if (style & WS_MINIMIZE) EventMsg = EVENT_SYSTEM_MINIMIZEEND;
2675 }
2676 else
2677 {
2678 if (WasVisible)
2679 {
2680 //ERR("co_WinPosShowWindow Exit Good 3\n");
2681 return TRUE;
2682 }
2683 Swp |= SWP_NOSIZE | SWP_NOMOVE;
2684 }
2685 if ( style & WS_CHILD &&
2686 !(Wnd->ExStyle & WS_EX_MDICHILD) &&
2687 !(Swp & SWP_STATECHANGED))
2689 break;
2690
2691 default:
2692 //ERR("co_WinPosShowWindow Exit Good 4\n");
2693 return FALSE;
2694 }
2695
2696 ShowFlag = (Cmd != SW_HIDE);
2697
2698 if ((ShowFlag != WasVisible || Cmd == SW_SHOWNA) && Cmd != SW_SHOWMAXIMIZED && !(Swp & SWP_STATECHANGED))
2699 {
2700 co_IntSendMessageNoWait(Wnd->head.h, WM_SHOWWINDOW, ShowFlag, 0);
2701#if 0 // Fix wine msg test_SetParent:WmSetParentSeq_1:2
2702 if (!(Wnd->state2 & WNDS2_WIN31COMPAT)) // <------------- XP sets this bit!
2703 co_IntSendMessageNoWait(Wnd->head.h, WM_SETVISIBLE, ShowFlag, 0);
2704#endif
2705 if (!VerifyWnd(Wnd)) return WasVisible;
2706 }
2707
2708 /* We can't activate a child window */
2709 if ((Wnd->style & WS_CHILD) &&
2710 !(Wnd->ExStyle & WS_EX_MDICHILD) &&
2711 Cmd != SW_SHOWNA)
2712 {
2713 //ERR("SWP Child No active and ZOrder\n");
2715 }
2716
2717#if 0 // Explorer issues with common controls? Someone does not know how CS_SAVEBITS works.
2718 // Breaks startup and shutdown active window...
2719 if ((Wnd->style & (WS_POPUP|WS_CHILD)) != WS_CHILD &&
2720 Wnd->pcls->style & CS_SAVEBITS &&
2721 ((Cmd == SW_SHOW) || (Cmd == SW_NORMAL)))
2722 {
2723 ERR("WinPosShowWindow Set active\n");
2724 //UserSetActiveWindow(Wnd);
2725 co_IntSetForegroundWindow(Wnd); // HACK
2727 }
2728#endif
2729
2730 if (IsChildVisible(Wnd) || Swp & SWP_STATECHANGED)
2731 {
2732 TRACE("Child is Vis %s or State changed %s. ShowFlag %s Swp %04x\n",
2733 (IsChildVisible(Wnd) ? "TRUE" : "FALSE"), (Swp & SWP_STATECHANGED ? "TRUE" : "FALSE"),
2734 (ShowFlag ? "TRUE" : "FALSE"),LOWORD(Swp));
2736 0 != (Wnd->ExStyle & WS_EX_TOPMOST) ? HWND_TOPMOST : HWND_TOP,
2737 NewPos.left,
2738 NewPos.top,
2739 NewPos.right, // NewPos.right - NewPos.left, when minimized and restore, the window becomes smaller.
2740 NewPos.bottom,// NewPos.bottom - NewPos.top,
2741 LOWORD(Swp));
2742 }
2743 else
2744 {
2745 TRACE("Parent Vis?\n");
2746 /* if parent is not visible simply toggle WS_VISIBLE and return */
2747 if (ShowFlag) IntSetStyle( Wnd, WS_VISIBLE, 0 );
2748 else IntSetStyle( Wnd, 0, WS_VISIBLE );
2749 }
2750
2751 if ( EventMsg ) IntNotifyWinEvent(EventMsg, Wnd, OBJID_WINDOW, CHILDID_SELF, WEF_SETBYWNDPTI);
2752
2753 if ( ShowOwned ) IntShowOwnedPopups(Wnd, TRUE );
2754
2755 if ((Cmd == SW_HIDE) || (Cmd == SW_MINIMIZE))
2756 {
2757 if ( Wnd == pti->MessageQueue->spwndActive && pti->MessageQueue == IntGetFocusMessageQueue() )
2758 {
2760 {
2761 if (!ActivateOtherWindowMin(Wnd))
2762 {
2764 }
2765 }
2766 else
2767 {
2769 }
2770 }
2771
2772 /* Revert focus to parent */
2773 if (Wnd == pti->MessageQueue->spwndFocus)
2774 {
2775 Parent = Wnd->spwndParent;
2777 Parent = 0;
2779 }
2780 // Hide, just return.
2781 if (Cmd == SW_HIDE) return WasVisible;
2782 }
2783
2784 /* FIXME: Check for window destruction. */
2785
2786 if ((Wnd->state & WNDS_SENDSIZEMOVEMSGS) &&
2787 !(Wnd->state2 & WNDS2_INDESTROY))
2788 {
2790 }
2791
2792 /* if previous state was minimized Windows sets focus to the window */
2793 if (style & WS_MINIMIZE)
2794 {
2795 co_UserSetFocus(Wnd);
2796 // Fix wine Win test_SetFocus todo #3,
2798 }
2799 //ERR("co_WinPosShowWindow EXIT\n");
2800 return WasVisible;
2801}
2802
2803static PWND
2805 IN PWND ScopeWin,
2806 IN POINT *Point,
2807 IN OUT USHORT *HitTest,
2808 IN BOOL Ignore
2809 )
2810{
2811 HWND *List, *phWnd;
2812 PWND pwndChild = NULL;
2813
2814 /* not visible */
2815 if (!(ScopeWin->style & WS_VISIBLE))
2816 {
2817 return NULL;
2818 }
2819
2820 /* not in window or in window region */
2821 if (!IntPtInWindow(ScopeWin, Point->x, Point->y))
2822 {
2823 return NULL;
2824 }
2825
2826 /* transparent */
2827 if ((ScopeWin->ExStyle & (WS_EX_LAYERED|WS_EX_TRANSPARENT)) == (WS_EX_LAYERED|WS_EX_TRANSPARENT))
2828 {
2829 return NULL;
2830 }
2831
2832 if (!Ignore && (ScopeWin->style & WS_DISABLED))
2833 { /* disabled child */
2834 if ((ScopeWin->style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return NULL;
2835 /* process the hit error */
2836 *HitTest = HTERROR;
2837 return ScopeWin;
2838 }
2839
2840 /* not minimized and check if point is inside the window */
2841 if (!(ScopeWin->style & WS_MINIMIZE) &&
2842 RECTL_bPointInRect(&ScopeWin->rcClient, Point->x, Point->y) )
2843 {
2844 UserReferenceObject(ScopeWin);
2845
2846 List = IntWinListChildren(ScopeWin);
2847 if (List)
2848 {
2849 for (phWnd = List; *phWnd; ++phWnd)
2850 {
2851 if (!(pwndChild = ValidateHwndNoErr(*phWnd)))
2852 {
2853 continue;
2854 }
2855
2856 pwndChild = co_WinPosSearchChildren(pwndChild, Point, HitTest, Ignore);
2857
2858 if (pwndChild != NULL)
2859 {
2860 /* We found a window. Don't send any more WM_NCHITTEST messages */
2862 UserDereferenceObject(ScopeWin);
2863 return pwndChild;
2864 }
2865 }
2867 }
2868 UserDereferenceObject(ScopeWin);
2869 }
2870
2871 if (ScopeWin->head.pti == PsGetCurrentThreadWin32Thread())
2872 {
2873 *HitTest = (USHORT)co_IntSendMessage(ScopeWin->head.h, WM_NCHITTEST, 0, MAKELONG(Point->x, Point->y));
2874
2875 if ((*HitTest) == (USHORT)HTTRANSPARENT)
2876 {
2877 return NULL;
2878 }
2879 }
2880 else
2881 {
2882 if (*HitTest == HTNOWHERE && pwndChild == NULL) *HitTest = HTCLIENT;
2883 }
2884
2885 return ScopeWin;
2886}
2887
2890 IN PWND ScopeWin,
2891 IN POINT *WinPoint,
2892 IN OUT USHORT* HitTest,
2893 IN BOOL Ignore)
2894{
2895 PWND Window;
2896 POINT Point = *WinPoint;
2898
2899 if( ScopeWin == NULL )
2900 {
2901 ScopeWin = UserGetDesktopWindow();
2902 if(ScopeWin == NULL)
2903 return NULL;
2904 }
2905
2906 *HitTest = HTNOWHERE;
2907
2908 ASSERT_REFS_CO(ScopeWin);
2909 UserRefObjectCo(ScopeWin, &Ref);
2910
2911 Window = co_WinPosSearchChildren(ScopeWin, &Point, HitTest, Ignore);
2912
2913 UserDerefObjectCo(ScopeWin);
2914 if (Window)
2916 ASSERT_REFS_CO(ScopeWin);
2917
2918 return Window;
2919}
2920
2923{
2924 POINTL Pt;
2925 HWND *List, *phWnd;
2926 PWND pwndHit = NULL;
2927
2928 Pt.x = x;
2929 Pt.y = y;
2930
2932 {
2933 Pt.x += Parent->rcClient.left;
2934 Pt.y += Parent->rcClient.top;
2935 }
2936
2937 if (!IntPtInWindow(Parent, Pt.x, Pt.y)) return NULL;
2938
2940 {
2941 for (phWnd = List; *phWnd; phWnd++)
2942 {
2943 PWND Child;
2944 if ((Child = ValidateHwndNoErr(*phWnd)))
2945 {
2946 if ( Child->style & WS_VISIBLE && IntPtInWindow(Child, Pt.x, Pt.y) )
2947 {
2948 if ( Child->pcls->atomClassName != gpsi->atomSysClass[ICLS_BUTTON] ||
2949 (Child->style & BS_TYPEMASK) != BS_GROUPBOX )
2950 {
2952 return Child;
2953 }
2954 pwndHit = Child;
2955 }
2956 }
2957 }
2959 }
2960 return pwndHit ? pwndHit : Parent;
2961}
2962
2965{
2966 POINTL Pt;
2967 HWND *List, *phWnd;
2968 PWND pwndHit = NULL;
2969
2970 Pt.x = x;
2971 Pt.y = y;
2972
2974 {
2975 if (Parent->ExStyle & WS_EX_LAYOUTRTL)
2976 Pt.x = Parent->rcClient.right - Pt.x;
2977 else
2978 Pt.x += Parent->rcClient.left;
2979 Pt.y += Parent->rcClient.top;
2980 }
2981
2982 if (!IntPtInWindow(Parent, Pt.x, Pt.y)) return NULL;
2983
2985 {
2986 for (phWnd = List; *phWnd; phWnd++)
2987 {
2988 PWND Child;
2989 if ((Child = ValidateHwndNoErr(*phWnd)))
2990 {
2991 if (uiFlags & (CWP_SKIPINVISIBLE|CWP_SKIPDISABLED))
2992 {
2993 if (!(Child->style & WS_VISIBLE) && (uiFlags & CWP_SKIPINVISIBLE)) continue;
2994 if ((Child->style & WS_DISABLED) && (uiFlags & CWP_SKIPDISABLED)) continue;
2995 }
2996
2997 if (uiFlags & CWP_SKIPTRANSPARENT)
2998 {
2999 if (Child->ExStyle & WS_EX_TRANSPARENT) continue;
3000 }
3001
3002 if (IntPtInWindow(Child, Pt.x, Pt.y))
3003 {
3004 pwndHit = Child;
3005 break;
3006 }
3007 }
3008 }
3010 }
3011 return pwndHit ? pwndHit : Parent;
3012}
3013
3014HDWP
3017 HWND hwnd,
3018 HWND hwndAfter,
3019 INT x,
3020 INT y,
3021 INT cx,
3022 INT cy,
3023 UINT flags )
3024{
3025 PSMWP pDWP;
3026 int i;
3027 HDWP retvalue = hdwp;
3028
3029 TRACE("hdwp %p, hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
3030 hdwp, hwnd, hwndAfter, x, y, cx, cy, flags);
3031
3032 if (flags & ~(SWP_NOSIZE | SWP_NOMOVE |
3037 {
3039 return NULL;
3040 }
3041
3042 if (!(pDWP = (PSMWP)UserGetObject(gHandleTable, hdwp, TYPE_SETWINDOWPOS)))
3043 {
3045 return NULL;
3046 }
3047
3048 for (i = 0; i < pDWP->ccvr; i++)
3049 {
3050 if (pDWP->acvr[i].pos.hwnd == hwnd)
3051 {
3052 /* Merge with the other changes */
3053 if (!(flags & SWP_NOZORDER))
3054 {
3055 pDWP->acvr[i].pos.hwndInsertAfter = hwndAfter;
3056 }
3057 if (!(flags & SWP_NOMOVE))
3058 {
3059 pDWP->acvr[i].pos.x = x;
3060 pDWP->acvr[i].pos.y = y;
3061 }
3062 if (!(flags & SWP_NOSIZE))
3063 {
3064 pDWP->acvr[i].pos.cx = cx;
3065 pDWP->acvr[i].pos.cy = cy;
3066 }
3067 pDWP->acvr[i].pos.flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
3073 goto END;
3074 }
3075 }
3076 if (pDWP->ccvr >= pDWP->ccvrAlloc)
3077 {
3078 PCVR newpos = ExAllocatePoolWithTag(PagedPool, pDWP->ccvrAlloc * 2 * sizeof(CVR), USERTAG_SWP);
3079 if (!newpos)
3080 {
3081 retvalue = NULL;
3082 goto END;
3083 }
3084 RtlZeroMemory(newpos, pDWP->ccvrAlloc * 2 * sizeof(CVR));
3085 RtlCopyMemory(newpos, pDWP->acvr, pDWP->ccvrAlloc * sizeof(CVR));
3087 pDWP->ccvrAlloc *= 2;
3088 pDWP->acvr = newpos;
3089 }
3090 pDWP->acvr[pDWP->ccvr].pos.hwnd = hwnd;
3091 pDWP->acvr[pDWP->ccvr].pos.hwndInsertAfter = hwndAfter;
3092 pDWP->acvr[pDWP->ccvr].pos.x = x;
3093 pDWP->acvr[pDWP->ccvr].pos.y = y;
3094 pDWP->acvr[pDWP->ccvr].pos.cx = cx;
3095 pDWP->acvr[pDWP->ccvr].pos.cy = cy;
3096 pDWP->acvr[pDWP->ccvr].pos.flags = flags;
3097 pDWP->acvr[pDWP->ccvr].hrgnClip = NULL;
3098 pDWP->acvr[pDWP->ccvr].hrgnInterMonitor = NULL;
3099 pDWP->ccvr++;
3100END:
3101 return retvalue;
3102}
3103
3105{
3106 PSMWP pDWP;
3107 PCVR winpos;
3108 BOOL res = TRUE;
3109 int i;
3110
3111 TRACE("%p\n", hdwp);
3112
3113 if (!(pDWP = (PSMWP)UserGetObject(gHandleTable, hdwp, TYPE_SETWINDOWPOS)))
3114 {
3116 return FALSE;
3117 }
3118
3119 for (i = 0, winpos = pDWP->acvr; res && i < pDWP->ccvr; i++, winpos++)
3120 {
3121 PWND pwnd;
3123
3124 TRACE("hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
3125 winpos->pos.hwnd, winpos->pos.hwndInsertAfter, winpos->pos.x, winpos->pos.y,
3126 winpos->pos.cx, winpos->pos.cy, winpos->pos.flags);
3127
3128 pwnd = ValidateHwndNoErr(winpos->pos.hwnd);
3129 if (!pwnd)
3130 continue;
3131
3132 UserRefObjectCo(pwnd, &Ref);
3133
3134 if ( sAsync )
3135 {
3136 LRESULT lRes;
3138 if ( ppos )
3139 {
3140 *ppos = winpos->pos;
3141 /* Yes it's a pointer inside Win32k! */
3142 lRes = co_IntSendMessageNoWait( winpos->pos.hwnd, WM_ASYNC_SETWINDOWPOS, 0, (LPARAM)ppos);
3143 /* We handle this the same way as Event Hooks and Hooks. */
3144 if ( !lRes )
3145 {
3147 }
3148 }
3149 }
3150 else
3151 res = co_WinPosSetWindowPos( pwnd,
3152 winpos->pos.hwndInsertAfter,
3153 winpos->pos.x,
3154 winpos->pos.y,
3155 winpos->pos.cx,
3156 winpos->pos.cy,
3157 winpos->pos.flags);
3158
3159 // Hack to pass tests.... Must have some work to do so clear the error.
3160 if (res && (winpos->pos.flags & (SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER)) == SWP_NOZORDER )
3162
3163 UserDerefObjectCo(pwnd);
3164 }
3168 return res;
3169}
3170
3171/*
3172 * @implemented
3173 */
3176 LONG x,
3177 LONG y,
3178 UINT uiFlags)
3179{
3180 PWND pwndParent;
3181 TRACE("Enter NtUserChildWindowFromPointEx\n");
3183 if ((pwndParent = UserGetWindowObject(hwndParent)))
3184 {
3185 pwndParent = IntChildWindowFromPointEx(pwndParent, x, y, uiFlags);
3186 }
3187 UserLeave();
3188 TRACE("Leave NtUserChildWindowFromPointEx\n");
3189 return pwndParent ? UserHMGetHandle(pwndParent) : NULL;
3190}
3191
3192/*
3193 * @implemented
3194 */
3197 BOOL bAsync)
3198{
3199 BOOL Ret;
3200 TRACE("Enter NtUserEndDeferWindowPosEx\n");
3202 Ret = IntEndDeferWindowPosEx(WinPosInfo, bAsync);
3203 TRACE("Leave NtUserEndDeferWindowPosEx, ret=%i\n", Ret);
3204 UserLeave();
3205 return Ret;
3206}
3207
3208/*
3209 * @implemented
3210 */
3211HDWP APIENTRY
3212NtUserDeferWindowPos(HDWP WinPosInfo,
3213 HWND Wnd,
3214 HWND WndInsertAfter,
3215 int x,
3216 int y,
3217 int cx,
3218 int cy,
3219 UINT Flags)
3220{
3221 PWND pWnd, pWndIA;
3222 HDWP Ret = NULL;
3226
3227 TRACE("Enter NtUserDeferWindowPos\n");
3229
3230 if ( Flags & Tmp )
3231 {
3233 goto Exit;
3234 }
3235
3236 pWnd = UserGetWindowObject(Wnd);
3237 if (!pWnd || UserIsDesktopWindow(pWnd) || UserIsMessageWindow(pWnd))
3238 {
3239 goto Exit;
3240 }
3241
3242 if ( WndInsertAfter &&
3243 WndInsertAfter != HWND_BOTTOM &&
3244 WndInsertAfter != HWND_TOPMOST &&
3245 WndInsertAfter != HWND_NOTOPMOST )
3246 {
3247 pWndIA = UserGetWindowObject(WndInsertAfter);
3248 if (!pWndIA || UserIsDesktopWindow(pWndIA) || UserIsMessageWindow(pWndIA))
3249 {
3250 goto Exit;
3251 }
3252 }
3253
3254 Ret = IntDeferWindowPos(WinPosInfo, Wnd, WndInsertAfter, x, y, cx, cy, Flags);
3255
3256Exit:
3257 TRACE("Leave NtUserDeferWindowPos, ret=%p\n", Ret);
3258 UserLeave();
3259 return Ret;
3260}
3261
3262/*
3263 * @implemented
3264 */
3267 LPRECT rectWnd,
3268 LPPOINT ptIcon)
3269{
3270 PWND Window;
3271 DWORD Ret = 0;
3272 BOOL Hit = FALSE;
3273 WINDOWPLACEMENT wndpl;
3274
3276
3278 {
3279 Hit = FALSE;
3280 goto Exit;
3281 }
3282
3283 _SEH2_TRY
3284 {
3285 if(rectWnd)
3286 {
3287 ProbeForWrite(rectWnd,
3288 sizeof(RECT),
3289 1);
3290 }
3291 if(ptIcon)
3292 {
3293 ProbeForWrite(ptIcon,
3294 sizeof(POINT),
3295 1);
3296 }
3297
3298 }
3300 {
3302 Hit = TRUE;
3303 }
3304 _SEH2_END;
3305
3306 wndpl.length = sizeof(WINDOWPLACEMENT);
3307
3308 if (IntGetWindowPlacement(Window, &wndpl) && !Hit)
3309 {
3310 _SEH2_TRY
3311 {
3312 if (rectWnd)
3313 {
3314 RtlCopyMemory(rectWnd, &wndpl.rcNormalPosition , sizeof(RECT));
3315 }
3316 if (ptIcon)
3317 {
3318 RtlCopyMemory(ptIcon, &wndpl.ptMinPosition, sizeof(POINT));
3319 }
3320
3321 }
3323 {
3325 Hit = TRUE;
3326 }
3327 _SEH2_END;
3328
3329 if (!Hit) Ret = wndpl.showCmd;
3330 }
3331Exit:
3332 UserLeave();
3333 return Ret;
3334}
3335
3336/*
3337 * @implemented
3338 */
3341 WINDOWPLACEMENT *lpwndpl)
3342{
3343 PWND Wnd;
3344 WINDOWPLACEMENT Safepl;
3347
3348 TRACE("Enter NtUserGetWindowPlacement\n");
3350
3351 if (!(Wnd = UserGetWindowObject(hWnd)))
3352 {
3353 RETURN( FALSE);
3354 }
3355
3356 Status = MmCopyFromCaller(&Safepl, lpwndpl, sizeof(WINDOWPLACEMENT));
3357 if (!NT_SUCCESS(Status))
3358 {
3360 RETURN( FALSE);
3361 }
3362
3363 Safepl.length = sizeof(WINDOWPLACEMENT);
3364
3365 IntGetWindowPlacement(Wnd, &Safepl);
3366
3367 Status = MmCopyToCaller(lpwndpl, &Safepl, sizeof(WINDOWPLACEMENT));
3368 if (!NT_SUCCESS(Status))
3369 {
3371 RETURN( FALSE);
3372 }
3373
3374 RETURN( TRUE);
3375
3376CLEANUP:
3377 TRACE("Leave NtUserGetWindowPlacement, ret=%i\n",_ret_);
3378 UserLeave();
3380}
3381
3382DWORD
3385 HWND hWnd,
3386 UINT cmd, // Wine SW_ commands
3387 BOOL Hide)
3388{
3389 PWND pWnd;
3390
3391 TRACE("Enter NtUserMinMaximize\n");
3393
3394 pWnd = UserGetWindowObject(hWnd);
3395 if (!pWnd || UserIsDesktopWindow(pWnd) || UserIsMessageWindow(pWnd))
3396 {
3397 goto Exit;
3398 }
3399
3400 if ( cmd > SW_MAX || pWnd->state2 & WNDS2_INDESTROY)
3401 {
3403 goto Exit;
3404 }
3405
3406 cmd |= Hide ? SW_HIDE : 0;
3407
3408 co_WinPosShowWindow(pWnd, cmd);
3409
3410Exit:
3411 TRACE("Leave NtUserMinMaximize\n");
3412 UserLeave();
3413 return 0; // Always NULL?
3414}
3415
3416/*
3417 * @implemented
3418 */
3421 HWND hWnd,
3422 int X,
3423 int Y,
3424 int nWidth,
3425 int nHeight,
3426 BOOL bRepaint)
3427{
3428 return NtUserSetWindowPos(hWnd, 0, X, Y, nWidth, nHeight,
3429 (bRepaint ? SWP_NOZORDER | SWP_NOACTIVATE :
3431}
3432
3433/*
3434 * @implemented
3435 */
3438 LONG x,
3439 LONG y)
3440{
3441 PWND pwndParent;
3442 TRACE("Enter NtUserRealChildWindowFromPoint\n");
3444 if ((pwndParent = UserGetWindowObject(Parent)))
3445 {
3446 pwndParent = IntRealChildWindowFromPoint(pwndParent, x, y);
3447 }
3448 UserLeave();
3449 TRACE("Leave NtUserRealChildWindowFromPoint\n");
3450 return pwndParent ? UserHMGetHandle(pwndParent) : NULL;
3451}
3452
3453/*
3454 * @implemented
3455 */
3458 HWND hWnd,
3459 HWND hWndInsertAfter,
3460 int X,
3461 int Y,
3462 int cx,
3463 int cy,
3464 UINT uFlags)
3465{
3467 PWND Window, pWndIA;
3468 BOOL ret;
3470
3471 TRACE("Enter NtUserSetWindowPos\n");
3473
3474 if (!(Window = UserGetWindowObject(hWnd)) ||
3476 {
3477 ERR("NtUserSetWindowPos bad window handle!\n");
3478 RETURN(FALSE);
3479 }
3480
3481 if ( hWndInsertAfter != HWND_TOP &&
3482 hWndInsertAfter != HWND_BOTTOM &&
3483 hWndInsertAfter != HWND_TOPMOST &&
3484 hWndInsertAfter != HWND_NOTOPMOST )
3485 {
3486 if (!(pWndIA = UserGetWindowObject(hWndInsertAfter)) ||
3487 UserIsDesktopWindow(pWndIA) || UserIsMessageWindow(pWndIA))
3488 {
3489 ERR("NtUserSetWindowPos bad insert window handle!\n");
3490 RETURN(FALSE);
3491 }
3492 }
3493
3494 /* First make sure that coordinates are valid for WM_WINDOWPOSCHANGING */
3495 if (!(uFlags & SWP_NOMOVE))
3496 {
3497 if (X < -32768) X = -32768;
3498 else if (X > 32767) X = 32767;
3499 if (Y < -32768) Y = -32768;
3500 else if (Y > 32767) Y = 32767;
3501 }
3502 if (!(uFlags & SWP_NOSIZE))
3503 {
3504 if (cx < 0) cx = 0;
3505 else if (cx > 32767) cx = 32767;
3506 if (cy < 0) cy = 0;
3507 else if (cy > 32767) cy = 32767;
3508 }
3509
3510 UserRefObjectCo(Window, &Ref);
3511 ret = co_WinPosSetWindowPos(Window, hWndInsertAfter, X, Y, cx, cy, uFlags);
3513
3514 RETURN(ret);
3515
3516CLEANUP:
3517 TRACE("Leave NtUserSetWindowPos, ret=%i\n",_ret_);
3518 UserLeave();
3520}
3521
3522/*
3523 * @implemented
3524 */
3527 HWND hWnd,
3528 HRGN hRgn,
3529 BOOL bRedraw)
3530{
3531 HRGN hrgnCopy = NULL;
3532 PWND Window;
3534 BOOLEAN Ret = FALSE;
3536
3537 TRACE("Enter NtUserSetWindowRgn\n");
3539
3540 if (!(Window = UserGetWindowObject(hWnd)) ||
3542 {
3543 RETURN( 0);
3544 }
3545
3546 if (hRgn) // The region will be deleted in user32.
3547 {
3549 {
3550 hrgnCopy = NtGdiCreateRectRgn(0, 0, 0, 0);
3551 /* The coordinates of a window's window region are relative to the
3552 upper-left corner of the window, not the client area of the window. */
3553 NtGdiCombineRgn( hrgnCopy, hRgn, 0, RGN_COPY);
3554 }
3555 else
3556 RETURN( 0);
3557 }
3558
3560 if (hrgnCopy)
3561 {
3562 Window->hrgnNewFrame = hrgnCopy; // Should be PSMWP->acvr->hrgnClip
3563 }
3564 else
3565 {
3566 Window->hrgnNewFrame = HRGN_WINDOW;
3567 }
3569 Ret = co_WinPosSetWindowPos(Window, HWND_TOP, 0, 0, 0, 0, bRedraw ? flags : (flags|SWP_NOREDRAW) );
3570
3571 RETURN( (INT)Ret);
3572
3573CLEANUP:
3574 TRACE("Leave NtUserSetWindowRgn, ret=%i\n",_ret_);
3575 UserLeave();
3577}
3578
3579/*
3580 * @implemented
3581 */
3584 HWND hwnd,
3585 UINT showCmd,
3586 LPRECT lprect,
3587 LPPOINT lppt)
3588{
3589 WINDOWPLACEMENT wndpl;
3590 UINT flags;
3591 PWND Wnd;
3592 RECT rect;
3593 POINT pt = {0};
3596
3597 TRACE("Enter NtUserSetWindowPlacement\n");
3599
3600 if (!(Wnd = UserGetWindowObject(hwnd)) || // FIXME:
3602 {
3603 RETURN( FALSE);
3604 }
3605
3606 _SEH2_TRY
3607 {
3608 if (lppt)
3609 {
3610 ProbeForRead(lppt, sizeof(POINT), 1);
3611 RtlCopyMemory(&pt, lppt, sizeof(POINT));
3612 }
3613 if (lprect)
3614 {
3615 ProbeForRead(lprect, sizeof(RECT), 1);
3616 RtlCopyMemory(&rect, lprect, sizeof(RECT));
3617 }
3618 }
3620 {
3623 }
3624 _SEH2_END
3625
3626 wndpl.length = sizeof(wndpl);
3627 wndpl.showCmd = showCmd;
3628 wndpl.flags = flags = 0;
3629
3630 if ( lppt )
3631 {
3632 flags |= PLACE_MIN;
3633 wndpl.flags |= WPF_SETMINPOSITION;
3634 wndpl.ptMinPosition = pt;
3635 }
3636 if ( lprect )
3637 {
3638 flags |= PLACE_RECT;
3639 wndpl.rcNormalPosition = rect;
3640 }
3641
3642 UserRefObjectCo(Wnd, &Ref);
3643 IntSetWindowPlacement(Wnd, &wndpl, flags);
3644 UserDerefObjectCo(Wnd);
3645 RETURN(TRUE);
3646
3647CLEANUP:
3648 TRACE("Leave NtUserSetWindowPlacement, ret=%i\n",_ret_);
3649 UserLeave();
3651}
3652
3653/*
3654 * @implemented
3655 */
3658 WINDOWPLACEMENT *lpwndpl)
3659{
3660 PWND Wnd;
3661 WINDOWPLACEMENT Safepl;
3662 UINT Flags;
3665
3666 TRACE("Enter NtUserSetWindowPlacement\n");
3668
3669 if (!(Wnd = UserGetWindowObject(hWnd)) ||
3671 {
3672 RETURN( FALSE);
3673 }
3674
3675 _SEH2_TRY
3676 {
3677 ProbeForRead(lpwndpl, sizeof(WINDOWPLACEMENT), 1);
3678 RtlCopyMemory(&Safepl, lpwndpl, sizeof(WINDOWPLACEMENT));
3679 }
3681 {
3684 }
3685 _SEH2_END
3686
3687 if(Safepl.length != sizeof(WINDOWPLACEMENT))
3688 {
3689 RETURN( FALSE);
3690 }
3691
3693 if (Safepl.flags & WPF_SETMINPOSITION) Flags |= PLACE_MIN;
3694 UserRefObjectCo(Wnd, &Ref);
3695 IntSetWindowPlacement(Wnd, &Safepl, Flags);
3696 UserDerefObjectCo(Wnd);
3697 RETURN(TRUE);
3698
3699CLEANUP:
3700 TRACE("Leave NtUserSetWindowPlacement, ret=%i\n",_ret_);
3701 UserLeave();
3703}
3704
3705/*
3706 * @implemented
3707 */
3710{
3711 PWND Window;
3712 BOOL ret;
3715
3716 TRACE("Enter NtUserShowWindowAsync\n");
3718
3719 if (!(Window = UserGetWindowObject(hWnd)) ||
3721 {
3722 RETURN(FALSE);
3723 }
3724
3725 if ( nCmdShow > SW_MAX )
3726 {
3728 RETURN(FALSE);
3729 }
3730
3731 UserRefObjectCo(Window, &Ref);
3734 if (-1 == (int) ret || !ret) ret = FALSE;
3735
3736 RETURN(ret);
3737
3738CLEANUP:
3739 TRACE("Leave NtUserShowWindowAsync, ret=%i\n",_ret_);
3740 UserLeave();
3742}
3743
3744/*
3745 * @implemented
3746 */
3749{
3750 PWND Window;
3751 BOOL ret;
3754
3755 TRACE("Enter NtUserShowWindow hWnd %p SW_ %d\n",hWnd, nCmdShow);
3757
3758 if (!(Window = UserGetWindowObject(hWnd)) ||
3760 {
3761 RETURN(FALSE);
3762 }
3763
3764 if ( nCmdShow > SW_MAX || Window->state2 & WNDS2_INDESTROY)
3765 {
3767 RETURN(FALSE);
3768 }
3769
3770 UserRefObjectCo(Window, &Ref);
3771 ret = co_WinPosShowWindow(Window, nCmdShow);
3773
3774 RETURN(ret);
3775
3776CLEANUP:
3777 TRACE("Leave NtUserShowWindow, ret=%i\n",_ret_);
3778 UserLeave();
3780}
3781
3782
3783/*
3784 * @implemented
3785 */
3788{
3789 POINT pt;
3790 HWND Ret;
3792 USHORT hittest;
3795
3796 TRACE("Enter NtUserWindowFromPoint\n");
3798
3800 {
3801 //PTHREADINFO pti;
3802
3803 pt.x = X;
3804 pt.y = Y;
3805
3806 // Hmm... Threads live on desktops thus we have a reference on the desktop and indirectly the desktop window.
3807 // It is possible this referencing is useless, though it should not hurt...
3809
3810 //pti = PsGetCurrentThreadWin32Thread();
3812
3813 if (Window)
3814 {
3815 Ret = UserHMGetHandle(Window);
3816
3817 RETURN( Ret);
3818 }
3819 }
3820
3821 RETURN( NULL);
3822
3823CLEANUP:
3825
3826 TRACE("Leave NtUserWindowFromPoint, ret=%p\n", _ret_);
3827 UserLeave();
3829}
3830
3831/* EOF */
static HDC hDC
Definition: 3dtext.c:33
#define RETURN(x)
#define DCX_USESTYLE
Definition: GetDCEx.c:10
unsigned char BOOLEAN
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:732
Arabic default style
Definition: afstyles.h:94
const DWORD Style
Definition: appswitch.c:71
const DWORD ExStyle
Definition: appswitch.c:72
#define msg(x)
Definition: auth_time.c:54
HWND hWnd
Definition: settings.c:17
LONG NTSTATUS
Definition: precomp.h:26
@ Create
Definition: registry.c:563
#define ERR(fmt,...)
Definition: debug.h:110
#define DBG_DEFAULT_CHANNEL(ch)
Definition: debug.h:103
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
#define SWP_NOCLIENTSIZE
Definition: msg.h:29
#define SWP_NOCLIENTMOVE
Definition: msg.h:30
static HWND hwndParent
Definition: cryptui.c:300
VOID FASTCALL DceResetActiveDCEs(PWND Window)
Definition: windc.c:816
ush Pos
Definition: deflate.h:92
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define APIENTRY
Definition: api.h:79
#define Y(I)
UINT uFlags
Definition: api.c:59
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
PSERVERINFO gpsi
Definition: imm.c:18
#define ValidateHwndNoErr(hwnd)
Definition: precomp.h:84
#define pt(x, y)
Definition: drawing.c:79
r parent
Definition: btrfs.c:3010
VOID FASTCALL IntEngWindowChanged(_In_ struct _WND *Window, _In_ FLONG flChanged)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PagedPool
Definition: env_spec_w32.h:308
#define ERROR(name)
Definition: error_private.h:53
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
HWND FASTCALL co_UserSetFocus(PWND Window)
Definition: focus.c:1314
BOOL FASTCALL IntCheckFullscreen(PWND Window)
Definition: focus.c:79
BOOL FASTCALL UserSetActiveWindow(_In_opt_ PWND Wnd)
Definition: focus.c:1260
PUSER_MESSAGE_QUEUE gpqForeground
Definition: focus.c:13
VOID FASTCALL UpdateShellHook(PWND Window)
Definition: focus.c:99
BOOL FASTCALL co_IntSetForegroundWindow(PWND Window)
Definition: focus.c:1550
HWND FASTCALL UserGetForegroundWindow(VOID)
Definition: focus.c:1421
BOOLEAN valid
Status
Definition: gdiplustypes.h:25
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLuint res
Definition: glext.h:9613
GLdouble GLdouble GLdouble GLdouble top
Definition: glext.h:10859
GLdouble GLdouble right
Definition: glext.h:10859
GLenum const GLfloat * params
Definition: glext.h:5645
GLint left
Definition: glext.h:7726
GLbitfield flags
Definition: glext.h:7161
GLint GLint bottom
Definition: glext.h:7726
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
#define X(b, s)
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define WNDS2_WIN31COMPAT
Definition: ntuser.h:644
#define WNDS_BEINGACTIVATED
Definition: ntuser.h:620
#define FNID_DESKTOP
Definition: ntuser.h:857
#define WNDS_SENDNCPAINT
Definition: ntuser.h:611
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define WNDS_MAXIMIZESTOMONITOR
Definition: ntuser.h:630
#define ICLS_BUTTON
Definition: ntuser.h:907
@ TYPE_SETWINDOWPOS
Definition: ntuser.h:44
#define WNDS_ERASEBACKGROUND
Definition: ntuser.h:610
#define WEF_SETBYWNDPTI
Definition: ntuser.h:235
#define WPF_MAXINIT
Definition: ntuser.h:682
#define WNDS2_INDESTROY
Definition: ntuser.h:643
#define WNDS_SENDSIZEMOVEMSGS
Definition: ntuser.h:604
#define WPF_MININIT
Definition: ntuser.h:681
#define HRGN_WINDOW
Definition: ntuser.h:356
#define WNDS_SENDERASEBACKGROUND
Definition: ntuser.h:609
if(dx< 0)
Definition: linetemp.h:194
#define MmCopyToCaller(x, y, z)
Definition: mmcopy.h:19
#define ASSERT(a)
Definition: mode.c:44
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define for
Definition: utility.h:88
#define END
Definition: options.h:105
static HDC
Definition: imagelist.c:92
static HRGN hRgn
Definition: mapping.c:33
#define SWP_STATECHANGED
Definition: msg.c:42
#define min(a, b)
Definition: monoChain.cc:55
VOID FASTCALL co_MsqInsertMouseMessage(MSG *Msg, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook)
Definition: msgqueue.c:580
@ WM_ASYNC_SHOWWINDOW
Definition: msgqueue.h:117
@ WM_ASYNC_SETWINDOWPOS
Definition: msgqueue.h:118
unsigned int UINT
Definition: ndis.h:50
_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:1597
#define FASTCALL
Definition: nt_native.h:50
__kernel_entry W32KAPI INT APIENTRY NtGdiCombineRgn(_In_ HRGN hrgnDst, _In_ HRGN hrgnSrc1, _In_opt_ HRGN hrgnSrc2, _In_ INT iMode)
__kernel_entry W32KAPI BOOL APIENTRY NtGdiBitBlt(_In_ HDC hdcDst, _In_ INT x, _In_ INT y, _In_ INT cx, _In_ INT cy, _In_opt_ HDC hdcSrc, _In_ INT xSrc, _In_ INT ySrc, _In_ DWORD rop4, _In_ DWORD crBackColor, _In_ FLONG fl)
__kernel_entry W32KAPI HRGN APIENTRY NtGdiCreateRectRgn(_In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
__kernel_entry W32KAPI INT APIENTRY NtGdiOffsetRgn(_In_ HRGN hrgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:3980
#define GDI_OBJ_HMGR_POWNED
Definition: ntgdihdl.h:117
#define GDI_OBJ_HMGR_PUBLIC
Definition: ntgdihdl.h:116
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
LRESULT APIENTRY co_HOOK_CallHooks(INT HookId, INT Code, WPARAM wParam, LPARAM lParam)
Definition: hook.c:1103
BOOL FASTCALL IntClientToScreen(PWND Wnd, LPPOINT lpPoint)
Definition: winpos.c:198
UINT FASTCALL co_WinPosMinMaximize(PWND Wnd, UINT ShowFlag, RECT *NewPos)
Definition: winpos.c:2371
INT APIENTRY NtUserSetWindowRgn(HWND hWnd, HRGN hRgn, BOOL bRedraw)
Definition: winpos.c:3526
BOOL APIENTRY NtUserSetWindowPlacement(HWND hWnd, WINDOWPLACEMENT *lpwndpl)
Definition: winpos.c:3657
DWORD APIENTRY NtUserMinMaximize(HWND hWnd, UINT cmd, BOOL Hide)
Definition: winpos.c:3384
UINT FASTCALL co_WinPosArrangeIconicWindows(PWND parent)
Definition: winpos.c:730
static VOID FASTCALL FixClientRect(PRECTL ClientRect, PRECTL WindowRect)
Definition: winpos.c:1080
BOOL FASTCALL IntSetWindowPlacement(PWND Wnd, WINDOWPLACEMENT *wpl, UINT Flags)
Definition: winpos.c:664
static BOOL FASTCALL co_WinPosDoWinPosChanging(PWND Window, PWINDOWPOS WinPos, PRECTL WindowRect, PRECTL ClientRect)
Definition: winpos.c:1266
VOID FASTCALL co_WinPosActivateOtherWindow(PWND Wnd)
Definition: winpos.c:396
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1748
static BOOL FASTCALL WinPosFixupFlags(WINDOWPOS *WinPos, PWND Wnd)
Definition: winpos.c:1550
BOOL APIENTRY NtUserMoveWindow(HWND hWnd, int X, int Y, int nWidth, int nHeight, BOOL bRepaint)
Definition: winpos.c:3420
INT FASTCALL IntMapWindowPoints(PWND FromWnd, PWND ToWnd, LPPOINT lpPoints, UINT cPoints)
Definition: winpos.c:143
BOOL FASTCALL IsChildVisible(PWND pWnd)
Definition: winpos.c:225
PWND FASTCALL IntGetLastTopMostWindow(VOID)
Definition: winpos.c:237
BOOL APIENTRY NtUserSetWindowPos(HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags)
Definition: winpos.c:3457
VOID ForceNCPaintErase(PWND Wnd, HRGN hRgn, PREGION pRgn)
Definition: winpos.c:1690
#define EMPTYPOINT(pt)
Definition: winpos.c:28
DWORD APIENTRY NtUserGetInternalWindowPos(HWND hWnd, LPRECT rectWnd, LPPOINT ptIcon)
Definition: winpos.c:3266
static void make_point_onscreen(POINT *pt)
Definition: winpos.c:653
DWORD IntGetWindowBorders(DWORD Style, DWORD ExStyle)
Definition: winpos.c:914
VOID FASTCALL WinPosInitInternalPos(PWND Wnd, RECTL *RestoreRect)
Definition: winpos.c:479
DWORD APIENTRY NtUserSetInternalWindowPos(HWND hwnd, UINT showCmd, LPRECT lprect, LPPOINT lppt)
Definition: winpos.c:3583
BOOL FASTCALL IntGetWindowPlacement(PWND Wnd, WINDOWPLACEMENT *lpwndpl)
Definition: winpos.c:558
static PWND co_WinPosSearchChildren(IN PWND ScopeWin, IN POINT *Point, IN OUT USHORT *HitTest, IN BOOL Ignore)
Definition: winpos.c:2804
static VOID FASTCALL get_valid_rects(RECTL *old_client, RECTL *new_client, UINT flags, RECTL *valid)
Definition: winpos.c:1123
BOOL FASTCALL ActivateOtherWindowMin(PWND Wnd)
Definition: winpos.c:284
static void make_rect_onscreen(RECT *rect)
Definition: winpos.c:623
#define PLACE_RECT
Definition: winpos.c:31
PWND APIENTRY co_WinPosWindowFromPoint(IN PWND ScopeWin, IN POINT *WinPoint, IN OUT USHORT *HitTest, IN BOOL Ignore)
Definition: winpos.c:2889
#define SWP_AGG_STATUSFLAGS
Definition: winpos.c:23
static VOID FASTCALL WinPosFindIconPos(PWND Window, POINT *Pos)
Definition: winpos.c:780
BOOL APIENTRY NtUserShowWindow(HWND hWnd, LONG nCmdShow)
Definition: winpos.c:3748
#define PLACE_MAX
Definition: winpos.c:30
HWND APIENTRY NtUserRealChildWindowFromPoint(HWND Parent, LONG x, LONG y)
Definition: winpos.c:3437
LRESULT FASTCALL co_WinPosGetNonClientSize(PWND Window, RECT *WindowRect, RECT *ClientRect)
Definition: winpos.c:2322
static VOID FASTCALL WinPosInternalMoveWindow(PWND Window, INT MoveX, INT MoveY)
Definition: winpos.c:1520
VOID FASTCALL IntGetClientRect(PWND Wnd, RECTL *Rect)
Definition: winpos.c:91
BOOL APIENTRY NtUserShowWindowAsync(HWND hWnd, LONG nCmdShow)
Definition: winpos.c:3709
static BOOL IntValidateParent(PWND Child, PREGION ValidateRgn)
Definition: winpos.c:1056
BOOL FASTCALL IntGetWindowRect(PWND Wnd, RECTL *Rect)
Definition: winpos.c:120
#define SWP_AGG_NOCLIENTCHANGE
Definition: winpos.c:25
UINT FASTCALL co_WinPosGetMinMaxInfo(PWND Window, POINT *MaxSize, POINT *MaxPos, POINT *MinTrack, POINT *MaxTrack)
Definition: winpos.c:933
static HWND FASTCALL WinPosDoOwnedPopups(PWND Window, HWND hWndInsertAfter)
Definition: winpos.c:1354
BOOL FASTCALL IntScreenToClient(PWND Wnd, LPPOINT lpPoint)
Definition: winpos.c:212
PWND APIENTRY IntChildWindowFromPointEx(PWND Parent, LONG x, LONG y, UINT uiFlags)
Definition: winpos.c:2964
BOOL APIENTRY NtUserGetWindowPlacement(HWND hWnd, WINDOWPLACEMENT *lpwndpl)
Definition: winpos.c:3340
static BOOL FASTCALL can_activate_window(PWND Wnd OPTIONAL)
Definition: winpos.c:372
void FASTCALL co_WinPosSendSizeMove(PWND Wnd)
Definition: winpos.c:2337
BOOL UserHasWindowEdge(DWORD Style, DWORD ExStyle)
Definition: winpos.c:843
HWND APIENTRY NtUserWindowFromPoint(LONG X, LONG Y)
Definition: winpos.c:3787
HDWP APIENTRY NtUserDeferWindowPos(HDWP WinPosInfo, HWND Wnd, HWND WndInsertAfter, int x, int y, int cx, int cy, UINT Flags)
Definition: winpos.c:3212
HWND APIENTRY NtUserChildWindowFromPointEx(HWND hwndParent, LONG x, LONG y, UINT uiFlags)
Definition: winpos.c:3175
BOOLEAN FASTCALL co_WinPosShowWindow(PWND Wnd, INT Cmd)
Definition: winpos.c:2522
BOOL FASTCALL IntGetClientOrigin(PWND Window OPTIONAL, LPPOINT Point)
Definition: winpos.c:70
#define SWP_AGG_NOGEOMETRYCHANGE
Definition: winpos.c:19
VOID UserGetWindowBorders(DWORD Style, DWORD ExStyle, SIZE *Size, BOOL WithClient)
Definition: winpos.c:887
#define SWP_AGG_NOPOSCHANGE
Definition: winpos.c:21
VOID FASTCALL IntGetWindowBorderMeasures(PWND Wnd, UINT *cx, UINT *cy)
Definition: winpos.c:860
VOID SelectWindowRgn(PWND Window, HRGN hRgnClip)
Definition: winpos.c:258
PWND FASTCALL IntRealChildWindowFromPoint(PWND Parent, LONG x, LONG y)
Definition: winpos.c:2922
BOOL FASTCALL IntEndDeferWindowPosEx(HDWP hdwp, BOOL sAsync)
Definition: winpos.c:3104
HDWP FASTCALL IntDeferWindowPos(HDWP hdwp, HWND hwnd, HWND hwndAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:3016
#define PLACE_MIN
Definition: winpos.c:29
BOOL APIENTRY NtUserEndDeferWindowPosEx(HDWP WinPosInfo, BOOL bAsync)
Definition: winpos.c:3196
static LONG FASTCALL co_WinPosDoNCCALCSize(PWND Window, PWINDOWPOS WinPos, RECTL *WindowRect, RECTL *ClientRect, RECTL *validRects)
Definition: winpos.c:1179
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:254
PTHREADINFO gptiCurrent
Definition: ntuser.c:15
VOID FASTCALL UserEnterShared(VOID)
Definition: ntuser.c:238
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:245
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:40
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:27
#define RDW_CLIPCHILDREN
Definition: painting.h:15
#define LOWORD(l)
Definition: pedump.c:82
#define WS_CHILD
Definition: pedump.c:617
#define WS_CAPTION
Definition: pedump.c:624
#define WS_SIZEBOX
Definition: pedump.c:642
#define WS_ICONIC
Definition: pedump.c:641
#define WS_MAXIMIZEBOX
Definition: pedump.c:632
#define WS_EX_DLGMODALFRAME
Definition: pedump.c:645
#define WS_MAXIMIZE
Definition: pedump.c:623
#define WS_BORDER
Definition: pedump.c:625
#define WS_POPUP
Definition: pedump.c:616
#define WS_MINIMIZE
Definition: pedump.c:622
#define WS_VISIBLE
Definition: pedump.c:620
#define WS_EX_TOPMOST
Definition: pedump.c:647
long LONG
Definition: pedump.c:60
#define BS_GROUPBOX
Definition: pedump.c:658
#define WS_DISABLED
Definition: pedump.c:621
#define WS_DLGFRAME
Definition: pedump.c:626
#define WS_EX_TRANSPARENT
Definition: pedump.c:649
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
unsigned short USHORT
Definition: pedump.c:61
#define WS_CLIPCHILDREN
Definition: pedump.c:619
#define WS_THICKFRAME
Definition: pedump.c:630
#define MmCopyFromCaller
Definition: polytest.cpp:29
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:586
_Out_opt_ int * cx
Definition: commctrl.h:585
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
@ Cmd
Definition: sacdrv.h:278
static void Exit(void)
Definition: sock.c:1330
#define TRACE(s)
Definition: solgame.cpp:4
& rect
Definition: startmenu.cpp:1413
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
Implementation of the Explorer desktop window.
Definition: desktop.h:52
long bottom
Definition: polytest.cpp:53
long right
Definition: polytest.cpp:53
long top
Definition: polytest.cpp:53
long left
Definition: polytest.cpp:53
Definition: window.c:28
UINT style
Definition: ntuser.h:575
Definition: winpos.h:4
WINDOWPOS pos
Definition: winpos.h:5
HRGN hrgnClip
Definition: winpos.h:16
HRGN hrgnInterMonitor
Definition: winpos.h:17
struct _WND * spwnd
Definition: ntuser.h:137
PDESKTOPINFO pDeskInfo
Definition: desktop.h:8
RECT rcWork
Definition: monitor.h:19
RECT rcMonitor
Definition: monitor.h:18
LONG y
Definition: windef.h:330
LONG x
Definition: windef.h:329
USERSTARTUPINFO usi
Definition: win32.h:278
Definition: region.h:8
Definition: winpos.h:21
PCVR acvr
Definition: winpos.h:27
INT ccvr
Definition: winpos.h:25
INT ccvrAlloc
Definition: winpos.h:26
struct _DESKTOP * rpdesk
Definition: ntuser.h:194
PPROCESSINFO ppi
Definition: win32.h:88
struct _DESKTOP * rpdesk
Definition: win32.h:92
struct _USER_MESSAGE_QUEUE * MessageQueue
Definition: win32.h:89
Definition: object.h:4
POINT ptMaxPosition
Definition: winuser.h:3284