?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Reset disabled style for the dialog boxes set on property pages.
[wine.git] / windows / winpos.c
blobfc517145ff83813dc592c71535f991a80017ef80
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 "debugtools.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("\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("\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("GetWindowRgn: doesn't really do regions\n");
278
279 memset (&rect, 0, sizeof(rect));
280
281 GetWindowRect ( hwnd, &rect );
282
283 FIXME("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("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("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("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("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("\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("\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("\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("(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("(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("%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("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("%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("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("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("(%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("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("%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("(%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("\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("\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("\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("\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 {
2279 Wnd->pDriver->pSurfaceCopy( Wnd->parent, dc, dx, dy, &r, TRUE );
2280
2281 /* When you copy the bits without repainting, parent doesn't
2282 get validated appropriately. Therefore, we have to validate
2283 the parent with the windows' updated region when the
2284 parent's update region is not empty. */
2285
2286 if (Wnd->parent->hrgnUpdate != 0 && !(Wnd->parent->dwStyle & WS_CLIPCHILDREN))
2287 {
2288 OffsetRect(&r, dx, dy);
2289 ValidateRect(Wnd->parent->hwndSelf, &r);
2290 }
2291 }
2292
2293 GDI_HEAP_UNLOCK( hDC );
2294 }
2295 ReleaseDC( (uFlags & SWP_EX_PAINTSELF) ?
2296 Wnd->hwndSelf : Wnd->parent->hwndSelf, hDC);
2297 }
2298 }
2299
2300 /* *pVisRgn now points to the invalidated region */
2301
2302 DeleteObject(newVisRgn);
2303 DeleteObject(dirtyRgn);
2304 return uFlags;
2305 }
2306
2307 /***********************************************************************
2308 * SWP_DoSimpleFrameChanged
2309 *
2310 * NOTE: old and new client rect origins are identical, only
2311 * extents may have changed. Window extents are the same.
2312 */
2313 static void SWP_DoSimpleFrameChanged( WND* wndPtr, RECT* pOldClientRect, WORD swpFlags, UINT uFlags )
2314 {
2315 INT i = 0;
2316 RECT rect;
2317 HRGN hrgn = 0;
2318
2319 if( !(swpFlags & SWP_NOCLIENTSIZE) )
2320 {
2321 /* Client rect changed its position/size, most likely a scrollar
2322 * was added/removed.
2323 *
2324 * FIXME: WVR alignment flags
2325 */
2326
2327 if( wndPtr->rectClient.right > pOldClientRect->right ) /* right edge */
2328 {
2329 i++;
2330 rect.top = 0;
2331 rect.bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
2332 rect.right = wndPtr->rectClient.right - wndPtr->rectClient.left;
2333 if(!(uFlags & SWP_EX_NOCOPY))
2334 rect.left = pOldClientRect->right - wndPtr->rectClient.left;
2335 else
2336 {
2337 rect.left = 0;
2338 goto redraw;
2339 }
2340 }
2341
2342 if( wndPtr->rectClient.bottom > pOldClientRect->bottom ) /* bottom edge */
2343 {
2344 if( i )
2345 hrgn = CreateRectRgnIndirect( &rect );
2346 rect.left = 0;
2347 rect.right = wndPtr->rectClient.right - wndPtr->rectClient.left;
2348 rect.bottom = wndPtr->rectClient.bottom - wndPtr->rectClient.top;
2349 if(!(uFlags & SWP_EX_NOCOPY))
2350 rect.top = pOldClientRect->bottom - wndPtr->rectClient.top;
2351 else
2352 rect.top = 0;
2353 if( i++ )
2354 REGION_UnionRectWithRgn( hrgn, &rect );
2355 }
2356
2357 if( i == 0 && (uFlags & SWP_EX_NOCOPY) ) /* force redraw anyway */
2358 {
2359 rect = wndPtr->rectWindow;
2360 OffsetRect( &rect, wndPtr->rectWindow.left - wndPtr->rectClient.left,
2361 wndPtr->rectWindow.top - wndPtr->rectClient.top );
2362 i++;
2363 }
2364 }
2365
2366 if( i )
2367 {
2368 redraw:
2369 PAINT_RedrawWindow( wndPtr->hwndSelf, &rect, hrgn, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE |
2370 RDW_ERASENOW | RDW_ALLCHILDREN, RDW_EX_TOPFRAME | RDW_EX_USEHRGN );
2371 }
2372 else
2373 {
2374 WIN_UpdateNCRgn(wndPtr, 0, UNC_UPDATE | UNC_ENTIRE);
2375 }
2376
2377 if( hrgn > 1 )
2378 DeleteObject( hrgn );
2379 }
2380
2381 /***********************************************************************
2382 * SWP_DoWinPosChanging
2383 */
2384 static BOOL SWP_DoWinPosChanging( WND* wndPtr, WINDOWPOS* pWinpos,
2385 RECT* pNewWindowRect, RECT* pNewClientRect )
2386 {
2387 /* Send WM_WINDOWPOSCHANGING message */
2388
2389 if (!(pWinpos->flags & SWP_NOSENDCHANGING))
2390 SendMessageA( wndPtr->hwndSelf, WM_WINDOWPOSCHANGING, 0, (LPARAM)pWinpos );
2391
2392 /* Calculate new position and size */
2393
2394 *pNewWindowRect = wndPtr->rectWindow;
2395 *pNewClientRect = (wndPtr->dwStyle & WS_MINIMIZE) ? wndPtr->rectWindow
2396 : wndPtr->rectClient;
2397
2398 if (!(pWinpos->flags & SWP_NOSIZE))
2399 {
2400 pNewWindowRect->right = pNewWindowRect->left + pWinpos->cx;
2401 pNewWindowRect->bottom = pNewWindowRect->top + pWinpos->cy;
2402 }
2403 if (!(pWinpos->flags & SWP_NOMOVE))
2404 {
2405 pNewWindowRect->left = pWinpos->x;
2406 pNewWindowRect->top = pWinpos->y;
2407 pNewWindowRect->right += pWinpos->x - wndPtr->rectWindow.left;
2408 pNewWindowRect->bottom += pWinpos->y - wndPtr->rectWindow.top;
2409
2410 OffsetRect( pNewClientRect, pWinpos->x - wndPtr->rectWindow.left,
2411 pWinpos->y - wndPtr->rectWindow.top );
2412 }
2413
2414 pWinpos->flags |= SWP_NOCLIENTMOVE | SWP_NOCLIENTSIZE;
2415 return TRUE;
2416 }
2417
2418 /***********************************************************************
2419 * SWP_DoNCCalcSize
2420 */
2421 static UINT SWP_DoNCCalcSize( WND* wndPtr, WINDOWPOS* pWinpos,
2422 RECT* pNewWindowRect, RECT* pNewClientRect, WORD f)
2423 {
2424 UINT wvrFlags = 0;
2425
2426 /* Send WM_NCCALCSIZE message to get new client area */
2427 if( (pWinpos->flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE )
2428 {
2429 wvrFlags = WINPOS_SendNCCalcSize( pWinpos->hwnd, TRUE, pNewWindowRect,
2430 &wndPtr->rectWindow, &wndPtr->rectClient,
2431 pWinpos, pNewClientRect );
2432
2433 /* FIXME: WVR_ALIGNxxx */
2434
2435 if( pNewClientRect->left != wndPtr->rectClient.left ||
2436 pNewClientRect->top != wndPtr->rectClient.top )
2437 pWinpos->flags &= ~SWP_NOCLIENTMOVE;
2438
2439 if( (pNewClientRect->right - pNewClientRect->left !=
2440 wndPtr->rectClient.right - wndPtr->rectClient.left) ||
2441 (pNewClientRect->bottom - pNewClientRect->top !=
2442 wndPtr->rectClient.bottom - wndPtr->rectClient.top) )
2443 pWinpos->flags &= ~SWP_NOCLIENTSIZE;
2444 }
2445 else
2446 if( !(f & SWP_NOMOVE) && (pNewClientRect->left != wndPtr->rectClient.left ||
2447 pNewClientRect->top != wndPtr->rectClient.top) )
2448 pWinpos->flags &= ~SWP_NOCLIENTMOVE;
2449 return wvrFlags;
2450 }
2451
2452 /***********************************************************************
2453 * SetWindowPos (USER.2)
2454 */
2455 BOOL16 WINAPI SetWindowPos16( HWND16 hwnd, HWND16 hwndInsertAfter,
2456 INT16 x, INT16 y, INT16 cx, INT16 cy, WORD flags)
2457 {
2458 return SetWindowPos(hwnd,(INT)(INT16)hwndInsertAfter,x,y,cx,cy,flags);
2459 }
2460
2461 /***********************************************************************
2462 * SetWindowPos (USER32.520)
2463 */
2464 BOOL WINAPI SetWindowPos( HWND hwnd, HWND hwndInsertAfter,
2465 INT x, INT y, INT cx, INT cy, UINT flags )
2466 {
2467 WINDOWPOS winpos;
2468 WND * wndPtr,*wndTemp;
2469 RECT newWindowRect, newClientRect;
2470 RECT oldWindowRect, oldClientRect;
2471 HRGN visRgn = 0;
2472 UINT wvrFlags = 0, uFlags = 0;
2473 BOOL retvalue, resync = FALSE, bChangePos;
2474 HWND hwndActive = 0;
2475
2476 /* Get current active window from the active queue */
2477 if ( hActiveQueue )
2478 {
2479 MESSAGEQUEUE *pActiveQueue = QUEUE_Lock( hActiveQueue );
2480 if ( pActiveQueue )
2481 {
2482 hwndActive = PERQDATA_GetActiveWnd( pActiveQueue->pQData );
2483 QUEUE_Unlock( pActiveQueue );
2484 }
2485 }
2486
2487 TRACE("hwnd %04x, swp (%i,%i)-(%i,%i) flags %08x\n",
2488 hwnd, x, y, x+cx, y+cy, flags);
2489
2490 bChangePos = !(flags & SWP_WINE_NOHOSTMOVE);
2491 flags &= ~SWP_WINE_NOHOSTMOVE;
2492
2493
2494 /* ------------------------------------------------------------------------ CHECKS */
2495
2496 /* Check window handle */
2497
2498 if (hwnd == GetDesktopWindow()) return FALSE;
2499 if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
2500
2501 TRACE("\tcurrent (%i,%i)-(%i,%i), style %08x\n", wndPtr->rectWindow.left, wndPtr->rectWindow.top,
2502 wndPtr->rectWindow.right, wndPtr->rectWindow.bottom, (unsigned)wndPtr->dwStyle );
2503
2504 /* Fix redundant flags */
2505
2506 if(wndPtr->dwStyle & WS_VISIBLE)
2507 flags &= ~SWP_SHOWWINDOW;
2508 else
2509 {
2510 if (!(flags & SWP_SHOWWINDOW))
2511 flags |= SWP_NOREDRAW;
2512 flags &= ~SWP_HIDEWINDOW;
2513 }
2514
2515 if ( cx < 0 ) cx = 0; if( cy < 0 ) cy = 0;
2516
2517 if ((wndPtr->rectWindow.right - wndPtr->rectWindow.left == cx) &&
2518 (wndPtr->rectWindow.bottom - wndPtr->rectWindow.top == cy))
2519 flags |= SWP_NOSIZE; /* Already the right size */
2520
2521 if ((wndPtr->rectWindow.left == x) && (wndPtr->rectWindow.top == y))
2522 flags |= SWP_NOMOVE; /* Already the right position */
2523
2524 if (hwnd == hwndActive)
2525 flags |= SWP_NOACTIVATE; /* Already active */
2526 else if ( (wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) != WS_CHILD )
2527 {
2528 if(!(flags & SWP_NOACTIVATE)) /* Bring to the top when activating */
2529 {
2530 flags &= ~SWP_NOZORDER;
2531 hwndInsertAfter = HWND_TOP;
2532 goto Pos;
2533 }
2534 }
2535
2536 /* Check hwndInsertAfter */
2537
2538 /* FIXME: TOPMOST not supported yet */
2539 if ((hwndInsertAfter == HWND_TOPMOST) ||
2540 (hwndInsertAfter == HWND_NOTOPMOST)) hwndInsertAfter = HWND_TOP;
2541
2542 /* hwndInsertAfter must be a sibling of the window */
2543 if ((hwndInsertAfter != HWND_TOP) && (hwndInsertAfter != HWND_BOTTOM))
2544 {
2545 WND* wnd = WIN_FindWndPtr(hwndInsertAfter);
2546
2547 if( wnd ) {
2548 if( wnd->parent != wndPtr->parent )
2549 {
2550 retvalue = FALSE;
2551 WIN_ReleaseWndPtr(wnd);
2552 goto END;
2553 }
2554 if( wnd->next == wndPtr ) flags |= SWP_NOZORDER;
2555 }
2556 WIN_ReleaseWndPtr(wnd);
2557 }
2558
2559 Pos: /* ------------------------------------------------------------------------ MAIN part */
2560
2561 /* Fill the WINDOWPOS structure */
2562
2563 winpos.hwnd = hwnd;
2564 winpos.hwndInsertAfter = hwndInsertAfter;
2565 winpos.x = x;
2566 winpos.y = y;
2567 winpos.cx = cx;
2568 winpos.cy = cy;
2569 winpos.flags = flags;
2570
2571 SWP_DoWinPosChanging( wndPtr, &winpos, &newWindowRect, &newClientRect );
2572
2573 if((winpos.flags & (SWP_NOZORDER | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) != SWP_NOZORDER)
2574 {
2575 if( wndPtr->parent == WIN_GetDesktop() )
2576 hwndInsertAfter = SWP_DoOwnedPopups( wndPtr->parent, wndPtr,
2577 hwndInsertAfter, winpos.flags );
2578 WIN_ReleaseDesktop();
2579 }
2580
2581 if(!(wndPtr->flags & WIN_NATIVE) )
2582 {
2583 if( hwndInsertAfter == HWND_TOP )
2584 winpos.flags |= ( wndPtr->parent->child == wndPtr)? SWP_NOZORDER: 0;
2585 else
2586 if( hwndInsertAfter == HWND_BOTTOM )
2587 winpos.flags |= ( wndPtr->next )? 0: SWP_NOZORDER;
2588 else
2589 if( !(winpos.flags & SWP_NOZORDER) )
2590 if( GetWindow(hwndInsertAfter, GW_HWNDNEXT) == wndPtr->hwndSelf )
2591 winpos.flags |= SWP_NOZORDER;
2592
2593 if( !(winpos.flags & (SWP_NOREDRAW | SWP_SHOWWINDOW)) &&
2594 ((winpos.flags & (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_HIDEWINDOW | SWP_FRAMECHANGED))
2595 != (SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER)) )
2596 {
2597 /* get a previous visible region for SWP_CopyValidBits() */
2598
2599 visRgn = DCE_GetVisRgn(hwnd, DCX_WINDOW | DCX_CLIPSIBLINGS, 0, 0);
2600 }
2601 }
2602
2603 /* Common operations */
2604
2605 wvrFlags = SWP_DoNCCalcSize( wndPtr, &winpos, &newWindowRect, &newClientRect, flags );
2606
2607 if(!(winpos.flags & SWP_NOZORDER))
2608 {
2609 if ( WIN_UnlinkWindow( winpos.hwnd ) )
2610 WIN_LinkWindow( winpos.hwnd, hwndInsertAfter );
2611 }
2612
2613 /* Reset active DCEs */
2614
2615 if( (((winpos.flags & SWP_AGG_NOPOSCHANGE) != SWP_AGG_NOPOSCHANGE) &&
2616 wndPtr->dwStyle & WS_VISIBLE) ||
2617 (flags & (SWP_HIDEWINDOW | SWP_SHOWWINDOW)) )
2618 {
2619 RECT rect;
2620
2621 UnionRect(&rect, &newWindowRect, &wndPtr->rectWindow);
2622 DCE_InvalidateDCE(wndPtr, &rect);
2623 }
2624
2625 oldWindowRect = wndPtr->rectWindow;
2626 oldClientRect = wndPtr->rectClient;
2627
2628 /* Find out if we have to redraw the whole client rect */
2629
2630 if( oldClientRect.bottom - oldClientRect.top ==
2631 newClientRect.bottom - newClientRect.top ) wvrFlags &= ~WVR_VREDRAW;
2632
2633 if( oldClientRect.right - oldClientRect.left ==
2634 newClientRect.right - newClientRect.left ) wvrFlags &= ~WVR_HREDRAW;
2635
2636 if( (winpos.flags & SWP_NOCOPYBITS) || (!(winpos.flags & SWP_NOCLIENTSIZE) &&
2637 (wvrFlags >= WVR_HREDRAW) && (wvrFlags < WVR_VALIDRECTS)) )
2638 {
2639 uFlags |= SWP_EX_NOCOPY;
2640 }
2641 /*
2642 * Use this later in CopyValidBits()
2643 *
2644 else if( 0 )
2645 uFlags |= SWP_EX_NONCLIENT;
2646 */
2647
2648 /* FIXME: actually do something with WVR_VALIDRECTS */
2649
2650 wndPtr->rectWindow = newWindowRect;
2651 wndPtr->rectClient = newClientRect;
2652
2653 if (wndPtr->flags & WIN_NATIVE) /* -------------------------------------------- hosted window */
2654 {
2655 BOOL bCallDriver = TRUE;
2656 HWND tempInsertAfter = winpos.hwndInsertAfter;
2657
2658 winpos.hwndInsertAfter = hwndInsertAfter;
2659
2660 if( !(winpos.flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW | SWP_NOREDRAW)) )
2661 {
2662 /* This is the only place where we need to force repainting of the contents
2663 of windows created by the host window system, all other cases go through the
2664 expose event handling */
2665
2666 if( (winpos.flags & (SWP_NOSIZE | SWP_FRAMECHANGED)) == (SWP_NOSIZE | SWP_FRAMECHANGED) )
2667 {
2668 cx = newWindowRect.right - newWindowRect.left;
2669 cy = newWindowRect.bottom - newWindowRect.top;
2670
2671 wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, bChangePos);
2672 winpos.hwndInsertAfter = tempInsertAfter;
2673 bCallDriver = FALSE;
2674
2675 if( winpos.flags & SWP_NOCLIENTMOVE )
2676 SWP_DoSimpleFrameChanged(wndPtr, &oldClientRect, winpos.flags, uFlags );
2677 else
2678 {
2679 /* client area moved but window extents remained the same, copy valid bits */
2680
2681 visRgn = CreateRectRgn( 0, 0, cx, cy );
2682 uFlags = SWP_CopyValidBits( wndPtr, &visRgn, &oldWindowRect, &oldClientRect,
2683 uFlags | SWP_EX_PAINTSELF );
2684 }
2685 }
2686 }
2687
2688 if( bCallDriver )
2689 {
2690 if( !(winpos.flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW | SWP_NOREDRAW)) )
2691 {
2692 if( (oldClientRect.left - oldWindowRect.left == newClientRect.left - newWindowRect.left) &&
2693 (oldClientRect.top - oldWindowRect.top == newClientRect.top - newWindowRect.top) &&
2694 !(uFlags & SWP_EX_NOCOPY) )
2695 {
2696 /* The origin of the client rect didn't move so we can try to repaint
2697 * only the nonclient area by setting bit gravity hint for the host window system.
2698 */
2699
2700 if( !(wndPtr->flags & WIN_MANAGED) )
2701 {
2702 HRGN hrgn = CreateRectRgn( 0, 0, newWindowRect.right - newWindowRect.left,
2703 newWindowRect.bottom - newWindowRect.top);
2704 RECT rcn = newClientRect;
2705 RECT rco = oldClientRect;
2706
2707 OffsetRect( &rcn, -newWindowRect.left, -newWindowRect.top );
2708 OffsetRect( &rco, -oldWindowRect.left, -oldWindowRect.top );
2709 IntersectRect( &rcn, &rcn, &rco );
2710 visRgn = CreateRectRgnIndirect( &rcn );
2711 CombineRgn( visRgn, hrgn, visRgn, RGN_DIFF );
2712 DeleteObject( hrgn );
2713 uFlags = SWP_EX_PAINTSELF;
2714 }
2715 wndPtr->pDriver->pSetHostAttr(wndPtr, HAK_BITGRAVITY, BGNorthWest );
2716 }
2717 else
2718 wndPtr->pDriver->pSetHostAttr(wndPtr, HAK_BITGRAVITY, BGForget );
2719 }
2720
2721 wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, bChangePos);
2722 winpos.hwndInsertAfter = tempInsertAfter;
2723 }
2724
2725 if( winpos.flags & SWP_SHOWWINDOW )
2726 {
2727 HWND focus, curr;
2728
2729 wndPtr->dwStyle |= WS_VISIBLE;
2730
2731 if (wndPtr->flags & WIN_MANAGED) resync = TRUE;
2732
2733 /* focus was set to unmapped window, reset host focus
2734 * since the window is now visible */
2735
2736 focus = curr = GetFocus();
2737 while (curr)
2738 {
2739 if (curr == hwnd)
2740 {
2741 WND *pFocus = WIN_FindWndPtr( focus );
2742 if (pFocus)
2743 pFocus->pDriver->pSetFocus(pFocus);
2744 WIN_ReleaseWndPtr(pFocus);
2745 break;
2746 }
2747 curr = GetParent(curr);
2748 }
2749 }
2750 }
2751 else /* -------------------------------------------- emulated window */
2752 {
2753 if( winpos.flags & SWP_SHOWWINDOW )
2754 {
2755 wndPtr->dwStyle |= WS_VISIBLE;
2756 uFlags |= SWP_EX_PAINTSELF;
2757 visRgn = 1; /* redraw the whole window */
2758 }
2759 else if( !(winpos.flags & SWP_NOREDRAW) )
2760 {
2761 if( winpos.flags & SWP_HIDEWINDOW )
2762 {
2763 if( visRgn > 1 ) /* map to parent */
2764 OffsetRgn( visRgn, oldWindowRect.left, oldWindowRect.top );
2765 else
2766 visRgn = 0;
2767 }
2768 else
2769 {
2770 if( (winpos.flags & SWP_AGG_NOPOSCHANGE) != SWP_AGG_NOPOSCHANGE )
2771 uFlags = SWP_CopyValidBits(wndPtr, &visRgn, &oldWindowRect,
2772 &oldClientRect, uFlags);
2773 else
2774 {
2775 /* nothing moved, redraw frame if needed */
2776
2777 if( winpos.flags & SWP_FRAMECHANGED )
2778 SWP_DoSimpleFrameChanged( wndPtr, &oldClientRect, winpos.flags, uFlags );
2779 if( visRgn )
2780 {
2781 DeleteObject( visRgn );
2782 visRgn = 0;
2783 }
2784 }
2785 }
2786 }
2787 }
2788
2789 if( winpos.flags & SWP_HIDEWINDOW )
2790 {
2791 wndPtr->dwStyle &= ~WS_VISIBLE;
2792
2793 if (hwnd == CARET_GetHwnd()) DestroyCaret();
2794
2795 /* FIXME: This will cause the window to be activated irrespective
2796 * of whether it is owned by the same thread. Has to be done
2797 * asynchronously.
2798 */
2799
2800 if (winpos.hwnd == hwndActive)
2801 WINPOS_ActivateOtherWindow( wndPtr );
2802 }
2803
2804 /* ------------------------------------------------------------------------ FINAL */
2805
2806 if (wndPtr->flags & WIN_NATIVE)
2807 EVENT_Synchronize(); /* Synchronize with the host window system */
2808
2809 if (!GetCapture() && ((wndPtr->dwStyle & WS_VISIBLE) || (flags & SWP_HIDEWINDOW)))
2810 {
2811 /* Simulate a mouse event to set the cursor */
2812 DWORD posX, posY, keyState;
2813
2814 if ( EVENT_QueryPointer( &posX, &posY, &keyState ) )
2815 {
2816 int iWndsLocks = WIN_SuspendWndsLock();
2817
2818 hardware_event( WM_MOUSEMOVE, keyState, 0,
2819 posX, posY, GetTickCount(), 0 );
2820
2821 WIN_RestoreWndsLock(iWndsLocks);
2822 }
2823 }
2824
2825 wndTemp = WIN_GetDesktop();
2826
2827 /* repaint invalidated region (if any)
2828 *
2829 * FIXME: if SWP_NOACTIVATE is not set then set invalid regions here without any painting
2830 * and force update after ChangeActiveWindow() to avoid painting frames twice.
2831 */
2832
2833 if( visRgn )
2834 {
2835 if( !(winpos.flags & SWP_NOREDRAW) )
2836 {
2837 if (wndPtr->parent == wndTemp)
2838 {
2839 /* Desktop does not receive wm_paint message so we use RDW_ERASENOW to erase the
2840 the desktop window */
2841
2842 if( uFlags & SWP_EX_PAINTSELF )
2843 {
2844 PAINT_RedrawWindow( wndPtr->hwndSelf, NULL, (visRgn == 1) ? 0 : visRgn, RDW_ERASE | RDW_FRAME |
2845 ((winpos.flags & SWP_DEFERERASE) ? 0 : RDW_ERASENOW) | RDW_INVALIDATE |
2846 RDW_ALLCHILDREN, RDW_EX_XYWINDOW | RDW_EX_USEHRGN );
2847 }
2848 else
2849 {
2850 PAINT_RedrawWindow( wndPtr->parent->hwndSelf, NULL, (visRgn == 1) ? 0 : visRgn,
2851 RDW_ERASE | RDW_ERASENOW | RDW_INVALIDATE | RDW_ALLCHILDREN, RDW_EX_USEHRGN );
2852 }
2853 }
2854 else
2855 {
2856 if( uFlags & SWP_EX_PAINTSELF )
2857 {
2858 /* Use PAINT_RedrawWindow to explicitly force an invalidation of the window,
2859 its parent and sibling and so on, and then update the parent window,
2860 the non-top-level window. Rely on the system to repaint other affected
2861 windows later on. */
2862
2863 PAINT_RedrawWindow( wndPtr->hwndSelf, NULL, (visRgn == 1) ? 0 : visRgn, RDW_ERASE |
2864 RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN, RDW_EX_XYWINDOW | RDW_EX_USEHRGN );
2865 }
2866 else
2867 {
2868 PAINT_RedrawWindow( wndPtr->parent->hwndSelf, NULL, (visRgn == 1) ? 0 : visRgn,
2869 RDW_ERASE | RDW_INVALIDATE | RDW_ALLCHILDREN, RDW_EX_USEHRGN );
2870
2871 UpdateWindow( wndPtr->parent->hwndSelf);
2872 }
2873 }
2874 }
2875 if( visRgn != 1 )
2876 DeleteObject( visRgn );
2877 }
2878
2879 WIN_ReleaseDesktop();
2880
2881 if (!(flags & SWP_NOACTIVATE))
2882 WINPOS_ChangeActiveWindow( winpos.hwnd, FALSE );
2883
2884 /* And last, send the WM_WINDOWPOSCHANGED message */
2885
2886 TRACE("\tstatus flags = %04x\n", winpos.flags & SWP_AGG_STATUSFLAGS);
2887
2888 if ( resync ||
2889 (((winpos.flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE) &&
2890 !(winpos.flags & SWP_NOSENDCHANGING)) )
2891 {
2892 SendMessageA( winpos.hwnd, WM_WINDOWPOSCHANGED, 0, (LPARAM)&winpos );
2893 if (resync) EVENT_Synchronize();
2894 }
2895
2896 retvalue = TRUE;
2897 END:
2898 WIN_ReleaseWndPtr(wndPtr);
2899 return retvalue;
2900 }
2901
2902
2903 /***********************************************************************
2904 * BeginDeferWindowPos16 (USER.259)
2905 */
2906 HDWP16 WINAPI BeginDeferWindowPos16( INT16 count )
2907 {
2908 return BeginDeferWindowPos( count );
2909 }
2910
2911
2912 /***********************************************************************
2913 * BeginDeferWindowPos (USER32.9)
2914 */
2915 HDWP WINAPI BeginDeferWindowPos( INT count )
2916 {
2917 HDWP handle;
2918 DWP *pDWP;
2919
2920 if (count <= 0) return 0;
2921 handle = USER_HEAP_ALLOC( sizeof(DWP) + (count-1)*sizeof(WINDOWPOS) );
2922 if (!handle) return 0;
2923 pDWP = (DWP *) USER_HEAP_LIN_ADDR( handle );
2924 pDWP->actualCount = 0;
2925 pDWP->suggestedCount = count;
2926 pDWP->valid = TRUE;
2927 pDWP->wMagic = DWP_MAGIC;
2928 pDWP->hwndParent = 0;
2929 return handle;
2930 }
2931
2932
2933 /***********************************************************************
2934 * DeferWindowPos16 (USER.260)
2935 */
2936 HDWP16 WINAPI DeferWindowPos16( HDWP16 hdwp, HWND16 hwnd, HWND16 hwndAfter,
2937 INT16 x, INT16 y, INT16 cx, INT16 cy,
2938 UINT16 flags )
2939 {
2940 return DeferWindowPos( hdwp, hwnd, (INT)(INT16)hwndAfter,
2941 x, y, cx, cy, flags );
2942 }
2943
2944
2945 /***********************************************************************
2946 * DeferWindowPos (USER32.128)
2947 */
2948 HDWP WINAPI DeferWindowPos( HDWP hdwp, HWND hwnd, HWND hwndAfter,
2949 INT x, INT y, INT cx, INT cy,
2950 UINT flags )
2951 {
2952 DWP *pDWP;
2953 int i;
2954 HDWP newhdwp = hdwp,retvalue;
2955 /* HWND parent; */
2956 WND *pWnd;
2957
2958 pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
2959 if (!pDWP) return 0;
2960 if (hwnd == GetDesktopWindow()) return 0;
2961
2962 if (!(pWnd=WIN_FindWndPtr( hwnd ))) {
2963 USER_HEAP_FREE( hdwp );
2964 return 0;
2965 }
2966
2967 /* Numega Bounds Checker Demo dislikes the following code.
2968 In fact, I've not been able to find any "same parent" requirement in any docu
2969 [AM 980509]
2970 */
2971 #if 0
2972 /* All the windows of a DeferWindowPos() must have the same parent */
2973 parent = pWnd->parent->hwndSelf;
2974 if (pDWP->actualCount == 0) pDWP->hwndParent = parent;
2975 else if (parent != pDWP->hwndParent)
2976 {
2977 USER_HEAP_FREE( hdwp );
2978 retvalue = 0;
2979 goto END;
2980 }
2981 #endif
2982
2983 for (i = 0; i < pDWP->actualCount; i++)
2984 {
2985 if (pDWP->winPos[i].hwnd == hwnd)
2986 {
2987 /* Merge with the other changes */
2988 if (!(flags & SWP_NOZORDER))
2989 {
2990 pDWP->winPos[i].hwndInsertAfter = hwndAfter;
2991 }
2992 if (!(flags & SWP_NOMOVE))
2993 {
2994 pDWP->winPos[i].x = x;
2995 pDWP->winPos[i].y = y;
2996 }
2997 if (!(flags & SWP_NOSIZE))
2998 {
2999 pDWP->winPos[i].cx = cx;
3000 pDWP->winPos[i].cy = cy;
3001 }
3002 pDWP->winPos[i].flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
3003 SWP_NOZORDER | SWP_NOREDRAW |
3004 SWP_NOACTIVATE | SWP_NOCOPYBITS|
3005 SWP_NOOWNERZORDER);
3006 pDWP->winPos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
3007 SWP_FRAMECHANGED);
3008 retvalue = hdwp;
3009 goto END;
3010 }
3011 }
3012 if (pDWP->actualCount >= pDWP->suggestedCount)
3013 {
3014 newhdwp = USER_HEAP_REALLOC( hdwp,
3015 sizeof(DWP) + pDWP->suggestedCount*sizeof(WINDOWPOS) );
3016 if (!newhdwp)
3017 {
3018 retvalue = 0;
3019 goto END;
3020 }
3021 pDWP = (DWP *) USER_HEAP_LIN_ADDR( newhdwp );
3022 pDWP->suggestedCount++;
3023 }
3024 pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
3025 pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
3026 pDWP->winPos[pDWP->actualCount].x = x;
3027 pDWP->winPos[pDWP->actualCount].y = y;
3028 pDWP->winPos[pDWP->actualCount].cx = cx;
3029 pDWP->winPos[pDWP->actualCount].cy = cy;
3030 pDWP->winPos[pDWP->actualCount].flags = flags;
3031 pDWP->actualCount++;
3032 retvalue = newhdwp;
3033 END:
3034 WIN_ReleaseWndPtr(pWnd);
3035 return retvalue;
3036 }
3037
3038
3039 /***********************************************************************
3040 * EndDeferWindowPos16 (USER.261)
3041 */
3042 BOOL16 WINAPI EndDeferWindowPos16( HDWP16 hdwp )
3043 {
3044 return EndDeferWindowPos( hdwp );
3045 }
3046
3047
3048 /***********************************************************************
3049 * EndDeferWindowPos (USER32.173)
3050 */
3051 BOOL WINAPI EndDeferWindowPos( HDWP hdwp )
3052 {
3053 DWP *pDWP;
3054 WINDOWPOS *winpos;
3055 BOOL res = TRUE;
3056 int i;
3057
3058 pDWP = (DWP *) USER_HEAP_LIN_ADDR( hdwp );
3059 if (!pDWP) return FALSE;
3060 for (i = 0, winpos = pDWP->winPos; i < pDWP->actualCount; i++, winpos++)
3061 {
3062 if (!(res = SetWindowPos( winpos->hwnd, winpos->hwndInsertAfter,
3063 winpos->x, winpos->y, winpos->cx,
3064 winpos->cy, winpos->flags ))) break;
3065 }
3066 USER_HEAP_FREE( hdwp );
3067 return res;
3068 }
3069
3070
3071 /***********************************************************************
3072 * TileChildWindows (USER.199)
3073 */
3074 void WINAPI TileChildWindows16( HWND16 parent, WORD action )
3075 {
3076 FIXME("(%04x, %d): stub\n", parent, action);
3077 }
3078
3079 /***********************************************************************
3080 * CascageChildWindows (USER.198)
3081 */
3082 void WINAPI CascadeChildWindows16( HWND16 parent, WORD action )
3083 {
3084 FIXME("(%04x, %d): stub\n", parent, action);
3085 }
3086
3087 /***********************************************************************
3088 * SetProgmanWindow [USER32.522]
3089 */
3090 HRESULT WINAPI SetProgmanWindow ( HWND hwnd )
3091 {
3092 hGlobalProgmanWindow = hwnd;
3093 return hGlobalProgmanWindow;
3094 }
3095
3096 /***********************************************************************
3097 * GetProgmanWindow [USER32.289]
3098 */
3099 HRESULT WINAPI GetProgmanWindow ( )
3100 {
3101 return hGlobalProgmanWindow;
3102 }
3103
3104 /***********************************************************************
3105 * SetShellWindowEx [USER32.531]
3106 * hwndProgman = Progman[Program Manager]
3107 * |-> SHELLDLL_DefView
3108 * hwndListView = | |-> SysListView32
3109 * | | |-> tooltips_class32
3110 * | |
3111 * | |-> SysHeader32
3112 * |
3113 * |-> ProxyTarget
3114 */
3115 HRESULT WINAPI SetShellWindowEx ( HWND hwndProgman, HWND hwndListView )
3116 {
3117 FIXME("0x%08x 0x%08x stub\n",hwndProgman ,hwndListView );
3118 hGlobalShellWindow = hwndProgman;
3119 return hGlobalShellWindow;
3120
3121 }
3122
3123 /***********************************************************************
3124 * SetTaskmanWindow [USER32.537]
3125 * NOTES
3126 * hwnd = MSTaskSwWClass
3127 * |-> SysTabControl32
3128 */
3129 HRESULT WINAPI SetTaskmanWindow ( HWND hwnd )
3130 {
3131 hGlobalTaskmanWindow = hwnd;
3132 return hGlobalTaskmanWindow;
3133 }
3134
3135 /***********************************************************************
3136 * GetTaskmanWindow [USER32.304]
3137 */
3138 HRESULT WINAPI GetTaskmanWindow ( )
3139 {
3140 return hGlobalTaskmanWindow;
3141 }
Windows API implementation