2 * Window position related functions.
4 * Copyright 1993, 1994, 1995 Alexandre Julliard
5 * 1995, 1996, 1999 Alex Korobka
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "wine/port.h"
28 #define WIN32_NO_STATUS
33 #include "wine/server.h"
35 #include "user_private.h"
37 #include "wine/debug.h"
39 WINE_DEFAULT_DEBUG_CHANNEL(win
);
41 #define SWP_AGG_NOGEOMETRYCHANGE \
42 (SWP_NOSIZE | SWP_NOCLIENTSIZE | SWP_NOZORDER)
43 #define SWP_AGG_NOPOSCHANGE \
44 (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER)
45 #define SWP_AGG_STATUSFLAGS \
46 (SWP_AGG_NOPOSCHANGE | SWP_FRAMECHANGED | SWP_HIDEWINDOW | SWP_SHOWWINDOW)
48 #define HAS_DLGFRAME(style,exStyle) \
49 (((exStyle) & WS_EX_DLGMODALFRAME) || \
50 (((style) & WS_DLGFRAME) && !((style) & WS_BORDER)))
52 #define HAS_THICKFRAME(style) \
53 (((style) & WS_THICKFRAME) && \
54 !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
56 #define EMPTYPOINT(pt) ((*(LONG*)&(pt)) == -1)
58 #define PLACE_MIN 0x0001
59 #define PLACE_MAX 0x0002
60 #define PLACE_RECT 0x0004
63 #define DWP_MAGIC ((INT)('W' | ('P' << 8) | ('O' << 16) | ('S' << 24)))
81 } INTERNALPOS
, *LPINTERNALPOS
;
83 /* ----- internal functions ----- */
85 static const WCHAR SysIP_W
[] = { 'S','y','s','I','P',0 };
87 static inline INTERNALPOS
*get_internal_pos( HWND hwnd
)
89 return GetPropW( hwnd
, SysIP_W
);
92 static inline void set_internal_pos( HWND hwnd
, INTERNALPOS
*pos
)
94 SetPropW( hwnd
, SysIP_W
, pos
);
97 /***********************************************************************
98 * WINPOS_CheckInternalPos
100 * Called when a window is destroyed.
102 void WINPOS_CheckInternalPos( HWND hwnd
)
104 LPINTERNALPOS lpPos
= get_internal_pos( hwnd
);
108 if( IsWindow(lpPos
->hwndIconTitle
) )
109 DestroyWindow( lpPos
->hwndIconTitle
);
110 HeapFree( GetProcessHeap(), 0, lpPos
);
114 /***********************************************************************
115 * ArrangeIconicWindows (USER32.@)
117 UINT WINAPI
ArrangeIconicWindows( HWND parent
)
121 INT x
, y
, xspacing
, yspacing
;
123 GetClientRect( parent
, &rectParent
);
125 y
= rectParent
.bottom
;
126 xspacing
= GetSystemMetrics(SM_CXICONSPACING
);
127 yspacing
= GetSystemMetrics(SM_CYICONSPACING
);
129 hwndChild
= GetWindow( parent
, GW_CHILD
);
132 if( IsIconic( hwndChild
) )
134 WINPOS_ShowIconTitle( hwndChild
, FALSE
);
136 SetWindowPos( hwndChild
, 0, x
+ (xspacing
- GetSystemMetrics(SM_CXICON
)) / 2,
137 y
- yspacing
- GetSystemMetrics(SM_CYICON
)/2, 0, 0,
138 SWP_NOSIZE
| SWP_NOZORDER
| SWP_NOACTIVATE
);
139 if( IsWindow(hwndChild
) )
140 WINPOS_ShowIconTitle(hwndChild
, TRUE
);
142 if (x
<= rectParent
.right
- xspacing
) x
+= xspacing
;
149 hwndChild
= GetWindow( hwndChild
, GW_HWNDNEXT
);
155 /***********************************************************************
156 * SwitchToThisWindow (USER32.@)
158 void WINAPI
SwitchToThisWindow( HWND hwnd
, BOOL restore
)
160 ShowWindow( hwnd
, restore
? SW_RESTORE
: SW_SHOWMINIMIZED
);
164 /***********************************************************************
165 * GetWindowRect (USER32.@)
167 BOOL WINAPI
GetWindowRect( HWND hwnd
, LPRECT rect
)
169 BOOL ret
= WIN_GetRectangles( hwnd
, rect
, NULL
);
172 MapWindowPoints( GetAncestor( hwnd
, GA_PARENT
), 0, (POINT
*)rect
, 2 );
173 TRACE( "hwnd %p (%s)\n", hwnd
, wine_dbgstr_rect(rect
) );
179 /***********************************************************************
180 * GetWindowRgn (USER32.@)
182 int WINAPI
GetWindowRgn ( HWND hwnd
, HRGN hrgn
)
192 if (!(data
= HeapAlloc( GetProcessHeap(), 0, sizeof(*data
) + size
- 1 )))
194 SetLastError( ERROR_OUTOFMEMORY
);
197 SERVER_START_REQ( get_window_region
)
200 wine_server_set_reply( req
, data
->Buffer
, size
);
201 if (!(status
= wine_server_call( req
)))
203 size_t reply_size
= wine_server_reply_size( reply
);
206 data
->rdh
.dwSize
= sizeof(data
->rdh
);
207 data
->rdh
.iType
= RDH_RECTANGLES
;
208 data
->rdh
.nCount
= reply_size
/ sizeof(RECT
);
209 data
->rdh
.nRgnSize
= reply_size
;
210 win_rgn
= ExtCreateRegion( NULL
, size
, data
);
213 else size
= reply
->total_size
;
216 HeapFree( GetProcessHeap(), 0, data
);
217 } while (status
== STATUS_BUFFER_OVERFLOW
);
219 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
222 nRet
= CombineRgn( hrgn
, win_rgn
, 0, RGN_COPY
);
223 DeleteObject( win_rgn
);
229 /***********************************************************************
230 * SetWindowRgn (USER32.@)
232 int WINAPI
SetWindowRgn( HWND hwnd
, HRGN hrgn
, BOOL bRedraw
)
234 static const RECT empty_rect
;
242 if (!(size
= GetRegionData( hrgn
, 0, NULL
))) return FALSE
;
243 if (!(data
= HeapAlloc( GetProcessHeap(), 0, size
))) return FALSE
;
244 if (!GetRegionData( hrgn
, size
, data
))
246 HeapFree( GetProcessHeap(), 0, data
);
249 SERVER_START_REQ( set_window_region
)
252 req
->redraw
= (bRedraw
!= 0);
253 if (data
->rdh
.nCount
)
254 wine_server_add_data( req
, data
->Buffer
, data
->rdh
.nCount
* sizeof(RECT
) );
256 wine_server_add_data( req
, &empty_rect
, sizeof(empty_rect
) );
257 ret
= !wine_server_call_err( req
);
261 else /* clear existing region */
263 SERVER_START_REQ( set_window_region
)
266 req
->redraw
= (bRedraw
!= 0);
267 ret
= !wine_server_call_err( req
);
272 if (ret
) ret
= USER_Driver
->pSetWindowRgn( hwnd
, hrgn
, bRedraw
);
276 UINT swp_flags
= SWP_NOSIZE
|SWP_NOMOVE
|SWP_NOZORDER
|SWP_NOACTIVATE
|SWP_FRAMECHANGED
|SWP_NOCLIENTSIZE
|SWP_NOCLIENTMOVE
;
277 if (!bRedraw
) swp_flags
|= SWP_NOREDRAW
;
278 SetWindowPos( hwnd
, 0, 0, 0, 0, 0, swp_flags
);
284 /***********************************************************************
285 * GetClientRect (USER32.@)
287 BOOL WINAPI
GetClientRect( HWND hwnd
, LPRECT rect
)
291 if ((ret
= WIN_GetRectangles( hwnd
, NULL
, rect
)))
293 rect
->right
-= rect
->left
;
294 rect
->bottom
-= rect
->top
;
295 rect
->left
= rect
->top
= 0;
301 /*******************************************************************
302 * ClientToScreen (USER32.@)
304 BOOL WINAPI
ClientToScreen( HWND hwnd
, LPPOINT lppnt
)
306 MapWindowPoints( hwnd
, 0, lppnt
, 1 );
311 /*******************************************************************
312 * ScreenToClient (USER32.@)
314 BOOL WINAPI
ScreenToClient( HWND hwnd
, LPPOINT lppnt
)
316 MapWindowPoints( 0, hwnd
, lppnt
, 1 );
321 /***********************************************************************
322 * list_children_from_point
324 * Get the list of children that can contain point from the server.
325 * Point is in screen coordinates.
326 * Returned list must be freed by caller.
328 static HWND
*list_children_from_point( HWND hwnd
, POINT pt
)
337 if (!(list
= HeapAlloc( GetProcessHeap(), 0, size
* sizeof(HWND
) ))) break;
339 SERVER_START_REQ( get_window_children_from_point
)
344 wine_server_set_reply( req
, list
, (size
-1) * sizeof(HWND
) );
345 if (!wine_server_call( req
)) count
= reply
->count
;
348 if (count
&& count
< size
)
353 HeapFree( GetProcessHeap(), 0, list
);
355 size
= count
+ 1; /* restart with a large enough buffer */
361 /***********************************************************************
362 * WINPOS_WindowFromPoint
364 * Find the window and hittest for a given point.
366 HWND
WINPOS_WindowFromPoint( HWND hwndScope
, POINT pt
, INT
*hittest
)
371 if (!hwndScope
) hwndScope
= GetDesktopWindow();
373 *hittest
= HTNOWHERE
;
375 if (!(list
= list_children_from_point( hwndScope
, pt
))) return 0;
377 /* now determine the hittest */
379 for (i
= 0; list
[i
]; i
++)
381 LONG style
= GetWindowLongW( list
[i
], GWL_STYLE
);
383 /* If window is minimized or disabled, return at once */
384 if (style
& WS_MINIMIZE
)
386 *hittest
= HTCAPTION
;
389 if (style
& WS_DISABLED
)
394 /* Send WM_NCCHITTEST (if same thread) */
395 if (!WIN_IsCurrentThread( list
[i
] ))
400 res
= SendMessageW( list
[i
], WM_NCHITTEST
, 0, MAKELONG(pt
.x
,pt
.y
) );
401 if (res
!= HTTRANSPARENT
)
403 *hittest
= res
; /* Found the window */
406 /* continue search with next window in z-order */
409 HeapFree( GetProcessHeap(), 0, list
);
410 TRACE( "scope %p (%d,%d) returning %p\n", hwndScope
, pt
.x
, pt
.y
, ret
);
415 /*******************************************************************
416 * WindowFromPoint (USER32.@)
418 HWND WINAPI
WindowFromPoint( POINT pt
)
421 return WINPOS_WindowFromPoint( 0, pt
, &hittest
);
425 /*******************************************************************
426 * ChildWindowFromPoint (USER32.@)
428 HWND WINAPI
ChildWindowFromPoint( HWND hwndParent
, POINT pt
)
430 return ChildWindowFromPointEx( hwndParent
, pt
, CWP_ALL
);
433 /*******************************************************************
434 * RealChildWindowFromPoint (USER32.@)
436 HWND WINAPI
RealChildWindowFromPoint( HWND hwndParent
, POINT pt
)
438 return ChildWindowFromPointEx( hwndParent
, pt
, CWP_SKIPTRANSPARENT
);
441 /*******************************************************************
442 * ChildWindowFromPointEx (USER32.@)
444 HWND WINAPI
ChildWindowFromPointEx( HWND hwndParent
, POINT pt
, UINT uFlags
)
446 /* pt is in the client coordinates */
452 GetClientRect( hwndParent
, &rect
);
453 if (!PtInRect( &rect
, pt
)) return 0;
454 if (!(list
= WIN_ListChildren( hwndParent
))) return hwndParent
;
456 for (i
= 0; list
[i
]; i
++)
458 if (!WIN_GetRectangles( list
[i
], &rect
, NULL
)) continue;
459 if (!PtInRect( &rect
, pt
)) continue;
460 if (uFlags
& (CWP_SKIPINVISIBLE
|CWP_SKIPDISABLED
))
462 LONG style
= GetWindowLongW( list
[i
], GWL_STYLE
);
463 if ((uFlags
& CWP_SKIPINVISIBLE
) && !(style
& WS_VISIBLE
)) continue;
464 if ((uFlags
& CWP_SKIPDISABLED
) && (style
& WS_DISABLED
)) continue;
466 if (uFlags
& CWP_SKIPTRANSPARENT
)
468 if (GetWindowLongW( list
[i
], GWL_EXSTYLE
) & WS_EX_TRANSPARENT
) continue;
473 HeapFree( GetProcessHeap(), 0, list
);
474 if (!retvalue
) retvalue
= hwndParent
;
479 /*******************************************************************
480 * WINPOS_GetWinOffset
482 * Calculate the offset between the origin of the two windows. Used
483 * to implement MapWindowPoints.
485 static void WINPOS_GetWinOffset( HWND hwndFrom
, HWND hwndTo
, POINT
*offset
)
489 offset
->x
= offset
->y
= 0;
491 /* Translate source window origin to screen coords */
494 HWND hwnd
= hwndFrom
;
498 if (hwnd
== hwndTo
) return;
499 if (!(wndPtr
= WIN_GetPtr( hwnd
)))
501 ERR( "bad hwndFrom = %p\n", hwnd
);
504 if (wndPtr
== WND_DESKTOP
) break;
505 if (wndPtr
== WND_OTHER_PROCESS
) goto other_process
;
506 offset
->x
+= wndPtr
->rectClient
.left
;
507 offset
->y
+= wndPtr
->rectClient
.top
;
508 hwnd
= wndPtr
->parent
;
509 WIN_ReleasePtr( wndPtr
);
513 /* Translate origin to destination window coords */
520 if (!(wndPtr
= WIN_GetPtr( hwnd
)))
522 ERR( "bad hwndTo = %p\n", hwnd
);
525 if (wndPtr
== WND_DESKTOP
) break;
526 if (wndPtr
== WND_OTHER_PROCESS
) goto other_process
;
527 offset
->x
-= wndPtr
->rectClient
.left
;
528 offset
->y
-= wndPtr
->rectClient
.top
;
529 hwnd
= wndPtr
->parent
;
530 WIN_ReleasePtr( wndPtr
);
535 other_process
: /* one of the parents may belong to another process, do it the hard way */
536 offset
->x
= offset
->y
= 0;
537 SERVER_START_REQ( get_windows_offset
)
539 req
->from
= hwndFrom
;
541 if (!wine_server_call( req
))
543 offset
->x
= reply
->x
;
544 offset
->y
= reply
->y
;
551 /*******************************************************************
552 * MapWindowPoints (USER.258)
554 void WINAPI
MapWindowPoints16( HWND16 hwndFrom
, HWND16 hwndTo
,
555 LPPOINT16 lppt
, UINT16 count
)
559 WINPOS_GetWinOffset( WIN_Handle32(hwndFrom
), WIN_Handle32(hwndTo
), &offset
);
569 /*******************************************************************
570 * MapWindowPoints (USER32.@)
572 INT WINAPI
MapWindowPoints( HWND hwndFrom
, HWND hwndTo
, LPPOINT lppt
, UINT count
)
576 WINPOS_GetWinOffset( hwndFrom
, hwndTo
, &offset
);
583 return MAKELONG( LOWORD(offset
.x
), LOWORD(offset
.y
) );
587 /***********************************************************************
588 * IsIconic (USER32.@)
590 BOOL WINAPI
IsIconic(HWND hWnd
)
592 return (GetWindowLongW( hWnd
, GWL_STYLE
) & WS_MINIMIZE
) != 0;
596 /***********************************************************************
597 * IsZoomed (USER32.@)
599 BOOL WINAPI
IsZoomed(HWND hWnd
)
601 return (GetWindowLongW( hWnd
, GWL_STYLE
) & WS_MAXIMIZE
) != 0;
605 /*******************************************************************
606 * AllowSetForegroundWindow (USER32.@)
608 BOOL WINAPI
AllowSetForegroundWindow( DWORD procid
)
610 /* FIXME: If Win98/2000 style SetForegroundWindow behavior is
611 * implemented, then fix this function. */
616 /*******************************************************************
617 * LockSetForegroundWindow (USER32.@)
619 BOOL WINAPI
LockSetForegroundWindow( UINT lockcode
)
621 /* FIXME: If Win98/2000 style SetForegroundWindow behavior is
622 * implemented, then fix this function. */
627 /***********************************************************************
628 * BringWindowToTop (USER32.@)
630 BOOL WINAPI
BringWindowToTop( HWND hwnd
)
632 return SetWindowPos( hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
636 /***********************************************************************
637 * MoveWindow (USER32.@)
639 BOOL WINAPI
MoveWindow( HWND hwnd
, INT x
, INT y
, INT cx
, INT cy
,
642 int flags
= SWP_NOZORDER
| SWP_NOACTIVATE
;
643 if (!repaint
) flags
|= SWP_NOREDRAW
;
644 TRACE("%p %d,%d %dx%d %d\n", hwnd
, x
, y
, cx
, cy
, repaint
);
645 return SetWindowPos( hwnd
, 0, x
, y
, cx
, cy
, flags
);
648 /***********************************************************************
649 * WINPOS_InitInternalPos
651 static LPINTERNALPOS
WINPOS_InitInternalPos( WND
* wnd
)
653 LPINTERNALPOS lpPos
= get_internal_pos( wnd
->hwndSelf
);
656 /* this happens when the window is minimized/maximized
657 * for the first time (rectWindow is not adjusted yet) */
659 lpPos
= HeapAlloc( GetProcessHeap(), 0, sizeof(INTERNALPOS
) );
660 if( !lpPos
) return NULL
;
662 set_internal_pos( wnd
->hwndSelf
, lpPos
);
663 lpPos
->hwndIconTitle
= 0; /* defer until needs to be shown */
664 lpPos
->rectNormal
.left
= wnd
->rectWindow
.left
;
665 lpPos
->rectNormal
.top
= wnd
->rectWindow
.top
;
666 lpPos
->rectNormal
.right
= wnd
->rectWindow
.right
;
667 lpPos
->rectNormal
.bottom
= wnd
->rectWindow
.bottom
;
668 lpPos
->ptIconPos
.x
= lpPos
->ptIconPos
.y
= -1;
669 lpPos
->ptMaxPos
.x
= lpPos
->ptMaxPos
.y
= -1;
672 if( wnd
->dwStyle
& WS_MINIMIZE
)
674 lpPos
->ptIconPos
.x
= wnd
->rectWindow
.left
;
675 lpPos
->ptIconPos
.y
= wnd
->rectWindow
.top
;
677 else if( wnd
->dwStyle
& WS_MAXIMIZE
)
679 lpPos
->ptMaxPos
.x
= wnd
->rectWindow
.left
;
680 lpPos
->ptMaxPos
.y
= wnd
->rectWindow
.top
;
684 lpPos
->rectNormal
.left
= wnd
->rectWindow
.left
;
685 lpPos
->rectNormal
.top
= wnd
->rectWindow
.top
;
686 lpPos
->rectNormal
.right
= wnd
->rectWindow
.right
;
687 lpPos
->rectNormal
.bottom
= wnd
->rectWindow
.bottom
;
692 /***********************************************************************
693 * WINPOS_RedrawIconTitle
695 BOOL
WINPOS_RedrawIconTitle( HWND hWnd
)
697 LPINTERNALPOS lpPos
= get_internal_pos( hWnd
);
700 if( lpPos
->hwndIconTitle
)
702 SendMessageW( lpPos
->hwndIconTitle
, WM_SHOWWINDOW
, TRUE
, 0);
703 InvalidateRect( lpPos
->hwndIconTitle
, NULL
, TRUE
);
710 /***********************************************************************
711 * WINPOS_ShowIconTitle
713 BOOL
WINPOS_ShowIconTitle( HWND hwnd
, BOOL bShow
)
715 LPINTERNALPOS lpPos
= get_internal_pos( hwnd
);
717 if (lpPos
&& !GetPropA( hwnd
, "__wine_x11_managed" ))
719 HWND title
= lpPos
->hwndIconTitle
;
721 TRACE("%p %i\n", hwnd
, (bShow
!= 0) );
724 lpPos
->hwndIconTitle
= title
= ICONTITLE_Create( hwnd
);
727 if (!IsWindowVisible(title
))
729 SendMessageW( title
, WM_SHOWWINDOW
, TRUE
, 0 );
730 SetWindowPos( title
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
|
731 SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_SHOWWINDOW
);
734 else ShowWindow( title
, SW_HIDE
);
739 /*******************************************************************
740 * WINPOS_GetMinMaxInfo
742 * Get the minimized and maximized information for a window.
744 void WINPOS_GetMinMaxInfo( HWND hwnd
, POINT
*maxSize
, POINT
*maxPos
,
745 POINT
*minTrack
, POINT
*maxTrack
)
751 LONG style
= GetWindowLongA( hwnd
, GWL_STYLE
);
752 LONG exstyle
= GetWindowLongA( hwnd
, GWL_EXSTYLE
);
755 /* Compute default values */
757 GetWindowRect(hwnd
, &rc
);
758 MinMax
.ptReserved
.x
= rc
.left
;
759 MinMax
.ptReserved
.y
= rc
.top
;
761 if (style
& WS_CHILD
)
763 if ((style
& WS_CAPTION
) == WS_CAPTION
)
764 style
&= ~WS_BORDER
; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
766 GetClientRect(GetAncestor(hwnd
,GA_PARENT
), &rc
);
767 AdjustWindowRectEx(&rc
, style
, ((style
& WS_POPUP
) && GetMenu(hwnd
)), exstyle
);
769 /* avoid calculating this twice */
770 style
&= ~(WS_DLGFRAME
| WS_BORDER
| WS_THICKFRAME
);
772 MinMax
.ptMaxSize
.x
= rc
.right
- rc
.left
;
773 MinMax
.ptMaxSize
.y
= rc
.bottom
- rc
.top
;
777 MinMax
.ptMaxSize
.x
= GetSystemMetrics(SM_CXSCREEN
);
778 MinMax
.ptMaxSize
.y
= GetSystemMetrics(SM_CYSCREEN
);
780 MinMax
.ptMinTrackSize
.x
= GetSystemMetrics(SM_CXMINTRACK
);
781 MinMax
.ptMinTrackSize
.y
= GetSystemMetrics(SM_CYMINTRACK
);
782 MinMax
.ptMaxTrackSize
.x
= GetSystemMetrics(SM_CXMAXTRACK
);
783 MinMax
.ptMaxTrackSize
.y
= GetSystemMetrics(SM_CYMAXTRACK
);
785 if (HAS_DLGFRAME( style
, exstyle
))
787 xinc
= GetSystemMetrics(SM_CXDLGFRAME
);
788 yinc
= GetSystemMetrics(SM_CYDLGFRAME
);
793 if (HAS_THICKFRAME(style
))
795 xinc
+= GetSystemMetrics(SM_CXFRAME
);
796 yinc
+= GetSystemMetrics(SM_CYFRAME
);
798 if (style
& WS_BORDER
)
800 xinc
+= GetSystemMetrics(SM_CXBORDER
);
801 yinc
+= GetSystemMetrics(SM_CYBORDER
);
804 MinMax
.ptMaxSize
.x
+= 2 * xinc
;
805 MinMax
.ptMaxSize
.y
+= 2 * yinc
;
807 lpPos
= get_internal_pos( hwnd
);
808 if( lpPos
&& !EMPTYPOINT(lpPos
->ptMaxPos
) )
810 MinMax
.ptMaxPosition
.x
= lpPos
->ptMaxPos
.x
;
811 MinMax
.ptMaxPosition
.y
= lpPos
->ptMaxPos
.y
;
815 MinMax
.ptMaxPosition
.x
= -xinc
;
816 MinMax
.ptMaxPosition
.y
= -yinc
;
819 SendMessageW( hwnd
, WM_GETMINMAXINFO
, 0, (LPARAM
)&MinMax
);
821 /* if the app didn't change the values, adapt them for the current monitor */
823 if ((monitor
= MonitorFromWindow( hwnd
, MONITOR_DEFAULTTOPRIMARY
)))
825 MONITORINFO mon_info
;
827 mon_info
.cbSize
= sizeof(mon_info
);
828 GetMonitorInfoW( monitor
, &mon_info
);
830 if (MinMax
.ptMaxSize
.x
== GetSystemMetrics(SM_CXSCREEN
) + 2 * xinc
&&
831 MinMax
.ptMaxSize
.y
== GetSystemMetrics(SM_CYSCREEN
) + 2 * yinc
)
833 MinMax
.ptMaxSize
.x
= (mon_info
.rcWork
.right
- mon_info
.rcWork
.left
) + 2 * xinc
;
834 MinMax
.ptMaxSize
.y
= (mon_info
.rcWork
.bottom
- mon_info
.rcWork
.top
) + 2 * yinc
;
836 if (MinMax
.ptMaxPosition
.x
== -xinc
&& MinMax
.ptMaxPosition
.y
== -yinc
)
838 MinMax
.ptMaxPosition
.x
= mon_info
.rcWork
.left
- xinc
;
839 MinMax
.ptMaxPosition
.y
= mon_info
.rcWork
.top
- yinc
;
843 /* Some sanity checks */
845 TRACE("%d %d / %d %d / %d %d / %d %d\n",
846 MinMax
.ptMaxSize
.x
, MinMax
.ptMaxSize
.y
,
847 MinMax
.ptMaxPosition
.x
, MinMax
.ptMaxPosition
.y
,
848 MinMax
.ptMaxTrackSize
.x
, MinMax
.ptMaxTrackSize
.y
,
849 MinMax
.ptMinTrackSize
.x
, MinMax
.ptMinTrackSize
.y
);
850 MinMax
.ptMaxTrackSize
.x
= max( MinMax
.ptMaxTrackSize
.x
,
851 MinMax
.ptMinTrackSize
.x
);
852 MinMax
.ptMaxTrackSize
.y
= max( MinMax
.ptMaxTrackSize
.y
,
853 MinMax
.ptMinTrackSize
.y
);
855 if (maxSize
) *maxSize
= MinMax
.ptMaxSize
;
856 if (maxPos
) *maxPos
= MinMax
.ptMaxPosition
;
857 if (minTrack
) *minTrack
= MinMax
.ptMinTrackSize
;
858 if (maxTrack
) *maxTrack
= MinMax
.ptMaxTrackSize
;
861 /***********************************************************************
862 * ShowWindowAsync (USER32.@)
864 * doesn't wait; returns immediately.
865 * used by threads to toggle windows in other (possibly hanging) threads
867 BOOL WINAPI
ShowWindowAsync( HWND hwnd
, INT cmd
)
871 if (is_broadcast(hwnd
))
873 SetLastError( ERROR_INVALID_PARAMETER
);
877 if ((full_handle
= WIN_IsCurrentThread( hwnd
)))
878 return USER_Driver
->pShowWindow( full_handle
, cmd
);
880 return SendNotifyMessageW( hwnd
, WM_WINE_SHOWWINDOW
, cmd
, 0 );
884 /***********************************************************************
885 * ShowWindow (USER32.@)
887 BOOL WINAPI
ShowWindow( HWND hwnd
, INT cmd
)
891 if (is_broadcast(hwnd
))
893 SetLastError( ERROR_INVALID_PARAMETER
);
896 if ((full_handle
= WIN_IsCurrentThread( hwnd
)))
897 return USER_Driver
->pShowWindow( full_handle
, cmd
);
899 return SendMessageW( hwnd
, WM_WINE_SHOWWINDOW
, cmd
, 0 );
903 /***********************************************************************
904 * GetInternalWindowPos (USER32.@)
906 UINT WINAPI
GetInternalWindowPos( HWND hwnd
, LPRECT rectWnd
,
909 WINDOWPLACEMENT wndpl
;
910 if (GetWindowPlacement( hwnd
, &wndpl
))
912 if (rectWnd
) *rectWnd
= wndpl
.rcNormalPosition
;
913 if (ptIcon
) *ptIcon
= wndpl
.ptMinPosition
;
914 return wndpl
.showCmd
;
920 /***********************************************************************
921 * GetWindowPlacement (USER32.@)
924 * Fails if wndpl->length of Win95 (!) apps is invalid.
926 BOOL WINAPI
GetWindowPlacement( HWND hwnd
, WINDOWPLACEMENT
*wndpl
)
928 WND
*pWnd
= WIN_GetPtr( hwnd
);
931 if (!pWnd
|| pWnd
== WND_DESKTOP
) return FALSE
;
932 if (pWnd
== WND_OTHER_PROCESS
)
934 if (IsWindow( hwnd
)) FIXME( "not supported on other process window %p\n", hwnd
);
938 lpPos
= WINPOS_InitInternalPos( pWnd
);
939 wndpl
->length
= sizeof(*wndpl
);
940 if( pWnd
->dwStyle
& WS_MINIMIZE
)
941 wndpl
->showCmd
= SW_SHOWMINIMIZED
;
943 wndpl
->showCmd
= ( pWnd
->dwStyle
& WS_MAXIMIZE
) ? SW_SHOWMAXIMIZED
: SW_SHOWNORMAL
;
944 if( pWnd
->flags
& WIN_RESTORE_MAX
)
945 wndpl
->flags
= WPF_RESTORETOMAXIMIZED
;
948 wndpl
->ptMinPosition
.x
= lpPos
->ptIconPos
.x
;
949 wndpl
->ptMinPosition
.y
= lpPos
->ptIconPos
.y
;
950 wndpl
->ptMaxPosition
.x
= lpPos
->ptMaxPos
.x
;
951 wndpl
->ptMaxPosition
.y
= lpPos
->ptMaxPos
.y
;
952 wndpl
->rcNormalPosition
.left
= lpPos
->rectNormal
.left
;
953 wndpl
->rcNormalPosition
.top
= lpPos
->rectNormal
.top
;
954 wndpl
->rcNormalPosition
.right
= lpPos
->rectNormal
.right
;
955 wndpl
->rcNormalPosition
.bottom
= lpPos
->rectNormal
.bottom
;
956 WIN_ReleasePtr( pWnd
);
961 /***********************************************************************
962 * WINPOS_SetPlacement
964 static BOOL
WINPOS_SetPlacement( HWND hwnd
, const WINDOWPLACEMENT
*wndpl
, UINT flags
)
968 WND
*pWnd
= WIN_GetPtr( hwnd
);
970 if (!pWnd
|| pWnd
== WND_OTHER_PROCESS
|| pWnd
== WND_DESKTOP
) return FALSE
;
971 lpPos
= WINPOS_InitInternalPos( pWnd
);
973 if( flags
& PLACE_MIN
)
975 lpPos
->ptIconPos
.x
= wndpl
->ptMinPosition
.x
;
976 lpPos
->ptIconPos
.y
= wndpl
->ptMinPosition
.y
;
978 if( flags
& PLACE_MAX
)
980 lpPos
->ptMaxPos
.x
= wndpl
->ptMaxPosition
.x
;
981 lpPos
->ptMaxPos
.y
= wndpl
->ptMaxPosition
.y
;
983 if( flags
& PLACE_RECT
)
985 lpPos
->rectNormal
.left
= wndpl
->rcNormalPosition
.left
;
986 lpPos
->rectNormal
.top
= wndpl
->rcNormalPosition
.top
;
987 lpPos
->rectNormal
.right
= wndpl
->rcNormalPosition
.right
;
988 lpPos
->rectNormal
.bottom
= wndpl
->rcNormalPosition
.bottom
;
991 style
= pWnd
->dwStyle
;
992 WIN_ReleasePtr( pWnd
);
994 if( style
& WS_MINIMIZE
)
996 WINPOS_ShowIconTitle( hwnd
, FALSE
);
997 if( wndpl
->flags
& WPF_SETMINPOSITION
&& !EMPTYPOINT(lpPos
->ptIconPos
))
998 SetWindowPos( hwnd
, 0, lpPos
->ptIconPos
.x
, lpPos
->ptIconPos
.y
,
999 0, 0, SWP_NOSIZE
| SWP_NOZORDER
| SWP_NOACTIVATE
);
1001 else if( style
& WS_MAXIMIZE
)
1003 if( !EMPTYPOINT(lpPos
->ptMaxPos
) )
1004 SetWindowPos( hwnd
, 0, lpPos
->ptMaxPos
.x
, lpPos
->ptMaxPos
.y
,
1005 0, 0, SWP_NOSIZE
| SWP_NOZORDER
| SWP_NOACTIVATE
);
1007 else if( flags
& PLACE_RECT
)
1008 SetWindowPos( hwnd
, 0, lpPos
->rectNormal
.left
, lpPos
->rectNormal
.top
,
1009 lpPos
->rectNormal
.right
- lpPos
->rectNormal
.left
,
1010 lpPos
->rectNormal
.bottom
- lpPos
->rectNormal
.top
,
1011 SWP_NOZORDER
| SWP_NOACTIVATE
);
1013 ShowWindow( hwnd
, wndpl
->showCmd
);
1015 if (IsIconic( hwnd
))
1017 if (GetWindowLongW( hwnd
, GWL_STYLE
) & WS_VISIBLE
) WINPOS_ShowIconTitle( hwnd
, TRUE
);
1019 /* SDK: ...valid only the next time... */
1020 if( wndpl
->flags
& WPF_RESTORETOMAXIMIZED
)
1022 pWnd
= WIN_GetPtr( hwnd
);
1023 if (pWnd
&& pWnd
!= WND_OTHER_PROCESS
)
1025 pWnd
->flags
|= WIN_RESTORE_MAX
;
1026 WIN_ReleasePtr( pWnd
);
1034 /***********************************************************************
1035 * SetWindowPlacement (USER32.@)
1038 * Fails if wndpl->length of Win95 (!) apps is invalid.
1040 BOOL WINAPI
SetWindowPlacement( HWND hwnd
, const WINDOWPLACEMENT
*wpl
)
1042 if (!wpl
) return FALSE
;
1043 return WINPOS_SetPlacement( hwnd
, wpl
, PLACE_MIN
| PLACE_MAX
| PLACE_RECT
);
1047 /***********************************************************************
1048 * AnimateWindow (USER32.@)
1049 * Shows/Hides a window with an animation
1052 BOOL WINAPI
AnimateWindow(HWND hwnd
, DWORD dwTime
, DWORD dwFlags
)
1054 FIXME("partial stub\n");
1056 /* If trying to show/hide and it's already *
1057 * shown/hidden or invalid window, fail with *
1058 * invalid parameter */
1059 if(!IsWindow(hwnd
) ||
1060 (IsWindowVisible(hwnd
) && !(dwFlags
& AW_HIDE
)) ||
1061 (!IsWindowVisible(hwnd
) && (dwFlags
& AW_HIDE
)))
1063 SetLastError(ERROR_INVALID_PARAMETER
);
1067 ShowWindow(hwnd
, (dwFlags
& AW_HIDE
) ? SW_HIDE
: ((dwFlags
& AW_ACTIVATE
) ? SW_SHOW
: SW_SHOWNA
));
1072 /***********************************************************************
1073 * SetInternalWindowPos (USER32.@)
1075 void WINAPI
SetInternalWindowPos( HWND hwnd
, UINT showCmd
,
1076 LPRECT rect
, LPPOINT pt
)
1078 if( IsWindow(hwnd
) )
1080 WINDOWPLACEMENT wndpl
;
1083 wndpl
.length
= sizeof(wndpl
);
1084 wndpl
.showCmd
= showCmd
;
1085 wndpl
.flags
= flags
= 0;
1090 wndpl
.flags
|= WPF_SETMINPOSITION
;
1091 wndpl
.ptMinPosition
= *pt
;
1095 flags
|= PLACE_RECT
;
1096 wndpl
.rcNormalPosition
= *rect
;
1098 WINPOS_SetPlacement( hwnd
, &wndpl
, flags
);
1103 /*******************************************************************
1104 * can_activate_window
1106 * Check if we can activate the specified window.
1108 static BOOL
can_activate_window( HWND hwnd
)
1112 if (!hwnd
) return FALSE
;
1113 style
= GetWindowLongW( hwnd
, GWL_STYLE
);
1114 if (!(style
& WS_VISIBLE
)) return FALSE
;
1115 if ((style
& (WS_POPUP
|WS_CHILD
)) == WS_CHILD
) return FALSE
;
1116 return !(style
& WS_DISABLED
);
1120 /*******************************************************************
1121 * WINPOS_ActivateOtherWindow
1123 * Activates window other than pWnd.
1125 void WINPOS_ActivateOtherWindow(HWND hwnd
)
1129 if ((GetWindowLongW( hwnd
, GWL_STYLE
) & WS_POPUP
) && (hwndTo
= GetWindow( hwnd
, GW_OWNER
)))
1131 hwndTo
= GetAncestor( hwndTo
, GA_ROOT
);
1132 if (can_activate_window( hwndTo
)) goto done
;
1138 if (!(hwndTo
= GetWindow( hwndTo
, GW_HWNDNEXT
))) break;
1139 if (can_activate_window( hwndTo
)) break;
1143 fg
= GetForegroundWindow();
1144 TRACE("win = %p fg = %p\n", hwndTo
, fg
);
1145 if (!fg
|| (hwnd
== fg
))
1147 if (SetForegroundWindow( hwndTo
)) return;
1149 if (!SetActiveWindow( hwndTo
)) SetActiveWindow(0);
1153 /***********************************************************************
1154 * WINPOS_HandleWindowPosChanging
1156 * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
1158 LONG
WINPOS_HandleWindowPosChanging( HWND hwnd
, WINDOWPOS
*winpos
)
1160 POINT minTrack
, maxTrack
;
1161 LONG style
= GetWindowLongW( hwnd
, GWL_STYLE
);
1163 if (winpos
->flags
& SWP_NOSIZE
) return 0;
1164 if ((style
& WS_THICKFRAME
) || ((style
& (WS_POPUP
| WS_CHILD
)) == 0))
1166 WINPOS_GetMinMaxInfo( hwnd
, NULL
, NULL
, &minTrack
, &maxTrack
);
1167 if (winpos
->cx
> maxTrack
.x
) winpos
->cx
= maxTrack
.x
;
1168 if (winpos
->cy
> maxTrack
.y
) winpos
->cy
= maxTrack
.y
;
1169 if (!(style
& WS_MINIMIZE
))
1171 if (winpos
->cx
< minTrack
.x
) winpos
->cx
= minTrack
.x
;
1172 if (winpos
->cy
< minTrack
.y
) winpos
->cy
= minTrack
.y
;
1179 /***********************************************************************
1182 static void dump_winpos_flags(UINT flags
)
1185 if(flags
& SWP_NOSIZE
) TRACE(" SWP_NOSIZE");
1186 if(flags
& SWP_NOMOVE
) TRACE(" SWP_NOMOVE");
1187 if(flags
& SWP_NOZORDER
) TRACE(" SWP_NOZORDER");
1188 if(flags
& SWP_NOREDRAW
) TRACE(" SWP_NOREDRAW");
1189 if(flags
& SWP_NOACTIVATE
) TRACE(" SWP_NOACTIVATE");
1190 if(flags
& SWP_FRAMECHANGED
) TRACE(" SWP_FRAMECHANGED");
1191 if(flags
& SWP_SHOWWINDOW
) TRACE(" SWP_SHOWWINDOW");
1192 if(flags
& SWP_HIDEWINDOW
) TRACE(" SWP_HIDEWINDOW");
1193 if(flags
& SWP_NOCOPYBITS
) TRACE(" SWP_NOCOPYBITS");
1194 if(flags
& SWP_NOOWNERZORDER
) TRACE(" SWP_NOOWNERZORDER");
1195 if(flags
& SWP_NOSENDCHANGING
) TRACE(" SWP_NOSENDCHANGING");
1196 if(flags
& SWP_DEFERERASE
) TRACE(" SWP_DEFERERASE");
1197 if(flags
& SWP_ASYNCWINDOWPOS
) TRACE(" SWP_ASYNCWINDOWPOS");
1199 #define DUMPED_FLAGS \
1205 SWP_FRAMECHANGED | \
1209 SWP_NOOWNERZORDER | \
1210 SWP_NOSENDCHANGING | \
1214 if(flags
& ~DUMPED_FLAGS
) TRACE(" %08x", flags
& ~DUMPED_FLAGS
);
1219 /***********************************************************************
1220 * SWP_DoWinPosChanging
1222 static BOOL
SWP_DoWinPosChanging( WINDOWPOS
* pWinpos
, RECT
* pNewWindowRect
, RECT
* pNewClientRect
)
1226 /* Send WM_WINDOWPOSCHANGING message */
1228 if (!(pWinpos
->flags
& SWP_NOSENDCHANGING
))
1229 SendMessageW( pWinpos
->hwnd
, WM_WINDOWPOSCHANGING
, 0, (LPARAM
)pWinpos
);
1231 if (!(wndPtr
= WIN_GetPtr( pWinpos
->hwnd
)) ||
1232 wndPtr
== WND_OTHER_PROCESS
|| wndPtr
== WND_DESKTOP
) return FALSE
;
1234 /* Calculate new position and size */
1236 *pNewWindowRect
= wndPtr
->rectWindow
;
1237 *pNewClientRect
= (wndPtr
->dwStyle
& WS_MINIMIZE
) ? wndPtr
->rectWindow
1238 : wndPtr
->rectClient
;
1240 if (!(pWinpos
->flags
& SWP_NOSIZE
))
1242 pNewWindowRect
->right
= pNewWindowRect
->left
+ pWinpos
->cx
;
1243 pNewWindowRect
->bottom
= pNewWindowRect
->top
+ pWinpos
->cy
;
1245 if (!(pWinpos
->flags
& SWP_NOMOVE
))
1247 pNewWindowRect
->left
= pWinpos
->x
;
1248 pNewWindowRect
->top
= pWinpos
->y
;
1249 pNewWindowRect
->right
+= pWinpos
->x
- wndPtr
->rectWindow
.left
;
1250 pNewWindowRect
->bottom
+= pWinpos
->y
- wndPtr
->rectWindow
.top
;
1252 OffsetRect( pNewClientRect
, pWinpos
->x
- wndPtr
->rectWindow
.left
,
1253 pWinpos
->y
- wndPtr
->rectWindow
.top
);
1255 pWinpos
->flags
|= SWP_NOCLIENTMOVE
| SWP_NOCLIENTSIZE
;
1257 TRACE( "hwnd %p, after %p, swp %d,%d %dx%d flags %08x\n",
1258 pWinpos
->hwnd
, pWinpos
->hwndInsertAfter
, pWinpos
->x
, pWinpos
->y
,
1259 pWinpos
->cx
, pWinpos
->cy
, pWinpos
->flags
);
1260 TRACE( "current %s style %08x new %s\n",
1261 wine_dbgstr_rect( &wndPtr
->rectWindow
), wndPtr
->dwStyle
,
1262 wine_dbgstr_rect( pNewWindowRect
));
1264 WIN_ReleasePtr( wndPtr
);
1268 /***********************************************************************
1271 * Compute the valid rects from the old and new client rect and WVR_* flags.
1272 * Helper for WM_NCCALCSIZE handling.
1274 static inline void get_valid_rects( const RECT
*old_client
, const RECT
*new_client
, UINT flags
,
1279 if (flags
& WVR_REDRAW
)
1281 SetRectEmpty( &valid
[0] );
1282 SetRectEmpty( &valid
[1] );
1286 if (flags
& WVR_VALIDRECTS
)
1288 if (!IntersectRect( &valid
[0], &valid
[0], new_client
) ||
1289 !IntersectRect( &valid
[1], &valid
[1], old_client
))
1291 SetRectEmpty( &valid
[0] );
1292 SetRectEmpty( &valid
[1] );
1295 flags
= WVR_ALIGNLEFT
| WVR_ALIGNTOP
;
1299 valid
[0] = *new_client
;
1300 valid
[1] = *old_client
;
1303 /* make sure the rectangles have the same size */
1304 cx
= min( valid
[0].right
- valid
[0].left
, valid
[1].right
- valid
[1].left
);
1305 cy
= min( valid
[0].bottom
- valid
[0].top
, valid
[1].bottom
- valid
[1].top
);
1307 if (flags
& WVR_ALIGNBOTTOM
)
1309 valid
[0].top
= valid
[0].bottom
- cy
;
1310 valid
[1].top
= valid
[1].bottom
- cy
;
1314 valid
[0].bottom
= valid
[0].top
+ cy
;
1315 valid
[1].bottom
= valid
[1].top
+ cy
;
1317 if (flags
& WVR_ALIGNRIGHT
)
1319 valid
[0].left
= valid
[0].right
- cx
;
1320 valid
[1].left
= valid
[1].right
- cx
;
1324 valid
[0].right
= valid
[0].left
+ cx
;
1325 valid
[1].right
= valid
[1].left
+ cx
;
1329 struct move_owned_info
1335 static BOOL CALLBACK
move_owned_popups( HWND hwnd
, LPARAM lparam
)
1337 struct move_owned_info
*info
= (struct move_owned_info
*)lparam
;
1339 if (hwnd
== info
->owner
) return FALSE
;
1340 if ((GetWindowLongW( hwnd
, GWL_STYLE
) & WS_POPUP
) &&
1341 GetWindow( hwnd
, GW_OWNER
) == info
->owner
)
1343 SetWindowPos( hwnd
, info
->insert_after
, 0, 0, 0, 0,
1344 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
|
1345 SWP_NOSENDCHANGING
| SWP_DEFERERASE
);
1346 info
->insert_after
= hwnd
;
1351 /***********************************************************************
1354 * fix Z order taking into account owned popups -
1355 * basically we need to maintain them above the window that owns them
1357 * FIXME: hide/show owned popups when owner visibility changes.
1359 static HWND
SWP_DoOwnedPopups(HWND hwnd
, HWND hwndInsertAfter
)
1361 HWND owner
= GetWindow( hwnd
, GW_OWNER
);
1362 LONG style
= GetWindowLongW( hwnd
, GWL_STYLE
);
1363 struct move_owned_info info
;
1365 TRACE("(%p) hInsertAfter = %p\n", hwnd
, hwndInsertAfter
);
1367 if ((style
& WS_POPUP
) && owner
)
1369 /* make sure this popup stays above the owner */
1371 if (hwndInsertAfter
!= HWND_TOP
&& hwndInsertAfter
!= HWND_TOPMOST
)
1373 HWND hwndLocalPrev
= HWND_TOP
;
1374 HWND prev
= GetWindow( owner
, GW_HWNDPREV
);
1376 while (prev
&& prev
!= hwndInsertAfter
)
1378 if (hwndLocalPrev
== HWND_TOP
&& GetWindowLongW( prev
, GWL_STYLE
) & WS_VISIBLE
)
1379 hwndLocalPrev
= prev
;
1380 prev
= GetWindow( prev
, GW_HWNDPREV
);
1382 if (!prev
) hwndInsertAfter
= hwndLocalPrev
;
1385 else if (style
& WS_CHILD
) return hwndInsertAfter
;
1388 info
.insert_after
= hwndInsertAfter
;
1389 EnumWindows( move_owned_popups
, (LPARAM
)&info
);
1390 return info
.insert_after
;
1393 /***********************************************************************
1396 static UINT
SWP_DoNCCalcSize( WINDOWPOS
* pWinpos
, const RECT
* pNewWindowRect
, RECT
* pNewClientRect
,
1402 if (!(wndPtr
= WIN_GetPtr( pWinpos
->hwnd
)) || wndPtr
== WND_OTHER_PROCESS
) return 0;
1404 /* Send WM_NCCALCSIZE message to get new client area */
1405 if( (pWinpos
->flags
& (SWP_FRAMECHANGED
| SWP_NOSIZE
)) != SWP_NOSIZE
)
1407 NCCALCSIZE_PARAMS params
;
1408 WINDOWPOS winposCopy
;
1410 params
.rgrc
[0] = *pNewWindowRect
;
1411 params
.rgrc
[1] = wndPtr
->rectWindow
;
1412 params
.rgrc
[2] = wndPtr
->rectClient
;
1413 params
.lppos
= &winposCopy
;
1414 winposCopy
= *pWinpos
;
1415 WIN_ReleasePtr( wndPtr
);
1417 wvrFlags
= SendMessageW( pWinpos
->hwnd
, WM_NCCALCSIZE
, TRUE
, (LPARAM
)¶ms
);
1419 *pNewClientRect
= params
.rgrc
[0];
1421 if (!(wndPtr
= WIN_GetPtr( pWinpos
->hwnd
)) || wndPtr
== WND_OTHER_PROCESS
) return 0;
1423 TRACE( "hwnd %p old win %s old client %s new win %s new client %s\n", pWinpos
->hwnd
,
1424 wine_dbgstr_rect(&wndPtr
->rectWindow
), wine_dbgstr_rect(&wndPtr
->rectClient
),
1425 wine_dbgstr_rect(pNewWindowRect
), wine_dbgstr_rect(pNewClientRect
) );
1427 if( pNewClientRect
->left
!= wndPtr
->rectClient
.left
||
1428 pNewClientRect
->top
!= wndPtr
->rectClient
.top
)
1429 pWinpos
->flags
&= ~SWP_NOCLIENTMOVE
;
1431 if( (pNewClientRect
->right
- pNewClientRect
->left
!=
1432 wndPtr
->rectClient
.right
- wndPtr
->rectClient
.left
))
1433 pWinpos
->flags
&= ~SWP_NOCLIENTSIZE
;
1435 wvrFlags
&= ~WVR_HREDRAW
;
1437 if (pNewClientRect
->bottom
- pNewClientRect
->top
!=
1438 wndPtr
->rectClient
.bottom
- wndPtr
->rectClient
.top
)
1439 pWinpos
->flags
&= ~SWP_NOCLIENTSIZE
;
1441 wvrFlags
&= ~WVR_VREDRAW
;
1443 validRects
[0] = params
.rgrc
[1];
1444 validRects
[1] = params
.rgrc
[2];
1448 if (!(pWinpos
->flags
& SWP_NOMOVE
) &&
1449 (pNewClientRect
->left
!= wndPtr
->rectClient
.left
||
1450 pNewClientRect
->top
!= wndPtr
->rectClient
.top
))
1451 pWinpos
->flags
&= ~SWP_NOCLIENTMOVE
;
1454 if (pWinpos
->flags
& (SWP_NOCOPYBITS
| SWP_NOREDRAW
| SWP_SHOWWINDOW
| SWP_HIDEWINDOW
))
1456 SetRectEmpty( &validRects
[0] );
1457 SetRectEmpty( &validRects
[1] );
1459 else get_valid_rects( &wndPtr
->rectClient
, pNewClientRect
, wvrFlags
, validRects
);
1461 WIN_ReleasePtr( wndPtr
);
1465 /* fix redundant flags and values in the WINDOWPOS structure */
1466 static BOOL
fixup_flags( WINDOWPOS
*winpos
)
1469 WND
*wndPtr
= WIN_GetPtr( winpos
->hwnd
);
1472 if (!wndPtr
|| wndPtr
== WND_OTHER_PROCESS
)
1474 SetLastError( ERROR_INVALID_WINDOW_HANDLE
);
1477 winpos
->hwnd
= wndPtr
->hwndSelf
; /* make it a full handle */
1479 /* Finally make sure that all coordinates are valid */
1480 if (winpos
->x
< -32768) winpos
->x
= -32768;
1481 else if (winpos
->x
> 32767) winpos
->x
= 32767;
1482 if (winpos
->y
< -32768) winpos
->y
= -32768;
1483 else if (winpos
->y
> 32767) winpos
->y
= 32767;
1485 if (winpos
->cx
< 0) winpos
->cx
= 0;
1486 else if (winpos
->cx
> 32767) winpos
->cx
= 32767;
1487 if (winpos
->cy
< 0) winpos
->cy
= 0;
1488 else if (winpos
->cy
> 32767) winpos
->cy
= 32767;
1490 parent
= GetAncestor( winpos
->hwnd
, GA_PARENT
);
1491 if (!IsWindowVisible( parent
)) winpos
->flags
|= SWP_NOREDRAW
;
1493 if (wndPtr
->dwStyle
& WS_VISIBLE
) winpos
->flags
&= ~SWP_SHOWWINDOW
;
1496 winpos
->flags
&= ~SWP_HIDEWINDOW
;
1497 if (!(winpos
->flags
& SWP_SHOWWINDOW
)) winpos
->flags
|= SWP_NOREDRAW
;
1500 if ((wndPtr
->rectWindow
.right
- wndPtr
->rectWindow
.left
== winpos
->cx
) &&
1501 (wndPtr
->rectWindow
.bottom
- wndPtr
->rectWindow
.top
== winpos
->cy
))
1502 winpos
->flags
|= SWP_NOSIZE
; /* Already the right size */
1504 if ((wndPtr
->rectWindow
.left
== winpos
->x
) && (wndPtr
->rectWindow
.top
== winpos
->y
))
1505 winpos
->flags
|= SWP_NOMOVE
; /* Already the right position */
1507 if ((wndPtr
->dwStyle
& (WS_POPUP
| WS_CHILD
)) != WS_CHILD
)
1509 if (!(winpos
->flags
& (SWP_NOACTIVATE
|SWP_HIDEWINDOW
)) && /* Bring to the top when activating */
1510 (winpos
->flags
& SWP_NOZORDER
||
1511 (winpos
->hwndInsertAfter
!= HWND_TOPMOST
&& winpos
->hwndInsertAfter
!= HWND_NOTOPMOST
)))
1513 winpos
->flags
&= ~SWP_NOZORDER
;
1514 winpos
->hwndInsertAfter
= HWND_TOP
;
1518 /* Check hwndInsertAfter */
1519 if (winpos
->flags
& SWP_NOZORDER
) goto done
;
1521 /* fix sign extension */
1522 if (winpos
->hwndInsertAfter
== (HWND
)0xffff) winpos
->hwndInsertAfter
= HWND_TOPMOST
;
1523 else if (winpos
->hwndInsertAfter
== (HWND
)0xfffe) winpos
->hwndInsertAfter
= HWND_NOTOPMOST
;
1525 /* hwndInsertAfter must be a sibling of the window */
1526 if (winpos
->hwndInsertAfter
== HWND_TOP
)
1528 if (GetWindow(winpos
->hwnd
, GW_HWNDFIRST
) == winpos
->hwnd
)
1529 winpos
->flags
|= SWP_NOZORDER
;
1531 else if (winpos
->hwndInsertAfter
== HWND_BOTTOM
)
1533 if (!(wndPtr
->dwExStyle
& WS_EX_TOPMOST
) && GetWindow(winpos
->hwnd
, GW_HWNDLAST
) == winpos
->hwnd
)
1534 winpos
->flags
|= SWP_NOZORDER
;
1536 else if (winpos
->hwndInsertAfter
== HWND_TOPMOST
)
1538 if ((wndPtr
->dwExStyle
& WS_EX_TOPMOST
) && GetWindow(winpos
->hwnd
, GW_HWNDFIRST
) == winpos
->hwnd
)
1539 winpos
->flags
|= SWP_NOZORDER
;
1541 else if (winpos
->hwndInsertAfter
== HWND_NOTOPMOST
)
1543 if (!(wndPtr
->dwExStyle
& WS_EX_TOPMOST
))
1544 winpos
->flags
|= SWP_NOZORDER
;
1548 if (GetAncestor( winpos
->hwndInsertAfter
, GA_PARENT
) != parent
) ret
= FALSE
;
1551 /* don't need to change the Zorder of hwnd if it's already inserted
1552 * after hwndInsertAfter or when inserting hwnd after itself.
1554 if ((winpos
->hwnd
== winpos
->hwndInsertAfter
) ||
1555 (winpos
->hwnd
== GetWindow( winpos
->hwndInsertAfter
, GW_HWNDNEXT
)))
1556 winpos
->flags
|= SWP_NOZORDER
;
1560 WIN_ReleasePtr( wndPtr
);
1565 /***********************************************************************
1568 * Backend implementation of SetWindowPos.
1570 BOOL
set_window_pos( HWND hwnd
, HWND insert_after
, UINT swp_flags
,
1571 const RECT
*window_rect
, const RECT
*client_rect
, const RECT
*valid_rects
)
1577 if (!(win
= WIN_GetPtr( hwnd
))) return FALSE
;
1578 if (win
== WND_DESKTOP
|| win
== WND_OTHER_PROCESS
) return FALSE
;
1580 SERVER_START_REQ( set_window_pos
)
1583 req
->previous
= insert_after
;
1584 req
->flags
= swp_flags
;
1585 req
->window
.left
= window_rect
->left
;
1586 req
->window
.top
= window_rect
->top
;
1587 req
->window
.right
= window_rect
->right
;
1588 req
->window
.bottom
= window_rect
->bottom
;
1589 req
->client
.left
= client_rect
->left
;
1590 req
->client
.top
= client_rect
->top
;
1591 req
->client
.right
= client_rect
->right
;
1592 req
->client
.bottom
= client_rect
->bottom
;
1593 if (!IsRectEmpty( &valid_rects
[0] ))
1594 wine_server_add_data( req
, valid_rects
, 2 * sizeof(*valid_rects
) );
1595 if ((ret
= !wine_server_call( req
)))
1597 win
->dwStyle
= reply
->new_style
;
1598 win
->dwExStyle
= reply
->new_ex_style
;
1599 win
->rectWindow
= *window_rect
;
1600 win
->rectClient
= *client_rect
;
1601 visible_rect
.left
= reply
->visible
.left
;
1602 visible_rect
.top
= reply
->visible
.top
;
1603 visible_rect
.right
= reply
->visible
.right
;
1604 visible_rect
.bottom
= reply
->visible
.bottom
;
1608 WIN_ReleasePtr( win
);
1611 USER_Driver
->pSetWindowPos( hwnd
, insert_after
, swp_flags
, window_rect
,
1612 client_rect
, &visible_rect
, valid_rects
);
1617 /***********************************************************************
1620 * User32 internal function
1622 BOOL
USER_SetWindowPos( WINDOWPOS
* winpos
)
1624 RECT newWindowRect
, newClientRect
, valid_rects
[2];
1627 orig_flags
= winpos
->flags
;
1629 /* First make sure that coordinates are valid for WM_WINDOWPOSCHANGING */
1630 if (!(winpos
->flags
& SWP_NOMOVE
))
1632 if (winpos
->x
< -32768) winpos
->x
= -32768;
1633 else if (winpos
->x
> 32767) winpos
->x
= 32767;
1634 if (winpos
->y
< -32768) winpos
->y
= -32768;
1635 else if (winpos
->y
> 32767) winpos
->y
= 32767;
1637 if (!(winpos
->flags
& SWP_NOSIZE
))
1639 if (winpos
->cx
< 0) winpos
->cx
= 0;
1640 else if (winpos
->cx
> 32767) winpos
->cx
= 32767;
1641 if (winpos
->cy
< 0) winpos
->cy
= 0;
1642 else if (winpos
->cy
> 32767) winpos
->cy
= 32767;
1645 if (!SWP_DoWinPosChanging( winpos
, &newWindowRect
, &newClientRect
)) return FALSE
;
1647 /* Fix redundant flags */
1648 if (!fixup_flags( winpos
)) return FALSE
;
1650 if((winpos
->flags
& (SWP_NOZORDER
| SWP_HIDEWINDOW
| SWP_SHOWWINDOW
)) != SWP_NOZORDER
)
1652 if (GetAncestor( winpos
->hwnd
, GA_PARENT
) == GetDesktopWindow())
1653 winpos
->hwndInsertAfter
= SWP_DoOwnedPopups( winpos
->hwnd
, winpos
->hwndInsertAfter
);
1656 /* Common operations */
1658 SWP_DoNCCalcSize( winpos
, &newWindowRect
, &newClientRect
, valid_rects
);
1660 if (!set_window_pos( winpos
->hwnd
, winpos
->hwndInsertAfter
, orig_flags
,
1661 &newWindowRect
, &newClientRect
, valid_rects
))
1664 /* erase parent when hiding or resizing child */
1665 if (!(orig_flags
& SWP_DEFERERASE
) &&
1666 ((orig_flags
& SWP_HIDEWINDOW
) ||
1667 (!(orig_flags
& SWP_SHOWWINDOW
) &&
1668 (winpos
->flags
& SWP_AGG_STATUSFLAGS
) != SWP_AGG_NOGEOMETRYCHANGE
)))
1670 HWND parent
= GetAncestor( winpos
->hwnd
, GA_PARENT
);
1671 if (!parent
|| parent
== GetDesktopWindow()) parent
= winpos
->hwnd
;
1672 erase_now( parent
, 0 );
1675 if( winpos
->flags
& SWP_HIDEWINDOW
)
1676 HideCaret(winpos
->hwnd
);
1677 else if (winpos
->flags
& SWP_SHOWWINDOW
)
1678 ShowCaret(winpos
->hwnd
);
1680 if (!(winpos
->flags
& (SWP_NOACTIVATE
|SWP_HIDEWINDOW
)))
1682 /* child windows get WM_CHILDACTIVATE message */
1683 if ((GetWindowLongW( winpos
->hwnd
, GWL_STYLE
) & (WS_CHILD
| WS_POPUP
)) == WS_CHILD
)
1684 SendMessageW( winpos
->hwnd
, WM_CHILDACTIVATE
, 0, 0 );
1686 SetForegroundWindow( winpos
->hwnd
);
1689 /* And last, send the WM_WINDOWPOSCHANGED message */
1691 TRACE("\tstatus flags = %04x\n", winpos
->flags
& SWP_AGG_STATUSFLAGS
);
1693 if (((winpos
->flags
& SWP_AGG_STATUSFLAGS
) != SWP_AGG_NOPOSCHANGE
))
1695 /* WM_WINDOWPOSCHANGED is sent even if SWP_NOSENDCHANGING is set
1696 and always contains final window position.
1698 winpos
->x
= newWindowRect
.left
;
1699 winpos
->y
= newWindowRect
.top
;
1700 winpos
->cx
= newWindowRect
.right
- newWindowRect
.left
;
1701 winpos
->cy
= newWindowRect
.bottom
- newWindowRect
.top
;
1702 SendMessageW( winpos
->hwnd
, WM_WINDOWPOSCHANGED
, 0, (LPARAM
)winpos
);
1707 /***********************************************************************
1708 * SetWindowPos (USER32.@)
1710 BOOL WINAPI
SetWindowPos( HWND hwnd
, HWND hwndInsertAfter
,
1711 INT x
, INT y
, INT cx
, INT cy
, UINT flags
)
1715 TRACE("hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
1716 hwnd
, hwndInsertAfter
, x
, y
, cx
, cy
, flags
);
1717 if(TRACE_ON(win
)) dump_winpos_flags(flags
);
1719 if (is_broadcast(hwnd
))
1721 SetLastError( ERROR_INVALID_PARAMETER
);
1725 winpos
.hwnd
= WIN_GetFullHandle(hwnd
);
1726 winpos
.hwndInsertAfter
= WIN_GetFullHandle(hwndInsertAfter
);
1731 winpos
.flags
= flags
;
1733 if (WIN_IsCurrentThread( hwnd
))
1734 return USER_SetWindowPos(&winpos
);
1736 return SendMessageW( winpos
.hwnd
, WM_WINE_SETWINDOWPOS
, 0, (LPARAM
)&winpos
);
1740 /***********************************************************************
1741 * BeginDeferWindowPos (USER32.@)
1743 HDWP WINAPI
BeginDeferWindowPos( INT count
)
1748 TRACE("%d\n", count
);
1752 SetLastError(ERROR_INVALID_PARAMETER
);
1755 /* Windows allows zero count, in which case it allocates context for 8 moves */
1756 if (count
== 0) count
= 8;
1758 handle
= USER_HEAP_ALLOC( sizeof(DWP
) + (count
-1)*sizeof(WINDOWPOS
) );
1759 if (!handle
) return 0;
1760 pDWP
= (DWP
*) USER_HEAP_LIN_ADDR( handle
);
1761 pDWP
->actualCount
= 0;
1762 pDWP
->suggestedCount
= count
;
1764 pDWP
->wMagic
= DWP_MAGIC
;
1765 pDWP
->hwndParent
= 0;
1767 TRACE("returning hdwp %p\n", handle
);
1772 /***********************************************************************
1773 * DeferWindowPos (USER32.@)
1775 HDWP WINAPI
DeferWindowPos( HDWP hdwp
, HWND hwnd
, HWND hwndAfter
,
1776 INT x
, INT y
, INT cx
, INT cy
,
1781 HDWP newhdwp
= hdwp
,retvalue
;
1783 TRACE("hdwp %p, hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
1784 hdwp
, hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
1786 hwnd
= WIN_GetFullHandle( hwnd
);
1787 if (hwnd
== GetDesktopWindow()) return 0;
1789 if (!(pDWP
= USER_HEAP_LIN_ADDR( hdwp
))) return 0;
1793 for (i
= 0; i
< pDWP
->actualCount
; i
++)
1795 if (pDWP
->winPos
[i
].hwnd
== hwnd
)
1797 /* Merge with the other changes */
1798 if (!(flags
& SWP_NOZORDER
))
1800 pDWP
->winPos
[i
].hwndInsertAfter
= WIN_GetFullHandle(hwndAfter
);
1802 if (!(flags
& SWP_NOMOVE
))
1804 pDWP
->winPos
[i
].x
= x
;
1805 pDWP
->winPos
[i
].y
= y
;
1807 if (!(flags
& SWP_NOSIZE
))
1809 pDWP
->winPos
[i
].cx
= cx
;
1810 pDWP
->winPos
[i
].cy
= cy
;
1812 pDWP
->winPos
[i
].flags
&= flags
| ~(SWP_NOSIZE
| SWP_NOMOVE
|
1813 SWP_NOZORDER
| SWP_NOREDRAW
|
1814 SWP_NOACTIVATE
| SWP_NOCOPYBITS
|
1816 pDWP
->winPos
[i
].flags
|= flags
& (SWP_SHOWWINDOW
| SWP_HIDEWINDOW
|
1822 if (pDWP
->actualCount
>= pDWP
->suggestedCount
)
1824 newhdwp
= USER_HEAP_REALLOC( hdwp
,
1825 sizeof(DWP
) + pDWP
->suggestedCount
*sizeof(WINDOWPOS
) );
1831 pDWP
= (DWP
*) USER_HEAP_LIN_ADDR( newhdwp
);
1832 pDWP
->suggestedCount
++;
1834 pDWP
->winPos
[pDWP
->actualCount
].hwnd
= hwnd
;
1835 pDWP
->winPos
[pDWP
->actualCount
].hwndInsertAfter
= hwndAfter
;
1836 pDWP
->winPos
[pDWP
->actualCount
].x
= x
;
1837 pDWP
->winPos
[pDWP
->actualCount
].y
= y
;
1838 pDWP
->winPos
[pDWP
->actualCount
].cx
= cx
;
1839 pDWP
->winPos
[pDWP
->actualCount
].cy
= cy
;
1840 pDWP
->winPos
[pDWP
->actualCount
].flags
= flags
;
1841 pDWP
->actualCount
++;
1849 /***********************************************************************
1850 * EndDeferWindowPos (USER32.@)
1852 BOOL WINAPI
EndDeferWindowPos( HDWP hdwp
)
1859 TRACE("%p\n", hdwp
);
1861 pDWP
= (DWP
*) USER_HEAP_LIN_ADDR( hdwp
);
1862 if (!pDWP
) return FALSE
;
1863 for (i
= 0, winpos
= pDWP
->winPos
; i
< pDWP
->actualCount
; i
++, winpos
++)
1865 TRACE("hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
1866 winpos
->hwnd
, winpos
->hwndInsertAfter
, winpos
->x
, winpos
->y
,
1867 winpos
->cx
, winpos
->cy
, winpos
->flags
);
1869 if (!(res
= USER_SetWindowPos( winpos
))) break;
1871 USER_HEAP_FREE( hdwp
);
1876 /***********************************************************************
1877 * TileChildWindows (USER.199)
1879 void WINAPI
TileChildWindows16( HWND16 parent
, WORD action
)
1881 FIXME("(%04x, %d): stub\n", parent
, action
);
1884 /***********************************************************************
1885 * CascadeChildWindows (USER.198)
1887 void WINAPI
CascadeChildWindows16( HWND16 parent
, WORD action
)
1889 FIXME("(%04x, %d): stub\n", parent
, action
);