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