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