?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Handle non-hardware X events correctly with native USER
[wine/multimedia.git] / windows / winpos.c
blobfcb9a39f915588e01325b97c256ebbdd0febec1d
1 /*
2 * Window position related functions.
3 *
4 * Copyright 1993, 1994, 1995 Alexandre Julliard
5 * 1995, 1996 Alex Korobka
6 */
7
8 #include <string.h>
9 #include "sysmetrics.h"
10 #include "heap.h"
11 #include "module.h"
12 #include "user.h"
13 #include "win.h"
14 #include "hook.h"
15 #include "message.h"
16 #include "queue.h"
17 #include "options.h"
18 #include "winpos.h"
19 #include "dce.h"
20 #include "nonclient.h"
21 #include "debug.h"
22
23 #define HAS_DLGFRAME(style,exStyle) \
24 (((exStyle) & WS_EX_DLGMODALFRAME) || \
25 (((style) & WS_DLGFRAME) && !((style) & WS_BORDER)))
26
27 #define HAS_THICKFRAME(style) \
28 (((style) & WS_THICKFRAME) && \
29 !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
30
31 #define SWP_AGG_NOGEOMETRYCHANGE \
32 (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE)
33 #define SWP_AGG_NOPOSCHANGE \
34 (SWP_AGG_NOGEOMETRYCHANGE | SWP_NOZORDER)
35 #define SWP_AGG_STATUSFLAGS \
36 (SWP_AGG_NOPOSCHANGE | SWP_FRAMECHANGED | SWP_HIDEWINDOW | SWP_SHOWWINDOW)
37
38 #define EMPTYPOINT(pt) ((*(LONG*)&(pt)) == -1)
39
40 #define PLACE_MIN 0x0001
41 #define PLACE_MAX 0x0002
42 #define PLACE_RECT 0x0004
43
44 #define SMC_NOCOPY 0x0001
45 #define SMC_NOPARENTERASE 0x0002
46 #define SMC_DRAWFRAME 0x0004
47 #define SMC_SETXPOS 0x0008
48
49 /* ----- internal variables ----- */
50
51 static HWND32 hwndActive = 0; /* Currently active window */
52 static HWND32 hwndPrevActive = 0; /* Previously active window */
53 static HWND32 hGlobalShellWindow=0; /*the shell*/
54
55 static LPCSTR atomInternalPos;
56
57 extern MESSAGEQUEUE* pActiveQueue;
58
59 /***********************************************************************
60 * WINPOS_CreateInternalPosAtom
61 */
62 BOOL32 WINPOS_CreateInternalPosAtom()
63 {
64 LPSTR str = "SysIP";
65 atomInternalPos = (LPCSTR)(DWORD)GlobalAddAtom32A(str);
66 return (atomInternalPos) ? TRUE : FALSE;
67 }
68
69 /***********************************************************************
70 * WINPOS_CheckInternalPos
71 *
72 * Called when a window is destroyed.
73 */
74 void WINPOS_CheckInternalPos( HWND32 hwnd )
75 {
76 LPINTERNALPOS lpPos = (LPINTERNALPOS) GetProp32A( hwnd, atomInternalPos );
77
78 if( hwnd == hwndPrevActive ) hwndPrevActive = 0;
79 if( hwnd == hwndActive )
80 {
81 hwndActive = 0;
82 WARN(win, "\tattempt to activate destroyed window!\n");
83 }
84
85 if( lpPos )
86 {
87 if( IsWindow32(lpPos->hwndIconTitle) )
88 DestroyWindow32( lpPos->hwndIconTitle );
89 HeapFree( SystemHeap, 0, lpPos );
90 }
91 }
92
93 /***********************************************************************
94 * WINPOS_FindIconPos
95 *
96 * Find a suitable place for an iconic window.
97 */
98 static POINT16 WINPOS_FindIconPos( WND* wndPtr, POINT16 pt )
99 {
100 RECT16 rectParent;
101 short x, y, xspacing, yspacing;
102
103 GetClientRect16( wndPtr->parent->hwndSelf, &rectParent );
104 if ((pt.x >= rectParent.left) && (pt.x + SYSMETRICS_CXICON < rectParent.right) &&
105 (pt.y >= rectParent.top) && (pt.y + SYSMETRICS_CYICON < rectParent.bottom))
106 return pt; /* The icon already has a suitable position */
107
108 xspacing = SYSMETRICS_CXICONSPACING;
109 yspacing = SYSMETRICS_CYICONSPACING;
110
111 y = rectParent.bottom;
112 for (;;)
113 {
114 for (x = rectParent.left; x <= rectParent.right-xspacing; x += xspacing)
115 {
116 /* Check if another icon already occupies this spot */
117 WND *childPtr = wndPtr->parent->child;
118 while (childPtr)
119 {
120 if ((childPtr->dwStyle & WS_MINIMIZE) && (childPtr != wndPtr))
121 {
122 if ((childPtr->rectWindow.left < x + xspacing) &&
123 (childPtr->rectWindow.right >= x) &&
124 (childPtr->rectWindow.top <= y) &&
125 (childPtr->rectWindow.bottom > y - yspacing))
126 break; /* There's a window in there */
127 }
128 childPtr = childPtr->next;
129 }
130 if (!childPtr) /* No window was found, so it's OK for us */
131 {
132 pt.x = x + (xspacing - SYSMETRICS_CXICON) / 2;
133 pt.y = y - (yspacing + SYSMETRICS_CYICON) / 2;
134 return pt;
135 }
136 }
137 y -= yspacing;
138 }
139 }
140
141
142 /***********************************************************************
143 * ArrangeIconicWindows16 (USER.170)
144 */
145 UINT16 WINAPI ArrangeIconicWindows16( HWND16 parent)
146 {
147 return ArrangeIconicWindows32(parent);
148 }
149 /***********************************************************************
150 * ArrangeIconicWindows32 (USER32.7)
151 */
152 UINT32 WINAPI ArrangeIconicWindows32( HWND32 parent )
153 {
154 RECT32 rectParent;
155 HWND32 hwndChild;
156 INT32 x, y, xspacing, yspacing;
157
158 GetClientRect32( parent, &rectParent );
159 x = rectParent.left;
160 y = rectParent.bottom;
161 xspacing = SYSMETRICS_CXICONSPACING;
162 yspacing = SYSMETRICS_CYICONSPACING;
163
164 hwndChild = GetWindow32( parent, GW_CHILD );
165 while (hwndChild)
166 {
167 if( IsIconic32( hwndChild ) )
168 {
169 WINPOS_ShowIconTitle( WIN_FindWndPtr(hwndChild), FALSE );
170 SetWindowPos32( hwndChild, 0, x + (xspacing - SYSMETRICS_CXICON) / 2,
171 y - yspacing - SYSMETRICS_CYICON/2, 0, 0,
172 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
173 if( IsWindow32(hwndChild) )
174 WINPOS_ShowIconTitle( WIN_FindWndPtr(hwndChild), TRUE );
175 if (x <= rectParent.right - xspacing) x += xspacing;
176 else
177 {
178 x = rectParent.left;
179 y -= yspacing;
180 }
181 }
182 hwndChild = GetWindow32( hwndChild, GW_HWNDNEXT );
183 }
184 return yspacing;
185 }
186
187
188 /***********************************************************************
189 * SwitchToThisWindow16 (USER.172)
190 */
191 void WINAPI SwitchToThisWindow16( HWND16 hwnd, BOOL16 restore )
192 {
193 SwitchToThisWindow32( hwnd, restore );
194 }
195
196
197 /***********************************************************************
198 * SwitchToThisWindow32 (USER32.539)
199 */
200 void WINAPI SwitchToThisWindow32( HWND32 hwnd, BOOL32 restore )
201 {
202 ShowWindow32( hwnd, restore ? SW_RESTORE : SW_SHOWMINIMIZED );
203 }
204
205
206 /***********************************************************************
207 * GetWindowRect16 (USER.32)
208 */
209 void WINAPI GetWindowRect16( HWND16 hwnd, LPRECT16 rect )
210 {
211 WND * wndPtr = WIN_FindWndPtr( hwnd );
212 if (!wndPtr) return;
213
214 CONV_RECT32TO16( &wndPtr->rectWindow, rect );
215 if (wndPtr->dwStyle & WS_CHILD)
216 MapWindowPoints16( wndPtr->parent->hwndSelf, 0, (POINT16 *)rect, 2 );
217 }
218
219
220 /***********************************************************************
221 * GetWindowRect32 (USER32.308)
222 */
223 BOOL32 WINAPI GetWindowRect32( HWND32 hwnd, LPRECT32 rect )
224 {
225 WND * wndPtr = WIN_FindWndPtr( hwnd );
226 if (!wndPtr) return FALSE;
227
228 *rect = wndPtr->rectWindow;
229 if (wndPtr->dwStyle & WS_CHILD)
230 MapWindowPoints32( wndPtr->parent->hwndSelf, 0, (POINT32 *)rect, 2 );
231 return TRUE;
232 }
233
234
235 /***********************************************************************
236 * GetWindowRgn32
237 */
238 BOOL32 WINAPI GetWindowRgn32 ( HWND32 hwnd, HRGN32 hrgn )
239
240 {
241 RECT32 rect;
242 WND * wndPtr = WIN_FindWndPtr( hwnd );
243 if (!wndPtr) return (ERROR);
244
245 FIXME (win, "GetWindowRgn32: doesn't really do regions\n");
246
247 memset (&rect, 0, sizeof(rect));
248
249 GetWindowRect32 ( hwnd, &rect );
250
251 FIXME (win, "Check whether a valid region here\n");
252
253 SetRectRgn32 ( hrgn, rect.left, rect.top, rect.right, rect.bottom );
254
255 return (SIMPLEREGION);
256 }
257
258 /***********************************************************************
259 * SetWindowRgn32
260 */
261 INT32 WINAPI SetWindowRgn32( HWND32 hwnd, HRGN32 hrgn,BOOL32 bRedraw)
262
263 {
264
265 FIXME (win, "SetWindowRgn32: stub\n");
266 return TRUE;
267 }
268
269 /***********************************************************************
270 * SetWindowRgn16
271 */
272 INT16 WINAPI SetWindowRgn16( HWND16 hwnd, HRGN16 hrgn,BOOL16 bRedraw)
273
274 {
275
276 FIXME (win, "SetWindowRgn16: stub\n");
277 return TRUE;
278 }
279
280
281 /***********************************************************************
282 * GetClientRect16 (USER.33)
283 */
284 void WINAPI GetClientRect16( HWND16 hwnd, LPRECT16 rect )
285 {
286 WND * wndPtr = WIN_FindWndPtr( hwnd );
287
288 rect->left = rect->top = rect->right = rect->bottom = 0;
289 if (wndPtr)
290 {
291 rect->right = wndPtr->rectClient.right - wndPtr->rectClient.left;
292 rect->bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
293 }
294 }
295
296
297 /***********************************************************************
298 * GetClientRect32 (USER32.220)
299 */
300 void WINAPI GetClientRect32( HWND32 hwnd, LPRECT32 rect )
301 {
302 WND * wndPtr = WIN_FindWndPtr( hwnd );
303
304 rect->left = rect->top = rect->right = rect->bottom = 0;
305 if (wndPtr)
306 {
307 rect->right = wndPtr->rectClient.right - wndPtr->rectClient.left;
308 rect->bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
309 }
310 }
311
312
313 /*******************************************************************
314 * ClientToScreen16 (USER.28)
315 */
316 void WINAPI ClientToScreen16( HWND16 hwnd, LPPOINT16 lppnt )
317 {
318 MapWindowPoints16( hwnd, 0, lppnt, 1 );
319 }
320
321
322 /*******************************************************************
323 * ClientToScreen32 (USER32.52)
324 */
325 BOOL32 WINAPI ClientToScreen32( HWND32 hwnd, LPPOINT32 lppnt )
326 {
327 MapWindowPoints32( hwnd, 0, lppnt, 1 );
328 return TRUE;
329 }
330
331
332 /*******************************************************************
333 * ScreenToClient16 (USER.29)
334 */
335 void WINAPI ScreenToClient16( HWND16 hwnd, LPPOINT16 lppnt )
336 {
337 MapWindowPoints16( 0, hwnd, lppnt, 1 );
338 }
339
340
341 /*******************************************************************
342 * ScreenToClient32 (USER32.447)
343 */
344 void WINAPI ScreenToClient32( HWND32 hwnd, LPPOINT32 lppnt )
345 {
346 MapWindowPoints32( 0, hwnd, lppnt, 1 );
347 }
348
349
350 /***********************************************************************
351 * WINPOS_WindowFromPoint
352 *
353 * Find the window and hittest for a given point.
354 */
355 INT16 WINPOS_WindowFromPoint( WND* wndScope, POINT16 pt, WND **ppWnd )
356 {
357 WND *wndPtr;
358 INT16 hittest = HTERROR;
359 POINT16 xy = pt;
360
361 *ppWnd = NULL;
362 wndPtr = wndScope->child;
363 if( wndScope->flags & WIN_MANAGED )
364 {
365 /* this prevents mouse clicks from going "through" scrollbars in managed mode */
366 if( pt.x < wndScope->rectClient.left || pt.x >= wndScope->rectClient.right ||
367 pt.y < wndScope->rectClient.top || pt.y >= wndScope->rectClient.bottom )
368 goto hittest;
369 }
370 MapWindowPoints16( GetDesktopWindow16(), wndScope->hwndSelf, &xy, 1 );
371
372 for (;;)
373 {
374 while (wndPtr)
375 {
376 /* If point is in window, and window is visible, and it */
377 /* is enabled (or it's a top-level window), then explore */
378 /* its children. Otherwise, go to the next window. */
379
380 if ((wndPtr->dwStyle & WS_VISIBLE) &&
381 (!(wndPtr->dwStyle & WS_DISABLED) ||
382 ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) != WS_CHILD)) &&
383 (xy.x >= wndPtr->rectWindow.left) &&
384 (xy.x < wndPtr->rectWindow.right) &&
385 (xy.y >= wndPtr->rectWindow.top) &&
386 (xy.y < wndPtr->rectWindow.bottom))
387 {
388 *ppWnd = wndPtr; /* Got a suitable window */
389
390 /* If window is minimized or disabled, return at once */
391 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
392 if (wndPtr->dwStyle & WS_DISABLED) return HTERROR;
393
394 /* If point is not in client area, ignore the children */
395 if ((xy.x < wndPtr->rectClient.left) ||
396 (xy.x >= wndPtr->rectClient.right) ||
397 (xy.y < wndPtr->rectClient.top) ||
398 (xy.y >= wndPtr->rectClient.bottom)) break;
399
400 xy.x -= wndPtr->rectClient.left;
401 xy.y -= wndPtr->rectClient.top;
402 wndPtr = wndPtr->child;
403 }
404 else wndPtr = wndPtr->next;
405 }
406
407 hittest:
408 /* If nothing found, try the scope window */
409 if (!*ppWnd) *ppWnd = wndScope;
410
411 /* Send the WM_NCHITTEST message (only if to the same task) */
412 if ((*ppWnd)->hmemTaskQ == GetTaskQueue(0))
413 {
414 hittest = (INT16)SendMessage16( (*ppWnd)->hwndSelf, WM_NCHITTEST,
415 0, MAKELONG( pt.x, pt.y ) );
416 if (hittest != HTTRANSPARENT) return hittest; /* Found the window */
417 }
418 else return HTCLIENT;
419
420 /* If no children found in last search, make point relative to parent */
421 if (!wndPtr)
422 {
423 xy.x += (*ppWnd)->rectClient.left;
424 xy.y += (*ppWnd)->rectClient.top;
425 }
426
427 /* Restart the search from the next sibling */
428 wndPtr = (*ppWnd)->next;
429 *ppWnd = (*ppWnd)->parent;
430 }
431 }
432
433
434 /*******************************************************************
435 * WindowFromPoint16 (USER.30)
436 */
437 HWND16 WINAPI WindowFromPoint16( POINT16 pt )
438 {
439 WND *pWnd;
440 WINPOS_WindowFromPoint( WIN_GetDesktop(), pt, &pWnd );
441 return pWnd->hwndSelf;
442 }
443
444
445 /*******************************************************************
446 * WindowFromPoint32 (USER32.582)
447 */
448 HWND32 WINAPI WindowFromPoint32( POINT32 pt )
449 {
450 WND *pWnd;
451 POINT16 pt16;
452 CONV_POINT32TO16( &pt, &pt16 );
453 WINPOS_WindowFromPoint( WIN_GetDesktop(), pt16, &pWnd );
454 return (HWND32)pWnd->hwndSelf;
455 }
456
457
458 /*******************************************************************
459 * ChildWindowFromPoint16 (USER.191)
460 */
461 HWND16 WINAPI ChildWindowFromPoint16( HWND16 hwndParent, POINT16 pt )
462 {
463 POINT32 pt32;
464 CONV_POINT16TO32( &pt, &pt32 );
465 return (HWND16)ChildWindowFromPoint32( hwndParent, pt32 );
466 }
467
468
469 /*******************************************************************
470 * ChildWindowFromPoint32 (USER32.49)
471 */
472 HWND32 WINAPI ChildWindowFromPoint32( HWND32 hwndParent, POINT32 pt )
473 {
474 /* pt is in the client coordinates */
475
476 WND* wnd = WIN_FindWndPtr(hwndParent);
477 RECT32 rect;
478
479 if( !wnd ) return 0;
480
481 /* get client rect fast */
482 rect.top = rect.left = 0;
483 rect.right = wnd->rectClient.right - wnd->rectClient.left;
484 rect.bottom = wnd->rectClient.bottom - wnd->rectClient.top;
485
486 if (!PtInRect32( &rect, pt )) return 0;
487
488 wnd = wnd->child;
489 while ( wnd )
490 {
491 if (PtInRect32( &wnd->rectWindow, pt )) return wnd->hwndSelf;
492 wnd = wnd->next;
493 }
494 return hwndParent;
495 }
496
497 /*******************************************************************
498 * ChildWindowFromPointEx16 (USER.50)
499 */
500 HWND16 WINAPI ChildWindowFromPointEx16( HWND16 hwndParent, POINT16 pt, UINT16 uFlags)
501 {
502 POINT32 pt32;
503 CONV_POINT16TO32( &pt, &pt32 );
504 return (HWND16)ChildWindowFromPointEx32( hwndParent, pt32, uFlags );
505 }
506
507
508 /*******************************************************************
509 * ChildWindowFromPointEx32 (USER32.50)
510 */
511 HWND32 WINAPI ChildWindowFromPointEx32( HWND32 hwndParent, POINT32 pt,
512 UINT32 uFlags)
513 {
514 /* pt is in the client coordinates */
515
516 WND* wnd = WIN_FindWndPtr(hwndParent);
517 RECT32 rect;
518
519 if( !wnd ) return 0;
520
521 /* get client rect fast */
522 rect.top = rect.left = 0;
523 rect.right = wnd->rectClient.right - wnd->rectClient.left;
524 rect.bottom = wnd->rectClient.bottom - wnd->rectClient.top;
525
526 if (!PtInRect32( &rect, pt )) return 0;
527
528 wnd = wnd->child;
529 while ( wnd )
530 {
531 if (PtInRect32( &wnd->rectWindow, pt )) {
532 if ( (uFlags & CWP_SKIPINVISIBLE) &&
533 !(wnd->dwStyle & WS_VISIBLE) )
534 wnd = wnd->next;
535 else if ( (uFlags & CWP_SKIPDISABLED) &&
536 (wnd->dwStyle & WS_DISABLED) )
537 wnd = wnd->next;
538 else if ( (uFlags & CWP_SKIPTRANSPARENT) &&
539 (wnd->dwExStyle & WS_EX_TRANSPARENT) )
540 wnd = wnd->next;
541 else
542 return wnd->hwndSelf;
543 }
544 }
545 return hwndParent;
546 }
547
548
549 /*******************************************************************
550 * WINPOS_GetWinOffset
551 *
552 * Calculate the offset between the origin of the two windows. Used
553 * to implement MapWindowPoints.
554 */
555 static void WINPOS_GetWinOffset( HWND32 hwndFrom, HWND32 hwndTo,
556 POINT32 *offset )
557 {
558 WND * wndPtr;
559
560 offset->x = offset->y = 0;
561 if (hwndFrom == hwndTo ) return;
562
563 /* Translate source window origin to screen coords */
564 if (hwndFrom)
565 {
566 if (!(wndPtr = WIN_FindWndPtr( hwndFrom )))
567 {
568 ERR(win,"bad hwndFrom = %04x\n",hwndFrom);
569 return;
570 }
571 while (wndPtr->parent)
572 {
573 offset->x += wndPtr->rectClient.left;
574 offset->y += wndPtr->rectClient.top;
575 wndPtr = wndPtr->parent;
576 }
577 }
578
579 /* Translate origin to destination window coords */
580 if (hwndTo)
581 {
582 if (!(wndPtr = WIN_FindWndPtr( hwndTo )))
583 {
584 ERR(win,"bad hwndTo = %04x\n", hwndTo );
585 return;
586 }
587 while (wndPtr->parent)
588 {
589 offset->x -= wndPtr->rectClient.left;
590 offset->y -= wndPtr->rectClient.top;
591 wndPtr = wndPtr->parent;
592 }
593 }
594 }
595
596
597 /*******************************************************************
598 * MapWindowPoints16 (USER.258)
599 */
600 void WINAPI MapWindowPoints16( HWND16 hwndFrom, HWND16 hwndTo,
601 LPPOINT16 lppt, UINT16 count )
602 {
603 POINT32 offset;
604
605 WINPOS_GetWinOffset( hwndFrom, hwndTo, &offset );
606 while (count--)
607 {
608 lppt->x += offset.x;
609 lppt->y += offset.y;
610 lppt++;
611 }
612 }
613
614
615 /*******************************************************************
616 * MapWindowPoints32 (USER32.386)
617 */
618 void WINAPI MapWindowPoints32( HWND32 hwndFrom, HWND32 hwndTo,
619 LPPOINT32 lppt, UINT32 count )
620 {
621 POINT32 offset;
622
623 WINPOS_GetWinOffset( hwndFrom, hwndTo, &offset );
624 while (count--)
625 {
626 lppt->x += offset.x;
627 lppt->y += offset.y;
628 lppt++;
629 }
630 }
631
632
633 /***********************************************************************
634 * IsIconic16 (USER.31)
635 */
636 BOOL16 WINAPI IsIconic16(HWND16 hWnd)
637 {
638 return IsIconic32(hWnd);
639 }
640
641
642 /***********************************************************************
643 * IsIconic32 (USER32.345)
644 */
645 BOOL32 WINAPI IsIconic32(HWND32 hWnd)
646 {
647 WND * wndPtr = WIN_FindWndPtr(hWnd);
648 if (wndPtr == NULL) return FALSE;
649 return (wndPtr->dwStyle & WS_MINIMIZE) != 0;
650 }
651
652
653 /***********************************************************************
654 * IsZoomed (USER.272)
655 */
656 BOOL16 WINAPI IsZoomed16(HWND16 hWnd)
657 {
658 return IsZoomed32(hWnd);
659 }
660
661
662 /***********************************************************************
663 * IsZoomed (USER32.352)
664 */
665 BOOL32 WINAPI IsZoomed32(HWND32 hWnd)
666 {
667 WND * wndPtr = WIN_FindWndPtr(hWnd);
668 if (wndPtr == NULL) return FALSE;
669 return (wndPtr->dwStyle & WS_MAXIMIZE) != 0;
670 }
671
672
673 /*******************************************************************
674 * GetActiveWindow (USER.60)
675 */
676 HWND16 WINAPI GetActiveWindow16(void)
677 {
678 return (HWND16)hwndActive;
679 }
680
681 /*******************************************************************
682 * GetActiveWindow (USER32.205)
683 */
684 HWND32 WINAPI GetActiveWindow32(void)
685 {
686 return (HWND32)hwndActive;
687 }
688
689
690 /*******************************************************************
691 * WINPOS_CanActivate
692 */
693 static BOOL32 WINPOS_CanActivate(WND* pWnd)
694 {
695 if( pWnd && ((pWnd->dwStyle & (WS_DISABLED | WS_VISIBLE | WS_CHILD))
696 == WS_VISIBLE) ) return TRUE;
697 return FALSE;
698 }
699
700
701 /*******************************************************************
702 * SetActiveWindow16 (USER.59)
703 */
704 HWND16 WINAPI SetActiveWindow16( HWND16 hwnd )
705 {
706 return SetActiveWindow32(hwnd);
707 }
708
709
710 /*******************************************************************
711 * SetActiveWindow32 (USER32.463)
712 */
713 HWND32 WINAPI SetActiveWindow32( HWND32 hwnd )
714 {
715 HWND32 prev = hwndActive;
716 WND *wndPtr = WIN_FindWndPtr( hwnd );
717
718 if ( !WINPOS_CanActivate(wndPtr) ) return 0;
719
720 WINPOS_SetActiveWindow( hwnd, 0, 0 );
721 return prev;
722 }
723
724
725 /*******************************************************************
726 * GetForegroundWindow16 (USER.608)
727 */
728 HWND16 WINAPI GetForegroundWindow16(void)
729 {
730 return (HWND16)GetForegroundWindow32();
731 }
732
733
734 /*******************************************************************
735 * SetForegroundWindow16 (USER.609)
736 */
737 BOOL16 WINAPI SetForegroundWindow16( HWND16 hwnd )
738 {
739 return SetForegroundWindow32( hwnd );
740 }
741
742
743 /*******************************************************************
744 * GetForegroundWindow32 (USER32.241)
745 */
746 HWND32 WINAPI GetForegroundWindow32(void)
747 {
748 return GetActiveWindow32();
749 }
750
751
752 /*******************************************************************
753 * SetForegroundWindow32 (USER32.482)
754 */
755 BOOL32 WINAPI SetForegroundWindow32( HWND32 hwnd )
756 {
757 SetActiveWindow32( hwnd );
758 return TRUE;
759 }
760
761
762 /*******************************************************************
763 * GetShellWindow16 (USER.600)
764 */
765 HWND16 WINAPI GetShellWindow16(void)
766 {
767 return GetShellWindow32();
768 }
769
770 /*******************************************************************
771 * SetShellWindow32 (USER32.504)
772 */
773 HWND32 WINAPI SetShellWindow32(HWND32 hwndshell)
774 { WARN(win, "(hWnd=%08x) semi stub\n",hwndshell );
775
776 hGlobalShellWindow = hwndshell;
777 return hGlobalShellWindow;
778 }
779
780
781 /*******************************************************************
782 * GetShellWindow32 (USER32.287)
783 */
784 HWND32 WINAPI GetShellWindow32(void)
785 { WARN(win, "(hWnd=%x) semi stub\n",hGlobalShellWindow );
786
787 return hGlobalShellWindow;
788 }
789
790
791 /***********************************************************************
792 * BringWindowToTop16 (USER.45)
793 */
794 BOOL16 WINAPI BringWindowToTop16( HWND16 hwnd )
795 {
796 return BringWindowToTop32(hwnd);
797 }
798
799
800 /***********************************************************************
801 * BringWindowToTop32 (USER32.11)
802 */
803 BOOL32 WINAPI BringWindowToTop32( HWND32 hwnd )
804 {
805 return SetWindowPos32( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE );
806 }
807
808
809 /***********************************************************************
810 * MoveWindow16 (USER.56)
811 */
812 BOOL16 WINAPI MoveWindow16( HWND16 hwnd, INT16 x, INT16 y, INT16 cx, INT16 cy,
813 BOOL16 repaint )
814 {
815 return MoveWindow32(hwnd,x,y,cx,cy,repaint);
816 }
817
818
819 /***********************************************************************
820 * MoveWindow32 (USER32.399)
821 */
822 BOOL32 WINAPI MoveWindow32( HWND32 hwnd, INT32 x, INT32 y, INT32 cx, INT32 cy,
823 BOOL32 repaint )
824 {
825 int flags = SWP_NOZORDER | SWP_NOACTIVATE;
826 if (!repaint) flags |= SWP_NOREDRAW;
827 TRACE(win, "%04x %d,%d %dx%d %d\n",
828 hwnd, x, y, cx, cy, repaint );
829 return SetWindowPos32( hwnd, 0, x, y, cx, cy, flags );
830 }
831
832 /***********************************************************************
833 * WINPOS_InitInternalPos
834 */
835 static LPINTERNALPOS WINPOS_InitInternalPos( WND* wnd, POINT32 pt,
836 LPRECT32 restoreRect )
837 {
838 LPINTERNALPOS lpPos = (LPINTERNALPOS) GetProp32A( wnd->hwndSelf,
839 atomInternalPos );
840 if( !lpPos )
841 {
842 /* this happens when the window is minimized/maximized
843 * for the first time (rectWindow is not adjusted yet) */
844
845 lpPos = HeapAlloc( SystemHeap, 0, sizeof(INTERNALPOS) );
846 if( !lpPos ) return NULL;
847
848 SetProp32A( wnd->hwndSelf, atomInternalPos, (HANDLE32)lpPos );
849 lpPos->hwndIconTitle = 0; /* defer until needs to be shown */
850 CONV_RECT32TO16( &wnd->rectWindow, &lpPos->rectNormal );
851 *(UINT32*)&lpPos->ptIconPos = *(UINT32*)&lpPos->ptMaxPos = 0xFFFFFFFF;
852 }
853
854 if( wnd->dwStyle & WS_MINIMIZE )
855 CONV_POINT32TO16( &pt, &lpPos->ptIconPos );
856 else if( wnd->dwStyle & WS_MAXIMIZE )
857 CONV_POINT32TO16( &pt, &lpPos->ptMaxPos );
858 else if( restoreRect )
859 CONV_RECT32TO16( restoreRect, &lpPos->rectNormal );
860
861 return lpPos;
862 }
863
864 /***********************************************************************
865 * WINPOS_RedrawIconTitle
866 */
867 BOOL32 WINPOS_RedrawIconTitle( HWND32 hWnd )
868 {
869 LPINTERNALPOS lpPos = (LPINTERNALPOS)GetProp32A( hWnd, atomInternalPos );
870 if( lpPos )
871 {
872 if( lpPos->hwndIconTitle )
873 {
874 SendMessage32A( lpPos->hwndIconTitle, WM_SHOWWINDOW, TRUE, 0);
875 InvalidateRect32( lpPos->hwndIconTitle, NULL, TRUE );
876 return TRUE;
877 }
878 }
879 return FALSE;
880 }
881
882 /***********************************************************************
883 * WINPOS_ShowIconTitle
884 */
885 BOOL32 WINPOS_ShowIconTitle( WND* pWnd, BOOL32 bShow )
886 {
887 LPINTERNALPOS lpPos = (LPINTERNALPOS)GetProp32A( pWnd->hwndSelf, atomInternalPos );
888
889 if( lpPos && !(pWnd->flags & WIN_MANAGED))
890 {
891 HWND16 hWnd = lpPos->hwndIconTitle;
892
893 TRACE(win,"0x%04x %i\n", pWnd->hwndSelf, (bShow != 0) );
894
895 if( !hWnd )
896 lpPos->hwndIconTitle = hWnd = ICONTITLE_Create( pWnd );
897 if( bShow )
898 {
899 pWnd = WIN_FindWndPtr(hWnd);
900
901 if( !(pWnd->dwStyle & WS_VISIBLE) )
902 {
903 SendMessage32A( hWnd, WM_SHOWWINDOW, TRUE, 0 );
904 SetWindowPos32( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
905 SWP_NOACTIVATE | SWP_NOZORDER | SWP_SHOWWINDOW );
906 }
907 }
908 else ShowWindow32( hWnd, SW_HIDE );
909 }
910 return FALSE;
911 }
912
913 /*******************************************************************
914 * WINPOS_GetMinMaxInfo
915 *
916 * Get the minimized and maximized information for a window.
917 */
918 void WINPOS_GetMinMaxInfo( WND *wndPtr, POINT32 *maxSize, POINT32 *maxPos,
919 POINT32 *minTrack, POINT32 *maxTrack )
920 {
921 LPINTERNALPOS lpPos;
922 MINMAXINFO32 MinMax;
923 INT32 xinc, yinc;
924
925 /* Compute default values */
926
927 MinMax.ptMaxSize.x = SYSMETRICS_CXSCREEN;
928 MinMax.ptMaxSize.y = SYSMETRICS_CYSCREEN;
929 MinMax.ptMinTrackSize.x = SYSMETRICS_CXMINTRACK;
930 MinMax.ptMinTrackSize.y = SYSMETRICS_CYMINTRACK;
931 MinMax.ptMaxTrackSize.x = SYSMETRICS_CXSCREEN;
932 MinMax.ptMaxTrackSize.y = SYSMETRICS_CYSCREEN;
933
934 if (wndPtr->flags & WIN_MANAGED) xinc = yinc = 0;
935 else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
936 {
937 xinc = SYSMETRICS_CXDLGFRAME;
938 yinc = SYSMETRICS_CYDLGFRAME;
939 }
940 else
941 {
942 xinc = yinc = 0;
943 if (HAS_THICKFRAME(wndPtr->dwStyle))
944 {
945 xinc += SYSMETRICS_CXFRAME;
946 yinc += SYSMETRICS_CYFRAME;
947 }
948 if (wndPtr->dwStyle & WS_BORDER)
949 {
950 xinc += SYSMETRICS_CXBORDER;
951 yinc += SYSMETRICS_CYBORDER;
952 }
953 }
954 MinMax.ptMaxSize.x += 2 * xinc;
955 MinMax.ptMaxSize.y += 2 * yinc;
956
957 lpPos = (LPINTERNALPOS)GetProp32A( wndPtr->hwndSelf, atomInternalPos );
958 if( lpPos && !EMPTYPOINT(lpPos->ptMaxPos) )
959 CONV_POINT16TO32( &lpPos->ptMaxPos, &MinMax.ptMaxPosition );
960 else
961 {
962 MinMax.ptMaxPosition.x = -xinc;
963 MinMax.ptMaxPosition.y = -yinc;
964 }
965
966 SendMessage32A( wndPtr->hwndSelf, WM_GETMINMAXINFO, 0, (LPARAM)&MinMax );
967
968 /* Some sanity checks */
969
970 TRACE(win,"%d %d / %d %d / %d %d / %d %d\n",
971 MinMax.ptMaxSize.x, MinMax.ptMaxSize.y,
972 MinMax.ptMaxPosition.x, MinMax.ptMaxPosition.y,
973 MinMax.ptMaxTrackSize.x, MinMax.ptMaxTrackSize.y,
974 MinMax.ptMinTrackSize.x, MinMax.ptMinTrackSize.y);
975 MinMax.ptMaxTrackSize.x = MAX( MinMax.ptMaxTrackSize.x,
976 MinMax.ptMinTrackSize.x );
977 MinMax.ptMaxTrackSize.y = MAX( MinMax.ptMaxTrackSize.y,
978 MinMax.ptMinTrackSize.y );
979
980 if (maxSize) *maxSize = MinMax.ptMaxSize;
981 if (maxPos) *maxPos = MinMax.ptMaxPosition;
982 if (minTrack) *minTrack = MinMax.ptMinTrackSize;
983 if (maxTrack) *maxTrack = MinMax.ptMaxTrackSize;
984 }
985
986 /***********************************************************************
987 * WINPOS_MinMaximize
988 *
989 * Fill in lpRect and return additional flags to be used with SetWindowPos().
990 * This function assumes that 'cmd' is different from the current window
991 * state.
992 */
993 UINT16 WINPOS_MinMaximize( WND* wndPtr, UINT16 cmd, LPRECT16 lpRect )
994 {
995 UINT16 swpFlags = 0;
996 POINT32 pt;
997 POINT32 size = { wndPtr->rectWindow.left, wndPtr->rectWindow.top };
998 LPINTERNALPOS lpPos = WINPOS_InitInternalPos( wndPtr, size,
999 &wndPtr->rectWindow );
1000
1001 TRACE(win,"0x%04x %u\n", wndPtr->hwndSelf, cmd );
1002
1003 if (lpPos && !HOOK_CallHooks16(WH_CBT, HCBT_MINMAX, wndPtr->hwndSelf, cmd))
1004 {
1005 if( wndPtr->dwStyle & WS_MINIMIZE )
1006 {
1007 if( !SendMessage32A( wndPtr->hwndSelf, WM_QUERYOPEN, 0, 0L ) )
1008 return (SWP_NOSIZE | SWP_NOMOVE);
1009 swpFlags |= SWP_NOCOPYBITS;
1010 }
1011 switch( cmd )
1012 {
1013 case SW_MINIMIZE:
1014 if( wndPtr->dwStyle & WS_MAXIMIZE)
1015 {
1016 wndPtr->flags |= WIN_RESTORE_MAX;
1017 wndPtr->dwStyle &= ~WS_MAXIMIZE;
1018 }
1019 else
1020 wndPtr->flags &= ~WIN_RESTORE_MAX;
1021 wndPtr->dwStyle |= WS_MINIMIZE;
1022
1023 lpPos->ptIconPos = WINPOS_FindIconPos( wndPtr, lpPos->ptIconPos );
1024
1025 SetRect16( lpRect, lpPos->ptIconPos.x, lpPos->ptIconPos.y,
1026 SYSMETRICS_CXICON, SYSMETRICS_CYICON );
1027 swpFlags |= SWP_NOCOPYBITS;
1028 break;
1029
1030 case SW_MAXIMIZE:
1031 CONV_POINT16TO32( &lpPos->ptMaxPos, &pt );
1032 WINPOS_GetMinMaxInfo( wndPtr, &size, &pt, NULL, NULL );
1033 CONV_POINT32TO16( &pt, &lpPos->ptMaxPos );
1034
1035 if( wndPtr->dwStyle & WS_MINIMIZE )
1036 {
1037 WINPOS_ShowIconTitle( wndPtr, FALSE );
1038 wndPtr->dwStyle &= ~WS_MINIMIZE;
1039 }
1040 wndPtr->dwStyle |= WS_MAXIMIZE;
1041
1042 SetRect16( lpRect, lpPos->ptMaxPos.x, lpPos->ptMaxPos.y,
1043 size.x, size.y );
1044 break;
1045
1046 case SW_RESTORE:
1047 if( wndPtr->dwStyle & WS_MINIMIZE )
1048 {
1049 wndPtr->dwStyle &= ~WS_MINIMIZE;
1050 WINPOS_ShowIconTitle( wndPtr, FALSE );
1051 if( wndPtr->flags & WIN_RESTORE_MAX)
1052 {
1053 /* Restore to maximized position */
1054 CONV_POINT16TO32( &lpPos->ptMaxPos, &pt );
1055 WINPOS_GetMinMaxInfo( wndPtr, &size, &pt, NULL, NULL);
1056 CONV_POINT32TO16( &pt, &lpPos->ptMaxPos );
1057 wndPtr->dwStyle |= WS_MAXIMIZE;
1058 SetRect16( lpRect, lpPos->ptMaxPos.x, lpPos->ptMaxPos.y, size.x, size.y );
1059 break;
1060 }
1061 }
1062 else
1063 if( !(wndPtr->dwStyle & WS_MAXIMIZE) ) return (UINT16)(-1);
1064 else wndPtr->dwStyle &= ~WS_MAXIMIZE;
1065
1066 /* Restore to normal position */
1067
1068 *lpRect = lpPos->rectNormal;
1069 lpRect->right -= lpRect->left;
1070 lpRect->bottom -= lpRect->top;
1071
1072 break;
1073 }
1074 } else swpFlags |= SWP_NOSIZE | SWP_NOMOVE;
1075 return swpFlags;
1076 }
1077
1078 /***********************************************************************
1079 * ShowWindowAsync32 (USER32.535)
1080 *
1081 * doesn't wait; returns immediately.
1082 * used by threads to toggle windows in other (possibly hanging) threads
1083 */
1084 BOOL32 WINAPI ShowWindowAsync32( HWND32 hwnd, INT32 cmd )
1085 {
1086 /* FIXME: does ShowWindow32() return immediately ? */
1087 return ShowWindow32(hwnd, cmd);
1088 }
1089
1090
1091 /***********************************************************************
1092 * ShowWindow16 (USER.42)
1093 */
1094 BOOL16 WINAPI ShowWindow16( HWND16 hwnd, INT16 cmd )
1095 {
1096 return ShowWindow32(hwnd,cmd);
1097 }
1098
1099
1100 /***********************************************************************
1101 * ShowWindow32 (USER32.534)
1102 */
1103 BOOL32 WINAPI ShowWindow32( HWND32 hwnd, INT32 cmd )
1104 {
1105 WND* wndPtr = WIN_FindWndPtr( hwnd );
1106 BOOL32 wasVisible, showFlag;
1107 RECT16 newPos = {0, 0, 0, 0};
1108 int swp = 0;
1109
1110 if (!wndPtr) return FALSE;
1111
1112 TRACE(win,"hwnd=%04x, cmd=%d\n", hwnd, cmd);
1113
1114 wasVisible = (wndPtr->dwStyle & WS_VISIBLE) != 0;
1115
1116 switch(cmd)
1117 {
1118 case SW_HIDE:
1119 if (!wasVisible) return FALSE;
1120 swp |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE |
1121 SWP_NOACTIVATE | SWP_NOZORDER;
1122 break;
1123
1124 case SW_SHOWMINNOACTIVE:
1125 swp |= SWP_NOACTIVATE | SWP_NOZORDER;
1126 /* fall through */
1127 case SW_SHOWMINIMIZED:
1128 swp |= SWP_SHOWWINDOW;
1129 /* fall through */
1130 case SW_MINIMIZE:
1131 swp |= SWP_FRAMECHANGED;
1132 if( !(wndPtr->dwStyle & WS_MINIMIZE) )
1133 swp |= WINPOS_MinMaximize( wndPtr, SW_MINIMIZE, &newPos );
1134 else swp |= SWP_NOSIZE | SWP_NOMOVE;
1135 break;
1136
1137 case SW_SHOWMAXIMIZED: /* same as SW_MAXIMIZE */
1138 swp |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
1139 if( !(wndPtr->dwStyle & WS_MAXIMIZE) )
1140 swp |= WINPOS_MinMaximize( wndPtr, SW_MAXIMIZE, &newPos );
1141 else swp |= SWP_NOSIZE | SWP_NOMOVE;
1142 break;
1143
1144 case SW_SHOWNA:
1145 swp |= SWP_NOACTIVATE | SWP_NOZORDER;
1146 /* fall through */
1147 case SW_SHOW:
1148 swp |= SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
1149 break;
1150
1151 case SW_SHOWNOACTIVATE:
1152 swp |= SWP_NOZORDER;
1153 if (GetActiveWindow32()) swp |= SWP_NOACTIVATE;
1154 /* fall through */
1155 case SW_SHOWNORMAL: /* same as SW_NORMAL: */
1156 case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
1157 case SW_RESTORE:
1158 swp |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
1159
1160 if( wndPtr->dwStyle & (WS_MINIMIZE | WS_MAXIMIZE) )
1161 swp |= WINPOS_MinMaximize( wndPtr, SW_RESTORE, &newPos );
1162 else swp |= SWP_NOSIZE | SWP_NOMOVE;
1163 break;
1164 }
1165
1166 showFlag = (cmd != SW_HIDE);
1167 if (showFlag != wasVisible)
1168 {
1169 SendMessage32A( hwnd, WM_SHOWWINDOW, showFlag, 0 );
1170 if (!IsWindow32( hwnd )) return wasVisible;
1171 }
1172
1173 if ((wndPtr->dwStyle & WS_CHILD) &&
1174 !IsWindowVisible32( wndPtr->parent->hwndSelf ) &&
1175 (swp & (SWP_NOSIZE | SWP_NOMOVE)) == (SWP_NOSIZE | SWP_NOMOVE) )
1176 {
1177 /* Don't call SetWindowPos32() on invisible child windows */
1178 if (cmd == SW_HIDE) wndPtr->dwStyle &= ~WS_VISIBLE;
1179 else wndPtr->dwStyle |= WS_VISIBLE;
1180 }
1181 else
1182 {
1183 /* We can't activate a child window */
1184 if (wndPtr->dwStyle & WS_CHILD) swp |= SWP_NOACTIVATE | SWP_NOZORDER;
1185 SetWindowPos32( hwnd, HWND_TOP,
1186 newPos.left, newPos.top, newPos.right, newPos.bottom, swp );
1187 if (!IsWindow32( hwnd )) return wasVisible;
1188 else if( wndPtr->dwStyle & WS_MINIMIZE ) WINPOS_ShowIconTitle( wndPtr, TRUE );
1189 }
1190
1191 if (wndPtr->flags & WIN_NEED_SIZE)
1192 {
1193 /* should happen only in CreateWindowEx() */
1194 int wParam = SIZE_RESTORED;
1195
1196 wndPtr->flags &= ~WIN_NEED_SIZE;
1197 if (wndPtr->dwStyle & WS_MAXIMIZE) wParam = SIZE_MAXIMIZED;
1198 else if (wndPtr->dwStyle & WS_MINIMIZE) wParam = SIZE_MINIMIZED;
1199 SendMessage32A( hwnd, WM_SIZE, wParam,
1200 MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left,
1201 wndPtr->rectClient.bottom-wndPtr->rectClient.top));
1202 SendMessage32A( hwnd, WM_MOVE, 0,
1203 MAKELONG(wndPtr->rectClient.left, wndPtr->rectClient.top) );
1204 }
1205
1206 return wasVisible;
1207 }
1208
1209
1210 /***********************************************************************
1211 * GetInternalWindowPos16 (USER.460)
1212 */
1213 UINT16 WINAPI GetInternalWindowPos16( HWND16 hwnd, LPRECT16 rectWnd,
1214 LPPOINT16 ptIcon )
1215 {
1216 WINDOWPLACEMENT16 wndpl;
1217 if (GetWindowPlacement16( hwnd, &wndpl ))
1218 {
1219 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
1220 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
1221 return wndpl.showCmd;
1222 }
1223 return 0;
1224 }
1225
1226
1227 /***********************************************************************
1228 * GetInternalWindowPos32 (USER32.245)
1229 */
1230 UINT32 WINAPI GetInternalWindowPos32( HWND32 hwnd, LPRECT32 rectWnd,
1231 LPPOINT32 ptIcon )
1232 {
1233 WINDOWPLACEMENT32 wndpl;
1234 if (GetWindowPlacement32( hwnd, &wndpl ))
1235 {
1236 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
1237 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
1238 return wndpl.showCmd;
1239 }
1240 return 0;
1241 }
1242
1243 /***********************************************************************
1244 * GetWindowPlacement16 (USER.370)
1245 */
1246 BOOL16 WINAPI GetWindowPlacement16( HWND16 hwnd, WINDOWPLACEMENT16 *wndpl )
1247 {
1248 WND *pWnd = WIN_FindWndPtr( hwnd );
1249 if( pWnd )
1250 {
1251 LPINTERNALPOS lpPos = (LPINTERNALPOS)WINPOS_InitInternalPos( pWnd,
1252 *(LPPOINT32)&pWnd->rectWindow.left, &pWnd->rectWindow );
1253 wndpl->length = sizeof(*wndpl);
1254 if( pWnd->dwStyle & WS_MINIMIZE )
1255 wndpl->showCmd = SW_SHOWMINIMIZED;
1256 else
1257 wndpl->showCmd = ( pWnd->dwStyle & WS_MAXIMIZE )
1258 ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL ;
1259 if( pWnd->flags & WIN_RESTORE_MAX )
1260 wndpl->flags = WPF_RESTORETOMAXIMIZED;
1261 else
1262 wndpl->flags = 0;
1263 wndpl->ptMinPosition = lpPos->ptIconPos;
1264 wndpl->ptMaxPosition = lpPos->ptMaxPos;
1265 wndpl->rcNormalPosition = lpPos->rectNormal;
1266 return TRUE;
1267 }
1268 return FALSE;
1269 }
1270
1271
1272 /***********************************************************************
1273 * GetWindowPlacement32 (USER32.307)
1274 */
1275 BOOL32 WINAPI GetWindowPlacement32( HWND32 hwnd, WINDOWPLACEMENT32 *pwpl32 )
1276 {
1277 if( pwpl32 )
1278 {
1279 WINDOWPLACEMENT16 wpl;
1280 wpl.length = sizeof(wpl);
1281 if( GetWindowPlacement16( hwnd, &wpl ) )
1282 {
1283 pwpl32->length = sizeof(*pwpl32);
1284 pwpl32->flags = wpl.flags;
1285 pwpl32->showCmd = wpl.showCmd;
1286 CONV_POINT16TO32( &wpl.ptMinPosition, &pwpl32->ptMinPosition );
1287 CONV_POINT16TO32( &wpl.ptMaxPosition, &pwpl32->ptMaxPosition );
1288 CONV_RECT16TO32( &wpl.rcNormalPosition, &pwpl32->rcNormalPosition );
1289 return TRUE;
1290 }
1291 }
1292 return FALSE;
1293 }
1294
1295
1296 /***********************************************************************
1297 * WINPOS_SetPlacement
1298 */
1299 static BOOL32 WINPOS_SetPlacement( HWND32 hwnd, const WINDOWPLACEMENT16 *wndpl,
1300 UINT32 flags )
1301 {
1302 WND *pWnd = WIN_FindWndPtr( hwnd );
1303 if( pWnd )
1304 {
1305 LPINTERNALPOS lpPos = (LPINTERNALPOS)WINPOS_InitInternalPos( pWnd,
1306 *(LPPOINT32)&pWnd->rectWindow.left, &pWnd->rectWindow );
1307
1308 if( flags & PLACE_MIN ) lpPos->ptIconPos = wndpl->ptMinPosition;
1309 if( flags & PLACE_MAX ) lpPos->ptMaxPos = wndpl->ptMaxPosition;
1310 if( flags & PLACE_RECT) lpPos->rectNormal = wndpl->rcNormalPosition;
1311
1312 if( pWnd->dwStyle & WS_MINIMIZE )
1313 {
1314 WINPOS_ShowIconTitle( pWnd, FALSE );
1315 if( wndpl->flags & WPF_SETMINPOSITION && !EMPTYPOINT(lpPos->ptIconPos))
1316 SetWindowPos32( hwnd, 0, lpPos->ptIconPos.x, lpPos->ptIconPos.y,
1317 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
1318 }
1319 else if( pWnd->dwStyle & WS_MAXIMIZE )
1320 {
1321 if( !EMPTYPOINT(lpPos->ptMaxPos) )
1322 SetWindowPos32( hwnd, 0, lpPos->ptMaxPos.x, lpPos->ptMaxPos.y,
1323 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
1324 }
1325 else if( flags & PLACE_RECT )
1326 SetWindowPos32( hwnd, 0, lpPos->rectNormal.left, lpPos->rectNormal.top,
1327 lpPos->rectNormal.right - lpPos->rectNormal.left,
1328 lpPos->rectNormal.bottom - lpPos->rectNormal.top,
1329 SWP_NOZORDER | SWP_NOACTIVATE );
1330
1331 ShowWindow32( hwnd, wndpl->showCmd );
1332 if( IsWindow32(hwnd) && pWnd->dwStyle & WS_MINIMIZE )
1333 {
1334 if( pWnd->dwStyle & WS_VISIBLE ) WINPOS_ShowIconTitle( pWnd, TRUE );
1335
1336 /* SDK: ...valid only the next time... */
1337 if( wndpl->flags & WPF_RESTORETOMAXIMIZED ) pWnd->flags |= WIN_RESTORE_MAX;
1338 }
1339 return TRUE;
1340 }
1341 return FALSE;
1342 }
1343
1344
1345 /***********************************************************************
1346 * SetWindowPlacement16 (USER.371)
1347 */
1348 BOOL16 WINAPI SetWindowPlacement16(HWND16 hwnd, const WINDOWPLACEMENT16 *wndpl)
1349 {
1350 return WINPOS_SetPlacement( hwnd, wndpl,
1351 PLACE_MIN | PLACE_MAX | PLACE_RECT );
1352 }
1353
1354 /***********************************************************************
1355 * SetWindowPlacement32 (USER32.519)
1356 */
1357 BOOL32 WINAPI SetWindowPlacement32( HWND32 hwnd, const WINDOWPLACEMENT32 *pwpl32 )
1358 {
1359 if( pwpl32 )
1360 {
1361 WINDOWPLACEMENT16 wpl = { sizeof(WINDOWPLACEMENT16),
1362 pwpl32->flags, pwpl32->showCmd, { pwpl32->ptMinPosition.x,
1363 pwpl32->ptMinPosition.y }, { pwpl32->ptMaxPosition.x,
1364 pwpl32->ptMaxPosition.y }, { pwpl32->rcNormalPosition.left,
1365 pwpl32->rcNormalPosition.top, pwpl32->rcNormalPosition.right,
1366 pwpl32->rcNormalPosition.bottom } };
1367
1368 return WINPOS_SetPlacement( hwnd, &wpl, PLACE_MIN | PLACE_MAX | PLACE_RECT );
1369 }
1370 return FALSE;
1371 }
1372
1373
1374 /***********************************************************************
1375 * SetInternalWindowPos16 (USER.461)
1376 */
1377 void WINAPI SetInternalWindowPos16( HWND16 hwnd, UINT16 showCmd,
1378 LPRECT16 rect, LPPOINT16 pt )
1379 {
1380 if( IsWindow16(hwnd) )
1381 {
1382 WINDOWPLACEMENT16 wndpl;
1383 UINT32 flags;
1384
1385 wndpl.length = sizeof(wndpl);
1386 wndpl.showCmd = showCmd;
1387 wndpl.flags = flags = 0;
1388
1389 if( pt )
1390 {
1391 flags |= PLACE_MIN;
1392 wndpl.flags |= WPF_SETMINPOSITION;
1393 wndpl.ptMinPosition = *pt;
1394 }
1395 if( rect )
1396 {
1397 flags |= PLACE_RECT;
1398 wndpl.rcNormalPosition = *rect;
1399 }
1400 WINPOS_SetPlacement( hwnd, &wndpl, flags );
1401 }
1402 }
1403
1404
1405 /***********************************************************************
1406 * SetInternalWindowPos32 (USER32.483)
1407 */
1408 void WINAPI SetInternalWindowPos32( HWND32 hwnd, UINT32 showCmd,
1409 LPRECT32 rect, LPPOINT32 pt )
1410 {
1411 if( IsWindow32(hwnd) )
1412 {
1413 WINDOWPLACEMENT16 wndpl;
1414 UINT32 flags;
1415
1416 wndpl.length = sizeof(wndpl);
1417 wndpl.showCmd = showCmd;
1418 wndpl.flags = flags = 0;
1419
1420 if( pt )
1421 {
1422 flags |= PLACE_MIN;
1423 wndpl.flags |= WPF_SETMINPOSITION;
1424 CONV_POINT32TO16( pt, &wndpl.ptMinPosition );
1425 }
1426 if( rect )
1427 {
1428 flags |= PLACE_RECT;
1429 CONV_RECT32TO16( rect, &wndpl.rcNormalPosition );
1430 }
1431 WINPOS_SetPlacement( hwnd, &wndpl, flags );
1432 }
1433 }
1434
1435 /*******************************************************************
1436 * WINPOS_SetActiveWindow
1437 *
1438 * SetActiveWindow() back-end. This is the only function that
1439 * can assign active status to a window. It must be called only
1440 * for the top level windows.
1441 */
1442 BOOL32 WINPOS_SetActiveWindow( HWND32 hWnd, BOOL32 fMouse, BOOL32 fChangeFocus)
1443 {
1444 CBTACTIVATESTRUCT16* cbtStruct;
1445 WND* wndPtr, *wndTemp;
1446 HQUEUE16 hOldActiveQueue, hNewActiveQueue;
1447 WORD wIconized = 0;
1448
1449 /* paranoid checks */
1450 if( hWnd == GetDesktopWindow32() || hWnd == hwndActive ) return 0;
1451
1452 /* if (wndPtr && (GetTaskQueue(0) != wndPtr->hmemTaskQ))
1453 * return 0;
1454 */
1455 wndPtr = WIN_FindWndPtr(hWnd);
1456 hOldActiveQueue = (pActiveQueue)?pActiveQueue->self : 0;
1457
1458 if( (wndTemp = WIN_FindWndPtr(hwndActive)) )
1459 wIconized = HIWORD(wndTemp->dwStyle & WS_MINIMIZE);
1460 else
1461 TRACE(win,"no current active window.\n");
1462
1463 /* call CBT hook chain */
1464 if ((cbtStruct = SEGPTR_NEW(CBTACTIVATESTRUCT16)))
1465 {
1466 LRESULT wRet;
1467 cbtStruct->fMouse = fMouse;
1468 cbtStruct->hWndActive = hwndActive;
1469 wRet = HOOK_CallHooks16( WH_CBT, HCBT_ACTIVATE, (WPARAM16)hWnd,
1470 (LPARAM)SEGPTR_GET(cbtStruct) );
1471 SEGPTR_FREE(cbtStruct);
1472 if (wRet) return wRet;
1473 }
1474
1475 /* set prev active wnd to current active wnd and send notification */
1476 if ((hwndPrevActive = hwndActive) && IsWindow32(hwndPrevActive))
1477 {
1478 if (!SendMessage32A( hwndPrevActive, WM_NCACTIVATE, FALSE, 0 ))
1479 {
1480 if (GetSysModalWindow16() != hWnd) return 0;
1481 /* disregard refusal if hWnd is sysmodal */
1482 }
1483
1484 #if 1
1485 SendMessage32A( hwndPrevActive, WM_ACTIVATE,
1486 MAKEWPARAM( WA_INACTIVE, wIconized ),
1487 (LPARAM)hWnd );
1488 #else
1489 /* FIXME: must be SendMessage16() because 32A doesn't do
1490 * intertask at this time */
1491 SendMessage16( hwndPrevActive, WM_ACTIVATE, WA_INACTIVE,
1492 MAKELPARAM( (HWND16)hWnd, wIconized ) );
1493 #endif
1494
1495 /* check if something happened during message processing */
1496 if( hwndPrevActive != hwndActive ) return 0;
1497 }
1498
1499 /* set active wnd */
1500 hwndActive = hWnd;
1501
1502 /* send palette messages */
1503 if (hWnd && SendMessage16( hWnd, WM_QUERYNEWPALETTE, 0, 0L))
1504 SendMessage16((HWND16)-1, WM_PALETTEISCHANGING, (WPARAM16)hWnd, 0L );
1505
1506 /* if prev wnd is minimized redraw icon title */
1507 if( IsIconic32( hwndPrevActive ) ) WINPOS_RedrawIconTitle(hwndPrevActive);
1508
1509 /* managed windows will get ConfigureNotify event */
1510 if (wndPtr && !(wndPtr->dwStyle & WS_CHILD) && !(wndPtr->flags & WIN_MANAGED))
1511 {
1512 /* check Z-order and bring hWnd to the top */
1513 for (wndTemp = WIN_GetDesktop()->child; wndTemp; wndTemp = wndTemp->next)
1514 if (wndTemp->dwStyle & WS_VISIBLE) break;
1515
1516 if( wndTemp != wndPtr )
1517 SetWindowPos32(hWnd, HWND_TOP, 0,0,0,0,
1518 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
1519 if (!IsWindow32(hWnd)) return 0;
1520 }
1521
1522 hNewActiveQueue = wndPtr ? wndPtr->hmemTaskQ : 0;
1523
1524 /* send WM_ACTIVATEAPP if necessary */
1525 if (hOldActiveQueue != hNewActiveQueue)
1526 {
1527 WND **list, **ppWnd;
1528
1529 if ((list = WIN_BuildWinArray( WIN_GetDesktop(), 0, NULL )))
1530 {
1531 for (ppWnd = list; *ppWnd; ppWnd++)
1532 {
1533 if (!IsWindow32( (*ppWnd)->hwndSelf )) continue;
1534
1535 if ((*ppWnd)->hmemTaskQ == hOldActiveQueue)
1536 SendMessage16( (*ppWnd)->hwndSelf, WM_ACTIVATEAPP,
1537 0, QUEUE_GetQueueTask(hNewActiveQueue) );
1538 }
1539 HeapFree( SystemHeap, 0, list );
1540 }
1541
1542 pActiveQueue = (hNewActiveQueue)
1543 ? (MESSAGEQUEUE*) GlobalLock16(hNewActiveQueue) : NULL;
1544
1545 if ((list = WIN_BuildWinArray( WIN_GetDesktop(), 0, NULL )))
1546 {
1547 for (ppWnd = list; *ppWnd; ppWnd++)
1548 {
1549 if (!IsWindow32( (*ppWnd)->hwndSelf )) continue;
1550
1551 if ((*ppWnd)->hmemTaskQ == hNewActiveQueue)
1552 SendMessage16( (*ppWnd)->hwndSelf, WM_ACTIVATEAPP,
1553 1, QUEUE_GetQueueTask( hOldActiveQueue ) );
1554 }
1555 HeapFree( SystemHeap, 0, list );
1556 }
1557 if (!IsWindow32(hWnd)) return 0;
1558 }
1559
1560 if (hWnd)
1561 {
1562 /* walk up to the first unowned window */
1563 wndTemp = wndPtr;
1564 while (wndTemp->owner) wndTemp = wndTemp->owner;
1565 /* and set last active owned popup */
1566 wndTemp->hwndLastActive = hWnd;
1567
1568 wIconized = HIWORD(wndTemp->dwStyle & WS_MINIMIZE);
1569 SendMessage32A( hWnd, WM_NCACTIVATE, TRUE, 0 );
1570 #if 1
1571 SendMessage32A( hWnd, WM_ACTIVATE,
1572 MAKEWPARAM( (fMouse) ? WA_CLICKACTIVE : WA_ACTIVE, wIconized),
1573 (LPARAM)hwndPrevActive );
1574 #else
1575 SendMessage16(hWnd, WM_ACTIVATE, (fMouse) ? WA_CLICKACTIVE : WA_ACTIVE,
1576 MAKELPARAM( (HWND16)hwndPrevActive, wIconized) );
1577 #endif
1578
1579 if( !IsWindow32(hWnd) ) return 0;
1580 }
1581
1582 /* change focus if possible */
1583 if( fChangeFocus && GetFocus32() )
1584 if( WIN_GetTopParent(GetFocus32()) != hwndActive )
1585 FOCUS_SwitchFocus( GetFocus32(),
1586 (wndPtr && (wndPtr->dwStyle & WS_MINIMIZE))?
1587 0:
1588 hwndActive
1589 );
1590
1591 if( !hwndPrevActive && wndPtr )
1592 (*wndPtr->pDriver->pForceWindowRaise)(wndPtr);
1593
1594 /* if active wnd is minimized redraw icon title */
1595 if( IsIconic32(hwndActive) ) WINPOS_RedrawIconTitle(hwndActive);
1596
1597 return (hWnd == hwndActive);
1598 }
1599
1600 /*******************************************************************
1601 * WINPOS_ActivateOtherWindow
1602 *
1603 * Activates window other than pWnd.
1604 */
1605 BOOL32 WINPOS_ActivateOtherWindow(WND* pWnd)
1606 {
1607 BOOL32 bRet = 0;
1608 WND* pWndTo = NULL;
1609
1610 if( pWnd->hwndSelf == hwndPrevActive )
1611 hwndPrevActive = 0;
1612
1613 if( hwndActive != pWnd->hwndSelf &&
1614 ( hwndActive || QUEUE_IsExitingQueue(pWnd->hmemTaskQ)) )
1615 return 0;
1616
1617 if( !(pWnd->dwStyle & WS_POPUP) || !(pWnd->owner) ||
1618 !WINPOS_CanActivate((pWndTo = WIN_GetTopParentPtr(pWnd->owner))) )
1619 {
1620 WND* pWndPtr = WIN_GetTopParentPtr(pWnd);
1621
1622 pWndTo = WIN_FindWndPtr(hwndPrevActive);
1623
1624 while( !WINPOS_CanActivate(pWndTo) )
1625 {
1626 /* by now owned windows should've been taken care of */
1627
1628 pWndTo = pWndPtr->next;
1629 pWndPtr = pWndTo;
1630 if( !pWndTo ) break;
1631 }
1632 }
1633
1634 bRet = WINPOS_SetActiveWindow( pWndTo ? pWndTo->hwndSelf : 0, FALSE, TRUE );
1635
1636 /* switch desktop queue to current active */
1637 if( pWndTo ) WIN_GetDesktop()->hmemTaskQ = pWndTo->hmemTaskQ;
1638
1639 hwndPrevActive = 0;
1640 return bRet;
1641 }
1642
1643 /*******************************************************************
1644 * WINPOS_ChangeActiveWindow
1645 *
1646 */
1647 BOOL32 WINPOS_ChangeActiveWindow( HWND32 hWnd, BOOL32 mouseMsg )
1648 {
1649 WND *wndPtr = WIN_FindWndPtr(hWnd);
1650
1651 if (!hWnd) return WINPOS_SetActiveWindow( 0, mouseMsg, TRUE );
1652
1653 if( !wndPtr ) return FALSE;
1654
1655 /* child windows get WM_CHILDACTIVATE message */
1656 if( (wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) == WS_CHILD )
1657 return SendMessage32A(hWnd, WM_CHILDACTIVATE, 0, 0L);
1658
1659 /* owned popups imply owner activation - not sure */
1660 if ((wndPtr->dwStyle & WS_POPUP) && wndPtr->owner &&
1661 (wndPtr->owner->dwStyle & WS_VISIBLE ) &&
1662 !(wndPtr->owner->dwStyle & WS_DISABLED ))
1663 {
1664 if (!(wndPtr = wndPtr->owner)) return FALSE;
1665 hWnd = wndPtr->hwndSelf;
1666 }
1667
1668 if( hWnd == hwndActive ) return FALSE;
1669
1670 if( !WINPOS_SetActiveWindow(hWnd ,mouseMsg ,TRUE) )
1671 return FALSE;
1672
1673 /* switch desktop queue to current active */
1674 if( wndPtr->parent == WIN_GetDesktop())
1675 WIN_GetDesktop()->hmemTaskQ = wndPtr->hmemTaskQ;
1676
1677 return TRUE;
1678 }
1679
1680
1681 /***********************************************************************
1682 * WINPOS_SendNCCalcSize
1683 *
1684 * Send a WM_NCCALCSIZE message to a window.
1685 * All parameters are read-only except newClientRect.
1686 * oldWindowRect, oldClientRect and winpos must be non-NULL only
1687 * when calcValidRect is TRUE.
1688 */
1689 LONG WINPOS_SendNCCalcSize( HWND32 hwnd, BOOL32 calcValidRect,
1690 RECT32 *newWindowRect, RECT32 *oldWindowRect,
1691 RECT32 *oldClientRect, WINDOWPOS32 *winpos,
1692 RECT32 *newClientRect )
1693 {
1694 NCCALCSIZE_PARAMS32 params;
1695 WINDOWPOS32 winposCopy;
1696 LONG result;
1697
1698 params.rgrc[0] = *newWindowRect;
1699 if (calcValidRect)
1700 {
1701 winposCopy = *winpos;
1702 params.rgrc[1] = *oldWindowRect;
1703 params.rgrc[2] = *oldClientRect;
1704 params.lppos = &winposCopy;
1705 }
1706 result = SendMessage32A( hwnd, WM_NCCALCSIZE, calcValidRect,
1707 (LPARAM)&params );
1708 TRACE(win, "%d,%d-%d,%d\n",
1709 params.rgrc[0].left, params.rgrc[0].top,
1710 params.rgrc[0].right, params.rgrc[0].bottom );
1711 *newClientRect = params.rgrc[0];
1712 return result;
1713 }
1714
1715
1716 /***********************************************************************
1717 * WINPOS_HandleWindowPosChanging16
1718 *
1719 * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
1720 */
1721 LONG WINPOS_HandleWindowPosChanging16( WND *wndPtr, WINDOWPOS16 *winpos )
1722 {
1723 POINT32 maxSize, minTrack;
1724 if (winpos->flags & SWP_NOSIZE) return 0;
1725 if ((wndPtr->dwStyle & WS_THICKFRAME) ||
1726 ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) == 0))
1727 {
1728 WINPOS_GetMinMaxInfo( wndPtr, &maxSize, NULL, &minTrack, NULL );
1729 if (maxSize.x < winpos->cx) winpos->cx = maxSize.x;
1730 if (maxSize.y < winpos->cy) winpos->cy = maxSize.y;
1731 if (!(wndPtr->dwStyle & WS_MINIMIZE))
1732 {
1733 if (winpos->cx < minTrack.x ) winpos->cx = minTrack.x;
1734 if (winpos->cy < minTrack.y ) winpos->cy = minTrack.y;
1735 }
1736 }
1737 return 0;
1738 }
1739
1740
1741 /***********************************************************************
1742 * WINPOS_HandleWindowPosChanging32
1743 *
1744 * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
1745 */
1746 LONG WINPOS_HandleWindowPosChanging32( WND *wndPtr, WINDOWPOS32 *winpos )
1747 {
1748 POINT32 maxSize;
1749 if (winpos->flags & SWP_NOSIZE) return 0;
1750 if ((wndPtr->dwStyle & WS_THICKFRAME) ||
1751 ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) == 0))
1752 {
1753 WINPOS_GetMinMaxInfo( wndPtr, &maxSize, NULL, NULL, NULL );
1754 winpos->cx = MIN( winpos->cx, maxSize.x );
1755 winpos->cy = MIN( winpos->cy, maxSize.y );
1756 }
1757 return 0;
1758 }
1759
1760
1761 /***********************************************************************
1762 * WINPOS_MoveWindowZOrder
1763 *
1764 * Move a window in Z order, invalidating everything that needs it.
1765 * Only necessary for windows without associated X window.
1766 */
1767 static void WINPOS_MoveWindowZOrder( HWND32 hwnd, HWND32 hwndAfter )
1768 {
1769 BOOL32 movingUp;
1770 WND *pWndAfter, *pWndCur, *wndPtr = WIN_FindWndPtr( hwnd );
1771
1772 /* We have two possible cases:
1773 * - The window is moving up: we have to invalidate all areas
1774 * of the window that were covered by other windows
1775 * - The window is moving down: we have to invalidate areas
1776 * of other windows covered by this one.
1777 */
1778
1779 if (hwndAfter == HWND_TOP)
1780 {
1781 movingUp = TRUE;
1782 }
1783 else if (hwndAfter == HWND_BOTTOM)
1784 {
1785 if (!wndPtr->next) return; /* Already at the bottom */
1786 movingUp = FALSE;
1787 }
1788 else
1789 {
1790 if (!(pWndAfter = WIN_FindWndPtr( hwndAfter ))) return;
1791 if (wndPtr->next == pWndAfter) return; /* Already placed right */
1792
1793 /* Determine which window we encounter first in Z-order */
1794 pWndCur = wndPtr->parent->child;
1795 while ((pWndCur != wndPtr) && (pWndCur != pWndAfter))
1796 pWndCur = pWndCur->next;
1797 movingUp = (pWndCur == pWndAfter);
1798 }
1799
1800 if (movingUp)
1801 {
1802 WND *pWndPrevAfter = wndPtr->next;
1803 WIN_UnlinkWindow( hwnd );
1804 WIN_LinkWindow( hwnd, hwndAfter );
1805 pWndCur = wndPtr->next;
1806 while (pWndCur != pWndPrevAfter)
1807 {
1808 RECT32 rect = { pWndCur->rectWindow.left,
1809 pWndCur->rectWindow.top,
1810 pWndCur->rectWindow.right,
1811 pWndCur->rectWindow.bottom };
1812 OffsetRect32( &rect, -wndPtr->rectClient.left,
1813 -wndPtr->rectClient.top );
1814 PAINT_RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN |
1815 RDW_FRAME | RDW_ERASE, 0 );
1816 pWndCur = pWndCur->next;
1817 }
1818 }
1819 else /* Moving down */
1820 {
1821 pWndCur = wndPtr->next;
1822 WIN_UnlinkWindow( hwnd );
1823 WIN_LinkWindow( hwnd, hwndAfter );
1824 while (pWndCur != wndPtr)
1825 {
1826 RECT32 rect = { pWndCur->rectWindow.left,
1827 pWndCur->rectWindow.top,
1828 pWndCur->rectWindow.right,
1829 pWndCur->rectWindow.bottom };
1830 OffsetRect32( &rect, -pWndCur->rectClient.left,
1831 -pWndCur->rectClient.top );
1832 PAINT_RedrawWindow( pWndCur->hwndSelf, &rect, 0, RDW_INVALIDATE |
1833 RDW_ALLCHILDREN | RDW_FRAME | RDW_ERASE, 0 );
1834 pWndCur = pWndCur->next;
1835 }
1836 }
1837 }
1838
1839 /***********************************************************************
1840 * WINPOS_ReorderOwnedPopups
1841 *
1842 * fix Z order taking into account owned popups -
1843 * basically we need to maintain them above the window that owns them
1844 */
1845 HWND32 WINPOS_ReorderOwnedPopups(HWND32 hwndInsertAfter,WND* wndPtr,WORD flags)
1846 {
1847 WND* w = WIN_GetDesktop()->child;
1848
1849 if( wndPtr->dwStyle & WS_POPUP && wndPtr->owner )
1850 {
1851 /* implement "local z-order" between the top and owner window */
1852
1853 HWND32 hwndLocalPrev = HWND_TOP;
1854
1855 if( hwndInsertAfter != HWND_TOP )
1856 {
1857 while( w != wndPtr->owner )
1858 {
1859 if (w != wndPtr) hwndLocalPrev = w->hwndSelf;
1860 if( hwndLocalPrev == hwndInsertAfter ) break;
1861 w = w->next;
1862 }
1863 hwndInsertAfter = hwndLocalPrev;
1864 }
1865
1866 }
1867 else if( wndPtr->dwStyle & WS_CHILD ) return hwndInsertAfter;
1868
1869 w = WIN_GetDesktop()->child;
1870 while( w )
1871 {
1872 if( w == wndPtr ) break;
1873
1874 if( w->dwStyle & WS_POPUP && w->owner == wndPtr )
1875 {
1876 SetWindowPos32(w->hwndSelf, hwndInsertAfter, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE |
1877 SWP_NOACTIVATE | SWP_NOSENDCHANGING | SWP_DEFERERASE);
1878 hwndInsertAfter = w->hwndSelf;
1879 }
1880 w = w->next;
1881 }
1882
1883 return hwndInsertAfter;
1884 }
1885
1886 /***********************************************************************
1887 * WINPOS_SizeMoveClean
1888 *
1889 * Make window look nice without excessive repainting
1890 *
1891 * the pain:
1892 *
1893 * visible regions are in window coordinates
1894 * update regions are in window client coordinates
1895 * client and window rectangles are in parent client coordinates
1896 *
1897 * FIXME: Move visible and update regions to the same coordinate system
1898 * (either parent client or window). This is a lot of work though.
1899 */
1900 static UINT32 WINPOS_SizeMoveClean( WND* Wnd, HRGN32 oldVisRgn,
1901 LPRECT32 lpOldWndRect,
1902 LPRECT32 lpOldClientRect, UINT32 uFlags )
1903 {
1904 HRGN32 newVisRgn = DCE_GetVisRgn(Wnd->hwndSelf,DCX_WINDOW | DCX_CLIPSIBLINGS);
1905 HRGN32 dirtyRgn = CreateRectRgn32(0,0,0,0);
1906 int other, my;
1907
1908 TRACE(win,"cleaning up...new wnd=(%i %i-%i %i) old wnd=(%i %i-%i %i)\n",
1909 Wnd->rectWindow.left, Wnd->rectWindow.top,
1910 Wnd->rectWindow.right, Wnd->rectWindow.bottom,
1911 lpOldWndRect->left, lpOldWndRect->top,
1912 lpOldWndRect->right, lpOldWndRect->bottom);
1913 TRACE(win,"\tnew client=(%i %i-%i %i) old client=(%i %i-%i %i)\n",
1914 Wnd->rectClient.left, Wnd->rectClient.top,
1915 Wnd->rectClient.right, Wnd->rectClient.bottom,
1916 lpOldClientRect->left, lpOldClientRect->top,
1917 lpOldClientRect->right,lpOldClientRect->bottom );
1918
1919 if( (lpOldWndRect->right - lpOldWndRect->left) != (Wnd->rectWindow.right - Wnd->rectWindow.left) ||
1920 (lpOldWndRect->bottom - lpOldWndRect->top) != (Wnd->rectWindow.bottom - Wnd->rectWindow.top) )
1921 uFlags |= SMC_DRAWFRAME;
1922
1923 CombineRgn32( dirtyRgn, newVisRgn, 0, RGN_COPY);
1924
1925 if( !(uFlags & SMC_NOCOPY) )
1926 CombineRgn32( newVisRgn, newVisRgn, oldVisRgn, RGN_AND );
1927
1928 /* map regions to the parent client area */
1929
1930 OffsetRgn32( dirtyRgn, Wnd->rectWindow.left, Wnd->rectWindow.top );
1931 OffsetRgn32( oldVisRgn, lpOldWndRect->left, lpOldWndRect->top );
1932
1933 /* compute invalidated region outside Wnd - (in client coordinates of the parent window) */
1934
1935 other = CombineRgn32(dirtyRgn, oldVisRgn, dirtyRgn, RGN_DIFF);
1936
1937 /* map visible region to the Wnd client area */
1938
1939 OffsetRgn32( newVisRgn, Wnd->rectWindow.left - Wnd->rectClient.left,
1940 Wnd->rectWindow.top - Wnd->rectClient.top );
1941
1942 /* substract previously invalidated region from the Wnd visible region */
1943
1944 my = (Wnd->hrgnUpdate > 1) ? CombineRgn32( newVisRgn, newVisRgn,
1945 Wnd->hrgnUpdate, RGN_DIFF)
1946 : COMPLEXREGION;
1947
1948 if( uFlags & SMC_NOCOPY ) /* invalidate Wnd visible region */
1949 {
1950 if (my != NULLREGION)
1951 PAINT_RedrawWindow( Wnd->hwndSelf, NULL, newVisRgn, RDW_INVALIDATE |
1952 RDW_FRAME | RDW_ALLCHILDREN | RDW_ERASE, RDW_C_USEHRGN );
1953 else if(uFlags & SMC_DRAWFRAME)
1954 Wnd->flags |= WIN_NEEDS_NCPAINT;
1955 }
1956 else /* bitblt old client area */
1957 {
1958 HDC32 hDC;
1959 int update;
1960 HRGN32 updateRgn;
1961 int xfrom,yfrom,xto,yto,width,height;
1962
1963 if( uFlags & SMC_DRAWFRAME )
1964 {
1965 /* copy only client area, frame will be redrawn anyway */
1966
1967 xfrom = lpOldClientRect->left; yfrom = lpOldClientRect->top;
1968 xto = Wnd->rectClient.left; yto = Wnd->rectClient.top;
1969 width = lpOldClientRect->right - xfrom; height = lpOldClientRect->bottom - yfrom;
1970 updateRgn = CreateRectRgn32( 0, 0, width, height );
1971 CombineRgn32( newVisRgn, newVisRgn, updateRgn, RGN_AND );
1972 SetRectRgn32( updateRgn, 0, 0, Wnd->rectClient.right - xto,
1973 Wnd->rectClient.bottom - yto );
1974 }
1975 else
1976 {
1977 xfrom = lpOldWndRect->left; yfrom = lpOldWndRect->top;
1978 xto = Wnd->rectWindow.left; yto = Wnd->rectWindow.top;
1979 width = lpOldWndRect->right - xfrom; height = lpOldWndRect->bottom - yfrom;
1980 updateRgn = CreateRectRgn32( xto - Wnd->rectClient.left,
1981 yto - Wnd->rectClient.top,
1982 Wnd->rectWindow.right - Wnd->rectClient.left,
1983 Wnd->rectWindow.bottom - Wnd->rectClient.top );
1984 }
1985
1986 CombineRgn32( newVisRgn, newVisRgn, updateRgn, RGN_AND );
1987
1988 /* substract new visRgn from target rect to get a region that won't be copied */
1989
1990 update = CombineRgn32( updateRgn, updateRgn, newVisRgn, RGN_DIFF );
1991
1992 /* Blt valid bits using parent window DC */
1993
1994 if( my != NULLREGION && (xfrom != xto || yfrom != yto) )
1995 {
1996
1997 /* compute clipping region in parent client coordinates */
1998
1999 OffsetRgn32( newVisRgn, Wnd->rectClient.left, Wnd->rectClient.top );
2000 CombineRgn32( oldVisRgn, oldVisRgn, newVisRgn, RGN_OR );
2001
2002 hDC = GetDCEx32( Wnd->parent->hwndSelf, oldVisRgn,
2003 DCX_KEEPCLIPRGN | DCX_INTERSECTRGN |
2004 DCX_CACHE | DCX_CLIPSIBLINGS);
2005
2006 BitBlt32( hDC, xto, yto, width, height, hDC, xfrom, yfrom, SRCCOPY );
2007 ReleaseDC32( Wnd->parent->hwndSelf, hDC);
2008 }
2009
2010 if( update != NULLREGION )
2011 PAINT_RedrawWindow( Wnd->hwndSelf, NULL, updateRgn, RDW_INVALIDATE |
2012 RDW_FRAME | RDW_ALLCHILDREN | RDW_ERASE, RDW_C_USEHRGN );
2013 else if( uFlags & SMC_DRAWFRAME ) Wnd->flags |= WIN_NEEDS_NCPAINT;
2014 DeleteObject32( updateRgn );
2015 }
2016
2017 /* erase uncovered areas */
2018
2019 if( !(uFlags & SMC_NOPARENTERASE) && (other != NULLREGION ) )
2020 PAINT_RedrawWindow( Wnd->parent->hwndSelf, NULL, dirtyRgn,
2021 RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE, RDW_C_USEHRGN );
2022 DeleteObject32(dirtyRgn);
2023 DeleteObject32(newVisRgn);
2024 return uFlags;
2025 }
2026
2027 /***********************************************************************
2028 * SetWindowPos (USER.232)
2029 */
2030 BOOL16 WINAPI SetWindowPos16( HWND16 hwnd, HWND16 hwndInsertAfter,
2031 INT16 x, INT16 y, INT16 cx, INT16 cy, WORD flags)
2032 {
2033 return SetWindowPos32(hwnd,(INT32)(INT16)hwndInsertAfter,x,y,cx,cy,flags);
2034 }
2035
2036 /***********************************************************************
2037 * SetWindowPos (USER32.520)
2038 */
2039 BOOL32 WINAPI SetWindowPos32( HWND32 hwnd, HWND32 hwndInsertAfter,
2040 INT32 x, INT32 y, INT32 cx, INT32 cy, WORD flags)
2041 {
2042 WINDOWPOS32 winpos;
2043 WND * wndPtr;
2044 RECT32 newWindowRect, newClientRect, oldWindowRect;
2045 HRGN32 visRgn = 0;
2046 HWND32 tempInsertAfter= 0;
2047 int result = 0;
2048 UINT32 uFlags = 0;
2049 BOOL32 resync = FALSE;
2050
2051 TRACE(win,"hwnd %04x, (%i,%i)-(%i,%i) flags %08x\n",
2052 hwnd, x, y, x+cx, y+cy, flags);
2053 /* Check window handle */
2054
2055 if (hwnd == GetDesktopWindow32()) return FALSE;
2056 if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
2057
2058 if(wndPtr->dwStyle & WS_VISIBLE)
2059 flags &= ~SWP_SHOWWINDOW;
2060 else
2061 {
2062 uFlags |= SMC_NOPARENTERASE;
2063 flags &= ~SWP_HIDEWINDOW;
2064 if (!(flags & SWP_SHOWWINDOW)) flags |= SWP_NOREDRAW;
2065 }
2066
2067 /* Check for windows that may not be resized
2068 FIXME: this should be done only for Windows 3.0 programs
2069 if (flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW ) )
2070 flags |= SWP_NOSIZE | SWP_NOMOVE;
2071 */
2072 /* Check dimensions */
2073
2074 if (cx <= 0) cx = 1;
2075 if (cy <= 0) cy = 1;
2076
2077 /* Check flags */
2078
2079 if (hwnd == hwndActive) flags |= SWP_NOACTIVATE; /* Already active */
2080 if ((wndPtr->rectWindow.right - wndPtr->rectWindow.left == cx) &&
2081 (wndPtr->rectWindow.bottom - wndPtr->rectWindow.top == cy))
2082 flags |= SWP_NOSIZE; /* Already the right size */
2083 if ((wndPtr->rectWindow.left == x) && (wndPtr->rectWindow.top == y))
2084 flags |= SWP_NOMOVE; /* Already the right position */
2085
2086 /* Check hwndInsertAfter */
2087
2088 if (!(flags & (SWP_NOZORDER | SWP_NOACTIVATE)))
2089 {
2090 /* Ignore TOPMOST flags when activating a window */
2091 /* _and_ moving it in Z order. */
2092 if ((hwndInsertAfter == HWND_TOPMOST) ||
2093 (hwndInsertAfter == HWND_NOTOPMOST))
2094 hwndInsertAfter = HWND_TOP;
2095 }
2096 /* TOPMOST not supported yet */
2097 if ((hwndInsertAfter == HWND_TOPMOST) ||
2098 (hwndInsertAfter == HWND_NOTOPMOST)) hwndInsertAfter = HWND_TOP;
2099
2100 /* hwndInsertAfter must be a sibling of the window */
2101 if ((hwndInsertAfter != HWND_TOP) && (hwndInsertAfter != HWND_BOTTOM))
2102 {
2103 WND* wnd = WIN_FindWndPtr(hwndInsertAfter);
2104
2105 if( wndPtr ) {
2106 if( wnd->parent != wndPtr->parent ) return FALSE;
2107 if( wnd->next == wndPtr ) flags |= SWP_NOZORDER;
2108 }
2109 }
2110 else if (!(wndPtr->window))
2111 {
2112 /* FIXME: the following optimization is no good for "X-ed" windows */
2113 if (hwndInsertAfter == HWND_TOP)
2114 flags |= ( wndPtr->parent->child == wndPtr)? SWP_NOZORDER: 0;
2115 else /* HWND_BOTTOM */
2116 flags |= ( wndPtr->next )? 0: SWP_NOZORDER;
2117 }
2118
2119 /* Fill the WINDOWPOS structure */
2120
2121 winpos.hwnd = hwnd;
2122 winpos.hwndInsertAfter = hwndInsertAfter;
2123 winpos.x = x;
2124 winpos.y = y;
2125 winpos.cx = cx;
2126 winpos.cy = cy;
2127 winpos.flags = flags;
2128
2129 /* Send WM_WINDOWPOSCHANGING message */
2130
2131 if (!(winpos.flags & SWP_NOSENDCHANGING))
2132 SendMessage32A( hwnd, WM_WINDOWPOSCHANGING, 0, (LPARAM)&winpos );
2133
2134 /* Calculate new position and size */
2135
2136 newWindowRect = wndPtr->rectWindow;
2137 newClientRect = (wndPtr->dwStyle & WS_MINIMIZE) ? wndPtr->rectWindow
2138 : wndPtr->rectClient;
2139
2140 if (!(winpos.flags & SWP_NOSIZE))
2141 {
2142 newWindowRect.right = newWindowRect.left + winpos.cx;
2143 newWindowRect.bottom = newWindowRect.top + winpos.cy;
2144 }
2145 if (!(winpos.flags & SWP_NOMOVE))
2146 {
2147 newWindowRect.left = winpos.x;
2148 newWindowRect.top = winpos.y;
2149 newWindowRect.right += winpos.x - wndPtr->rectWindow.left;
2150 newWindowRect.bottom += winpos.y - wndPtr->rectWindow.top;
2151
2152 OffsetRect32( &newClientRect, winpos.x - wndPtr->rectWindow.left,
2153 winpos.y - wndPtr->rectWindow.top );
2154 }
2155
2156 winpos.flags |= SWP_NOCLIENTMOVE | SWP_NOCLIENTSIZE;
2157
2158 /* Reposition window in Z order */
2159
2160 if (!(winpos.flags & SWP_NOZORDER))
2161 {
2162 /* reorder owned popups if hwnd is top-level window
2163 */
2164 if( wndPtr->parent == WIN_GetDesktop() )
2165 hwndInsertAfter = WINPOS_ReorderOwnedPopups( hwndInsertAfter,
2166 wndPtr, winpos.flags );
2167
2168 if (wndPtr->window)
2169 {
2170 WIN_UnlinkWindow( winpos.hwnd );
2171 WIN_LinkWindow( winpos.hwnd, hwndInsertAfter );
2172 }
2173 else WINPOS_MoveWindowZOrder( winpos.hwnd, hwndInsertAfter );
2174 }
2175
2176 if ( !wndPtr->window && !(winpos.flags & SWP_NOREDRAW) &&
2177 ((winpos.flags & (SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED))
2178 != (SWP_NOMOVE | SWP_NOSIZE)) )
2179 visRgn = DCE_GetVisRgn(hwnd, DCX_WINDOW | DCX_CLIPSIBLINGS);
2180
2181
2182 /* Send WM_NCCALCSIZE message to get new client area */
2183 if( (winpos.flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE )
2184 {
2185 result = WINPOS_SendNCCalcSize( winpos.hwnd, TRUE, &newWindowRect,
2186 &wndPtr->rectWindow, &wndPtr->rectClient,
2187 &winpos, &newClientRect );
2188
2189 /* FIXME: WVR_ALIGNxxx */
2190
2191 if( newClientRect.left != wndPtr->rectClient.left ||
2192 newClientRect.top != wndPtr->rectClient.top )
2193 winpos.flags &= ~SWP_NOCLIENTMOVE;
2194
2195 if( (newClientRect.right - newClientRect.left !=
2196 wndPtr->rectClient.right - wndPtr->rectClient.left) ||
2197 (newClientRect.bottom - newClientRect.top !=
2198 wndPtr->rectClient.bottom - wndPtr->rectClient.top) )
2199 winpos.flags &= ~SWP_NOCLIENTSIZE;
2200 }
2201 else
2202 if( !(flags & SWP_NOMOVE) && (newClientRect.left != wndPtr->rectClient.left ||
2203 newClientRect.top != wndPtr->rectClient.top) )
2204 winpos.flags &= ~SWP_NOCLIENTMOVE;
2205
2206 /* Update active DCEs
2207 * TODO: Optimize conditions that trigger DCE update.
2208 */
2209
2210 if( (((winpos.flags & SWP_AGG_NOPOSCHANGE) != SWP_AGG_NOPOSCHANGE) &&
2211 wndPtr->dwStyle & WS_VISIBLE) ||
2212 (flags & (SWP_HIDEWINDOW | SWP_SHOWWINDOW)) )
2213 {
2214 RECT32 rect;
2215
2216 UnionRect32(&rect, &newWindowRect, &wndPtr->rectWindow);
2217 DCE_InvalidateDCE(wndPtr, &rect);
2218 }
2219
2220 /* change geometry */
2221
2222 oldWindowRect = wndPtr->rectWindow;
2223
2224 if (wndPtr->window)
2225 {
2226 RECT32 oldClientRect = wndPtr->rectClient;
2227
2228 tempInsertAfter = winpos.hwndInsertAfter;
2229
2230 winpos.hwndInsertAfter = hwndInsertAfter;
2231
2232 /* postpone geometry change */
2233
2234 if( !(flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW)) )
2235 {
2236 wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, TRUE);
2237 winpos.hwndInsertAfter = tempInsertAfter;
2238 }
2239 else uFlags |= SMC_SETXPOS;
2240
2241 wndPtr->rectWindow = newWindowRect;
2242 wndPtr->rectClient = newClientRect;
2243
2244 if( !(flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW)) )
2245 {
2246 if( (oldClientRect.left - oldWindowRect.left !=
2247 newClientRect.left - newWindowRect.left) ||
2248 (oldClientRect.top - oldWindowRect.top !=
2249 newClientRect.top - newWindowRect.top) ||
2250 (winpos.flags & SWP_NOCOPYBITS) )
2251 {
2252 /* if the client area moved as a result of WM_NCCALCSIZE returning
2253 * obscure WVR_ALIGNxxx flags then we simply redraw the whole thing
2254 *
2255 * TODO: use WINPOS_SizeMoveClean() if there is no SWP_NOCOPYBITS
2256 */
2257
2258 PAINT_RedrawWindow( wndPtr->hwndSelf, NULL, 0, RDW_INVALIDATE |
2259 RDW_ALLCHILDREN | RDW_FRAME | RDW_ERASE, 0 );
2260 }
2261 else
2262 if( winpos.flags & SWP_FRAMECHANGED )
2263 {
2264 WORD wErase = 0;
2265 RECT32 rect;
2266
2267 if( newClientRect.right > oldClientRect.right ) /* redraw exposed client area on the right */
2268 {
2269 rect.top = 0; rect.bottom = newClientRect.bottom - newClientRect.top;
2270 rect.left = oldClientRect.right - newClientRect.left;
2271 rect.right = newClientRect.right - newClientRect.left;
2272 wErase = 1;
2273 PAINT_RedrawWindow( wndPtr->hwndSelf, &rect, 0,
2274 RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW | RDW_ALLCHILDREN, 0 );
2275 }
2276 if( newClientRect.bottom > oldClientRect.bottom ) /* redraw exposed client area on the bottom */
2277 {
2278 rect.left = 0; rect.right = ((wErase)?oldClientRect.right:newClientRect.right) - newClientRect.left;
2279 rect.top = oldClientRect.bottom - newClientRect.top;
2280 rect.bottom = newClientRect.bottom - newClientRect.top;
2281 wErase = 1;
2282 PAINT_RedrawWindow( wndPtr->hwndSelf, &rect, 0,
2283 RDW_INVALIDATE | RDW_FRAME | RDW_ERASE | RDW_ERASENOW | RDW_ALLCHILDREN, 0 );
2284 }
2285 if( !wErase ) /* just update the nonclient area */
2286 wndPtr->flags |= WIN_NEEDS_NCPAINT;
2287 }
2288 }
2289 uFlags |= SMC_NOPARENTERASE; /* X windows do not have eraseable parents */
2290 }
2291 else /* not an X window */
2292 {
2293 RECT32 oldClientRect = wndPtr->rectClient;
2294
2295 wndPtr->rectWindow = newWindowRect;
2296 wndPtr->rectClient = newClientRect;
2297
2298 if( oldClientRect.bottom - oldClientRect.top ==
2299 newClientRect.bottom - newClientRect.top ) result &= ~WVR_VREDRAW;
2300
2301 if( oldClientRect.right - oldClientRect.left ==
2302 newClientRect.right - newClientRect.left ) result &= ~WVR_HREDRAW;
2303
2304 if( !(flags & (SWP_NOREDRAW | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) )
2305 {
2306 uFlags |= ((winpos.flags & SWP_NOCOPYBITS) ||
2307 (result >= WVR_HREDRAW && result < WVR_VALIDRECTS)) ? SMC_NOCOPY : 0;
2308 uFlags |= (winpos.flags & SWP_FRAMECHANGED) ? SMC_DRAWFRAME : 0;
2309
2310 if( (winpos.flags & SWP_AGG_NOGEOMETRYCHANGE) != SWP_AGG_NOGEOMETRYCHANGE )
2311 uFlags = WINPOS_SizeMoveClean(wndPtr, visRgn, &oldWindowRect,
2312 &oldClientRect, uFlags);
2313 else
2314 {
2315 /* adjust the frame and do not erase the parent */
2316
2317 if( winpos.flags & SWP_FRAMECHANGED ) wndPtr->flags |= WIN_NEEDS_NCPAINT;
2318 if( winpos.flags & SWP_NOZORDER ) uFlags |= SMC_NOPARENTERASE;
2319 }
2320 }
2321 DeleteObject32(visRgn);
2322 }
2323
2324 if (flags & SWP_SHOWWINDOW)
2325 {
2326 wndPtr->dwStyle |= WS_VISIBLE;
2327 if (wndPtr->window)
2328 {
2329 HWND32 focus, curr;
2330
2331 wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, uFlags & SMC_SETXPOS );
2332 if( uFlags & SMC_SETXPOS )
2333 {
2334 winpos.hwndInsertAfter = tempInsertAfter;
2335 }
2336
2337 if (wndPtr->flags & WIN_MANAGED) resync = TRUE;
2338
2339 /* If focus was set to an unmapped window, reset X focus now */
2340 focus = curr = GetFocus32();
2341 while (curr) {
2342 if (curr == hwnd) {
2343 SetFocus32( 0 );
2344 SetFocus32( focus );
2345 break;
2346 }
2347 curr = GetParent32(curr);
2348 }
2349 }
2350 else
2351 {
2352 if (!(flags & SWP_NOREDRAW))
2353 PAINT_RedrawWindow( winpos.hwnd, NULL, 0,
2354 RDW_INVALIDATE | RDW_ALLCHILDREN |
2355 RDW_FRAME | RDW_ERASENOW | RDW_ERASE, 0 );
2356 }
2357 }
2358 else if (flags & SWP_HIDEWINDOW)
2359 {
2360 wndPtr->dwStyle &= ~WS_VISIBLE;
2361
2362 if (wndPtr->window)
2363 {
2364 wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, uFlags & SMC_SETXPOS );
2365 if( uFlags & SMC_SETXPOS )
2366 {
2367 winpos.hwndInsertAfter = tempInsertAfter;
2368 }
2369 }
2370 else
2371 {
2372 if (!(flags & SWP_NOREDRAW))
2373 PAINT_RedrawWindow( wndPtr->parent->hwndSelf, &oldWindowRect,
2374 0, RDW_INVALIDATE | RDW_ALLCHILDREN |
2375 RDW_ERASE | RDW_ERASENOW, 0 );
2376 uFlags |= SMC_NOPARENTERASE;
2377 }
2378
2379 if ((winpos.hwnd == GetFocus32()) ||
2380 IsChild32( winpos.hwnd, GetFocus32()))
2381 {
2382 /* Revert focus to parent */
2383 SetFocus32( GetParent32(winpos.hwnd) );
2384 }
2385 if (hwnd == CARET_GetHwnd()) DestroyCaret32();
2386
2387 if (winpos.hwnd == hwndActive)
2388 WINPOS_ActivateOtherWindow( wndPtr );
2389 }
2390
2391 /* Activate the window */
2392
2393 if (!(flags & SWP_NOACTIVATE))
2394 WINPOS_ChangeActiveWindow( winpos.hwnd, FALSE );
2395
2396 /* Repaint the window */
2397
2398 if (wndPtr->window) EVENT_Synchronize(); /* Wait for all expose events */
2399
2400 if (!GetCapture32())
2401 EVENT_DummyMotionNotify(); /* Simulate a mouse event to set the cursor */
2402
2403 if (!(flags & SWP_DEFERERASE) && !(uFlags & SMC_NOPARENTERASE) )
2404 PAINT_RedrawWindow( wndPtr->parent->hwndSelf, NULL, 0, RDW_ALLCHILDREN | RDW_ERASENOW, 0 );
2405 else if( wndPtr->parent == WIN_GetDesktop() && wndPtr->parent->flags & WIN_NEEDS_ERASEBKGND )
2406 PAINT_RedrawWindow( wndPtr->parent->hwndSelf, NULL, 0, RDW_NOCHILDREN | RDW_ERASENOW, 0 );
2407
2408 /* And last, send the WM_WINDOWPOSCHANGED message */
2409
2410 TRACE(win,"\tstatus flags = %04x\n", winpos.flags & SWP_AGG_STATUSFLAGS);
2411
2412 if ( resync ||
2413 (((winpos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE) &&
2414 !(winpos.flags & SWP_NOSENDCHANGING)) )
2415 {
2416 SendMessage32A( winpos.hwnd, WM_WINDOWPOSCHANGED, 0, (LPARAM)&winpos );
2417 if (resync) EVENT_Synchronize ();
2418 }
2419
2420 return TRUE;
2421 }
2422
2423
2424 /***********************************************************************
2425 * BeginDeferWindowPos16 (USER.259)
2426 */
2427 HDWP16 WINAPI BeginDeferWindowPos16( INT16 count )
2428 {
2429 return BeginDeferWindowPos32( count );
2430 }
2431
2432
2433 /***********************************************************************
2434 * BeginDeferWindowPos32 (USER32.9)
2435 */
2436 HDWP32 WINAPI BeginDeferWindowPos32( INT32 count )
2437 {
2438 HDWP32 handle;
2439 DWP *pDWP;
2440
2441 if (count <= 0) return 0;
2442 handle = USER_HEAP_ALLOC( sizeof(DWP) + (count-1)*sizeof(WINDOWPOS32) );
2443 if (!handle) return 0;
2444 pDWP = (DWP *) USER_HEAP_LIN_ADDR( handle );
2445 pDWP->actualCount = 0;
2446 pDWP->suggestedCount = count;
2447 pDWP->valid = TRUE;
2448 pDWP->wMagic = DWP_MAGIC;
2449 pDWP->hwndParent = 0;
2450 return handle;
2451 }
2452
2453
2454 /***********************************************************************
2455 * DeferWindowPos16 (USER.260)
2456 */
2457 HDWP16 WINAPI DeferWindowPos16( HDWP16 hdwp, HWND16 hwnd, HWND16 hwndAfter,
2458 INT16 x, INT16 y, INT16 cx, INT16 cy,
2459 UINT16 flags )
2460 {
2461 return DeferWindowPos32( hdwp, hwnd, (INT32)(INT16)hwndAfter,
2462 x, y, cx, cy, flags );
2463 }
2464
2465
2466 /***********************************************************************
2467 * DeferWindowPos32 (USER32.128)
2468 */
2469 HDWP32 WINAPI DeferWindowPos32( HDWP32 hdwp, HWND32 hwnd, HWND32 hwndAfter,
2470 INT32 x, INT32 y, INT32 cx, INT32 cy,
2471 UINT32 flags )
2472 {
2473 DWP *pDWP;
2474 int i;
2475 HDWP32 newhdwp = hdwp;
2476 /* HWND32 parent; */
2477 WND *pWnd;
2478
2479 pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
2480 if (!pDWP) return 0;
2481 if (hwnd == GetDesktopWindow32()) return 0;
2482
2483 if (!(pWnd=WIN_FindWndPtr( hwnd ))) {
2484 USER_HEAP_FREE( hdwp );
2485 return 0;
2486 }
2487
2488 /* Numega Bounds Checker Demo dislikes the following code.
2489 In fact, I've not been able to find any "same parent" requirement in any docu
2490 [AM 980509]
2491 */
2492 #if 0
2493 /* All the windows of a DeferWindowPos() must have the same parent */
2494 parent = pWnd->parent->hwndSelf;
2495 if (pDWP->actualCount == 0) pDWP->hwndParent = parent;
2496 else if (parent != pDWP->hwndParent)
2497 {
2498 USER_HEAP_FREE( hdwp );
2499 return 0;
2500 }
2501 #endif
2502
2503 for (i = 0; i < pDWP->actualCount; i++)
2504 {
2505 if (pDWP->winPos[i].hwnd == hwnd)
2506 {
2507 /* Merge with the other changes */
2508 if (!(flags & SWP_NOZORDER))
2509 {
2510 pDWP->winPos[i].hwndInsertAfter = hwndAfter;
2511 }
2512 if (!(flags & SWP_NOMOVE))
2513 {
2514 pDWP->winPos[i].x = x;
2515 pDWP->winPos[i].y = y;
2516 }
2517 if (!(flags & SWP_NOSIZE))
2518 {
2519 pDWP->winPos[i].cx = cx;
2520 pDWP->winPos[i].cy = cy;
2521 }
2522 pDWP->winPos[i].flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
2523 SWP_NOZORDER | SWP_NOREDRAW |
2524 SWP_NOACTIVATE | SWP_NOCOPYBITS|
2525 SWP_NOOWNERZORDER);
2526 pDWP->winPos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
2527 SWP_FRAMECHANGED);
2528 return hdwp;
2529 }
2530 }
2531 if (pDWP->actualCount >= pDWP->suggestedCount)
2532 {
2533 newhdwp = USER_HEAP_REALLOC( hdwp,
2534 sizeof(DWP) + pDWP->suggestedCount*sizeof(WINDOWPOS32) );
2535 if (!newhdwp) return 0;
2536 pDWP = (DWP *) USER_HEAP_LIN_ADDR( newhdwp );
2537 pDWP->suggestedCount++;
2538 }
2539 pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
2540 pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
2541 pDWP->winPos[pDWP->actualCount].x = x;
2542 pDWP->winPos[pDWP->actualCount].y = y;
2543 pDWP->winPos[pDWP->actualCount].cx = cx;
2544 pDWP->winPos[pDWP->actualCount].cy = cy;
2545 pDWP->winPos[pDWP->actualCount].flags = flags;
2546 pDWP->actualCount++;
2547 return newhdwp;
2548 }
2549
2550
2551 /***********************************************************************
2552 * EndDeferWindowPos16 (USER.261)
2553 */
2554 BOOL16 WINAPI EndDeferWindowPos16( HDWP16 hdwp )
2555 {
2556 return EndDeferWindowPos32( hdwp );
2557 }
2558
2559
2560 /***********************************************************************
2561 * EndDeferWindowPos32 (USER32.173)
2562 */
2563 BOOL32 WINAPI EndDeferWindowPos32( HDWP32 hdwp )
2564 {
2565 DWP *pDWP;
2566 WINDOWPOS32 *winpos;
2567 BOOL32 res = TRUE;
2568 int i;
2569
2570 pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
2571 if (!pDWP) return FALSE;
2572 for (i = 0, winpos = pDWP->winPos; i < pDWP->actualCount; i++, winpos++)
2573 {
2574 if (!(res = SetWindowPos32( winpos->hwnd, winpos->hwndInsertAfter,
2575 winpos->x, winpos->y, winpos->cx,
2576 winpos->cy, winpos->flags ))) break;
2577 }
2578 USER_HEAP_FREE( hdwp );
2579 return res;
2580 }
2581
2582
2583 /***********************************************************************
2584 * TileChildWindows (USER.199)
2585 */
2586 void WINAPI TileChildWindows( HWND16 parent, WORD action )
2587 {
2588 FIXME(win, "(%04x, %d): stub\n", parent, action);
2589 }
2590
2591 /***********************************************************************
2592 * CascageChildWindows (USER.198)
2593 */
2594 void WINAPI CascadeChildWindows( HWND16 parent, WORD action )
2595 {
2596 FIXME(win, "(%04x, %d): stub\n", parent, action);
2597 }
2598 /***********************************************************************
2599 * GetProgmanWindow [USER32.289]
2600 */
2601 HRESULT WINAPI GetProgmanWindow ( )
2602 { FIXME(win,"stub\n");
2603 return 0;
2604 }
2605 /***********************************************************************
2606 * GetTaskmanWindow [USER32.304]
2607 */
2608 HRESULT WINAPI GetTaskmanWindow ( )
2609 { FIXME(win,"stub\n");
2610 return 0;
2611 }
2612 /***********************************************************************
2613 * SetProgmanWindow [USER32.522]
2614 */
2615 HRESULT WINAPI SetProgmanWindow ( DWORD x )
2616 { FIXME(win,"0x%08lx stub\n",x);
2617 return 0;
2618 }
2619 /***********************************************************************
2620 * SetShellWindowEx [USER32.531]
2621 */
2622 HRESULT WINAPI SetShellWindowEx ( DWORD x, DWORD y )
2623 { FIXME(win,"0x%08lx 0x%08lx stub\n",x,y);
2624 return 0;
2625 }
2626 /***********************************************************************
2627 * SetTaskmanWindow [USER32.537]
2628 */
2629 HRESULT WINAPI SetTaskmanWindow ( DWORD x )
2630 { FIXME(win,"0x%08lx stub\n",x);
2631 return 0;
2632 }
Maarten's multimedia branch