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