?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
services: Check for services without lpBinaryPathName in get_winedevice_process.
[wine.git] / dlls / user32 / winpos.c
blob2fa194fa1c582da86152801e1ca8832c08921297
1 /*
2 * Window position related functions.
3 *
4 * Copyright 1993, 1994, 1995 Alexandre Julliard
5 * 1995, 1996, 1999 Alex Korobka
6 *
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.
11 *
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.
16 *
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
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdarg.h>
26 #include <string.h>
27 #include "ntstatus.h"
28 #define WIN32_NO_STATUS
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wingdi.h"
32 #include "winerror.h"
33 #include "wine/server.h"
34 #include "controls.h"
35 #include "user_private.h"
36 #include "wine/gdi_driver.h"
37 #include "win.h"
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(win);
41
42 #define SWP_AGG_NOGEOMETRYCHANGE \
43 (SWP_NOSIZE | SWP_NOCLIENTSIZE | SWP_NOZORDER)
44 #define SWP_AGG_NOPOSCHANGE \
45 (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER)
46 #define SWP_AGG_STATUSFLAGS \
47 (SWP_AGG_NOPOSCHANGE | SWP_FRAMECHANGED | SWP_HIDEWINDOW | SWP_SHOWWINDOW)
48
49 #define HAS_DLGFRAME(style,exStyle) \
50 (((exStyle) & WS_EX_DLGMODALFRAME) || \
51 (((style) & WS_DLGFRAME) && !((style) & WS_BORDER)))
52
53 #define HAS_THICKFRAME(style) \
54 (((style) & WS_THICKFRAME) && \
55 !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
56
57 #define EMPTYPOINT(pt) ((pt).x == -1 && (pt).y == -1)
58
59 #define ON_LEFT_BORDER(hit) \
60 (((hit) == HTLEFT) || ((hit) == HTTOPLEFT) || ((hit) == HTBOTTOMLEFT))
61 #define ON_RIGHT_BORDER(hit) \
62 (((hit) == HTRIGHT) || ((hit) == HTTOPRIGHT) || ((hit) == HTBOTTOMRIGHT))
63 #define ON_TOP_BORDER(hit) \
64 (((hit) == HTTOP) || ((hit) == HTTOPLEFT) || ((hit) == HTTOPRIGHT))
65 #define ON_BOTTOM_BORDER(hit) \
66 (((hit) == HTBOTTOM) || ((hit) == HTBOTTOMLEFT) || ((hit) == HTBOTTOMRIGHT))
67
68 #define PLACE_MIN 0x0001
69 #define PLACE_MAX 0x0002
70 #define PLACE_RECT 0x0004
71
72 typedef struct
73 {
74 struct user_object obj;
75 INT actualCount;
76 INT suggestedCount;
77 HWND hwndParent;
78 WINDOWPOS *winPos;
79 } DWP;
80
81
82 /***********************************************************************
83 * SwitchToThisWindow (USER32.@)
84 */
85 void WINAPI SwitchToThisWindow( HWND hwnd, BOOL alt_tab )
86 {
87 if (IsIconic( hwnd )) ShowWindow( hwnd, SW_RESTORE );
88 else BringWindowToTop( hwnd );
89 }
90
91
92 /***********************************************************************
93 * GetWindowRect (USER32.@)
94 */
95 BOOL WINAPI GetWindowRect( HWND hwnd, LPRECT rect )
96 {
97 BOOL ret = WIN_GetRectangles( hwnd, COORDS_SCREEN, rect, NULL );
98 if (ret) TRACE( "hwnd %p %s\n", hwnd, wine_dbgstr_rect(rect) );
99 return ret;
100 }
101
102
103 /***********************************************************************
104 * GetWindowRgn (USER32.@)
105 */
106 int WINAPI GetWindowRgn ( HWND hwnd, HRGN hrgn )
107 {
108 int nRet = ERROR;
109 NTSTATUS status;
110 HRGN win_rgn = 0;
111 RGNDATA *data;
112 size_t size = 256;
113
114 do
115 {
116 if (!(data = HeapAlloc( GetProcessHeap(), 0, sizeof(*data) + size - 1 )))
117 {
118 SetLastError( ERROR_OUTOFMEMORY );
119 return ERROR;
120 }
121 SERVER_START_REQ( get_window_region )
122 {
123 req->window = wine_server_user_handle( hwnd );
124 wine_server_set_reply( req, data->Buffer, size );
125 if (!(status = wine_server_call( req )))
126 {
127 size_t reply_size = wine_server_reply_size( reply );
128 if (reply_size)
129 {
130 data->rdh.dwSize = sizeof(data->rdh);
131 data->rdh.iType = RDH_RECTANGLES;
132 data->rdh.nCount = reply_size / sizeof(RECT);
133 data->rdh.nRgnSize = reply_size;
134 win_rgn = ExtCreateRegion( NULL, data->rdh.dwSize + data->rdh.nRgnSize, data );
135 }
136 }
137 else size = reply->total_size;
138 }
139 SERVER_END_REQ;
140 HeapFree( GetProcessHeap(), 0, data );
141 } while (status == STATUS_BUFFER_OVERFLOW);
142
143 if (status) SetLastError( RtlNtStatusToDosError(status) );
144 else if (win_rgn)
145 {
146 nRet = CombineRgn( hrgn, win_rgn, 0, RGN_COPY );
147 DeleteObject( win_rgn );
148 }
149 return nRet;
150 }
151
152 /***********************************************************************
153 * GetWindowRgnBox (USER32.@)
154 */
155 int WINAPI GetWindowRgnBox( HWND hwnd, LPRECT prect )
156 {
157 int ret = ERROR;
158 HRGN hrgn;
159
160 if (!prect)
161 return ERROR;
162
163 if ((hrgn = CreateRectRgn(0, 0, 0, 0)))
164 {
165 if ((ret = GetWindowRgn( hwnd, hrgn )) != ERROR )
166 ret = GetRgnBox( hrgn, prect );
167 DeleteObject(hrgn);
168 }
169
170 return ret;
171 }
172
173 /***********************************************************************
174 * SetWindowRgn (USER32.@)
175 */
176 int WINAPI SetWindowRgn( HWND hwnd, HRGN hrgn, BOOL bRedraw )
177 {
178 static const RECT empty_rect;
179 BOOL ret;
180
181 if (hrgn)
182 {
183 RGNDATA *data;
184 DWORD size;
185
186 if (!(size = GetRegionData( hrgn, 0, NULL ))) return FALSE;
187 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
188 if (!GetRegionData( hrgn, size, data ))
189 {
190 HeapFree( GetProcessHeap(), 0, data );
191 return FALSE;
192 }
193 SERVER_START_REQ( set_window_region )
194 {
195 req->window = wine_server_user_handle( hwnd );
196 req->redraw = (bRedraw != 0);
197 if (data->rdh.nCount)
198 wine_server_add_data( req, data->Buffer, data->rdh.nCount * sizeof(RECT) );
199 else
200 wine_server_add_data( req, &empty_rect, sizeof(empty_rect) );
201 ret = !wine_server_call_err( req );
202 }
203 SERVER_END_REQ;
204 HeapFree( GetProcessHeap(), 0, data );
205 }
206 else /* clear existing region */
207 {
208 SERVER_START_REQ( set_window_region )
209 {
210 req->window = wine_server_user_handle( hwnd );
211 req->redraw = (bRedraw != 0);
212 ret = !wine_server_call_err( req );
213 }
214 SERVER_END_REQ;
215 }
216
217 if (ret)
218 {
219 UINT swp_flags = SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE;
220 if (!bRedraw) swp_flags |= SWP_NOREDRAW;
221 SetWindowPos( hwnd, 0, 0, 0, 0, 0, swp_flags );
222 USER_Driver->pSetWindowRgn( hwnd, hrgn, bRedraw );
223 if (hrgn) DeleteObject( hrgn );
224 }
225 return ret;
226 }
227
228
229 /***********************************************************************
230 * GetClientRect (USER32.@)
231 */
232 BOOL WINAPI GetClientRect( HWND hwnd, LPRECT rect )
233 {
234 return WIN_GetRectangles( hwnd, COORDS_CLIENT, NULL, rect );
235 }
236
237
238 /***********************************************************************
239 * list_children_from_point
240 *
241 * Get the list of children that can contain point from the server.
242 * Point is in screen coordinates.
243 * Returned list must be freed by caller.
244 */
245 static HWND *list_children_from_point( HWND hwnd, POINT pt )
246 {
247 HWND *list;
248 int i, size = 128;
249
250 for (;;)
251 {
252 int count = 0;
253
254 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) break;
255
256 SERVER_START_REQ( get_window_children_from_point )
257 {
258 req->parent = wine_server_user_handle( hwnd );
259 req->x = pt.x;
260 req->y = pt.y;
261 wine_server_set_reply( req, list, (size-1) * sizeof(user_handle_t) );
262 if (!wine_server_call( req )) count = reply->count;
263 }
264 SERVER_END_REQ;
265 if (count && count < size)
266 {
267 /* start from the end since HWND is potentially larger than user_handle_t */
268 for (i = count - 1; i >= 0; i--)
269 list[i] = wine_server_ptr_handle( ((user_handle_t *)list)[i] );
270 list[count] = 0;
271 return list;
272 }
273 HeapFree( GetProcessHeap(), 0, list );
274 if (!count) break;
275 size = count + 1; /* restart with a large enough buffer */
276 }
277 return NULL;
278 }
279
280
281 /***********************************************************************
282 * WINPOS_WindowFromPoint
283 *
284 * Find the window and hittest for a given point.
285 */
286 HWND WINPOS_WindowFromPoint( HWND hwndScope, POINT pt, INT *hittest )
287 {
288 int i, res;
289 HWND ret, *list;
290
291 if (!hwndScope) hwndScope = GetDesktopWindow();
292
293 *hittest = HTNOWHERE;
294
295 if (!(list = list_children_from_point( hwndScope, pt ))) return 0;
296
297 /* now determine the hittest */
298
299 for (i = 0; list[i]; i++)
300 {
301 LONG style = GetWindowLongW( list[i], GWL_STYLE );
302
303 /* If window is minimized or disabled, return at once */
304 if (style & WS_MINIMIZE)
305 {
306 *hittest = HTCAPTION;
307 break;
308 }
309 if (style & WS_DISABLED)
310 {
311 *hittest = HTERROR;
312 break;
313 }
314 /* Send WM_NCCHITTEST (if same thread) */
315 if (!WIN_IsCurrentThread( list[i] ))
316 {
317 *hittest = HTCLIENT;
318 break;
319 }
320 res = SendMessageW( list[i], WM_NCHITTEST, 0, MAKELONG(pt.x,pt.y) );
321 if (res != HTTRANSPARENT)
322 {
323 *hittest = res; /* Found the window */
324 break;
325 }
326 /* continue search with next window in z-order */
327 }
328 ret = list[i];
329 HeapFree( GetProcessHeap(), 0, list );
330 TRACE( "scope %p (%d,%d) returning %p\n", hwndScope, pt.x, pt.y, ret );
331 return ret;
332 }
333
334
335 /*******************************************************************
336 * WindowFromPoint (USER32.@)
337 */
338 HWND WINAPI WindowFromPoint( POINT pt )
339 {
340 INT hittest;
341 return WINPOS_WindowFromPoint( 0, pt, &hittest );
342 }
343
344
345 /*******************************************************************
346 * ChildWindowFromPoint (USER32.@)
347 */
348 HWND WINAPI ChildWindowFromPoint( HWND hwndParent, POINT pt )
349 {
350 return ChildWindowFromPointEx( hwndParent, pt, CWP_ALL );
351 }
352
353 /*******************************************************************
354 * RealChildWindowFromPoint (USER32.@)
355 */
356 HWND WINAPI RealChildWindowFromPoint( HWND hwndParent, POINT pt )
357 {
358 return ChildWindowFromPointEx( hwndParent, pt, CWP_SKIPTRANSPARENT | CWP_SKIPINVISIBLE );
359 }
360
361 /*******************************************************************
362 * ChildWindowFromPointEx (USER32.@)
363 */
364 HWND WINAPI ChildWindowFromPointEx( HWND hwndParent, POINT pt, UINT uFlags)
365 {
366 /* pt is in the client coordinates */
367 HWND *list;
368 int i;
369 RECT rect;
370 HWND retvalue;
371
372 GetClientRect( hwndParent, &rect );
373 if (!PtInRect( &rect, pt )) return 0;
374 if (!(list = WIN_ListChildren( hwndParent ))) return hwndParent;
375
376 for (i = 0; list[i]; i++)
377 {
378 if (!WIN_GetRectangles( list[i], COORDS_PARENT, &rect, NULL )) continue;
379 if (!PtInRect( &rect, pt )) continue;
380 if (uFlags & (CWP_SKIPINVISIBLE|CWP_SKIPDISABLED))
381 {
382 LONG style = GetWindowLongW( list[i], GWL_STYLE );
383 if ((uFlags & CWP_SKIPINVISIBLE) && !(style & WS_VISIBLE)) continue;
384 if ((uFlags & CWP_SKIPDISABLED) && (style & WS_DISABLED)) continue;
385 }
386 if (uFlags & CWP_SKIPTRANSPARENT)
387 {
388 if (GetWindowLongW( list[i], GWL_EXSTYLE ) & WS_EX_TRANSPARENT) continue;
389 }
390 break;
391 }
392 retvalue = list[i];
393 HeapFree( GetProcessHeap(), 0, list );
394 if (!retvalue) retvalue = hwndParent;
395 return retvalue;
396 }
397
398
399 /*******************************************************************
400 * WINPOS_GetWinOffset
401 *
402 * Calculate the offset between the origin of the two windows. Used
403 * to implement MapWindowPoints.
404 */
405 static BOOL WINPOS_GetWinOffset( HWND hwndFrom, HWND hwndTo, BOOL *mirrored, POINT *ret_offset )
406 {
407 WND * wndPtr;
408 POINT offset;
409 BOOL mirror_from, mirror_to, ret;
410 HWND hwnd;
411
412 offset.x = offset.y = 0;
413 *mirrored = mirror_from = mirror_to = FALSE;
414
415 /* Translate source window origin to screen coords */
416 if (hwndFrom)
417 {
418 if (!(wndPtr = WIN_GetPtr( hwndFrom )))
419 {
420 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
421 return FALSE;
422 }
423 if (wndPtr == WND_OTHER_PROCESS) goto other_process;
424 if (wndPtr != WND_DESKTOP)
425 {
426 if (wndPtr->dwExStyle & WS_EX_LAYOUTRTL)
427 {
428 mirror_from = TRUE;
429 offset.x += wndPtr->rectClient.right - wndPtr->rectClient.left;
430 }
431 while (wndPtr->parent)
432 {
433 offset.x += wndPtr->rectClient.left;
434 offset.y += wndPtr->rectClient.top;
435 hwnd = wndPtr->parent;
436 WIN_ReleasePtr( wndPtr );
437 if (!(wndPtr = WIN_GetPtr( hwnd ))) break;
438 if (wndPtr == WND_OTHER_PROCESS) goto other_process;
439 if (wndPtr == WND_DESKTOP) break;
440 if (wndPtr->flags & WIN_CHILDREN_MOVED)
441 {
442 WIN_ReleasePtr( wndPtr );
443 goto other_process;
444 }
445 }
446 if (wndPtr && wndPtr != WND_DESKTOP) WIN_ReleasePtr( wndPtr );
447 }
448 }
449
450 /* Translate origin to destination window coords */
451 if (hwndTo)
452 {
453 if (!(wndPtr = WIN_GetPtr( hwndTo )))
454 {
455 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
456 return FALSE;
457 }
458 if (wndPtr == WND_OTHER_PROCESS) goto other_process;
459 if (wndPtr != WND_DESKTOP)
460 {
461 if (wndPtr->dwExStyle & WS_EX_LAYOUTRTL)
462 {
463 mirror_to = TRUE;
464 offset.x -= wndPtr->rectClient.right - wndPtr->rectClient.left;
465 }
466 while (wndPtr->parent)
467 {
468 offset.x -= wndPtr->rectClient.left;
469 offset.y -= wndPtr->rectClient.top;
470 hwnd = wndPtr->parent;
471 WIN_ReleasePtr( wndPtr );
472 if (!(wndPtr = WIN_GetPtr( hwnd ))) break;
473 if (wndPtr == WND_OTHER_PROCESS) goto other_process;
474 if (wndPtr == WND_DESKTOP) break;
475 if (wndPtr->flags & WIN_CHILDREN_MOVED)
476 {
477 WIN_ReleasePtr( wndPtr );
478 goto other_process;
479 }
480 }
481 if (wndPtr && wndPtr != WND_DESKTOP) WIN_ReleasePtr( wndPtr );
482 }
483 }
484
485 *mirrored = mirror_from ^ mirror_to;
486 if (mirror_from) offset.x = -offset.x;
487 *ret_offset = offset;
488 return TRUE;
489
490 other_process: /* one of the parents may belong to another process, do it the hard way */
491 SERVER_START_REQ( get_windows_offset )
492 {
493 req->from = wine_server_user_handle( hwndFrom );
494 req->to = wine_server_user_handle( hwndTo );
495 if ((ret = !wine_server_call_err( req )))
496 {
497 ret_offset->x = reply->x;
498 ret_offset->y = reply->y;
499 *mirrored = reply->mirror;
500 }
501 }
502 SERVER_END_REQ;
503 return ret;
504 }
505
506 /* map coordinates of a window region */
507 void map_window_region( HWND from, HWND to, HRGN hrgn )
508 {
509 BOOL mirrored;
510 POINT offset;
511 UINT i, size;
512 RGNDATA *data;
513 HRGN new_rgn;
514 RECT *rect;
515
516 if (!WINPOS_GetWinOffset( from, to, &mirrored, &offset )) return;
517
518 if (!mirrored)
519 {
520 OffsetRgn( hrgn, offset.x, offset.y );
521 return;
522 }
523 if (!(size = GetRegionData( hrgn, 0, NULL ))) return;
524 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return;
525 GetRegionData( hrgn, size, data );
526 rect = (RECT *)data->Buffer;
527 for (i = 0; i < data->rdh.nCount; i++)
528 {
529 int tmp = -(rect[i].left + offset.x);
530 rect[i].left = -(rect[i].right + offset.x);
531 rect[i].right = tmp;
532 rect[i].top += offset.y;
533 rect[i].bottom += offset.y;
534 }
535 if ((new_rgn = ExtCreateRegion( NULL, data->rdh.dwSize + data->rdh.nRgnSize, data )))
536 {
537 CombineRgn( hrgn, new_rgn, 0, RGN_COPY );
538 DeleteObject( new_rgn );
539 }
540 HeapFree( GetProcessHeap(), 0, data );
541 }
542
543
544 /*******************************************************************
545 * MapWindowPoints (USER32.@)
546 */
547 INT WINAPI MapWindowPoints( HWND hwndFrom, HWND hwndTo, LPPOINT lppt, UINT count )
548 {
549 BOOL mirrored;
550 POINT offset;
551 UINT i;
552
553 if (!WINPOS_GetWinOffset( hwndFrom, hwndTo, &mirrored, &offset )) return 0;
554
555 for (i = 0; i < count; i++)
556 {
557 lppt[i].x += offset.x;
558 lppt[i].y += offset.y;
559 if (mirrored) lppt[i].x = -lppt[i].x;
560 }
561 if (mirrored && count == 2) /* special case for rectangle */
562 {
563 int tmp = lppt[0].x;
564 lppt[0].x = lppt[1].x;
565 lppt[1].x = tmp;
566 }
567 return MAKELONG( LOWORD(offset.x), LOWORD(offset.y) );
568 }
569
570
571 /*******************************************************************
572 * ClientToScreen (USER32.@)
573 */
574 BOOL WINAPI ClientToScreen( HWND hwnd, LPPOINT lppnt )
575 {
576 POINT offset;
577 BOOL mirrored;
578
579 if (!hwnd)
580 {
581 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
582 return FALSE;
583 }
584 if (!WINPOS_GetWinOffset( hwnd, 0, &mirrored, &offset )) return FALSE;
585 lppnt->x += offset.x;
586 lppnt->y += offset.y;
587 if (mirrored) lppnt->x = -lppnt->x;
588 return TRUE;
589 }
590
591
592 /*******************************************************************
593 * ScreenToClient (USER32.@)
594 */
595 BOOL WINAPI ScreenToClient( HWND hwnd, LPPOINT lppnt )
596 {
597 POINT offset;
598 BOOL mirrored;
599
600 if (!hwnd)
601 {
602 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
603 return FALSE;
604 }
605 if (!WINPOS_GetWinOffset( 0, hwnd, &mirrored, &offset )) return FALSE;
606 lppnt->x += offset.x;
607 lppnt->y += offset.y;
608 if (mirrored) lppnt->x = -lppnt->x;
609 return TRUE;
610 }
611
612
613 /***********************************************************************
614 * IsIconic (USER32.@)
615 */
616 BOOL WINAPI IsIconic(HWND hWnd)
617 {
618 return (GetWindowLongW( hWnd, GWL_STYLE ) & WS_MINIMIZE) != 0;
619 }
620
621
622 /***********************************************************************
623 * IsZoomed (USER32.@)
624 */
625 BOOL WINAPI IsZoomed(HWND hWnd)
626 {
627 return (GetWindowLongW( hWnd, GWL_STYLE ) & WS_MAXIMIZE) != 0;
628 }
629
630
631 /*******************************************************************
632 * AllowSetForegroundWindow (USER32.@)
633 */
634 BOOL WINAPI AllowSetForegroundWindow( DWORD procid )
635 {
636 /* FIXME: If Win98/2000 style SetForegroundWindow behavior is
637 * implemented, then fix this function. */
638 return TRUE;
639 }
640
641
642 /*******************************************************************
643 * LockSetForegroundWindow (USER32.@)
644 */
645 BOOL WINAPI LockSetForegroundWindow( UINT lockcode )
646 {
647 /* FIXME: If Win98/2000 style SetForegroundWindow behavior is
648 * implemented, then fix this function. */
649 return TRUE;
650 }
651
652
653 /***********************************************************************
654 * BringWindowToTop (USER32.@)
655 */
656 BOOL WINAPI BringWindowToTop( HWND hwnd )
657 {
658 return SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE );
659 }
660
661
662 /***********************************************************************
663 * MoveWindow (USER32.@)
664 */
665 BOOL WINAPI MoveWindow( HWND hwnd, INT x, INT y, INT cx, INT cy,
666 BOOL repaint )
667 {
668 int flags = SWP_NOZORDER | SWP_NOACTIVATE;
669 if (!repaint) flags |= SWP_NOREDRAW;
670 TRACE("%p %d,%d %dx%d %d\n", hwnd, x, y, cx, cy, repaint );
671 return SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
672 }
673
674
675 /***********************************************************************
676 * WINPOS_RedrawIconTitle
677 */
678 BOOL WINPOS_RedrawIconTitle( HWND hWnd )
679 {
680 HWND icon_title = 0;
681 WND *win = WIN_GetPtr( hWnd );
682
683 if (win && win != WND_OTHER_PROCESS && win != WND_DESKTOP)
684 {
685 icon_title = win->icon_title;
686 WIN_ReleasePtr( win );
687 }
688 if (!icon_title) return FALSE;
689 SendMessageW( icon_title, WM_SHOWWINDOW, TRUE, 0 );
690 InvalidateRect( icon_title, NULL, TRUE );
691 return TRUE;
692 }
693
694 /***********************************************************************
695 * WINPOS_ShowIconTitle
696 */
697 static void WINPOS_ShowIconTitle( HWND hwnd, BOOL bShow )
698 {
699 WND *win = WIN_GetPtr( hwnd );
700 HWND title = 0;
701
702 TRACE("%p %i\n", hwnd, (bShow != 0) );
703
704 if (!win || win == WND_OTHER_PROCESS || win == WND_DESKTOP) return;
705 if (win->rectWindow.left == -32000 || win->rectWindow.top == -32000)
706 {
707 TRACE( "not showing title for hidden icon %p\n", hwnd );
708 bShow = FALSE;
709 }
710 else title = win->icon_title;
711 WIN_ReleasePtr( win );
712
713 if (bShow)
714 {
715 if (!title)
716 {
717 title = ICONTITLE_Create( hwnd );
718 if (!(win = WIN_GetPtr( hwnd )) || win == WND_OTHER_PROCESS)
719 {
720 DestroyWindow( title );
721 return;
722 }
723 win->icon_title = title;
724 WIN_ReleasePtr( win );
725 }
726 if (!IsWindowVisible(title))
727 {
728 SendMessageW( title, WM_SHOWWINDOW, TRUE, 0 );
729 SetWindowPos( title, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE |
730 SWP_NOACTIVATE | SWP_NOZORDER | SWP_SHOWWINDOW );
731 }
732 }
733 else if (title) ShowWindow( title, SW_HIDE );
734 }
735
736 /*******************************************************************
737 * WINPOS_GetMinMaxInfo
738 *
739 * Get the minimized and maximized information for a window.
740 */
741 void WINPOS_GetMinMaxInfo( HWND hwnd, POINT *maxSize, POINT *maxPos,
742 POINT *minTrack, POINT *maxTrack )
743 {
744 MINMAXINFO MinMax;
745 HMONITOR monitor;
746 INT xinc, yinc;
747 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
748 LONG adjustedStyle;
749 LONG exstyle = GetWindowLongW( hwnd, GWL_EXSTYLE );
750 RECT rc;
751 WND *win;
752
753 /* Compute default values */
754
755 GetWindowRect(hwnd, &rc);
756 MinMax.ptReserved.x = rc.left;
757 MinMax.ptReserved.y = rc.top;
758
759 if ((style & WS_CAPTION) == WS_CAPTION)
760 adjustedStyle = style & ~WS_BORDER; /* WS_CAPTION = WS_DLGFRAME | WS_BORDER */
761 else
762 adjustedStyle = style;
763
764 GetClientRect(GetAncestor(hwnd,GA_PARENT), &rc);
765 AdjustWindowRectEx(&rc, adjustedStyle, ((style & WS_POPUP) && GetMenu(hwnd)), exstyle);
766
767 xinc = -rc.left;
768 yinc = -rc.top;
769
770 MinMax.ptMaxSize.x = rc.right - rc.left;
771 MinMax.ptMaxSize.y = rc.bottom - rc.top;
772 if (style & (WS_DLGFRAME | WS_BORDER))
773 {
774 MinMax.ptMinTrackSize.x = GetSystemMetrics(SM_CXMINTRACK);
775 MinMax.ptMinTrackSize.y = GetSystemMetrics(SM_CYMINTRACK);
776 }
777 else
778 {
779 MinMax.ptMinTrackSize.x = 2 * xinc;
780 MinMax.ptMinTrackSize.y = 2 * yinc;
781 }
782 MinMax.ptMaxTrackSize.x = GetSystemMetrics(SM_CXMAXTRACK);
783 MinMax.ptMaxTrackSize.y = GetSystemMetrics(SM_CYMAXTRACK);
784 MinMax.ptMaxPosition.x = -xinc;
785 MinMax.ptMaxPosition.y = -yinc;
786
787 if ((win = WIN_GetPtr( hwnd )) && win != WND_DESKTOP && win != WND_OTHER_PROCESS)
788 {
789 if (!EMPTYPOINT(win->max_pos)) MinMax.ptMaxPosition = win->max_pos;
790 WIN_ReleasePtr( win );
791 }
792
793 SendMessageW( hwnd, WM_GETMINMAXINFO, 0, (LPARAM)&MinMax );
794
795 /* if the app didn't change the values, adapt them for the current monitor */
796
797 if ((monitor = MonitorFromWindow( hwnd, MONITOR_DEFAULTTOPRIMARY )))
798 {
799 RECT rc_work;
800 MONITORINFO mon_info;
801
802 mon_info.cbSize = sizeof(mon_info);
803 GetMonitorInfoW( monitor, &mon_info );
804
805 rc_work = mon_info.rcMonitor;
806
807 if (style & WS_MAXIMIZEBOX)
808 {
809 if ((style & WS_CAPTION) == WS_CAPTION || !(style & (WS_CHILD | WS_POPUP)))
810 rc_work = mon_info.rcWork;
811 }
812
813 if (MinMax.ptMaxSize.x == GetSystemMetrics(SM_CXSCREEN) + 2 * xinc &&
814 MinMax.ptMaxSize.y == GetSystemMetrics(SM_CYSCREEN) + 2 * yinc)
815 {
816 MinMax.ptMaxSize.x = (rc_work.right - rc_work.left) + 2 * xinc;
817 MinMax.ptMaxSize.y = (rc_work.bottom - rc_work.top) + 2 * yinc;
818 }
819 if (MinMax.ptMaxPosition.x == -xinc && MinMax.ptMaxPosition.y == -yinc)
820 {
821 MinMax.ptMaxPosition.x = rc_work.left - xinc;
822 MinMax.ptMaxPosition.y = rc_work.top - yinc;
823 }
824 }
825
826 /* Some sanity checks */
827
828 TRACE("%d %d / %d %d / %d %d / %d %d\n",
829 MinMax.ptMaxSize.x, MinMax.ptMaxSize.y,
830 MinMax.ptMaxPosition.x, MinMax.ptMaxPosition.y,
831 MinMax.ptMaxTrackSize.x, MinMax.ptMaxTrackSize.y,
832 MinMax.ptMinTrackSize.x, MinMax.ptMinTrackSize.y);
833 MinMax.ptMaxTrackSize.x = max( MinMax.ptMaxTrackSize.x,
834 MinMax.ptMinTrackSize.x );
835 MinMax.ptMaxTrackSize.y = max( MinMax.ptMaxTrackSize.y,
836 MinMax.ptMinTrackSize.y );
837
838 if (maxSize) *maxSize = MinMax.ptMaxSize;
839 if (maxPos) *maxPos = MinMax.ptMaxPosition;
840 if (minTrack) *minTrack = MinMax.ptMinTrackSize;
841 if (maxTrack) *maxTrack = MinMax.ptMaxTrackSize;
842 }
843
844
845 /***********************************************************************
846 * WINPOS_FindIconPos
847 *
848 * Find a suitable place for an iconic window.
849 */
850 static POINT WINPOS_FindIconPos( HWND hwnd, POINT pt )
851 {
852 RECT rect, rectParent;
853 HWND parent, child;
854 HRGN hrgn, tmp;
855 int x, y, xspacing, yspacing;
856 MINIMIZEDMETRICS metrics;
857
858 metrics.cbSize = sizeof(metrics);
859 SystemParametersInfoW( SPI_GETMINIMIZEDMETRICS, sizeof(metrics), &metrics, 0 );
860
861 parent = GetAncestor( hwnd, GA_PARENT );
862 if (parent == GetDesktopWindow())
863 {
864 MONITORINFO mon_info;
865 HMONITOR monitor = MonitorFromWindow( hwnd, MONITOR_DEFAULTTOPRIMARY );
866
867 mon_info.cbSize = sizeof( mon_info );
868 GetMonitorInfoW( monitor, &mon_info );
869 rectParent = mon_info.rcWork;
870 }
871 else GetClientRect( parent, &rectParent );
872
873 if ((pt.x >= rectParent.left) && (pt.x + GetSystemMetrics(SM_CXICON) < rectParent.right) &&
874 (pt.y >= rectParent.top) && (pt.y + GetSystemMetrics(SM_CYICON) < rectParent.bottom))
875 return pt; /* The icon already has a suitable position */
876
877 xspacing = GetSystemMetrics(SM_CXICONSPACING);
878 yspacing = GetSystemMetrics(SM_CYICONSPACING);
879
880 /* Check if another icon already occupies this spot */
881 /* FIXME: this is completely inefficient */
882
883 hrgn = CreateRectRgn( 0, 0, 0, 0 );
884 tmp = CreateRectRgn( 0, 0, 0, 0 );
885 for (child = GetWindow( parent, GW_CHILD ); child; child = GetWindow( child, GW_HWNDNEXT ))
886 {
887 if (child == hwnd) continue;
888 if ((GetWindowLongW( child, GWL_STYLE ) & (WS_VISIBLE|WS_MINIMIZE)) != (WS_VISIBLE|WS_MINIMIZE))
889 continue;
890 if (WIN_GetRectangles( child, COORDS_PARENT, &rect, NULL ))
891 {
892 SetRectRgn( tmp, rect.left, rect.top, rect.right, rect.bottom );
893 CombineRgn( hrgn, hrgn, tmp, RGN_OR );
894 }
895 }
896 DeleteObject( tmp );
897
898 for (y = 0; y < (rectParent.bottom - rectParent.top) / yspacing; y++)
899 {
900 if (metrics.iArrange & ARW_STARTTOP)
901 {
902 rect.top = rectParent.top + y * yspacing;
903 rect.bottom = rect.top + yspacing;
904 }
905 else
906 {
907 rect.bottom = rectParent.bottom - y * yspacing;
908 rect.top = rect.bottom - yspacing;
909 }
910 for (x = 0; x < (rectParent.right - rectParent.left) / xspacing; x++)
911 {
912 if (metrics.iArrange & ARW_STARTRIGHT)
913 {
914 rect.right = rectParent.right - x * xspacing;
915 rect.left = rect.right - xspacing;
916 }
917 else
918 {
919 rect.left = rectParent.left + x * xspacing;
920 rect.right = rect.left + xspacing;
921 }
922 if (!RectInRegion( hrgn, &rect ))
923 {
924 /* No window was found, so it's OK for us */
925 pt.x = rect.left + (xspacing - GetSystemMetrics(SM_CXICON)) / 2;
926 pt.y = rect.top + (yspacing - GetSystemMetrics(SM_CYICON)) / 2;
927 DeleteObject( hrgn );
928 return pt;
929 }
930 }
931 }
932 DeleteObject( hrgn );
933 pt.x = pt.y = 0;
934 return pt;
935 }
936
937
938 /***********************************************************************
939 * WINPOS_MinMaximize
940 */
941 UINT WINPOS_MinMaximize( HWND hwnd, UINT cmd, LPRECT rect )
942 {
943 UINT swpFlags = 0;
944 POINT size;
945 LONG old_style;
946 WINDOWPLACEMENT wpl;
947
948 TRACE("%p %u\n", hwnd, cmd );
949
950 wpl.length = sizeof(wpl);
951 GetWindowPlacement( hwnd, &wpl );
952
953 if (HOOK_CallHooks( WH_CBT, HCBT_MINMAX, (WPARAM)hwnd, cmd, TRUE ))
954 return SWP_NOSIZE | SWP_NOMOVE;
955
956 if (IsIconic( hwnd ))
957 {
958 switch (cmd)
959 {
960 case SW_SHOWMINNOACTIVE:
961 case SW_SHOWMINIMIZED:
962 case SW_FORCEMINIMIZE:
963 case SW_MINIMIZE:
964 return SWP_NOSIZE | SWP_NOMOVE;
965 }
966 if (!SendMessageW( hwnd, WM_QUERYOPEN, 0, 0 )) return SWP_NOSIZE | SWP_NOMOVE;
967 swpFlags |= SWP_NOCOPYBITS;
968 }
969
970 switch( cmd )
971 {
972 case SW_SHOWMINNOACTIVE:
973 case SW_SHOWMINIMIZED:
974 case SW_FORCEMINIMIZE:
975 case SW_MINIMIZE:
976 if (IsZoomed( hwnd )) win_set_flags( hwnd, WIN_RESTORE_MAX, 0 );
977 else win_set_flags( hwnd, 0, WIN_RESTORE_MAX );
978
979 old_style = WIN_SetStyle( hwnd, WS_MINIMIZE, WS_MAXIMIZE );
980
981 wpl.ptMinPosition = WINPOS_FindIconPos( hwnd, wpl.ptMinPosition );
982
983 if (!(old_style & WS_MINIMIZE)) swpFlags |= SWP_STATECHANGED;
984 SetRect( rect, wpl.ptMinPosition.x, wpl.ptMinPosition.y,
985 wpl.ptMinPosition.x + GetSystemMetrics(SM_CXICON),
986 wpl.ptMinPosition.y + GetSystemMetrics(SM_CYICON) );
987 swpFlags |= SWP_NOCOPYBITS;
988 break;
989
990 case SW_MAXIMIZE:
991 old_style = GetWindowLongW( hwnd, GWL_STYLE );
992 if ((old_style & WS_MAXIMIZE) && (old_style & WS_VISIBLE)) return SWP_NOSIZE | SWP_NOMOVE;
993
994 WINPOS_GetMinMaxInfo( hwnd, &size, &wpl.ptMaxPosition, NULL, NULL );
995
996 old_style = WIN_SetStyle( hwnd, WS_MAXIMIZE, WS_MINIMIZE );
997 if (old_style & WS_MINIMIZE)
998 {
999 win_set_flags( hwnd, WIN_RESTORE_MAX, 0 );
1000 WINPOS_ShowIconTitle( hwnd, FALSE );
1001 }
1002
1003 if (!(old_style & WS_MAXIMIZE)) swpFlags |= SWP_STATECHANGED;
1004 SetRect( rect, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
1005 wpl.ptMaxPosition.x + size.x, wpl.ptMaxPosition.y + size.y );
1006 break;
1007
1008 case SW_SHOWNOACTIVATE:
1009 win_set_flags( hwnd, 0, WIN_RESTORE_MAX );
1010 /* fall through */
1011 case SW_SHOWNORMAL:
1012 case SW_RESTORE:
1013 case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
1014 old_style = WIN_SetStyle( hwnd, 0, WS_MINIMIZE | WS_MAXIMIZE );
1015 if (old_style & WS_MINIMIZE)
1016 {
1017 WINPOS_ShowIconTitle( hwnd, FALSE );
1018 if (win_get_flags( hwnd ) & WIN_RESTORE_MAX)
1019 {
1020 /* Restore to maximized position */
1021 WINPOS_GetMinMaxInfo( hwnd, &size, &wpl.ptMaxPosition, NULL, NULL);
1022 WIN_SetStyle( hwnd, WS_MAXIMIZE, 0 );
1023 swpFlags |= SWP_STATECHANGED;
1024 SetRect( rect, wpl.ptMaxPosition.x, wpl.ptMaxPosition.y,
1025 wpl.ptMaxPosition.x + size.x, wpl.ptMaxPosition.y + size.y );
1026 break;
1027 }
1028 }
1029 else if (!(old_style & WS_MAXIMIZE)) break;
1030
1031 swpFlags |= SWP_STATECHANGED;
1032
1033 /* Restore to normal position */
1034
1035 *rect = wpl.rcNormalPosition;
1036 break;
1037 }
1038
1039 return swpFlags;
1040 }
1041
1042
1043 /***********************************************************************
1044 * show_window
1045 *
1046 * Implementation of ShowWindow and ShowWindowAsync.
1047 */
1048 static BOOL show_window( HWND hwnd, INT cmd )
1049 {
1050 WND *wndPtr;
1051 HWND parent;
1052 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
1053 BOOL wasVisible = (style & WS_VISIBLE) != 0;
1054 BOOL showFlag = TRUE;
1055 RECT newPos = {0, 0, 0, 0};
1056 UINT swp = 0;
1057
1058 TRACE("hwnd=%p, cmd=%d, wasVisible %d\n", hwnd, cmd, wasVisible);
1059
1060 switch(cmd)
1061 {
1062 case SW_HIDE:
1063 if (!wasVisible) return FALSE;
1064 showFlag = FALSE;
1065 swp |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE;
1066 if (style & WS_CHILD) swp |= SWP_NOACTIVATE | SWP_NOZORDER;
1067 break;
1068
1069 case SW_SHOWMINNOACTIVE:
1070 case SW_MINIMIZE:
1071 case SW_FORCEMINIMIZE: /* FIXME: Does not work if thread is hung. */
1072 swp |= SWP_NOACTIVATE | SWP_NOZORDER;
1073 /* fall through */
1074 case SW_SHOWMINIMIZED:
1075 swp |= SWP_SHOWWINDOW | SWP_FRAMECHANGED;
1076 swp |= WINPOS_MinMaximize( hwnd, cmd, &newPos );
1077 if ((style & WS_MINIMIZE) && wasVisible) return TRUE;
1078 break;
1079
1080 case SW_SHOWMAXIMIZED: /* same as SW_MAXIMIZE */
1081 if (!wasVisible) swp |= SWP_SHOWWINDOW;
1082 swp |= SWP_FRAMECHANGED;
1083 swp |= WINPOS_MinMaximize( hwnd, SW_MAXIMIZE, &newPos );
1084 if ((style & WS_MAXIMIZE) && wasVisible) return TRUE;
1085 break;
1086
1087 case SW_SHOWNA:
1088 swp |= SWP_NOACTIVATE | SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
1089 if (style & WS_CHILD) swp |= SWP_NOZORDER;
1090 break;
1091 case SW_SHOW:
1092 if (wasVisible) return TRUE;
1093 swp |= SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE;
1094 if (style & WS_CHILD) swp |= SWP_NOACTIVATE | SWP_NOZORDER;
1095 break;
1096
1097 case SW_SHOWNOACTIVATE:
1098 swp |= SWP_NOACTIVATE | SWP_NOZORDER;
1099 /* fall through */
1100 case SW_RESTORE:
1101 /* fall through */
1102 case SW_SHOWNORMAL: /* same as SW_NORMAL: */
1103 case SW_SHOWDEFAULT: /* FIXME: should have its own handler */
1104 if (!wasVisible) swp |= SWP_SHOWWINDOW;
1105 if (style & (WS_MINIMIZE | WS_MAXIMIZE))
1106 {
1107 swp |= SWP_FRAMECHANGED;
1108 swp |= WINPOS_MinMaximize( hwnd, cmd, &newPos );
1109 }
1110 else
1111 {
1112 if (wasVisible) return TRUE;
1113 swp |= SWP_NOSIZE | SWP_NOMOVE;
1114 }
1115 if (style & WS_CHILD && !(swp & SWP_STATECHANGED)) swp |= SWP_NOACTIVATE | SWP_NOZORDER;
1116 break;
1117 default:
1118 return wasVisible;
1119 }
1120
1121 if ((showFlag != wasVisible || cmd == SW_SHOWNA) && cmd != SW_SHOWMAXIMIZED && !(swp & SWP_STATECHANGED))
1122 {
1123 SendMessageW( hwnd, WM_SHOWWINDOW, showFlag, 0 );
1124 if (!IsWindow( hwnd )) return wasVisible;
1125 }
1126
1127 swp = USER_Driver->pShowWindow( hwnd, cmd, &newPos, swp );
1128
1129 parent = GetAncestor( hwnd, GA_PARENT );
1130 if (parent && !IsWindowVisible( parent ) && !(swp & SWP_STATECHANGED))
1131 {
1132 /* if parent is not visible simply toggle WS_VISIBLE and return */
1133 if (showFlag) WIN_SetStyle( hwnd, WS_VISIBLE, 0 );
1134 else WIN_SetStyle( hwnd, 0, WS_VISIBLE );
1135 }
1136 else
1137 SetWindowPos( hwnd, HWND_TOP, newPos.left, newPos.top,
1138 newPos.right - newPos.left, newPos.bottom - newPos.top, swp );
1139
1140 if (cmd == SW_HIDE)
1141 {
1142 HWND hFocus;
1143
1144 WINPOS_ShowIconTitle( hwnd, FALSE );
1145
1146 /* FIXME: This will cause the window to be activated irrespective
1147 * of whether it is owned by the same thread. Has to be done
1148 * asynchronously.
1149 */
1150
1151 if (hwnd == GetActiveWindow())
1152 WINPOS_ActivateOtherWindow(hwnd);
1153
1154 /* Revert focus to parent */
1155 hFocus = GetFocus();
1156 if (hwnd == hFocus)
1157 {
1158 HWND parent = GetAncestor(hwnd, GA_PARENT);
1159 if (parent == GetDesktopWindow()) parent = 0;
1160 SetFocus(parent);
1161 }
1162 return wasVisible;
1163 }
1164
1165 if (IsIconic(hwnd)) WINPOS_ShowIconTitle( hwnd, TRUE );
1166
1167 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return wasVisible;
1168
1169 if (wndPtr->flags & WIN_NEED_SIZE)
1170 {
1171 /* should happen only in CreateWindowEx() */
1172 int wParam = SIZE_RESTORED;
1173 RECT client;
1174 LPARAM lparam;
1175
1176 WIN_GetRectangles( hwnd, COORDS_PARENT, NULL, &client );
1177 lparam = MAKELONG( client.right - client.left, client.bottom - client.top );
1178 wndPtr->flags &= ~WIN_NEED_SIZE;
1179 if (wndPtr->dwStyle & WS_MAXIMIZE) wParam = SIZE_MAXIMIZED;
1180 else if (wndPtr->dwStyle & WS_MINIMIZE)
1181 {
1182 wParam = SIZE_MINIMIZED;
1183 lparam = 0;
1184 }
1185 WIN_ReleasePtr( wndPtr );
1186
1187 SendMessageW( hwnd, WM_SIZE, wParam, lparam );
1188 SendMessageW( hwnd, WM_MOVE, 0, MAKELONG( client.left, client.top ));
1189 }
1190 else WIN_ReleasePtr( wndPtr );
1191
1192 /* if previous state was minimized Windows sets focus to the window */
1193 if (style & WS_MINIMIZE) SetFocus( hwnd );
1194
1195 return wasVisible;
1196 }
1197
1198
1199 /***********************************************************************
1200 * ShowWindowAsync (USER32.@)
1201 *
1202 * doesn't wait; returns immediately.
1203 * used by threads to toggle windows in other (possibly hanging) threads
1204 */
1205 BOOL WINAPI ShowWindowAsync( HWND hwnd, INT cmd )
1206 {
1207 HWND full_handle;
1208
1209 if (is_broadcast(hwnd))
1210 {
1211 SetLastError( ERROR_INVALID_PARAMETER );
1212 return FALSE;
1213 }
1214
1215 if ((full_handle = WIN_IsCurrentThread( hwnd )))
1216 return show_window( full_handle, cmd );
1217
1218 return SendNotifyMessageW( hwnd, WM_WINE_SHOWWINDOW, cmd, 0 );
1219 }
1220
1221
1222 /***********************************************************************
1223 * ShowWindow (USER32.@)
1224 */
1225 BOOL WINAPI ShowWindow( HWND hwnd, INT cmd )
1226 {
1227 HWND full_handle;
1228
1229 if (is_broadcast(hwnd))
1230 {
1231 SetLastError( ERROR_INVALID_PARAMETER );
1232 return FALSE;
1233 }
1234 if ((full_handle = WIN_IsCurrentThread( hwnd )))
1235 return show_window( full_handle, cmd );
1236
1237 if ((cmd == SW_HIDE) && !(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE))
1238 return FALSE;
1239
1240 return SendMessageW( hwnd, WM_WINE_SHOWWINDOW, cmd, 0 );
1241 }
1242
1243
1244 /***********************************************************************
1245 * GetInternalWindowPos (USER32.@)
1246 */
1247 UINT WINAPI GetInternalWindowPos( HWND hwnd, LPRECT rectWnd,
1248 LPPOINT ptIcon )
1249 {
1250 WINDOWPLACEMENT wndpl;
1251 if (GetWindowPlacement( hwnd, &wndpl ))
1252 {
1253 if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
1254 if (ptIcon) *ptIcon = wndpl.ptMinPosition;
1255 return wndpl.showCmd;
1256 }
1257 return 0;
1258 }
1259
1260
1261 /***********************************************************************
1262 * GetWindowPlacement (USER32.@)
1263 *
1264 * Win95:
1265 * Fails if wndpl->length of Win95 (!) apps is invalid.
1266 */
1267 BOOL WINAPI GetWindowPlacement( HWND hwnd, WINDOWPLACEMENT *wndpl )
1268 {
1269 WND *pWnd = WIN_GetPtr( hwnd );
1270
1271 if (!pWnd) return FALSE;
1272
1273 if (pWnd == WND_DESKTOP)
1274 {
1275 wndpl->length = sizeof(*wndpl);
1276 wndpl->showCmd = SW_SHOWNORMAL;
1277 wndpl->flags = 0;
1278 wndpl->ptMinPosition.x = -1;
1279 wndpl->ptMinPosition.y = -1;
1280 wndpl->ptMaxPosition.x = -1;
1281 wndpl->ptMaxPosition.y = -1;
1282 GetWindowRect( hwnd, &wndpl->rcNormalPosition );
1283 return TRUE;
1284 }
1285 if (pWnd == WND_OTHER_PROCESS)
1286 {
1287 if (!IsWindow( hwnd )) return FALSE;
1288 FIXME( "not supported on other process window %p\n", hwnd );
1289 /* provide some dummy information */
1290 wndpl->length = sizeof(*wndpl);
1291 wndpl->showCmd = SW_SHOWNORMAL;
1292 wndpl->flags = 0;
1293 wndpl->ptMinPosition.x = -1;
1294 wndpl->ptMinPosition.y = -1;
1295 wndpl->ptMaxPosition.x = -1;
1296 wndpl->ptMaxPosition.y = -1;
1297 GetWindowRect( hwnd, &wndpl->rcNormalPosition );
1298 return TRUE;
1299 }
1300
1301 /* update the placement according to the current style */
1302 if (pWnd->dwStyle & WS_MINIMIZE)
1303 {
1304 pWnd->min_pos.x = pWnd->rectWindow.left;
1305 pWnd->min_pos.y = pWnd->rectWindow.top;
1306 }
1307 else if (pWnd->dwStyle & WS_MAXIMIZE)
1308 {
1309 pWnd->max_pos.x = pWnd->rectWindow.left;
1310 pWnd->max_pos.y = pWnd->rectWindow.top;
1311 }
1312 else
1313 {
1314 pWnd->normal_rect = pWnd->rectWindow;
1315 }
1316
1317 wndpl->length = sizeof(*wndpl);
1318 if( pWnd->dwStyle & WS_MINIMIZE )
1319 wndpl->showCmd = SW_SHOWMINIMIZED;
1320 else
1321 wndpl->showCmd = ( pWnd->dwStyle & WS_MAXIMIZE ) ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL ;
1322 if( pWnd->flags & WIN_RESTORE_MAX )
1323 wndpl->flags = WPF_RESTORETOMAXIMIZED;
1324 else
1325 wndpl->flags = 0;
1326 wndpl->ptMinPosition = pWnd->min_pos;
1327 wndpl->ptMaxPosition = pWnd->max_pos;
1328 wndpl->rcNormalPosition = pWnd->normal_rect;
1329 WIN_ReleasePtr( pWnd );
1330
1331 TRACE( "%p: returning min %d,%d max %d,%d normal %s\n",
1332 hwnd, wndpl->ptMinPosition.x, wndpl->ptMinPosition.y,
1333 wndpl->ptMaxPosition.x, wndpl->ptMaxPosition.y,
1334 wine_dbgstr_rect(&wndpl->rcNormalPosition) );
1335 return TRUE;
1336 }
1337
1338 /* make sure the specified rect is visible on screen */
1339 static void make_rect_onscreen( RECT *rect )
1340 {
1341 MONITORINFO info;
1342 HMONITOR monitor = MonitorFromRect( rect, MONITOR_DEFAULTTONEAREST );
1343
1344 info.cbSize = sizeof(info);
1345 if (!monitor || !GetMonitorInfoW( monitor, &info )) return;
1346 /* FIXME: map coordinates from rcWork to rcMonitor */
1347 if (rect->right <= info.rcWork.left)
1348 {
1349 rect->right += info.rcWork.left - rect->left;
1350 rect->left = info.rcWork.left;
1351 }
1352 else if (rect->left >= info.rcWork.right)
1353 {
1354 rect->left += info.rcWork.right - rect->right;
1355 rect->right = info.rcWork.right;
1356 }
1357 if (rect->bottom <= info.rcWork.top)
1358 {
1359 rect->bottom += info.rcWork.top - rect->top;
1360 rect->top = info.rcWork.top;
1361 }
1362 else if (rect->top >= info.rcWork.bottom)
1363 {
1364 rect->top += info.rcWork.bottom - rect->bottom;
1365 rect->bottom = info.rcWork.bottom;
1366 }
1367 }
1368
1369 /* make sure the specified point is visible on screen */
1370 static void make_point_onscreen( POINT *pt )
1371 {
1372 RECT rect;
1373
1374 SetRect( &rect, pt->x, pt->y, pt->x + 1, pt->y + 1 );
1375 make_rect_onscreen( &rect );
1376 pt->x = rect.left;
1377 pt->y = rect.top;
1378 }
1379
1380
1381 /***********************************************************************
1382 * WINPOS_SetPlacement
1383 */
1384 static BOOL WINPOS_SetPlacement( HWND hwnd, const WINDOWPLACEMENT *wndpl, UINT flags )
1385 {
1386 DWORD style;
1387 WND *pWnd = WIN_GetPtr( hwnd );
1388 WINDOWPLACEMENT wp = *wndpl;
1389
1390 if (flags & PLACE_MIN) make_point_onscreen( &wp.ptMinPosition );
1391 if (flags & PLACE_MAX) make_point_onscreen( &wp.ptMaxPosition );
1392 if (flags & PLACE_RECT) make_rect_onscreen( &wp.rcNormalPosition );
1393
1394 TRACE( "%p: setting min %d,%d max %d,%d normal %s flags %x ajusted to min %d,%d max %d,%d normal %s\n",
1395 hwnd, wndpl->ptMinPosition.x, wndpl->ptMinPosition.y,
1396 wndpl->ptMaxPosition.x, wndpl->ptMaxPosition.y,
1397 wine_dbgstr_rect(&wndpl->rcNormalPosition), flags,
1398 wp.ptMinPosition.x, wp.ptMinPosition.y, wp.ptMaxPosition.x, wp.ptMaxPosition.y,
1399 wine_dbgstr_rect(&wp.rcNormalPosition) );
1400
1401 if (!pWnd || pWnd == WND_OTHER_PROCESS || pWnd == WND_DESKTOP) return FALSE;
1402
1403 if( flags & PLACE_MIN ) pWnd->min_pos = wp.ptMinPosition;
1404 if( flags & PLACE_MAX ) pWnd->max_pos = wp.ptMaxPosition;
1405 if( flags & PLACE_RECT) pWnd->normal_rect = wp.rcNormalPosition;
1406
1407 style = pWnd->dwStyle;
1408
1409 WIN_ReleasePtr( pWnd );
1410
1411 if( style & WS_MINIMIZE )
1412 {
1413 if (flags & PLACE_MIN)
1414 {
1415 WINPOS_ShowIconTitle( hwnd, FALSE );
1416 SetWindowPos( hwnd, 0, wp.ptMinPosition.x, wp.ptMinPosition.y, 0, 0,
1417 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
1418 }
1419 }
1420 else if( style & WS_MAXIMIZE )
1421 {
1422 if (flags & PLACE_MAX)
1423 SetWindowPos( hwnd, 0, wp.ptMaxPosition.x, wp.ptMaxPosition.y, 0, 0,
1424 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
1425 }
1426 else if( flags & PLACE_RECT )
1427 SetWindowPos( hwnd, 0, wp.rcNormalPosition.left, wp.rcNormalPosition.top,
1428 wp.rcNormalPosition.right - wp.rcNormalPosition.left,
1429 wp.rcNormalPosition.bottom - wp.rcNormalPosition.top,
1430 SWP_NOZORDER | SWP_NOACTIVATE );
1431
1432 ShowWindow( hwnd, wndpl->showCmd );
1433
1434 if (IsIconic( hwnd ))
1435 {
1436 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE) WINPOS_ShowIconTitle( hwnd, TRUE );
1437
1438 /* SDK: ...valid only the next time... */
1439 if( wndpl->flags & WPF_RESTORETOMAXIMIZED )
1440 win_set_flags( hwnd, WIN_RESTORE_MAX, 0 );
1441 }
1442 return TRUE;
1443 }
1444
1445
1446 /***********************************************************************
1447 * SetWindowPlacement (USER32.@)
1448 *
1449 * Win95:
1450 * Fails if wndpl->length of Win95 (!) apps is invalid.
1451 */
1452 BOOL WINAPI SetWindowPlacement( HWND hwnd, const WINDOWPLACEMENT *wpl )
1453 {
1454 UINT flags = PLACE_MAX | PLACE_RECT;
1455 if (!wpl) return FALSE;
1456 if (wpl->flags & WPF_SETMINPOSITION) flags |= PLACE_MIN;
1457 return WINPOS_SetPlacement( hwnd, wpl, flags );
1458 }
1459
1460
1461 /***********************************************************************
1462 * AnimateWindow (USER32.@)
1463 * Shows/Hides a window with an animation
1464 * NO ANIMATION YET
1465 */
1466 BOOL WINAPI AnimateWindow(HWND hwnd, DWORD dwTime, DWORD dwFlags)
1467 {
1468 FIXME("partial stub\n");
1469
1470 /* If trying to show/hide and it's already *
1471 * shown/hidden or invalid window, fail with *
1472 * invalid parameter */
1473 if(!IsWindow(hwnd) ||
1474 (IsWindowVisible(hwnd) && !(dwFlags & AW_HIDE)) ||
1475 (!IsWindowVisible(hwnd) && (dwFlags & AW_HIDE)))
1476 {
1477 SetLastError(ERROR_INVALID_PARAMETER);
1478 return FALSE;
1479 }
1480
1481 ShowWindow(hwnd, (dwFlags & AW_HIDE) ? SW_HIDE : ((dwFlags & AW_ACTIVATE) ? SW_SHOW : SW_SHOWNA));
1482
1483 return TRUE;
1484 }
1485
1486 /***********************************************************************
1487 * SetInternalWindowPos (USER32.@)
1488 */
1489 void WINAPI SetInternalWindowPos( HWND hwnd, UINT showCmd,
1490 LPRECT rect, LPPOINT pt )
1491 {
1492 WINDOWPLACEMENT wndpl;
1493 UINT flags;
1494
1495 wndpl.length = sizeof(wndpl);
1496 wndpl.showCmd = showCmd;
1497 wndpl.flags = flags = 0;
1498
1499 if( pt )
1500 {
1501 flags |= PLACE_MIN;
1502 wndpl.flags |= WPF_SETMINPOSITION;
1503 wndpl.ptMinPosition = *pt;
1504 }
1505 if( rect )
1506 {
1507 flags |= PLACE_RECT;
1508 wndpl.rcNormalPosition = *rect;
1509 }
1510 WINPOS_SetPlacement( hwnd, &wndpl, flags );
1511 }
1512
1513
1514 /*******************************************************************
1515 * can_activate_window
1516 *
1517 * Check if we can activate the specified window.
1518 */
1519 static BOOL can_activate_window( HWND hwnd )
1520 {
1521 LONG style;
1522
1523 if (!hwnd) return FALSE;
1524 style = GetWindowLongW( hwnd, GWL_STYLE );
1525 if (!(style & WS_VISIBLE)) return FALSE;
1526 if ((style & (WS_POPUP|WS_CHILD)) == WS_CHILD) return FALSE;
1527 return !(style & WS_DISABLED);
1528 }
1529
1530
1531 /*******************************************************************
1532 * WINPOS_ActivateOtherWindow
1533 *
1534 * Activates window other than pWnd.
1535 */
1536 void WINPOS_ActivateOtherWindow(HWND hwnd)
1537 {
1538 HWND hwndTo, fg;
1539
1540 if ((GetWindowLongW( hwnd, GWL_STYLE ) & WS_POPUP) && (hwndTo = GetWindow( hwnd, GW_OWNER )))
1541 {
1542 hwndTo = GetAncestor( hwndTo, GA_ROOT );
1543 if (can_activate_window( hwndTo )) goto done;
1544 }
1545
1546 hwndTo = hwnd;
1547 for (;;)
1548 {
1549 if (!(hwndTo = GetWindow( hwndTo, GW_HWNDNEXT ))) break;
1550 if (can_activate_window( hwndTo )) goto done;
1551 }
1552
1553 hwndTo = GetTopWindow( 0 );
1554 for (;;)
1555 {
1556 if (hwndTo == hwnd)
1557 {
1558 hwndTo = 0;
1559 break;
1560 }
1561 if (can_activate_window( hwndTo )) goto done;
1562 if (!(hwndTo = GetWindow( hwndTo, GW_HWNDNEXT ))) break;
1563 }
1564
1565 done:
1566 fg = GetForegroundWindow();
1567 TRACE("win = %p fg = %p\n", hwndTo, fg);
1568 if (!fg || (hwnd == fg))
1569 {
1570 if (SetForegroundWindow( hwndTo )) return;
1571 }
1572 if (!SetActiveWindow( hwndTo )) SetActiveWindow(0);
1573 }
1574
1575
1576 /***********************************************************************
1577 * WINPOS_HandleWindowPosChanging
1578 *
1579 * Default handling for a WM_WINDOWPOSCHANGING. Called from DefWindowProc().
1580 */
1581 LONG WINPOS_HandleWindowPosChanging( HWND hwnd, WINDOWPOS *winpos )
1582 {
1583 POINT minTrack, maxTrack;
1584 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
1585
1586 if (winpos->flags & SWP_NOSIZE) return 0;
1587 if ((style & WS_THICKFRAME) || ((style & (WS_POPUP | WS_CHILD)) == 0))
1588 {
1589 WINPOS_GetMinMaxInfo( hwnd, NULL, NULL, &minTrack, &maxTrack );
1590 if (winpos->cx > maxTrack.x) winpos->cx = maxTrack.x;
1591 if (winpos->cy > maxTrack.y) winpos->cy = maxTrack.y;
1592 if (!(style & WS_MINIMIZE))
1593 {
1594 if (winpos->cx < minTrack.x ) winpos->cx = minTrack.x;
1595 if (winpos->cy < minTrack.y ) winpos->cy = minTrack.y;
1596 }
1597 }
1598 return 0;
1599 }
1600
1601
1602 /***********************************************************************
1603 * dump_winpos_flags
1604 */
1605 static void dump_winpos_flags(UINT flags)
1606 {
1607 static const DWORD dumped_flags = (SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOREDRAW |
1608 SWP_NOACTIVATE | SWP_FRAMECHANGED | SWP_SHOWWINDOW |
1609 SWP_HIDEWINDOW | SWP_NOCOPYBITS | SWP_NOOWNERZORDER |
1610 SWP_NOSENDCHANGING | SWP_DEFERERASE | SWP_ASYNCWINDOWPOS |
1611 SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_STATECHANGED);
1612 TRACE("flags:");
1613 if(flags & SWP_NOSIZE) TRACE(" SWP_NOSIZE");
1614 if(flags & SWP_NOMOVE) TRACE(" SWP_NOMOVE");
1615 if(flags & SWP_NOZORDER) TRACE(" SWP_NOZORDER");
1616 if(flags & SWP_NOREDRAW) TRACE(" SWP_NOREDRAW");
1617 if(flags & SWP_NOACTIVATE) TRACE(" SWP_NOACTIVATE");
1618 if(flags & SWP_FRAMECHANGED) TRACE(" SWP_FRAMECHANGED");
1619 if(flags & SWP_SHOWWINDOW) TRACE(" SWP_SHOWWINDOW");
1620 if(flags & SWP_HIDEWINDOW) TRACE(" SWP_HIDEWINDOW");
1621 if(flags & SWP_NOCOPYBITS) TRACE(" SWP_NOCOPYBITS");
1622 if(flags & SWP_NOOWNERZORDER) TRACE(" SWP_NOOWNERZORDER");
1623 if(flags & SWP_NOSENDCHANGING) TRACE(" SWP_NOSENDCHANGING");
1624 if(flags & SWP_DEFERERASE) TRACE(" SWP_DEFERERASE");
1625 if(flags & SWP_ASYNCWINDOWPOS) TRACE(" SWP_ASYNCWINDOWPOS");
1626 if(flags & SWP_NOCLIENTSIZE) TRACE(" SWP_NOCLIENTSIZE");
1627 if(flags & SWP_NOCLIENTMOVE) TRACE(" SWP_NOCLIENTMOVE");
1628 if(flags & SWP_STATECHANGED) TRACE(" SWP_STATECHANGED");
1629
1630 if(flags & ~dumped_flags) TRACE(" %08x", flags & ~dumped_flags);
1631 TRACE("\n");
1632 }
1633
1634 /***********************************************************************
1635 * SWP_DoWinPosChanging
1636 */
1637 static BOOL SWP_DoWinPosChanging( WINDOWPOS* pWinpos, RECT* pNewWindowRect, RECT* pNewClientRect )
1638 {
1639 WND *wndPtr;
1640 RECT window_rect, client_rect;
1641
1642 /* Send WM_WINDOWPOSCHANGING message */
1643
1644 if (!(pWinpos->flags & SWP_NOSENDCHANGING))
1645 SendMessageW( pWinpos->hwnd, WM_WINDOWPOSCHANGING, 0, (LPARAM)pWinpos );
1646
1647 if (!(wndPtr = WIN_GetPtr( pWinpos->hwnd )) ||
1648 wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return FALSE;
1649
1650 /* Calculate new position and size */
1651
1652 WIN_GetRectangles( pWinpos->hwnd, COORDS_PARENT, &window_rect, &client_rect );
1653 *pNewWindowRect = window_rect;
1654 *pNewClientRect = (wndPtr->dwStyle & WS_MINIMIZE) ? window_rect : client_rect;
1655
1656 if (!(pWinpos->flags & SWP_NOSIZE))
1657 {
1658 if (wndPtr->dwStyle & WS_MINIMIZE)
1659 {
1660 pNewWindowRect->right = pNewWindowRect->left + GetSystemMetrics(SM_CXICON);
1661 pNewWindowRect->bottom = pNewWindowRect->top + GetSystemMetrics(SM_CYICON);
1662 }
1663 else
1664 {
1665 pNewWindowRect->right = pNewWindowRect->left + pWinpos->cx;
1666 pNewWindowRect->bottom = pNewWindowRect->top + pWinpos->cy;
1667 }
1668 }
1669 if (!(pWinpos->flags & SWP_NOMOVE))
1670 {
1671 pNewWindowRect->left = pWinpos->x;
1672 pNewWindowRect->top = pWinpos->y;
1673 pNewWindowRect->right += pWinpos->x - window_rect.left;
1674 pNewWindowRect->bottom += pWinpos->y - window_rect.top;
1675
1676 OffsetRect( pNewClientRect, pWinpos->x - window_rect.left,
1677 pWinpos->y - window_rect.top );
1678 }
1679 pWinpos->flags |= SWP_NOCLIENTMOVE | SWP_NOCLIENTSIZE;
1680
1681 TRACE( "hwnd %p, after %p, swp %d,%d %dx%d flags %08x\n",
1682 pWinpos->hwnd, pWinpos->hwndInsertAfter, pWinpos->x, pWinpos->y,
1683 pWinpos->cx, pWinpos->cy, pWinpos->flags );
1684 TRACE( "current %s style %08x new %s\n",
1685 wine_dbgstr_rect( &window_rect ), wndPtr->dwStyle,
1686 wine_dbgstr_rect( pNewWindowRect ));
1687
1688 WIN_ReleasePtr( wndPtr );
1689 return TRUE;
1690 }
1691
1692 /***********************************************************************
1693 * get_valid_rects
1694 *
1695 * Compute the valid rects from the old and new client rect and WVR_* flags.
1696 * Helper for WM_NCCALCSIZE handling.
1697 */
1698 static inline void get_valid_rects( const RECT *old_client, const RECT *new_client, UINT flags,
1699 RECT *valid )
1700 {
1701 int cx, cy;
1702
1703 if (flags & WVR_REDRAW)
1704 {
1705 SetRectEmpty( &valid[0] );
1706 SetRectEmpty( &valid[1] );
1707 return;
1708 }
1709
1710 if (flags & WVR_VALIDRECTS)
1711 {
1712 if (!IntersectRect( &valid[0], &valid[0], new_client ) ||
1713 !IntersectRect( &valid[1], &valid[1], old_client ))
1714 {
1715 SetRectEmpty( &valid[0] );
1716 SetRectEmpty( &valid[1] );
1717 return;
1718 }
1719 flags = WVR_ALIGNLEFT | WVR_ALIGNTOP;
1720 }
1721 else
1722 {
1723 valid[0] = *new_client;
1724 valid[1] = *old_client;
1725 }
1726
1727 /* make sure the rectangles have the same size */
1728 cx = min( valid[0].right - valid[0].left, valid[1].right - valid[1].left );
1729 cy = min( valid[0].bottom - valid[0].top, valid[1].bottom - valid[1].top );
1730
1731 if (flags & WVR_ALIGNBOTTOM)
1732 {
1733 valid[0].top = valid[0].bottom - cy;
1734 valid[1].top = valid[1].bottom - cy;
1735 }
1736 else
1737 {
1738 valid[0].bottom = valid[0].top + cy;
1739 valid[1].bottom = valid[1].top + cy;
1740 }
1741 if (flags & WVR_ALIGNRIGHT)
1742 {
1743 valid[0].left = valid[0].right - cx;
1744 valid[1].left = valid[1].right - cx;
1745 }
1746 else
1747 {
1748 valid[0].right = valid[0].left + cx;
1749 valid[1].right = valid[1].left + cx;
1750 }
1751 }
1752
1753
1754 /***********************************************************************
1755 * SWP_DoOwnedPopups
1756 *
1757 * fix Z order taking into account owned popups -
1758 * basically we need to maintain them above the window that owns them
1759 *
1760 * FIXME: hide/show owned popups when owner visibility changes.
1761 */
1762 static HWND SWP_DoOwnedPopups(HWND hwnd, HWND hwndInsertAfter)
1763 {
1764 HWND owner, *list = NULL;
1765 unsigned int i;
1766
1767 TRACE("(%p) hInsertAfter = %p\n", hwnd, hwndInsertAfter );
1768
1769 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) return hwndInsertAfter;
1770
1771 if ((owner = GetWindow( hwnd, GW_OWNER )))
1772 {
1773 /* make sure this popup stays above the owner */
1774
1775 if (hwndInsertAfter != HWND_TOPMOST)
1776 {
1777 if (!(list = WIN_ListChildren( GetDesktopWindow() ))) return hwndInsertAfter;
1778
1779 for (i = 0; list[i]; i++)
1780 {
1781 BOOL topmost = (GetWindowLongW( list[i], GWL_EXSTYLE ) & WS_EX_TOPMOST) != 0;
1782
1783 if (list[i] == owner)
1784 {
1785 if (i > 0) hwndInsertAfter = list[i-1];
1786 else hwndInsertAfter = topmost ? HWND_TOPMOST : HWND_TOP;
1787 break;
1788 }
1789
1790 if (hwndInsertAfter == HWND_TOP || hwndInsertAfter == HWND_NOTOPMOST)
1791 {
1792 if (!topmost) break;
1793 }
1794 else if (list[i] == hwndInsertAfter) break;
1795 }
1796 }
1797 }
1798
1799 if (hwndInsertAfter == HWND_BOTTOM) goto done;
1800 if (!list && !(list = WIN_ListChildren( GetDesktopWindow() ))) goto done;
1801
1802 i = 0;
1803 if (hwndInsertAfter == HWND_TOP || hwndInsertAfter == HWND_NOTOPMOST)
1804 {
1805 if (hwndInsertAfter == HWND_NOTOPMOST || !(GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_TOPMOST))
1806 {
1807 /* skip all the topmost windows */
1808 while (list[i] && (GetWindowLongW( list[i], GWL_EXSTYLE ) & WS_EX_TOPMOST)) i++;
1809 }
1810 }
1811 else if (hwndInsertAfter != HWND_TOPMOST)
1812 {
1813 /* skip windows that are already placed correctly */
1814 for (i = 0; list[i]; i++)
1815 {
1816 if (list[i] == hwndInsertAfter) break;
1817 if (list[i] == hwnd) goto done; /* nothing to do if window is moving backwards in z-order */
1818 }
1819 }
1820
1821 for ( ; list[i]; i++)
1822 {
1823 if (list[i] == hwnd) break;
1824 if (GetWindow( list[i], GW_OWNER ) != hwnd) continue;
1825 TRACE( "moving %p owned by %p after %p\n", list[i], hwnd, hwndInsertAfter );
1826 SetWindowPos( list[i], hwndInsertAfter, 0, 0, 0, 0,
1827 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOSENDCHANGING | SWP_DEFERERASE );
1828 hwndInsertAfter = list[i];
1829 }
1830
1831 done:
1832 HeapFree( GetProcessHeap(), 0, list );
1833 return hwndInsertAfter;
1834 }
1835
1836 /***********************************************************************
1837 * SWP_DoNCCalcSize
1838 */
1839 static UINT SWP_DoNCCalcSize( WINDOWPOS* pWinpos, const RECT* pNewWindowRect, RECT* pNewClientRect,
1840 RECT *validRects )
1841 {
1842 UINT wvrFlags = 0;
1843 RECT window_rect, client_rect;
1844
1845 WIN_GetRectangles( pWinpos->hwnd, COORDS_PARENT, &window_rect, &client_rect );
1846
1847 /* Send WM_NCCALCSIZE message to get new client area */
1848 if( (pWinpos->flags & (SWP_FRAMECHANGED | SWP_NOSIZE)) != SWP_NOSIZE )
1849 {
1850 NCCALCSIZE_PARAMS params;
1851 WINDOWPOS winposCopy;
1852
1853 params.rgrc[0] = *pNewWindowRect;
1854 params.rgrc[1] = window_rect;
1855 params.rgrc[2] = client_rect;
1856 params.lppos = &winposCopy;
1857 winposCopy = *pWinpos;
1858
1859 wvrFlags = SendMessageW( pWinpos->hwnd, WM_NCCALCSIZE, TRUE, (LPARAM)&params );
1860
1861 *pNewClientRect = params.rgrc[0];
1862
1863 TRACE( "hwnd %p old win %s old client %s new win %s new client %s\n", pWinpos->hwnd,
1864 wine_dbgstr_rect(&window_rect), wine_dbgstr_rect(&client_rect),
1865 wine_dbgstr_rect(pNewWindowRect), wine_dbgstr_rect(pNewClientRect) );
1866
1867 if( pNewClientRect->left != client_rect.left ||
1868 pNewClientRect->top != client_rect.top )
1869 pWinpos->flags &= ~SWP_NOCLIENTMOVE;
1870
1871 if( (pNewClientRect->right - pNewClientRect->left !=
1872 client_rect.right - client_rect.left))
1873 pWinpos->flags &= ~SWP_NOCLIENTSIZE;
1874 else
1875 wvrFlags &= ~WVR_HREDRAW;
1876
1877 if (pNewClientRect->bottom - pNewClientRect->top !=
1878 client_rect.bottom - client_rect.top)
1879 pWinpos->flags &= ~SWP_NOCLIENTSIZE;
1880 else
1881 wvrFlags &= ~WVR_VREDRAW;
1882
1883 validRects[0] = params.rgrc[1];
1884 validRects[1] = params.rgrc[2];
1885 }
1886 else
1887 {
1888 if (!(pWinpos->flags & SWP_NOMOVE) &&
1889 (pNewClientRect->left != client_rect.left ||
1890 pNewClientRect->top != client_rect.top))
1891 pWinpos->flags &= ~SWP_NOCLIENTMOVE;
1892 }
1893
1894 if (pWinpos->flags & (SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_SHOWWINDOW | SWP_HIDEWINDOW))
1895 {
1896 SetRectEmpty( &validRects[0] );
1897 SetRectEmpty( &validRects[1] );
1898 }
1899 else get_valid_rects( &client_rect, pNewClientRect, wvrFlags, validRects );
1900
1901 return wvrFlags;
1902 }
1903
1904 /* fix redundant flags and values in the WINDOWPOS structure */
1905 static BOOL fixup_flags( WINDOWPOS *winpos )
1906 {
1907 HWND parent;
1908 RECT window_rect;
1909 POINT pt;
1910 WND *wndPtr = WIN_GetPtr( winpos->hwnd );
1911 BOOL ret = TRUE;
1912
1913 if (!wndPtr || wndPtr == WND_OTHER_PROCESS)
1914 {
1915 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1916 return FALSE;
1917 }
1918 winpos->hwnd = wndPtr->obj.handle; /* make it a full handle */
1919
1920 /* Finally make sure that all coordinates are valid */
1921 if (winpos->x < -32768) winpos->x = -32768;
1922 else if (winpos->x > 32767) winpos->x = 32767;
1923 if (winpos->y < -32768) winpos->y = -32768;
1924 else if (winpos->y > 32767) winpos->y = 32767;
1925
1926 if (winpos->cx < 0) winpos->cx = 0;
1927 else if (winpos->cx > 32767) winpos->cx = 32767;
1928 if (winpos->cy < 0) winpos->cy = 0;
1929 else if (winpos->cy > 32767) winpos->cy = 32767;
1930
1931 parent = GetAncestor( winpos->hwnd, GA_PARENT );
1932 if (!IsWindowVisible( parent )) winpos->flags |= SWP_NOREDRAW;
1933
1934 if (wndPtr->dwStyle & WS_VISIBLE) winpos->flags &= ~SWP_SHOWWINDOW;
1935 else
1936 {
1937 winpos->flags &= ~SWP_HIDEWINDOW;
1938 if (!(winpos->flags & SWP_SHOWWINDOW)) winpos->flags |= SWP_NOREDRAW;
1939 }
1940
1941 WIN_GetRectangles( winpos->hwnd, COORDS_SCREEN, &window_rect, NULL );
1942 if ((window_rect.right - window_rect.left == winpos->cx) &&
1943 (window_rect.bottom - window_rect.top == winpos->cy))
1944 winpos->flags |= SWP_NOSIZE; /* Already the right size */
1945
1946 pt.x = winpos->x;
1947 pt.y = winpos->y;
1948 ClientToScreen( parent, &pt );
1949 if ((window_rect.left == pt.x) && (window_rect.top == pt.y))
1950 winpos->flags |= SWP_NOMOVE; /* Already the right position */
1951
1952 if ((wndPtr->dwStyle & (WS_POPUP | WS_CHILD)) != WS_CHILD)
1953 {
1954 if (!(winpos->flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)) && /* Bring to the top when activating */
1955 (winpos->flags & SWP_NOZORDER ||
1956 (winpos->hwndInsertAfter != HWND_TOPMOST && winpos->hwndInsertAfter != HWND_NOTOPMOST)))
1957 {
1958 winpos->flags &= ~SWP_NOZORDER;
1959 winpos->hwndInsertAfter = HWND_TOP;
1960 }
1961 }
1962
1963 /* Check hwndInsertAfter */
1964 if (winpos->flags & SWP_NOZORDER) goto done;
1965
1966 if (winpos->hwndInsertAfter == HWND_TOP)
1967 {
1968 if (GetWindow(winpos->hwnd, GW_HWNDFIRST) == winpos->hwnd)
1969 winpos->flags |= SWP_NOZORDER;
1970 }
1971 else if (winpos->hwndInsertAfter == HWND_BOTTOM)
1972 {
1973 if (!(wndPtr->dwExStyle & WS_EX_TOPMOST) && GetWindow(winpos->hwnd, GW_HWNDLAST) == winpos->hwnd)
1974 winpos->flags |= SWP_NOZORDER;
1975 }
1976 else if (winpos->hwndInsertAfter == HWND_TOPMOST)
1977 {
1978 if ((wndPtr->dwExStyle & WS_EX_TOPMOST) && GetWindow(winpos->hwnd, GW_HWNDFIRST) == winpos->hwnd)
1979 winpos->flags |= SWP_NOZORDER;
1980 }
1981 else if (winpos->hwndInsertAfter == HWND_NOTOPMOST)
1982 {
1983 if (!(wndPtr->dwExStyle & WS_EX_TOPMOST))
1984 winpos->flags |= SWP_NOZORDER;
1985 }
1986 else
1987 {
1988 if ((winpos->hwnd == winpos->hwndInsertAfter) ||
1989 (winpos->hwnd == GetWindow( winpos->hwndInsertAfter, GW_HWNDNEXT )))
1990 winpos->flags |= SWP_NOZORDER;
1991 }
1992 done:
1993 WIN_ReleasePtr( wndPtr );
1994 return ret;
1995 }
1996
1997
1998 /***********************************************************************
1999 * update_surface_region
2000 */
2001 static void update_surface_region( HWND hwnd )
2002 {
2003 NTSTATUS status;
2004 HRGN region = 0;
2005 RGNDATA *data;
2006 size_t size = 256;
2007 WND *win = WIN_GetPtr( hwnd );
2008
2009 if (!win || win == WND_DESKTOP || win == WND_OTHER_PROCESS) return;
2010 if (!win->surface) goto done;
2011
2012 do
2013 {
2014 if (!(data = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET( RGNDATA, Buffer[size] )))) goto done;
2015
2016 SERVER_START_REQ( get_surface_region )
2017 {
2018 req->window = wine_server_user_handle( hwnd );
2019 wine_server_set_reply( req, data->Buffer, size );
2020 if (!(status = wine_server_call( req )))
2021 {
2022 size_t reply_size = wine_server_reply_size( reply );
2023 if (reply_size)
2024 {
2025 data->rdh.dwSize = sizeof(data->rdh);
2026 data->rdh.iType = RDH_RECTANGLES;
2027 data->rdh.nCount = reply_size / sizeof(RECT);
2028 data->rdh.nRgnSize = reply_size;
2029 region = ExtCreateRegion( NULL, data->rdh.dwSize + data->rdh.nRgnSize, data );
2030 OffsetRgn( region, -reply->visible_rect.left, -reply->visible_rect.top );
2031 }
2032 }
2033 else size = reply->total_size;
2034 }
2035 SERVER_END_REQ;
2036 HeapFree( GetProcessHeap(), 0, data );
2037 } while (status == STATUS_BUFFER_OVERFLOW);
2038
2039 if (status) goto done;
2040
2041 win->surface->funcs->set_region( win->surface, region );
2042 if (region) DeleteObject( region );
2043
2044 done:
2045 WIN_ReleasePtr( win );
2046 }
2047
2048
2049 /***********************************************************************
2050 * set_window_pos
2051 *
2052 * Backend implementation of SetWindowPos.
2053 */
2054 BOOL set_window_pos( HWND hwnd, HWND insert_after, UINT swp_flags,
2055 const RECT *window_rect, const RECT *client_rect, const RECT *valid_rects )
2056 {
2057 WND *win;
2058 HWND surface_win = 0, parent = GetAncestor( hwnd, GA_PARENT );
2059 BOOL ret;
2060 int old_width;
2061 RECT visible_rect, old_visible_rect, old_window_rect;
2062 struct window_surface *old_surface, *new_surface = NULL;
2063
2064 if (!parent || parent == GetDesktopWindow())
2065 {
2066 new_surface = &dummy_surface; /* provide a default surface for top-level windows */
2067 window_surface_add_ref( new_surface );
2068 }
2069 visible_rect = *window_rect;
2070 USER_Driver->pWindowPosChanging( hwnd, insert_after, swp_flags,
2071 window_rect, client_rect, &visible_rect, &new_surface );
2072
2073 WIN_GetRectangles( hwnd, COORDS_SCREEN, &old_window_rect, NULL );
2074
2075 if (!(win = WIN_GetPtr( hwnd )) || win == WND_DESKTOP || win == WND_OTHER_PROCESS)
2076 {
2077 if (new_surface) window_surface_release( new_surface );
2078 return FALSE;
2079 }
2080 old_width = win->rectClient.right - win->rectClient.left;
2081 old_visible_rect = win->visible_rect;
2082 old_surface = win->surface;
2083 if (old_surface != new_surface) swp_flags |= SWP_FRAMECHANGED; /* force refreshing non-client area */
2084
2085 SERVER_START_REQ( set_window_pos )
2086 {
2087 req->handle = wine_server_user_handle( hwnd );
2088 req->previous = wine_server_user_handle( insert_after );
2089 req->swp_flags = swp_flags;
2090 req->window.left = window_rect->left;
2091 req->window.top = window_rect->top;
2092 req->window.right = window_rect->right;
2093 req->window.bottom = window_rect->bottom;
2094 req->client.left = client_rect->left;
2095 req->client.top = client_rect->top;
2096 req->client.right = client_rect->right;
2097 req->client.bottom = client_rect->bottom;
2098 if (!EqualRect( window_rect, &visible_rect ) || !IsRectEmpty( &valid_rects[0] ))
2099 {
2100 wine_server_add_data( req, &visible_rect, sizeof(visible_rect) );
2101 if (!IsRectEmpty( &valid_rects[0] ))
2102 wine_server_add_data( req, valid_rects, 2 * sizeof(*valid_rects) );
2103 }
2104 if (new_surface) req->paint_flags |= SET_WINPOS_PAINT_SURFACE;
2105 if (win->pixel_format) req->paint_flags |= SET_WINPOS_PIXEL_FORMAT;
2106
2107 if ((ret = !wine_server_call( req )))
2108 {
2109 win->dwStyle = reply->new_style;
2110 win->dwExStyle = reply->new_ex_style;
2111 win->rectWindow = *window_rect;
2112 win->rectClient = *client_rect;
2113 win->visible_rect = visible_rect;
2114 win->surface = new_surface;
2115 surface_win = wine_server_ptr_handle( reply->surface_win );
2116 if (GetWindowLongW( win->parent, GWL_EXSTYLE ) & WS_EX_LAYOUTRTL)
2117 {
2118 RECT client;
2119 GetClientRect( win->parent, &client );
2120 mirror_rect( &client, &win->rectWindow );
2121 mirror_rect( &client, &win->rectClient );
2122 mirror_rect( &client, &win->visible_rect );
2123 }
2124 /* if an RTL window is resized the children have moved */
2125 if (win->dwExStyle & WS_EX_LAYOUTRTL && client_rect->right - client_rect->left != old_width)
2126 win->flags |= WIN_CHILDREN_MOVED;
2127 }
2128 }
2129 SERVER_END_REQ;
2130
2131 if (ret)
2132 {
2133 if (surface_win) update_surface_region( surface_win );
2134 if (((swp_flags & SWP_AGG_NOPOSCHANGE) != SWP_AGG_NOPOSCHANGE) ||
2135 (swp_flags & (SWP_HIDEWINDOW | SWP_SHOWWINDOW | SWP_STATECHANGED | SWP_FRAMECHANGED)))
2136 invalidate_dce( win, &old_window_rect );
2137 }
2138
2139 WIN_ReleasePtr( win );
2140
2141 if (ret)
2142 {
2143 TRACE( "win %p surface %p -> %p\n", hwnd, old_surface, new_surface );
2144 register_window_surface( old_surface, new_surface );
2145 if (old_surface)
2146 {
2147 if (!IsRectEmpty( valid_rects ))
2148 {
2149 move_window_bits( hwnd, old_surface, new_surface, &visible_rect,
2150 &old_visible_rect, client_rect, valid_rects );
2151 valid_rects = NULL; /* prevent the driver from trying to also move the bits */
2152 }
2153 window_surface_release( old_surface );
2154 }
2155 USER_Driver->pWindowPosChanged( hwnd, insert_after, swp_flags, window_rect,
2156 client_rect, &visible_rect, valid_rects, new_surface );
2157 }
2158 else if (new_surface) window_surface_release( new_surface );
2159
2160 return ret;
2161 }
2162
2163
2164 /***********************************************************************
2165 * USER_SetWindowPos
2166 *
2167 * User32 internal function
2168 */
2169 BOOL USER_SetWindowPos( WINDOWPOS * winpos )
2170 {
2171 RECT newWindowRect, newClientRect, valid_rects[2];
2172 UINT orig_flags;
2173
2174 orig_flags = winpos->flags;
2175
2176 /* First, check z-order arguments. */
2177 if (!(winpos->flags & SWP_NOZORDER))
2178 {
2179 /* fix sign extension */
2180 if (winpos->hwndInsertAfter == (HWND)0xffff) winpos->hwndInsertAfter = HWND_TOPMOST;
2181 else if (winpos->hwndInsertAfter == (HWND)0xfffe) winpos->hwndInsertAfter = HWND_NOTOPMOST;
2182
2183 if (!(winpos->hwndInsertAfter == HWND_TOP ||
2184 winpos->hwndInsertAfter == HWND_BOTTOM ||
2185 winpos->hwndInsertAfter == HWND_TOPMOST ||
2186 winpos->hwndInsertAfter == HWND_NOTOPMOST))
2187 {
2188 HWND parent = GetAncestor( winpos->hwnd, GA_PARENT );
2189 HWND insertafter_parent = GetAncestor( winpos->hwndInsertAfter, GA_PARENT );
2190
2191 /* hwndInsertAfter must be a sibling of the window */
2192 if (!insertafter_parent) return FALSE;
2193 if (insertafter_parent != parent) return TRUE;
2194 }
2195 }
2196
2197 /* Make sure that coordinates are valid for WM_WINDOWPOSCHANGING */
2198 if (!(winpos->flags & SWP_NOMOVE))
2199 {
2200 if (winpos->x < -32768) winpos->x = -32768;
2201 else if (winpos->x > 32767) winpos->x = 32767;
2202 if (winpos->y < -32768) winpos->y = -32768;
2203 else if (winpos->y > 32767) winpos->y = 32767;
2204 }
2205 if (!(winpos->flags & SWP_NOSIZE))
2206 {
2207 if (winpos->cx < 0) winpos->cx = 0;
2208 else if (winpos->cx > 32767) winpos->cx = 32767;
2209 if (winpos->cy < 0) winpos->cy = 0;
2210 else if (winpos->cy > 32767) winpos->cy = 32767;
2211 }
2212
2213 if (!SWP_DoWinPosChanging( winpos, &newWindowRect, &newClientRect )) return FALSE;
2214
2215 /* Fix redundant flags */
2216 if (!fixup_flags( winpos )) return FALSE;
2217
2218 if((winpos->flags & (SWP_NOZORDER | SWP_HIDEWINDOW | SWP_SHOWWINDOW)) != SWP_NOZORDER)
2219 {
2220 if (GetAncestor( winpos->hwnd, GA_PARENT ) == GetDesktopWindow())
2221 winpos->hwndInsertAfter = SWP_DoOwnedPopups( winpos->hwnd, winpos->hwndInsertAfter );
2222 }
2223
2224 /* Common operations */
2225
2226 SWP_DoNCCalcSize( winpos, &newWindowRect, &newClientRect, valid_rects );
2227
2228 if (!set_window_pos( winpos->hwnd, winpos->hwndInsertAfter, winpos->flags,
2229 &newWindowRect, &newClientRect, valid_rects ))
2230 return FALSE;
2231
2232 /* erase parent when hiding or resizing child */
2233 if (!(orig_flags & SWP_DEFERERASE) &&
2234 ((orig_flags & SWP_HIDEWINDOW) ||
2235 (!(orig_flags & SWP_SHOWWINDOW) &&
2236 (winpos->flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOGEOMETRYCHANGE)))
2237 {
2238 HWND parent = GetAncestor( winpos->hwnd, GA_PARENT );
2239 if (!parent || parent == GetDesktopWindow()) parent = winpos->hwnd;
2240 erase_now( parent, 0 );
2241 }
2242
2243 if( winpos->flags & SWP_HIDEWINDOW )
2244 HideCaret(winpos->hwnd);
2245 else if (winpos->flags & SWP_SHOWWINDOW)
2246 ShowCaret(winpos->hwnd);
2247
2248 if (!(winpos->flags & (SWP_NOACTIVATE|SWP_HIDEWINDOW)))
2249 {
2250 /* child windows get WM_CHILDACTIVATE message */
2251 if ((GetWindowLongW( winpos->hwnd, GWL_STYLE ) & (WS_CHILD | WS_POPUP)) == WS_CHILD)
2252 SendMessageW( winpos->hwnd, WM_CHILDACTIVATE, 0, 0 );
2253 else
2254 SetForegroundWindow( winpos->hwnd );
2255 }
2256
2257 /* And last, send the WM_WINDOWPOSCHANGED message */
2258
2259 TRACE("\tstatus flags = %04x\n", winpos->flags & SWP_AGG_STATUSFLAGS);
2260
2261 if (((winpos->flags & SWP_AGG_STATUSFLAGS) != SWP_AGG_NOPOSCHANGE))
2262 {
2263 /* WM_WINDOWPOSCHANGED is sent even if SWP_NOSENDCHANGING is set
2264 and always contains final window position.
2265 */
2266 winpos->x = newWindowRect.left;
2267 winpos->y = newWindowRect.top;
2268 winpos->cx = newWindowRect.right - newWindowRect.left;
2269 winpos->cy = newWindowRect.bottom - newWindowRect.top;
2270 SendMessageW( winpos->hwnd, WM_WINDOWPOSCHANGED, 0, (LPARAM)winpos );
2271 }
2272 return TRUE;
2273 }
2274
2275 /***********************************************************************
2276 * SetWindowPos (USER32.@)
2277 */
2278 BOOL WINAPI SetWindowPos( HWND hwnd, HWND hwndInsertAfter,
2279 INT x, INT y, INT cx, INT cy, UINT flags )
2280 {
2281 WINDOWPOS winpos;
2282
2283 TRACE("hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
2284 hwnd, hwndInsertAfter, x, y, cx, cy, flags);
2285 if(TRACE_ON(win)) dump_winpos_flags(flags);
2286
2287 if (is_broadcast(hwnd))
2288 {
2289 SetLastError( ERROR_INVALID_PARAMETER );
2290 return FALSE;
2291 }
2292
2293 winpos.hwnd = WIN_GetFullHandle(hwnd);
2294 winpos.hwndInsertAfter = WIN_GetFullHandle(hwndInsertAfter);
2295 winpos.x = x;
2296 winpos.y = y;
2297 winpos.cx = cx;
2298 winpos.cy = cy;
2299 winpos.flags = flags;
2300
2301 if (WIN_IsCurrentThread( hwnd ))
2302 return USER_SetWindowPos(&winpos);
2303
2304 return SendMessageW( winpos.hwnd, WM_WINE_SETWINDOWPOS, 0, (LPARAM)&winpos );
2305 }
2306
2307
2308 /***********************************************************************
2309 * BeginDeferWindowPos (USER32.@)
2310 */
2311 HDWP WINAPI BeginDeferWindowPos( INT count )
2312 {
2313 HDWP handle = 0;
2314 DWP *pDWP;
2315
2316 TRACE("%d\n", count);
2317
2318 if (count < 0)
2319 {
2320 SetLastError(ERROR_INVALID_PARAMETER);
2321 return 0;
2322 }
2323 /* Windows allows zero count, in which case it allocates context for 8 moves */
2324 if (count == 0) count = 8;
2325
2326 if (!(pDWP = HeapAlloc( GetProcessHeap(), 0, sizeof(DWP)))) return 0;
2327
2328 pDWP->actualCount = 0;
2329 pDWP->suggestedCount = count;
2330 pDWP->hwndParent = 0;
2331
2332 if (!(pDWP->winPos = HeapAlloc( GetProcessHeap(), 0, count * sizeof(WINDOWPOS) )) ||
2333 !(handle = alloc_user_handle( &pDWP->obj, USER_DWP )))
2334 {
2335 HeapFree( GetProcessHeap(), 0, pDWP->winPos );
2336 HeapFree( GetProcessHeap(), 0, pDWP );
2337 }
2338
2339 TRACE("returning hdwp %p\n", handle);
2340 return handle;
2341 }
2342
2343
2344 /***********************************************************************
2345 * DeferWindowPos (USER32.@)
2346 */
2347 HDWP WINAPI DeferWindowPos( HDWP hdwp, HWND hwnd, HWND hwndAfter,
2348 INT x, INT y, INT cx, INT cy,
2349 UINT flags )
2350 {
2351 DWP *pDWP;
2352 int i;
2353 HDWP retvalue = hdwp;
2354
2355 TRACE("hdwp %p, hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
2356 hdwp, hwnd, hwndAfter, x, y, cx, cy, flags);
2357
2358 hwnd = WIN_GetFullHandle( hwnd );
2359 if (is_desktop_window( hwnd ) || !IsWindow( hwnd ))
2360 {
2361 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2362 return 0;
2363 }
2364
2365 if (!(pDWP = get_user_handle_ptr( hdwp, USER_DWP ))) return 0;
2366 if (pDWP == OBJ_OTHER_PROCESS)
2367 {
2368 FIXME( "other process handle %p?\n", hdwp );
2369 return 0;
2370 }
2371
2372 for (i = 0; i < pDWP->actualCount; i++)
2373 {
2374 if (pDWP->winPos[i].hwnd == hwnd)
2375 {
2376 /* Merge with the other changes */
2377 if (!(flags & SWP_NOZORDER))
2378 {
2379 pDWP->winPos[i].hwndInsertAfter = WIN_GetFullHandle(hwndAfter);
2380 }
2381 if (!(flags & SWP_NOMOVE))
2382 {
2383 pDWP->winPos[i].x = x;
2384 pDWP->winPos[i].y = y;
2385 }
2386 if (!(flags & SWP_NOSIZE))
2387 {
2388 pDWP->winPos[i].cx = cx;
2389 pDWP->winPos[i].cy = cy;
2390 }
2391 pDWP->winPos[i].flags &= flags | ~(SWP_NOSIZE | SWP_NOMOVE |
2392 SWP_NOZORDER | SWP_NOREDRAW |
2393 SWP_NOACTIVATE | SWP_NOCOPYBITS|
2394 SWP_NOOWNERZORDER);
2395 pDWP->winPos[i].flags |= flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW |
2396 SWP_FRAMECHANGED);
2397 goto END;
2398 }
2399 }
2400 if (pDWP->actualCount >= pDWP->suggestedCount)
2401 {
2402 WINDOWPOS *newpos = HeapReAlloc( GetProcessHeap(), 0, pDWP->winPos,
2403 pDWP->suggestedCount * 2 * sizeof(WINDOWPOS) );
2404 if (!newpos)
2405 {
2406 retvalue = 0;
2407 goto END;
2408 }
2409 pDWP->suggestedCount *= 2;
2410 pDWP->winPos = newpos;
2411 }
2412 pDWP->winPos[pDWP->actualCount].hwnd = hwnd;
2413 pDWP->winPos[pDWP->actualCount].hwndInsertAfter = hwndAfter;
2414 pDWP->winPos[pDWP->actualCount].x = x;
2415 pDWP->winPos[pDWP->actualCount].y = y;
2416 pDWP->winPos[pDWP->actualCount].cx = cx;
2417 pDWP->winPos[pDWP->actualCount].cy = cy;
2418 pDWP->winPos[pDWP->actualCount].flags = flags;
2419 pDWP->actualCount++;
2420 END:
2421 release_user_handle_ptr( pDWP );
2422 return retvalue;
2423 }
2424
2425
2426 /***********************************************************************
2427 * EndDeferWindowPos (USER32.@)
2428 */
2429 BOOL WINAPI EndDeferWindowPos( HDWP hdwp )
2430 {
2431 DWP *pDWP;
2432 WINDOWPOS *winpos;
2433 BOOL res = TRUE;
2434 int i;
2435
2436 TRACE("%p\n", hdwp);
2437
2438 if (!(pDWP = free_user_handle( hdwp, USER_DWP ))) return FALSE;
2439 if (pDWP == OBJ_OTHER_PROCESS)
2440 {
2441 FIXME( "other process handle %p?\n", hdwp );
2442 return FALSE;
2443 }
2444
2445 for (i = 0, winpos = pDWP->winPos; res && i < pDWP->actualCount; i++, winpos++)
2446 {
2447 TRACE("hwnd %p, after %p, %d,%d (%dx%d), flags %08x\n",
2448 winpos->hwnd, winpos->hwndInsertAfter, winpos->x, winpos->y,
2449 winpos->cx, winpos->cy, winpos->flags);
2450
2451 if (WIN_IsCurrentThread( winpos->hwnd ))
2452 res = USER_SetWindowPos( winpos );
2453 else
2454 res = SendMessageW( winpos->hwnd, WM_WINE_SETWINDOWPOS, 0, (LPARAM)winpos );
2455 }
2456 HeapFree( GetProcessHeap(), 0, pDWP->winPos );
2457 HeapFree( GetProcessHeap(), 0, pDWP );
2458 return res;
2459 }
2460
2461
2462 /***********************************************************************
2463 * ArrangeIconicWindows (USER32.@)
2464 */
2465 UINT WINAPI ArrangeIconicWindows( HWND parent )
2466 {
2467 RECT rectParent;
2468 HWND hwndChild;
2469 INT x, y, xspacing, yspacing;
2470 POINT pt;
2471 MINIMIZEDMETRICS metrics;
2472
2473 metrics.cbSize = sizeof(metrics);
2474 SystemParametersInfoW( SPI_GETMINIMIZEDMETRICS, sizeof(metrics), &metrics, 0 );
2475
2476 if (parent == GetDesktopWindow())
2477 {
2478 MONITORINFO mon_info;
2479 HMONITOR monitor = MonitorFromWindow( 0, MONITOR_DEFAULTTOPRIMARY );
2480
2481 mon_info.cbSize = sizeof( mon_info );
2482 GetMonitorInfoW( monitor, &mon_info );
2483 rectParent = mon_info.rcWork;
2484 }
2485 else GetClientRect( parent, &rectParent );
2486
2487 x = y = 0;
2488 xspacing = GetSystemMetrics(SM_CXICONSPACING);
2489 yspacing = GetSystemMetrics(SM_CYICONSPACING);
2490
2491 hwndChild = GetWindow( parent, GW_CHILD );
2492 while (hwndChild)
2493 {
2494 if( IsIconic( hwndChild ) )
2495 {
2496 WINPOS_ShowIconTitle( hwndChild, FALSE );
2497
2498 if (metrics.iArrange & ARW_STARTRIGHT)
2499 pt.x = rectParent.right - (x + 1) * xspacing;
2500 else
2501 pt.x = rectParent.left + x * xspacing;
2502 if (metrics.iArrange & ARW_STARTTOP)
2503 pt.y = rectParent.top + y * yspacing;
2504 else
2505 pt.y = rectParent.bottom - (y + 1) * yspacing;
2506
2507 SetWindowPos( hwndChild, 0, pt.x + (xspacing - GetSystemMetrics(SM_CXICON)) / 2,
2508 pt.y + (yspacing - GetSystemMetrics(SM_CYICON)) / 2, 0, 0,
2509 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
2510 if( IsWindow(hwndChild) )
2511 WINPOS_ShowIconTitle(hwndChild , TRUE );
2512
2513 if (++x >= (rectParent.right - rectParent.left) / xspacing)
2514 {
2515 x = 0;
2516 y++;
2517 }
2518 }
2519 hwndChild = GetWindow( hwndChild, GW_HWNDNEXT );
2520 }
2521 return yspacing;
2522 }
2523
2524
2525 /***********************************************************************
2526 * draw_moving_frame
2527 *
2528 * Draw the frame used when moving or resizing window.
2529 */
2530 static void draw_moving_frame( HWND parent, HDC hdc, RECT *screen_rect, BOOL thickframe )
2531 {
2532 RECT rect = *screen_rect;
2533
2534 if (parent) MapWindowPoints( 0, parent, (POINT *)&rect, 2 );
2535 if (thickframe)
2536 {
2537 const int width = GetSystemMetrics(SM_CXFRAME);
2538 const int height = GetSystemMetrics(SM_CYFRAME);
2539
2540 HBRUSH hbrush = SelectObject( hdc, GetStockObject( GRAY_BRUSH ) );
2541 PatBlt( hdc, rect.left, rect.top,
2542 rect.right - rect.left - width, height, PATINVERT );
2543 PatBlt( hdc, rect.left, rect.top + height, width,
2544 rect.bottom - rect.top - height, PATINVERT );
2545 PatBlt( hdc, rect.left + width, rect.bottom - 1,
2546 rect.right - rect.left - width, -height, PATINVERT );
2547 PatBlt( hdc, rect.right - 1, rect.top, -width,
2548 rect.bottom - rect.top - height, PATINVERT );
2549 SelectObject( hdc, hbrush );
2550 }
2551 else DrawFocusRect( hdc, &rect );
2552 }
2553
2554
2555 /***********************************************************************
2556 * start_size_move
2557 *
2558 * Initialization of a move or resize, when initiated from a menu choice.
2559 * Return hit test code for caption or sizing border.
2560 */
2561 static LONG start_size_move( HWND hwnd, WPARAM wParam, POINT *capturePoint, LONG style )
2562 {
2563 LONG hittest = 0;
2564 POINT pt;
2565 MSG msg;
2566 RECT rectWindow;
2567
2568 GetWindowRect( hwnd, &rectWindow );
2569
2570 if ((wParam & 0xfff0) == SC_MOVE)
2571 {
2572 /* Move pointer at the center of the caption */
2573 RECT rect = rectWindow;
2574 /* Note: to be exactly centered we should take the different types
2575 * of border into account, but it shouldn't make more than a few pixels
2576 * of difference so let's not bother with that */
2577 rect.top += GetSystemMetrics(SM_CYBORDER);
2578 if (style & WS_SYSMENU)
2579 rect.left += GetSystemMetrics(SM_CXSIZE) + 1;
2580 if (style & WS_MINIMIZEBOX)
2581 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
2582 if (style & WS_MAXIMIZEBOX)
2583 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
2584 pt.x = (rect.right + rect.left) / 2;
2585 pt.y = rect.top + GetSystemMetrics(SM_CYSIZE)/2;
2586 hittest = HTCAPTION;
2587 *capturePoint = pt;
2588 }
2589 else /* SC_SIZE */
2590 {
2591 SetCursor( LoadCursorW( 0, (LPWSTR)IDC_SIZEALL ) );
2592 pt.x = pt.y = 0;
2593 while(!hittest)
2594 {
2595 if (!GetMessageW( &msg, 0, 0, 0 )) return 0;
2596 if (CallMsgFilterW( &msg, MSGF_SIZE )) continue;
2597
2598 switch(msg.message)
2599 {
2600 case WM_MOUSEMOVE:
2601 pt.x = min( max( msg.pt.x, rectWindow.left ), rectWindow.right - 1 );
2602 pt.y = min( max( msg.pt.y, rectWindow.top ), rectWindow.bottom - 1 );
2603 hittest = SendMessageW( hwnd, WM_NCHITTEST, 0, MAKELONG( pt.x, pt.y ) );
2604 if ((hittest < HTLEFT) || (hittest > HTBOTTOMRIGHT)) hittest = 0;
2605 break;
2606
2607 case WM_LBUTTONUP:
2608 return 0;
2609
2610 case WM_KEYDOWN:
2611 switch(msg.wParam)
2612 {
2613 case VK_UP:
2614 hittest = HTTOP;
2615 pt.x =(rectWindow.left+rectWindow.right)/2;
2616 pt.y = rectWindow.top + GetSystemMetrics(SM_CYFRAME) / 2;
2617 break;
2618 case VK_DOWN:
2619 hittest = HTBOTTOM;
2620 pt.x =(rectWindow.left+rectWindow.right)/2;
2621 pt.y = rectWindow.bottom - GetSystemMetrics(SM_CYFRAME) / 2;
2622 break;
2623 case VK_LEFT:
2624 hittest = HTLEFT;
2625 pt.x = rectWindow.left + GetSystemMetrics(SM_CXFRAME) / 2;
2626 pt.y =(rectWindow.top+rectWindow.bottom)/2;
2627 break;
2628 case VK_RIGHT:
2629 hittest = HTRIGHT;
2630 pt.x = rectWindow.right - GetSystemMetrics(SM_CXFRAME) / 2;
2631 pt.y =(rectWindow.top+rectWindow.bottom)/2;
2632 break;
2633 case VK_RETURN:
2634 case VK_ESCAPE:
2635 return 0;
2636 }
2637 break;
2638 default:
2639 TranslateMessage( &msg );
2640 DispatchMessageW( &msg );
2641 break;
2642 }
2643 }
2644 *capturePoint = pt;
2645 }
2646 SetCursorPos( pt.x, pt.y );
2647 SendMessageW( hwnd, WM_SETCURSOR, (WPARAM)hwnd, MAKELONG( hittest, WM_MOUSEMOVE ));
2648 return hittest;
2649 }
2650
2651
2652 /***********************************************************************
2653 * WINPOS_SysCommandSizeMove
2654 *
2655 * Perform SC_MOVE and SC_SIZE commands.
2656 */
2657 void WINPOS_SysCommandSizeMove( HWND hwnd, WPARAM wParam )
2658 {
2659 MSG msg;
2660 RECT sizingRect, mouseRect, origRect;
2661 HDC hdc;
2662 HWND parent;
2663 LONG hittest = (LONG)(wParam & 0x0f);
2664 WPARAM syscommand = wParam & 0xfff0;
2665 HCURSOR hDragCursor = 0, hOldCursor = 0;
2666 POINT minTrack, maxTrack;
2667 POINT capturePoint, pt;
2668 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
2669 BOOL thickframe = HAS_THICKFRAME( style );
2670 BOOL iconic = style & WS_MINIMIZE;
2671 BOOL moved = FALSE;
2672 DWORD dwPoint = GetMessagePos ();
2673 BOOL DragFullWindows = TRUE;
2674 HMONITOR mon = 0;
2675
2676 if (IsZoomed(hwnd) || !IsWindowVisible(hwnd)) return;
2677
2678 pt.x = (short)LOWORD(dwPoint);
2679 pt.y = (short)HIWORD(dwPoint);
2680 capturePoint = pt;
2681 ClipCursor( NULL );
2682
2683 TRACE("hwnd %p command %04lx, hittest %d, pos %d,%d\n",
2684 hwnd, syscommand, hittest, pt.x, pt.y);
2685
2686 if (syscommand == SC_MOVE)
2687 {
2688 if (!hittest) hittest = start_size_move( hwnd, wParam, &capturePoint, style );
2689 if (!hittest) return;
2690 }
2691 else /* SC_SIZE */
2692 {
2693 if ( hittest && (syscommand != SC_MOUSEMENU) )
2694 hittest += (HTLEFT - WMSZ_LEFT);
2695 else
2696 {
2697 set_capture_window( hwnd, GUI_INMOVESIZE, NULL );
2698 hittest = start_size_move( hwnd, wParam, &capturePoint, style );
2699 if (!hittest)
2700 {
2701 set_capture_window( 0, GUI_INMOVESIZE, NULL );
2702 return;
2703 }
2704 }
2705 }
2706
2707 /* Get min/max info */
2708
2709 WINPOS_GetMinMaxInfo( hwnd, NULL, NULL, &minTrack, &maxTrack );
2710 WIN_GetRectangles( hwnd, COORDS_PARENT, &sizingRect, NULL );
2711 origRect = sizingRect;
2712 if (style & WS_CHILD)
2713 {
2714 parent = GetParent(hwnd);
2715 GetClientRect( parent, &mouseRect );
2716 MapWindowPoints( parent, 0, (LPPOINT)&mouseRect, 2 );
2717 MapWindowPoints( parent, 0, (LPPOINT)&sizingRect, 2 );
2718 }
2719 else
2720 {
2721 parent = 0;
2722 mouseRect = get_virtual_screen_rect();
2723 mon = MonitorFromPoint( pt, MONITOR_DEFAULTTONEAREST );
2724 }
2725
2726 if (ON_LEFT_BORDER(hittest))
2727 {
2728 mouseRect.left = max( mouseRect.left, sizingRect.right-maxTrack.x+capturePoint.x-sizingRect.left );
2729 mouseRect.right = min( mouseRect.right, sizingRect.right-minTrack.x+capturePoint.x-sizingRect.left );
2730 }
2731 else if (ON_RIGHT_BORDER(hittest))
2732 {
2733 mouseRect.left = max( mouseRect.left, sizingRect.left+minTrack.x+capturePoint.x-sizingRect.right );
2734 mouseRect.right = min( mouseRect.right, sizingRect.left+maxTrack.x+capturePoint.x-sizingRect.right );
2735 }
2736 if (ON_TOP_BORDER(hittest))
2737 {
2738 mouseRect.top = max( mouseRect.top, sizingRect.bottom-maxTrack.y+capturePoint.y-sizingRect.top );
2739 mouseRect.bottom = min( mouseRect.bottom,sizingRect.bottom-minTrack.y+capturePoint.y-sizingRect.top);
2740 }
2741 else if (ON_BOTTOM_BORDER(hittest))
2742 {
2743 mouseRect.top = max( mouseRect.top, sizingRect.top+minTrack.y+capturePoint.y-sizingRect.bottom );
2744 mouseRect.bottom = min( mouseRect.bottom, sizingRect.top+maxTrack.y+capturePoint.y-sizingRect.bottom );
2745 }
2746
2747 /* Retrieve a default cache DC (without using the window style) */
2748 hdc = GetDCEx( parent, 0, DCX_CACHE );
2749
2750 if( iconic ) /* create a cursor for dragging */
2751 {
2752 hDragCursor = (HCURSOR)GetClassLongPtrW( hwnd, GCLP_HICON);
2753 if( !hDragCursor ) hDragCursor = (HCURSOR)SendMessageW( hwnd, WM_QUERYDRAGICON, 0, 0L);
2754 if( !hDragCursor ) iconic = FALSE;
2755 }
2756
2757 /* we only allow disabling the full window drag for child windows */
2758 if (parent) SystemParametersInfoW( SPI_GETDRAGFULLWINDOWS, 0, &DragFullWindows, 0 );
2759
2760 /* repaint the window before moving it around */
2761 RedrawWindow( hwnd, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN );
2762
2763 SendMessageW( hwnd, WM_ENTERSIZEMOVE, 0, 0 );
2764 set_capture_window( hwnd, GUI_INMOVESIZE, NULL );
2765
2766 while(1)
2767 {
2768 int dx = 0, dy = 0;
2769
2770 if (!GetMessageW( &msg, 0, 0, 0 )) break;
2771 if (CallMsgFilterW( &msg, MSGF_SIZE )) continue;
2772
2773 /* Exit on button-up, Return, or Esc */
2774 if ((msg.message == WM_LBUTTONUP) ||
2775 ((msg.message == WM_KEYDOWN) &&
2776 ((msg.wParam == VK_RETURN) || (msg.wParam == VK_ESCAPE)))) break;
2777
2778 if ((msg.message != WM_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
2779 {
2780 TranslateMessage( &msg );
2781 DispatchMessageW( &msg );
2782 continue; /* We are not interested in other messages */
2783 }
2784
2785 pt = msg.pt;
2786
2787 if (msg.message == WM_KEYDOWN) switch(msg.wParam)
2788 {
2789 case VK_UP: pt.y -= 8; break;
2790 case VK_DOWN: pt.y += 8; break;
2791 case VK_LEFT: pt.x -= 8; break;
2792 case VK_RIGHT: pt.x += 8; break;
2793 }
2794
2795 pt.x = max( pt.x, mouseRect.left );
2796 pt.x = min( pt.x, mouseRect.right - 1 );
2797 pt.y = max( pt.y, mouseRect.top );
2798 pt.y = min( pt.y, mouseRect.bottom - 1 );
2799
2800 if (!parent)
2801 {
2802 HMONITOR newmon;
2803 MONITORINFO info;
2804
2805 if ((newmon = MonitorFromPoint( pt, MONITOR_DEFAULTTONULL )))
2806 mon = newmon;
2807
2808 info.cbSize = sizeof(info);
2809 if (mon && GetMonitorInfoW( mon, &info ))
2810 {
2811 pt.x = max( pt.x, info.rcWork.left );
2812 pt.x = min( pt.x, info.rcWork.right - 1 );
2813 pt.y = max( pt.y, info.rcWork.top );
2814 pt.y = min( pt.y, info.rcWork.bottom - 1 );
2815 }
2816 }
2817
2818 dx = pt.x - capturePoint.x;
2819 dy = pt.y - capturePoint.y;
2820
2821 if (dx || dy)
2822 {
2823 if( !moved )
2824 {
2825 moved = TRUE;
2826
2827 if( iconic ) /* ok, no system popup tracking */
2828 {
2829 hOldCursor = SetCursor(hDragCursor);
2830 ShowCursor( TRUE );
2831 WINPOS_ShowIconTitle( hwnd, FALSE );
2832 }
2833 else if(!DragFullWindows)
2834 draw_moving_frame( parent, hdc, &sizingRect, thickframe );
2835 }
2836
2837 if (msg.message == WM_KEYDOWN) SetCursorPos( pt.x, pt.y );
2838 else
2839 {
2840 if(!iconic && !DragFullWindows) draw_moving_frame( parent, hdc, &sizingRect, thickframe );
2841 if (hittest == HTCAPTION) OffsetRect( &sizingRect, dx, dy );
2842 if (ON_LEFT_BORDER(hittest)) sizingRect.left += dx;
2843 else if (ON_RIGHT_BORDER(hittest)) sizingRect.right += dx;
2844 if (ON_TOP_BORDER(hittest)) sizingRect.top += dy;
2845 else if (ON_BOTTOM_BORDER(hittest)) sizingRect.bottom += dy;
2846 capturePoint = pt;
2847
2848 /* determine the hit location */
2849 if (syscommand == SC_SIZE)
2850 {
2851 WPARAM wpSizingHit = 0;
2852
2853 if (hittest >= HTLEFT && hittest <= HTBOTTOMRIGHT)
2854 wpSizingHit = WMSZ_LEFT + (hittest - HTLEFT);
2855 SendMessageW( hwnd, WM_SIZING, wpSizingHit, (LPARAM)&sizingRect );
2856 }
2857 else
2858 SendMessageW( hwnd, WM_MOVING, 0, (LPARAM)&sizingRect );
2859
2860 if (!iconic)
2861 {
2862 if(!DragFullWindows)
2863 draw_moving_frame( parent, hdc, &sizingRect, thickframe );
2864 else
2865 {
2866 RECT rect = sizingRect;
2867 MapWindowPoints( 0, parent, (POINT *)&rect, 2 );
2868 SetWindowPos( hwnd, 0, rect.left, rect.top,
2869 rect.right - rect.left, rect.bottom - rect.top,
2870 ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
2871 }
2872 }
2873 }
2874 }
2875 }
2876
2877 if( iconic )
2878 {
2879 if( moved ) /* restore cursors, show icon title later on */
2880 {
2881 ShowCursor( FALSE );
2882 SetCursor( hOldCursor );
2883 }
2884 }
2885 else if (moved && !DragFullWindows)
2886 {
2887 draw_moving_frame( parent, hdc, &sizingRect, thickframe );
2888 }
2889
2890 set_capture_window( 0, GUI_INMOVESIZE, NULL );
2891 ReleaseDC( parent, hdc );
2892 if (parent) MapWindowPoints( 0, parent, (POINT *)&sizingRect, 2 );
2893
2894 if (HOOK_CallHooks( WH_CBT, HCBT_MOVESIZE, (WPARAM)hwnd, (LPARAM)&sizingRect, TRUE ))
2895 moved = FALSE;
2896
2897 SendMessageW( hwnd, WM_EXITSIZEMOVE, 0, 0 );
2898 SendMessageW( hwnd, WM_SETVISIBLE, !IsIconic(hwnd), 0L);
2899
2900 /* window moved or resized */
2901 if (moved)
2902 {
2903 /* if the moving/resizing isn't canceled call SetWindowPos
2904 * with the new position or the new size of the window
2905 */
2906 if (!((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) )
2907 {
2908 /* NOTE: SWP_NOACTIVATE prevents document window activation in Word 6 */
2909 if(!DragFullWindows || iconic)
2910 SetWindowPos( hwnd, 0, sizingRect.left, sizingRect.top,
2911 sizingRect.right - sizingRect.left,
2912 sizingRect.bottom - sizingRect.top,
2913 ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
2914 }
2915 else
2916 { /* restore previous size/position */
2917 if(DragFullWindows)
2918 SetWindowPos( hwnd, 0, origRect.left, origRect.top,
2919 origRect.right - origRect.left,
2920 origRect.bottom - origRect.top,
2921 ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
2922 }
2923 }
2924
2925 if (IsIconic(hwnd))
2926 {
2927 /* Single click brings up the system menu when iconized */
2928
2929 if( !moved )
2930 {
2931 if(style & WS_SYSMENU )
2932 SendMessageW( hwnd, WM_SYSCOMMAND,
2933 SC_MOUSEMENU + HTSYSMENU, MAKELONG(pt.x,pt.y));
2934 }
2935 else WINPOS_ShowIconTitle( hwnd, TRUE );
2936 }
2937 }
Windows API implementation