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