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