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