?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus: Brush tests.
[wine/gsoc-2012-control.git] / dlls / user32 / win.c
blobd9b3a2ec3e58b5b14c9495864ecf8f8e984287b3
1 /*
2 * Window related functions
3 *
4 * Copyright 1993, 1994 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <assert.h>
25 #include <stdarg.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wine/winbase16.h"
31 #include "wine/winuser16.h"
32 #include "wownt32.h"
33 #include "wine/server.h"
34 #include "wine/unicode.h"
35 #include "win.h"
36 #include "winproc.h"
37 #include "user_private.h"
38 #include "controls.h"
39 #include "winerror.h"
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(win);
43
44 #define NB_USER_HANDLES ((LAST_USER_HANDLE - FIRST_USER_HANDLE + 1) >> 1)
45 #define USER_HANDLE_TO_INDEX(hwnd) ((LOWORD(hwnd) - FIRST_USER_HANDLE) >> 1)
46
47 /**********************************************************************/
48
49 /* helper for Get/SetWindowLong */
50 static inline LONG_PTR get_win_data( const void *ptr, UINT size )
51 {
52 if (size == sizeof(WORD))
53 {
54 WORD ret;
55 memcpy( &ret, ptr, sizeof(ret) );
56 return ret;
57 }
58 else if (size == sizeof(DWORD))
59 {
60 DWORD ret;
61 memcpy( &ret, ptr, sizeof(ret) );
62 return ret;
63 }
64 else
65 {
66 LONG_PTR ret;
67 memcpy( &ret, ptr, sizeof(ret) );
68 return ret;
69 }
70 }
71
72 /* helper for Get/SetWindowLong */
73 static inline void set_win_data( void *ptr, LONG_PTR val, UINT size )
74 {
75 if (size == sizeof(WORD))
76 {
77 WORD newval = val;
78 memcpy( ptr, &newval, sizeof(newval) );
79 }
80 else if (size == sizeof(DWORD))
81 {
82 DWORD newval = val;
83 memcpy( ptr, &newval, sizeof(newval) );
84 }
85 else
86 {
87 memcpy( ptr, &val, sizeof(val) );
88 }
89 }
90
91
92 static void *user_handles[NB_USER_HANDLES];
93
94 /***********************************************************************
95 * create_window_handle
96 *
97 * Create a window handle with the server.
98 */
99 static WND *create_window_handle( HWND parent, HWND owner, ATOM atom,
100 HINSTANCE instance, BOOL unicode )
101 {
102 WORD index;
103 WND *win;
104 HWND full_parent = 0, full_owner = 0;
105 struct tagCLASS *class = NULL;
106 user_handle_t handle = 0;
107 int extra_bytes = 0;
108
109 /* if 16-bit instance, map to module handle */
110 if (instance && !HIWORD(instance))
111 instance = HINSTANCE_32(GetExePtr(HINSTANCE_16(instance)));
112
113 SERVER_START_REQ( create_window )
114 {
115 req->parent = parent;
116 req->owner = owner;
117 req->atom = atom;
118 req->instance = instance;
119 if (!wine_server_call_err( req ))
120 {
121 handle = reply->handle;
122 full_parent = reply->parent;
123 full_owner = reply->owner;
124 extra_bytes = reply->extra;
125 class = reply->class_ptr;
126 }
127 }
128 SERVER_END_REQ;
129
130 if (!handle)
131 {
132 WARN( "error %d creating window\n", GetLastError() );
133 return NULL;
134 }
135
136 if (!(win = HeapAlloc( GetProcessHeap(), 0, sizeof(WND) + extra_bytes - sizeof(win->wExtra) )))
137 {
138 SERVER_START_REQ( destroy_window )
139 {
140 req->handle = handle;
141 wine_server_call( req );
142 }
143 SERVER_END_REQ;
144 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
145 return NULL;
146 }
147
148 if (!parent) /* if parent is 0 we don't have a desktop window yet */
149 {
150 struct user_thread_info *thread_info = get_user_thread_info();
151
152 assert( !thread_info->desktop );
153 thread_info->desktop = full_parent ? full_parent : handle;
154 if (full_parent && !USER_Driver->pCreateDesktopWindow( thread_info->desktop ))
155 ERR( "failed to create desktop window\n" );
156 }
157
158 USER_Lock();
159
160 index = USER_HANDLE_TO_INDEX(handle);
161 assert( index < NB_USER_HANDLES );
162 user_handles[index] = win;
163 win->hwndSelf = handle;
164 win->parent = full_parent;
165 win->owner = full_owner;
166 win->dwMagic = WND_MAGIC;
167 win->flags = 0;
168 win->cbWndExtra = extra_bytes;
169 memset( win->wExtra, 0, extra_bytes );
170 CLASS_AddWindow( class, win, unicode );
171 return win;
172 }
173
174
175 /***********************************************************************
176 * free_window_handle
177 *
178 * Free a window handle.
179 */
180 static WND *free_window_handle( HWND hwnd )
181 {
182 WND *ptr;
183 WORD index = USER_HANDLE_TO_INDEX(hwnd);
184
185 if (index >= NB_USER_HANDLES) return NULL;
186 USER_Lock();
187 if ((ptr = user_handles[index]))
188 {
189 SERVER_START_REQ( destroy_window )
190 {
191 req->handle = hwnd;
192 if (!wine_server_call_err( req ))
193 {
194 user_handles[index] = NULL;
195 ptr->dwMagic = 0;
196 }
197 else
198 ptr = NULL;
199 }
200 SERVER_END_REQ;
201 }
202 USER_Unlock();
203 HeapFree( GetProcessHeap(), 0, ptr );
204 return ptr;
205 }
206
207
208 /*******************************************************************
209 * list_window_children
210 *
211 * Build an array of the children of a given window. The array must be
212 * freed with HeapFree. Returns NULL when no windows are found.
213 */
214 static HWND *list_window_children( HWND hwnd, ATOM atom, DWORD tid )
215 {
216 HWND *list;
217 int size = 32;
218
219 for (;;)
220 {
221 int count = 0;
222
223 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) break;
224
225 SERVER_START_REQ( get_window_children )
226 {
227 req->parent = hwnd;
228 req->atom = atom;
229 req->tid = tid;
230 wine_server_set_reply( req, list, (size-1) * sizeof(HWND) );
231 if (!wine_server_call( req )) count = reply->count;
232 }
233 SERVER_END_REQ;
234 if (count && count < size)
235 {
236 list[count] = 0;
237 return list;
238 }
239 HeapFree( GetProcessHeap(), 0, list );
240 if (!count) break;
241 size = count + 1; /* restart with a large enough buffer */
242 }
243 return NULL;
244 }
245
246
247 /*******************************************************************
248 * list_window_parents
249 *
250 * Build an array of all parents of a given window, starting with
251 * the immediate parent. The array must be freed with HeapFree.
252 */
253 static HWND *list_window_parents( HWND hwnd )
254 {
255 WND *win;
256 HWND current, *list;
257 int pos = 0, size = 16, count = 0;
258
259 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL;
260
261 current = hwnd;
262 for (;;)
263 {
264 if (!(win = WIN_GetPtr( current ))) goto empty;
265 if (win == WND_OTHER_PROCESS) break; /* need to do it the hard way */
266 if (win == WND_DESKTOP)
267 {
268 if (!pos) goto empty;
269 list[pos] = 0;
270 return list;
271 }
272 list[pos] = current = win->parent;
273 WIN_ReleasePtr( win );
274 if (++pos == size - 1)
275 {
276 /* need to grow the list */
277 HWND *new_list = HeapReAlloc( GetProcessHeap(), 0, list, (size+16) * sizeof(HWND) );
278 if (!new_list) goto empty;
279 list = new_list;
280 size += 16;
281 }
282 }
283
284 /* at least one parent belongs to another process, have to query the server */
285
286 for (;;)
287 {
288 count = 0;
289 SERVER_START_REQ( get_window_parents )
290 {
291 req->handle = hwnd;
292 wine_server_set_reply( req, list, (size-1) * sizeof(HWND) );
293 if (!wine_server_call( req )) count = reply->count;
294 }
295 SERVER_END_REQ;
296 if (!count) goto empty;
297 if (size > count)
298 {
299 list[count] = 0;
300 return list;
301 }
302 HeapFree( GetProcessHeap(), 0, list );
303 size = count + 1;
304 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL;
305 }
306
307 empty:
308 HeapFree( GetProcessHeap(), 0, list );
309 return NULL;
310 }
311
312
313 /*******************************************************************
314 * send_parent_notify
315 */
316 static void send_parent_notify( HWND hwnd, UINT msg )
317 {
318 if ((GetWindowLongW( hwnd, GWL_STYLE ) & (WS_CHILD | WS_POPUP)) == WS_CHILD &&
319 !(GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY))
320 {
321 HWND parent = GetParent(hwnd);
322 if (parent && parent != GetDesktopWindow())
323 SendMessageW( parent, WM_PARENTNOTIFY,
324 MAKEWPARAM( msg, GetWindowLongPtrW( hwnd, GWLP_ID )), (LPARAM)hwnd );
325 }
326 }
327
328
329 /*******************************************************************
330 * get_server_window_text
331 *
332 * Retrieve the window text from the server.
333 */
334 static void get_server_window_text( HWND hwnd, LPWSTR text, INT count )
335 {
336 size_t len = 0;
337
338 SERVER_START_REQ( get_window_text )
339 {
340 req->handle = hwnd;
341 wine_server_set_reply( req, text, (count - 1) * sizeof(WCHAR) );
342 if (!wine_server_call_err( req )) len = wine_server_reply_size(reply);
343 }
344 SERVER_END_REQ;
345 text[len / sizeof(WCHAR)] = 0;
346 }
347
348
349 /***********************************************************************
350 * WIN_GetPtr
351 *
352 * Return a pointer to the WND structure if local to the process,
353 * or WND_OTHER_PROCESS if handle may be valid in other process.
354 * If ret value is a valid pointer, it must be released with WIN_ReleasePtr.
355 */
356 WND *WIN_GetPtr( HWND hwnd )
357 {
358 WND * ptr;
359 WORD index = USER_HANDLE_TO_INDEX(hwnd);
360
361 if (index >= NB_USER_HANDLES) return NULL;
362
363 USER_Lock();
364 if ((ptr = user_handles[index]))
365 {
366 if (ptr->dwMagic == WND_MAGIC &&
367 (hwnd == ptr->hwndSelf || !HIWORD(hwnd) || HIWORD(hwnd) == 0xffff))
368 return ptr;
369 ptr = NULL;
370 }
371 else if (index == USER_HANDLE_TO_INDEX(GetDesktopWindow()))
372 {
373 if (hwnd == GetDesktopWindow() || !HIWORD(hwnd) || HIWORD(hwnd) == 0xffff) ptr = WND_DESKTOP;
374 else ptr = NULL;
375 }
376 else ptr = WND_OTHER_PROCESS;
377 USER_Unlock();
378 return ptr;
379 }
380
381
382 /***********************************************************************
383 * WIN_IsCurrentProcess
384 *
385 * Check whether a given window belongs to the current process (and return the full handle).
386 */
387 HWND WIN_IsCurrentProcess( HWND hwnd )
388 {
389 WND *ptr;
390 HWND ret;
391
392 if (!(ptr = WIN_GetPtr( hwnd )) || ptr == WND_OTHER_PROCESS || ptr == WND_DESKTOP) return 0;
393 ret = ptr->hwndSelf;
394 WIN_ReleasePtr( ptr );
395 return ret;
396 }
397
398
399 /***********************************************************************
400 * WIN_IsCurrentThread
401 *
402 * Check whether a given window belongs to the current thread (and return the full handle).
403 */
404 HWND WIN_IsCurrentThread( HWND hwnd )
405 {
406 WND *ptr;
407 HWND ret = 0;
408
409 if (!(ptr = WIN_GetPtr( hwnd )) || ptr == WND_OTHER_PROCESS || ptr == WND_DESKTOP) return 0;
410 if (ptr->tid == GetCurrentThreadId()) ret = ptr->hwndSelf;
411 WIN_ReleasePtr( ptr );
412 return ret;
413 }
414
415
416 /***********************************************************************
417 * WIN_Handle32
418 *
419 * Convert a 16-bit window handle to a full 32-bit handle.
420 */
421 HWND WIN_Handle32( HWND16 hwnd16 )
422 {
423 WND *ptr;
424 HWND hwnd = (HWND)(ULONG_PTR)hwnd16;
425
426 if (hwnd16 <= 1 || hwnd16 == 0xffff) return hwnd;
427 /* do sign extension for -2 and -3 */
428 if (hwnd16 >= (HWND16)-3) return (HWND)(LONG_PTR)(INT16)hwnd16;
429
430 if (!(ptr = WIN_GetPtr( hwnd ))) return hwnd;
431
432 if (ptr == WND_DESKTOP) return GetDesktopWindow();
433
434 if (ptr != WND_OTHER_PROCESS)
435 {
436 hwnd = ptr->hwndSelf;
437 WIN_ReleasePtr( ptr );
438 }
439 else /* may belong to another process */
440 {
441 SERVER_START_REQ( get_window_info )
442 {
443 req->handle = hwnd;
444 if (!wine_server_call_err( req )) hwnd = reply->full_handle;
445 }
446 SERVER_END_REQ;
447 }
448 return hwnd;
449 }
450
451
452 /***********************************************************************
453 * WIN_SetOwner
454 *
455 * Change the owner of a window.
456 */
457 HWND WIN_SetOwner( HWND hwnd, HWND owner )
458 {
459 WND *win = WIN_GetPtr( hwnd );
460 HWND ret = 0;
461
462 if (!win || win == WND_DESKTOP) return 0;
463 if (win == WND_OTHER_PROCESS)
464 {
465 if (IsWindow(hwnd)) ERR( "cannot set owner %p on other process window %p\n", owner, hwnd );
466 return 0;
467 }
468 SERVER_START_REQ( set_window_owner )
469 {
470 req->handle = hwnd;
471 req->owner = owner;
472 if (!wine_server_call( req ))
473 {
474 win->owner = reply->full_owner;
475 ret = reply->prev_owner;
476 }
477 }
478 SERVER_END_REQ;
479 WIN_ReleasePtr( win );
480 return ret;
481 }
482
483
484 /***********************************************************************
485 * WIN_SetStyle
486 *
487 * Change the style of a window.
488 */
489 ULONG WIN_SetStyle( HWND hwnd, ULONG set_bits, ULONG clear_bits )
490 {
491 BOOL ok;
492 ULONG new_style, old_style = 0;
493 WND *win = WIN_GetPtr( hwnd );
494
495 if (!win || win == WND_DESKTOP) return 0;
496 if (win == WND_OTHER_PROCESS)
497 {
498 if (IsWindow(hwnd))
499 ERR( "cannot set style %x/%x on other process window %p\n",
500 set_bits, clear_bits, hwnd );
501 return 0;
502 }
503 new_style = (win->dwStyle | set_bits) & ~clear_bits;
504 if (new_style == win->dwStyle)
505 {
506 WIN_ReleasePtr( win );
507 return new_style;
508 }
509 SERVER_START_REQ( set_window_info )
510 {
511 req->handle = hwnd;
512 req->flags = SET_WIN_STYLE;
513 req->style = new_style;
514 req->extra_offset = -1;
515 if ((ok = !wine_server_call( req )))
516 {
517 old_style = reply->old_style;
518 win->dwStyle = new_style;
519 }
520 }
521 SERVER_END_REQ;
522 WIN_ReleasePtr( win );
523 if (ok) USER_Driver->pSetWindowStyle( hwnd, old_style );
524 return old_style;
525 }
526
527
528 /***********************************************************************
529 * WIN_GetRectangles
530 *
531 * Get the window and client rectangles.
532 */
533 BOOL WIN_GetRectangles( HWND hwnd, RECT *rectWindow, RECT *rectClient )
534 {
535 WND *win = WIN_GetPtr( hwnd );
536 BOOL ret = TRUE;
537
538 if (!win) return FALSE;
539 if (win == WND_DESKTOP)
540 {
541 RECT rect;
542 rect.left = rect.top = 0;
543 rect.right = GetSystemMetrics(SM_CXSCREEN);
544 rect.bottom = GetSystemMetrics(SM_CYSCREEN);
545 if (rectWindow) *rectWindow = rect;
546 if (rectClient) *rectClient = rect;
547 }
548 else if (win == WND_OTHER_PROCESS)
549 {
550 SERVER_START_REQ( get_window_rectangles )
551 {
552 req->handle = hwnd;
553 if ((ret = !wine_server_call( req )))
554 {
555 if (rectWindow)
556 {
557 rectWindow->left = reply->window.left;
558 rectWindow->top = reply->window.top;
559 rectWindow->right = reply->window.right;
560 rectWindow->bottom = reply->window.bottom;
561 }
562 if (rectClient)
563 {
564 rectClient->left = reply->client.left;
565 rectClient->top = reply->client.top;
566 rectClient->right = reply->client.right;
567 rectClient->bottom = reply->client.bottom;
568 }
569 }
570 }
571 SERVER_END_REQ;
572 }
573 else
574 {
575 if (rectWindow) *rectWindow = win->rectWindow;
576 if (rectClient) *rectClient = win->rectClient;
577 WIN_ReleasePtr( win );
578 }
579 return ret;
580 }
581
582
583 /***********************************************************************
584 * WIN_DestroyWindow
585 *
586 * Destroy storage associated to a window. "Internals" p.358
587 */
588 LRESULT WIN_DestroyWindow( HWND hwnd )
589 {
590 WND *wndPtr;
591 HWND *list;
592 HMENU menu = 0, sys_menu;
593
594 TRACE("%p\n", hwnd );
595
596 /* free child windows */
597 if ((list = WIN_ListChildren( hwnd )))
598 {
599 int i;
600 for (i = 0; list[i]; i++)
601 {
602 if (WIN_IsCurrentThread( list[i] )) WIN_DestroyWindow( list[i] );
603 else SendMessageW( list[i], WM_WINE_DESTROYWINDOW, 0, 0 );
604 }
605 HeapFree( GetProcessHeap(), 0, list );
606 }
607
608 /* Unlink now so we won't bother with the children later on */
609 SERVER_START_REQ( set_parent )
610 {
611 req->handle = hwnd;
612 req->parent = 0;
613 wine_server_call( req );
614 }
615 SERVER_END_REQ;
616
617 /*
618 * Send the WM_NCDESTROY to the window being destroyed.
619 */
620 SendMessageW( hwnd, WM_NCDESTROY, 0, 0 );
621
622 /* FIXME: do we need to fake QS_MOUSEMOVE wakebit? */
623
624 WINPOS_CheckInternalPos( hwnd );
625
626 /* free resources associated with the window */
627
628 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return 0;
629 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
630 menu = (HMENU)wndPtr->wIDmenu;
631 sys_menu = wndPtr->hSysMenu;
632 WIN_ReleasePtr( wndPtr );
633
634 if (menu) DestroyMenu( menu );
635 if (sys_menu) DestroyMenu( sys_menu );
636
637 USER_Driver->pDestroyWindow( hwnd );
638
639 free_window_handle( hwnd );
640 return 0;
641 }
642
643 /***********************************************************************
644 * WIN_DestroyThreadWindows
645 *
646 * Destroy all children of 'wnd' owned by the current thread.
647 */
648 void WIN_DestroyThreadWindows( HWND hwnd )
649 {
650 HWND *list;
651 int i;
652
653 if (!(list = WIN_ListChildren( hwnd ))) return;
654 for (i = 0; list[i]; i++)
655 {
656 if (WIN_IsCurrentThread( list[i] ))
657 DestroyWindow( list[i] );
658 else
659 WIN_DestroyThreadWindows( list[i] );
660 }
661 HeapFree( GetProcessHeap(), 0, list );
662 }
663
664
665 /***********************************************************************
666 * WIN_FixCoordinates
667 *
668 * Fix the coordinates - Helper for WIN_CreateWindowEx.
669 * returns default show mode in sw.
670 */
671 static void WIN_FixCoordinates( CREATESTRUCTA *cs, INT *sw)
672 {
673 #define IS_DEFAULT(x) ((x) == CW_USEDEFAULT || (x) == CW_USEDEFAULT16)
674 POINT pos[2];
675
676 if (cs->dwExStyle & WS_EX_MDICHILD)
677 {
678 UINT id = 0;
679
680 MDI_CalcDefaultChildPos(cs->hwndParent, -1, pos, 0, &id);
681 if (!(cs->style & WS_POPUP)) cs->hMenu = ULongToHandle(id);
682
683 TRACE("MDI child id %04x\n", id);
684 }
685
686 if (cs->style & (WS_CHILD | WS_POPUP))
687 {
688 if (cs->dwExStyle & WS_EX_MDICHILD)
689 {
690 if (IS_DEFAULT(cs->x))
691 {
692 cs->x = pos[0].x;
693 cs->y = pos[0].y;
694 }
695 if (IS_DEFAULT(cs->cx) || !cs->cx) cs->cx = pos[1].x;
696 if (IS_DEFAULT(cs->cy) || !cs->cy) cs->cy = pos[1].y;
697 }
698 else
699 {
700 if (IS_DEFAULT(cs->x)) cs->x = cs->y = 0;
701 if (IS_DEFAULT(cs->cx)) cs->cx = cs->cy = 0;
702 }
703 }
704 else /* overlapped window */
705 {
706 HMONITOR monitor;
707 MONITORINFO mon_info;
708 STARTUPINFOW info;
709
710 if (!IS_DEFAULT(cs->x) && !IS_DEFAULT(cs->cx) && !IS_DEFAULT(cs->cy)) return;
711
712 monitor = MonitorFromWindow( cs->hwndParent, MONITOR_DEFAULTTOPRIMARY );
713 mon_info.cbSize = sizeof(mon_info);
714 GetMonitorInfoW( monitor, &mon_info );
715 GetStartupInfoW( &info );
716
717 if (IS_DEFAULT(cs->x))
718 {
719 if (!IS_DEFAULT(cs->y)) *sw = cs->y;
720 cs->x = (info.dwFlags & STARTF_USEPOSITION) ? info.dwX : mon_info.rcWork.left;
721 cs->y = (info.dwFlags & STARTF_USEPOSITION) ? info.dwY : mon_info.rcWork.top;
722 }
723
724 if (IS_DEFAULT(cs->cx))
725 {
726 if (info.dwFlags & STARTF_USESIZE)
727 {
728 cs->cx = info.dwXSize;
729 cs->cy = info.dwYSize;
730 }
731 else
732 {
733 cs->cx = (mon_info.rcWork.right - mon_info.rcWork.left) * 3 / 4 - cs->x;
734 cs->cy = (mon_info.rcWork.bottom - mon_info.rcWork.top) * 3 / 4 - cs->y;
735 }
736 }
737 /* neither x nor cx are default. Check the y values .
738 * In the trace we see Outlook and Outlook Express using
739 * cy set to CW_USEDEFAULT when opening the address book.
740 */
741 else if (IS_DEFAULT(cs->cy))
742 {
743 FIXME("Strange use of CW_USEDEFAULT in nHeight\n");
744 cs->cy = (mon_info.rcWork.bottom - mon_info.rcWork.top) * 3 / 4 - cs->y;
745 }
746 }
747 #undef IS_DEFAULT
748 }
749
750 /***********************************************************************
751 * dump_window_styles
752 */
753 static void dump_window_styles( DWORD style, DWORD exstyle )
754 {
755 TRACE( "style:" );
756 if(style & WS_POPUP) TRACE(" WS_POPUP");
757 if(style & WS_CHILD) TRACE(" WS_CHILD");
758 if(style & WS_MINIMIZE) TRACE(" WS_MINIMIZE");
759 if(style & WS_VISIBLE) TRACE(" WS_VISIBLE");
760 if(style & WS_DISABLED) TRACE(" WS_DISABLED");
761 if(style & WS_CLIPSIBLINGS) TRACE(" WS_CLIPSIBLINGS");
762 if(style & WS_CLIPCHILDREN) TRACE(" WS_CLIPCHILDREN");
763 if(style & WS_MAXIMIZE) TRACE(" WS_MAXIMIZE");
764 if((style & WS_CAPTION) == WS_CAPTION) TRACE(" WS_CAPTION");
765 else
766 {
767 if(style & WS_BORDER) TRACE(" WS_BORDER");
768 if(style & WS_DLGFRAME) TRACE(" WS_DLGFRAME");
769 }
770 if(style & WS_VSCROLL) TRACE(" WS_VSCROLL");
771 if(style & WS_HSCROLL) TRACE(" WS_HSCROLL");
772 if(style & WS_SYSMENU) TRACE(" WS_SYSMENU");
773 if(style & WS_THICKFRAME) TRACE(" WS_THICKFRAME");
774 if (style & WS_CHILD)
775 {
776 if(style & WS_GROUP) TRACE(" WS_GROUP");
777 if(style & WS_TABSTOP) TRACE(" WS_TABSTOP");
778 }
779 else
780 {
781 if(style & WS_MINIMIZEBOX) TRACE(" WS_MINIMIZEBOX");
782 if(style & WS_MAXIMIZEBOX) TRACE(" WS_MAXIMIZEBOX");
783 }
784
785 /* FIXME: Add dumping of BS_/ES_/SBS_/LBS_/CBS_/DS_/etc. styles */
786 #define DUMPED_STYLES \
787 (WS_POPUP | \
788 WS_CHILD | \
789 WS_MINIMIZE | \
790 WS_VISIBLE | \
791 WS_DISABLED | \
792 WS_CLIPSIBLINGS | \
793 WS_CLIPCHILDREN | \
794 WS_MAXIMIZE | \
795 WS_BORDER | \
796 WS_DLGFRAME | \
797 WS_VSCROLL | \
798 WS_HSCROLL | \
799 WS_SYSMENU | \
800 WS_THICKFRAME | \
801 WS_GROUP | \
802 WS_TABSTOP | \
803 WS_MINIMIZEBOX | \
804 WS_MAXIMIZEBOX)
805
806 if(style & ~DUMPED_STYLES) TRACE(" %08lx", style & ~DUMPED_STYLES);
807 TRACE("\n");
808 #undef DUMPED_STYLES
809
810 TRACE( "exstyle:" );
811 if(exstyle & WS_EX_DLGMODALFRAME) TRACE(" WS_EX_DLGMODALFRAME");
812 if(exstyle & WS_EX_DRAGDETECT) TRACE(" WS_EX_DRAGDETECT");
813 if(exstyle & WS_EX_NOPARENTNOTIFY) TRACE(" WS_EX_NOPARENTNOTIFY");
814 if(exstyle & WS_EX_TOPMOST) TRACE(" WS_EX_TOPMOST");
815 if(exstyle & WS_EX_ACCEPTFILES) TRACE(" WS_EX_ACCEPTFILES");
816 if(exstyle & WS_EX_TRANSPARENT) TRACE(" WS_EX_TRANSPARENT");
817 if(exstyle & WS_EX_MDICHILD) TRACE(" WS_EX_MDICHILD");
818 if(exstyle & WS_EX_TOOLWINDOW) TRACE(" WS_EX_TOOLWINDOW");
819 if(exstyle & WS_EX_WINDOWEDGE) TRACE(" WS_EX_WINDOWEDGE");
820 if(exstyle & WS_EX_CLIENTEDGE) TRACE(" WS_EX_CLIENTEDGE");
821 if(exstyle & WS_EX_CONTEXTHELP) TRACE(" WS_EX_CONTEXTHELP");
822 if(exstyle & WS_EX_RIGHT) TRACE(" WS_EX_RIGHT");
823 if(exstyle & WS_EX_RTLREADING) TRACE(" WS_EX_RTLREADING");
824 if(exstyle & WS_EX_LEFTSCROLLBAR) TRACE(" WS_EX_LEFTSCROLLBAR");
825 if(exstyle & WS_EX_CONTROLPARENT) TRACE(" WS_EX_CONTROLPARENT");
826 if(exstyle & WS_EX_STATICEDGE) TRACE(" WS_EX_STATICEDGE");
827 if(exstyle & WS_EX_APPWINDOW) TRACE(" WS_EX_APPWINDOW");
828 if(exstyle & WS_EX_LAYERED) TRACE(" WS_EX_LAYERED");
829
830 #define DUMPED_EX_STYLES \
831 (WS_EX_DLGMODALFRAME | \
832 WS_EX_DRAGDETECT | \
833 WS_EX_NOPARENTNOTIFY | \
834 WS_EX_TOPMOST | \
835 WS_EX_ACCEPTFILES | \
836 WS_EX_TRANSPARENT | \
837 WS_EX_MDICHILD | \
838 WS_EX_TOOLWINDOW | \
839 WS_EX_WINDOWEDGE | \
840 WS_EX_CLIENTEDGE | \
841 WS_EX_CONTEXTHELP | \
842 WS_EX_RIGHT | \
843 WS_EX_RTLREADING | \
844 WS_EX_LEFTSCROLLBAR | \
845 WS_EX_CONTROLPARENT | \
846 WS_EX_STATICEDGE | \
847 WS_EX_APPWINDOW | \
848 WS_EX_LAYERED)
849
850 if(exstyle & ~DUMPED_EX_STYLES) TRACE(" %08lx", exstyle & ~DUMPED_EX_STYLES);
851 TRACE("\n");
852 #undef DUMPED_EX_STYLES
853 }
854
855
856 /***********************************************************************
857 * WIN_CreateWindowEx
858 *
859 * Implementation of CreateWindowEx().
860 */
861 static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, ATOM classAtom, UINT flags )
862 {
863 INT sw = SW_SHOW;
864 WND *wndPtr;
865 HWND hwnd, parent, owner, top_child = 0;
866 BOOL unicode = (flags & WIN_ISUNICODE) != 0;
867 MDICREATESTRUCTA mdi_cs;
868
869 TRACE("%s %s ex=%08x style=%08x %d,%d %dx%d parent=%p menu=%p inst=%p params=%p\n",
870 unicode ? debugstr_w((LPCWSTR)cs->lpszName) : debugstr_a(cs->lpszName),
871 unicode ? debugstr_w((LPCWSTR)cs->lpszClass) : debugstr_a(cs->lpszClass),
872 cs->dwExStyle, cs->style, cs->x, cs->y, cs->cx, cs->cy,
873 cs->hwndParent, cs->hMenu, cs->hInstance, cs->lpCreateParams );
874 if(TRACE_ON(win)) dump_window_styles( cs->style, cs->dwExStyle );
875
876 /* Fix the styles for MDI children */
877 if (cs->dwExStyle & WS_EX_MDICHILD)
878 {
879 UINT flags = 0;
880
881 wndPtr = WIN_GetPtr(cs->hwndParent);
882 if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
883 {
884 flags = wndPtr->flags;
885 WIN_ReleasePtr(wndPtr);
886 }
887
888 if (!(flags & WIN_ISMDICLIENT))
889 {
890 WARN("WS_EX_MDICHILD, but parent %p is not MDIClient\n", cs->hwndParent);
891 return 0;
892 }
893
894 /* cs->lpCreateParams of WM_[NC]CREATE is different for MDI children.
895 * MDICREATESTRUCT members have the originally passed values.
896 *
897 * Note: we rely on the fact that MDICREATESTRUCTA and MDICREATESTRUCTW
898 * have the same layout.
899 */
900 mdi_cs.szClass = cs->lpszClass;
901 mdi_cs.szTitle = cs->lpszName;
902 mdi_cs.hOwner = cs->hInstance;
903 mdi_cs.x = cs->x;
904 mdi_cs.y = cs->y;
905 mdi_cs.cx = cs->cx;
906 mdi_cs.cy = cs->cy;
907 mdi_cs.style = cs->style;
908 mdi_cs.lParam = (LPARAM)cs->lpCreateParams;
909
910 cs->lpCreateParams = (LPVOID)&mdi_cs;
911
912 if (GetWindowLongW(cs->hwndParent, GWL_STYLE) & MDIS_ALLCHILDSTYLES)
913 {
914 if (cs->style & WS_POPUP)
915 {
916 TRACE("WS_POPUP with MDIS_ALLCHILDSTYLES is not allowed\n");
917 return 0;
918 }
919 cs->style |= WS_CHILD | WS_CLIPSIBLINGS;
920 }
921 else
922 {
923 cs->style &= ~WS_POPUP;
924 cs->style |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CAPTION |
925 WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
926 }
927
928 top_child = GetWindow(cs->hwndParent, GW_CHILD);
929
930 if (top_child)
931 {
932 /* Restore current maximized child */
933 if((cs->style & WS_VISIBLE) && IsZoomed(top_child))
934 {
935 TRACE("Restoring current maximized child %p\n", top_child);
936 SendMessageW( top_child, WM_SETREDRAW, FALSE, 0 );
937 ShowWindow( top_child, SW_SHOWNORMAL );
938 SendMessageW( top_child, WM_SETREDRAW, TRUE, 0 );
939 }
940 }
941 }
942
943 /* Find the parent window */
944
945 parent = cs->hwndParent;
946 owner = 0;
947
948 if (cs->hwndParent == HWND_MESSAGE)
949 {
950 /* native ole32.OleInitialize uses HWND_MESSAGE to create the
951 * message window (style: WS_POPUP|WS_DISABLED)
952 */
953 FIXME("Parent is HWND_MESSAGE\n");
954 parent = GetDesktopWindow();
955 }
956 else if (cs->hwndParent)
957 {
958 if ((cs->style & (WS_CHILD|WS_POPUP)) != WS_CHILD)
959 {
960 parent = GetDesktopWindow();
961 owner = cs->hwndParent;
962 }
963 }
964 else
965 {
966 if ((cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
967 {
968 WARN("No parent for child window\n" );
969 SetLastError(ERROR_TLW_WITH_WSCHILD);
970 return 0; /* WS_CHILD needs a parent, but WS_POPUP doesn't */
971 }
972 if (classAtom != LOWORD(DESKTOP_CLASS_ATOM)) /* are we creating the desktop itself? */
973 parent = GetDesktopWindow();
974 }
975
976 WIN_FixCoordinates(cs, &sw); /* fix default coordinates */
977
978 if ((cs->dwExStyle & WS_EX_DLGMODALFRAME) ||
979 ((!(cs->dwExStyle & WS_EX_STATICEDGE)) &&
980 (cs->style & (WS_DLGFRAME | WS_THICKFRAME))))
981 cs->dwExStyle |= WS_EX_WINDOWEDGE;
982 else
983 cs->dwExStyle &= ~WS_EX_WINDOWEDGE;
984
985 /* Create the window structure */
986
987 if (!(wndPtr = create_window_handle( parent, owner, classAtom, cs->hInstance, unicode )))
988 return 0;
989 hwnd = wndPtr->hwndSelf;
990
991 /* Fill the window structure */
992
993 wndPtr->tid = GetCurrentThreadId();
994 wndPtr->hInstance = cs->hInstance;
995 wndPtr->text = NULL;
996 wndPtr->dwStyle = cs->style & ~WS_VISIBLE;
997 wndPtr->dwExStyle = cs->dwExStyle;
998 wndPtr->wIDmenu = 0;
999 wndPtr->helpContext = 0;
1000 wndPtr->pVScroll = NULL;
1001 wndPtr->pHScroll = NULL;
1002 wndPtr->userdata = 0;
1003 wndPtr->hIcon = 0;
1004 wndPtr->hIconSmall = 0;
1005 wndPtr->hSysMenu = 0;
1006 wndPtr->flags |= (flags & WIN_ISWIN32);
1007
1008 if (wndPtr->dwStyle & WS_SYSMENU) SetSystemMenu( hwnd, 0 );
1009
1010 /*
1011 * Correct the window styles.
1012 *
1013 * It affects only the style loaded into the WIN structure.
1014 */
1015
1016 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1017 {
1018 wndPtr->dwStyle |= WS_CLIPSIBLINGS;
1019 if (!(wndPtr->dwStyle & WS_POPUP))
1020 wndPtr->dwStyle |= WS_CAPTION;
1021 }
1022
1023 /*
1024 * WS_EX_WINDOWEDGE appears to be enforced based on the other styles, so
1025 * why does the user get to set it?
1026 */
1027
1028 if ((wndPtr->dwExStyle & WS_EX_DLGMODALFRAME) ||
1029 (wndPtr->dwStyle & (WS_DLGFRAME | WS_THICKFRAME)))
1030 wndPtr->dwExStyle |= WS_EX_WINDOWEDGE;
1031 else
1032 wndPtr->dwExStyle &= ~WS_EX_WINDOWEDGE;
1033
1034 if (!(wndPtr->dwStyle & (WS_CHILD | WS_POPUP)))
1035 wndPtr->flags |= WIN_NEED_SIZE;
1036
1037 SERVER_START_REQ( set_window_info )
1038 {
1039 req->handle = hwnd;
1040 req->flags = SET_WIN_STYLE | SET_WIN_EXSTYLE | SET_WIN_INSTANCE | SET_WIN_UNICODE;
1041 req->style = wndPtr->dwStyle;
1042 req->ex_style = wndPtr->dwExStyle;
1043 req->instance = (void *)wndPtr->hInstance;
1044 req->is_unicode = (wndPtr->flags & WIN_ISUNICODE) != 0;
1045 req->extra_offset = -1;
1046 wine_server_call( req );
1047 }
1048 SERVER_END_REQ;
1049
1050 /* Set the window menu */
1051
1052 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1053 {
1054 if (cs->hMenu)
1055 {
1056 if (!MENU_SetMenu(hwnd, cs->hMenu))
1057 {
1058 WIN_ReleasePtr( wndPtr );
1059 free_window_handle( hwnd );
1060 return 0;
1061 }
1062 }
1063 else
1064 {
1065 LPCSTR menuName = (LPCSTR)GetClassLongPtrA( hwnd, GCLP_MENUNAME );
1066 if (menuName)
1067 {
1068 if (!cs->hInstance || HIWORD(cs->hInstance))
1069 cs->hMenu = LoadMenuA(cs->hInstance,menuName);
1070 else
1071 cs->hMenu = HMENU_32(LoadMenu16(HINSTANCE_16(cs->hInstance),menuName));
1072
1073 if (cs->hMenu) MENU_SetMenu( hwnd, cs->hMenu );
1074 }
1075 }
1076 }
1077 else SetWindowLongPtrW( hwnd, GWLP_ID, (ULONG_PTR)cs->hMenu );
1078 WIN_ReleasePtr( wndPtr );
1079
1080 if (!USER_Driver->pCreateWindow( hwnd, cs, unicode))
1081 {
1082 WIN_DestroyWindow( hwnd );
1083 return 0;
1084 }
1085
1086 /* Notify the parent window only */
1087
1088 send_parent_notify( hwnd, WM_CREATE );
1089 if (!IsWindow( hwnd )) return 0;
1090
1091 if (cs->style & WS_VISIBLE)
1092 {
1093 if (cs->style & WS_MAXIMIZE)
1094 sw = SW_SHOW;
1095 else if (cs->style & WS_MINIMIZE)
1096 sw = SW_SHOWMINIMIZED;
1097
1098 ShowWindow( hwnd, sw );
1099 if (cs->dwExStyle & WS_EX_MDICHILD)
1100 {
1101 SendMessageW(cs->hwndParent, WM_MDIREFRESHMENU, 0, 0);
1102 /* ShowWindow won't activate child windows */
1103 SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE );
1104 }
1105 }
1106
1107 /* Call WH_SHELL hook */
1108
1109 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) && !GetWindow( hwnd, GW_OWNER ))
1110 HOOK_CallHooks( WH_SHELL, HSHELL_WINDOWCREATED, (WPARAM)hwnd, 0, TRUE );
1111
1112 TRACE("created window %p\n", hwnd);
1113 return hwnd;
1114 }
1115
1116
1117 /***********************************************************************
1118 * CreateWindow (USER.41)
1119 */
1120 HWND16 WINAPI CreateWindow16( LPCSTR className, LPCSTR windowName,
1121 DWORD style, INT16 x, INT16 y, INT16 width,
1122 INT16 height, HWND16 parent, HMENU16 menu,
1123 HINSTANCE16 instance, LPVOID data )
1124 {
1125 return CreateWindowEx16( 0, className, windowName, style,
1126 x, y, width, height, parent, menu, instance, data );
1127 }
1128
1129
1130 /***********************************************************************
1131 * CreateWindowEx (USER.452)
1132 */
1133 HWND16 WINAPI CreateWindowEx16( DWORD exStyle, LPCSTR className,
1134 LPCSTR windowName, DWORD style, INT16 x,
1135 INT16 y, INT16 width, INT16 height,
1136 HWND16 parent, HMENU16 menu,
1137 HINSTANCE16 instance, LPVOID data )
1138 {
1139 ATOM classAtom;
1140 CREATESTRUCTA cs;
1141 char buffer[256];
1142
1143 /* Find the class atom */
1144
1145 if (HIWORD(className))
1146 {
1147 if (!(classAtom = GlobalFindAtomA( className )))
1148 {
1149 ERR( "bad class name %s\n", debugstr_a(className) );
1150 return 0;
1151 }
1152 }
1153 else
1154 {
1155 classAtom = LOWORD(className);
1156 if (!GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) ))
1157 {
1158 ERR( "bad atom %x\n", classAtom);
1159 return 0;
1160 }
1161 className = buffer;
1162 }
1163
1164 /* Fix the coordinates */
1165
1166 cs.x = (x == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)x;
1167 cs.y = (y == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)y;
1168 cs.cx = (width == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)width;
1169 cs.cy = (height == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)height;
1170
1171 /* Create the window */
1172
1173 cs.lpCreateParams = data;
1174 cs.hInstance = HINSTANCE_32(instance);
1175 cs.hMenu = HMENU_32(menu);
1176 cs.hwndParent = WIN_Handle32( parent );
1177 cs.style = style;
1178 cs.lpszName = windowName;
1179 cs.lpszClass = className;
1180 cs.dwExStyle = exStyle;
1181
1182 return HWND_16( WIN_CreateWindowEx( &cs, classAtom, 0 ));
1183 }
1184
1185
1186 /***********************************************************************
1187 * CreateWindowExA (USER32.@)
1188 */
1189 HWND WINAPI CreateWindowExA( DWORD exStyle, LPCSTR className,
1190 LPCSTR windowName, DWORD style, INT x,
1191 INT y, INT width, INT height,
1192 HWND parent, HMENU menu,
1193 HINSTANCE instance, LPVOID data )
1194 {
1195 ATOM classAtom;
1196 CREATESTRUCTA cs;
1197 char buffer[256];
1198
1199 /* Find the class atom */
1200
1201 if (HIWORD(className))
1202 {
1203 if (!(classAtom = GlobalFindAtomA( className )))
1204 {
1205 ERR( "bad class name %s\n", debugstr_a(className) );
1206 return 0;
1207 }
1208 }
1209 else
1210 {
1211 classAtom = LOWORD(className);
1212 if (!GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) ))
1213 {
1214 ERR( "bad atom %x\n", classAtom);
1215 return 0;
1216 }
1217 className = buffer;
1218 }
1219
1220 /* Create the window */
1221
1222 cs.lpCreateParams = data;
1223 cs.hInstance = instance;
1224 cs.hMenu = menu;
1225 cs.hwndParent = parent;
1226 cs.x = x;
1227 cs.y = y;
1228 cs.cx = width;
1229 cs.cy = height;
1230 cs.style = style;
1231 cs.lpszName = windowName;
1232 cs.lpszClass = className;
1233 cs.dwExStyle = exStyle;
1234
1235 return WIN_CreateWindowEx( &cs, classAtom, WIN_ISWIN32 );
1236 }
1237
1238
1239 /***********************************************************************
1240 * CreateWindowExW (USER32.@)
1241 */
1242 HWND WINAPI CreateWindowExW( DWORD exStyle, LPCWSTR className,
1243 LPCWSTR windowName, DWORD style, INT x,
1244 INT y, INT width, INT height,
1245 HWND parent, HMENU menu,
1246 HINSTANCE instance, LPVOID data )
1247 {
1248 ATOM classAtom;
1249 CREATESTRUCTW cs;
1250 WCHAR buffer[256];
1251
1252 /* Find the class atom */
1253
1254 if (HIWORD(className))
1255 {
1256 if (!(classAtom = GlobalFindAtomW( className )))
1257 {
1258 ERR( "bad class name %s\n", debugstr_w(className) );
1259 return 0;
1260 }
1261 }
1262 else
1263 {
1264 classAtom = LOWORD(className);
1265 if (!GlobalGetAtomNameW( classAtom, buffer, sizeof(buffer)/sizeof(WCHAR) ))
1266 {
1267 ERR( "bad atom %x\n", classAtom);
1268 return 0;
1269 }
1270 className = buffer;
1271 }
1272
1273 /* Create the window */
1274
1275 cs.lpCreateParams = data;
1276 cs.hInstance = instance;
1277 cs.hMenu = menu;
1278 cs.hwndParent = parent;
1279 cs.x = x;
1280 cs.y = y;
1281 cs.cx = width;
1282 cs.cy = height;
1283 cs.style = style;
1284 cs.lpszName = windowName;
1285 cs.lpszClass = className;
1286 cs.dwExStyle = exStyle;
1287
1288 /* Note: we rely on the fact that CREATESTRUCTA and */
1289 /* CREATESTRUCTW have the same layout. */
1290 return WIN_CreateWindowEx( (CREATESTRUCTA *)&cs, classAtom, WIN_ISWIN32 | WIN_ISUNICODE );
1291 }
1292
1293
1294 /***********************************************************************
1295 * WIN_SendDestroyMsg
1296 */
1297 static void WIN_SendDestroyMsg( HWND hwnd )
1298 {
1299 GUITHREADINFO info;
1300
1301 if (GetGUIThreadInfo( GetCurrentThreadId(), &info ))
1302 {
1303 if (hwnd == info.hwndCaret) DestroyCaret();
1304 if (hwnd == info.hwndActive) WINPOS_ActivateOtherWindow( hwnd );
1305 }
1306
1307 /*
1308 * Send the WM_DESTROY to the window.
1309 */
1310 SendMessageW( hwnd, WM_DESTROY, 0, 0);
1311
1312 /*
1313 * This WM_DESTROY message can trigger re-entrant calls to DestroyWindow
1314 * make sure that the window still exists when we come back.
1315 */
1316 if (IsWindow(hwnd))
1317 {
1318 HWND* pWndArray;
1319 int i;
1320
1321 if (!(pWndArray = WIN_ListChildren( hwnd ))) return;
1322
1323 for (i = 0; pWndArray[i]; i++)
1324 {
1325 if (IsWindow( pWndArray[i] )) WIN_SendDestroyMsg( pWndArray[i] );
1326 }
1327 HeapFree( GetProcessHeap(), 0, pWndArray );
1328 }
1329 else
1330 WARN("\tdestroyed itself while in WM_DESTROY!\n");
1331 }
1332
1333
1334 /***********************************************************************
1335 * DestroyWindow (USER32.@)
1336 */
1337 BOOL WINAPI DestroyWindow( HWND hwnd )
1338 {
1339 BOOL is_child;
1340
1341 if (!(hwnd = WIN_IsCurrentThread( hwnd )) || (hwnd == GetDesktopWindow()))
1342 {
1343 SetLastError( ERROR_ACCESS_DENIED );
1344 return FALSE;
1345 }
1346
1347 TRACE("(%p)\n", hwnd);
1348
1349 /* Call hooks */
1350
1351 if (HOOK_CallHooks( WH_CBT, HCBT_DESTROYWND, (WPARAM)hwnd, 0, TRUE )) return FALSE;
1352
1353 if (MENU_IsMenuActive() == hwnd)
1354 EndMenu();
1355
1356 is_child = (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) != 0;
1357
1358 if (is_child)
1359 {
1360 if (!USER_IsExitingThread( GetCurrentThreadId() ))
1361 send_parent_notify( hwnd, WM_DESTROY );
1362 }
1363 else if (!GetWindow( hwnd, GW_OWNER ))
1364 {
1365 HOOK_CallHooks( WH_SHELL, HSHELL_WINDOWDESTROYED, (WPARAM)hwnd, 0L, TRUE );
1366 /* FIXME: clean up palette - see "Internals" p.352 */
1367 }
1368
1369 if (!IsWindow(hwnd)) return TRUE;
1370
1371 /* Hide the window */
1372 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)
1373 {
1374 /* Only child windows receive WM_SHOWWINDOW in DestroyWindow() */
1375 if (is_child)
1376 ShowWindow( hwnd, SW_HIDE );
1377 else
1378 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE |
1379 SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW );
1380 }
1381
1382 if (!IsWindow(hwnd)) return TRUE;
1383
1384 /* Recursively destroy owned windows */
1385
1386 if (!is_child)
1387 {
1388 for (;;)
1389 {
1390 int i, got_one = 0;
1391 HWND *list = WIN_ListChildren( GetDesktopWindow() );
1392 if (list)
1393 {
1394 for (i = 0; list[i]; i++)
1395 {
1396 if (GetWindow( list[i], GW_OWNER ) != hwnd) continue;
1397 if (WIN_IsCurrentThread( list[i] ))
1398 {
1399 DestroyWindow( list[i] );
1400 got_one = 1;
1401 continue;
1402 }
1403 WIN_SetOwner( list[i], 0 );
1404 }
1405 HeapFree( GetProcessHeap(), 0, list );
1406 }
1407 if (!got_one) break;
1408 }
1409 }
1410
1411 /* Send destroy messages */
1412
1413 WIN_SendDestroyMsg( hwnd );
1414 if (!IsWindow( hwnd )) return TRUE;
1415
1416 if (GetClipboardOwner() == hwnd)
1417 CLIPBOARD_ReleaseOwner();
1418
1419 /* Destroy the window storage */
1420
1421 WIN_DestroyWindow( hwnd );
1422 return TRUE;
1423 }
1424
1425
1426 /***********************************************************************
1427 * CloseWindow (USER32.@)
1428 */
1429 BOOL WINAPI CloseWindow( HWND hwnd )
1430 {
1431 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) return FALSE;
1432 ShowWindow( hwnd, SW_MINIMIZE );
1433 return TRUE;
1434 }
1435
1436
1437 /***********************************************************************
1438 * OpenIcon (USER32.@)
1439 */
1440 BOOL WINAPI OpenIcon( HWND hwnd )
1441 {
1442 if (!IsIconic( hwnd )) return FALSE;
1443 ShowWindow( hwnd, SW_SHOWNORMAL );
1444 return TRUE;
1445 }
1446
1447
1448 /***********************************************************************
1449 * WIN_FindWindow
1450 *
1451 * Implementation of FindWindow() and FindWindowEx().
1452 */
1453 static HWND WIN_FindWindow( HWND parent, HWND child, ATOM className, LPCWSTR title )
1454 {
1455 HWND *list = NULL;
1456 HWND retvalue = 0;
1457 int i = 0, len = 0;
1458 WCHAR *buffer = NULL;
1459
1460 if (!parent) parent = GetDesktopWindow();
1461 if (title)
1462 {
1463 len = strlenW(title) + 1; /* one extra char to check for chars beyond the end */
1464 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return 0;
1465 }
1466
1467 if (!(list = list_window_children( parent, className, 0 ))) goto done;
1468
1469 if (child)
1470 {
1471 child = WIN_GetFullHandle( child );
1472 while (list[i] && list[i] != child) i++;
1473 if (!list[i]) goto done;
1474 i++; /* start from next window */
1475 }
1476
1477 if (title)
1478 {
1479 while (list[i])
1480 {
1481 if (GetWindowTextW( list[i], buffer, len + 1 ) && !strcmpiW( buffer, title )) break;
1482 i++;
1483 }
1484 }
1485 retvalue = list[i];
1486
1487 done:
1488 HeapFree( GetProcessHeap(), 0, list );
1489 HeapFree( GetProcessHeap(), 0, buffer );
1490 return retvalue;
1491 }
1492
1493
1494
1495 /***********************************************************************
1496 * FindWindowA (USER32.@)
1497 */
1498 HWND WINAPI FindWindowA( LPCSTR className, LPCSTR title )
1499 {
1500 HWND ret = FindWindowExA( 0, 0, className, title );
1501 if (!ret) SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1502 return ret;
1503 }
1504
1505
1506 /***********************************************************************
1507 * FindWindowExA (USER32.@)
1508 */
1509 HWND WINAPI FindWindowExA( HWND parent, HWND child,
1510 LPCSTR className, LPCSTR title )
1511 {
1512 ATOM atom = 0;
1513 LPWSTR buffer;
1514 HWND hwnd;
1515 INT len;
1516
1517 if (className)
1518 {
1519 /* If the atom doesn't exist, then no class */
1520 /* with this name exists either. */
1521 if (!(atom = GlobalFindAtomA( className )))
1522 {
1523 SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1524 return 0;
1525 }
1526 }
1527 if (!title) return WIN_FindWindow( parent, child, atom, NULL );
1528
1529 len = MultiByteToWideChar( CP_ACP, 0, title, -1, NULL, 0 );
1530 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return 0;
1531 MultiByteToWideChar( CP_ACP, 0, title, -1, buffer, len );
1532 hwnd = WIN_FindWindow( parent, child, atom, buffer );
1533 HeapFree( GetProcessHeap(), 0, buffer );
1534 return hwnd;
1535 }
1536
1537
1538 /***********************************************************************
1539 * FindWindowExW (USER32.@)
1540 */
1541 HWND WINAPI FindWindowExW( HWND parent, HWND child,
1542 LPCWSTR className, LPCWSTR title )
1543 {
1544 ATOM atom = 0;
1545
1546 if (className)
1547 {
1548 /* If the atom doesn't exist, then no class */
1549 /* with this name exists either. */
1550 if (!(atom = GlobalFindAtomW( className )))
1551 {
1552 SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1553 return 0;
1554 }
1555 }
1556 return WIN_FindWindow( parent, child, atom, title );
1557 }
1558
1559
1560 /***********************************************************************
1561 * FindWindowW (USER32.@)
1562 */
1563 HWND WINAPI FindWindowW( LPCWSTR className, LPCWSTR title )
1564 {
1565 return FindWindowExW( 0, 0, className, title );
1566 }
1567
1568
1569 /**********************************************************************
1570 * GetDesktopWindow (USER32.@)
1571 */
1572 HWND WINAPI GetDesktopWindow(void)
1573 {
1574 struct user_thread_info *thread_info = get_user_thread_info();
1575
1576 if (thread_info->desktop) return thread_info->desktop;
1577
1578 SERVER_START_REQ( get_desktop_window )
1579 {
1580 req->force = 0;
1581 if (!wine_server_call( req )) thread_info->desktop = reply->handle;
1582 }
1583 SERVER_END_REQ;
1584
1585 if (!thread_info->desktop)
1586 {
1587 static const WCHAR command_line[] = {'\\','e','x','p','l','o','r','e','r','.','e','x','e',' ','/','d','e','s','k','t','o','p',0};
1588 STARTUPINFOW si;
1589 PROCESS_INFORMATION pi;
1590 WCHAR cmdline[MAX_PATH + sizeof(command_line)/sizeof(WCHAR)];
1591
1592 memset( &si, 0, sizeof(si) );
1593 si.cb = sizeof(si);
1594 GetSystemDirectoryW( cmdline, MAX_PATH );
1595 lstrcatW( cmdline, command_line );
1596 if (CreateProcessW( NULL, cmdline, NULL, NULL, FALSE, DETACHED_PROCESS,
1597 NULL, NULL, &si, &pi ))
1598 {
1599 TRACE( "started explorer pid %04x tid %04x\n", pi.dwProcessId, pi.dwThreadId );
1600 WaitForInputIdle( pi.hProcess, 10000 );
1601 CloseHandle( pi.hThread );
1602 CloseHandle( pi.hProcess );
1603
1604 }
1605 else WARN( "failed to start explorer, err %d\n", GetLastError() );
1606
1607 SERVER_START_REQ( get_desktop_window )
1608 {
1609 req->force = 1;
1610 if (!wine_server_call( req )) thread_info->desktop = reply->handle;
1611 }
1612 SERVER_END_REQ;
1613 }
1614
1615 if (!thread_info->desktop || !USER_Driver->pCreateDesktopWindow( thread_info->desktop ))
1616 ERR( "failed to create desktop window\n" );
1617
1618 return thread_info->desktop;
1619 }
1620
1621
1622 /*******************************************************************
1623 * EnableWindow (USER32.@)
1624 */
1625 BOOL WINAPI EnableWindow( HWND hwnd, BOOL enable )
1626 {
1627 BOOL retvalue;
1628 HWND full_handle;
1629
1630 if (is_broadcast(hwnd))
1631 {
1632 SetLastError( ERROR_INVALID_PARAMETER );
1633 return FALSE;
1634 }
1635
1636 if (!(full_handle = WIN_IsCurrentThread( hwnd )))
1637 return SendMessageW( hwnd, WM_WINE_ENABLEWINDOW, enable, 0 );
1638
1639 hwnd = full_handle;
1640
1641 TRACE("( %p, %d )\n", hwnd, enable);
1642
1643 retvalue = !IsWindowEnabled( hwnd );
1644
1645 if (enable && retvalue)
1646 {
1647 WIN_SetStyle( hwnd, 0, WS_DISABLED );
1648 SendMessageW( hwnd, WM_ENABLE, TRUE, 0 );
1649 }
1650 else if (!enable && !retvalue)
1651 {
1652 HWND capture_wnd;
1653
1654 SendMessageW( hwnd, WM_CANCELMODE, 0, 0);
1655
1656 WIN_SetStyle( hwnd, WS_DISABLED, 0 );
1657
1658 if (hwnd == GetFocus())
1659 SetFocus( 0 ); /* A disabled window can't have the focus */
1660
1661 capture_wnd = GetCapture();
1662 if (hwnd == capture_wnd || IsChild(hwnd, capture_wnd))
1663 ReleaseCapture(); /* A disabled window can't capture the mouse */
1664
1665 SendMessageW( hwnd, WM_ENABLE, FALSE, 0 );
1666 }
1667 return retvalue;
1668 }
1669
1670
1671 /***********************************************************************
1672 * IsWindowEnabled (USER32.@)
1673 */
1674 BOOL WINAPI IsWindowEnabled(HWND hWnd)
1675 {
1676 return !(GetWindowLongW( hWnd, GWL_STYLE ) & WS_DISABLED);
1677 }
1678
1679
1680 /***********************************************************************
1681 * IsWindowUnicode (USER32.@)
1682 */
1683 BOOL WINAPI IsWindowUnicode( HWND hwnd )
1684 {
1685 WND * wndPtr;
1686 BOOL retvalue = FALSE;
1687
1688 if (!(wndPtr = WIN_GetPtr(hwnd))) return FALSE;
1689
1690 if (wndPtr == WND_DESKTOP) return TRUE;
1691
1692 if (wndPtr != WND_OTHER_PROCESS)
1693 {
1694 retvalue = (wndPtr->flags & WIN_ISUNICODE) != 0;
1695 WIN_ReleasePtr( wndPtr );
1696 }
1697 else
1698 {
1699 SERVER_START_REQ( get_window_info )
1700 {
1701 req->handle = hwnd;
1702 if (!wine_server_call_err( req )) retvalue = reply->is_unicode;
1703 }
1704 SERVER_END_REQ;
1705 }
1706 return retvalue;
1707 }
1708
1709
1710 /**********************************************************************
1711 * WIN_GetWindowLong
1712 *
1713 * Helper function for GetWindowLong().
1714 */
1715 static LONG_PTR WIN_GetWindowLong( HWND hwnd, INT offset, UINT size, BOOL unicode )
1716 {
1717 LONG_PTR retvalue = 0;
1718 WND *wndPtr;
1719
1720 if (offset == GWLP_HWNDPARENT)
1721 {
1722 HWND parent = GetAncestor( hwnd, GA_PARENT );
1723 if (parent == GetDesktopWindow()) parent = GetWindow( hwnd, GW_OWNER );
1724 return (ULONG_PTR)parent;
1725 }
1726
1727 if (!(wndPtr = WIN_GetPtr( hwnd )))
1728 {
1729 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1730 return 0;
1731 }
1732
1733 if (wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP)
1734 {
1735 if (offset == GWLP_WNDPROC)
1736 {
1737 SetLastError( ERROR_ACCESS_DENIED );
1738 return 0;
1739 }
1740 SERVER_START_REQ( set_window_info )
1741 {
1742 req->handle = hwnd;
1743 req->flags = 0; /* don't set anything, just retrieve */
1744 req->extra_offset = (offset >= 0) ? offset : -1;
1745 req->extra_size = (offset >= 0) ? size : 0;
1746 if (!wine_server_call_err( req ))
1747 {
1748 switch(offset)
1749 {
1750 case GWL_STYLE: retvalue = reply->old_style; break;
1751 case GWL_EXSTYLE: retvalue = reply->old_ex_style; break;
1752 case GWLP_ID: retvalue = reply->old_id; break;
1753 case GWLP_HINSTANCE: retvalue = (ULONG_PTR)reply->old_instance; break;
1754 case GWLP_USERDATA: retvalue = reply->old_user_data; break;
1755 default:
1756 if (offset >= 0) retvalue = get_win_data( &reply->old_extra_value, size );
1757 else SetLastError( ERROR_INVALID_INDEX );
1758 break;
1759 }
1760 }
1761 }
1762 SERVER_END_REQ;
1763 return retvalue;
1764 }
1765
1766 /* now we have a valid wndPtr */
1767
1768 if (offset >= 0)
1769 {
1770 if (offset > (int)(wndPtr->cbWndExtra - size))
1771 {
1772 WARN("Invalid offset %d\n", offset );
1773 WIN_ReleasePtr( wndPtr );
1774 SetLastError( ERROR_INVALID_INDEX );
1775 return 0;
1776 }
1777 retvalue = get_win_data( (char *)wndPtr->wExtra + offset, size );
1778
1779 /* Special case for dialog window procedure */
1780 if ((offset == DWLP_DLGPROC) && (size == sizeof(LONG_PTR)) && (wndPtr->flags & WIN_ISDIALOG))
1781 retvalue = (LONG_PTR)WINPROC_GetProc( (WNDPROC)retvalue, unicode );
1782 WIN_ReleasePtr( wndPtr );
1783 return retvalue;
1784 }
1785
1786 switch(offset)
1787 {
1788 case GWLP_USERDATA: retvalue = wndPtr->userdata; break;
1789 case GWL_STYLE: retvalue = wndPtr->dwStyle; break;
1790 case GWL_EXSTYLE: retvalue = wndPtr->dwExStyle; break;
1791 case GWLP_ID: retvalue = (ULONG_PTR)wndPtr->wIDmenu; break;
1792 case GWLP_WNDPROC: retvalue = (ULONG_PTR)WINPROC_GetProc( wndPtr->winproc, unicode ); break;
1793 case GWLP_HINSTANCE: retvalue = (ULONG_PTR)wndPtr->hInstance; break;
1794 default:
1795 WARN("Unknown offset %d\n", offset );
1796 SetLastError( ERROR_INVALID_INDEX );
1797 break;
1798 }
1799 WIN_ReleasePtr(wndPtr);
1800 return retvalue;
1801 }
1802
1803
1804 /**********************************************************************
1805 * WIN_SetWindowLong
1806 *
1807 * Helper function for SetWindowLong().
1808 *
1809 * 0 is the failure code. However, in the case of failure SetLastError
1810 * must be set to distinguish between a 0 return value and a failure.
1811 */
1812 LONG_PTR WIN_SetWindowLong( HWND hwnd, INT offset, UINT size, LONG_PTR newval, BOOL unicode )
1813 {
1814 STYLESTRUCT style;
1815 BOOL ok;
1816 LONG_PTR retval = 0;
1817 WND *wndPtr;
1818
1819 TRACE( "%p %d %lx %c\n", hwnd, offset, newval, unicode ? 'W' : 'A' );
1820
1821 if (is_broadcast(hwnd))
1822 {
1823 SetLastError( ERROR_INVALID_PARAMETER );
1824 return FALSE;
1825 }
1826
1827 if (!(wndPtr = WIN_GetPtr( hwnd )))
1828 {
1829 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1830 return 0;
1831 }
1832 if (wndPtr == WND_DESKTOP)
1833 {
1834 /* can't change anything on the desktop window */
1835 SetLastError( ERROR_ACCESS_DENIED );
1836 return 0;
1837 }
1838 if (wndPtr == WND_OTHER_PROCESS)
1839 {
1840 if (offset == GWLP_WNDPROC)
1841 {
1842 SetLastError( ERROR_ACCESS_DENIED );
1843 return 0;
1844 }
1845 if (offset > 32767 || offset < -32767)
1846 {
1847 SetLastError( ERROR_INVALID_INDEX );
1848 return 0;
1849 }
1850 return SendMessageW( hwnd, WM_WINE_SETWINDOWLONG, MAKEWPARAM( offset, size ), newval );
1851 }
1852
1853 /* first some special cases */
1854 switch( offset )
1855 {
1856 case GWL_STYLE:
1857 case GWL_EXSTYLE:
1858 style.styleOld =
1859 offset == GWL_STYLE ? wndPtr->dwStyle : wndPtr->dwExStyle;
1860 style.styleNew = newval;
1861 WIN_ReleasePtr( wndPtr );
1862 SendMessageW( hwnd, WM_STYLECHANGING, offset, (LPARAM)&style );
1863 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return 0;
1864 newval = style.styleNew;
1865 break;
1866 case GWLP_HWNDPARENT:
1867 if (wndPtr->parent == GetDesktopWindow())
1868 {
1869 WIN_ReleasePtr( wndPtr );
1870 return (ULONG_PTR)WIN_SetOwner( hwnd, (HWND)newval );
1871 }
1872 else
1873 {
1874 WIN_ReleasePtr( wndPtr );
1875 return (ULONG_PTR)SetParent( hwnd, (HWND)newval );
1876 }
1877 case GWLP_WNDPROC:
1878 {
1879 WNDPROC proc;
1880 UINT old_flags = wndPtr->flags;
1881 retval = (ULONG_PTR)WINPROC_GetProc( wndPtr->winproc, unicode );
1882 if (unicode) proc = WINPROC_AllocProc( NULL, (WNDPROC)newval );
1883 else proc = WINPROC_AllocProc( (WNDPROC)newval, NULL );
1884 if (proc) wndPtr->winproc = proc;
1885 if (WINPROC_IsUnicode( proc, unicode )) wndPtr->flags |= WIN_ISUNICODE;
1886 else wndPtr->flags &= ~WIN_ISUNICODE;
1887 if (!((old_flags ^ wndPtr->flags) & WIN_ISUNICODE))
1888 {
1889 WIN_ReleasePtr( wndPtr );
1890 return retval;
1891 }
1892 /* update is_unicode flag on the server side */
1893 break;
1894 }
1895 case GWLP_ID:
1896 case GWLP_HINSTANCE:
1897 case GWLP_USERDATA:
1898 break;
1899 case DWLP_DLGPROC:
1900 if ((wndPtr->cbWndExtra - sizeof(LONG_PTR) >= DWLP_DLGPROC) &&
1901 (size == sizeof(LONG_PTR)) && (wndPtr->flags & WIN_ISDIALOG))
1902 {
1903 WNDPROC *ptr = (WNDPROC *)((char *)wndPtr->wExtra + DWLP_DLGPROC);
1904 retval = (ULONG_PTR)WINPROC_GetProc( *ptr, unicode );
1905 if (unicode) *ptr = WINPROC_AllocProc( NULL, (WNDPROC)newval );
1906 else *ptr = WINPROC_AllocProc( (WNDPROC)newval, NULL );
1907 WIN_ReleasePtr( wndPtr );
1908 return retval;
1909 }
1910 /* fall through */
1911 default:
1912 if (offset < 0 || offset > (int)(wndPtr->cbWndExtra - size))
1913 {
1914 WARN("Invalid offset %d\n", offset );
1915 WIN_ReleasePtr( wndPtr );
1916 SetLastError( ERROR_INVALID_INDEX );
1917 return 0;
1918 }
1919 else if (get_win_data( (char *)wndPtr->wExtra + offset, size ) == newval)
1920 {
1921 /* already set to the same value */
1922 WIN_ReleasePtr( wndPtr );
1923 return newval;
1924 }
1925 break;
1926 }
1927
1928 SERVER_START_REQ( set_window_info )
1929 {
1930 req->handle = hwnd;
1931 req->extra_offset = -1;
1932 switch(offset)
1933 {
1934 case GWL_STYLE:
1935 req->flags = SET_WIN_STYLE;
1936 req->style = newval;
1937 break;
1938 case GWL_EXSTYLE:
1939 req->flags = SET_WIN_EXSTYLE;
1940 req->ex_style = newval;
1941 break;
1942 case GWLP_ID:
1943 req->flags = SET_WIN_ID;
1944 req->id = newval;
1945 break;
1946 case GWLP_HINSTANCE:
1947 req->flags = SET_WIN_INSTANCE;
1948 req->instance = (void *)newval;
1949 break;
1950 case GWLP_WNDPROC:
1951 req->flags = SET_WIN_UNICODE;
1952 req->is_unicode = (wndPtr->flags & WIN_ISUNICODE) != 0;
1953 break;
1954 case GWLP_USERDATA:
1955 req->flags = SET_WIN_USERDATA;
1956 req->user_data = newval;
1957 break;
1958 default:
1959 req->flags = SET_WIN_EXTRA;
1960 req->extra_offset = offset;
1961 req->extra_size = size;
1962 set_win_data( &req->extra_value, newval, size );
1963 }
1964 if ((ok = !wine_server_call_err( req )))
1965 {
1966 switch(offset)
1967 {
1968 case GWL_STYLE:
1969 wndPtr->dwStyle = newval;
1970 retval = reply->old_style;
1971 break;
1972 case GWL_EXSTYLE:
1973 wndPtr->dwExStyle = newval;
1974 retval = reply->old_ex_style;
1975 break;
1976 case GWLP_ID:
1977 wndPtr->wIDmenu = newval;
1978 retval = reply->old_id;
1979 break;
1980 case GWLP_HINSTANCE:
1981 wndPtr->hInstance = (HINSTANCE)newval;
1982 retval = (ULONG_PTR)reply->old_instance;
1983 break;
1984 case GWLP_WNDPROC:
1985 break;
1986 case GWLP_USERDATA:
1987 wndPtr->userdata = newval;
1988 retval = reply->old_user_data;
1989 break;
1990 default:
1991 retval = get_win_data( (char *)wndPtr->wExtra + offset, size );
1992 set_win_data( (char *)wndPtr->wExtra + offset, newval, size );
1993 break;
1994 }
1995 }
1996 }
1997 SERVER_END_REQ;
1998 WIN_ReleasePtr( wndPtr );
1999
2000 if (!ok) return 0;
2001
2002 if (offset == GWL_STYLE) USER_Driver->pSetWindowStyle( hwnd, retval );
2003
2004 if (offset == GWL_STYLE || offset == GWL_EXSTYLE)
2005 SendMessageW( hwnd, WM_STYLECHANGED, offset, (LPARAM)&style );
2006
2007 return retval;
2008 }
2009
2010
2011 /**********************************************************************
2012 * GetWindowLong (USER.135)
2013 */
2014 LONG WINAPI GetWindowLong16( HWND16 hwnd, INT16 offset )
2015 {
2016 WND *wndPtr;
2017 LONG_PTR retvalue;
2018 BOOL is_winproc = (offset == GWLP_WNDPROC);
2019
2020 if (offset >= 0)
2021 {
2022 if (!(wndPtr = WIN_GetPtr( WIN_Handle32(hwnd) )))
2023 {
2024 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2025 return 0;
2026 }
2027 if (wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
2028 {
2029 if (offset > (int)(wndPtr->cbWndExtra - sizeof(LONG)))
2030 {
2031 /*
2032 * Some programs try to access last element from 16 bit
2033 * code using illegal offset value. Hopefully this is
2034 * what those programs really expect.
2035 */
2036 if (wndPtr->cbWndExtra >= 4 && offset == wndPtr->cbWndExtra - sizeof(WORD))
2037 {
2038 INT offset2 = wndPtr->cbWndExtra - sizeof(LONG);
2039 ERR( "- replaced invalid offset %d with %d\n", offset, offset2 );
2040 offset = offset2;
2041 }
2042 else
2043 {
2044 WARN("Invalid offset %d\n", offset );
2045 WIN_ReleasePtr( wndPtr );
2046 SetLastError( ERROR_INVALID_INDEX );
2047 return 0;
2048 }
2049 }
2050 is_winproc = ((offset == DWLP_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG));
2051 WIN_ReleasePtr( wndPtr );
2052 }
2053 }
2054 retvalue = GetWindowLongA( WIN_Handle32(hwnd), offset );
2055 if (is_winproc) retvalue = (LONG_PTR)WINPROC_GetProc16( (WNDPROC)retvalue, FALSE );
2056 return retvalue;
2057 }
2058
2059
2060 /**********************************************************************
2061 * GetWindowWord (USER32.@)
2062 */
2063 WORD WINAPI GetWindowWord( HWND hwnd, INT offset )
2064 {
2065 switch(offset)
2066 {
2067 case GWLP_ID:
2068 case GWLP_HINSTANCE:
2069 case GWLP_HWNDPARENT:
2070 break;
2071 default:
2072 if (offset < 0)
2073 {
2074 WARN("Invalid offset %d\n", offset );
2075 SetLastError( ERROR_INVALID_INDEX );
2076 return 0;
2077 }
2078 break;
2079 }
2080 return WIN_GetWindowLong( hwnd, offset, sizeof(WORD), FALSE );
2081 }
2082
2083
2084 /**********************************************************************
2085 * GetWindowLongA (USER32.@)
2086 */
2087 LONG WINAPI GetWindowLongA( HWND hwnd, INT offset )
2088 {
2089 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG), FALSE );
2090 }
2091
2092
2093 /**********************************************************************
2094 * GetWindowLongW (USER32.@)
2095 */
2096 LONG WINAPI GetWindowLongW( HWND hwnd, INT offset )
2097 {
2098 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG), TRUE );
2099 }
2100
2101
2102 /**********************************************************************
2103 * SetWindowLong (USER.136)
2104 */
2105 LONG WINAPI SetWindowLong16( HWND16 hwnd, INT16 offset, LONG newval )
2106 {
2107 WND *wndPtr;
2108 BOOL is_winproc = (offset == GWLP_WNDPROC);
2109
2110 if (offset == DWLP_DLGPROC)
2111 {
2112 if (!(wndPtr = WIN_GetPtr( WIN_Handle32(hwnd) )))
2113 {
2114 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2115 return 0;
2116 }
2117 if (wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
2118 {
2119 is_winproc = ((wndPtr->cbWndExtra - sizeof(LONG_PTR) >= DWLP_DLGPROC) &&
2120 (wndPtr->flags & WIN_ISDIALOG));
2121 WIN_ReleasePtr( wndPtr );
2122 }
2123 }
2124
2125 if (is_winproc)
2126 {
2127 WNDPROC new_proc = WINPROC_AllocProc16( (WNDPROC16)newval );
2128 WNDPROC old_proc = (WNDPROC)SetWindowLongPtrA( WIN_Handle32(hwnd), offset, (LONG_PTR)new_proc );
2129 return (LONG)WINPROC_GetProc16( (WNDPROC)old_proc, FALSE );
2130 }
2131 else return SetWindowLongA( WIN_Handle32(hwnd), offset, newval );
2132 }
2133
2134
2135 /**********************************************************************
2136 * SetWindowWord (USER32.@)
2137 */
2138 WORD WINAPI SetWindowWord( HWND hwnd, INT offset, WORD newval )
2139 {
2140 switch(offset)
2141 {
2142 case GWLP_ID:
2143 case GWLP_HINSTANCE:
2144 case GWLP_HWNDPARENT:
2145 break;
2146 default:
2147 if (offset < 0)
2148 {
2149 WARN("Invalid offset %d\n", offset );
2150 SetLastError( ERROR_INVALID_INDEX );
2151 return 0;
2152 }
2153 break;
2154 }
2155 return WIN_SetWindowLong( hwnd, offset, sizeof(WORD), newval, FALSE );
2156 }
2157
2158
2159 /**********************************************************************
2160 * SetWindowLongA (USER32.@)
2161 *
2162 * See SetWindowLongW.
2163 */
2164 LONG WINAPI SetWindowLongA( HWND hwnd, INT offset, LONG newval )
2165 {
2166 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG), newval, FALSE );
2167 }
2168
2169
2170 /**********************************************************************
2171 * SetWindowLongW (USER32.@) Set window attribute
2172 *
2173 * SetWindowLong() alters one of a window's attributes or sets a 32-bit (long)
2174 * value in a window's extra memory.
2175 *
2176 * The _hwnd_ parameter specifies the window. is the handle to a
2177 * window that has extra memory. The _newval_ parameter contains the
2178 * new attribute or extra memory value. If positive, the _offset_
2179 * parameter is the byte-addressed location in the window's extra
2180 * memory to set. If negative, _offset_ specifies the window
2181 * attribute to set, and should be one of the following values:
2182 *
2183 * GWL_EXSTYLE The window's extended window style
2184 *
2185 * GWL_STYLE The window's window style.
2186 *
2187 * GWLP_WNDPROC Pointer to the window's window procedure.
2188 *
2189 * GWLP_HINSTANCE The window's pplication instance handle.
2190 *
2191 * GWLP_ID The window's identifier.
2192 *
2193 * GWLP_USERDATA The window's user-specified data.
2194 *
2195 * If the window is a dialog box, the _offset_ parameter can be one of
2196 * the following values:
2197 *
2198 * DWLP_DLGPROC The address of the window's dialog box procedure.
2199 *
2200 * DWLP_MSGRESULT The return value of a message
2201 * that the dialog box procedure processed.
2202 *
2203 * DWLP_USER Application specific information.
2204 *
2205 * RETURNS
2206 *
2207 * If successful, returns the previous value located at _offset_. Otherwise,
2208 * returns 0.
2209 *
2210 * NOTES
2211 *
2212 * Extra memory for a window class is specified by a nonzero cbWndExtra
2213 * parameter of the WNDCLASS structure passed to RegisterClass() at the
2214 * time of class creation.
2215 *
2216 * Using GWL_WNDPROC to set a new window procedure effectively creates
2217 * a window subclass. Use CallWindowProc() in the new windows procedure
2218 * to pass messages to the superclass's window procedure.
2219 *
2220 * The user data is reserved for use by the application which created
2221 * the window.
2222 *
2223 * Do not use GWL_STYLE to change the window's WS_DISABLED style;
2224 * instead, call the EnableWindow() function to change the window's
2225 * disabled state.
2226 *
2227 * Do not use GWL_HWNDPARENT to reset the window's parent, use
2228 * SetParent() instead.
2229 *
2230 * Win95:
2231 * When offset is GWL_STYLE and the calling app's ver is 4.0,
2232 * it sends WM_STYLECHANGING before changing the settings
2233 * and WM_STYLECHANGED afterwards.
2234 * App ver 4.0 can't use SetWindowLong to change WS_EX_TOPMOST.
2235 */
2236 LONG WINAPI SetWindowLongW(
2237 HWND hwnd, /* [in] window to alter */
2238 INT offset, /* [in] offset, in bytes, of location to alter */
2239 LONG newval /* [in] new value of location */
2240 ) {
2241 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG), newval, TRUE );
2242 }
2243
2244
2245 /*******************************************************************
2246 * GetWindowTextA (USER32.@)
2247 */
2248 INT WINAPI GetWindowTextA( HWND hwnd, LPSTR lpString, INT nMaxCount )
2249 {
2250 WCHAR *buffer;
2251
2252 if (!lpString) return 0;
2253
2254 if (WIN_IsCurrentProcess( hwnd ))
2255 return (INT)SendMessageA( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2256
2257 /* when window belongs to other process, don't send a message */
2258 if (nMaxCount <= 0) return 0;
2259 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, nMaxCount * sizeof(WCHAR) ))) return 0;
2260 get_server_window_text( hwnd, buffer, nMaxCount );
2261 if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, lpString, nMaxCount, NULL, NULL ))
2262 lpString[nMaxCount-1] = 0;
2263 HeapFree( GetProcessHeap(), 0, buffer );
2264 return strlen(lpString);
2265 }
2266
2267
2268 /*******************************************************************
2269 * InternalGetWindowText (USER32.@)
2270 */
2271 INT WINAPI InternalGetWindowText(HWND hwnd,LPWSTR lpString,INT nMaxCount )
2272 {
2273 WND *win;
2274
2275 if (nMaxCount <= 0) return 0;
2276 if (!(win = WIN_GetPtr( hwnd ))) return 0;
2277 if (win == WND_DESKTOP) lpString[0] = 0;
2278 else if (win != WND_OTHER_PROCESS)
2279 {
2280 if (win->text) lstrcpynW( lpString, win->text, nMaxCount );
2281 else lpString[0] = 0;
2282 WIN_ReleasePtr( win );
2283 }
2284 else
2285 {
2286 get_server_window_text( hwnd, lpString, nMaxCount );
2287 }
2288 return strlenW(lpString);
2289 }
2290
2291
2292 /*******************************************************************
2293 * GetWindowTextW (USER32.@)
2294 */
2295 INT WINAPI GetWindowTextW( HWND hwnd, LPWSTR lpString, INT nMaxCount )
2296 {
2297 if (!lpString) return 0;
2298
2299 if (WIN_IsCurrentProcess( hwnd ))
2300 return (INT)SendMessageW( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2301
2302 /* when window belongs to other process, don't send a message */
2303 if (nMaxCount <= 0) return 0;
2304 get_server_window_text( hwnd, lpString, nMaxCount );
2305 return strlenW(lpString);
2306 }
2307
2308
2309 /*******************************************************************
2310 * SetWindowTextA (USER32.@)
2311 * SetWindowText (USER32.@)
2312 */
2313 BOOL WINAPI SetWindowTextA( HWND hwnd, LPCSTR lpString )
2314 {
2315 if (is_broadcast(hwnd))
2316 {
2317 SetLastError( ERROR_INVALID_PARAMETER );
2318 return FALSE;
2319 }
2320 if (!WIN_IsCurrentProcess( hwnd ))
2321 WARN( "setting text %s of other process window %p should not use SendMessage\n",
2322 debugstr_a(lpString), hwnd );
2323 return (BOOL)SendMessageA( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2324 }
2325
2326
2327 /*******************************************************************
2328 * SetWindowTextW (USER32.@)
2329 */
2330 BOOL WINAPI SetWindowTextW( HWND hwnd, LPCWSTR lpString )
2331 {
2332 if (is_broadcast(hwnd))
2333 {
2334 SetLastError( ERROR_INVALID_PARAMETER );
2335 return FALSE;
2336 }
2337 if (!WIN_IsCurrentProcess( hwnd ))
2338 WARN( "setting text %s of other process window %p should not use SendMessage\n",
2339 debugstr_w(lpString), hwnd );
2340 return (BOOL)SendMessageW( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2341 }
2342
2343
2344 /*******************************************************************
2345 * GetWindowTextLengthA (USER32.@)
2346 */
2347 INT WINAPI GetWindowTextLengthA( HWND hwnd )
2348 {
2349 return SendMessageA( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2350 }
2351
2352 /*******************************************************************
2353 * GetWindowTextLengthW (USER32.@)
2354 */
2355 INT WINAPI GetWindowTextLengthW( HWND hwnd )
2356 {
2357 return SendMessageW( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2358 }
2359
2360
2361 /*******************************************************************
2362 * IsWindow (USER32.@)
2363 */
2364 BOOL WINAPI IsWindow( HWND hwnd )
2365 {
2366 WND *ptr;
2367 BOOL ret;
2368
2369 if (!(ptr = WIN_GetPtr( hwnd ))) return FALSE;
2370 if (ptr == WND_DESKTOP) return TRUE;
2371
2372 if (ptr != WND_OTHER_PROCESS)
2373 {
2374 WIN_ReleasePtr( ptr );
2375 return TRUE;
2376 }
2377
2378 /* check other processes */
2379 SERVER_START_REQ( get_window_info )
2380 {
2381 req->handle = hwnd;
2382 ret = !wine_server_call_err( req );
2383 }
2384 SERVER_END_REQ;
2385 return ret;
2386 }
2387
2388
2389 /***********************************************************************
2390 * GetWindowThreadProcessId (USER32.@)
2391 */
2392 DWORD WINAPI GetWindowThreadProcessId( HWND hwnd, LPDWORD process )
2393 {
2394 WND *ptr;
2395 DWORD tid = 0;
2396
2397 if (!(ptr = WIN_GetPtr( hwnd )))
2398 {
2399 SetLastError( ERROR_INVALID_WINDOW_HANDLE);
2400 return 0;
2401 }
2402
2403 if (ptr != WND_OTHER_PROCESS && ptr != WND_DESKTOP)
2404 {
2405 /* got a valid window */
2406 tid = ptr->tid;
2407 if (process) *process = GetCurrentProcessId();
2408 WIN_ReleasePtr( ptr );
2409 return tid;
2410 }
2411
2412 /* check other processes */
2413 SERVER_START_REQ( get_window_info )
2414 {
2415 req->handle = hwnd;
2416 if (!wine_server_call_err( req ))
2417 {
2418 tid = (DWORD)reply->tid;
2419 if (process) *process = (DWORD)reply->pid;
2420 }
2421 }
2422 SERVER_END_REQ;
2423 return tid;
2424 }
2425
2426
2427 /*****************************************************************
2428 * GetParent (USER32.@)
2429 */
2430 HWND WINAPI GetParent( HWND hwnd )
2431 {
2432 WND *wndPtr;
2433 HWND retvalue = 0;
2434
2435 if (!(wndPtr = WIN_GetPtr( hwnd )))
2436 {
2437 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2438 return 0;
2439 }
2440 if (wndPtr == WND_DESKTOP) return 0;
2441 if (wndPtr == WND_OTHER_PROCESS)
2442 {
2443 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
2444 if (style & (WS_POPUP | WS_CHILD))
2445 {
2446 SERVER_START_REQ( get_window_tree )
2447 {
2448 req->handle = hwnd;
2449 if (!wine_server_call_err( req ))
2450 {
2451 if (style & WS_POPUP) retvalue = reply->owner;
2452 else if (style & WS_CHILD) retvalue = reply->parent;
2453 }
2454 }
2455 SERVER_END_REQ;
2456 }
2457 }
2458 else
2459 {
2460 if (wndPtr->dwStyle & WS_POPUP) retvalue = wndPtr->owner;
2461 else if (wndPtr->dwStyle & WS_CHILD) retvalue = wndPtr->parent;
2462 WIN_ReleasePtr( wndPtr );
2463 }
2464 return retvalue;
2465 }
2466
2467
2468 /*****************************************************************
2469 * GetAncestor (USER32.@)
2470 */
2471 HWND WINAPI GetAncestor( HWND hwnd, UINT type )
2472 {
2473 WND *win;
2474 HWND *list, ret = 0;
2475
2476 switch(type)
2477 {
2478 case GA_PARENT:
2479 if (!(win = WIN_GetPtr( hwnd )))
2480 {
2481 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2482 return 0;
2483 }
2484 if (win == WND_DESKTOP) return 0;
2485 if (win != WND_OTHER_PROCESS)
2486 {
2487 ret = win->parent;
2488 WIN_ReleasePtr( win );
2489 }
2490 else /* need to query the server */
2491 {
2492 SERVER_START_REQ( get_window_tree )
2493 {
2494 req->handle = hwnd;
2495 if (!wine_server_call_err( req )) ret = reply->parent;
2496 }
2497 SERVER_END_REQ;
2498 }
2499 break;
2500
2501 case GA_ROOT:
2502 if (!(list = list_window_parents( hwnd ))) return 0;
2503
2504 if (!list[0] || !list[1]) ret = WIN_GetFullHandle( hwnd ); /* top-level window */
2505 else
2506 {
2507 int count = 2;
2508 while (list[count]) count++;
2509 ret = list[count - 2]; /* get the one before the desktop */
2510 }
2511 HeapFree( GetProcessHeap(), 0, list );
2512 break;
2513
2514 case GA_ROOTOWNER:
2515 if ((ret = WIN_GetFullHandle( hwnd )) == GetDesktopWindow()) return 0;
2516 for (;;)
2517 {
2518 HWND parent = GetParent( ret );
2519 if (!parent) break;
2520 ret = parent;
2521 }
2522 break;
2523 }
2524 return ret;
2525 }
2526
2527
2528 /*****************************************************************
2529 * SetParent (USER32.@)
2530 */
2531 HWND WINAPI SetParent( HWND hwnd, HWND parent )
2532 {
2533 HWND full_handle;
2534 HWND old_parent = 0;
2535 BOOL was_visible;
2536 WND *wndPtr;
2537 BOOL ret;
2538
2539 if (is_broadcast(hwnd) || is_broadcast(parent))
2540 {
2541 SetLastError(ERROR_INVALID_PARAMETER);
2542 return 0;
2543 }
2544
2545 if (!parent) parent = GetDesktopWindow();
2546 else parent = WIN_GetFullHandle( parent );
2547
2548 if (!IsWindow( parent ))
2549 {
2550 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2551 return 0;
2552 }
2553
2554 /* Some applications try to set a child as a parent */
2555 if (IsChild(hwnd, parent))
2556 {
2557 SetLastError( ERROR_INVALID_PARAMETER );
2558 return 0;
2559 }
2560
2561 if (!(full_handle = WIN_IsCurrentThread( hwnd )))
2562 return (HWND)SendMessageW( hwnd, WM_WINE_SETPARENT, (WPARAM)parent, 0 );
2563
2564 /* Windows hides the window first, then shows it again
2565 * including the WM_SHOWWINDOW messages and all */
2566 was_visible = ShowWindow( hwnd, SW_HIDE );
2567
2568 wndPtr = WIN_GetPtr( hwnd );
2569 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return 0;
2570
2571 SERVER_START_REQ( set_parent )
2572 {
2573 req->handle = hwnd;
2574 req->parent = parent;
2575 if ((ret = !wine_server_call( req )))
2576 {
2577 old_parent = reply->old_parent;
2578 wndPtr->parent = parent = reply->full_parent;
2579 }
2580
2581 }
2582 SERVER_END_REQ;
2583 WIN_ReleasePtr( wndPtr );
2584 if (!ret) return 0;
2585
2586 USER_Driver->pSetParent( full_handle, parent, old_parent );
2587
2588 /* SetParent additionally needs to make hwnd the topmost window
2589 in the x-order and send the expected WM_WINDOWPOSCHANGING and
2590 WM_WINDOWPOSCHANGED notification messages.
2591 */
2592 SetWindowPos( hwnd, HWND_TOPMOST, 0, 0, 0, 0,
2593 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | (was_visible ? SWP_SHOWWINDOW : 0) );
2594 /* FIXME: a WM_MOVE is also generated (in the DefWindowProc handler
2595 * for WM_WINDOWPOSCHANGED) in Windows, should probably remove SWP_NOMOVE */
2596
2597 return old_parent;
2598 }
2599
2600
2601 /*******************************************************************
2602 * IsChild (USER32.@)
2603 */
2604 BOOL WINAPI IsChild( HWND parent, HWND child )
2605 {
2606 HWND *list = list_window_parents( child );
2607 int i;
2608 BOOL ret;
2609
2610 if (!list) return FALSE;
2611 parent = WIN_GetFullHandle( parent );
2612 for (i = 0; list[i]; i++) if (list[i] == parent) break;
2613 ret = (list[i] != 0);
2614 HeapFree( GetProcessHeap(), 0, list );
2615 return ret;
2616 }
2617
2618
2619 /***********************************************************************
2620 * IsWindowVisible (USER32.@)
2621 */
2622 BOOL WINAPI IsWindowVisible( HWND hwnd )
2623 {
2624 HWND *list;
2625 BOOL retval = TRUE;
2626 int i;
2627
2628 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)) return FALSE;
2629 if (!(list = list_window_parents( hwnd ))) return TRUE;
2630 if (list[0] && list[1]) /* desktop window is considered always visible so we don't check it */
2631 {
2632 for (i = 0; list[i+1]; i++)
2633 if (!(GetWindowLongW( list[i], GWL_STYLE ) & WS_VISIBLE)) break;
2634 retval = !list[i+1];
2635 }
2636 HeapFree( GetProcessHeap(), 0, list );
2637 return retval;
2638 }
2639
2640
2641 /***********************************************************************
2642 * WIN_IsWindowDrawable
2643 *
2644 * hwnd is drawable when it is visible, all parents are not
2645 * minimized, and it is itself not minimized unless we are
2646 * trying to draw its default class icon.
2647 */
2648 BOOL WIN_IsWindowDrawable( HWND hwnd, BOOL icon )
2649 {
2650 HWND *list;
2651 BOOL retval = TRUE;
2652 int i;
2653 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
2654
2655 if (!(style & WS_VISIBLE)) return FALSE;
2656 if ((style & WS_MINIMIZE) && icon && GetClassLongPtrW( hwnd, GCLP_HICON )) return FALSE;
2657
2658 if (!(list = list_window_parents( hwnd ))) return TRUE;
2659 if (list[0] && list[1]) /* desktop window is considered always visible so we don't check it */
2660 {
2661 for (i = 0; list[i+1]; i++)
2662 if ((GetWindowLongW( list[i], GWL_STYLE ) & (WS_VISIBLE|WS_MINIMIZE)) != WS_VISIBLE)
2663 break;
2664 retval = !list[i+1];
2665 }
2666 HeapFree( GetProcessHeap(), 0, list );
2667 return retval;
2668 }
2669
2670
2671 /*******************************************************************
2672 * GetTopWindow (USER32.@)
2673 */
2674 HWND WINAPI GetTopWindow( HWND hwnd )
2675 {
2676 if (!hwnd) hwnd = GetDesktopWindow();
2677 return GetWindow( hwnd, GW_CHILD );
2678 }
2679
2680
2681 /*******************************************************************
2682 * GetWindow (USER32.@)
2683 */
2684 HWND WINAPI GetWindow( HWND hwnd, UINT rel )
2685 {
2686 HWND retval = 0;
2687
2688 if (rel == GW_OWNER) /* this one may be available locally */
2689 {
2690 WND *wndPtr = WIN_GetPtr( hwnd );
2691 if (!wndPtr)
2692 {
2693 SetLastError( ERROR_INVALID_HANDLE );
2694 return 0;
2695 }
2696 if (wndPtr == WND_DESKTOP) return 0;
2697 if (wndPtr != WND_OTHER_PROCESS)
2698 {
2699 retval = wndPtr->owner;
2700 WIN_ReleasePtr( wndPtr );
2701 return retval;
2702 }
2703 /* else fall through to server call */
2704 }
2705
2706 SERVER_START_REQ( get_window_tree )
2707 {
2708 req->handle = hwnd;
2709 if (!wine_server_call_err( req ))
2710 {
2711 switch(rel)
2712 {
2713 case GW_HWNDFIRST:
2714 retval = reply->first_sibling;
2715 break;
2716 case GW_HWNDLAST:
2717 retval = reply->last_sibling;
2718 break;
2719 case GW_HWNDNEXT:
2720 retval = reply->next_sibling;
2721 break;
2722 case GW_HWNDPREV:
2723 retval = reply->prev_sibling;
2724 break;
2725 case GW_OWNER:
2726 retval = reply->owner;
2727 break;
2728 case GW_CHILD:
2729 retval = reply->first_child;
2730 break;
2731 }
2732 }
2733 }
2734 SERVER_END_REQ;
2735 return retval;
2736 }
2737
2738
2739 /*******************************************************************
2740 * ShowOwnedPopups (USER32.@)
2741 */
2742 BOOL WINAPI ShowOwnedPopups( HWND owner, BOOL fShow )
2743 {
2744 int count = 0;
2745 WND *pWnd;
2746 HWND *win_array = WIN_ListChildren( GetDesktopWindow() );
2747
2748 if (!win_array) return TRUE;
2749
2750 while (win_array[count]) count++;
2751 while (--count >= 0)
2752 {
2753 if (GetWindow( win_array[count], GW_OWNER ) != owner) continue;
2754 if (!(pWnd = WIN_GetPtr( win_array[count] ))) continue;
2755 if (pWnd == WND_OTHER_PROCESS) continue;
2756 if (fShow)
2757 {
2758 if (pWnd->flags & WIN_NEEDS_SHOW_OWNEDPOPUP)
2759 {
2760 WIN_ReleasePtr( pWnd );
2761 /* In Windows, ShowOwnedPopups(TRUE) generates
2762 * WM_SHOWWINDOW messages with SW_PARENTOPENING,
2763 * regardless of the state of the owner
2764 */
2765 SendMessageW(win_array[count], WM_SHOWWINDOW, SW_SHOWNORMAL, SW_PARENTOPENING);
2766 continue;
2767 }
2768 }
2769 else
2770 {
2771 if (pWnd->dwStyle & WS_VISIBLE)
2772 {
2773 WIN_ReleasePtr( pWnd );
2774 /* In Windows, ShowOwnedPopups(FALSE) generates
2775 * WM_SHOWWINDOW messages with SW_PARENTCLOSING,
2776 * regardless of the state of the owner
2777 */
2778 SendMessageW(win_array[count], WM_SHOWWINDOW, SW_HIDE, SW_PARENTCLOSING);
2779 continue;
2780 }
2781 }
2782 WIN_ReleasePtr( pWnd );
2783 }
2784 HeapFree( GetProcessHeap(), 0, win_array );
2785 return TRUE;
2786 }
2787
2788
2789 /*******************************************************************
2790 * GetLastActivePopup (USER32.@)
2791 */
2792 HWND WINAPI GetLastActivePopup( HWND hwnd )
2793 {
2794 HWND retval = hwnd;
2795
2796 SERVER_START_REQ( get_window_info )
2797 {
2798 req->handle = hwnd;
2799 if (!wine_server_call_err( req )) retval = reply->last_active;
2800 }
2801 SERVER_END_REQ;
2802 return retval;
2803 }
2804
2805
2806 /*******************************************************************
2807 * WIN_ListChildren
2808 *
2809 * Build an array of the children of a given window. The array must be
2810 * freed with HeapFree. Returns NULL when no windows are found.
2811 */
2812 HWND *WIN_ListChildren( HWND hwnd )
2813 {
2814 return list_window_children( hwnd, 0, 0 );
2815 }
2816
2817
2818 /*******************************************************************
2819 * EnumWindows (USER32.@)
2820 */
2821 BOOL WINAPI EnumWindows( WNDENUMPROC lpEnumFunc, LPARAM lParam )
2822 {
2823 HWND *list;
2824 BOOL ret = TRUE;
2825 int i;
2826
2827 USER_CheckNotLock();
2828
2829 /* We have to build a list of all windows first, to avoid */
2830 /* unpleasant side-effects, for instance if the callback */
2831 /* function changes the Z-order of the windows. */
2832
2833 if (!(list = WIN_ListChildren( GetDesktopWindow() ))) return TRUE;
2834
2835 /* Now call the callback function for every window */
2836
2837 for (i = 0; list[i]; i++)
2838 {
2839 /* Make sure that the window still exists */
2840 if (!IsWindow( list[i] )) continue;
2841 if (!(ret = lpEnumFunc( list[i], lParam ))) break;
2842 }
2843 HeapFree( GetProcessHeap(), 0, list );
2844 return ret;
2845 }
2846
2847
2848 /**********************************************************************
2849 * EnumThreadWindows (USER32.@)
2850 */
2851 BOOL WINAPI EnumThreadWindows( DWORD id, WNDENUMPROC func, LPARAM lParam )
2852 {
2853 HWND *list;
2854 int i;
2855
2856 USER_CheckNotLock();
2857
2858 if (!(list = list_window_children( GetDesktopWindow(), 0, id ))) return TRUE;
2859
2860 /* Now call the callback function for every window */
2861
2862 for (i = 0; list[i]; i++)
2863 if (!func( list[i], lParam )) break;
2864 HeapFree( GetProcessHeap(), 0, list );
2865 return TRUE;
2866 }
2867
2868
2869 /**********************************************************************
2870 * WIN_EnumChildWindows
2871 *
2872 * Helper function for EnumChildWindows().
2873 */
2874 static BOOL WIN_EnumChildWindows( HWND *list, WNDENUMPROC func, LPARAM lParam )
2875 {
2876 HWND *childList;
2877 BOOL ret = FALSE;
2878
2879 for ( ; *list; list++)
2880 {
2881 /* Make sure that the window still exists */
2882 if (!IsWindow( *list )) continue;
2883 /* Build children list first */
2884 childList = WIN_ListChildren( *list );
2885
2886 ret = func( *list, lParam );
2887
2888 if (childList)
2889 {
2890 if (ret) ret = WIN_EnumChildWindows( childList, func, lParam );
2891 HeapFree( GetProcessHeap(), 0, childList );
2892 }
2893 if (!ret) return FALSE;
2894 }
2895 return TRUE;
2896 }
2897
2898
2899 /**********************************************************************
2900 * EnumChildWindows (USER32.@)
2901 */
2902 BOOL WINAPI EnumChildWindows( HWND parent, WNDENUMPROC func, LPARAM lParam )
2903 {
2904 HWND *list;
2905 BOOL ret;
2906
2907 USER_CheckNotLock();
2908
2909 if (!(list = WIN_ListChildren( parent ))) return FALSE;
2910 ret = WIN_EnumChildWindows( list, func, lParam );
2911 HeapFree( GetProcessHeap(), 0, list );
2912 return ret;
2913 }
2914
2915
2916 /*******************************************************************
2917 * AnyPopup (USER.52)
2918 */
2919 BOOL16 WINAPI AnyPopup16(void)
2920 {
2921 return AnyPopup();
2922 }
2923
2924
2925 /*******************************************************************
2926 * AnyPopup (USER32.@)
2927 */
2928 BOOL WINAPI AnyPopup(void)
2929 {
2930 int i;
2931 BOOL retvalue;
2932 HWND *list = WIN_ListChildren( GetDesktopWindow() );
2933
2934 if (!list) return FALSE;
2935 for (i = 0; list[i]; i++)
2936 {
2937 if (IsWindowVisible( list[i] ) && GetWindow( list[i], GW_OWNER )) break;
2938 }
2939 retvalue = (list[i] != 0);
2940 HeapFree( GetProcessHeap(), 0, list );
2941 return retvalue;
2942 }
2943
2944
2945 /*******************************************************************
2946 * FlashWindow (USER32.@)
2947 */
2948 BOOL WINAPI FlashWindow( HWND hWnd, BOOL bInvert )
2949 {
2950 WND *wndPtr;
2951
2952 TRACE("%p\n", hWnd);
2953
2954 if (IsIconic( hWnd ))
2955 {
2956 RedrawWindow( hWnd, 0, 0, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_FRAME );
2957
2958 wndPtr = WIN_GetPtr(hWnd);
2959 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return FALSE;
2960 if (bInvert && !(wndPtr->flags & WIN_NCACTIVATED))
2961 {
2962 wndPtr->flags |= WIN_NCACTIVATED;
2963 }
2964 else
2965 {
2966 wndPtr->flags &= ~WIN_NCACTIVATED;
2967 }
2968 WIN_ReleasePtr( wndPtr );
2969 return TRUE;
2970 }
2971 else
2972 {
2973 WPARAM wparam;
2974
2975 wndPtr = WIN_GetPtr(hWnd);
2976 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return FALSE;
2977 hWnd = wndPtr->hwndSelf; /* make it a full handle */
2978
2979 if (bInvert) wparam = !(wndPtr->flags & WIN_NCACTIVATED);
2980 else wparam = (hWnd == GetForegroundWindow());
2981
2982 WIN_ReleasePtr( wndPtr );
2983 SendMessageW( hWnd, WM_NCACTIVATE, wparam, (LPARAM)0 );
2984 return wparam;
2985 }
2986 }
2987
2988 /*******************************************************************
2989 * FlashWindowEx (USER32.@)
2990 */
2991 BOOL WINAPI FlashWindowEx( PFLASHWINFO pfwi )
2992 {
2993 FIXME("%p\n", pfwi);
2994 return TRUE;
2995 }
2996
2997 /*******************************************************************
2998 * GetWindowContextHelpId (USER32.@)
2999 */
3000 DWORD WINAPI GetWindowContextHelpId( HWND hwnd )
3001 {
3002 DWORD retval;
3003 WND *wnd = WIN_GetPtr( hwnd );
3004 if (!wnd || wnd == WND_DESKTOP) return 0;
3005 if (wnd == WND_OTHER_PROCESS)
3006 {
3007 if (IsWindow( hwnd )) FIXME( "not supported on other process window %p\n", hwnd );
3008 return 0;
3009 }
3010 retval = wnd->helpContext;
3011 WIN_ReleasePtr( wnd );
3012 return retval;
3013 }
3014
3015
3016 /*******************************************************************
3017 * SetWindowContextHelpId (USER32.@)
3018 */
3019 BOOL WINAPI SetWindowContextHelpId( HWND hwnd, DWORD id )
3020 {
3021 WND *wnd = WIN_GetPtr( hwnd );
3022 if (!wnd || wnd == WND_DESKTOP) return FALSE;
3023 if (wnd == WND_OTHER_PROCESS)
3024 {
3025 if (IsWindow( hwnd )) FIXME( "not supported on other process window %p\n", hwnd );
3026 return 0;
3027 }
3028 wnd->helpContext = id;
3029 WIN_ReleasePtr( wnd );
3030 return TRUE;
3031 }
3032
3033
3034 /*******************************************************************
3035 * DragDetect (USER32.@)
3036 */
3037 BOOL WINAPI DragDetect( HWND hWnd, POINT pt )
3038 {
3039 MSG msg;
3040 RECT rect;
3041 WORD wDragWidth = GetSystemMetrics(SM_CXDRAG);
3042 WORD wDragHeight= GetSystemMetrics(SM_CYDRAG);
3043
3044 rect.left = pt.x - wDragWidth;
3045 rect.right = pt.x + wDragWidth;
3046
3047 rect.top = pt.y - wDragHeight;
3048 rect.bottom = pt.y + wDragHeight;
3049
3050 SetCapture(hWnd);
3051
3052 while(1)
3053 {
3054 while (PeekMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE ))
3055 {
3056 if( msg.message == WM_LBUTTONUP )
3057 {
3058 ReleaseCapture();
3059 return 0;
3060 }
3061 if( msg.message == WM_MOUSEMOVE )
3062 {
3063 POINT tmp;
3064 tmp.x = (short)LOWORD(msg.lParam);
3065 tmp.y = (short)HIWORD(msg.lParam);
3066 if( !PtInRect( &rect, tmp ))
3067 {
3068 ReleaseCapture();
3069 return 1;
3070 }
3071 }
3072 }
3073 WaitMessage();
3074 }
3075 return 0;
3076 }
3077
3078 /******************************************************************************
3079 * GetWindowModuleFileNameA (USER32.@)
3080 */
3081 UINT WINAPI GetWindowModuleFileNameA( HWND hwnd, LPSTR lpszFileName, UINT cchFileNameMax)
3082 {
3083 FIXME("GetWindowModuleFileNameA(hwnd %p, lpszFileName %p, cchFileNameMax %u) stub!\n",
3084 hwnd, lpszFileName, cchFileNameMax);
3085 return 0;
3086 }
3087
3088 /******************************************************************************
3089 * GetWindowModuleFileNameW (USER32.@)
3090 */
3091 UINT WINAPI GetWindowModuleFileNameW( HWND hwnd, LPWSTR lpszFileName, UINT cchFileNameMax)
3092 {
3093 FIXME("GetWindowModuleFileNameW(hwnd %p, lpszFileName %p, cchFileNameMax %u) stub!\n",
3094 hwnd, lpszFileName, cchFileNameMax);
3095 return 0;
3096 }
3097
3098 /******************************************************************************
3099 * GetWindowInfo (USER32.@)
3100 *
3101 * Note: tests show that Windows doesn't check cbSize of the structure.
3102 */
3103 BOOL WINAPI GetWindowInfo( HWND hwnd, PWINDOWINFO pwi)
3104 {
3105 if (!pwi) return FALSE;
3106 if (!IsWindow(hwnd)) return FALSE;
3107
3108 GetWindowRect(hwnd, &pwi->rcWindow);
3109 GetClientRect(hwnd, &pwi->rcClient);
3110 /* translate to screen coordinates */
3111 MapWindowPoints(hwnd, 0, (LPPOINT)&pwi->rcClient, 2);
3112
3113 pwi->dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
3114 pwi->dwExStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
3115 pwi->dwWindowStatus = ((GetActiveWindow() == hwnd) ? WS_ACTIVECAPTION : 0);
3116
3117 pwi->cxWindowBorders = pwi->rcClient.left - pwi->rcWindow.left;
3118 pwi->cyWindowBorders = pwi->rcWindow.bottom - pwi->rcClient.bottom;
3119
3120 pwi->atomWindowType = GetClassLongW( hwnd, GCW_ATOM );
3121 pwi->wCreatorVersion = 0x0400;
3122
3123 return TRUE;
3124 }
3125
3126 /******************************************************************************
3127 * SwitchDesktop (USER32.@)
3128 *
3129 * NOTES: Sets the current input or interactive desktop.
3130 */
3131 BOOL WINAPI SwitchDesktop( HDESK hDesktop)
3132 {
3133 FIXME("SwitchDesktop(hwnd %p) stub!\n", hDesktop);
3134 return TRUE;
3135 }
3136
3137 /*****************************************************************************
3138 * SetLayeredWindowAttributes (USER32.@)
3139 */
3140 BOOL WINAPI SetLayeredWindowAttributes( HWND hWnd, COLORREF rgbKey,
3141 BYTE bAlpha, DWORD dwFlags )
3142 {
3143 FIXME("(%p,0x%.8x,%d,%d): stub!\n", hWnd, rgbKey, bAlpha, dwFlags);
3144 return TRUE;
3145 }
3146
3147 /*****************************************************************************
3148 * UpdateLayeredWindow (USER32.@)
3149 */
3150 BOOL WINAPI UpdateLayeredWindow( HWND hwnd, HDC hdcDst, POINT *pptDst, SIZE *psize,
3151 HDC hdcSrc, POINT *pptSrc, COLORREF crKey, BLENDFUNCTION *pblend,
3152 DWORD dwFlags)
3153 {
3154 static int once;
3155 if (!once)
3156 {
3157 once = 1;
3158 FIXME("(%p,%p,%p,%p,%p,%p,0x%08x,%p,%d): stub!\n",
3159 hwnd, hdcDst, pptDst, psize, hdcSrc, pptSrc, crKey, pblend, dwFlags);
3160 }
3161 return 0;
3162 }
3163
3164 /* 64bit versions */
3165
3166 #ifdef GetWindowLongPtrW
3167 #undef GetWindowLongPtrW
3168 #endif
3169
3170 #ifdef GetWindowLongPtrA
3171 #undef GetWindowLongPtrA
3172 #endif
3173
3174 #ifdef SetWindowLongPtrW
3175 #undef SetWindowLongPtrW
3176 #endif
3177
3178 #ifdef SetWindowLongPtrA
3179 #undef SetWindowLongPtrA
3180 #endif
3181
3182 /*****************************************************************************
3183 * GetWindowLongPtrW (USER32.@)
3184 */
3185 LONG_PTR WINAPI GetWindowLongPtrW( HWND hwnd, INT offset )
3186 {
3187 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG_PTR), TRUE );
3188 }
3189
3190 /*****************************************************************************
3191 * GetWindowLongPtrA (USER32.@)
3192 */
3193 LONG_PTR WINAPI GetWindowLongPtrA( HWND hwnd, INT offset )
3194 {
3195 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG_PTR), FALSE );
3196 }
3197
3198 /*****************************************************************************
3199 * SetWindowLongPtrW (USER32.@)
3200 */
3201 LONG_PTR WINAPI SetWindowLongPtrW( HWND hwnd, INT offset, LONG_PTR newval )
3202 {
3203 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG_PTR), newval, TRUE );
3204 }
3205
3206 /*****************************************************************************
3207 * SetWindowLongPtrA (USER32.@)
3208 */
3209 LONG_PTR WINAPI SetWindowLongPtrA( HWND hwnd, INT offset, LONG_PTR newval )
3210 {
3211 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG_PTR), newval, FALSE );
3212 }
GSOC 2012 project to enhance the control panel