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