?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 961102
[wine/hacks.git] / windows / winpos.c
blob7d0dd30ba53b95b0cd72c2fc598d1c628ed8cb52
1 /*
2 * Window position related functions.
3 *
4 * Copyright 1993, 1994, 1995 Alexandre Julliard
5 * 1995,1996 Alex Korobka
6 */
7
8 #include <X11/Xlib.h>
9 #include <X11/Xutil.h>
10 #include <X11/Xatom.h>
11 #include "sysmetrics.h"
12 #include "heap.h"
13 #include "module.h"
14 #include "user.h"
15 #include "win.h"
16 #include "hook.h"
17 #include "message.h"
18 #include "queue.h"
19 #include "options.h"
20 #include "winpos.h"
21 #include "dce.h"
22 #include "nonclient.h"
23 #include "stddebug.h"
24 /* #define DEBUG_WIN */
25 #include "debug.h"
26
27 #define SWP_AGG_NOGEOMETRYCHANGE \
28 (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE)
29 #define SWP_AGG_NOPOSCHANGE \
30 (SWP_AGG_NOGEOMETRYCHANGE | SWP_NOZORDER)
31 #define SWP_AGG_STATUSFLAGS \
32 (SWP_AGG_NOPOSCHANGE | SWP_FRAMECHANGED | SWP_HIDEWINDOW | SWP_SHOWWINDOW)
33
34 #define SMC_NOCOPY 0x0001
35 #define SMC_NOPARENTERASE 0x0002
36 #define SMC_DRAWFRAME 0x0004
37 #define SMC_SETXPOS 0x0008
38
39 /* ----- external functions ----- */
40
41 extern void FOCUS_SwitchFocus( HWND , HWND );
42 extern HRGN32 DCE_GetVisRgn( HWND, WORD );
43 extern HWND CARET_GetHwnd();
44 extern BOOL DCE_InvalidateDCE(WND*, RECT16* );
45
46 /* ----- internal variables ----- */
47
48 static HWND hwndActive = 0; /* Currently active window */
49 static HWND hwndPrevActive = 0; /* Previously active window */
50
51 extern MESSAGEQUEUE* pActiveQueue;
52
53 /***********************************************************************
54 * WINPOS_CheckActive
55 */
56 void WINPOS_CheckActive( HWND32 hwnd )
57 {
58 if( hwnd == hwndPrevActive ) hwndPrevActive = 0;
59 if( hwnd == hwndActive )
60 {
61 hwndActive = 0;
62 dprintf_win(stddeb,"\tattempt to activate destroyed window!\n");
63 }
64 }
65
66 /***********************************************************************
67 * WINPOS_FindIconPos
68 *
69 * Find a suitable place for an iconic window.
70 * The new position is stored into wndPtr->ptIconPos.
71 */
72 void WINPOS_FindIconPos( HWND32 hwnd )
73 {
74 RECT16 rectParent;
75 short x, y, xspacing, yspacing;
76 WND * wndPtr = WIN_FindWndPtr( hwnd );
77
78 if (!wndPtr || !wndPtr->parent) return;
79 GetClientRect16( wndPtr->parent->hwndSelf, &rectParent );
80 if ((wndPtr->ptIconPos.x >= rectParent.left) &&
81 (wndPtr->ptIconPos.x + SYSMETRICS_CXICON < rectParent.right) &&
82 (wndPtr->ptIconPos.y >= rectParent.top) &&
83 (wndPtr->ptIconPos.y + SYSMETRICS_CYICON < rectParent.bottom))
84 return; /* The icon already has a suitable position */
85
86 xspacing = yspacing = 70; /* FIXME: This should come from WIN.INI */
87 y = rectParent.bottom;
88 for (;;)
89 {
90 for (x = rectParent.left; x<=rectParent.right-xspacing; x += xspacing)
91 {
92 /* Check if another icon already occupies this spot */
93 WND *childPtr = wndPtr->parent->child;
94 while (childPtr)
95 {
96 if ((childPtr->dwStyle & WS_MINIMIZE) && (childPtr != wndPtr))
97 {
98 if ((childPtr->rectWindow.left < x + xspacing) &&
99 (childPtr->rectWindow.right >= x) &&
100 (childPtr->rectWindow.top <= y) &&
101 (childPtr->rectWindow.bottom > y - yspacing))
102 break; /* There's a window in there */
103 }
104 childPtr = childPtr->next;
105 }
106 if (!childPtr)
107 {
108 /* No window was found, so it's OK for us */
109 wndPtr->ptIconPos.x = x + (xspacing - SYSMETRICS_CXICON) / 2;
110 wndPtr->ptIconPos.y = y - (yspacing + SYSMETRICS_CYICON) / 2;
111 return;
112 }
113 }
114 y -= yspacing;
115 }
116 }
117
118
119 /***********************************************************************
120 * ArrangeIconicWindows (USER.170)
121 */
122 UINT ArrangeIconicWindows( HWND parent )
123 {
124 RECT16 rectParent;
125 HWND hwndChild;
126 INT x, y, xspacing, yspacing;
127
128 GetClientRect16( parent, &rectParent );
129 x = rectParent.left;
130 y = rectParent.bottom;
131 xspacing = yspacing = 70; /* FIXME: This should come from WIN.INI */
132 hwndChild = GetWindow( parent, GW_CHILD );
133 while (hwndChild)
134 {
135 if (IsIconic( hwndChild ))
136 {
137 SetWindowPos( hwndChild, 0, x + (xspacing - SYSMETRICS_CXICON) / 2,
138 y - (yspacing + SYSMETRICS_CYICON) / 2, 0, 0,
139 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
140 if (x <= rectParent.right - xspacing) x += xspacing;
141 else
142 {
143 x = rectParent.left;
144 y -= yspacing;
145 }
146 }
147 hwndChild = GetWindow( hwndChild, GW_HWNDNEXT );
148 }
149 return yspacing;
150 }
151
152
153 /***********************************************************************
154 * GetWindowRect16 (USER.32)
155 */
156 void GetWindowRect16( HWND16 hwnd, LPRECT16 rect )
157 {
158 WND * wndPtr = WIN_FindWndPtr( hwnd );
159 if (!wndPtr) return;
160
161 *rect = wndPtr->rectWindow;
162 if (wndPtr->dwStyle & WS_CHILD)
163 MapWindowPoints16( wndPtr->parent->hwndSelf, 0, (POINT16 *)rect, 2 );
164 }
165
166
167 /***********************************************************************
168 * GetWindowRect32 (USER.32)
169 */
170 void GetWindowRect32( HWND32 hwnd, LPRECT32 rect )
171 {
172 WND * wndPtr = WIN_FindWndPtr( hwnd );
173 if (!wndPtr) return;
174
175 CONV_RECT16TO32( &wndPtr->rectWindow, rect );
176 if (wndPtr->dwStyle & WS_CHILD)
177 MapWindowPoints32( wndPtr->parent->hwndSelf, 0, (POINT32 *)rect, 2 );
178 }
179
180
181 /***********************************************************************
182 * GetClientRect16 (USER.33)
183 */
184 void GetClientRect16( HWND16 hwnd, LPRECT16 rect )
185 {
186 WND * wndPtr = WIN_FindWndPtr( hwnd );
187
188 rect->left = rect->top = rect->right = rect->bottom = 0;
189 if (wndPtr)
190 {
191 rect->right = wndPtr->rectClient.right - wndPtr->rectClient.left;
192 rect->bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
193 }
194 }
195
196
197 /***********************************************************************
198 * GetClientRect32 (USER32.219)
199 */
200 void GetClientRect32( HWND32 hwnd, LPRECT32 rect )
201 {
202 WND * wndPtr = WIN_FindWndPtr( hwnd );
203
204 rect->left = rect->top = rect->right = rect->bottom = 0;
205 if (wndPtr)
206 {
207 rect->right = wndPtr->rectClient.right - wndPtr->rectClient.left;
208 rect->bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
209 }
210 }
211
212
213 /*******************************************************************
214 * ClientToScreen16 (USER.28)
215 */
216 BOOL16 ClientToScreen16( HWND16 hwnd, LPPOINT16 lppnt )
217 {
218 MapWindowPoints16( hwnd, 0, lppnt, 1 );
219 return TRUE;
220 }
221
222
223 /*******************************************************************
224 * ClientToScreen32 (USER32.51)
225 */
226 BOOL32 ClientToScreen32( HWND32 hwnd, LPPOINT32 lppnt )
227 {
228 MapWindowPoints32( hwnd, 0, lppnt, 1 );
229 return TRUE;
230 }
231
232
233 /*******************************************************************
234 * ScreenToClient16 (USER.29)
235 */
236 void ScreenToClient16( HWND16 hwnd, LPPOINT16 lppnt )
237 {
238 MapWindowPoints16( 0, hwnd, lppnt, 1 );
239 }
240
241
242 /*******************************************************************
243 * ScreenToClient32 (USER32.446)
244 */
245 void ScreenToClient32( HWND32 hwnd, LPPOINT32 lppnt )
246 {
247 MapWindowPoints32( 0, hwnd, lppnt, 1 );
248 }
249
250
251 /***********************************************************************
252 * WINPOS_WindowFromPoint
253 *
254 * Find the window and hittest for a given point.
255 */
256 INT16 WINPOS_WindowFromPoint( POINT16 pt, WND **ppWnd )
257 {
258 WND *wndPtr;
259 INT16 hittest = HTERROR;
260 INT16 x, y;
261
262 *ppWnd = NULL;
263 x = pt.x;
264 y = pt.y;
265 wndPtr = WIN_GetDesktop()->child;
266 for (;;)
267 {
268 while (wndPtr)
269 {
270 /* If point is in window, and window is visible, and it */
271 /* is enabled (or it's a top-level window), then explore */
272 /* its children. Otherwise, go to the next window. */
273
274 if ((wndPtr->dwStyle & WS_VISIBLE) &&
275 (!(wndPtr->dwStyle & WS_DISABLED) ||
276 ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) != WS_CHILD)) &&
277 (x >= wndPtr->rectWindow.left) &&
278 (x < wndPtr->rectWindow.right) &&
279 (y >= wndPtr->rectWindow.top) &&
280 (y < wndPtr->rectWindow.bottom))
281 {
282 *ppWnd = wndPtr; /* Got a suitable window */
283
284 /* If window is minimized or disabled, return at once */
285 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
286 if (wndPtr->dwStyle & WS_DISABLED) return HTERROR;
287
288 /* If point is not in client area, ignore the children */
289 if ((x < wndPtr->rectClient.left) ||
290 (x >= wndPtr->rectClient.right) ||
291 (y < wndPtr->rectClient.top) ||
292 (y >= wndPtr->rectClient.bottom)) break;
293
294 x -= wndPtr->rectClient.left;
295 y -= wndPtr->rectClient.top;
296 wndPtr = wndPtr->child;
297 }
298 else wndPtr = wndPtr->next;
299 }
300
301 /* If nothing found, return the desktop window */
302 if (!*ppWnd)
303 {
304 *ppWnd = WIN_GetDesktop();
305 return HTCLIENT;
306 }
307
308 /* Send the WM_NCHITTEST message (only if to the same task) */
309 if ((*ppWnd)->hmemTaskQ != GetTaskQueue(0)) return HTCLIENT;
310 hittest = (INT)SendMessage16( (*ppWnd)->hwndSelf, WM_NCHITTEST, 0,
311 MAKELONG( pt.x, pt.y ) );
312 if (hittest != HTTRANSPARENT) return hittest; /* Found the window */
313
314 /* If no children found in last search, make point relative to parent*/
315 if (!wndPtr)
316 {
317 x += (*ppWnd)->rectClient.left;
318 y += (*ppWnd)->rectClient.top;
319 }
320
321 /* Restart the search from the next sibling */
322 wndPtr = (*ppWnd)->next;
323 *ppWnd = (*ppWnd)->parent;
324 }
325 }
326
327
328 /*******************************************************************
329 * WindowFromPoint16 (USER.30)
330 */
331 HWND16 WindowFromPoint16( POINT16 pt )
332 {
333 WND *pWnd;
334 WINPOS_WindowFromPoint( pt, &pWnd );
335 return pWnd->hwndSelf;
336 }
337
338
339 /*******************************************************************
340 * WindowFromPoint32 (USER32.581)
341 */
342 HWND32 WindowFromPoint32( POINT32 pt )
343 {
344 WND *pWnd;
345 POINT16 pt16;
346 CONV_POINT32TO16( &pt, &pt16 );
347 WINPOS_WindowFromPoint( pt16, &pWnd );
348 return (HWND32)pWnd->hwndSelf;
349 }
350
351
352 /*******************************************************************
353 * ChildWindowFromPoint16 (USER.191)
354 */
355 HWND16 ChildWindowFromPoint16( HWND16 hwndParent, POINT16 pt )
356 {
357 /* pt is in the client coordinates */
358
359 WND* wnd = WIN_FindWndPtr(hwndParent);
360 RECT16 rect;
361
362 if( !wnd ) return 0;
363
364 /* get client rect fast */
365 rect.top = rect.left = 0;
366 rect.right = wnd->rectClient.right - wnd->rectClient.left;
367 rect.bottom = wnd->rectClient.bottom - wnd->rectClient.top;
368
369 if (!PtInRect16( &rect, pt )) return 0;
370
371 wnd = wnd->child;
372 while ( wnd )
373 {
374 if (PtInRect16( &wnd->rectWindow, pt )) return wnd->hwndSelf;
375 wnd = wnd->next;
376 }
377 return hwndParent;
378 }
379
380
381 /*******************************************************************
382 * ChildWindowFromPoint32 (USER32.)
383 */
384 HWND32 ChildWindowFromPoint32( HWND32 hwndParent, POINT32 pt )
385 {
386 POINT16 pt16;
387 CONV_POINT32TO16( &pt, &pt16 );
388 return (HWND32)ChildWindowFromPoint16( hwndParent, pt16 );
389 }
390
391
392 /*******************************************************************
393 * WINPOS_GetWinOffset
394 *
395 * Calculate the offset between the origin of the two windows. Used
396 * to implement MapWindowPoints.
397 */
398 static void WINPOS_GetWinOffset( HWND32 hwndFrom, HWND32 hwndTo,
399 POINT32 *offset )
400 {
401 WND * wndPtr;
402
403 offset->x = offset->y = 0;
404 if (hwndFrom == hwndTo ) return;
405
406 /* Translate source window origin to screen coords */
407 if (hwndFrom)
408 {
409 if (!(wndPtr = WIN_FindWndPtr( hwndFrom )))
410 {
411 fprintf(stderr,"MapWindowPoints: bad hwndFrom = %04x\n",hwndFrom);
412 return;
413 }
414 while (wndPtr->parent)
415 {
416 offset->x += wndPtr->rectClient.left;
417 offset->y += wndPtr->rectClient.top;
418 wndPtr = wndPtr->parent;
419 }
420 }
421
422 /* Translate origin to destination window coords */
423 if (hwndTo)
424 {
425 if (!(wndPtr = WIN_FindWndPtr( hwndTo )))
426 {
427 fprintf(stderr,"MapWindowPoints: bad hwndTo = %04x\n", hwndTo );
428 return;
429 }
430 while (wndPtr->parent)
431 {
432 offset->x -= wndPtr->rectClient.left;
433 offset->y -= wndPtr->rectClient.top;
434 wndPtr = wndPtr->parent;
435 }
436 }
437 }
438
439
440 /*******************************************************************
441 * MapWindowPoints16 (USER.258)
442 */
443 void MapWindowPoints16( HWND16 hwndFrom, HWND16 hwndTo,
444 LPPOINT16 lppt, UINT16 count )
445 {
446 POINT32 offset;
447
448 WINPOS_GetWinOffset( hwndFrom, hwndTo, &offset );
449 while (count--)
450 {
451 lppt->x += offset.x;
452 lppt->y += offset.y;
453 lppt++;
454 }
455 }
456
457
458 /*******************************************************************
459 * MapWindowPoints32 (USER32.385)
460 */
461 void MapWindowPoints32( HWND32 hwndFrom, HWND32 hwndTo,
462 LPPOINT32 lppt, UINT32 count )
463 {
464 POINT32 offset;
465
466 WINPOS_GetWinOffset( hwndFrom, hwndTo, &offset );
467 while (count--)
468 {
469 lppt->x += offset.x;
470 lppt->y += offset.y;
471 lppt++;
472 }
473 }
474
475
476 /***********************************************************************
477 * IsIconic (USER.31)
478 */
479 BOOL IsIconic(HWND hWnd)
480 {
481 WND * wndPtr = WIN_FindWndPtr(hWnd);
482 if (wndPtr == NULL) return FALSE;
483 return (wndPtr->dwStyle & WS_MINIMIZE) != 0;
484 }
485
486
487 /***********************************************************************
488 * IsZoomed (USER.272)
489 */
490 BOOL IsZoomed(HWND hWnd)
491 {
492 WND * wndPtr = WIN_FindWndPtr(hWnd);
493 if (wndPtr == NULL) return FALSE;
494 return (wndPtr->dwStyle & WS_MAXIMIZE) != 0;
495 }
496
497
498 /*******************************************************************
499 * GetActiveWindow (USER.60)
500 */
501 HWND GetActiveWindow(void)
502 {
503 return hwndActive;
504 }
505
506
507 /*******************************************************************
508 * WINPOS_IsGoodEnough
509 */
510 static BOOL32 WINPOS_IsGoodEnough(WND* pWnd)
511 {
512 return (pWnd) ? ((!(pWnd->dwStyle & WS_DISABLED) &&
513 pWnd->dwStyle & WS_VISIBLE ) ? TRUE : FALSE) : FALSE;
514 }
515
516
517 /*******************************************************************
518 * SetActiveWindow (USER.59)
519 */
520 HWND SetActiveWindow( HWND hwnd )
521 {
522 HWND prev = hwndActive;
523 WND *wndPtr = WIN_FindWndPtr( hwnd );
524
525 if ( !WINPOS_IsGoodEnough(wndPtr) ) return 0;
526
527 WINPOS_SetActiveWindow( hwnd, 0, 0 );
528 return prev;
529 }
530
531
532 /***********************************************************************
533 * BringWindowToTop (USER.45)
534 */
535 BOOL BringWindowToTop( HWND hwnd )
536 {
537 return SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE );
538 }
539
540
541 /***********************************************************************
542 * MoveWindow (USER.56)
543 */
544 BOOL MoveWindow( HWND hwnd, short x, short y, short cx, short cy, BOOL repaint)
545 {
546 int flags = SWP_NOZORDER | SWP_NOACTIVATE;
547 if (!repaint) flags |= SWP_NOREDRAW;
548 dprintf_win(stddeb, "MoveWindow: %04x %d,%d %dx%d %d\n",
549 hwnd, x, y, cx, cy, repaint );
550 return SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
551 }
552
553
554 /***********************************************************************
555 * ShowWindow (USER.42)
556 */
557 BOOL ShowWindow( HWND hwnd, int cmd )
558 {
559 WND * wndPtr = WIN_FindWndPtr( hwnd );
560 BOOL32 wasVisible, showFlag;
561 POINT16 maxSize;
562 int swpflags = 0;
563 short x = 0, y = 0, cx = 0, cy = 0;
564
565 if (!wndPtr) return FALSE;
566
567 dprintf_win(stddeb,"ShowWindow: hwnd=%04x, cmd=%d\n", hwnd, cmd);
568
569 wasVisible = (wndPtr->dwStyle & WS_VISIBLE) != 0;
570
571 switch(cmd)
572 {
573 case SW_HIDE:
574 if (!wasVisible) return FALSE;
575 swpflags |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE |
576 SWP_NOACTIVATE | SWP_NOZORDER;
577 break;
578
579 case SW_SHOWMINNOACTIVE:
580 swpflags |= SWP_NOACTIVATE | SWP_NOZORDER;
581 /* fall through */
582 case SW_SHOWMINIMIZED:
583 swpflags |= SWP_SHOWWINDOW;
584 /* fall through */
585 case SW_MINIMIZE:
586 swpflags |= SWP_FRAMECHANGED;
587 if (!(wndPtr->dwStyle & WS_MINIMIZE))
588 {
589 if( HOOK_CallHooks( WH_CBT, HCBT_MINMAX, hwnd, cmd) )
590 return 0;
591
592 if (wndPtr->dwStyle & WS_MAXIMIZE)
593 {
594 wndPtr->flags |= WIN_RESTORE_MAX;
595 wndPtr->dwStyle &= ~WS_MAXIMIZE;
596 }
597 else
598 {
599 wndPtr->flags &= ~WIN_RESTORE_MAX;
600 wndPtr->rectNormal = wndPtr->rectWindow;
601 }
602 wndPtr->dwStyle |= WS_MINIMIZE;
603 WINPOS_FindIconPos( hwnd );
604 x = wndPtr->ptIconPos.x;
605 y = wndPtr->ptIconPos.y;
606 cx = SYSMETRICS_CXICON;
607 cy = SYSMETRICS_CYICON;
608 swpflags |= SWP_NOCOPYBITS;
609 }
610 else swpflags |= SWP_NOSIZE | SWP_NOMOVE;
611 break;
612
613 case SW_SHOWMAXIMIZED: /* same as SW_MAXIMIZE: */
614 swpflags |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
615 if (!(wndPtr->dwStyle & WS_MAXIMIZE))
616 {
617 if( HOOK_CallHooks( WH_CBT, HCBT_MINMAX, hwnd, cmd) )
618 return 0;
619
620 /* Store the current position and find the maximized size */
621 if (!(wndPtr->dwStyle & WS_MINIMIZE))
622 wndPtr->rectNormal = wndPtr->rectWindow;
623
624 NC_GetMinMaxInfo( wndPtr, &maxSize,
625 &wndPtr->ptMaxPos, NULL, NULL );
626 x = wndPtr->ptMaxPos.x;
627 y = wndPtr->ptMaxPos.y;
628
629 if( wndPtr->dwStyle & WS_MINIMIZE )
630 if( !SendMessage16( hwnd, WM_QUERYOPEN, 0, 0L ) )
631 {
632 swpflags |= SWP_NOSIZE | SWP_NOMOVE;
633 break;
634 }
635 else swpflags |= SWP_NOCOPYBITS;
636
637 cx = maxSize.x;
638 cy = maxSize.y;
639 wndPtr->dwStyle &= ~WS_MINIMIZE;
640 wndPtr->dwStyle |= WS_MAXIMIZE;
641 }
642 else swpflags |= SWP_NOSIZE | SWP_NOMOVE;
643 break;
644
645 case SW_SHOWNA:
646 swpflags |= SWP_NOACTIVATE | SWP_NOZORDER;
647 /* fall through */
648 case SW_SHOW:
649 swpflags |= SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
650 break;
651
652 case SW_SHOWNOACTIVATE:
653 swpflags |= SWP_NOZORDER;
654 if (GetActiveWindow()) swpflags |= SWP_NOACTIVATE;
655 /* fall through */
656 case SW_SHOWNORMAL: /* same as SW_NORMAL: */
657 case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
658 case SW_RESTORE:
659 swpflags |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
660
661 if (wndPtr->dwStyle & WS_MINIMIZE)
662 {
663 if( HOOK_CallHooks( WH_CBT, HCBT_MINMAX, hwnd, cmd) )
664 return 0;
665
666 if( !SendMessage16( hwnd, WM_QUERYOPEN, 0, 0L) )
667 {
668 swpflags |= SWP_NOSIZE | SWP_NOMOVE;
669 break;
670 }
671 wndPtr->ptIconPos.x = wndPtr->rectWindow.left;
672 wndPtr->ptIconPos.y = wndPtr->rectWindow.top;
673 wndPtr->dwStyle &= ~WS_MINIMIZE;
674 if (wndPtr->flags & WIN_RESTORE_MAX)
675 {
676 /* Restore to maximized position */
677 NC_GetMinMaxInfo( wndPtr, &maxSize, &wndPtr->ptMaxPos,
678 NULL, NULL );
679 x = wndPtr->ptMaxPos.x;
680 y = wndPtr->ptMaxPos.y;
681 cx = maxSize.x;
682 cy = maxSize.y;
683 wndPtr->dwStyle |= WS_MAXIMIZE;
684 }
685 else /* Restore to normal position */
686 {
687 x = wndPtr->rectNormal.left;
688 y = wndPtr->rectNormal.top;
689 cx = wndPtr->rectNormal.right - wndPtr->rectNormal.left;
690 cy = wndPtr->rectNormal.bottom - wndPtr->rectNormal.top;
691 }
692 swpflags |= SWP_NOCOPYBITS;
693 }
694 else if (wndPtr->dwStyle & WS_MAXIMIZE)
695 {
696 if( HOOK_CallHooks( WH_CBT, HCBT_MINMAX, hwnd, cmd) )
697 return 0;
698
699 wndPtr->ptMaxPos.x = wndPtr->rectWindow.left;
700 wndPtr->ptMaxPos.y = wndPtr->rectWindow.top;
701 wndPtr->dwStyle &= ~WS_MAXIMIZE;
702 x = wndPtr->rectNormal.left;
703 y = wndPtr->rectNormal.top;
704 cx = wndPtr->rectNormal.right - wndPtr->rectNormal.left;
705 cy = wndPtr->rectNormal.bottom - wndPtr->rectNormal.top;
706 }
707 else swpflags |= SWP_NOSIZE | SWP_NOMOVE;
708 break;
709 }
710
711 showFlag = (cmd != SW_HIDE);
712 if (showFlag != wasVisible)
713 {
714 SendMessage16( hwnd, WM_SHOWWINDOW, showFlag, 0 );
715 if (!IsWindow( hwnd )) return wasVisible;
716 }
717
718 if ((wndPtr->dwStyle & WS_CHILD) &&
719 !IsWindowVisible( wndPtr->parent->hwndSelf ) &&
720 (swpflags & SWP_NOSIZE) && (swpflags & SWP_NOMOVE))
721 {
722 /* Don't call SetWindowPos() on invisible child windows */
723 if (cmd == SW_HIDE) wndPtr->dwStyle &= ~WS_VISIBLE;
724 else wndPtr->dwStyle |= WS_VISIBLE;
725 }
726 else
727 {
728 /* We can't activate a child window */
729 if (wndPtr->dwStyle & WS_CHILD)
730 swpflags |= SWP_NOACTIVATE | SWP_NOZORDER;
731 SetWindowPos( hwnd, HWND_TOP, x, y, cx, cy, swpflags );
732 if (!IsWindow( hwnd )) return wasVisible;
733 }
734
735 if (wndPtr->flags & WIN_NEED_SIZE)
736 {
737 /* should happen only in CreateWindowEx() */
738 int wParam = SIZE_RESTORED;
739
740 wndPtr->flags &= ~WIN_NEED_SIZE;
741 if (wndPtr->dwStyle & WS_MAXIMIZE) wParam = SIZE_MAXIMIZED;
742 else if (wndPtr->dwStyle & WS_MINIMIZE) wParam = SIZE_MINIMIZED;
743 SendMessage16( hwnd, WM_SIZE, wParam,
744 MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left,
745 wndPtr->rectClient.bottom-wndPtr->rectClient.top));
746 SendMessage16( hwnd, WM_MOVE, 0,
747 MAKELONG(wndPtr->rectClient.left, wndPtr->rectClient.top) );
748 }
749
750 return wasVisible;
751 }
752
753
754 /***********************************************************************
755 * GetInternalWindowPos16 (USER.460)
756 */
757 UINT16 GetInternalWindowPos16( HWND16 hwnd, LPRECT16 rectWnd, LPPOINT16 ptIcon)
758 {
759 WINDOWPLACEMENT16 wndpl;
760 if (!GetWindowPlacement16( hwnd, &wndpl )) return 0;
761 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
762 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
763 return wndpl.showCmd;
764 }
765
766
767 /***********************************************************************
768 * GetInternalWindowPos32 (USER32.244)
769 */
770 UINT32 GetInternalWindowPos32( HWND32 hwnd, LPRECT32 rectWnd, LPPOINT32 ptIcon)
771 {
772 WINDOWPLACEMENT32 wndpl;
773 if (!GetWindowPlacement32( hwnd, &wndpl )) return 0;
774 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
775 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
776 return wndpl.showCmd;
777 }
778
779
780 /***********************************************************************
781 * SetInternalWindowPos16 (USER.461)
782 */
783 void SetInternalWindowPos16( HWND16 hwnd, UINT16 showCmd,
784 LPRECT16 rect, LPPOINT16 pt )
785 {
786 WINDOWPLACEMENT16 wndpl;
787 WND *wndPtr = WIN_FindWndPtr( hwnd );
788
789 wndpl.length = sizeof(wndpl);
790 wndpl.flags = (pt != NULL) ? WPF_SETMINPOSITION : 0;
791 wndpl.showCmd = showCmd;
792 if (pt) wndpl.ptMinPosition = *pt;
793 wndpl.rcNormalPosition = (rect != NULL) ? *rect : wndPtr->rectNormal;
794 wndpl.ptMaxPosition = wndPtr->ptMaxPos;
795 SetWindowPlacement16( hwnd, &wndpl );
796 }
797
798
799 /***********************************************************************
800 * SetInternalWindowPos32 (USER32.482)
801 */
802 void SetInternalWindowPos32( HWND32 hwnd, UINT32 showCmd,
803 LPRECT32 rect, LPPOINT32 pt )
804 {
805 WINDOWPLACEMENT32 wndpl;
806 WND *wndPtr = WIN_FindWndPtr( hwnd );
807
808 wndpl.length = sizeof(wndpl);
809 wndpl.flags = (pt != NULL) ? WPF_SETMINPOSITION : 0;
810 wndpl.showCmd = showCmd;
811 if (pt) wndpl.ptMinPosition = *pt;
812 if (rect) wndpl.rcNormalPosition = *rect;
813 else CONV_RECT16TO32( &wndPtr->rectNormal, &wndpl.rcNormalPosition );
814 CONV_POINT16TO32( &wndPtr->ptMaxPos, &wndpl.ptMaxPosition );
815 SetWindowPlacement32( hwnd, &wndpl );
816 }
817
818
819 /***********************************************************************
820 * GetWindowPlacement16 (USER.370)
821 */
822 BOOL16 GetWindowPlacement16( HWND16 hwnd, WINDOWPLACEMENT16 *wndpl )
823 {
824 WND *wndPtr = WIN_FindWndPtr( hwnd );
825 if (!wndPtr) return FALSE;
826
827 wndpl->length = sizeof(*wndpl);
828 wndpl->flags = 0;
829 wndpl->showCmd = IsZoomed(hwnd) ? SW_SHOWMAXIMIZED :
830 (IsIconic(hwnd) ? SW_SHOWMINIMIZED : SW_SHOWNORMAL);
831 wndpl->ptMinPosition = wndPtr->ptIconPos;
832 wndpl->ptMaxPosition = wndPtr->ptMaxPos;
833 wndpl->rcNormalPosition = wndPtr->rectNormal;
834 return TRUE;
835 }
836
837
838 /***********************************************************************
839 * GetWindowPlacement32 (USER32.306)
840 */
841 BOOL32 GetWindowPlacement32( HWND32 hwnd, WINDOWPLACEMENT32 *wndpl )
842 {
843 WND *wndPtr = WIN_FindWndPtr( hwnd );
844 if (!wndPtr) return FALSE;
845
846 wndpl->length = sizeof(*wndpl);
847 wndpl->flags = 0;
848 wndpl->showCmd = IsZoomed(hwnd) ? SW_SHOWMAXIMIZED :
849 (IsIconic(hwnd) ? SW_SHOWMINIMIZED : SW_SHOWNORMAL);
850 CONV_POINT16TO32( &wndPtr->ptIconPos, &wndpl->ptMinPosition );
851 CONV_POINT16TO32( &wndPtr->ptMaxPos, &wndpl->ptMaxPosition );
852 CONV_RECT16TO32( &wndPtr->rectNormal, &wndpl->rcNormalPosition );
853 return TRUE;
854 }
855
856
857 /***********************************************************************
858 * SetWindowPlacement16 (USER.371)
859 */
860 BOOL16 SetWindowPlacement16( HWND16 hwnd, const WINDOWPLACEMENT16 *wndpl )
861 {
862 WND *wndPtr = WIN_FindWndPtr( hwnd );
863 if (!wndPtr) return FALSE;
864
865 if (wndpl->flags & WPF_SETMINPOSITION)
866 wndPtr->ptIconPos = wndpl->ptMinPosition;
867 if ((wndpl->flags & WPF_RESTORETOMAXIMIZED) &&
868 (wndpl->showCmd == SW_SHOWMINIMIZED)) wndPtr->flags |= WIN_RESTORE_MAX;
869 wndPtr->ptMaxPos = wndpl->ptMaxPosition;
870 wndPtr->rectNormal = wndpl->rcNormalPosition;
871 ShowWindow( hwnd, wndpl->showCmd );
872 return TRUE;
873 }
874
875
876 /***********************************************************************
877 * SetWindowPlacement32 (USER32.518)
878 */
879 BOOL32 SetWindowPlacement32( HWND32 hwnd, const WINDOWPLACEMENT32 *wndpl )
880 {
881 WND *wndPtr = WIN_FindWndPtr( hwnd );
882 if (!wndPtr) return FALSE;
883
884 if (wndpl->flags & WPF_SETMINPOSITION)
885 CONV_POINT32TO16( &wndpl->ptMinPosition, &wndPtr->ptIconPos );
886 if ((wndpl->flags & WPF_RESTORETOMAXIMIZED) &&
887 (wndpl->showCmd == SW_SHOWMINIMIZED)) wndPtr->flags |= WIN_RESTORE_MAX;
888 CONV_POINT32TO16( &wndpl->ptMaxPosition, &wndPtr->ptMaxPos );
889 CONV_RECT32TO16( &wndpl->rcNormalPosition, &wndPtr->rectNormal );
890 ShowWindow( hwnd, wndpl->showCmd );
891 return TRUE;
892 }
893
894
895 /***********************************************************************
896 * WINPOS_ForceXWindowRaise
897 *
898 * Raise a window on top of the X stacking order, while preserving
899 * the correct Windows Z order.
900 */
901 static void WINPOS_ForceXWindowRaise( WND* pWnd )
902 {
903 XWindowChanges winChanges;
904 WND *wndPrev;
905
906 /* Raise all windows up to pWnd according to their Z order.
907 * (it would be easier with sibling-related Below but it doesn't
908 * work very well with SGI mwm for instance)
909 */
910 winChanges.stack_mode = Above;
911 while (pWnd)
912 {
913 if (pWnd->window) XReconfigureWMWindow( display, pWnd->window, 0,
914 CWStackMode, &winChanges );
915 wndPrev = WIN_GetDesktop()->child;
916 if (wndPrev == pWnd) break;
917 while (wndPrev && (wndPrev->next != pWnd)) wndPrev = wndPrev->next;
918 pWnd = wndPrev;
919 }
920 }
921
922
923 /*******************************************************************
924 * WINPOS_SetActiveWindow
925 *
926 * back-end to SetActiveWindow
927 */
928 BOOL32 WINPOS_SetActiveWindow( HWND32 hWnd, BOOL32 fMouse, BOOL32 fChangeFocus)
929 {
930 WND *wndPtr = WIN_FindWndPtr(hWnd);
931 WND *wndTemp = WIN_FindWndPtr(hwndActive);
932 CBTACTIVATESTRUCT16 *cbtStruct;
933 WORD wIconized=0;
934 HQUEUE16 hOldActiveQueue = (pActiveQueue)?pActiveQueue->self:0;
935 HQUEUE16 hNewActiveQueue;
936
937 /* paranoid checks */
938 if( hWnd == GetDesktopWindow32() || hWnd == hwndActive )
939 return 0;
940
941 /* if (wndPtr && (GetTaskQueue(0) != wndPtr->hmemTaskQ))
942 return 0;
943 */
944
945 if( wndTemp )
946 wIconized = HIWORD(wndTemp->dwStyle & WS_MINIMIZE);
947 else
948 dprintf_win(stddeb,"WINPOS_ActivateWindow: no current active window.\n");
949
950 /* call CBT hook chain */
951 if ((cbtStruct = SEGPTR_NEW(CBTACTIVATESTRUCT16)))
952 {
953 LRESULT wRet;
954 cbtStruct->fMouse = fMouse;
955 cbtStruct->hWndActive = hwndActive;
956 wRet = HOOK_CallHooks( WH_CBT, HCBT_ACTIVATE, (WPARAM16)hWnd,
957 (LPARAM)SEGPTR_GET(cbtStruct) );
958 SEGPTR_FREE(cbtStruct);
959 if (wRet) return wRet;
960 }
961
962 /* set prev active wnd to current active wnd and send notification */
963 if ((hwndPrevActive = hwndActive) && IsWindow(hwndPrevActive))
964 {
965 if (!SendMessage16( hwndPrevActive, WM_NCACTIVATE, FALSE, 0 ))
966 {
967 if (GetSysModalWindow16() != hWnd) return 0;
968 /* disregard refusal if hWnd is sysmodal */
969 }
970
971 SendMessage32A( hwndPrevActive, WM_ACTIVATE,
972 MAKEWPARAM( WA_INACTIVE, wIconized ),
973 (LPARAM)hWnd );
974
975 /* check if something happened during message processing */
976 if( hwndPrevActive != hwndActive ) return 0;
977 }
978
979 /* set active wnd */
980 hwndActive = hWnd;
981
982 /* send palette messages */
983 if (hWnd && SendMessage16( hWnd, WM_QUERYNEWPALETTE, 0, 0L))
984 SendMessage16((HWND16)-1, WM_PALETTEISCHANGING, (WPARAM16)hWnd, 0L );
985
986 /* if prev wnd is minimized redraw icon title
987 if( hwndPrevActive )
988 {
989 wndTemp = WIN_FindWndPtr( WIN_GetTopParent( hwndPrevActive ) );
990 if(wndTemp)
991 if(wndTemp->dwStyle & WS_MINIMIZE)
992 RedrawIconTitle(hwndPrevActive);
993 }
994 */
995
996 /* managed windows will get ConfigureNotify event */
997 if (wndPtr && !(wndPtr->dwStyle & WS_CHILD) && !(wndPtr->flags & WIN_MANAGED))
998 {
999 /* check Z-order and bring hWnd to the top */
1000 for (wndTemp = WIN_GetDesktop()->child; wndTemp; wndTemp = wndTemp->next)
1001 if (wndTemp->dwStyle & WS_VISIBLE) break;
1002
1003 if( wndTemp != wndPtr )
1004 SetWindowPos(hWnd, HWND_TOP, 0,0,0,0,
1005 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
1006 if( !IsWindow(hWnd) ) return 0;
1007 }
1008
1009 hNewActiveQueue = wndPtr ? wndPtr->hmemTaskQ : 0;
1010
1011 /* send WM_ACTIVATEAPP if necessary */
1012 if (hOldActiveQueue != hNewActiveQueue)
1013 {
1014 WND **list, **ppWnd;
1015
1016 if ((list = WIN_BuildWinArray( WIN_GetDesktop() )))
1017 {
1018 for (ppWnd = list; *ppWnd; ppWnd++)
1019 {
1020 if (!IsWindow( (*ppWnd)->hwndSelf )) continue;
1021
1022 if ((*ppWnd)->hmemTaskQ == hOldActiveQueue)
1023 SendMessage16( (*ppWnd)->hwndSelf, WM_ACTIVATEAPP,
1024 0, QUEUE_GetQueueTask(hNewActiveQueue) );
1025 }
1026 HeapFree( SystemHeap, 0, list );
1027 }
1028
1029 pActiveQueue = (hNewActiveQueue)
1030 ? (MESSAGEQUEUE*) GlobalLock16(hNewActiveQueue) : NULL;
1031
1032 if ((list = WIN_BuildWinArray( WIN_GetDesktop() )))
1033 {
1034 for (ppWnd = list; *ppWnd; ppWnd++)
1035 {
1036 if (!IsWindow( (*ppWnd)->hwndSelf )) continue;
1037
1038 if ((*ppWnd)->hmemTaskQ == hNewActiveQueue)
1039 SendMessage16( (*ppWnd)->hwndSelf, WM_ACTIVATEAPP,
1040 1, QUEUE_GetQueueTask( hOldActiveQueue ) );
1041 }
1042 HeapFree( SystemHeap, 0, list );
1043 }
1044 if (!IsWindow(hWnd)) return 0;
1045 }
1046
1047 if (hWnd)
1048 {
1049 /* walk up to the first unowned window */
1050 wndTemp = wndPtr;
1051 while (wndTemp->owner) wndTemp = wndTemp->owner;
1052 /* and set last active owned popup */
1053 wndTemp->hwndLastActive = hWnd;
1054
1055 wIconized = HIWORD(wndTemp->dwStyle & WS_MINIMIZE);
1056 SendMessage16( hWnd, WM_NCACTIVATE, TRUE, 0 );
1057 SendMessage32A( hWnd, WM_ACTIVATE,
1058 MAKEWPARAM( (fMouse) ? WA_CLICKACTIVE : WA_ACTIVE, wIconized),
1059 (LPARAM)hwndPrevActive );
1060
1061 if( !IsWindow(hWnd) ) return 0;
1062 }
1063
1064 /* change focus if possible */
1065 if( fChangeFocus && GetFocus32() )
1066 if( WIN_GetTopParent(GetFocus32()) != hwndActive )
1067 FOCUS_SwitchFocus( GetFocus32(),
1068 (wndPtr->dwStyle & WS_MINIMIZE)? 0: hwndActive);
1069
1070 if( !hwndPrevActive && wndPtr &&
1071 wndPtr->window && !(wndPtr->flags & WIN_MANAGED) )
1072 WINPOS_ForceXWindowRaise(wndPtr);
1073
1074 /* if active wnd is minimized redraw icon title
1075 if( hwndActive )
1076 {
1077 wndPtr = WIN_FindWndPtr(hwndActive);
1078 if(wndPtr->dwStyle & WS_MINIMIZE)
1079 RedrawIconTitle(hwndActive);
1080 }
1081 */
1082 return (hWnd == hwndActive);
1083 }
1084
1085 /*******************************************************************
1086 * WINPOS_ActivateOtherWindow
1087 *
1088 * DestroyWindow() helper. pWnd must be a top-level window.
1089 */
1090 BOOL32 WINPOS_ActivateOtherWindow(WND* pWnd)
1091 {
1092 BOOL32 bRet = 0;
1093 WND* pWndTo = NULL;
1094
1095 if( pWnd->hwndSelf == hwndPrevActive )
1096 hwndPrevActive = 0;
1097
1098 if( hwndActive != pWnd->hwndSelf &&
1099 ( hwndActive || QUEUE_IsDoomedQueue(pWnd->hmemTaskQ)) )
1100 return 0;
1101
1102 if( pWnd->dwStyle & WS_POPUP &&
1103 WINPOS_IsGoodEnough( pWnd->owner ) ) pWndTo = pWnd->owner;
1104 else
1105 {
1106 WND* pWndPtr = pWnd;
1107
1108 pWndTo = WIN_FindWndPtr(hwndPrevActive);
1109
1110 while( !WINPOS_IsGoodEnough(pWndTo) )
1111 {
1112 /* by now owned windows should've been taken care of */
1113
1114 pWndTo = pWndPtr->next;
1115 pWndPtr = pWndTo;
1116 if( !pWndTo ) return 0;
1117 }
1118 }
1119
1120 bRet = WINPOS_SetActiveWindow( pWndTo->hwndSelf, FALSE, TRUE );
1121
1122 /* switch desktop queue to current active */
1123 if( pWndTo->parent == WIN_GetDesktop())
1124 WIN_GetDesktop()->hmemTaskQ = pWndTo->hmemTaskQ;
1125
1126 hwndPrevActive = 0;
1127 return bRet;
1128 }
1129
1130 /*******************************************************************
1131 * WINPOS_ChangeActiveWindow
1132 *
1133 */
1134 BOOL32 WINPOS_ChangeActiveWindow( HWND32 hWnd, BOOL32 mouseMsg )
1135 {
1136 WND *wndPtr = WIN_FindWndPtr(hWnd);
1137
1138 if (!hWnd) return WINPOS_SetActiveWindow( 0, mouseMsg, TRUE );
1139
1140 if( !wndPtr ) return FALSE;
1141
1142 /* child windows get WM_CHILDACTIVATE message */
1143 if( (wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) == WS_CHILD )
1144 return SendMessage16(hWnd, WM_CHILDACTIVATE, 0, 0L);
1145
1146 /* owned popups imply owner activation - not sure */
1147 if ((wndPtr->dwStyle & WS_POPUP) && wndPtr->owner &&
1148 !(wndPtr->owner->dwStyle & WS_DISABLED ))
1149 {
1150 if (!(wndPtr = wndPtr->owner)) return FALSE;
1151 hWnd = wndPtr->hwndSelf;
1152 }
1153
1154 if( hWnd == hwndActive ) return FALSE;
1155
1156 if( !WINPOS_SetActiveWindow(hWnd ,mouseMsg ,TRUE) )
1157 return FALSE;
1158
1159 /* switch desktop queue to current active */
1160 if( wndPtr->parent == WIN_GetDesktop())
1161 WIN_GetDesktop()->hmemTaskQ = wndPtr->hmemTaskQ;
1162
1163 return TRUE;
1164 }
1165
1166
1167 /***********************************************************************
1168 * WINPOS_SendNCCalcSize
1169 *
1170 * Send a WM_NCCALCSIZE message to a window.
1171 * All parameters are read-only except newClientRect.
1172 * oldWindowRect, oldClientRect and winpos must be non-NULL only
1173 * when calcValidRect is TRUE.
1174 */
1175 LONG WINPOS_SendNCCalcSize( HWND32 hwnd, BOOL32 calcValidRect,
1176 RECT16 *newWindowRect, RECT16 *oldWindowRect,
1177 RECT16 *oldClientRect, SEGPTR winpos,
1178 RECT16 *newClientRect )
1179 {
1180 NCCALCSIZE_PARAMS16 *params;
1181 LONG result;
1182
1183 if (!(params = SEGPTR_NEW(NCCALCSIZE_PARAMS16))) return 0;
1184 params->rgrc[0] = *newWindowRect;
1185 if (calcValidRect)
1186 {
1187 params->rgrc[1] = *oldWindowRect;
1188 params->rgrc[2] = *oldClientRect;
1189 params->lppos = winpos;
1190 }
1191 result = SendMessage16( hwnd, WM_NCCALCSIZE, calcValidRect,
1192 (LPARAM)SEGPTR_GET( params ) );
1193 dprintf_win( stddeb, "WINPOS_SendNCCalcSize: %d,%d-%d,%d\n",
1194 params->rgrc[0].left, params->rgrc[0].top,
1195 params->rgrc[0].right, params->rgrc[0].bottom );
1196 *newClientRect = params->rgrc[0];
1197 SEGPTR_FREE(params);
1198 return result;
1199 }
1200
1201
1202 /***********************************************************************
1203 * WINPOS_HandleWindowPosChanging16
1204 *
1205 * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
1206 */
1207 LONG WINPOS_HandleWindowPosChanging16( WND *wndPtr, WINDOWPOS16 *winpos )
1208 {
1209 POINT16 maxSize;
1210 if (winpos->flags & SWP_NOSIZE) return 0;
1211 if ((wndPtr->dwStyle & WS_THICKFRAME) ||
1212 ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) == 0))
1213 {
1214 NC_GetMinMaxInfo( wndPtr, &maxSize, NULL, NULL, NULL );
1215 winpos->cx = MIN( winpos->cx, maxSize.x );
1216 winpos->cy = MIN( winpos->cy, maxSize.y );
1217 }
1218 return 0;
1219 }
1220
1221
1222 /***********************************************************************
1223 * WINPOS_HandleWindowPosChanging32
1224 *
1225 * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
1226 */
1227 LONG WINPOS_HandleWindowPosChanging32( WND *wndPtr, WINDOWPOS32 *winpos )
1228 {
1229 POINT16 maxSize;
1230 if (winpos->flags & SWP_NOSIZE) return 0;
1231 if ((wndPtr->dwStyle & WS_THICKFRAME) ||
1232 ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) == 0))
1233 {
1234 NC_GetMinMaxInfo( wndPtr, &maxSize, NULL, NULL, NULL );
1235 winpos->cx = MIN( winpos->cx, maxSize.x );
1236 winpos->cy = MIN( winpos->cy, maxSize.y );
1237 }
1238 return 0;
1239 }
1240
1241
1242 /***********************************************************************
1243 * WINPOS_MoveWindowZOrder
1244 *
1245 * Move a window in Z order, invalidating everything that needs it.
1246 * Only necessary for windows without associated X window.
1247 */
1248 static void WINPOS_MoveWindowZOrder( HWND hwnd, HWND hwndAfter )
1249 {
1250 BOOL movingUp;
1251 WND *pWndAfter, *pWndCur, *wndPtr = WIN_FindWndPtr( hwnd );
1252
1253 /* We have two possible cases:
1254 * - The window is moving up: we have to invalidate all areas
1255 * of the window that were covered by other windows
1256 * - The window is moving down: we have to invalidate areas
1257 * of other windows covered by this one.
1258 */
1259
1260 if (hwndAfter == HWND_TOP)
1261 {
1262 movingUp = TRUE;
1263 }
1264 else if (hwndAfter == HWND_BOTTOM)
1265 {
1266 if (!wndPtr->next) return; /* Already at the bottom */
1267 movingUp = FALSE;
1268 }
1269 else
1270 {
1271 if (!(pWndAfter = WIN_FindWndPtr( hwndAfter ))) return;
1272 if (wndPtr->next == pWndAfter) return; /* Already placed right */
1273
1274 /* Determine which window we encounter first in Z-order */
1275 pWndCur = wndPtr->parent->child;
1276 while ((pWndCur != wndPtr) && (pWndCur != pWndAfter))
1277 pWndCur = pWndCur->next;
1278 movingUp = (pWndCur == pWndAfter);
1279 }
1280
1281 if (movingUp)
1282 {
1283 WND *pWndPrevAfter = wndPtr->next;
1284 WIN_UnlinkWindow( hwnd );
1285 WIN_LinkWindow( hwnd, hwndAfter );
1286 pWndCur = wndPtr->next;
1287 while (pWndCur != pWndPrevAfter)
1288 {
1289 RECT32 rect = { pWndCur->rectWindow.left,
1290 pWndCur->rectWindow.top,
1291 pWndCur->rectWindow.right,
1292 pWndCur->rectWindow.bottom };
1293 OffsetRect32( &rect, -wndPtr->rectClient.left,
1294 -wndPtr->rectClient.top );
1295 PAINT_RedrawWindow( hwnd, &rect, 0, RDW_INVALIDATE | RDW_ALLCHILDREN |
1296 RDW_FRAME | RDW_ERASE, 0 );
1297 pWndCur = pWndCur->next;
1298 }
1299 }
1300 else /* Moving down */
1301 {
1302 pWndCur = wndPtr->next;
1303 WIN_UnlinkWindow( hwnd );
1304 WIN_LinkWindow( hwnd, hwndAfter );
1305 while (pWndCur != wndPtr)
1306 {
1307 RECT32 rect = { pWndCur->rectWindow.left,
1308 pWndCur->rectWindow.top,
1309 pWndCur->rectWindow.right,
1310 pWndCur->rectWindow.bottom };
1311 OffsetRect32( &rect, -pWndCur->rectClient.left,
1312 -pWndCur->rectClient.top );
1313 PAINT_RedrawWindow( pWndCur->hwndSelf, &rect, 0, RDW_INVALIDATE |
1314 RDW_ALLCHILDREN | RDW_FRAME | RDW_ERASE, 0 );
1315 pWndCur = pWndCur->next;
1316 }
1317 }
1318 }
1319
1320 /***********************************************************************
1321 * WINPOS_ReorderOwnedPopups
1322 *
1323 * fix Z order taking into account owned popups -
1324 * basically we need to maintain them above owner window
1325 */
1326 HWND WINPOS_ReorderOwnedPopups(HWND hwndInsertAfter, WND* wndPtr, WORD flags)
1327 {
1328 WND* w = WIN_GetDesktop()->child;
1329
1330 if( wndPtr->dwStyle & WS_POPUP && wndPtr->owner )
1331 {
1332 /* implement "local z-order" between the top and owner window */
1333
1334 HWND hwndLocalPrev = HWND_TOP;
1335
1336 if( hwndInsertAfter != HWND_TOP )
1337 {
1338 while( w != wndPtr->owner )
1339 {
1340 hwndLocalPrev = w->hwndSelf;
1341 if( hwndLocalPrev == hwndInsertAfter ) break;
1342 w = w->next;
1343 }
1344 hwndInsertAfter = hwndLocalPrev;
1345 }
1346
1347 }
1348 else if( wndPtr->dwStyle & WS_CHILD ) return hwndInsertAfter;
1349
1350 w = WIN_GetDesktop()->child;
1351 while( w )
1352 {
1353 if( w == wndPtr ) break;
1354
1355 if( w->dwStyle & WS_POPUP && w->owner == wndPtr )
1356 {
1357 SetWindowPos(w->hwndSelf, hwndInsertAfter, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE |
1358 SWP_NOACTIVATE | SWP_NOSENDCHANGING | SWP_DEFERERASE);
1359 hwndInsertAfter = w->hwndSelf;
1360 }
1361 w = w->next;
1362 }
1363
1364 return hwndInsertAfter;
1365 }
1366
1367 /***********************************************************************
1368 * WINPOS_SizeMoveClean
1369 *
1370 * Make window look nice without excessive repainting
1371 *
1372 * the pain:
1373 *
1374 * visible regions are in window coordinates
1375 * update regions are in window client coordinates
1376 * client and window rectangles are in parent client coordinates
1377 */
1378 static UINT WINPOS_SizeMoveClean(WND* Wnd, HRGN32 oldVisRgn, LPRECT16 lpOldWndRect, LPRECT16 lpOldClientRect, UINT uFlags )
1379 {
1380 HRGN32 newVisRgn = DCE_GetVisRgn(Wnd->hwndSelf,DCX_WINDOW | DCX_CLIPSIBLINGS);
1381 HRGN32 dirtyRgn = CreateRectRgn32(0,0,0,0);
1382 int other, my;
1383
1384 dprintf_win(stddeb,"cleaning up...new wnd=(%i %i-%i %i) old wnd=(%i %i-%i %i)\n\
1385 \t\tnew client=(%i %i-%i %i) old client=(%i %i-%i %i)\n",
1386 Wnd->rectWindow.left, Wnd->rectWindow.top, Wnd->rectWindow.right, Wnd->rectWindow.bottom,
1387 lpOldWndRect->left, lpOldWndRect->top, lpOldWndRect->right, lpOldWndRect->bottom,
1388 Wnd->rectClient.left,Wnd->rectClient.top,Wnd->rectClient.right,Wnd->rectClient.bottom,
1389 lpOldClientRect->left,lpOldClientRect->top,lpOldClientRect->right,lpOldClientRect->bottom);
1390
1391 if( (lpOldWndRect->right - lpOldWndRect->left) != (Wnd->rectWindow.right - Wnd->rectWindow.left) ||
1392 (lpOldWndRect->bottom - lpOldWndRect->top) != (Wnd->rectWindow.bottom - Wnd->rectWindow.top) )
1393 uFlags |= SMC_DRAWFRAME;
1394
1395 CombineRgn32( dirtyRgn, newVisRgn, 0, RGN_COPY);
1396
1397 if( !(uFlags & SMC_NOCOPY) )
1398 CombineRgn32( newVisRgn, newVisRgn, oldVisRgn, RGN_AND );
1399
1400 /* map regions to the parent client area */
1401
1402 OffsetRgn32( dirtyRgn, Wnd->rectWindow.left, Wnd->rectWindow.top );
1403 OffsetRgn32( oldVisRgn, lpOldWndRect->left, lpOldWndRect->top );
1404
1405 /* compute invalidated region outside Wnd - (in client coordinates of the parent window) */
1406
1407 other = CombineRgn32(dirtyRgn, oldVisRgn, dirtyRgn, RGN_DIFF);
1408
1409 /* map visible region to the Wnd client area */
1410
1411 OffsetRgn32( newVisRgn, Wnd->rectWindow.left - Wnd->rectClient.left,
1412 Wnd->rectWindow.top - Wnd->rectClient.top );
1413
1414 /* substract previously invalidated region from the Wnd visible region */
1415
1416 my = (Wnd->hrgnUpdate > 1) ? CombineRgn32( newVisRgn, newVisRgn,
1417 Wnd->hrgnUpdate, RGN_DIFF)
1418 : COMPLEXREGION;
1419
1420 if( uFlags & SMC_NOCOPY ) /* invalidate Wnd visible region */
1421 {
1422 if (my != NULLREGION) PAINT_RedrawWindow( Wnd->hwndSelf, NULL, newVisRgn, RDW_INVALIDATE |
1423 RDW_FRAME | RDW_ALLCHILDREN | RDW_ERASE, RDW_C_USEHRGN );
1424 }
1425 else /* bitblt old client area */
1426 {
1427 HDC32 hDC;
1428 int update;
1429 HRGN32 updateRgn;
1430 int xfrom,yfrom,xto,yto,width,height;
1431
1432 if( uFlags & SMC_DRAWFRAME )
1433 {
1434 /* copy only client area, frame will be redrawn anyway */
1435
1436 xfrom = lpOldClientRect->left; yfrom = lpOldClientRect->top;
1437 xto = Wnd->rectClient.left; yto = Wnd->rectClient.top;
1438 width = lpOldClientRect->right - xfrom; height = lpOldClientRect->bottom - yfrom;
1439 updateRgn = CreateRectRgn32( 0, 0, width, height );
1440 CombineRgn32( newVisRgn, newVisRgn, updateRgn, RGN_AND );
1441 SetRectRgn( updateRgn, 0, 0, Wnd->rectClient.right - xto, Wnd->rectClient.bottom - yto );
1442 }
1443 else
1444 {
1445 xfrom = lpOldWndRect->left; yfrom = lpOldWndRect->top;
1446 xto = Wnd->rectWindow.left; yto = Wnd->rectWindow.top;
1447 width = lpOldWndRect->right - xfrom; height = lpOldWndRect->bottom - yfrom;
1448 updateRgn = CreateRectRgn32( xto - Wnd->rectClient.left,
1449 yto - Wnd->rectClient.top,
1450 Wnd->rectWindow.right - Wnd->rectClient.left,
1451 Wnd->rectWindow.bottom - Wnd->rectClient.top );
1452 }
1453
1454 CombineRgn32( newVisRgn, newVisRgn, updateRgn, RGN_AND );
1455
1456 /* substract new visRgn from target rect to get a region that won't be copied */
1457
1458 update = CombineRgn32( updateRgn, updateRgn, newVisRgn, RGN_DIFF );
1459
1460 /* Blt valid bits using parent window DC */
1461
1462 if( my != NULLREGION && (xfrom != xto || yfrom != yto) )
1463 {
1464
1465 /* compute clipping region in parent client coordinates */
1466
1467 OffsetRgn32( newVisRgn, Wnd->rectClient.left, Wnd->rectClient.top );
1468 CombineRgn32( oldVisRgn, oldVisRgn, newVisRgn, RGN_OR );
1469
1470 hDC = GetDCEx32( Wnd->parent->hwndSelf, oldVisRgn,
1471 DCX_KEEPCLIPRGN | DCX_INTERSECTRGN |
1472 DCX_CACHE | DCX_CLIPSIBLINGS);
1473
1474 BitBlt( hDC, xto, yto, width, height, hDC, xfrom, yfrom, SRCCOPY );
1475
1476 ReleaseDC32( Wnd->parent->hwndSelf, hDC);
1477 }
1478
1479 if( update != NULLREGION )
1480 PAINT_RedrawWindow( Wnd->hwndSelf, NULL, updateRgn, RDW_INVALIDATE |
1481 RDW_FRAME | RDW_ALLCHILDREN | RDW_ERASE, RDW_C_USEHRGN );
1482 else if( uFlags & SMC_DRAWFRAME ) Wnd->flags |= WIN_NEEDS_NCPAINT;
1483 DeleteObject32( updateRgn );
1484 }
1485
1486 /* erase uncovered areas */
1487
1488 if( !(uFlags & SMC_NOPARENTERASE) && (other != NULLREGION ) )
1489 PAINT_RedrawWindow( Wnd->parent->hwndSelf, NULL, dirtyRgn,
1490 RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE, RDW_C_USEHRGN );
1491 DeleteObject32(dirtyRgn);
1492 DeleteObject32(newVisRgn);
1493 return uFlags;
1494 }
1495
1496
1497 /***********************************************************************
1498 * WINPOS_SetXWindowPos
1499 *
1500 * SetWindowPos() for an X window. Used by the real SetWindowPos().
1501 */
1502 static void WINPOS_SetXWindowPos( WINDOWPOS16 *winpos )
1503 {
1504 XWindowChanges winChanges;
1505 int changeMask = 0;
1506 WND *wndPtr = WIN_FindWndPtr( winpos->hwnd );
1507
1508 if (!(winpos->flags & SWP_NOSIZE))
1509 {
1510 winChanges.width = winpos->cx;
1511 winChanges.height = winpos->cy;
1512 changeMask |= CWWidth | CWHeight;
1513
1514 /* Tweak dialog window size hints */
1515
1516 if ((wndPtr->flags & WIN_MANAGED) &&
1517 (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME))
1518 {
1519 XSizeHints *size_hints = XAllocSizeHints();
1520
1521 if (size_hints)
1522 {
1523 long supplied_return;
1524
1525 XGetWMSizeHints( display, wndPtr->window, size_hints,
1526 &supplied_return, XA_WM_NORMAL_HINTS);
1527 size_hints->min_width = size_hints->max_width = winpos->cx;
1528 size_hints->min_height = size_hints->max_height = winpos->cy;
1529 XSetWMSizeHints( display, wndPtr->window, size_hints,
1530 XA_WM_NORMAL_HINTS );
1531 XFree(size_hints);
1532 }
1533 }
1534 }
1535 if (!(winpos->flags & SWP_NOMOVE))
1536 {
1537 winChanges.x = winpos->x;
1538 winChanges.y = winpos->y;
1539 changeMask |= CWX | CWY;
1540 }
1541 if (!(winpos->flags & SWP_NOZORDER))
1542 {
1543 winChanges.stack_mode = Below;
1544 changeMask |= CWStackMode;
1545
1546 if (winpos->hwndInsertAfter == HWND_TOP) winChanges.stack_mode = Above;
1547 else if (winpos->hwndInsertAfter != HWND_BOTTOM)
1548 {
1549 WND* insertPtr = WIN_FindWndPtr( winpos->hwndInsertAfter );
1550 Window stack[2];
1551
1552 stack[0] = insertPtr->window;
1553 stack[1] = wndPtr->window;
1554
1555 /* for stupid window managers (i.e. all of them) */
1556
1557 XRestackWindows(display, stack, 2);
1558 changeMask &= ~CWStackMode;
1559 }
1560 }
1561 if (!changeMask) return;
1562
1563 XReconfigureWMWindow( display, wndPtr->window, 0, changeMask, &winChanges );
1564 }
1565
1566
1567 /***********************************************************************
1568 * SetWindowPos (USER.232)
1569 */
1570 BOOL SetWindowPos( HWND hwnd, HWND hwndInsertAfter, INT x, INT y,
1571 INT cx, INT cy, WORD flags )
1572 {
1573 WINDOWPOS16 *winpos;
1574 WND * wndPtr;
1575 RECT16 newWindowRect, newClientRect, oldWindowRect;
1576 HRGN32 visRgn = 0;
1577 HWND tempInsertAfter= 0;
1578 int result = 0;
1579 UINT uFlags = 0;
1580
1581 dprintf_win(stddeb,"SetWindowPos: hwnd %04x, (%i,%i)-(%i,%i) flags %08x\n",
1582 hwnd, x, y, x+cx, y+cy, flags);
1583 /* Check window handle */
1584
1585 if (hwnd == GetDesktopWindow32()) return FALSE;
1586 if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
1587
1588 if (wndPtr->dwStyle & WS_VISIBLE) flags &= ~SWP_SHOWWINDOW;
1589 else
1590 {
1591 uFlags |= SMC_NOPARENTERASE;
1592 flags &= ~SWP_HIDEWINDOW;
1593 if (!(flags & SWP_SHOWWINDOW)) flags |= SWP_NOREDRAW;
1594 }
1595
1596 /* Check for windows that may not be resized
1597 FIXME: this should be done only for Windows 3.0 programs
1598 if (flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW ) )
1599 flags |= SWP_NOSIZE | SWP_NOMOVE;
1600 */
1601 /* Check dimensions */
1602
1603 if (cx <= 0) cx = 1;
1604 if (cy <= 0) cy = 1;
1605
1606 /* Check flags */
1607
1608 if (hwnd == hwndActive) flags |= SWP_NOACTIVATE; /* Already active */
1609 if ((wndPtr->rectWindow.right - wndPtr->rectWindow.left == cx) &&
1610 (wndPtr->rectWindow.bottom - wndPtr->rectWindow.top == cy))
1611 flags |= SWP_NOSIZE; /* Already the right size */
1612 if ((wndPtr->rectWindow.left == x) && (wndPtr->rectWindow.top == y))
1613 flags |= SWP_NOMOVE; /* Already the right position */
1614
1615 /* Check hwndInsertAfter */
1616
1617 if (!(flags & (SWP_NOZORDER | SWP_NOACTIVATE)))
1618 {
1619 /* Ignore TOPMOST flags when activating a window */
1620 /* _and_ moving it in Z order. */
1621 if ((hwndInsertAfter == HWND_TOPMOST) ||
1622 (hwndInsertAfter == HWND_NOTOPMOST))
1623 hwndInsertAfter = HWND_TOP;
1624 }
1625 /* TOPMOST not supported yet */
1626 if ((hwndInsertAfter == HWND_TOPMOST) ||
1627 (hwndInsertAfter == HWND_NOTOPMOST)) hwndInsertAfter = HWND_TOP;
1628
1629 /* hwndInsertAfter must be a sibling of the window */
1630 if ((hwndInsertAfter != HWND_TOP) && (hwndInsertAfter != HWND_BOTTOM))
1631 {
1632 WND* wnd = WIN_FindWndPtr(hwndInsertAfter);
1633 if( wnd->parent != wndPtr->parent ) return FALSE;
1634 if( wnd->next == wndPtr ) flags |= SWP_NOZORDER;
1635 }
1636 else
1637 if (hwndInsertAfter == HWND_TOP)
1638 flags |= ( wndPtr->parent->child == wndPtr)? SWP_NOZORDER: 0;
1639 else /* HWND_BOTTOM */
1640 flags |= ( wndPtr->next )? 0: SWP_NOZORDER;
1641
1642 /* Fill the WINDOWPOS structure */
1643
1644 if (!(winpos = SEGPTR_NEW(WINDOWPOS16))) return FALSE;
1645 winpos->hwnd = hwnd;
1646 winpos->hwndInsertAfter = hwndInsertAfter;
1647 winpos->x = x;
1648 winpos->y = y;
1649 winpos->cx = cx;
1650 winpos->cy = cy;
1651 winpos->flags = flags;
1652
1653 /* Send WM_WINDOWPOSCHANGING message */
1654
1655 if (!(flags & SWP_NOSENDCHANGING))
1656 SendMessage16( hwnd, WM_WINDOWPOSCHANGING, 0,
1657 (LPARAM)SEGPTR_GET(winpos) );
1658
1659 /* Calculate new position and size */
1660
1661 newWindowRect = wndPtr->rectWindow;
1662 newClientRect = (wndPtr->dwStyle & WS_MINIMIZE) ? wndPtr->rectWindow
1663 : wndPtr->rectClient;
1664
1665 if (!(winpos->flags & SWP_NOSIZE))
1666 {
1667 newWindowRect.right = newWindowRect.left + winpos->cx;
1668 newWindowRect.bottom = newWindowRect.top + winpos->cy;
1669 }
1670 if (!(winpos->flags & SWP_NOMOVE))
1671 {
1672 newWindowRect.left = winpos->x;
1673 newWindowRect.top = winpos->y;
1674 newWindowRect.right += winpos->x - wndPtr->rectWindow.left;
1675 newWindowRect.bottom += winpos->y - wndPtr->rectWindow.top;
1676
1677 OffsetRect16( &newClientRect, winpos->x - wndPtr->rectWindow.left,
1678 winpos->y - wndPtr->rectWindow.top );
1679 }
1680
1681 winpos->flags |= SWP_NOCLIENTMOVE | SWP_NOCLIENTSIZE;
1682
1683 /* Reposition window in Z order */
1684
1685 if (!(winpos->flags & SWP_NOZORDER))
1686 {
1687 /* reorder owned popups if hwnd is top-level window
1688 */
1689 if( wndPtr->parent == WIN_GetDesktop() )
1690 hwndInsertAfter = WINPOS_ReorderOwnedPopups( hwndInsertAfter,
1691 wndPtr, flags );
1692
1693 if (wndPtr->window)
1694 {
1695 WIN_UnlinkWindow( winpos->hwnd );
1696 WIN_LinkWindow( winpos->hwnd, hwndInsertAfter );
1697 }
1698 else WINPOS_MoveWindowZOrder( winpos->hwnd, hwndInsertAfter );
1699 }
1700
1701 if ( !wndPtr->window && !(flags & SWP_NOREDRAW) &&
1702 (!(flags & SWP_NOMOVE) || !(flags & SWP_NOSIZE) || (flags & SWP_FRAMECHANGED)) )
1703 visRgn = DCE_GetVisRgn(hwnd, DCX_WINDOW | DCX_CLIPSIBLINGS);
1704
1705
1706 /* Send WM_NCCALCSIZE message to get new client area */
1707 if( (flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE )
1708 {
1709 result = WINPOS_SendNCCalcSize( winpos->hwnd, TRUE, &newWindowRect,
1710 &wndPtr->rectWindow, &wndPtr->rectClient,
1711 SEGPTR_GET(winpos), &newClientRect );
1712
1713 /* FIXME: WVR_ALIGNxxx */
1714
1715 if( newClientRect.left != wndPtr->rectClient.left ||
1716 newClientRect.top != wndPtr->rectClient.top )
1717 winpos->flags &= ~SWP_NOCLIENTMOVE;
1718
1719 if( (newClientRect.right - newClientRect.left !=
1720 wndPtr->rectClient.right - wndPtr->rectClient.left) ||
1721 (newClientRect.bottom - newClientRect.top !=
1722 wndPtr->rectClient.bottom - wndPtr->rectClient.top) )
1723 winpos->flags &= ~SWP_NOCLIENTSIZE;
1724 }
1725 else
1726 if( !(flags & SWP_NOMOVE) && (newClientRect.left != wndPtr->rectClient.left ||
1727 newClientRect.top != wndPtr->rectClient.top) )
1728 winpos->flags &= ~SWP_NOCLIENTMOVE;
1729
1730 /* Update active DCEs */
1731
1732 if( !(flags & SWP_NOZORDER) || (flags & SWP_HIDEWINDOW) || (flags & SWP_SHOWWINDOW)
1733 || (memcmp(&newWindowRect,&wndPtr->rectWindow,sizeof(RECT16))
1734 && wndPtr->dwStyle & WS_VISIBLE ) )
1735 {
1736 RECT16 rect;
1737
1738 UnionRect16(&rect,&newWindowRect,&wndPtr->rectWindow);
1739 DCE_InvalidateDCE(wndPtr->parent, &rect);
1740 }
1741
1742 /* change geometry */
1743
1744 oldWindowRect = wndPtr->rectWindow;
1745
1746 if (wndPtr->window)
1747 {
1748 RECT16 oldClientRect = wndPtr->rectClient;
1749
1750 tempInsertAfter = winpos->hwndInsertAfter;
1751
1752 winpos->hwndInsertAfter = hwndInsertAfter;
1753
1754 /* postpone geometry change */
1755
1756 if( !(flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW)) )
1757 {
1758 WINPOS_SetXWindowPos( winpos );
1759 winpos->hwndInsertAfter = tempInsertAfter;
1760 }
1761 else uFlags |= SMC_SETXPOS;
1762
1763 wndPtr->rectWindow = newWindowRect;
1764 wndPtr->rectClient = newClientRect;
1765
1766 if( !(flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW)) )
1767 if( (oldClientRect.left - oldWindowRect.left !=
1768 newClientRect.left - newWindowRect.left) ||
1769 (oldClientRect.top - oldWindowRect.top !=
1770 newClientRect.top - newWindowRect.top) || winpos->flags & SWP_NOCOPYBITS )
1771
1772 PAINT_RedrawWindow( wndPtr->hwndSelf, NULL, 0, RDW_INVALIDATE |
1773 RDW_ALLCHILDREN | RDW_FRAME | RDW_ERASE, 0 );
1774 else
1775 if( winpos->flags & SWP_FRAMECHANGED )
1776 {
1777 WORD wErase = 0;
1778 RECT32 rect;
1779
1780 if( oldClientRect.right > newClientRect.right )
1781 {
1782 rect.left = newClientRect.right; rect.top = newClientRect.top;
1783 rect.right = oldClientRect.right; rect.bottom = newClientRect.bottom;
1784 wErase = 1;
1785 PAINT_RedrawWindow( wndPtr->hwndSelf, &rect, 0,
1786 RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN, 0 );
1787 }
1788 if( oldClientRect.bottom > newClientRect.bottom )
1789 {
1790 rect.left = newClientRect.left; rect.top = newClientRect.bottom;
1791 rect.right = (wErase)?oldClientRect.right:newClientRect.right;
1792 rect.bottom = oldClientRect.bottom;
1793 wErase = 1;
1794 PAINT_RedrawWindow( wndPtr->hwndSelf, &rect, 0,
1795 RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN, 0 );
1796 }
1797 if( !wErase ) wndPtr->flags |= WIN_NEEDS_NCPAINT;
1798 }
1799 }
1800 else
1801 {
1802 RECT16 oldClientRect = wndPtr->rectClient;
1803
1804 wndPtr->rectWindow = newWindowRect;
1805 wndPtr->rectClient = newClientRect;
1806
1807 if( oldClientRect.bottom - oldClientRect.top ==
1808 newClientRect.bottom - newClientRect.top ) result &= ~WVR_VREDRAW;
1809
1810 if( oldClientRect.right - oldClientRect.left ==
1811 newClientRect.right - newClientRect.left ) result &= ~WVR_HREDRAW;
1812
1813 if( !(flags & (SWP_NOREDRAW | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) )
1814 {
1815 uFlags |= ((winpos->flags & SWP_NOCOPYBITS) ||
1816 (result >= WVR_HREDRAW && result < WVR_VALIDRECTS)) ? SMC_NOCOPY : 0;
1817 uFlags |= (winpos->flags & SWP_FRAMECHANGED) ? SMC_DRAWFRAME : 0;
1818
1819 if( (winpos->flags & SWP_AGG_NOGEOMETRYCHANGE) != SWP_AGG_NOGEOMETRYCHANGE )
1820 uFlags = WINPOS_SizeMoveClean(wndPtr, visRgn, &oldWindowRect,
1821 &oldClientRect, uFlags);
1822 else
1823 {
1824 /* adjust frame and do not erase parent */
1825
1826 if( winpos->flags & SWP_FRAMECHANGED ) wndPtr->flags |= WIN_NEEDS_NCPAINT;
1827 if( winpos->flags & SWP_NOZORDER ) uFlags |= SMC_NOPARENTERASE;
1828 }
1829 }
1830 DeleteObject32(visRgn);
1831 }
1832
1833 if (flags & SWP_SHOWWINDOW)
1834 {
1835 wndPtr->dwStyle |= WS_VISIBLE;
1836 if (wndPtr->window)
1837 {
1838 if( uFlags & SMC_SETXPOS )
1839 {
1840 WINPOS_SetXWindowPos( winpos );
1841 winpos->hwndInsertAfter = tempInsertAfter;
1842 }
1843 XMapWindow( display, wndPtr->window );
1844 }
1845 else
1846 {
1847 if (!(flags & SWP_NOREDRAW))
1848 PAINT_RedrawWindow( winpos->hwnd, NULL, 0,
1849 RDW_INVALIDATE | RDW_ALLCHILDREN |
1850 RDW_FRAME | RDW_ERASENOW | RDW_ERASE, 0 );
1851 }
1852 }
1853 else if (flags & SWP_HIDEWINDOW)
1854 {
1855 wndPtr->dwStyle &= ~WS_VISIBLE;
1856 if (wndPtr->window)
1857 {
1858 XUnmapWindow( display, wndPtr->window );
1859 if( uFlags & SMC_SETXPOS )
1860 {
1861 WINPOS_SetXWindowPos( winpos );
1862 winpos->hwndInsertAfter = tempInsertAfter;
1863 }
1864 }
1865 else
1866 {
1867 if (!(flags & SWP_NOREDRAW))
1868 {
1869 RECT32 rect = { oldWindowRect.left, oldWindowRect.top,
1870 oldWindowRect.right, oldWindowRect.bottom };
1871 PAINT_RedrawWindow( wndPtr->parent->hwndSelf, &rect, 0,
1872 RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE | RDW_ERASENOW, 0);
1873 }
1874 uFlags |= SMC_NOPARENTERASE;
1875 }
1876
1877 if ((winpos->hwnd == GetFocus32()) ||
1878 IsChild( winpos->hwnd, GetFocus32()))
1879 {
1880 /* Revert focus to parent */
1881 SetFocus32( GetParent32(winpos->hwnd) );
1882 }
1883 if (hwnd == CARET_GetHwnd()) DestroyCaret();
1884
1885 if (winpos->hwnd == hwndActive)
1886 {
1887 /* Activate previously active window if possible */
1888 HWND newActive = hwndPrevActive;
1889 if (!IsWindow(newActive) || (newActive == winpos->hwnd))
1890 {
1891 newActive = GetTopWindow( GetDesktopWindow32() );
1892 if (newActive == winpos->hwnd)
1893 newActive = wndPtr->next ? wndPtr->next->hwndSelf : 0;
1894 }
1895 WINPOS_ChangeActiveWindow( newActive, FALSE );
1896 }
1897 }
1898
1899 /* Activate the window */
1900
1901 if (!(flags & SWP_NOACTIVATE))
1902 WINPOS_ChangeActiveWindow( winpos->hwnd, FALSE );
1903
1904 /* Repaint the window */
1905
1906 if (wndPtr->window) EVENT_Synchronize(); /* Wait for all expose events */
1907
1908 EVENT_DummyMotionNotify(); /* Simulate a mouse event to set the cursor */
1909
1910 if (!(flags & SWP_DEFERERASE) && !(uFlags & SMC_NOPARENTERASE) )
1911 {
1912 RECT32 rect;
1913 CONV_RECT16TO32( &oldWindowRect, &rect );
1914 PAINT_RedrawWindow( wndPtr->parent->hwndSelf, (wndPtr->flags & WIN_SAVEUNDER_OVERRIDE)
1915 ? &rect : NULL, 0, RDW_ALLCHILDREN | RDW_ERASENOW |
1916 ((wndPtr->flags & WIN_SAVEUNDER_OVERRIDE) ? RDW_INVALIDATE : 0), 0 );
1917 wndPtr->flags &= ~WIN_SAVEUNDER_OVERRIDE;
1918 }
1919 else if( wndPtr->parent == WIN_GetDesktop() && wndPtr->parent->flags & WIN_NEEDS_ERASEBKGND )
1920 PAINT_RedrawWindow( wndPtr->parent->hwndSelf, NULL, 0, RDW_NOCHILDREN | RDW_ERASENOW, 0 );
1921
1922 /* And last, send the WM_WINDOWPOSCHANGED message */
1923
1924 dprintf_win(stddeb,"\tstatus flags = %04x\n", winpos->flags & SWP_AGG_STATUSFLAGS);
1925
1926 if ( ((winpos->flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE) &&
1927 !(winpos->flags & SWP_NOSENDCHANGING))
1928 SendMessage16( winpos->hwnd, WM_WINDOWPOSCHANGED,
1929 0, (LPARAM)SEGPTR_GET(winpos) );
1930
1931 SEGPTR_FREE(winpos);
1932 return TRUE;
1933 }
1934
1935
1936 /***********************************************************************
1937 * BeginDeferWindowPos (USER.259)
1938 */
1939 HDWP16 BeginDeferWindowPos( INT count )
1940 {
1941 HDWP16 handle;
1942 DWP *pDWP;
1943
1944 if (count <= 0) return 0;
1945 handle = USER_HEAP_ALLOC( sizeof(DWP) + (count-1)*sizeof(WINDOWPOS16) );
1946 if (!handle) return 0;
1947 pDWP = (DWP *) USER_HEAP_LIN_ADDR( handle );
1948 pDWP->actualCount = 0;
1949 pDWP->suggestedCount = count;
1950 pDWP->valid = TRUE;
1951 pDWP->wMagic = DWP_MAGIC;
1952 pDWP->hwndParent = 0;
1953 return handle;
1954 }
1955
1956
1957 /***********************************************************************
1958 * DeferWindowPos (USER.260)
1959 */
1960 HDWP16 DeferWindowPos( HDWP16 hdwp, HWND hwnd, HWND hwndAfter, INT x, INT y,
1961 INT cx, INT cy, UINT flags )
1962 {
1963 DWP *pDWP;
1964 int i;
1965 HDWP16 newhdwp = hdwp;
1966 HWND parent;
1967
1968 pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
1969 if (!pDWP) return 0;
1970 if (hwnd == GetDesktopWindow32()) return 0;
1971
1972 /* All the windows of a DeferWindowPos() must have the same parent */
1973
1974 parent = WIN_FindWndPtr( hwnd )->parent->hwndSelf;
1975 if (pDWP->actualCount == 0) pDWP->hwndParent = parent;
1976 else if (parent != pDWP->hwndParent)
1977 {
1978 USER_HEAP_FREE( hdwp );
1979 return 0;
1980 }
1981
1982 for (i = 0; i < pDWP->actualCount; i++)
1983 {
1984 if (pDWP->winPos[i].hwnd == hwnd)
1985 {
1986 /* Merge with the other changes */
1987 if (!(flags & SWP_NOZORDER))
1988 {
1989 pDWP->winPos[i].hwndInsertAfter = hwndAfter;
1990 }
1991 if (!(flags & SWP_NOMOVE))
1992 {
1993 pDWP->winPos[i].x = x;
1994 pDWP->winPos[i].y = y;
1995 }
1996 if (!(flags & SWP_NOSIZE))
1997 {
1998 pDWP->winPos[i].cx = cx;
1999 pDWP->winPos[i].cy = cy;
2000 }
2001 pDWP->winPos[i].flags &= flags & (SWP_NOSIZE | SWP_NOMOVE |
2002 SWP_NOZORDER | SWP_NOREDRAW |
2003 SWP_NOACTIVATE | SWP_NOCOPYBITS |
2004 SWP_NOOWNERZORDER);
2005 pDWP->winPos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
2006 SWP_FRAMECHANGED);
2007 return hdwp;
2008 }
2009 }
2010 if (pDWP->actualCount >= pDWP->suggestedCount)
2011 {
2012 newhdwp = USER_HEAP_REALLOC( hdwp,
2013 sizeof(DWP) + pDWP->suggestedCount*sizeof(WINDOWPOS16) );
2014 if (!newhdwp) return 0;
2015 pDWP = (DWP *) USER_HEAP_LIN_ADDR( newhdwp );
2016 pDWP->suggestedCount++;
2017 }
2018 pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
2019 pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
2020 pDWP->winPos[pDWP->actualCount].x = x;
2021 pDWP->winPos[pDWP->actualCount].y = y;
2022 pDWP->winPos[pDWP->actualCount].cx = cx;
2023 pDWP->winPos[pDWP->actualCount].cy = cy;
2024 pDWP->winPos[pDWP->actualCount].flags = flags;
2025 pDWP->actualCount++;
2026 return newhdwp;
2027 }
2028
2029
2030 /***********************************************************************
2031 * EndDeferWindowPos (USER.261)
2032 */
2033 BOOL EndDeferWindowPos( HDWP16 hdwp )
2034 {
2035 DWP *pDWP;
2036 WINDOWPOS16 *winpos;
2037 BOOL res = TRUE;
2038 int i;
2039
2040 pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
2041 if (!pDWP) return FALSE;
2042 for (i = 0, winpos = pDWP->winPos; i < pDWP->actualCount; i++, winpos++)
2043 {
2044 if (!(res = SetWindowPos( winpos->hwnd, winpos->hwndInsertAfter,
2045 winpos->x, winpos->y, winpos->cx, winpos->cy,
2046 winpos->flags ))) break;
2047 }
2048 USER_HEAP_FREE( hdwp );
2049 return res;
2050 }
2051
2052
2053 /***********************************************************************
2054 * TileChildWindows (USER.199)
2055 */
2056 void TileChildWindows( HWND parent, WORD action )
2057 {
2058 printf("STUB TileChildWindows(%04x, %d)\n", parent, action);
2059 }
2060
2061 /***********************************************************************
2062 * CascageChildWindows (USER.198)
2063 */
2064 void CascadeChildWindows( HWND parent, WORD action )
2065 {
2066 printf("STUB CascadeChildWindows(%04x, %d)\n", parent, action);
2067 }
useful hacks and other patches not (yet) suitable for mainline