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