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