push 3cf4bc9cdb38c4fc36232fe19b9b904fd4d068e9
[wine/hacks.git] / dlls / user32 / win.c
blob34491fe319adf7dc8fa291d024b3f37d20ba87ef
1 /*
2 * Window related functions
4 * Copyright 1993, 1994 Alexandre Julliard
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.
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.
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
21 #include "config.h"
22 #include "wine/port.h"
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"
41 WINE_DEFAULT_DEBUG_CHANNEL(win);
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)
46 /**********************************************************************/
48 /* helper for Get/SetWindowLong */
49 static inline LONG_PTR get_win_data( const void *ptr, UINT size )
51 if (size == sizeof(WORD))
53 WORD ret;
54 memcpy( &ret, ptr, sizeof(ret) );
55 return ret;
57 else if (size == sizeof(DWORD))
59 DWORD ret;
60 memcpy( &ret, ptr, sizeof(ret) );
61 return ret;
63 else
65 LONG_PTR ret;
66 memcpy( &ret, ptr, sizeof(ret) );
67 return ret;
71 /* helper for Get/SetWindowLong */
72 static inline void set_win_data( void *ptr, LONG_PTR val, UINT size )
74 if (size == sizeof(WORD))
76 WORD newval = val;
77 memcpy( ptr, &newval, sizeof(newval) );
79 else if (size == sizeof(DWORD))
81 DWORD newval = val;
82 memcpy( ptr, &newval, sizeof(newval) );
84 else
86 memcpy( ptr, &val, sizeof(val) );
91 static void *user_handles[NB_USER_HANDLES];
93 /***********************************************************************
94 * create_window_handle
96 * Create a window handle with the server.
98 static WND *create_window_handle( HWND parent, HWND owner, LPCWSTR name,
99 HINSTANCE instance, BOOL unicode )
101 WORD index;
102 WND *win;
103 HWND handle = 0, full_parent = 0, full_owner = 0;
104 struct tagCLASS *class = NULL;
105 int extra_bytes = 0;
107 /* if 16-bit instance, map to module handle */
108 if (instance && !HIWORD(instance))
109 instance = HINSTANCE_32(GetExePtr(HINSTANCE_16(instance)));
111 SERVER_START_REQ( create_window )
113 req->parent = wine_server_user_handle( parent );
114 req->owner = wine_server_user_handle( owner );
115 req->instance = instance;
116 if (!(req->atom = get_int_atom_value( name )) && name)
117 wine_server_add_data( req, name, strlenW(name)*sizeof(WCHAR) );
118 if (!wine_server_call_err( req ))
120 handle = wine_server_ptr_handle( reply->handle );
121 full_parent = wine_server_ptr_handle( reply->parent );
122 full_owner = wine_server_ptr_handle( reply->owner );
123 extra_bytes = reply->extra;
124 class = reply->class_ptr;
127 SERVER_END_REQ;
129 if (!handle)
131 WARN( "error %d creating window\n", GetLastError() );
132 return NULL;
135 if (!(win = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
136 sizeof(WND) + extra_bytes - sizeof(win->wExtra) )))
138 SERVER_START_REQ( destroy_window )
140 req->handle = wine_server_user_handle( handle );
141 wine_server_call( req );
143 SERVER_END_REQ;
144 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
145 return NULL;
148 if (!parent) /* if parent is 0 we don't have a desktop window yet */
150 struct user_thread_info *thread_info = get_user_thread_info();
152 if (name == (LPCWSTR)DESKTOP_CLASS_ATOM)
154 if (!thread_info->top_window) thread_info->top_window = full_parent ? full_parent : handle;
155 else assert( full_parent == thread_info->top_window );
156 if (full_parent && !USER_Driver->pCreateDesktopWindow( thread_info->top_window ))
157 ERR( "failed to create desktop window\n" );
159 else /* HWND_MESSAGE parent */
161 if (!thread_info->msg_window && !full_parent) thread_info->msg_window = handle;
165 USER_Lock();
167 index = USER_HANDLE_TO_INDEX(handle);
168 assert( index < NB_USER_HANDLES );
169 user_handles[index] = win;
170 win->hwndSelf = handle;
171 win->parent = full_parent;
172 win->owner = full_owner;
173 win->class = class;
174 win->winproc = get_class_winproc( class );
175 win->dwMagic = WND_MAGIC;
176 win->cbWndExtra = extra_bytes;
177 if (WINPROC_IsUnicode( win->winproc, unicode )) win->flags |= WIN_ISUNICODE;
178 return win;
182 /***********************************************************************
183 * free_window_handle
185 * Free a window handle.
187 static WND *free_window_handle( HWND hwnd )
189 WND *ptr;
190 WORD index = USER_HANDLE_TO_INDEX(hwnd);
192 if (index >= NB_USER_HANDLES) return NULL;
193 USER_Lock();
194 if ((ptr = user_handles[index]))
196 SERVER_START_REQ( destroy_window )
198 req->handle = wine_server_user_handle( hwnd );
199 if (!wine_server_call_err( req ))
201 user_handles[index] = NULL;
202 ptr->dwMagic = 0;
204 else
205 ptr = NULL;
207 SERVER_END_REQ;
209 USER_Unlock();
210 HeapFree( GetProcessHeap(), 0, ptr );
211 return ptr;
215 /*******************************************************************
216 * list_window_children
218 * Build an array of the children of a given window. The array must be
219 * freed with HeapFree. Returns NULL when no windows are found.
221 static HWND *list_window_children( HDESK desktop, HWND hwnd, LPCWSTR class, DWORD tid )
223 HWND *list;
224 int i, size = 128;
225 ATOM atom = get_int_atom_value( class );
227 /* empty class is not the same as NULL class */
228 if (!atom && class && !class[0]) return NULL;
230 for (;;)
232 int count = 0;
234 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) break;
236 SERVER_START_REQ( get_window_children )
238 req->desktop = wine_server_obj_handle( desktop );
239 req->parent = wine_server_user_handle( hwnd );
240 req->tid = tid;
241 req->atom = atom;
242 if (!atom && class) wine_server_add_data( req, class, strlenW(class)*sizeof(WCHAR) );
243 wine_server_set_reply( req, list, (size-1) * sizeof(user_handle_t) );
244 if (!wine_server_call( req )) count = reply->count;
246 SERVER_END_REQ;
247 if (count && count < size)
249 /* start from the end since HWND is potentially larger than user_handle_t */
250 for (i = count - 1; i >= 0; i--)
251 list[i] = wine_server_ptr_handle( ((user_handle_t *)list)[i] );
252 list[count] = 0;
253 return list;
255 HeapFree( GetProcessHeap(), 0, list );
256 if (!count) break;
257 size = count + 1; /* restart with a large enough buffer */
259 return NULL;
263 /*******************************************************************
264 * list_window_parents
266 * Build an array of all parents of a given window, starting with
267 * the immediate parent. The array must be freed with HeapFree.
269 static HWND *list_window_parents( HWND hwnd )
271 WND *win;
272 HWND current, *list;
273 int i, pos = 0, size = 16, count = 0;
275 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL;
277 current = hwnd;
278 for (;;)
280 if (!(win = WIN_GetPtr( current ))) goto empty;
281 if (win == WND_OTHER_PROCESS) break; /* need to do it the hard way */
282 if (win == WND_DESKTOP)
284 if (!pos) goto empty;
285 list[pos] = 0;
286 return list;
288 list[pos] = current = win->parent;
289 WIN_ReleasePtr( win );
290 if (!current) return list;
291 if (++pos == size - 1)
293 /* need to grow the list */
294 HWND *new_list = HeapReAlloc( GetProcessHeap(), 0, list, (size+16) * sizeof(HWND) );
295 if (!new_list) goto empty;
296 list = new_list;
297 size += 16;
301 /* at least one parent belongs to another process, have to query the server */
303 for (;;)
305 count = 0;
306 SERVER_START_REQ( get_window_parents )
308 req->handle = wine_server_user_handle( hwnd );
309 wine_server_set_reply( req, list, (size-1) * sizeof(user_handle_t) );
310 if (!wine_server_call( req )) count = reply->count;
312 SERVER_END_REQ;
313 if (!count) goto empty;
314 if (size > count)
316 /* start from the end since HWND is potentially larger than user_handle_t */
317 for (i = count - 1; i >= 0; i--)
318 list[i] = wine_server_ptr_handle( ((user_handle_t *)list)[i] );
319 list[count] = 0;
320 return list;
322 HeapFree( GetProcessHeap(), 0, list );
323 size = count + 1;
324 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL;
327 empty:
328 HeapFree( GetProcessHeap(), 0, list );
329 return NULL;
333 /*******************************************************************
334 * send_parent_notify
336 static void send_parent_notify( HWND hwnd, UINT msg )
338 if ((GetWindowLongW( hwnd, GWL_STYLE ) & (WS_CHILD | WS_POPUP)) == WS_CHILD &&
339 !(GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY))
341 HWND parent = GetParent(hwnd);
342 if (parent && parent != GetDesktopWindow())
343 SendMessageW( parent, WM_PARENTNOTIFY,
344 MAKEWPARAM( msg, GetWindowLongPtrW( hwnd, GWLP_ID )), (LPARAM)hwnd );
349 /*******************************************************************
350 * get_server_window_text
352 * Retrieve the window text from the server.
354 static void get_server_window_text( HWND hwnd, LPWSTR text, INT count )
356 size_t len = 0;
358 SERVER_START_REQ( get_window_text )
360 req->handle = wine_server_user_handle( hwnd );
361 wine_server_set_reply( req, text, (count - 1) * sizeof(WCHAR) );
362 if (!wine_server_call_err( req )) len = wine_server_reply_size(reply);
364 SERVER_END_REQ;
365 text[len / sizeof(WCHAR)] = 0;
369 /*******************************************************************
370 * get_hwnd_message_parent
372 * Return the parent for HWND_MESSAGE windows.
374 HWND get_hwnd_message_parent(void)
376 struct user_thread_info *thread_info = get_user_thread_info();
378 if (!thread_info->msg_window) GetDesktopWindow(); /* trigger creation */
379 return thread_info->msg_window;
383 /*******************************************************************
384 * is_desktop_window
386 * Check if window is the desktop or the HWND_MESSAGE top parent.
388 BOOL is_desktop_window( HWND hwnd )
390 struct user_thread_info *thread_info = get_user_thread_info();
392 if (!hwnd) return FALSE;
393 if (hwnd == thread_info->top_window) return TRUE;
394 if (hwnd == thread_info->msg_window) return TRUE;
396 if (!HIWORD(hwnd) || HIWORD(hwnd) == 0xffff)
398 if (LOWORD(thread_info->top_window) == LOWORD(hwnd)) return TRUE;
399 if (LOWORD(thread_info->msg_window) == LOWORD(hwnd)) return TRUE;
401 return FALSE;
405 /***********************************************************************
406 * WIN_GetPtr
408 * Return a pointer to the WND structure if local to the process,
409 * or WND_OTHER_PROCESS if handle may be valid in other process.
410 * If ret value is a valid pointer, it must be released with WIN_ReleasePtr.
412 WND *WIN_GetPtr( HWND hwnd )
414 WND * ptr;
415 WORD index = USER_HANDLE_TO_INDEX(hwnd);
417 if (index >= NB_USER_HANDLES) return NULL;
419 USER_Lock();
420 if ((ptr = user_handles[index]))
422 if (ptr->dwMagic == WND_MAGIC &&
423 (hwnd == ptr->hwndSelf || !HIWORD(hwnd) || HIWORD(hwnd) == 0xffff))
424 return ptr;
425 ptr = NULL;
427 else if (is_desktop_window( hwnd )) ptr = WND_DESKTOP;
428 else ptr = WND_OTHER_PROCESS;
429 USER_Unlock();
430 return ptr;
434 /***********************************************************************
435 * WIN_IsCurrentProcess
437 * Check whether a given window belongs to the current process (and return the full handle).
439 HWND WIN_IsCurrentProcess( HWND hwnd )
441 WND *ptr;
442 HWND ret;
444 if (!(ptr = WIN_GetPtr( hwnd )) || ptr == WND_OTHER_PROCESS || ptr == WND_DESKTOP) return 0;
445 ret = ptr->hwndSelf;
446 WIN_ReleasePtr( ptr );
447 return ret;
451 /***********************************************************************
452 * WIN_IsCurrentThread
454 * Check whether a given window belongs to the current thread (and return the full handle).
456 HWND WIN_IsCurrentThread( HWND hwnd )
458 WND *ptr;
459 HWND ret = 0;
461 if (!(ptr = WIN_GetPtr( hwnd )) || ptr == WND_OTHER_PROCESS || ptr == WND_DESKTOP) return 0;
462 if (ptr->tid == GetCurrentThreadId()) ret = ptr->hwndSelf;
463 WIN_ReleasePtr( ptr );
464 return ret;
468 /***********************************************************************
469 * WIN_Handle32
471 * Convert a 16-bit window handle to a full 32-bit handle.
473 HWND WIN_Handle32( HWND16 hwnd16 )
475 WND *ptr;
476 HWND hwnd = (HWND)(ULONG_PTR)hwnd16;
478 if (hwnd16 <= 1 || hwnd16 == 0xffff) return hwnd;
479 /* do sign extension for -2 and -3 */
480 if (hwnd16 >= (HWND16)-3) return (HWND)(LONG_PTR)(INT16)hwnd16;
482 if (!(ptr = WIN_GetPtr( hwnd ))) return hwnd;
484 if (ptr == WND_DESKTOP)
486 if (LOWORD(hwnd) == LOWORD(GetDesktopWindow())) return GetDesktopWindow();
487 else return get_hwnd_message_parent();
490 if (ptr != WND_OTHER_PROCESS)
492 hwnd = ptr->hwndSelf;
493 WIN_ReleasePtr( ptr );
495 else /* may belong to another process */
497 SERVER_START_REQ( get_window_info )
499 req->handle = wine_server_user_handle( hwnd );
500 if (!wine_server_call_err( req )) hwnd = wine_server_ptr_handle( reply->full_handle );
502 SERVER_END_REQ;
504 return hwnd;
508 /***********************************************************************
509 * WIN_SetOwner
511 * Change the owner of a window.
513 HWND WIN_SetOwner( HWND hwnd, HWND owner )
515 WND *win = WIN_GetPtr( hwnd );
516 HWND ret = 0;
518 if (!win || win == WND_DESKTOP) return 0;
519 if (win == WND_OTHER_PROCESS)
521 if (IsWindow(hwnd)) ERR( "cannot set owner %p on other process window %p\n", owner, hwnd );
522 return 0;
524 SERVER_START_REQ( set_window_owner )
526 req->handle = wine_server_user_handle( hwnd );
527 req->owner = wine_server_user_handle( owner );
528 if (!wine_server_call( req ))
530 win->owner = wine_server_ptr_handle( reply->full_owner );
531 ret = wine_server_ptr_handle( reply->prev_owner );
534 SERVER_END_REQ;
535 WIN_ReleasePtr( win );
536 return ret;
540 /***********************************************************************
541 * WIN_SetStyle
543 * Change the style of a window.
545 ULONG WIN_SetStyle( HWND hwnd, ULONG set_bits, ULONG clear_bits )
547 BOOL ok;
548 STYLESTRUCT style;
549 WND *win = WIN_GetPtr( hwnd );
551 if (!win || win == WND_DESKTOP) return 0;
552 if (win == WND_OTHER_PROCESS)
554 if (IsWindow(hwnd))
555 ERR( "cannot set style %x/%x on other process window %p\n",
556 set_bits, clear_bits, hwnd );
557 return 0;
559 style.styleOld = win->dwStyle;
560 style.styleNew = (win->dwStyle | set_bits) & ~clear_bits;
561 if (style.styleNew == style.styleOld)
563 WIN_ReleasePtr( win );
564 return style.styleNew;
566 SERVER_START_REQ( set_window_info )
568 req->handle = wine_server_user_handle( hwnd );
569 req->flags = SET_WIN_STYLE;
570 req->style = style.styleNew;
571 req->extra_offset = -1;
572 if ((ok = !wine_server_call( req )))
574 style.styleOld = reply->old_style;
575 win->dwStyle = style.styleNew;
578 SERVER_END_REQ;
579 WIN_ReleasePtr( win );
580 if (ok)
582 USER_Driver->pSetWindowStyle( hwnd, GWL_STYLE, &style );
583 if ((style.styleOld ^ style.styleNew) & WS_VISIBLE) invalidate_dce( hwnd, NULL );
585 return style.styleOld;
589 /***********************************************************************
590 * WIN_GetRectangles
592 * Get the window and client rectangles.
594 BOOL WIN_GetRectangles( HWND hwnd, RECT *rectWindow, RECT *rectClient )
596 WND *win = WIN_GetPtr( hwnd );
597 BOOL ret = TRUE;
599 if (!win) return FALSE;
600 if (win == WND_DESKTOP)
602 RECT rect;
603 rect.left = rect.top = 0;
604 if (hwnd == get_hwnd_message_parent())
606 rect.right = 100;
607 rect.bottom = 100;
609 else
611 rect.right = GetSystemMetrics(SM_CXSCREEN);
612 rect.bottom = GetSystemMetrics(SM_CYSCREEN);
614 if (rectWindow) *rectWindow = rect;
615 if (rectClient) *rectClient = rect;
617 else if (win == WND_OTHER_PROCESS)
619 SERVER_START_REQ( get_window_rectangles )
621 req->handle = wine_server_user_handle( hwnd );
622 if ((ret = !wine_server_call( req )))
624 if (rectWindow)
626 rectWindow->left = reply->window.left;
627 rectWindow->top = reply->window.top;
628 rectWindow->right = reply->window.right;
629 rectWindow->bottom = reply->window.bottom;
631 if (rectClient)
633 rectClient->left = reply->client.left;
634 rectClient->top = reply->client.top;
635 rectClient->right = reply->client.right;
636 rectClient->bottom = reply->client.bottom;
640 SERVER_END_REQ;
642 else
644 if (rectWindow) *rectWindow = win->rectWindow;
645 if (rectClient) *rectClient = win->rectClient;
646 WIN_ReleasePtr( win );
648 return ret;
652 /***********************************************************************
653 * WIN_DestroyWindow
655 * Destroy storage associated to a window. "Internals" p.358
657 LRESULT WIN_DestroyWindow( HWND hwnd )
659 WND *wndPtr;
660 HWND *list;
661 HMENU menu = 0, sys_menu;
662 HWND icon_title;
664 TRACE("%p\n", hwnd );
666 /* free child windows */
667 if ((list = WIN_ListChildren( hwnd )))
669 int i;
670 for (i = 0; list[i]; i++)
672 if (WIN_IsCurrentThread( list[i] )) WIN_DestroyWindow( list[i] );
673 else SendMessageW( list[i], WM_WINE_DESTROYWINDOW, 0, 0 );
675 HeapFree( GetProcessHeap(), 0, list );
678 /* Unlink now so we won't bother with the children later on */
679 SERVER_START_REQ( set_parent )
681 req->handle = wine_server_user_handle( hwnd );
682 req->parent = 0;
683 wine_server_call( req );
685 SERVER_END_REQ;
688 * Send the WM_NCDESTROY to the window being destroyed.
690 SendMessageW( hwnd, WM_NCDESTROY, 0, 0 );
692 /* FIXME: do we need to fake QS_MOUSEMOVE wakebit? */
694 /* free resources associated with the window */
696 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return 0;
697 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
698 menu = (HMENU)wndPtr->wIDmenu;
699 sys_menu = wndPtr->hSysMenu;
700 free_dce( wndPtr->dce, hwnd );
701 wndPtr->dce = NULL;
702 icon_title = wndPtr->icon_title;
703 WIN_ReleasePtr( wndPtr );
705 if (icon_title) DestroyWindow( icon_title );
706 if (menu) DestroyMenu( menu );
707 if (sys_menu) DestroyMenu( sys_menu );
709 USER_Driver->pDestroyWindow( hwnd );
711 free_window_handle( hwnd );
712 return 0;
715 /***********************************************************************
716 * WIN_DestroyThreadWindows
718 * Destroy all children of 'wnd' owned by the current thread.
720 void WIN_DestroyThreadWindows( HWND hwnd )
722 HWND *list;
723 int i;
725 if (!(list = WIN_ListChildren( hwnd ))) return;
726 for (i = 0; list[i]; i++)
728 if (WIN_IsCurrentThread( list[i] ))
729 DestroyWindow( list[i] );
730 else
731 WIN_DestroyThreadWindows( list[i] );
733 HeapFree( GetProcessHeap(), 0, list );
737 /***********************************************************************
738 * WIN_FixCoordinates
740 * Fix the coordinates - Helper for WIN_CreateWindowEx.
741 * returns default show mode in sw.
743 static void WIN_FixCoordinates( CREATESTRUCTA *cs, INT *sw)
745 #define IS_DEFAULT(x) ((x) == CW_USEDEFAULT || (x) == CW_USEDEFAULT16)
746 POINT pos[2];
748 if (cs->dwExStyle & WS_EX_MDICHILD)
750 UINT id = 0;
752 MDI_CalcDefaultChildPos(cs->hwndParent, -1, pos, 0, &id);
753 if (!(cs->style & WS_POPUP)) cs->hMenu = ULongToHandle(id);
755 TRACE("MDI child id %04x\n", id);
758 if (cs->style & (WS_CHILD | WS_POPUP))
760 if (cs->dwExStyle & WS_EX_MDICHILD)
762 if (IS_DEFAULT(cs->x))
764 cs->x = pos[0].x;
765 cs->y = pos[0].y;
767 if (IS_DEFAULT(cs->cx) || !cs->cx) cs->cx = pos[1].x;
768 if (IS_DEFAULT(cs->cy) || !cs->cy) cs->cy = pos[1].y;
770 else
772 if (IS_DEFAULT(cs->x)) cs->x = cs->y = 0;
773 if (IS_DEFAULT(cs->cx)) cs->cx = cs->cy = 0;
776 else /* overlapped window */
778 HMONITOR monitor;
779 MONITORINFO mon_info;
780 STARTUPINFOW info;
782 if (!IS_DEFAULT(cs->x) && !IS_DEFAULT(cs->cx) && !IS_DEFAULT(cs->cy)) return;
784 monitor = MonitorFromWindow( cs->hwndParent, MONITOR_DEFAULTTOPRIMARY );
785 mon_info.cbSize = sizeof(mon_info);
786 GetMonitorInfoW( monitor, &mon_info );
787 GetStartupInfoW( &info );
789 if (IS_DEFAULT(cs->x))
791 if (!IS_DEFAULT(cs->y)) *sw = cs->y;
792 cs->x = (info.dwFlags & STARTF_USEPOSITION) ? info.dwX : mon_info.rcWork.left;
793 cs->y = (info.dwFlags & STARTF_USEPOSITION) ? info.dwY : mon_info.rcWork.top;
796 if (IS_DEFAULT(cs->cx))
798 if (info.dwFlags & STARTF_USESIZE)
800 cs->cx = info.dwXSize;
801 cs->cy = info.dwYSize;
803 else
805 cs->cx = (mon_info.rcWork.right - mon_info.rcWork.left) * 3 / 4 - cs->x;
806 cs->cy = (mon_info.rcWork.bottom - mon_info.rcWork.top) * 3 / 4 - cs->y;
809 /* neither x nor cx are default. Check the y values .
810 * In the trace we see Outlook and Outlook Express using
811 * cy set to CW_USEDEFAULT when opening the address book.
813 else if (IS_DEFAULT(cs->cy))
815 FIXME("Strange use of CW_USEDEFAULT in nHeight\n");
816 cs->cy = (mon_info.rcWork.bottom - mon_info.rcWork.top) * 3 / 4 - cs->y;
819 #undef IS_DEFAULT
822 /***********************************************************************
823 * dump_window_styles
825 static void dump_window_styles( DWORD style, DWORD exstyle )
827 TRACE( "style:" );
828 if(style & WS_POPUP) TRACE(" WS_POPUP");
829 if(style & WS_CHILD) TRACE(" WS_CHILD");
830 if(style & WS_MINIMIZE) TRACE(" WS_MINIMIZE");
831 if(style & WS_VISIBLE) TRACE(" WS_VISIBLE");
832 if(style & WS_DISABLED) TRACE(" WS_DISABLED");
833 if(style & WS_CLIPSIBLINGS) TRACE(" WS_CLIPSIBLINGS");
834 if(style & WS_CLIPCHILDREN) TRACE(" WS_CLIPCHILDREN");
835 if(style & WS_MAXIMIZE) TRACE(" WS_MAXIMIZE");
836 if((style & WS_CAPTION) == WS_CAPTION) TRACE(" WS_CAPTION");
837 else
839 if(style & WS_BORDER) TRACE(" WS_BORDER");
840 if(style & WS_DLGFRAME) TRACE(" WS_DLGFRAME");
842 if(style & WS_VSCROLL) TRACE(" WS_VSCROLL");
843 if(style & WS_HSCROLL) TRACE(" WS_HSCROLL");
844 if(style & WS_SYSMENU) TRACE(" WS_SYSMENU");
845 if(style & WS_THICKFRAME) TRACE(" WS_THICKFRAME");
846 if (style & WS_CHILD)
848 if(style & WS_GROUP) TRACE(" WS_GROUP");
849 if(style & WS_TABSTOP) TRACE(" WS_TABSTOP");
851 else
853 if(style & WS_MINIMIZEBOX) TRACE(" WS_MINIMIZEBOX");
854 if(style & WS_MAXIMIZEBOX) TRACE(" WS_MAXIMIZEBOX");
857 /* FIXME: Add dumping of BS_/ES_/SBS_/LBS_/CBS_/DS_/etc. styles */
858 #define DUMPED_STYLES \
859 (WS_POPUP | \
860 WS_CHILD | \
861 WS_MINIMIZE | \
862 WS_VISIBLE | \
863 WS_DISABLED | \
864 WS_CLIPSIBLINGS | \
865 WS_CLIPCHILDREN | \
866 WS_MAXIMIZE | \
867 WS_BORDER | \
868 WS_DLGFRAME | \
869 WS_VSCROLL | \
870 WS_HSCROLL | \
871 WS_SYSMENU | \
872 WS_THICKFRAME | \
873 WS_GROUP | \
874 WS_TABSTOP | \
875 WS_MINIMIZEBOX | \
876 WS_MAXIMIZEBOX)
878 if(style & ~DUMPED_STYLES) TRACE(" %08lx", style & ~DUMPED_STYLES);
879 TRACE("\n");
880 #undef DUMPED_STYLES
882 TRACE( "exstyle:" );
883 if(exstyle & WS_EX_DLGMODALFRAME) TRACE(" WS_EX_DLGMODALFRAME");
884 if(exstyle & WS_EX_DRAGDETECT) TRACE(" WS_EX_DRAGDETECT");
885 if(exstyle & WS_EX_NOPARENTNOTIFY) TRACE(" WS_EX_NOPARENTNOTIFY");
886 if(exstyle & WS_EX_TOPMOST) TRACE(" WS_EX_TOPMOST");
887 if(exstyle & WS_EX_ACCEPTFILES) TRACE(" WS_EX_ACCEPTFILES");
888 if(exstyle & WS_EX_TRANSPARENT) TRACE(" WS_EX_TRANSPARENT");
889 if(exstyle & WS_EX_MDICHILD) TRACE(" WS_EX_MDICHILD");
890 if(exstyle & WS_EX_TOOLWINDOW) TRACE(" WS_EX_TOOLWINDOW");
891 if(exstyle & WS_EX_WINDOWEDGE) TRACE(" WS_EX_WINDOWEDGE");
892 if(exstyle & WS_EX_CLIENTEDGE) TRACE(" WS_EX_CLIENTEDGE");
893 if(exstyle & WS_EX_CONTEXTHELP) TRACE(" WS_EX_CONTEXTHELP");
894 if(exstyle & WS_EX_RIGHT) TRACE(" WS_EX_RIGHT");
895 if(exstyle & WS_EX_RTLREADING) TRACE(" WS_EX_RTLREADING");
896 if(exstyle & WS_EX_LEFTSCROLLBAR) TRACE(" WS_EX_LEFTSCROLLBAR");
897 if(exstyle & WS_EX_CONTROLPARENT) TRACE(" WS_EX_CONTROLPARENT");
898 if(exstyle & WS_EX_STATICEDGE) TRACE(" WS_EX_STATICEDGE");
899 if(exstyle & WS_EX_APPWINDOW) TRACE(" WS_EX_APPWINDOW");
900 if(exstyle & WS_EX_LAYERED) TRACE(" WS_EX_LAYERED");
902 #define DUMPED_EX_STYLES \
903 (WS_EX_DLGMODALFRAME | \
904 WS_EX_DRAGDETECT | \
905 WS_EX_NOPARENTNOTIFY | \
906 WS_EX_TOPMOST | \
907 WS_EX_ACCEPTFILES | \
908 WS_EX_TRANSPARENT | \
909 WS_EX_MDICHILD | \
910 WS_EX_TOOLWINDOW | \
911 WS_EX_WINDOWEDGE | \
912 WS_EX_CLIENTEDGE | \
913 WS_EX_CONTEXTHELP | \
914 WS_EX_RIGHT | \
915 WS_EX_RTLREADING | \
916 WS_EX_LEFTSCROLLBAR | \
917 WS_EX_CONTROLPARENT | \
918 WS_EX_STATICEDGE | \
919 WS_EX_APPWINDOW | \
920 WS_EX_LAYERED)
922 if(exstyle & ~DUMPED_EX_STYLES) TRACE(" %08lx", exstyle & ~DUMPED_EX_STYLES);
923 TRACE("\n");
924 #undef DUMPED_EX_STYLES
928 /***********************************************************************
929 * WIN_CreateWindowEx
931 * Implementation of CreateWindowEx().
933 static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, LPCWSTR className, UINT flags )
935 INT cx, cy, style, sw = SW_SHOW;
936 LRESULT result;
937 RECT rect;
938 WND *wndPtr;
939 HWND hwnd, parent, owner, top_child = 0;
940 BOOL unicode = (flags & WIN_ISUNICODE) != 0;
941 MDICREATESTRUCTA mdi_cs;
942 CBT_CREATEWNDA cbtc;
943 CREATESTRUCTA cbcs;
945 TRACE("%s %s ex=%08x style=%08x %d,%d %dx%d parent=%p menu=%p inst=%p params=%p\n",
946 unicode ? debugstr_w((LPCWSTR)cs->lpszName) : debugstr_a(cs->lpszName),
947 debugstr_w(className),
948 cs->dwExStyle, cs->style, cs->x, cs->y, cs->cx, cs->cy,
949 cs->hwndParent, cs->hMenu, cs->hInstance, cs->lpCreateParams );
950 if(TRACE_ON(win)) dump_window_styles( cs->style, cs->dwExStyle );
952 /* Fix the styles for MDI children */
953 if (cs->dwExStyle & WS_EX_MDICHILD)
955 UINT flags = 0;
957 wndPtr = WIN_GetPtr(cs->hwndParent);
958 if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
960 flags = wndPtr->flags;
961 WIN_ReleasePtr(wndPtr);
964 if (!(flags & WIN_ISMDICLIENT))
966 WARN("WS_EX_MDICHILD, but parent %p is not MDIClient\n", cs->hwndParent);
967 return 0;
970 /* cs->lpCreateParams of WM_[NC]CREATE is different for MDI children.
971 * MDICREATESTRUCT members have the originally passed values.
973 * Note: we rely on the fact that MDICREATESTRUCTA and MDICREATESTRUCTW
974 * have the same layout.
976 mdi_cs.szClass = cs->lpszClass;
977 mdi_cs.szTitle = cs->lpszName;
978 mdi_cs.hOwner = cs->hInstance;
979 mdi_cs.x = cs->x;
980 mdi_cs.y = cs->y;
981 mdi_cs.cx = cs->cx;
982 mdi_cs.cy = cs->cy;
983 mdi_cs.style = cs->style;
984 mdi_cs.lParam = (LPARAM)cs->lpCreateParams;
986 cs->lpCreateParams = (LPVOID)&mdi_cs;
988 if (GetWindowLongW(cs->hwndParent, GWL_STYLE) & MDIS_ALLCHILDSTYLES)
990 if (cs->style & WS_POPUP)
992 TRACE("WS_POPUP with MDIS_ALLCHILDSTYLES is not allowed\n");
993 return 0;
995 cs->style |= WS_CHILD | WS_CLIPSIBLINGS;
997 else
999 cs->style &= ~WS_POPUP;
1000 cs->style |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CAPTION |
1001 WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
1004 top_child = GetWindow(cs->hwndParent, GW_CHILD);
1006 if (top_child)
1008 /* Restore current maximized child */
1009 if((cs->style & WS_VISIBLE) && IsZoomed(top_child))
1011 TRACE("Restoring current maximized child %p\n", top_child);
1012 SendMessageW( top_child, WM_SETREDRAW, FALSE, 0 );
1013 ShowWindow( top_child, SW_SHOWNORMAL );
1014 SendMessageW( top_child, WM_SETREDRAW, TRUE, 0 );
1019 /* Find the parent window */
1021 parent = cs->hwndParent;
1022 owner = 0;
1024 if (cs->hwndParent == HWND_MESSAGE)
1026 cs->hwndParent = parent = get_hwnd_message_parent();
1028 else if (cs->hwndParent)
1030 if ((cs->style & (WS_CHILD|WS_POPUP)) != WS_CHILD)
1032 parent = GetDesktopWindow();
1033 owner = cs->hwndParent;
1036 else
1038 static const WCHAR messageW[] = {'M','e','s','s','a','g','e',0};
1040 if ((cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
1042 WARN("No parent for child window\n" );
1043 SetLastError(ERROR_TLW_WITH_WSCHILD);
1044 return 0; /* WS_CHILD needs a parent, but WS_POPUP doesn't */
1046 /* are we creating the desktop or HWND_MESSAGE parent itself? */
1047 if (className != (LPCWSTR)DESKTOP_CLASS_ATOM &&
1048 (IS_INTRESOURCE(className) || strcmpiW( className, messageW )))
1049 parent = GetDesktopWindow();
1052 WIN_FixCoordinates(cs, &sw); /* fix default coordinates */
1054 if ((cs->dwExStyle & WS_EX_DLGMODALFRAME) ||
1055 ((!(cs->dwExStyle & WS_EX_STATICEDGE)) &&
1056 (cs->style & (WS_DLGFRAME | WS_THICKFRAME))))
1057 cs->dwExStyle |= WS_EX_WINDOWEDGE;
1058 else
1059 cs->dwExStyle &= ~WS_EX_WINDOWEDGE;
1061 /* Create the window structure */
1063 if (!(wndPtr = create_window_handle( parent, owner, className, cs->hInstance, unicode )))
1064 return 0;
1065 hwnd = wndPtr->hwndSelf;
1067 /* Fill the window structure */
1069 wndPtr->tid = GetCurrentThreadId();
1070 wndPtr->hInstance = cs->hInstance;
1071 wndPtr->text = NULL;
1072 wndPtr->dwStyle = cs->style & ~WS_VISIBLE;
1073 wndPtr->dwExStyle = cs->dwExStyle;
1074 wndPtr->wIDmenu = 0;
1075 wndPtr->helpContext = 0;
1076 wndPtr->pVScroll = NULL;
1077 wndPtr->pHScroll = NULL;
1078 wndPtr->userdata = 0;
1079 wndPtr->hIcon = 0;
1080 wndPtr->hIconSmall = 0;
1081 wndPtr->hSysMenu = 0;
1082 wndPtr->flags |= (flags & WIN_ISWIN32);
1084 wndPtr->min_pos.x = wndPtr->min_pos.y = -1;
1085 wndPtr->max_pos.x = wndPtr->max_pos.y = -1;
1087 if (wndPtr->dwStyle & WS_SYSMENU) SetSystemMenu( hwnd, 0 );
1090 * Correct the window styles.
1092 * It affects only the style loaded into the WIN structure.
1095 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1097 wndPtr->dwStyle |= WS_CLIPSIBLINGS;
1098 if (!(wndPtr->dwStyle & WS_POPUP))
1099 wndPtr->dwStyle |= WS_CAPTION;
1103 * WS_EX_WINDOWEDGE appears to be enforced based on the other styles, so
1104 * why does the user get to set it?
1107 if ((wndPtr->dwExStyle & WS_EX_DLGMODALFRAME) ||
1108 (wndPtr->dwStyle & (WS_DLGFRAME | WS_THICKFRAME)))
1109 wndPtr->dwExStyle |= WS_EX_WINDOWEDGE;
1110 else
1111 wndPtr->dwExStyle &= ~WS_EX_WINDOWEDGE;
1113 if (!(wndPtr->dwStyle & (WS_CHILD | WS_POPUP)))
1114 wndPtr->flags |= WIN_NEED_SIZE;
1116 SERVER_START_REQ( set_window_info )
1118 req->handle = wine_server_user_handle( hwnd );
1119 req->flags = SET_WIN_STYLE | SET_WIN_EXSTYLE | SET_WIN_INSTANCE | SET_WIN_UNICODE;
1120 req->style = wndPtr->dwStyle;
1121 req->ex_style = wndPtr->dwExStyle;
1122 req->instance = (void *)wndPtr->hInstance;
1123 req->is_unicode = (wndPtr->flags & WIN_ISUNICODE) != 0;
1124 req->extra_offset = -1;
1125 wine_server_call( req );
1127 SERVER_END_REQ;
1129 /* Set the window menu */
1131 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1133 if (cs->hMenu)
1135 if (!MENU_SetMenu(hwnd, cs->hMenu))
1137 WIN_ReleasePtr( wndPtr );
1138 free_window_handle( hwnd );
1139 return 0;
1142 else
1144 LPCSTR menuName = (LPCSTR)GetClassLongPtrA( hwnd, GCLP_MENUNAME );
1145 if (menuName)
1147 if (!cs->hInstance || HIWORD(cs->hInstance))
1148 cs->hMenu = LoadMenuA(cs->hInstance,menuName);
1149 else
1150 cs->hMenu = HMENU_32(LoadMenu16(HINSTANCE_16(cs->hInstance),menuName));
1152 if (cs->hMenu) MENU_SetMenu( hwnd, cs->hMenu );
1156 else SetWindowLongPtrW( hwnd, GWLP_ID, (ULONG_PTR)cs->hMenu );
1158 /* call the WH_CBT hook */
1160 /* the window style passed to the hook must be the real window style,
1161 * rather than just the window style that the caller to CreateWindowEx
1162 * passed in, so we have to copy the original CREATESTRUCT and get the
1163 * the real style. */
1164 cbcs = *cs;
1165 cbcs.style = wndPtr->dwStyle;
1166 cbtc.lpcs = &cbcs;
1167 cbtc.hwndInsertAfter = HWND_TOP;
1168 WIN_ReleasePtr( wndPtr );
1169 if (HOOK_CallHooks( WH_CBT, HCBT_CREATEWND, (WPARAM)hwnd, (LPARAM)&cbtc, unicode )) goto failed;
1171 /* send the WM_GETMINMAXINFO message and fix the size if needed */
1173 cx = cs->cx;
1174 cy = cs->cy;
1175 if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD)))
1177 POINT maxSize, maxPos, minTrack, maxTrack;
1178 WINPOS_GetMinMaxInfo( hwnd, &maxSize, &maxPos, &minTrack, &maxTrack);
1179 if (maxTrack.x < cx) cx = maxTrack.x;
1180 if (maxTrack.y < cy) cy = maxTrack.y;
1181 if (minTrack.x > cx) cx = minTrack.x;
1182 if (minTrack.y > cy) cy = minTrack.y;
1185 if (cx < 0) cx = 0;
1186 if (cy < 0) cy = 0;
1187 SetRect( &rect, cs->x, cs->y, cs->x + cx, cs->y + cy );
1188 /* check for wraparound */
1189 if (cs->x + cx < cs->x) rect.right = 0x7fffffff;
1190 if (cs->y + cy < cs->y) rect.bottom = 0x7fffffff;
1191 if (!set_window_pos( hwnd, 0, SWP_NOZORDER | SWP_NOACTIVATE, &rect, &rect, NULL )) goto failed;
1193 /* send WM_NCCREATE */
1195 TRACE( "hwnd %p cs %d,%d %dx%d\n", hwnd, cs->x, cs->y, cx, cy );
1196 if (unicode)
1197 result = SendMessageW( hwnd, WM_NCCREATE, 0, (LPARAM)cs );
1198 else
1199 result = SendMessageA( hwnd, WM_NCCREATE, 0, (LPARAM)cs );
1200 if (!result)
1202 WARN( "%p: aborted by WM_NCCREATE\n", hwnd );
1203 goto failed;
1206 /* send WM_NCCALCSIZE */
1208 if ((wndPtr = WIN_GetPtr(hwnd)))
1210 /* yes, even if the CBT hook was called with HWND_TOP */
1211 POINT pt;
1212 HWND insert_after = (wndPtr->dwStyle & WS_CHILD) ? HWND_BOTTOM : HWND_TOP;
1213 RECT window_rect = wndPtr->rectWindow;
1214 RECT client_rect = window_rect;
1215 WIN_ReleasePtr( wndPtr );
1217 /* the rectangle is in screen coords for WM_NCCALCSIZE when wparam is FALSE */
1218 pt.x = pt.y = 0;
1219 MapWindowPoints( parent, 0, &pt, 1 );
1220 OffsetRect( &client_rect, pt.x, pt.y );
1221 SendMessageW( hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&client_rect );
1222 OffsetRect( &client_rect, -pt.x, -pt.y );
1223 set_window_pos( hwnd, insert_after, SWP_NOACTIVATE, &window_rect, &client_rect, NULL );
1225 else return 0;
1227 /* send WM_CREATE */
1229 if (unicode)
1230 result = SendMessageW( hwnd, WM_CREATE, 0, (LPARAM)cs );
1231 else
1232 result = SendMessageA( hwnd, WM_CREATE, 0, (LPARAM)cs );
1233 if (result == -1) goto failed;
1235 /* call the driver */
1237 if (!USER_Driver->pCreateWindow( hwnd )) goto failed;
1239 NotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_WINDOW, 0);
1241 /* send the size messages */
1243 if (!(wndPtr = WIN_GetPtr( hwnd )) ||
1244 wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return 0;
1245 if (!(wndPtr->flags & WIN_NEED_SIZE))
1247 rect = wndPtr->rectClient;
1248 WIN_ReleasePtr( wndPtr );
1249 SendMessageW( hwnd, WM_SIZE, SIZE_RESTORED,
1250 MAKELONG(rect.right-rect.left, rect.bottom-rect.top));
1251 SendMessageW( hwnd, WM_MOVE, 0, MAKELONG( rect.left, rect.top ) );
1253 else WIN_ReleasePtr( wndPtr );
1255 /* Show the window, maximizing or minimizing if needed */
1257 style = WIN_SetStyle( hwnd, 0, WS_MAXIMIZE | WS_MINIMIZE );
1258 if (style & (WS_MINIMIZE | WS_MAXIMIZE))
1260 RECT newPos;
1261 UINT swFlag = (style & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE;
1263 swFlag = WINPOS_MinMaximize( hwnd, swFlag, &newPos );
1264 swFlag |= SWP_FRAMECHANGED; /* Frame always gets changed */
1265 if (!(style & WS_VISIBLE) || (style & WS_CHILD) || GetActiveWindow()) swFlag |= SWP_NOACTIVATE;
1266 SetWindowPos( hwnd, 0, newPos.left, newPos.top, newPos.right - newPos.left,
1267 newPos.bottom - newPos.top, swFlag );
1270 /* Notify the parent window only */
1272 send_parent_notify( hwnd, WM_CREATE );
1273 if (!IsWindow( hwnd )) return 0;
1275 if (cs->style & WS_VISIBLE)
1277 if (cs->style & WS_MAXIMIZE)
1278 sw = SW_SHOW;
1279 else if (cs->style & WS_MINIMIZE)
1280 sw = SW_SHOWMINIMIZED;
1282 ShowWindow( hwnd, sw );
1283 if (cs->dwExStyle & WS_EX_MDICHILD)
1285 SendMessageW(cs->hwndParent, WM_MDIREFRESHMENU, 0, 0);
1286 /* ShowWindow won't activate child windows */
1287 SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE );
1291 /* Call WH_SHELL hook */
1293 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) && !GetWindow( hwnd, GW_OWNER ))
1294 HOOK_CallHooks( WH_SHELL, HSHELL_WINDOWCREATED, (WPARAM)hwnd, 0, TRUE );
1296 TRACE("created window %p\n", hwnd);
1297 return hwnd;
1299 failed:
1300 WIN_DestroyWindow( hwnd );
1301 return 0;
1305 /***********************************************************************
1306 * CreateWindow (USER.41)
1308 HWND16 WINAPI CreateWindow16( LPCSTR className, LPCSTR windowName,
1309 DWORD style, INT16 x, INT16 y, INT16 width,
1310 INT16 height, HWND16 parent, HMENU16 menu,
1311 HINSTANCE16 instance, LPVOID data )
1313 return CreateWindowEx16( 0, className, windowName, style,
1314 x, y, width, height, parent, menu, instance, data );
1318 /***********************************************************************
1319 * CreateWindowEx (USER.452)
1321 HWND16 WINAPI CreateWindowEx16( DWORD exStyle, LPCSTR className,
1322 LPCSTR windowName, DWORD style, INT16 x,
1323 INT16 y, INT16 width, INT16 height,
1324 HWND16 parent, HMENU16 menu,
1325 HINSTANCE16 instance, LPVOID data )
1327 CREATESTRUCTA cs;
1328 char buffer[256];
1330 /* Fix the coordinates */
1332 cs.x = (x == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)x;
1333 cs.y = (y == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)y;
1334 cs.cx = (width == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)width;
1335 cs.cy = (height == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)height;
1337 /* Create the window */
1339 cs.lpCreateParams = data;
1340 cs.hInstance = HINSTANCE_32(instance);
1341 cs.hMenu = HMENU_32(menu);
1342 cs.hwndParent = WIN_Handle32( parent );
1343 cs.style = style;
1344 cs.lpszName = windowName;
1345 cs.lpszClass = className;
1346 cs.dwExStyle = exStyle;
1348 if (!IS_INTRESOURCE(className))
1350 WCHAR bufferW[256];
1352 if (!MultiByteToWideChar( CP_ACP, 0, className, -1, bufferW, sizeof(bufferW)/sizeof(WCHAR) ))
1353 return 0;
1354 return HWND_16( WIN_CreateWindowEx( &cs, bufferW, 0 ));
1356 else
1358 if (!GlobalGetAtomNameA( LOWORD(className), buffer, sizeof(buffer) ))
1360 ERR( "bad atom %x\n", LOWORD(className));
1361 return 0;
1363 cs.lpszClass = buffer;
1364 return HWND_16( WIN_CreateWindowEx( &cs, (LPCWSTR)className, 0 ));
1369 /***********************************************************************
1370 * CreateWindowExA (USER32.@)
1372 HWND WINAPI CreateWindowExA( DWORD exStyle, LPCSTR className,
1373 LPCSTR windowName, DWORD style, INT x,
1374 INT y, INT width, INT height,
1375 HWND parent, HMENU menu,
1376 HINSTANCE instance, LPVOID data )
1378 CREATESTRUCTA cs;
1380 cs.lpCreateParams = data;
1381 cs.hInstance = instance;
1382 cs.hMenu = menu;
1383 cs.hwndParent = parent;
1384 cs.x = x;
1385 cs.y = y;
1386 cs.cx = width;
1387 cs.cy = height;
1388 cs.style = style;
1389 cs.lpszName = windowName;
1390 cs.lpszClass = className;
1391 cs.dwExStyle = exStyle;
1393 if (!IS_INTRESOURCE(className))
1395 WCHAR bufferW[256];
1396 if (!MultiByteToWideChar( CP_ACP, 0, className, -1, bufferW, sizeof(bufferW)/sizeof(WCHAR) ))
1397 return 0;
1398 return WIN_CreateWindowEx( &cs, bufferW, WIN_ISWIN32 );
1400 return WIN_CreateWindowEx( &cs, (LPCWSTR)className, WIN_ISWIN32 );
1404 /***********************************************************************
1405 * CreateWindowExW (USER32.@)
1407 HWND WINAPI CreateWindowExW( DWORD exStyle, LPCWSTR className,
1408 LPCWSTR windowName, DWORD style, INT x,
1409 INT y, INT width, INT height,
1410 HWND parent, HMENU menu,
1411 HINSTANCE instance, LPVOID data )
1413 CREATESTRUCTW cs;
1415 cs.lpCreateParams = data;
1416 cs.hInstance = instance;
1417 cs.hMenu = menu;
1418 cs.hwndParent = parent;
1419 cs.x = x;
1420 cs.y = y;
1421 cs.cx = width;
1422 cs.cy = height;
1423 cs.style = style;
1424 cs.lpszName = windowName;
1425 cs.lpszClass = className;
1426 cs.dwExStyle = exStyle;
1428 /* Note: we rely on the fact that CREATESTRUCTA and */
1429 /* CREATESTRUCTW have the same layout. */
1430 return WIN_CreateWindowEx( (CREATESTRUCTA *)&cs, className, WIN_ISWIN32 | WIN_ISUNICODE );
1434 /***********************************************************************
1435 * WIN_SendDestroyMsg
1437 static void WIN_SendDestroyMsg( HWND hwnd )
1439 GUITHREADINFO info;
1441 if (GetGUIThreadInfo( GetCurrentThreadId(), &info ))
1443 if (hwnd == info.hwndCaret) DestroyCaret();
1444 if (hwnd == info.hwndActive) WINPOS_ActivateOtherWindow( hwnd );
1448 * Send the WM_DESTROY to the window.
1450 SendMessageW( hwnd, WM_DESTROY, 0, 0);
1453 * This WM_DESTROY message can trigger re-entrant calls to DestroyWindow
1454 * make sure that the window still exists when we come back.
1456 if (IsWindow(hwnd))
1458 HWND* pWndArray;
1459 int i;
1461 if (!(pWndArray = WIN_ListChildren( hwnd ))) return;
1463 for (i = 0; pWndArray[i]; i++)
1465 if (IsWindow( pWndArray[i] )) WIN_SendDestroyMsg( pWndArray[i] );
1467 HeapFree( GetProcessHeap(), 0, pWndArray );
1469 else
1470 WARN("\tdestroyed itself while in WM_DESTROY!\n");
1474 /***********************************************************************
1475 * DestroyWindow (USER32.@)
1477 BOOL WINAPI DestroyWindow( HWND hwnd )
1479 BOOL is_child;
1481 if (!(hwnd = WIN_IsCurrentThread( hwnd )) || is_desktop_window( hwnd ))
1483 SetLastError( ERROR_ACCESS_DENIED );
1484 return FALSE;
1487 TRACE("(%p)\n", hwnd);
1489 /* Call hooks */
1491 if (HOOK_CallHooks( WH_CBT, HCBT_DESTROYWND, (WPARAM)hwnd, 0, TRUE )) return FALSE;
1493 if (MENU_IsMenuActive() == hwnd)
1494 EndMenu();
1496 is_child = (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) != 0;
1498 if (is_child)
1500 if (!USER_IsExitingThread( GetCurrentThreadId() ))
1501 send_parent_notify( hwnd, WM_DESTROY );
1503 else if (!GetWindow( hwnd, GW_OWNER ))
1505 HOOK_CallHooks( WH_SHELL, HSHELL_WINDOWDESTROYED, (WPARAM)hwnd, 0L, TRUE );
1506 /* FIXME: clean up palette - see "Internals" p.352 */
1509 if (!IsWindow(hwnd)) return TRUE;
1511 /* Hide the window */
1512 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)
1514 /* Only child windows receive WM_SHOWWINDOW in DestroyWindow() */
1515 if (is_child)
1516 ShowWindow( hwnd, SW_HIDE );
1517 else
1518 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE |
1519 SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW );
1522 if (!IsWindow(hwnd)) return TRUE;
1524 /* Recursively destroy owned windows */
1526 if (!is_child)
1528 for (;;)
1530 int i, got_one = 0;
1531 HWND *list = WIN_ListChildren( GetDesktopWindow() );
1532 if (list)
1534 for (i = 0; list[i]; i++)
1536 if (GetWindow( list[i], GW_OWNER ) != hwnd) continue;
1537 if (WIN_IsCurrentThread( list[i] ))
1539 DestroyWindow( list[i] );
1540 got_one = 1;
1541 continue;
1543 WIN_SetOwner( list[i], 0 );
1545 HeapFree( GetProcessHeap(), 0, list );
1547 if (!got_one) break;
1551 /* Send destroy messages */
1553 WIN_SendDestroyMsg( hwnd );
1554 if (!IsWindow( hwnd )) return TRUE;
1556 if (GetClipboardOwner() == hwnd)
1557 CLIPBOARD_ReleaseOwner();
1559 /* Destroy the window storage */
1561 WIN_DestroyWindow( hwnd );
1562 return TRUE;
1566 /***********************************************************************
1567 * CloseWindow (USER32.@)
1569 BOOL WINAPI CloseWindow( HWND hwnd )
1571 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) return FALSE;
1572 ShowWindow( hwnd, SW_MINIMIZE );
1573 return TRUE;
1577 /***********************************************************************
1578 * OpenIcon (USER32.@)
1580 BOOL WINAPI OpenIcon( HWND hwnd )
1582 if (!IsIconic( hwnd )) return FALSE;
1583 ShowWindow( hwnd, SW_SHOWNORMAL );
1584 return TRUE;
1588 /***********************************************************************
1589 * FindWindowExW (USER32.@)
1591 HWND WINAPI FindWindowExW( HWND parent, HWND child, LPCWSTR className, LPCWSTR title )
1593 HWND *list = NULL;
1594 HWND retvalue = 0;
1595 int i = 0, len = 0;
1596 WCHAR *buffer = NULL;
1598 if (!parent && child) parent = GetDesktopWindow();
1599 else if (parent == HWND_MESSAGE) parent = get_hwnd_message_parent();
1601 if (title)
1603 len = strlenW(title) + 1; /* one extra char to check for chars beyond the end */
1604 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return 0;
1607 if (!(list = list_window_children( 0, parent, className, 0 ))) goto done;
1609 if (child)
1611 child = WIN_GetFullHandle( child );
1612 while (list[i] && list[i] != child) i++;
1613 if (!list[i]) goto done;
1614 i++; /* start from next window */
1617 if (title)
1619 while (list[i])
1621 if (GetWindowTextW( list[i], buffer, len + 1 ) && !strcmpiW( buffer, title )) break;
1622 i++;
1625 retvalue = list[i];
1627 done:
1628 HeapFree( GetProcessHeap(), 0, list );
1629 HeapFree( GetProcessHeap(), 0, buffer );
1630 return retvalue;
1635 /***********************************************************************
1636 * FindWindowA (USER32.@)
1638 HWND WINAPI FindWindowA( LPCSTR className, LPCSTR title )
1640 HWND ret = FindWindowExA( 0, 0, className, title );
1641 if (!ret) SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1642 return ret;
1646 /***********************************************************************
1647 * FindWindowExA (USER32.@)
1649 HWND WINAPI FindWindowExA( HWND parent, HWND child, LPCSTR className, LPCSTR title )
1651 LPWSTR titleW = NULL;
1652 HWND hwnd = 0;
1654 if (title)
1656 DWORD len = MultiByteToWideChar( CP_ACP, 0, title, -1, NULL, 0 );
1657 if (!(titleW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return 0;
1658 MultiByteToWideChar( CP_ACP, 0, title, -1, titleW, len );
1661 if (!IS_INTRESOURCE(className))
1663 WCHAR classW[256];
1664 if (MultiByteToWideChar( CP_ACP, 0, className, -1, classW, sizeof(classW)/sizeof(WCHAR) ))
1665 hwnd = FindWindowExW( parent, child, classW, titleW );
1667 else
1669 hwnd = FindWindowExW( parent, child, (LPCWSTR)className, titleW );
1672 HeapFree( GetProcessHeap(), 0, titleW );
1673 return hwnd;
1677 /***********************************************************************
1678 * FindWindowW (USER32.@)
1680 HWND WINAPI FindWindowW( LPCWSTR className, LPCWSTR title )
1682 return FindWindowExW( 0, 0, className, title );
1686 /**********************************************************************
1687 * GetDesktopWindow (USER32.@)
1689 HWND WINAPI GetDesktopWindow(void)
1691 struct user_thread_info *thread_info = get_user_thread_info();
1693 if (thread_info->top_window) return thread_info->top_window;
1695 SERVER_START_REQ( get_desktop_window )
1697 req->force = 0;
1698 if (!wine_server_call( req ))
1700 thread_info->top_window = wine_server_ptr_handle( reply->top_window );
1701 thread_info->msg_window = wine_server_ptr_handle( reply->msg_window );
1704 SERVER_END_REQ;
1706 if (!thread_info->top_window)
1708 USEROBJECTFLAGS flags;
1709 if (!GetUserObjectInformationW( GetProcessWindowStation(), UOI_FLAGS, &flags,
1710 sizeof(flags), NULL ) || (flags.dwFlags & WSF_VISIBLE))
1712 static const WCHAR command_line[] = {'\\','e','x','p','l','o','r','e','r','.','e','x','e',' ','/','d','e','s','k','t','o','p',0};
1713 STARTUPINFOW si;
1714 PROCESS_INFORMATION pi;
1715 WCHAR cmdline[MAX_PATH + sizeof(command_line)/sizeof(WCHAR)];
1717 memset( &si, 0, sizeof(si) );
1718 si.cb = sizeof(si);
1719 si.dwFlags = STARTF_USESTDHANDLES;
1720 si.hStdInput = 0;
1721 si.hStdOutput = 0;
1722 si.hStdError = GetStdHandle( STD_ERROR_HANDLE );
1724 GetSystemDirectoryW( cmdline, MAX_PATH );
1725 lstrcatW( cmdline, command_line );
1726 if (CreateProcessW( NULL, cmdline, NULL, NULL, FALSE, DETACHED_PROCESS,
1727 NULL, NULL, &si, &pi ))
1729 TRACE( "started explorer pid %04x tid %04x\n", pi.dwProcessId, pi.dwThreadId );
1730 WaitForInputIdle( pi.hProcess, 10000 );
1731 CloseHandle( pi.hThread );
1732 CloseHandle( pi.hProcess );
1734 else WARN( "failed to start explorer, err %d\n", GetLastError() );
1736 else TRACE( "not starting explorer since winstation is not visible\n" );
1738 SERVER_START_REQ( get_desktop_window )
1740 req->force = 1;
1741 if (!wine_server_call( req ))
1743 thread_info->top_window = wine_server_ptr_handle( reply->top_window );
1744 thread_info->msg_window = wine_server_ptr_handle( reply->msg_window );
1747 SERVER_END_REQ;
1750 if (!thread_info->top_window || !USER_Driver->pCreateDesktopWindow( thread_info->top_window ))
1751 ERR( "failed to create desktop window\n" );
1753 return thread_info->top_window;
1757 /*******************************************************************
1758 * EnableWindow (USER32.@)
1760 BOOL WINAPI EnableWindow( HWND hwnd, BOOL enable )
1762 BOOL retvalue;
1763 HWND full_handle;
1765 if (is_broadcast(hwnd))
1767 SetLastError( ERROR_INVALID_PARAMETER );
1768 return FALSE;
1771 if (!(full_handle = WIN_IsCurrentThread( hwnd )))
1772 return SendMessageW( hwnd, WM_WINE_ENABLEWINDOW, enable, 0 );
1774 hwnd = full_handle;
1776 TRACE("( %p, %d )\n", hwnd, enable);
1778 retvalue = !IsWindowEnabled( hwnd );
1780 if (enable && retvalue)
1782 WIN_SetStyle( hwnd, 0, WS_DISABLED );
1783 SendMessageW( hwnd, WM_ENABLE, TRUE, 0 );
1785 else if (!enable && !retvalue)
1787 HWND capture_wnd;
1789 SendMessageW( hwnd, WM_CANCELMODE, 0, 0);
1791 WIN_SetStyle( hwnd, WS_DISABLED, 0 );
1793 if (hwnd == GetFocus())
1794 SetFocus( 0 ); /* A disabled window can't have the focus */
1796 capture_wnd = GetCapture();
1797 if (hwnd == capture_wnd || IsChild(hwnd, capture_wnd))
1798 ReleaseCapture(); /* A disabled window can't capture the mouse */
1800 SendMessageW( hwnd, WM_ENABLE, FALSE, 0 );
1802 return retvalue;
1806 /***********************************************************************
1807 * IsWindowEnabled (USER32.@)
1809 BOOL WINAPI IsWindowEnabled(HWND hWnd)
1811 return !(GetWindowLongW( hWnd, GWL_STYLE ) & WS_DISABLED);
1815 /***********************************************************************
1816 * IsWindowUnicode (USER32.@)
1818 BOOL WINAPI IsWindowUnicode( HWND hwnd )
1820 WND * wndPtr;
1821 BOOL retvalue = FALSE;
1823 if (!(wndPtr = WIN_GetPtr(hwnd))) return FALSE;
1825 if (wndPtr == WND_DESKTOP) return TRUE;
1827 if (wndPtr != WND_OTHER_PROCESS)
1829 retvalue = (wndPtr->flags & WIN_ISUNICODE) != 0;
1830 WIN_ReleasePtr( wndPtr );
1832 else
1834 SERVER_START_REQ( get_window_info )
1836 req->handle = wine_server_user_handle( hwnd );
1837 if (!wine_server_call_err( req )) retvalue = reply->is_unicode;
1839 SERVER_END_REQ;
1841 return retvalue;
1845 /**********************************************************************
1846 * WIN_GetWindowLong
1848 * Helper function for GetWindowLong().
1850 static LONG_PTR WIN_GetWindowLong( HWND hwnd, INT offset, UINT size, BOOL unicode )
1852 LONG_PTR retvalue = 0;
1853 WND *wndPtr;
1855 if (offset == GWLP_HWNDPARENT)
1857 HWND parent = GetAncestor( hwnd, GA_PARENT );
1858 if (parent == GetDesktopWindow()) parent = GetWindow( hwnd, GW_OWNER );
1859 return (ULONG_PTR)parent;
1862 if (!(wndPtr = WIN_GetPtr( hwnd )))
1864 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1865 return 0;
1868 if (wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP)
1870 if (offset == GWLP_WNDPROC)
1872 SetLastError( ERROR_ACCESS_DENIED );
1873 return 0;
1875 SERVER_START_REQ( set_window_info )
1877 req->handle = wine_server_user_handle( hwnd );
1878 req->flags = 0; /* don't set anything, just retrieve */
1879 req->extra_offset = (offset >= 0) ? offset : -1;
1880 req->extra_size = (offset >= 0) ? size : 0;
1881 if (!wine_server_call_err( req ))
1883 switch(offset)
1885 case GWL_STYLE: retvalue = reply->old_style; break;
1886 case GWL_EXSTYLE: retvalue = reply->old_ex_style; break;
1887 case GWLP_ID: retvalue = reply->old_id; break;
1888 case GWLP_HINSTANCE: retvalue = (ULONG_PTR)reply->old_instance; break;
1889 case GWLP_USERDATA: retvalue = reply->old_user_data; break;
1890 default:
1891 if (offset >= 0) retvalue = get_win_data( &reply->old_extra_value, size );
1892 else SetLastError( ERROR_INVALID_INDEX );
1893 break;
1897 SERVER_END_REQ;
1898 return retvalue;
1901 /* now we have a valid wndPtr */
1903 if (offset >= 0)
1905 if (offset > (int)(wndPtr->cbWndExtra - size))
1907 WARN("Invalid offset %d\n", offset );
1908 WIN_ReleasePtr( wndPtr );
1909 SetLastError( ERROR_INVALID_INDEX );
1910 return 0;
1912 retvalue = get_win_data( (char *)wndPtr->wExtra + offset, size );
1914 /* Special case for dialog window procedure */
1915 if ((offset == DWLP_DLGPROC) && (size == sizeof(LONG_PTR)) && (wndPtr->flags & WIN_ISDIALOG))
1916 retvalue = (LONG_PTR)WINPROC_GetProc( (WNDPROC)retvalue, unicode );
1917 WIN_ReleasePtr( wndPtr );
1918 return retvalue;
1921 switch(offset)
1923 case GWLP_USERDATA: retvalue = wndPtr->userdata; break;
1924 case GWL_STYLE: retvalue = wndPtr->dwStyle; break;
1925 case GWL_EXSTYLE: retvalue = wndPtr->dwExStyle; break;
1926 case GWLP_ID: retvalue = wndPtr->wIDmenu; break;
1927 case GWLP_HINSTANCE: retvalue = (ULONG_PTR)wndPtr->hInstance; break;
1928 case GWLP_WNDPROC:
1929 /* This looks like a hack only for the edit control (see tests). This makes these controls
1930 * more tolerant to A/W mismatches. The lack of W->A->W conversion for such a mismatch suggests
1931 * that the hack is in GetWindowLongPtr[AW], not in winprocs.
1933 if (wndPtr->winproc == EDIT_winproc_handle && (!unicode != !(wndPtr->flags & WIN_ISUNICODE)))
1934 retvalue = (ULONG_PTR)wndPtr->winproc;
1935 else
1936 retvalue = (ULONG_PTR)WINPROC_GetProc( wndPtr->winproc, unicode );
1937 break;
1938 default:
1939 WARN("Unknown offset %d\n", offset );
1940 SetLastError( ERROR_INVALID_INDEX );
1941 break;
1943 WIN_ReleasePtr(wndPtr);
1944 return retvalue;
1948 /**********************************************************************
1949 * WIN_SetWindowLong
1951 * Helper function for SetWindowLong().
1953 * 0 is the failure code. However, in the case of failure SetLastError
1954 * must be set to distinguish between a 0 return value and a failure.
1956 LONG_PTR WIN_SetWindowLong( HWND hwnd, INT offset, UINT size, LONG_PTR newval, BOOL unicode )
1958 STYLESTRUCT style;
1959 BOOL ok;
1960 LONG_PTR retval = 0;
1961 WND *wndPtr;
1963 TRACE( "%p %d %lx %c\n", hwnd, offset, newval, unicode ? 'W' : 'A' );
1965 if (is_broadcast(hwnd))
1967 SetLastError( ERROR_INVALID_PARAMETER );
1968 return FALSE;
1971 if (!(wndPtr = WIN_GetPtr( hwnd )))
1973 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1974 return 0;
1976 if (wndPtr == WND_DESKTOP)
1978 /* can't change anything on the desktop window */
1979 SetLastError( ERROR_ACCESS_DENIED );
1980 return 0;
1982 if (wndPtr == WND_OTHER_PROCESS)
1984 if (offset == GWLP_WNDPROC)
1986 SetLastError( ERROR_ACCESS_DENIED );
1987 return 0;
1989 if (offset > 32767 || offset < -32767)
1991 SetLastError( ERROR_INVALID_INDEX );
1992 return 0;
1994 return SendMessageW( hwnd, WM_WINE_SETWINDOWLONG, MAKEWPARAM( offset, size ), newval );
1997 /* first some special cases */
1998 switch( offset )
2000 case GWL_STYLE:
2001 case GWL_EXSTYLE:
2002 style.styleOld =
2003 offset == GWL_STYLE ? wndPtr->dwStyle : wndPtr->dwExStyle;
2004 style.styleNew = newval;
2005 WIN_ReleasePtr( wndPtr );
2006 SendMessageW( hwnd, WM_STYLECHANGING, offset, (LPARAM)&style );
2007 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return 0;
2008 newval = style.styleNew;
2009 break;
2010 case GWLP_HWNDPARENT:
2011 if (wndPtr->parent == GetDesktopWindow())
2013 WIN_ReleasePtr( wndPtr );
2014 return (ULONG_PTR)WIN_SetOwner( hwnd, (HWND)newval );
2016 else
2018 WIN_ReleasePtr( wndPtr );
2019 return (ULONG_PTR)SetParent( hwnd, (HWND)newval );
2021 case GWLP_WNDPROC:
2023 WNDPROC proc;
2024 UINT old_flags = wndPtr->flags;
2025 retval = WIN_GetWindowLong( hwnd, offset, size, unicode );
2026 if (unicode) proc = WINPROC_AllocProc( NULL, (WNDPROC)newval );
2027 else proc = WINPROC_AllocProc( (WNDPROC)newval, NULL );
2028 if (proc) wndPtr->winproc = proc;
2029 if (WINPROC_IsUnicode( proc, unicode )) wndPtr->flags |= WIN_ISUNICODE;
2030 else wndPtr->flags &= ~WIN_ISUNICODE;
2031 if (!((old_flags ^ wndPtr->flags) & WIN_ISUNICODE))
2033 WIN_ReleasePtr( wndPtr );
2034 return retval;
2036 /* update is_unicode flag on the server side */
2037 break;
2039 case GWLP_ID:
2040 case GWLP_HINSTANCE:
2041 case GWLP_USERDATA:
2042 break;
2043 case DWLP_DLGPROC:
2044 if ((wndPtr->cbWndExtra - sizeof(LONG_PTR) >= DWLP_DLGPROC) &&
2045 (size == sizeof(LONG_PTR)) && (wndPtr->flags & WIN_ISDIALOG))
2047 WNDPROC *ptr = (WNDPROC *)((char *)wndPtr->wExtra + DWLP_DLGPROC);
2048 retval = (ULONG_PTR)WINPROC_GetProc( *ptr, unicode );
2049 if (unicode) *ptr = WINPROC_AllocProc( NULL, (WNDPROC)newval );
2050 else *ptr = WINPROC_AllocProc( (WNDPROC)newval, NULL );
2051 WIN_ReleasePtr( wndPtr );
2052 return retval;
2054 /* fall through */
2055 default:
2056 if (offset < 0 || offset > (int)(wndPtr->cbWndExtra - size))
2058 WARN("Invalid offset %d\n", offset );
2059 WIN_ReleasePtr( wndPtr );
2060 SetLastError( ERROR_INVALID_INDEX );
2061 return 0;
2063 else if (get_win_data( (char *)wndPtr->wExtra + offset, size ) == newval)
2065 /* already set to the same value */
2066 WIN_ReleasePtr( wndPtr );
2067 return newval;
2069 break;
2072 SERVER_START_REQ( set_window_info )
2074 req->handle = wine_server_user_handle( hwnd );
2075 req->extra_offset = -1;
2076 switch(offset)
2078 case GWL_STYLE:
2079 req->flags = SET_WIN_STYLE;
2080 req->style = newval;
2081 break;
2082 case GWL_EXSTYLE:
2083 req->flags = SET_WIN_EXSTYLE;
2084 /* WS_EX_TOPMOST can only be changed through SetWindowPos */
2085 newval = (newval & ~WS_EX_TOPMOST) | (wndPtr->dwExStyle & WS_EX_TOPMOST);
2086 req->ex_style = newval;
2087 break;
2088 case GWLP_ID:
2089 req->flags = SET_WIN_ID;
2090 req->id = newval;
2091 break;
2092 case GWLP_HINSTANCE:
2093 req->flags = SET_WIN_INSTANCE;
2094 req->instance = (void *)newval;
2095 break;
2096 case GWLP_WNDPROC:
2097 req->flags = SET_WIN_UNICODE;
2098 req->is_unicode = (wndPtr->flags & WIN_ISUNICODE) != 0;
2099 break;
2100 case GWLP_USERDATA:
2101 req->flags = SET_WIN_USERDATA;
2102 req->user_data = newval;
2103 break;
2104 default:
2105 req->flags = SET_WIN_EXTRA;
2106 req->extra_offset = offset;
2107 req->extra_size = size;
2108 set_win_data( &req->extra_value, newval, size );
2110 if ((ok = !wine_server_call_err( req )))
2112 switch(offset)
2114 case GWL_STYLE:
2115 wndPtr->dwStyle = newval;
2116 retval = reply->old_style;
2117 break;
2118 case GWL_EXSTYLE:
2119 wndPtr->dwExStyle = newval;
2120 retval = reply->old_ex_style;
2121 break;
2122 case GWLP_ID:
2123 wndPtr->wIDmenu = newval;
2124 retval = reply->old_id;
2125 break;
2126 case GWLP_HINSTANCE:
2127 wndPtr->hInstance = (HINSTANCE)newval;
2128 retval = (ULONG_PTR)reply->old_instance;
2129 break;
2130 case GWLP_WNDPROC:
2131 break;
2132 case GWLP_USERDATA:
2133 wndPtr->userdata = newval;
2134 retval = reply->old_user_data;
2135 break;
2136 default:
2137 retval = get_win_data( (char *)wndPtr->wExtra + offset, size );
2138 set_win_data( (char *)wndPtr->wExtra + offset, newval, size );
2139 break;
2143 SERVER_END_REQ;
2144 WIN_ReleasePtr( wndPtr );
2146 if (!ok) return 0;
2148 if (offset == GWL_STYLE || offset == GWL_EXSTYLE)
2150 USER_Driver->pSetWindowStyle( hwnd, offset, &style );
2151 SendMessageW( hwnd, WM_STYLECHANGED, offset, (LPARAM)&style );
2154 return retval;
2158 /**********************************************************************
2159 * GetWindowLong (USER.135)
2161 LONG WINAPI GetWindowLong16( HWND16 hwnd, INT16 offset )
2163 WND *wndPtr;
2164 LONG_PTR retvalue;
2165 BOOL is_winproc = (offset == GWLP_WNDPROC);
2167 if (offset >= 0)
2169 if (!(wndPtr = WIN_GetPtr( WIN_Handle32(hwnd) )))
2171 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2172 return 0;
2174 if (wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
2176 if (offset > (int)(wndPtr->cbWndExtra - sizeof(LONG)))
2179 * Some programs try to access last element from 16 bit
2180 * code using illegal offset value. Hopefully this is
2181 * what those programs really expect.
2183 if (wndPtr->cbWndExtra >= 4 && offset == wndPtr->cbWndExtra - sizeof(WORD))
2185 INT offset2 = wndPtr->cbWndExtra - sizeof(LONG);
2186 ERR( "- replaced invalid offset %d with %d\n", offset, offset2 );
2187 offset = offset2;
2189 else
2191 WARN("Invalid offset %d\n", offset );
2192 WIN_ReleasePtr( wndPtr );
2193 SetLastError( ERROR_INVALID_INDEX );
2194 return 0;
2197 is_winproc = ((offset == DWLP_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG));
2198 WIN_ReleasePtr( wndPtr );
2201 retvalue = GetWindowLongA( WIN_Handle32(hwnd), offset );
2202 if (is_winproc) retvalue = (LONG_PTR)WINPROC_GetProc16( (WNDPROC)retvalue, FALSE );
2203 return retvalue;
2207 /**********************************************************************
2208 * GetWindowWord (USER32.@)
2210 WORD WINAPI GetWindowWord( HWND hwnd, INT offset )
2212 switch(offset)
2214 case GWLP_ID:
2215 case GWLP_HINSTANCE:
2216 case GWLP_HWNDPARENT:
2217 break;
2218 default:
2219 if (offset < 0)
2221 WARN("Invalid offset %d\n", offset );
2222 SetLastError( ERROR_INVALID_INDEX );
2223 return 0;
2225 break;
2227 return WIN_GetWindowLong( hwnd, offset, sizeof(WORD), FALSE );
2231 /**********************************************************************
2232 * GetWindowLongA (USER32.@)
2234 LONG WINAPI GetWindowLongA( HWND hwnd, INT offset )
2236 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG), FALSE );
2240 /**********************************************************************
2241 * GetWindowLongW (USER32.@)
2243 LONG WINAPI GetWindowLongW( HWND hwnd, INT offset )
2245 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG), TRUE );
2249 /**********************************************************************
2250 * SetWindowLong (USER.136)
2252 LONG WINAPI SetWindowLong16( HWND16 hwnd, INT16 offset, LONG newval )
2254 WND *wndPtr;
2255 BOOL is_winproc = (offset == GWLP_WNDPROC);
2257 if (offset == DWLP_DLGPROC)
2259 if (!(wndPtr = WIN_GetPtr( WIN_Handle32(hwnd) )))
2261 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2262 return 0;
2264 if (wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
2266 is_winproc = ((wndPtr->cbWndExtra - sizeof(LONG_PTR) >= DWLP_DLGPROC) &&
2267 (wndPtr->flags & WIN_ISDIALOG));
2268 WIN_ReleasePtr( wndPtr );
2272 if (is_winproc)
2274 WNDPROC new_proc = WINPROC_AllocProc16( (WNDPROC16)newval );
2275 WNDPROC old_proc = (WNDPROC)SetWindowLongPtrA( WIN_Handle32(hwnd), offset, (LONG_PTR)new_proc );
2276 return (LONG)WINPROC_GetProc16( old_proc, FALSE );
2278 else return SetWindowLongA( WIN_Handle32(hwnd), offset, newval );
2282 /**********************************************************************
2283 * SetWindowWord (USER32.@)
2285 WORD WINAPI SetWindowWord( HWND hwnd, INT offset, WORD newval )
2287 switch(offset)
2289 case GWLP_ID:
2290 case GWLP_HINSTANCE:
2291 case GWLP_HWNDPARENT:
2292 break;
2293 default:
2294 if (offset < 0)
2296 WARN("Invalid offset %d\n", offset );
2297 SetLastError( ERROR_INVALID_INDEX );
2298 return 0;
2300 break;
2302 return WIN_SetWindowLong( hwnd, offset, sizeof(WORD), newval, FALSE );
2306 /**********************************************************************
2307 * SetWindowLongA (USER32.@)
2309 * See SetWindowLongW.
2311 LONG WINAPI SetWindowLongA( HWND hwnd, INT offset, LONG newval )
2313 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG), newval, FALSE );
2317 /**********************************************************************
2318 * SetWindowLongW (USER32.@) Set window attribute
2320 * SetWindowLong() alters one of a window's attributes or sets a 32-bit (long)
2321 * value in a window's extra memory.
2323 * The _hwnd_ parameter specifies the window. is the handle to a
2324 * window that has extra memory. The _newval_ parameter contains the
2325 * new attribute or extra memory value. If positive, the _offset_
2326 * parameter is the byte-addressed location in the window's extra
2327 * memory to set. If negative, _offset_ specifies the window
2328 * attribute to set, and should be one of the following values:
2330 * GWL_EXSTYLE The window's extended window style
2332 * GWL_STYLE The window's window style.
2334 * GWLP_WNDPROC Pointer to the window's window procedure.
2336 * GWLP_HINSTANCE The window's pplication instance handle.
2338 * GWLP_ID The window's identifier.
2340 * GWLP_USERDATA The window's user-specified data.
2342 * If the window is a dialog box, the _offset_ parameter can be one of
2343 * the following values:
2345 * DWLP_DLGPROC The address of the window's dialog box procedure.
2347 * DWLP_MSGRESULT The return value of a message
2348 * that the dialog box procedure processed.
2350 * DWLP_USER Application specific information.
2352 * RETURNS
2354 * If successful, returns the previous value located at _offset_. Otherwise,
2355 * returns 0.
2357 * NOTES
2359 * Extra memory for a window class is specified by a nonzero cbWndExtra
2360 * parameter of the WNDCLASS structure passed to RegisterClass() at the
2361 * time of class creation.
2363 * Using GWL_WNDPROC to set a new window procedure effectively creates
2364 * a window subclass. Use CallWindowProc() in the new windows procedure
2365 * to pass messages to the superclass's window procedure.
2367 * The user data is reserved for use by the application which created
2368 * the window.
2370 * Do not use GWL_STYLE to change the window's WS_DISABLED style;
2371 * instead, call the EnableWindow() function to change the window's
2372 * disabled state.
2374 * Do not use GWL_HWNDPARENT to reset the window's parent, use
2375 * SetParent() instead.
2377 * Win95:
2378 * When offset is GWL_STYLE and the calling app's ver is 4.0,
2379 * it sends WM_STYLECHANGING before changing the settings
2380 * and WM_STYLECHANGED afterwards.
2381 * App ver 4.0 can't use SetWindowLong to change WS_EX_TOPMOST.
2383 LONG WINAPI SetWindowLongW(
2384 HWND hwnd, /* [in] window to alter */
2385 INT offset, /* [in] offset, in bytes, of location to alter */
2386 LONG newval /* [in] new value of location */
2388 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG), newval, TRUE );
2392 /*******************************************************************
2393 * GetWindowTextA (USER32.@)
2395 INT WINAPI GetWindowTextA( HWND hwnd, LPSTR lpString, INT nMaxCount )
2397 WCHAR *buffer;
2399 if (!lpString) return 0;
2401 if (WIN_IsCurrentProcess( hwnd ))
2402 return (INT)SendMessageA( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2404 /* when window belongs to other process, don't send a message */
2405 if (nMaxCount <= 0) return 0;
2406 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, nMaxCount * sizeof(WCHAR) ))) return 0;
2407 get_server_window_text( hwnd, buffer, nMaxCount );
2408 if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, lpString, nMaxCount, NULL, NULL ))
2409 lpString[nMaxCount-1] = 0;
2410 HeapFree( GetProcessHeap(), 0, buffer );
2411 return strlen(lpString);
2415 /*******************************************************************
2416 * InternalGetWindowText (USER32.@)
2418 INT WINAPI InternalGetWindowText(HWND hwnd,LPWSTR lpString,INT nMaxCount )
2420 WND *win;
2422 if (nMaxCount <= 0) return 0;
2423 if (!(win = WIN_GetPtr( hwnd ))) return 0;
2424 if (win == WND_DESKTOP) lpString[0] = 0;
2425 else if (win != WND_OTHER_PROCESS)
2427 if (win->text) lstrcpynW( lpString, win->text, nMaxCount );
2428 else lpString[0] = 0;
2429 WIN_ReleasePtr( win );
2431 else
2433 get_server_window_text( hwnd, lpString, nMaxCount );
2435 return strlenW(lpString);
2439 /*******************************************************************
2440 * GetWindowTextW (USER32.@)
2442 INT WINAPI GetWindowTextW( HWND hwnd, LPWSTR lpString, INT nMaxCount )
2444 if (!lpString) return 0;
2446 if (WIN_IsCurrentProcess( hwnd ))
2447 return (INT)SendMessageW( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2449 /* when window belongs to other process, don't send a message */
2450 if (nMaxCount <= 0) return 0;
2451 get_server_window_text( hwnd, lpString, nMaxCount );
2452 return strlenW(lpString);
2456 /*******************************************************************
2457 * SetWindowTextA (USER32.@)
2458 * SetWindowText (USER32.@)
2460 BOOL WINAPI SetWindowTextA( HWND hwnd, LPCSTR lpString )
2462 if (is_broadcast(hwnd))
2464 SetLastError( ERROR_INVALID_PARAMETER );
2465 return FALSE;
2467 if (!WIN_IsCurrentProcess( hwnd ))
2468 WARN( "setting text %s of other process window %p should not use SendMessage\n",
2469 debugstr_a(lpString), hwnd );
2470 return (BOOL)SendMessageA( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2474 /*******************************************************************
2475 * SetWindowTextW (USER32.@)
2477 BOOL WINAPI SetWindowTextW( HWND hwnd, LPCWSTR lpString )
2479 if (is_broadcast(hwnd))
2481 SetLastError( ERROR_INVALID_PARAMETER );
2482 return FALSE;
2484 if (!WIN_IsCurrentProcess( hwnd ))
2485 WARN( "setting text %s of other process window %p should not use SendMessage\n",
2486 debugstr_w(lpString), hwnd );
2487 return (BOOL)SendMessageW( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2491 /*******************************************************************
2492 * GetWindowTextLengthA (USER32.@)
2494 INT WINAPI GetWindowTextLengthA( HWND hwnd )
2496 return SendMessageA( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2499 /*******************************************************************
2500 * GetWindowTextLengthW (USER32.@)
2502 INT WINAPI GetWindowTextLengthW( HWND hwnd )
2504 return SendMessageW( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2508 /*******************************************************************
2509 * IsWindow (USER32.@)
2511 BOOL WINAPI IsWindow( HWND hwnd )
2513 WND *ptr;
2514 BOOL ret;
2516 if (!(ptr = WIN_GetPtr( hwnd ))) return FALSE;
2517 if (ptr == WND_DESKTOP) return TRUE;
2519 if (ptr != WND_OTHER_PROCESS)
2521 WIN_ReleasePtr( ptr );
2522 return TRUE;
2525 /* check other processes */
2526 SERVER_START_REQ( get_window_info )
2528 req->handle = wine_server_user_handle( hwnd );
2529 ret = !wine_server_call_err( req );
2531 SERVER_END_REQ;
2532 return ret;
2536 /***********************************************************************
2537 * GetWindowThreadProcessId (USER32.@)
2539 DWORD WINAPI GetWindowThreadProcessId( HWND hwnd, LPDWORD process )
2541 WND *ptr;
2542 DWORD tid = 0;
2544 if (!(ptr = WIN_GetPtr( hwnd )))
2546 SetLastError( ERROR_INVALID_WINDOW_HANDLE);
2547 return 0;
2550 if (ptr != WND_OTHER_PROCESS && ptr != WND_DESKTOP)
2552 /* got a valid window */
2553 tid = ptr->tid;
2554 if (process) *process = GetCurrentProcessId();
2555 WIN_ReleasePtr( ptr );
2556 return tid;
2559 /* check other processes */
2560 SERVER_START_REQ( get_window_info )
2562 req->handle = wine_server_user_handle( hwnd );
2563 if (!wine_server_call_err( req ))
2565 tid = (DWORD)reply->tid;
2566 if (process) *process = (DWORD)reply->pid;
2569 SERVER_END_REQ;
2570 return tid;
2574 /*****************************************************************
2575 * GetParent (USER32.@)
2577 HWND WINAPI GetParent( HWND hwnd )
2579 WND *wndPtr;
2580 HWND retvalue = 0;
2582 if (!(wndPtr = WIN_GetPtr( hwnd )))
2584 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2585 return 0;
2587 if (wndPtr == WND_DESKTOP) return 0;
2588 if (wndPtr == WND_OTHER_PROCESS)
2590 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
2591 if (style & (WS_POPUP | WS_CHILD))
2593 SERVER_START_REQ( get_window_tree )
2595 req->handle = wine_server_user_handle( hwnd );
2596 if (!wine_server_call_err( req ))
2598 if (style & WS_POPUP) retvalue = wine_server_ptr_handle( reply->owner );
2599 else if (style & WS_CHILD) retvalue = wine_server_ptr_handle( reply->parent );
2602 SERVER_END_REQ;
2605 else
2607 if (wndPtr->dwStyle & WS_POPUP) retvalue = wndPtr->owner;
2608 else if (wndPtr->dwStyle & WS_CHILD) retvalue = wndPtr->parent;
2609 WIN_ReleasePtr( wndPtr );
2611 return retvalue;
2615 /*****************************************************************
2616 * GetAncestor (USER32.@)
2618 HWND WINAPI GetAncestor( HWND hwnd, UINT type )
2620 WND *win;
2621 HWND *list, ret = 0;
2623 switch(type)
2625 case GA_PARENT:
2626 if (!(win = WIN_GetPtr( hwnd )))
2628 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2629 return 0;
2631 if (win == WND_DESKTOP) return 0;
2632 if (win != WND_OTHER_PROCESS)
2634 ret = win->parent;
2635 WIN_ReleasePtr( win );
2637 else /* need to query the server */
2639 SERVER_START_REQ( get_window_tree )
2641 req->handle = wine_server_user_handle( hwnd );
2642 if (!wine_server_call_err( req )) ret = wine_server_ptr_handle( reply->parent );
2644 SERVER_END_REQ;
2646 break;
2648 case GA_ROOT:
2649 if (!(list = list_window_parents( hwnd ))) return 0;
2651 if (!list[0] || !list[1]) ret = WIN_GetFullHandle( hwnd ); /* top-level window */
2652 else
2654 int count = 2;
2655 while (list[count]) count++;
2656 ret = list[count - 2]; /* get the one before the desktop */
2658 HeapFree( GetProcessHeap(), 0, list );
2659 break;
2661 case GA_ROOTOWNER:
2662 if (is_desktop_window( hwnd )) return 0;
2663 ret = WIN_GetFullHandle( hwnd );
2664 for (;;)
2666 HWND parent = GetParent( ret );
2667 if (!parent) break;
2668 ret = parent;
2670 break;
2672 return ret;
2676 /*****************************************************************
2677 * SetParent (USER32.@)
2679 HWND WINAPI SetParent( HWND hwnd, HWND parent )
2681 HWND full_handle;
2682 HWND old_parent = 0;
2683 BOOL was_visible;
2684 WND *wndPtr;
2685 BOOL ret;
2687 if (is_broadcast(hwnd) || is_broadcast(parent))
2689 SetLastError(ERROR_INVALID_PARAMETER);
2690 return 0;
2693 if (!parent) parent = GetDesktopWindow();
2694 else if (parent == HWND_MESSAGE) parent = get_hwnd_message_parent();
2695 else parent = WIN_GetFullHandle( parent );
2697 if (!IsWindow( parent ))
2699 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2700 return 0;
2703 /* Some applications try to set a child as a parent */
2704 if (IsChild(hwnd, parent))
2706 SetLastError( ERROR_INVALID_PARAMETER );
2707 return 0;
2710 if (!(full_handle = WIN_IsCurrentThread( hwnd )))
2711 return (HWND)SendMessageW( hwnd, WM_WINE_SETPARENT, (WPARAM)parent, 0 );
2713 /* Windows hides the window first, then shows it again
2714 * including the WM_SHOWWINDOW messages and all */
2715 was_visible = ShowWindow( hwnd, SW_HIDE );
2717 wndPtr = WIN_GetPtr( hwnd );
2718 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return 0;
2720 SERVER_START_REQ( set_parent )
2722 req->handle = wine_server_user_handle( hwnd );
2723 req->parent = wine_server_user_handle( parent );
2724 if ((ret = !wine_server_call( req )))
2726 old_parent = wine_server_ptr_handle( reply->old_parent );
2727 wndPtr->parent = parent = wine_server_ptr_handle( reply->full_parent );
2731 SERVER_END_REQ;
2732 WIN_ReleasePtr( wndPtr );
2733 if (!ret) return 0;
2735 USER_Driver->pSetParent( full_handle, parent, old_parent );
2737 /* SetParent additionally needs to make hwnd the topmost window
2738 in the x-order and send the expected WM_WINDOWPOSCHANGING and
2739 WM_WINDOWPOSCHANGED notification messages.
2741 SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0,
2742 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | (was_visible ? SWP_SHOWWINDOW : 0) );
2743 /* FIXME: a WM_MOVE is also generated (in the DefWindowProc handler
2744 * for WM_WINDOWPOSCHANGED) in Windows, should probably remove SWP_NOMOVE */
2746 return old_parent;
2750 /*******************************************************************
2751 * IsChild (USER32.@)
2753 BOOL WINAPI IsChild( HWND parent, HWND child )
2755 HWND *list = list_window_parents( child );
2756 int i;
2757 BOOL ret;
2759 if (!list) return FALSE;
2760 parent = WIN_GetFullHandle( parent );
2761 for (i = 0; list[i]; i++) if (list[i] == parent) break;
2762 ret = list[i] && list[i+1];
2763 HeapFree( GetProcessHeap(), 0, list );
2764 return ret;
2768 /***********************************************************************
2769 * IsWindowVisible (USER32.@)
2771 BOOL WINAPI IsWindowVisible( HWND hwnd )
2773 HWND *list;
2774 BOOL retval = TRUE;
2775 int i;
2777 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)) return FALSE;
2778 if (!(list = list_window_parents( hwnd ))) return TRUE;
2779 if (list[0])
2781 for (i = 0; list[i+1]; i++)
2782 if (!(GetWindowLongW( list[i], GWL_STYLE ) & WS_VISIBLE)) break;
2783 retval = !list[i+1] && (list[i] == GetDesktopWindow()); /* top message window isn't visible */
2785 HeapFree( GetProcessHeap(), 0, list );
2786 return retval;
2790 /***********************************************************************
2791 * WIN_IsWindowDrawable
2793 * hwnd is drawable when it is visible, all parents are not
2794 * minimized, and it is itself not minimized unless we are
2795 * trying to draw its default class icon.
2797 BOOL WIN_IsWindowDrawable( HWND hwnd, BOOL icon )
2799 HWND *list;
2800 BOOL retval = TRUE;
2801 int i;
2802 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
2804 if (!(style & WS_VISIBLE)) return FALSE;
2805 if ((style & WS_MINIMIZE) && icon && GetClassLongPtrW( hwnd, GCLP_HICON )) return FALSE;
2807 if (!(list = list_window_parents( hwnd ))) return TRUE;
2808 if (list[0])
2810 for (i = 0; list[i+1]; i++)
2811 if ((GetWindowLongW( list[i], GWL_STYLE ) & (WS_VISIBLE|WS_MINIMIZE)) != WS_VISIBLE)
2812 break;
2813 retval = !list[i+1] && (list[i] == GetDesktopWindow()); /* top message window isn't visible */
2815 HeapFree( GetProcessHeap(), 0, list );
2816 return retval;
2820 /*******************************************************************
2821 * GetTopWindow (USER32.@)
2823 HWND WINAPI GetTopWindow( HWND hwnd )
2825 if (!hwnd) hwnd = GetDesktopWindow();
2826 return GetWindow( hwnd, GW_CHILD );
2830 /*******************************************************************
2831 * GetWindow (USER32.@)
2833 HWND WINAPI GetWindow( HWND hwnd, UINT rel )
2835 HWND retval = 0;
2837 if (rel == GW_OWNER) /* this one may be available locally */
2839 WND *wndPtr = WIN_GetPtr( hwnd );
2840 if (!wndPtr)
2842 SetLastError( ERROR_INVALID_HANDLE );
2843 return 0;
2845 if (wndPtr == WND_DESKTOP) return 0;
2846 if (wndPtr != WND_OTHER_PROCESS)
2848 retval = wndPtr->owner;
2849 WIN_ReleasePtr( wndPtr );
2850 return retval;
2852 /* else fall through to server call */
2855 SERVER_START_REQ( get_window_tree )
2857 req->handle = wine_server_user_handle( hwnd );
2858 if (!wine_server_call_err( req ))
2860 switch(rel)
2862 case GW_HWNDFIRST:
2863 retval = wine_server_ptr_handle( reply->first_sibling );
2864 break;
2865 case GW_HWNDLAST:
2866 retval = wine_server_ptr_handle( reply->last_sibling );
2867 break;
2868 case GW_HWNDNEXT:
2869 retval = wine_server_ptr_handle( reply->next_sibling );
2870 break;
2871 case GW_HWNDPREV:
2872 retval = wine_server_ptr_handle( reply->prev_sibling );
2873 break;
2874 case GW_OWNER:
2875 retval = wine_server_ptr_handle( reply->owner );
2876 break;
2877 case GW_CHILD:
2878 retval = wine_server_ptr_handle( reply->first_child );
2879 break;
2883 SERVER_END_REQ;
2884 return retval;
2888 /*******************************************************************
2889 * ShowOwnedPopups (USER32.@)
2891 BOOL WINAPI ShowOwnedPopups( HWND owner, BOOL fShow )
2893 int count = 0;
2894 WND *pWnd;
2895 HWND *win_array = WIN_ListChildren( GetDesktopWindow() );
2897 if (!win_array) return TRUE;
2899 while (win_array[count]) count++;
2900 while (--count >= 0)
2902 if (GetWindow( win_array[count], GW_OWNER ) != owner) continue;
2903 if (!(pWnd = WIN_GetPtr( win_array[count] ))) continue;
2904 if (pWnd == WND_OTHER_PROCESS) continue;
2905 if (fShow)
2907 if (pWnd->flags & WIN_NEEDS_SHOW_OWNEDPOPUP)
2909 WIN_ReleasePtr( pWnd );
2910 /* In Windows, ShowOwnedPopups(TRUE) generates
2911 * WM_SHOWWINDOW messages with SW_PARENTOPENING,
2912 * regardless of the state of the owner
2914 SendMessageW(win_array[count], WM_SHOWWINDOW, SW_SHOWNORMAL, SW_PARENTOPENING);
2915 continue;
2918 else
2920 if (pWnd->dwStyle & WS_VISIBLE)
2922 WIN_ReleasePtr( pWnd );
2923 /* In Windows, ShowOwnedPopups(FALSE) generates
2924 * WM_SHOWWINDOW messages with SW_PARENTCLOSING,
2925 * regardless of the state of the owner
2927 SendMessageW(win_array[count], WM_SHOWWINDOW, SW_HIDE, SW_PARENTCLOSING);
2928 continue;
2931 WIN_ReleasePtr( pWnd );
2933 HeapFree( GetProcessHeap(), 0, win_array );
2934 return TRUE;
2938 /*******************************************************************
2939 * GetLastActivePopup (USER32.@)
2941 HWND WINAPI GetLastActivePopup( HWND hwnd )
2943 HWND retval = hwnd;
2945 SERVER_START_REQ( get_window_info )
2947 req->handle = wine_server_user_handle( hwnd );
2948 if (!wine_server_call_err( req )) retval = wine_server_ptr_handle( reply->last_active );
2950 SERVER_END_REQ;
2951 return retval;
2955 /*******************************************************************
2956 * WIN_ListChildren
2958 * Build an array of the children of a given window. The array must be
2959 * freed with HeapFree. Returns NULL when no windows are found.
2961 HWND *WIN_ListChildren( HWND hwnd )
2963 if (!hwnd)
2965 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2966 return NULL;
2968 return list_window_children( 0, hwnd, NULL, 0 );
2972 /*******************************************************************
2973 * EnumWindows (USER32.@)
2975 BOOL WINAPI EnumWindows( WNDENUMPROC lpEnumFunc, LPARAM lParam )
2977 HWND *list;
2978 BOOL ret = TRUE;
2979 int i;
2981 USER_CheckNotLock();
2983 /* We have to build a list of all windows first, to avoid */
2984 /* unpleasant side-effects, for instance if the callback */
2985 /* function changes the Z-order of the windows. */
2987 if (!(list = WIN_ListChildren( GetDesktopWindow() ))) return TRUE;
2989 /* Now call the callback function for every window */
2991 for (i = 0; list[i]; i++)
2993 /* Make sure that the window still exists */
2994 if (!IsWindow( list[i] )) continue;
2995 if (!(ret = lpEnumFunc( list[i], lParam ))) break;
2997 HeapFree( GetProcessHeap(), 0, list );
2998 return ret;
3002 /**********************************************************************
3003 * EnumThreadWindows (USER32.@)
3005 BOOL WINAPI EnumThreadWindows( DWORD id, WNDENUMPROC func, LPARAM lParam )
3007 HWND *list;
3008 int i;
3010 USER_CheckNotLock();
3012 if (!(list = list_window_children( 0, GetDesktopWindow(), NULL, id ))) return TRUE;
3014 /* Now call the callback function for every window */
3016 for (i = 0; list[i]; i++)
3017 if (!func( list[i], lParam )) break;
3018 HeapFree( GetProcessHeap(), 0, list );
3019 return TRUE;
3023 /***********************************************************************
3024 * EnumDesktopWindows (USER32.@)
3026 BOOL WINAPI EnumDesktopWindows( HDESK desktop, WNDENUMPROC func, LPARAM lparam )
3028 HWND *list;
3029 int i;
3031 USER_CheckNotLock();
3033 if (!(list = list_window_children( desktop, 0, NULL, 0 ))) return TRUE;
3035 for (i = 0; list[i]; i++)
3036 if (!func( list[i], lparam )) break;
3037 HeapFree( GetProcessHeap(), 0, list );
3038 return TRUE;
3042 /**********************************************************************
3043 * WIN_EnumChildWindows
3045 * Helper function for EnumChildWindows().
3047 static BOOL WIN_EnumChildWindows( HWND *list, WNDENUMPROC func, LPARAM lParam )
3049 HWND *childList;
3050 BOOL ret = FALSE;
3052 for ( ; *list; list++)
3054 /* Make sure that the window still exists */
3055 if (!IsWindow( *list )) continue;
3056 /* Build children list first */
3057 childList = WIN_ListChildren( *list );
3059 ret = func( *list, lParam );
3061 if (childList)
3063 if (ret) ret = WIN_EnumChildWindows( childList, func, lParam );
3064 HeapFree( GetProcessHeap(), 0, childList );
3066 if (!ret) return FALSE;
3068 return TRUE;
3072 /**********************************************************************
3073 * EnumChildWindows (USER32.@)
3075 BOOL WINAPI EnumChildWindows( HWND parent, WNDENUMPROC func, LPARAM lParam )
3077 HWND *list;
3078 BOOL ret;
3080 USER_CheckNotLock();
3082 if (!(list = WIN_ListChildren( parent ))) return FALSE;
3083 ret = WIN_EnumChildWindows( list, func, lParam );
3084 HeapFree( GetProcessHeap(), 0, list );
3085 return ret;
3089 /*******************************************************************
3090 * AnyPopup (USER.52)
3092 BOOL16 WINAPI AnyPopup16(void)
3094 return AnyPopup();
3098 /*******************************************************************
3099 * AnyPopup (USER32.@)
3101 BOOL WINAPI AnyPopup(void)
3103 int i;
3104 BOOL retvalue;
3105 HWND *list = WIN_ListChildren( GetDesktopWindow() );
3107 if (!list) return FALSE;
3108 for (i = 0; list[i]; i++)
3110 if (IsWindowVisible( list[i] ) && GetWindow( list[i], GW_OWNER )) break;
3112 retvalue = (list[i] != 0);
3113 HeapFree( GetProcessHeap(), 0, list );
3114 return retvalue;
3118 /*******************************************************************
3119 * FlashWindow (USER32.@)
3121 BOOL WINAPI FlashWindow( HWND hWnd, BOOL bInvert )
3123 WND *wndPtr;
3125 TRACE("%p\n", hWnd);
3127 if (IsIconic( hWnd ))
3129 RedrawWindow( hWnd, 0, 0, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_FRAME );
3131 wndPtr = WIN_GetPtr(hWnd);
3132 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return FALSE;
3133 if (bInvert && !(wndPtr->flags & WIN_NCACTIVATED))
3135 wndPtr->flags |= WIN_NCACTIVATED;
3137 else
3139 wndPtr->flags &= ~WIN_NCACTIVATED;
3141 WIN_ReleasePtr( wndPtr );
3142 return TRUE;
3144 else
3146 WPARAM wparam;
3148 wndPtr = WIN_GetPtr(hWnd);
3149 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return FALSE;
3150 hWnd = wndPtr->hwndSelf; /* make it a full handle */
3152 if (bInvert) wparam = !(wndPtr->flags & WIN_NCACTIVATED);
3153 else wparam = (hWnd == GetForegroundWindow());
3155 WIN_ReleasePtr( wndPtr );
3156 SendMessageW( hWnd, WM_NCACTIVATE, wparam, 0 );
3157 return wparam;
3161 /*******************************************************************
3162 * FlashWindowEx (USER32.@)
3164 BOOL WINAPI FlashWindowEx( PFLASHWINFO pfwi )
3166 FIXME("%p\n", pfwi);
3167 return TRUE;
3170 /*******************************************************************
3171 * GetWindowContextHelpId (USER32.@)
3173 DWORD WINAPI GetWindowContextHelpId( HWND hwnd )
3175 DWORD retval;
3176 WND *wnd = WIN_GetPtr( hwnd );
3177 if (!wnd || wnd == WND_DESKTOP) return 0;
3178 if (wnd == WND_OTHER_PROCESS)
3180 if (IsWindow( hwnd )) FIXME( "not supported on other process window %p\n", hwnd );
3181 return 0;
3183 retval = wnd->helpContext;
3184 WIN_ReleasePtr( wnd );
3185 return retval;
3189 /*******************************************************************
3190 * SetWindowContextHelpId (USER32.@)
3192 BOOL WINAPI SetWindowContextHelpId( HWND hwnd, DWORD id )
3194 WND *wnd = WIN_GetPtr( hwnd );
3195 if (!wnd || wnd == WND_DESKTOP) return FALSE;
3196 if (wnd == WND_OTHER_PROCESS)
3198 if (IsWindow( hwnd )) FIXME( "not supported on other process window %p\n", hwnd );
3199 return 0;
3201 wnd->helpContext = id;
3202 WIN_ReleasePtr( wnd );
3203 return TRUE;
3207 /*******************************************************************
3208 * DragDetect (USER32.@)
3210 BOOL WINAPI DragDetect( HWND hWnd, POINT pt )
3212 MSG msg;
3213 RECT rect;
3214 WORD wDragWidth = GetSystemMetrics(SM_CXDRAG);
3215 WORD wDragHeight= GetSystemMetrics(SM_CYDRAG);
3217 rect.left = pt.x - wDragWidth;
3218 rect.right = pt.x + wDragWidth;
3220 rect.top = pt.y - wDragHeight;
3221 rect.bottom = pt.y + wDragHeight;
3223 SetCapture(hWnd);
3225 while(1)
3227 while (PeekMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE ))
3229 if( msg.message == WM_LBUTTONUP )
3231 ReleaseCapture();
3232 return 0;
3234 if( msg.message == WM_MOUSEMOVE )
3236 POINT tmp;
3237 tmp.x = (short)LOWORD(msg.lParam);
3238 tmp.y = (short)HIWORD(msg.lParam);
3239 if( !PtInRect( &rect, tmp ))
3241 ReleaseCapture();
3242 return 1;
3246 WaitMessage();
3248 return 0;
3251 /******************************************************************************
3252 * GetWindowModuleFileNameA (USER32.@)
3254 UINT WINAPI GetWindowModuleFileNameA( HWND hwnd, LPSTR module, UINT size )
3256 WND *win;
3257 HINSTANCE hinst;
3259 TRACE( "%p, %p, %u\n", hwnd, module, size );
3261 win = WIN_GetPtr( hwnd );
3262 if (!win || win == WND_OTHER_PROCESS || win == WND_DESKTOP)
3264 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
3265 return 0;
3267 hinst = win->hInstance;
3268 WIN_ReleasePtr( win );
3270 return GetModuleFileNameA( hinst, module, size );
3273 /******************************************************************************
3274 * GetWindowModuleFileNameW (USER32.@)
3276 UINT WINAPI GetWindowModuleFileNameW( HWND hwnd, LPWSTR module, UINT size )
3278 WND *win;
3279 HINSTANCE hinst;
3281 TRACE( "%p, %p, %u\n", hwnd, module, size );
3283 win = WIN_GetPtr( hwnd );
3284 if (!win || win == WND_OTHER_PROCESS || win == WND_DESKTOP)
3286 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
3287 return 0;
3289 hinst = win->hInstance;
3290 WIN_ReleasePtr( win );
3292 return GetModuleFileNameW( hinst, module, size );
3295 /******************************************************************************
3296 * GetWindowInfo (USER32.@)
3298 * Note: tests show that Windows doesn't check cbSize of the structure.
3300 BOOL WINAPI GetWindowInfo( HWND hwnd, PWINDOWINFO pwi)
3302 if (!pwi) return FALSE;
3303 if (!IsWindow(hwnd)) return FALSE;
3305 GetWindowRect(hwnd, &pwi->rcWindow);
3306 GetClientRect(hwnd, &pwi->rcClient);
3307 /* translate to screen coordinates */
3308 MapWindowPoints(hwnd, 0, (LPPOINT)&pwi->rcClient, 2);
3310 pwi->dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
3311 pwi->dwExStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
3312 pwi->dwWindowStatus = ((GetActiveWindow() == hwnd) ? WS_ACTIVECAPTION : 0);
3314 pwi->cxWindowBorders = pwi->rcClient.left - pwi->rcWindow.left;
3315 pwi->cyWindowBorders = pwi->rcWindow.bottom - pwi->rcClient.bottom;
3317 pwi->atomWindowType = GetClassLongW( hwnd, GCW_ATOM );
3318 pwi->wCreatorVersion = 0x0400;
3320 return TRUE;
3323 /******************************************************************************
3324 * SwitchDesktop (USER32.@)
3326 * NOTES: Sets the current input or interactive desktop.
3328 BOOL WINAPI SwitchDesktop( HDESK hDesktop)
3330 FIXME("SwitchDesktop(hwnd %p) stub!\n", hDesktop);
3331 return TRUE;
3334 /*****************************************************************************
3335 * SetLayeredWindowAttributes (USER32.@)
3337 BOOL WINAPI SetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags )
3339 BOOL ret;
3341 TRACE("(%p,%08x,%d,%x): stub!\n", hwnd, key, alpha, flags);
3343 SERVER_START_REQ( set_window_layered_info )
3345 req->handle = wine_server_user_handle( hwnd );
3346 req->color_key = key;
3347 req->alpha = alpha;
3348 req->flags = flags;
3349 ret = !wine_server_call_err( req );
3351 SERVER_END_REQ;
3353 if (ret) USER_Driver->pSetLayeredWindowAttributes( hwnd, key, alpha, flags );
3355 return ret;
3359 /*****************************************************************************
3360 * GetLayeredWindowAttributes (USER32.@)
3362 BOOL WINAPI GetLayeredWindowAttributes( HWND hwnd, COLORREF *key, BYTE *alpha, DWORD *flags )
3364 BOOL ret;
3366 SERVER_START_REQ( get_window_layered_info )
3368 req->handle = wine_server_user_handle( hwnd );
3369 if ((ret = !wine_server_call_err( req )))
3371 if (key) *key = reply->color_key;
3372 if (alpha) *alpha = reply->alpha;
3373 if (flags) *flags = reply->flags;
3376 SERVER_END_REQ;
3378 return ret;
3382 /*****************************************************************************
3383 * UpdateLayeredWindowIndirect (USER32.@)
3385 BOOL WINAPI UpdateLayeredWindowIndirect( HWND hwnd, const UPDATELAYEREDWINDOWINFO *info )
3387 BYTE alpha = 0xff;
3389 if (!(info->dwFlags & ULW_EX_NORESIZE) && (info->pptDst || info->psize))
3391 int x = 0, y = 0, cx = 0, cy = 0;
3392 DWORD flags = SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOSENDCHANGING;
3394 if (info->pptDst)
3396 x = info->pptDst->x;
3397 y = info->pptDst->y;
3398 flags &= ~SWP_NOMOVE;
3400 if (info->psize)
3402 cx = info->psize->cx;
3403 cy = info->psize->cy;
3404 flags &= ~SWP_NOSIZE;
3406 TRACE( "moving window %p pos %d,%d %dx%x\n", hwnd, x, y, cx, cy );
3407 SetWindowPos( hwnd, 0, x, y, cx, cy, flags );
3410 if (info->hdcSrc)
3412 RECT rect;
3413 HDC hdc = GetDCEx( hwnd, 0, DCX_CACHE );
3415 if (hdc)
3417 int x = 0, y = 0;
3419 GetClientRect( hwnd, &rect );
3420 if (info->pptSrc)
3422 x = info->pptSrc->x;
3423 y = info->pptSrc->y;
3425 /* FIXME: intersect rect with info->prcDirty */
3426 TRACE( "copying window %p pos %d,%d\n", hwnd, x, y );
3427 BitBlt( hdc, rect.left, rect.top, rect.right, rect.bottom,
3428 info->hdcSrc, rect.left + x, rect.top + y, SRCCOPY );
3429 ReleaseDC( hwnd, hdc );
3433 if (info->pblend && !(info->dwFlags & ULW_OPAQUE)) alpha = info->pblend->SourceConstantAlpha;
3434 TRACE( "setting window %p alpha %u\n", hwnd, alpha );
3435 USER_Driver->pSetLayeredWindowAttributes( hwnd, info->crKey, alpha,
3436 info->dwFlags & (LWA_ALPHA | LWA_COLORKEY) );
3437 return TRUE;
3441 /*****************************************************************************
3442 * UpdateLayeredWindow (USER32.@)
3444 BOOL WINAPI UpdateLayeredWindow( HWND hwnd, HDC hdcDst, POINT *pptDst, SIZE *psize,
3445 HDC hdcSrc, POINT *pptSrc, COLORREF crKey, BLENDFUNCTION *pblend,
3446 DWORD dwFlags)
3448 UPDATELAYEREDWINDOWINFO info;
3450 info.cbSize = sizeof(info);
3451 info.hdcDst = hdcDst;
3452 info.pptDst = pptDst;
3453 info.psize = psize;
3454 info.hdcSrc = hdcSrc;
3455 info.pptSrc = pptSrc;
3456 info.crKey = crKey;
3457 info.pblend = pblend;
3458 info.dwFlags = dwFlags;
3459 info.prcDirty = NULL;
3460 return UpdateLayeredWindowIndirect( hwnd, &info );
3463 /* 64bit versions */
3465 #ifdef GetWindowLongPtrW
3466 #undef GetWindowLongPtrW
3467 #endif
3469 #ifdef GetWindowLongPtrA
3470 #undef GetWindowLongPtrA
3471 #endif
3473 #ifdef SetWindowLongPtrW
3474 #undef SetWindowLongPtrW
3475 #endif
3477 #ifdef SetWindowLongPtrA
3478 #undef SetWindowLongPtrA
3479 #endif
3481 /*****************************************************************************
3482 * GetWindowLongPtrW (USER32.@)
3484 LONG_PTR WINAPI GetWindowLongPtrW( HWND hwnd, INT offset )
3486 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG_PTR), TRUE );
3489 /*****************************************************************************
3490 * GetWindowLongPtrA (USER32.@)
3492 LONG_PTR WINAPI GetWindowLongPtrA( HWND hwnd, INT offset )
3494 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG_PTR), FALSE );
3497 /*****************************************************************************
3498 * SetWindowLongPtrW (USER32.@)
3500 LONG_PTR WINAPI SetWindowLongPtrW( HWND hwnd, INT offset, LONG_PTR newval )
3502 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG_PTR), newval, TRUE );
3505 /*****************************************************************************
3506 * SetWindowLongPtrA (USER32.@)
3508 LONG_PTR WINAPI SetWindowLongPtrA( HWND hwnd, INT offset, LONG_PTR newval )
3510 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG_PTR), newval, FALSE );