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