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