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