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