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