push 8edcbf8579c1d48dd3fb4c679acf4b3012a9efac
[wine/hacks.git] / dlls / user32 / win.c
blob3a7f5db7a0ff8627bde423d5dd375506d92e9860
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 full_parent = 0, full_owner = 0;
104 struct tagCLASS *class = NULL;
105 user_handle_t handle = 0;
106 int extra_bytes = 0;
108 /* if 16-bit instance, map to module handle */
109 if (instance && !HIWORD(instance))
110 instance = HINSTANCE_32(GetExePtr(HINSTANCE_16(instance)));
112 SERVER_START_REQ( create_window )
114 req->parent = parent;
115 req->owner = owner;
116 req->instance = instance;
117 if (!(req->atom = get_int_atom_value( name )) && name)
118 wine_server_add_data( req, name, strlenW(name)*sizeof(WCHAR) );
119 if (!wine_server_call_err( req ))
121 handle = reply->handle;
122 full_parent = reply->parent;
123 full_owner = reply->owner;
124 extra_bytes = reply->extra;
125 class = reply->class_ptr;
128 SERVER_END_REQ;
130 if (!handle)
132 WARN( "error %d creating window\n", GetLastError() );
133 return NULL;
136 if (!(win = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
137 sizeof(WND) + extra_bytes - sizeof(win->wExtra) )))
139 SERVER_START_REQ( destroy_window )
141 req->handle = handle;
142 wine_server_call( req );
144 SERVER_END_REQ;
145 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
146 return NULL;
149 if (!parent) /* if parent is 0 we don't have a desktop window yet */
151 struct user_thread_info *thread_info = get_user_thread_info();
153 if (name == (LPCWSTR)DESKTOP_CLASS_ATOM)
155 if (!thread_info->top_window) thread_info->top_window = full_parent ? full_parent : handle;
156 else assert( full_parent == thread_info->top_window );
157 if (full_parent && !USER_Driver->pCreateDesktopWindow( thread_info->top_window ))
158 ERR( "failed to create desktop window\n" );
160 else /* HWND_MESSAGE parent */
162 if (!thread_info->msg_window && !full_parent) thread_info->msg_window = handle;
166 USER_Lock();
168 index = USER_HANDLE_TO_INDEX(handle);
169 assert( index < NB_USER_HANDLES );
170 user_handles[index] = win;
171 win->hwndSelf = handle;
172 win->parent = full_parent;
173 win->owner = full_owner;
174 win->class = class;
175 win->winproc = get_class_winproc( class );
176 win->dwMagic = WND_MAGIC;
177 win->cbWndExtra = extra_bytes;
178 if (WINPROC_IsUnicode( win->winproc, unicode )) win->flags |= WIN_ISUNICODE;
179 return win;
183 /***********************************************************************
184 * free_window_handle
186 * Free a window handle.
188 static WND *free_window_handle( HWND hwnd )
190 WND *ptr;
191 WORD index = USER_HANDLE_TO_INDEX(hwnd);
193 if (index >= NB_USER_HANDLES) return NULL;
194 USER_Lock();
195 if ((ptr = user_handles[index]))
197 SERVER_START_REQ( destroy_window )
199 req->handle = hwnd;
200 if (!wine_server_call_err( req ))
202 user_handles[index] = NULL;
203 ptr->dwMagic = 0;
205 else
206 ptr = NULL;
208 SERVER_END_REQ;
210 USER_Unlock();
211 HeapFree( GetProcessHeap(), 0, ptr );
212 return ptr;
216 /*******************************************************************
217 * list_window_children
219 * Build an array of the children of a given window. The array must be
220 * freed with HeapFree. Returns NULL when no windows are found.
222 static HWND *list_window_children( HDESK desktop, HWND hwnd, LPCWSTR class, DWORD tid )
224 HWND *list;
225 int size = 128;
227 for (;;)
229 int count = 0;
231 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) break;
233 SERVER_START_REQ( get_window_children )
235 req->desktop = desktop;
236 req->parent = hwnd;
237 req->tid = tid;
238 if (!(req->atom = get_int_atom_value( class )) && class)
239 wine_server_add_data( req, class, strlenW(class)*sizeof(WCHAR) );
240 wine_server_set_reply( req, list, (size-1) * sizeof(HWND) );
241 if (!wine_server_call( req )) count = reply->count;
243 SERVER_END_REQ;
244 if (count && count < size)
246 list[count] = 0;
247 return list;
249 HeapFree( GetProcessHeap(), 0, list );
250 if (!count) break;
251 size = count + 1; /* restart with a large enough buffer */
253 return NULL;
257 /*******************************************************************
258 * list_window_parents
260 * Build an array of all parents of a given window, starting with
261 * the immediate parent. The array must be freed with HeapFree.
263 static HWND *list_window_parents( HWND hwnd )
265 WND *win;
266 HWND current, *list;
267 int pos = 0, size = 16, count = 0;
269 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL;
271 current = hwnd;
272 for (;;)
274 if (!(win = WIN_GetPtr( current ))) goto empty;
275 if (win == WND_OTHER_PROCESS) break; /* need to do it the hard way */
276 if (win == WND_DESKTOP)
278 if (!pos) goto empty;
279 list[pos] = 0;
280 return list;
282 list[pos] = current = win->parent;
283 WIN_ReleasePtr( win );
284 if (!current) return list;
285 if (++pos == size - 1)
287 /* need to grow the list */
288 HWND *new_list = HeapReAlloc( GetProcessHeap(), 0, list, (size+16) * sizeof(HWND) );
289 if (!new_list) goto empty;
290 list = new_list;
291 size += 16;
295 /* at least one parent belongs to another process, have to query the server */
297 for (;;)
299 count = 0;
300 SERVER_START_REQ( get_window_parents )
302 req->handle = hwnd;
303 wine_server_set_reply( req, list, (size-1) * sizeof(HWND) );
304 if (!wine_server_call( req )) count = reply->count;
306 SERVER_END_REQ;
307 if (!count) goto empty;
308 if (size > count)
310 list[count] = 0;
311 return list;
313 HeapFree( GetProcessHeap(), 0, list );
314 size = count + 1;
315 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL;
318 empty:
319 HeapFree( GetProcessHeap(), 0, list );
320 return NULL;
324 /*******************************************************************
325 * send_parent_notify
327 static void send_parent_notify( HWND hwnd, UINT msg )
329 if ((GetWindowLongW( hwnd, GWL_STYLE ) & (WS_CHILD | WS_POPUP)) == WS_CHILD &&
330 !(GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY))
332 HWND parent = GetParent(hwnd);
333 if (parent && parent != GetDesktopWindow())
334 SendMessageW( parent, WM_PARENTNOTIFY,
335 MAKEWPARAM( msg, GetWindowLongPtrW( hwnd, GWLP_ID )), (LPARAM)hwnd );
340 /*******************************************************************
341 * get_server_window_text
343 * Retrieve the window text from the server.
345 static void get_server_window_text( HWND hwnd, LPWSTR text, INT count )
347 size_t len = 0;
349 SERVER_START_REQ( get_window_text )
351 req->handle = hwnd;
352 wine_server_set_reply( req, text, (count - 1) * sizeof(WCHAR) );
353 if (!wine_server_call_err( req )) len = wine_server_reply_size(reply);
355 SERVER_END_REQ;
356 text[len / sizeof(WCHAR)] = 0;
360 /*******************************************************************
361 * get_hwnd_message_parent
363 * Return the parent for HWND_MESSAGE windows.
365 HWND get_hwnd_message_parent(void)
367 struct user_thread_info *thread_info = get_user_thread_info();
369 if (!thread_info->msg_window) GetDesktopWindow(); /* trigger creation */
370 return thread_info->msg_window;
374 /*******************************************************************
375 * is_desktop_window
377 * Check if window is the desktop or the HWND_MESSAGE top parent.
379 BOOL is_desktop_window( HWND hwnd )
381 struct user_thread_info *thread_info = get_user_thread_info();
383 if (!hwnd) return FALSE;
384 if (hwnd == thread_info->top_window) return TRUE;
385 if (hwnd == thread_info->msg_window) return TRUE;
387 if (!HIWORD(hwnd) || HIWORD(hwnd) == 0xffff)
389 if (LOWORD(thread_info->top_window) == LOWORD(hwnd)) return TRUE;
390 if (LOWORD(thread_info->msg_window) == LOWORD(hwnd)) return TRUE;
392 return FALSE;
396 /***********************************************************************
397 * WIN_GetPtr
399 * Return a pointer to the WND structure if local to the process,
400 * or WND_OTHER_PROCESS if handle may be valid in other process.
401 * If ret value is a valid pointer, it must be released with WIN_ReleasePtr.
403 WND *WIN_GetPtr( HWND hwnd )
405 WND * ptr;
406 WORD index = USER_HANDLE_TO_INDEX(hwnd);
408 if (index >= NB_USER_HANDLES) return NULL;
410 USER_Lock();
411 if ((ptr = user_handles[index]))
413 if (ptr->dwMagic == WND_MAGIC &&
414 (hwnd == ptr->hwndSelf || !HIWORD(hwnd) || HIWORD(hwnd) == 0xffff))
415 return ptr;
416 ptr = NULL;
418 else if (is_desktop_window( hwnd )) ptr = WND_DESKTOP;
419 else ptr = WND_OTHER_PROCESS;
420 USER_Unlock();
421 return ptr;
425 /***********************************************************************
426 * WIN_IsCurrentProcess
428 * Check whether a given window belongs to the current process (and return the full handle).
430 HWND WIN_IsCurrentProcess( HWND hwnd )
432 WND *ptr;
433 HWND ret;
435 if (!(ptr = WIN_GetPtr( hwnd )) || ptr == WND_OTHER_PROCESS || ptr == WND_DESKTOP) return 0;
436 ret = ptr->hwndSelf;
437 WIN_ReleasePtr( ptr );
438 return ret;
442 /***********************************************************************
443 * WIN_IsCurrentThread
445 * Check whether a given window belongs to the current thread (and return the full handle).
447 HWND WIN_IsCurrentThread( HWND hwnd )
449 WND *ptr;
450 HWND ret = 0;
452 if (!(ptr = WIN_GetPtr( hwnd )) || ptr == WND_OTHER_PROCESS || ptr == WND_DESKTOP) return 0;
453 if (ptr->tid == GetCurrentThreadId()) ret = ptr->hwndSelf;
454 WIN_ReleasePtr( ptr );
455 return ret;
459 /***********************************************************************
460 * WIN_Handle32
462 * Convert a 16-bit window handle to a full 32-bit handle.
464 HWND WIN_Handle32( HWND16 hwnd16 )
466 WND *ptr;
467 HWND hwnd = (HWND)(ULONG_PTR)hwnd16;
469 if (hwnd16 <= 1 || hwnd16 == 0xffff) return hwnd;
470 /* do sign extension for -2 and -3 */
471 if (hwnd16 >= (HWND16)-3) return (HWND)(LONG_PTR)(INT16)hwnd16;
473 if (!(ptr = WIN_GetPtr( hwnd ))) return hwnd;
475 if (ptr == WND_DESKTOP)
477 if (LOWORD(hwnd) == LOWORD(GetDesktopWindow())) return GetDesktopWindow();
478 else return get_hwnd_message_parent();
481 if (ptr != WND_OTHER_PROCESS)
483 hwnd = ptr->hwndSelf;
484 WIN_ReleasePtr( ptr );
486 else /* may belong to another process */
488 SERVER_START_REQ( get_window_info )
490 req->handle = hwnd;
491 if (!wine_server_call_err( req )) hwnd = reply->full_handle;
493 SERVER_END_REQ;
495 return hwnd;
499 /***********************************************************************
500 * WIN_SetOwner
502 * Change the owner of a window.
504 HWND WIN_SetOwner( HWND hwnd, HWND owner )
506 WND *win = WIN_GetPtr( hwnd );
507 HWND ret = 0;
509 if (!win || win == WND_DESKTOP) return 0;
510 if (win == WND_OTHER_PROCESS)
512 if (IsWindow(hwnd)) ERR( "cannot set owner %p on other process window %p\n", owner, hwnd );
513 return 0;
515 SERVER_START_REQ( set_window_owner )
517 req->handle = hwnd;
518 req->owner = owner;
519 if (!wine_server_call( req ))
521 win->owner = reply->full_owner;
522 ret = reply->prev_owner;
525 SERVER_END_REQ;
526 WIN_ReleasePtr( win );
527 return ret;
531 /***********************************************************************
532 * WIN_SetStyle
534 * Change the style of a window.
536 ULONG WIN_SetStyle( HWND hwnd, ULONG set_bits, ULONG clear_bits )
538 BOOL ok;
539 STYLESTRUCT style;
540 WND *win = WIN_GetPtr( hwnd );
542 if (!win || win == WND_DESKTOP) return 0;
543 if (win == WND_OTHER_PROCESS)
545 if (IsWindow(hwnd))
546 ERR( "cannot set style %x/%x on other process window %p\n",
547 set_bits, clear_bits, hwnd );
548 return 0;
550 style.styleOld = win->dwStyle;
551 style.styleNew = (win->dwStyle | set_bits) & ~clear_bits;
552 if (style.styleNew == style.styleOld)
554 WIN_ReleasePtr( win );
555 return style.styleNew;
557 SERVER_START_REQ( set_window_info )
559 req->handle = hwnd;
560 req->flags = SET_WIN_STYLE;
561 req->style = style.styleNew;
562 req->extra_offset = -1;
563 if ((ok = !wine_server_call( req )))
565 style.styleOld = reply->old_style;
566 win->dwStyle = style.styleNew;
569 SERVER_END_REQ;
570 WIN_ReleasePtr( win );
571 if (ok)
573 USER_Driver->pSetWindowStyle( hwnd, GWL_STYLE, &style );
574 if ((style.styleOld ^ style.styleNew) & WS_VISIBLE) invalidate_dce( hwnd, NULL );
576 return style.styleOld;
580 /***********************************************************************
581 * WIN_GetRectangles
583 * Get the window and client rectangles.
585 BOOL WIN_GetRectangles( HWND hwnd, RECT *rectWindow, RECT *rectClient )
587 WND *win = WIN_GetPtr( hwnd );
588 BOOL ret = TRUE;
590 if (!win) return FALSE;
591 if (win == WND_DESKTOP)
593 RECT rect;
594 rect.left = rect.top = 0;
595 if (hwnd == get_hwnd_message_parent())
597 rect.right = 100;
598 rect.bottom = 100;
600 else
602 rect.right = GetSystemMetrics(SM_CXSCREEN);
603 rect.bottom = GetSystemMetrics(SM_CYSCREEN);
605 if (rectWindow) *rectWindow = rect;
606 if (rectClient) *rectClient = rect;
608 else if (win == WND_OTHER_PROCESS)
610 SERVER_START_REQ( get_window_rectangles )
612 req->handle = hwnd;
613 if ((ret = !wine_server_call( req )))
615 if (rectWindow)
617 rectWindow->left = reply->window.left;
618 rectWindow->top = reply->window.top;
619 rectWindow->right = reply->window.right;
620 rectWindow->bottom = reply->window.bottom;
622 if (rectClient)
624 rectClient->left = reply->client.left;
625 rectClient->top = reply->client.top;
626 rectClient->right = reply->client.right;
627 rectClient->bottom = reply->client.bottom;
631 SERVER_END_REQ;
633 else
635 if (rectWindow) *rectWindow = win->rectWindow;
636 if (rectClient) *rectClient = win->rectClient;
637 WIN_ReleasePtr( win );
639 return ret;
643 /***********************************************************************
644 * WIN_DestroyWindow
646 * Destroy storage associated to a window. "Internals" p.358
648 LRESULT WIN_DestroyWindow( HWND hwnd )
650 WND *wndPtr;
651 HWND *list;
652 HMENU menu = 0, sys_menu;
653 HWND icon_title;
655 TRACE("%p\n", hwnd );
657 /* free child windows */
658 if ((list = WIN_ListChildren( hwnd )))
660 int i;
661 for (i = 0; list[i]; i++)
663 if (WIN_IsCurrentThread( list[i] )) WIN_DestroyWindow( list[i] );
664 else SendMessageW( list[i], WM_WINE_DESTROYWINDOW, 0, 0 );
666 HeapFree( GetProcessHeap(), 0, list );
669 /* Unlink now so we won't bother with the children later on */
670 SERVER_START_REQ( set_parent )
672 req->handle = hwnd;
673 req->parent = 0;
674 wine_server_call( req );
676 SERVER_END_REQ;
679 * Send the WM_NCDESTROY to the window being destroyed.
681 SendMessageW( hwnd, WM_NCDESTROY, 0, 0 );
683 /* FIXME: do we need to fake QS_MOUSEMOVE wakebit? */
685 /* free resources associated with the window */
687 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return 0;
688 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
689 menu = (HMENU)wndPtr->wIDmenu;
690 sys_menu = wndPtr->hSysMenu;
691 free_dce( wndPtr->dce, hwnd );
692 wndPtr->dce = NULL;
693 icon_title = wndPtr->icon_title;
694 WIN_ReleasePtr( wndPtr );
696 if (icon_title) DestroyWindow( icon_title );
697 if (menu) DestroyMenu( menu );
698 if (sys_menu) DestroyMenu( sys_menu );
700 USER_Driver->pDestroyWindow( hwnd );
702 free_window_handle( hwnd );
703 return 0;
706 /***********************************************************************
707 * WIN_DestroyThreadWindows
709 * Destroy all children of 'wnd' owned by the current thread.
711 void WIN_DestroyThreadWindows( HWND hwnd )
713 HWND *list;
714 int i;
716 if (!(list = WIN_ListChildren( hwnd ))) return;
717 for (i = 0; list[i]; i++)
719 if (WIN_IsCurrentThread( list[i] ))
720 DestroyWindow( list[i] );
721 else
722 WIN_DestroyThreadWindows( list[i] );
724 HeapFree( GetProcessHeap(), 0, list );
728 /***********************************************************************
729 * WIN_FixCoordinates
731 * Fix the coordinates - Helper for WIN_CreateWindowEx.
732 * returns default show mode in sw.
734 static void WIN_FixCoordinates( CREATESTRUCTA *cs, INT *sw)
736 #define IS_DEFAULT(x) ((x) == CW_USEDEFAULT || (x) == CW_USEDEFAULT16)
737 POINT pos[2];
739 if (cs->dwExStyle & WS_EX_MDICHILD)
741 UINT id = 0;
743 MDI_CalcDefaultChildPos(cs->hwndParent, -1, pos, 0, &id);
744 if (!(cs->style & WS_POPUP)) cs->hMenu = ULongToHandle(id);
746 TRACE("MDI child id %04x\n", id);
749 if (cs->style & (WS_CHILD | WS_POPUP))
751 if (cs->dwExStyle & WS_EX_MDICHILD)
753 if (IS_DEFAULT(cs->x))
755 cs->x = pos[0].x;
756 cs->y = pos[0].y;
758 if (IS_DEFAULT(cs->cx) || !cs->cx) cs->cx = pos[1].x;
759 if (IS_DEFAULT(cs->cy) || !cs->cy) cs->cy = pos[1].y;
761 else
763 if (IS_DEFAULT(cs->x)) cs->x = cs->y = 0;
764 if (IS_DEFAULT(cs->cx)) cs->cx = cs->cy = 0;
767 else /* overlapped window */
769 HMONITOR monitor;
770 MONITORINFO mon_info;
771 STARTUPINFOW info;
773 if (!IS_DEFAULT(cs->x) && !IS_DEFAULT(cs->cx) && !IS_DEFAULT(cs->cy)) return;
775 monitor = MonitorFromWindow( cs->hwndParent, MONITOR_DEFAULTTOPRIMARY );
776 mon_info.cbSize = sizeof(mon_info);
777 GetMonitorInfoW( monitor, &mon_info );
778 GetStartupInfoW( &info );
780 if (IS_DEFAULT(cs->x))
782 if (!IS_DEFAULT(cs->y)) *sw = cs->y;
783 cs->x = (info.dwFlags & STARTF_USEPOSITION) ? info.dwX : mon_info.rcWork.left;
784 cs->y = (info.dwFlags & STARTF_USEPOSITION) ? info.dwY : mon_info.rcWork.top;
787 if (IS_DEFAULT(cs->cx))
789 if (info.dwFlags & STARTF_USESIZE)
791 cs->cx = info.dwXSize;
792 cs->cy = info.dwYSize;
794 else
796 cs->cx = (mon_info.rcWork.right - mon_info.rcWork.left) * 3 / 4 - cs->x;
797 cs->cy = (mon_info.rcWork.bottom - mon_info.rcWork.top) * 3 / 4 - cs->y;
800 /* neither x nor cx are default. Check the y values .
801 * In the trace we see Outlook and Outlook Express using
802 * cy set to CW_USEDEFAULT when opening the address book.
804 else if (IS_DEFAULT(cs->cy))
806 FIXME("Strange use of CW_USEDEFAULT in nHeight\n");
807 cs->cy = (mon_info.rcWork.bottom - mon_info.rcWork.top) * 3 / 4 - cs->y;
810 #undef IS_DEFAULT
813 /***********************************************************************
814 * dump_window_styles
816 static void dump_window_styles( DWORD style, DWORD exstyle )
818 TRACE( "style:" );
819 if(style & WS_POPUP) TRACE(" WS_POPUP");
820 if(style & WS_CHILD) TRACE(" WS_CHILD");
821 if(style & WS_MINIMIZE) TRACE(" WS_MINIMIZE");
822 if(style & WS_VISIBLE) TRACE(" WS_VISIBLE");
823 if(style & WS_DISABLED) TRACE(" WS_DISABLED");
824 if(style & WS_CLIPSIBLINGS) TRACE(" WS_CLIPSIBLINGS");
825 if(style & WS_CLIPCHILDREN) TRACE(" WS_CLIPCHILDREN");
826 if(style & WS_MAXIMIZE) TRACE(" WS_MAXIMIZE");
827 if((style & WS_CAPTION) == WS_CAPTION) TRACE(" WS_CAPTION");
828 else
830 if(style & WS_BORDER) TRACE(" WS_BORDER");
831 if(style & WS_DLGFRAME) TRACE(" WS_DLGFRAME");
833 if(style & WS_VSCROLL) TRACE(" WS_VSCROLL");
834 if(style & WS_HSCROLL) TRACE(" WS_HSCROLL");
835 if(style & WS_SYSMENU) TRACE(" WS_SYSMENU");
836 if(style & WS_THICKFRAME) TRACE(" WS_THICKFRAME");
837 if (style & WS_CHILD)
839 if(style & WS_GROUP) TRACE(" WS_GROUP");
840 if(style & WS_TABSTOP) TRACE(" WS_TABSTOP");
842 else
844 if(style & WS_MINIMIZEBOX) TRACE(" WS_MINIMIZEBOX");
845 if(style & WS_MAXIMIZEBOX) TRACE(" WS_MAXIMIZEBOX");
848 /* FIXME: Add dumping of BS_/ES_/SBS_/LBS_/CBS_/DS_/etc. styles */
849 #define DUMPED_STYLES \
850 (WS_POPUP | \
851 WS_CHILD | \
852 WS_MINIMIZE | \
853 WS_VISIBLE | \
854 WS_DISABLED | \
855 WS_CLIPSIBLINGS | \
856 WS_CLIPCHILDREN | \
857 WS_MAXIMIZE | \
858 WS_BORDER | \
859 WS_DLGFRAME | \
860 WS_VSCROLL | \
861 WS_HSCROLL | \
862 WS_SYSMENU | \
863 WS_THICKFRAME | \
864 WS_GROUP | \
865 WS_TABSTOP | \
866 WS_MINIMIZEBOX | \
867 WS_MAXIMIZEBOX)
869 if(style & ~DUMPED_STYLES) TRACE(" %08lx", style & ~DUMPED_STYLES);
870 TRACE("\n");
871 #undef DUMPED_STYLES
873 TRACE( "exstyle:" );
874 if(exstyle & WS_EX_DLGMODALFRAME) TRACE(" WS_EX_DLGMODALFRAME");
875 if(exstyle & WS_EX_DRAGDETECT) TRACE(" WS_EX_DRAGDETECT");
876 if(exstyle & WS_EX_NOPARENTNOTIFY) TRACE(" WS_EX_NOPARENTNOTIFY");
877 if(exstyle & WS_EX_TOPMOST) TRACE(" WS_EX_TOPMOST");
878 if(exstyle & WS_EX_ACCEPTFILES) TRACE(" WS_EX_ACCEPTFILES");
879 if(exstyle & WS_EX_TRANSPARENT) TRACE(" WS_EX_TRANSPARENT");
880 if(exstyle & WS_EX_MDICHILD) TRACE(" WS_EX_MDICHILD");
881 if(exstyle & WS_EX_TOOLWINDOW) TRACE(" WS_EX_TOOLWINDOW");
882 if(exstyle & WS_EX_WINDOWEDGE) TRACE(" WS_EX_WINDOWEDGE");
883 if(exstyle & WS_EX_CLIENTEDGE) TRACE(" WS_EX_CLIENTEDGE");
884 if(exstyle & WS_EX_CONTEXTHELP) TRACE(" WS_EX_CONTEXTHELP");
885 if(exstyle & WS_EX_RIGHT) TRACE(" WS_EX_RIGHT");
886 if(exstyle & WS_EX_RTLREADING) TRACE(" WS_EX_RTLREADING");
887 if(exstyle & WS_EX_LEFTSCROLLBAR) TRACE(" WS_EX_LEFTSCROLLBAR");
888 if(exstyle & WS_EX_CONTROLPARENT) TRACE(" WS_EX_CONTROLPARENT");
889 if(exstyle & WS_EX_STATICEDGE) TRACE(" WS_EX_STATICEDGE");
890 if(exstyle & WS_EX_APPWINDOW) TRACE(" WS_EX_APPWINDOW");
891 if(exstyle & WS_EX_LAYERED) TRACE(" WS_EX_LAYERED");
893 #define DUMPED_EX_STYLES \
894 (WS_EX_DLGMODALFRAME | \
895 WS_EX_DRAGDETECT | \
896 WS_EX_NOPARENTNOTIFY | \
897 WS_EX_TOPMOST | \
898 WS_EX_ACCEPTFILES | \
899 WS_EX_TRANSPARENT | \
900 WS_EX_MDICHILD | \
901 WS_EX_TOOLWINDOW | \
902 WS_EX_WINDOWEDGE | \
903 WS_EX_CLIENTEDGE | \
904 WS_EX_CONTEXTHELP | \
905 WS_EX_RIGHT | \
906 WS_EX_RTLREADING | \
907 WS_EX_LEFTSCROLLBAR | \
908 WS_EX_CONTROLPARENT | \
909 WS_EX_STATICEDGE | \
910 WS_EX_APPWINDOW | \
911 WS_EX_LAYERED)
913 if(exstyle & ~DUMPED_EX_STYLES) TRACE(" %08lx", exstyle & ~DUMPED_EX_STYLES);
914 TRACE("\n");
915 #undef DUMPED_EX_STYLES
919 /***********************************************************************
920 * WIN_CreateWindowEx
922 * Implementation of CreateWindowEx().
924 static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, LPCWSTR className, UINT flags )
926 INT cx, cy, style, sw = SW_SHOW;
927 LRESULT result;
928 RECT rect;
929 WND *wndPtr;
930 HWND hwnd, parent, owner, top_child = 0;
931 BOOL unicode = (flags & WIN_ISUNICODE) != 0;
932 MDICREATESTRUCTA mdi_cs;
933 CBT_CREATEWNDA cbtc;
934 CREATESTRUCTA cbcs;
936 TRACE("%s %s ex=%08x style=%08x %d,%d %dx%d parent=%p menu=%p inst=%p params=%p\n",
937 unicode ? debugstr_w((LPCWSTR)cs->lpszName) : debugstr_a(cs->lpszName),
938 debugstr_w(className),
939 cs->dwExStyle, cs->style, cs->x, cs->y, cs->cx, cs->cy,
940 cs->hwndParent, cs->hMenu, cs->hInstance, cs->lpCreateParams );
941 if(TRACE_ON(win)) dump_window_styles( cs->style, cs->dwExStyle );
943 /* Fix the styles for MDI children */
944 if (cs->dwExStyle & WS_EX_MDICHILD)
946 UINT flags = 0;
948 wndPtr = WIN_GetPtr(cs->hwndParent);
949 if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
951 flags = wndPtr->flags;
952 WIN_ReleasePtr(wndPtr);
955 if (!(flags & WIN_ISMDICLIENT))
957 WARN("WS_EX_MDICHILD, but parent %p is not MDIClient\n", cs->hwndParent);
958 return 0;
961 /* cs->lpCreateParams of WM_[NC]CREATE is different for MDI children.
962 * MDICREATESTRUCT members have the originally passed values.
964 * Note: we rely on the fact that MDICREATESTRUCTA and MDICREATESTRUCTW
965 * have the same layout.
967 mdi_cs.szClass = cs->lpszClass;
968 mdi_cs.szTitle = cs->lpszName;
969 mdi_cs.hOwner = cs->hInstance;
970 mdi_cs.x = cs->x;
971 mdi_cs.y = cs->y;
972 mdi_cs.cx = cs->cx;
973 mdi_cs.cy = cs->cy;
974 mdi_cs.style = cs->style;
975 mdi_cs.lParam = (LPARAM)cs->lpCreateParams;
977 cs->lpCreateParams = (LPVOID)&mdi_cs;
979 if (GetWindowLongW(cs->hwndParent, GWL_STYLE) & MDIS_ALLCHILDSTYLES)
981 if (cs->style & WS_POPUP)
983 TRACE("WS_POPUP with MDIS_ALLCHILDSTYLES is not allowed\n");
984 return 0;
986 cs->style |= WS_CHILD | WS_CLIPSIBLINGS;
988 else
990 cs->style &= ~WS_POPUP;
991 cs->style |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CAPTION |
992 WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
995 top_child = GetWindow(cs->hwndParent, GW_CHILD);
997 if (top_child)
999 /* Restore current maximized child */
1000 if((cs->style & WS_VISIBLE) && IsZoomed(top_child))
1002 TRACE("Restoring current maximized child %p\n", top_child);
1003 SendMessageW( top_child, WM_SETREDRAW, FALSE, 0 );
1004 ShowWindow( top_child, SW_SHOWNORMAL );
1005 SendMessageW( top_child, WM_SETREDRAW, TRUE, 0 );
1010 /* Find the parent window */
1012 parent = cs->hwndParent;
1013 owner = 0;
1015 if (cs->hwndParent == HWND_MESSAGE)
1017 cs->hwndParent = parent = get_hwnd_message_parent();
1019 else if (cs->hwndParent)
1021 if ((cs->style & (WS_CHILD|WS_POPUP)) != WS_CHILD)
1023 parent = GetDesktopWindow();
1024 owner = cs->hwndParent;
1027 else
1029 static const WCHAR messageW[] = {'M','e','s','s','a','g','e',0};
1031 if ((cs->style & (WS_CHILD|WS_POPUP)) == WS_CHILD)
1033 WARN("No parent for child window\n" );
1034 SetLastError(ERROR_TLW_WITH_WSCHILD);
1035 return 0; /* WS_CHILD needs a parent, but WS_POPUP doesn't */
1037 /* are we creating the desktop or HWND_MESSAGE parent itself? */
1038 if (className != (LPCWSTR)DESKTOP_CLASS_ATOM &&
1039 (IS_INTRESOURCE(className) || strcmpiW( className, messageW )))
1040 parent = GetDesktopWindow();
1043 WIN_FixCoordinates(cs, &sw); /* fix default coordinates */
1045 if ((cs->dwExStyle & WS_EX_DLGMODALFRAME) ||
1046 ((!(cs->dwExStyle & WS_EX_STATICEDGE)) &&
1047 (cs->style & (WS_DLGFRAME | WS_THICKFRAME))))
1048 cs->dwExStyle |= WS_EX_WINDOWEDGE;
1049 else
1050 cs->dwExStyle &= ~WS_EX_WINDOWEDGE;
1052 /* Create the window structure */
1054 if (!(wndPtr = create_window_handle( parent, owner, className, cs->hInstance, unicode )))
1055 return 0;
1056 hwnd = wndPtr->hwndSelf;
1058 /* Fill the window structure */
1060 wndPtr->tid = GetCurrentThreadId();
1061 wndPtr->hInstance = cs->hInstance;
1062 wndPtr->text = NULL;
1063 wndPtr->dwStyle = cs->style & ~WS_VISIBLE;
1064 wndPtr->dwExStyle = cs->dwExStyle;
1065 wndPtr->wIDmenu = 0;
1066 wndPtr->helpContext = 0;
1067 wndPtr->pVScroll = NULL;
1068 wndPtr->pHScroll = NULL;
1069 wndPtr->userdata = 0;
1070 wndPtr->hIcon = 0;
1071 wndPtr->hIconSmall = 0;
1072 wndPtr->hSysMenu = 0;
1073 wndPtr->flags |= (flags & WIN_ISWIN32);
1075 if (wndPtr->dwStyle & WS_SYSMENU) SetSystemMenu( hwnd, 0 );
1078 * Correct the window styles.
1080 * It affects only the style loaded into the WIN structure.
1083 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1085 wndPtr->dwStyle |= WS_CLIPSIBLINGS;
1086 if (!(wndPtr->dwStyle & WS_POPUP))
1087 wndPtr->dwStyle |= WS_CAPTION;
1091 * WS_EX_WINDOWEDGE appears to be enforced based on the other styles, so
1092 * why does the user get to set it?
1095 if ((wndPtr->dwExStyle & WS_EX_DLGMODALFRAME) ||
1096 (wndPtr->dwStyle & (WS_DLGFRAME | WS_THICKFRAME)))
1097 wndPtr->dwExStyle |= WS_EX_WINDOWEDGE;
1098 else
1099 wndPtr->dwExStyle &= ~WS_EX_WINDOWEDGE;
1101 if (!(wndPtr->dwStyle & (WS_CHILD | WS_POPUP)))
1102 wndPtr->flags |= WIN_NEED_SIZE;
1104 SERVER_START_REQ( set_window_info )
1106 req->handle = hwnd;
1107 req->flags = SET_WIN_STYLE | SET_WIN_EXSTYLE | SET_WIN_INSTANCE | SET_WIN_UNICODE;
1108 req->style = wndPtr->dwStyle;
1109 req->ex_style = wndPtr->dwExStyle;
1110 req->instance = (void *)wndPtr->hInstance;
1111 req->is_unicode = (wndPtr->flags & WIN_ISUNICODE) != 0;
1112 req->extra_offset = -1;
1113 wine_server_call( req );
1115 SERVER_END_REQ;
1117 /* Set the window menu */
1119 if ((wndPtr->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1121 if (cs->hMenu)
1123 if (!MENU_SetMenu(hwnd, cs->hMenu))
1125 WIN_ReleasePtr( wndPtr );
1126 free_window_handle( hwnd );
1127 return 0;
1130 else
1132 LPCSTR menuName = (LPCSTR)GetClassLongPtrA( hwnd, GCLP_MENUNAME );
1133 if (menuName)
1135 if (!cs->hInstance || HIWORD(cs->hInstance))
1136 cs->hMenu = LoadMenuA(cs->hInstance,menuName);
1137 else
1138 cs->hMenu = HMENU_32(LoadMenu16(HINSTANCE_16(cs->hInstance),menuName));
1140 if (cs->hMenu) MENU_SetMenu( hwnd, cs->hMenu );
1144 else SetWindowLongPtrW( hwnd, GWLP_ID, (ULONG_PTR)cs->hMenu );
1146 /* call the WH_CBT hook */
1148 /* the window style passed to the hook must be the real window style,
1149 * rather than just the window style that the caller to CreateWindowEx
1150 * passed in, so we have to copy the original CREATESTRUCT and get the
1151 * the real style. */
1152 cbcs = *cs;
1153 cbcs.style = wndPtr->dwStyle;
1154 cbtc.lpcs = &cbcs;
1155 cbtc.hwndInsertAfter = HWND_TOP;
1156 WIN_ReleasePtr( wndPtr );
1157 if (HOOK_CallHooks( WH_CBT, HCBT_CREATEWND, (WPARAM)hwnd, (LPARAM)&cbtc, unicode )) goto failed;
1159 /* send the WM_GETMINMAXINFO message and fix the size if needed */
1161 cx = cs->cx;
1162 cy = cs->cy;
1163 if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD)))
1165 POINT maxSize, maxPos, minTrack, maxTrack;
1166 WINPOS_GetMinMaxInfo( hwnd, &maxSize, &maxPos, &minTrack, &maxTrack);
1167 if (maxTrack.x < cx) cx = maxTrack.x;
1168 if (maxTrack.y < cy) cy = maxTrack.y;
1169 if (minTrack.x > cx) cx = minTrack.x;
1170 if (minTrack.y > cy) cy = minTrack.y;
1173 if (cx < 0) cx = 0;
1174 if (cy < 0) cy = 0;
1175 SetRect( &rect, cs->x, cs->y, cs->x + cx, cs->y + cy );
1176 /* check for wraparound */
1177 if (cs->x + cx < cs->x) rect.right = 0x7fffffff;
1178 if (cs->y + cy < cs->y) rect.bottom = 0x7fffffff;
1179 if (!set_window_pos( hwnd, 0, SWP_NOZORDER | SWP_NOACTIVATE, &rect, &rect, NULL )) goto failed;
1181 /* send WM_NCCREATE */
1183 TRACE( "hwnd %p cs %d,%d %dx%d\n", hwnd, cs->x, cs->y, cx, cy );
1184 if (unicode)
1185 result = SendMessageW( hwnd, WM_NCCREATE, 0, (LPARAM)cs );
1186 else
1187 result = SendMessageA( hwnd, WM_NCCREATE, 0, (LPARAM)cs );
1188 if (!result)
1190 WARN( "%p: aborted by WM_NCCREATE\n", hwnd );
1191 goto failed;
1194 /* send WM_NCCALCSIZE */
1196 if ((wndPtr = WIN_GetPtr(hwnd)))
1198 /* yes, even if the CBT hook was called with HWND_TOP */
1199 POINT pt;
1200 HWND insert_after = (wndPtr->dwStyle & WS_CHILD) ? HWND_BOTTOM : HWND_TOP;
1201 RECT window_rect = wndPtr->rectWindow;
1202 RECT client_rect = window_rect;
1203 WIN_ReleasePtr( wndPtr );
1205 /* the rectangle is in screen coords for WM_NCCALCSIZE when wparam is FALSE */
1206 pt.x = pt.y = 0;
1207 MapWindowPoints( parent, 0, &pt, 1 );
1208 OffsetRect( &client_rect, pt.x, pt.y );
1209 SendMessageW( hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&client_rect );
1210 OffsetRect( &client_rect, -pt.x, -pt.y );
1211 set_window_pos( hwnd, insert_after, SWP_NOACTIVATE, &window_rect, &client_rect, NULL );
1213 else return 0;
1215 /* send WM_CREATE */
1217 if (unicode)
1218 result = SendMessageW( hwnd, WM_CREATE, 0, (LPARAM)cs );
1219 else
1220 result = SendMessageA( hwnd, WM_CREATE, 0, (LPARAM)cs );
1221 if (result == -1) goto failed;
1223 /* call the driver */
1225 if (!USER_Driver->pCreateWindow( hwnd )) goto failed;
1227 NotifyWinEvent(EVENT_OBJECT_CREATE, hwnd, OBJID_WINDOW, 0);
1229 /* send the size messages */
1231 if (!(wndPtr = WIN_GetPtr(hwnd))) return 0;
1232 if (!(wndPtr->flags & WIN_NEED_SIZE))
1234 rect = wndPtr->rectClient;
1235 WIN_ReleasePtr( wndPtr );
1236 SendMessageW( hwnd, WM_SIZE, SIZE_RESTORED,
1237 MAKELONG(rect.right-rect.left, rect.bottom-rect.top));
1238 SendMessageW( hwnd, WM_MOVE, 0, MAKELONG( rect.left, rect.top ) );
1240 else WIN_ReleasePtr( wndPtr );
1242 /* Show the window, maximizing or minimizing if needed */
1244 style = WIN_SetStyle( hwnd, 0, WS_MAXIMIZE | WS_MINIMIZE );
1245 if (style & (WS_MINIMIZE | WS_MAXIMIZE))
1247 RECT newPos;
1248 UINT swFlag = (style & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE;
1250 swFlag = WINPOS_MinMaximize( hwnd, swFlag, &newPos );
1251 swFlag |= SWP_FRAMECHANGED; /* Frame always gets changed */
1252 if (!(style & WS_VISIBLE) || (style & WS_CHILD) || GetActiveWindow()) swFlag |= SWP_NOACTIVATE;
1253 SetWindowPos( hwnd, 0, newPos.left, newPos.top, newPos.right - newPos.left,
1254 newPos.bottom - newPos.top, swFlag );
1257 /* Notify the parent window only */
1259 send_parent_notify( hwnd, WM_CREATE );
1260 if (!IsWindow( hwnd )) return 0;
1262 if (cs->style & WS_VISIBLE)
1264 if (cs->style & WS_MAXIMIZE)
1265 sw = SW_SHOW;
1266 else if (cs->style & WS_MINIMIZE)
1267 sw = SW_SHOWMINIMIZED;
1269 ShowWindow( hwnd, sw );
1270 if (cs->dwExStyle & WS_EX_MDICHILD)
1272 SendMessageW(cs->hwndParent, WM_MDIREFRESHMENU, 0, 0);
1273 /* ShowWindow won't activate child windows */
1274 SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE );
1278 /* Call WH_SHELL hook */
1280 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) && !GetWindow( hwnd, GW_OWNER ))
1281 HOOK_CallHooks( WH_SHELL, HSHELL_WINDOWCREATED, (WPARAM)hwnd, 0, TRUE );
1283 TRACE("created window %p\n", hwnd);
1284 return hwnd;
1286 failed:
1287 WIN_DestroyWindow( hwnd );
1288 return 0;
1292 /***********************************************************************
1293 * CreateWindow (USER.41)
1295 HWND16 WINAPI CreateWindow16( LPCSTR className, LPCSTR windowName,
1296 DWORD style, INT16 x, INT16 y, INT16 width,
1297 INT16 height, HWND16 parent, HMENU16 menu,
1298 HINSTANCE16 instance, LPVOID data )
1300 return CreateWindowEx16( 0, className, windowName, style,
1301 x, y, width, height, parent, menu, instance, data );
1305 /***********************************************************************
1306 * CreateWindowEx (USER.452)
1308 HWND16 WINAPI CreateWindowEx16( DWORD exStyle, LPCSTR className,
1309 LPCSTR windowName, DWORD style, INT16 x,
1310 INT16 y, INT16 width, INT16 height,
1311 HWND16 parent, HMENU16 menu,
1312 HINSTANCE16 instance, LPVOID data )
1314 CREATESTRUCTA cs;
1315 char buffer[256];
1317 /* Fix the coordinates */
1319 cs.x = (x == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)x;
1320 cs.y = (y == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)y;
1321 cs.cx = (width == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)width;
1322 cs.cy = (height == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)height;
1324 /* Create the window */
1326 cs.lpCreateParams = data;
1327 cs.hInstance = HINSTANCE_32(instance);
1328 cs.hMenu = HMENU_32(menu);
1329 cs.hwndParent = WIN_Handle32( parent );
1330 cs.style = style;
1331 cs.lpszName = windowName;
1332 cs.lpszClass = className;
1333 cs.dwExStyle = exStyle;
1335 if (!IS_INTRESOURCE(className))
1337 WCHAR bufferW[256];
1339 if (!MultiByteToWideChar( CP_ACP, 0, className, -1, bufferW, sizeof(bufferW)/sizeof(WCHAR) ))
1340 return 0;
1341 return HWND_16( WIN_CreateWindowEx( &cs, bufferW, 0 ));
1343 else
1345 if (!GlobalGetAtomNameA( LOWORD(className), buffer, sizeof(buffer) ))
1347 ERR( "bad atom %x\n", LOWORD(className));
1348 return 0;
1350 cs.lpszClass = buffer;
1351 return HWND_16( WIN_CreateWindowEx( &cs, (LPCWSTR)className, 0 ));
1356 /***********************************************************************
1357 * CreateWindowExA (USER32.@)
1359 HWND WINAPI CreateWindowExA( DWORD exStyle, LPCSTR className,
1360 LPCSTR windowName, DWORD style, INT x,
1361 INT y, INT width, INT height,
1362 HWND parent, HMENU menu,
1363 HINSTANCE instance, LPVOID data )
1365 CREATESTRUCTA cs;
1367 cs.lpCreateParams = data;
1368 cs.hInstance = instance;
1369 cs.hMenu = menu;
1370 cs.hwndParent = parent;
1371 cs.x = x;
1372 cs.y = y;
1373 cs.cx = width;
1374 cs.cy = height;
1375 cs.style = style;
1376 cs.lpszName = windowName;
1377 cs.lpszClass = className;
1378 cs.dwExStyle = exStyle;
1380 if (!IS_INTRESOURCE(className))
1382 WCHAR bufferW[256];
1383 if (!MultiByteToWideChar( CP_ACP, 0, className, -1, bufferW, sizeof(bufferW)/sizeof(WCHAR) ))
1384 return 0;
1385 return WIN_CreateWindowEx( &cs, bufferW, WIN_ISWIN32 );
1387 return WIN_CreateWindowEx( &cs, (LPCWSTR)className, WIN_ISWIN32 );
1391 /***********************************************************************
1392 * CreateWindowExW (USER32.@)
1394 HWND WINAPI CreateWindowExW( DWORD exStyle, LPCWSTR className,
1395 LPCWSTR windowName, DWORD style, INT x,
1396 INT y, INT width, INT height,
1397 HWND parent, HMENU menu,
1398 HINSTANCE instance, LPVOID data )
1400 CREATESTRUCTW cs;
1402 cs.lpCreateParams = data;
1403 cs.hInstance = instance;
1404 cs.hMenu = menu;
1405 cs.hwndParent = parent;
1406 cs.x = x;
1407 cs.y = y;
1408 cs.cx = width;
1409 cs.cy = height;
1410 cs.style = style;
1411 cs.lpszName = windowName;
1412 cs.lpszClass = className;
1413 cs.dwExStyle = exStyle;
1415 /* Note: we rely on the fact that CREATESTRUCTA and */
1416 /* CREATESTRUCTW have the same layout. */
1417 return WIN_CreateWindowEx( (CREATESTRUCTA *)&cs, className, WIN_ISWIN32 | WIN_ISUNICODE );
1421 /***********************************************************************
1422 * WIN_SendDestroyMsg
1424 static void WIN_SendDestroyMsg( HWND hwnd )
1426 GUITHREADINFO info;
1428 if (GetGUIThreadInfo( GetCurrentThreadId(), &info ))
1430 if (hwnd == info.hwndCaret) DestroyCaret();
1431 if (hwnd == info.hwndActive) WINPOS_ActivateOtherWindow( hwnd );
1435 * Send the WM_DESTROY to the window.
1437 SendMessageW( hwnd, WM_DESTROY, 0, 0);
1440 * This WM_DESTROY message can trigger re-entrant calls to DestroyWindow
1441 * make sure that the window still exists when we come back.
1443 if (IsWindow(hwnd))
1445 HWND* pWndArray;
1446 int i;
1448 if (!(pWndArray = WIN_ListChildren( hwnd ))) return;
1450 for (i = 0; pWndArray[i]; i++)
1452 if (IsWindow( pWndArray[i] )) WIN_SendDestroyMsg( pWndArray[i] );
1454 HeapFree( GetProcessHeap(), 0, pWndArray );
1456 else
1457 WARN("\tdestroyed itself while in WM_DESTROY!\n");
1461 /***********************************************************************
1462 * DestroyWindow (USER32.@)
1464 BOOL WINAPI DestroyWindow( HWND hwnd )
1466 BOOL is_child;
1468 if (!(hwnd = WIN_IsCurrentThread( hwnd )) || is_desktop_window( hwnd ))
1470 SetLastError( ERROR_ACCESS_DENIED );
1471 return FALSE;
1474 TRACE("(%p)\n", hwnd);
1476 /* Call hooks */
1478 if (HOOK_CallHooks( WH_CBT, HCBT_DESTROYWND, (WPARAM)hwnd, 0, TRUE )) return FALSE;
1480 if (MENU_IsMenuActive() == hwnd)
1481 EndMenu();
1483 is_child = (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) != 0;
1485 if (is_child)
1487 if (!USER_IsExitingThread( GetCurrentThreadId() ))
1488 send_parent_notify( hwnd, WM_DESTROY );
1490 else if (!GetWindow( hwnd, GW_OWNER ))
1492 HOOK_CallHooks( WH_SHELL, HSHELL_WINDOWDESTROYED, (WPARAM)hwnd, 0L, TRUE );
1493 /* FIXME: clean up palette - see "Internals" p.352 */
1496 if (!IsWindow(hwnd)) return TRUE;
1498 /* Hide the window */
1499 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)
1501 /* Only child windows receive WM_SHOWWINDOW in DestroyWindow() */
1502 if (is_child)
1503 ShowWindow( hwnd, SW_HIDE );
1504 else
1505 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE |
1506 SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW );
1509 if (!IsWindow(hwnd)) return TRUE;
1511 /* Recursively destroy owned windows */
1513 if (!is_child)
1515 for (;;)
1517 int i, got_one = 0;
1518 HWND *list = WIN_ListChildren( GetDesktopWindow() );
1519 if (list)
1521 for (i = 0; list[i]; i++)
1523 if (GetWindow( list[i], GW_OWNER ) != hwnd) continue;
1524 if (WIN_IsCurrentThread( list[i] ))
1526 DestroyWindow( list[i] );
1527 got_one = 1;
1528 continue;
1530 WIN_SetOwner( list[i], 0 );
1532 HeapFree( GetProcessHeap(), 0, list );
1534 if (!got_one) break;
1538 /* Send destroy messages */
1540 WIN_SendDestroyMsg( hwnd );
1541 if (!IsWindow( hwnd )) return TRUE;
1543 if (GetClipboardOwner() == hwnd)
1544 CLIPBOARD_ReleaseOwner();
1546 /* Destroy the window storage */
1548 WIN_DestroyWindow( hwnd );
1549 return TRUE;
1553 /***********************************************************************
1554 * CloseWindow (USER32.@)
1556 BOOL WINAPI CloseWindow( HWND hwnd )
1558 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) return FALSE;
1559 ShowWindow( hwnd, SW_MINIMIZE );
1560 return TRUE;
1564 /***********************************************************************
1565 * OpenIcon (USER32.@)
1567 BOOL WINAPI OpenIcon( HWND hwnd )
1569 if (!IsIconic( hwnd )) return FALSE;
1570 ShowWindow( hwnd, SW_SHOWNORMAL );
1571 return TRUE;
1575 /***********************************************************************
1576 * FindWindowExW (USER32.@)
1578 HWND WINAPI FindWindowExW( HWND parent, HWND child, LPCWSTR className, LPCWSTR title )
1580 HWND *list = NULL;
1581 HWND retvalue = 0;
1582 int i = 0, len = 0;
1583 WCHAR *buffer = NULL;
1585 if (!parent && child) parent = GetDesktopWindow();
1586 else if (parent == HWND_MESSAGE) parent = get_hwnd_message_parent();
1588 if (title)
1590 len = strlenW(title) + 1; /* one extra char to check for chars beyond the end */
1591 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return 0;
1594 if (!(list = list_window_children( 0, parent, className, 0 ))) goto done;
1596 if (child)
1598 child = WIN_GetFullHandle( child );
1599 while (list[i] && list[i] != child) i++;
1600 if (!list[i]) goto done;
1601 i++; /* start from next window */
1604 if (title)
1606 while (list[i])
1608 if (GetWindowTextW( list[i], buffer, len + 1 ) && !strcmpiW( buffer, title )) break;
1609 i++;
1612 retvalue = list[i];
1614 done:
1615 HeapFree( GetProcessHeap(), 0, list );
1616 HeapFree( GetProcessHeap(), 0, buffer );
1617 return retvalue;
1622 /***********************************************************************
1623 * FindWindowA (USER32.@)
1625 HWND WINAPI FindWindowA( LPCSTR className, LPCSTR title )
1627 HWND ret = FindWindowExA( 0, 0, className, title );
1628 if (!ret) SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1629 return ret;
1633 /***********************************************************************
1634 * FindWindowExA (USER32.@)
1636 HWND WINAPI FindWindowExA( HWND parent, HWND child, LPCSTR className, LPCSTR title )
1638 LPWSTR titleW = NULL;
1639 HWND hwnd = 0;
1641 if (title)
1643 DWORD len = MultiByteToWideChar( CP_ACP, 0, title, -1, NULL, 0 );
1644 if (!(titleW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return 0;
1645 MultiByteToWideChar( CP_ACP, 0, title, -1, titleW, len );
1648 if (!IS_INTRESOURCE(className))
1650 WCHAR classW[256];
1651 if (MultiByteToWideChar( CP_ACP, 0, className, -1, classW, sizeof(classW)/sizeof(WCHAR) ))
1652 hwnd = FindWindowExW( parent, child, classW, titleW );
1654 else
1656 hwnd = FindWindowExW( parent, child, (LPCWSTR)className, titleW );
1659 HeapFree( GetProcessHeap(), 0, titleW );
1660 return hwnd;
1664 /***********************************************************************
1665 * FindWindowW (USER32.@)
1667 HWND WINAPI FindWindowW( LPCWSTR className, LPCWSTR title )
1669 return FindWindowExW( 0, 0, className, title );
1673 /**********************************************************************
1674 * GetDesktopWindow (USER32.@)
1676 HWND WINAPI GetDesktopWindow(void)
1678 struct user_thread_info *thread_info = get_user_thread_info();
1680 if (thread_info->top_window) return thread_info->top_window;
1682 SERVER_START_REQ( get_desktop_window )
1684 req->force = 0;
1685 if (!wine_server_call( req ))
1687 thread_info->top_window = reply->top_window;
1688 thread_info->msg_window = reply->msg_window;
1691 SERVER_END_REQ;
1693 if (!thread_info->top_window)
1695 USEROBJECTFLAGS flags;
1696 if (!GetUserObjectInformationW( GetProcessWindowStation(), UOI_FLAGS, &flags,
1697 sizeof(flags), NULL ) || (flags.dwFlags & WSF_VISIBLE))
1699 static const WCHAR command_line[] = {'\\','e','x','p','l','o','r','e','r','.','e','x','e',' ','/','d','e','s','k','t','o','p',0};
1700 STARTUPINFOW si;
1701 PROCESS_INFORMATION pi;
1702 WCHAR cmdline[MAX_PATH + sizeof(command_line)/sizeof(WCHAR)];
1704 memset( &si, 0, sizeof(si) );
1705 si.cb = sizeof(si);
1706 si.dwFlags = STARTF_USESTDHANDLES;
1707 si.hStdInput = 0;
1708 si.hStdOutput = 0;
1709 si.hStdError = GetStdHandle( STD_ERROR_HANDLE );
1711 GetSystemDirectoryW( cmdline, MAX_PATH );
1712 lstrcatW( cmdline, command_line );
1713 if (CreateProcessW( NULL, cmdline, NULL, NULL, FALSE, DETACHED_PROCESS,
1714 NULL, NULL, &si, &pi ))
1716 TRACE( "started explorer pid %04x tid %04x\n", pi.dwProcessId, pi.dwThreadId );
1717 WaitForInputIdle( pi.hProcess, 10000 );
1718 CloseHandle( pi.hThread );
1719 CloseHandle( pi.hProcess );
1721 else WARN( "failed to start explorer, err %d\n", GetLastError() );
1723 else TRACE( "not starting explorer since winstation is not visible\n" );
1725 SERVER_START_REQ( get_desktop_window )
1727 req->force = 1;
1728 if (!wine_server_call( req ))
1730 thread_info->top_window = reply->top_window;
1731 thread_info->msg_window = reply->msg_window;
1734 SERVER_END_REQ;
1737 if (!thread_info->top_window || !USER_Driver->pCreateDesktopWindow( thread_info->top_window ))
1738 ERR( "failed to create desktop window\n" );
1740 return thread_info->top_window;
1744 /*******************************************************************
1745 * EnableWindow (USER32.@)
1747 BOOL WINAPI EnableWindow( HWND hwnd, BOOL enable )
1749 BOOL retvalue;
1750 HWND full_handle;
1752 if (is_broadcast(hwnd))
1754 SetLastError( ERROR_INVALID_PARAMETER );
1755 return FALSE;
1758 if (!(full_handle = WIN_IsCurrentThread( hwnd )))
1759 return SendMessageW( hwnd, WM_WINE_ENABLEWINDOW, enable, 0 );
1761 hwnd = full_handle;
1763 TRACE("( %p, %d )\n", hwnd, enable);
1765 retvalue = !IsWindowEnabled( hwnd );
1767 if (enable && retvalue)
1769 WIN_SetStyle( hwnd, 0, WS_DISABLED );
1770 SendMessageW( hwnd, WM_ENABLE, TRUE, 0 );
1772 else if (!enable && !retvalue)
1774 HWND capture_wnd;
1776 SendMessageW( hwnd, WM_CANCELMODE, 0, 0);
1778 WIN_SetStyle( hwnd, WS_DISABLED, 0 );
1780 if (hwnd == GetFocus())
1781 SetFocus( 0 ); /* A disabled window can't have the focus */
1783 capture_wnd = GetCapture();
1784 if (hwnd == capture_wnd || IsChild(hwnd, capture_wnd))
1785 ReleaseCapture(); /* A disabled window can't capture the mouse */
1787 SendMessageW( hwnd, WM_ENABLE, FALSE, 0 );
1789 return retvalue;
1793 /***********************************************************************
1794 * IsWindowEnabled (USER32.@)
1796 BOOL WINAPI IsWindowEnabled(HWND hWnd)
1798 return !(GetWindowLongW( hWnd, GWL_STYLE ) & WS_DISABLED);
1802 /***********************************************************************
1803 * IsWindowUnicode (USER32.@)
1805 BOOL WINAPI IsWindowUnicode( HWND hwnd )
1807 WND * wndPtr;
1808 BOOL retvalue = FALSE;
1810 if (!(wndPtr = WIN_GetPtr(hwnd))) return FALSE;
1812 if (wndPtr == WND_DESKTOP) return TRUE;
1814 if (wndPtr != WND_OTHER_PROCESS)
1816 retvalue = (wndPtr->flags & WIN_ISUNICODE) != 0;
1817 WIN_ReleasePtr( wndPtr );
1819 else
1821 SERVER_START_REQ( get_window_info )
1823 req->handle = hwnd;
1824 if (!wine_server_call_err( req )) retvalue = reply->is_unicode;
1826 SERVER_END_REQ;
1828 return retvalue;
1832 /**********************************************************************
1833 * WIN_GetWindowLong
1835 * Helper function for GetWindowLong().
1837 static LONG_PTR WIN_GetWindowLong( HWND hwnd, INT offset, UINT size, BOOL unicode )
1839 LONG_PTR retvalue = 0;
1840 WND *wndPtr;
1842 if (offset == GWLP_HWNDPARENT)
1844 HWND parent = GetAncestor( hwnd, GA_PARENT );
1845 if (parent == GetDesktopWindow()) parent = GetWindow( hwnd, GW_OWNER );
1846 return (ULONG_PTR)parent;
1849 if (!(wndPtr = WIN_GetPtr( hwnd )))
1851 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1852 return 0;
1855 if (wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP)
1857 if (offset == GWLP_WNDPROC)
1859 SetLastError( ERROR_ACCESS_DENIED );
1860 return 0;
1862 SERVER_START_REQ( set_window_info )
1864 req->handle = hwnd;
1865 req->flags = 0; /* don't set anything, just retrieve */
1866 req->extra_offset = (offset >= 0) ? offset : -1;
1867 req->extra_size = (offset >= 0) ? size : 0;
1868 if (!wine_server_call_err( req ))
1870 switch(offset)
1872 case GWL_STYLE: retvalue = reply->old_style; break;
1873 case GWL_EXSTYLE: retvalue = reply->old_ex_style; break;
1874 case GWLP_ID: retvalue = reply->old_id; break;
1875 case GWLP_HINSTANCE: retvalue = (ULONG_PTR)reply->old_instance; break;
1876 case GWLP_USERDATA: retvalue = reply->old_user_data; break;
1877 default:
1878 if (offset >= 0) retvalue = get_win_data( &reply->old_extra_value, size );
1879 else SetLastError( ERROR_INVALID_INDEX );
1880 break;
1884 SERVER_END_REQ;
1885 return retvalue;
1888 /* now we have a valid wndPtr */
1890 if (offset >= 0)
1892 if (offset > (int)(wndPtr->cbWndExtra - size))
1894 WARN("Invalid offset %d\n", offset );
1895 WIN_ReleasePtr( wndPtr );
1896 SetLastError( ERROR_INVALID_INDEX );
1897 return 0;
1899 retvalue = get_win_data( (char *)wndPtr->wExtra + offset, size );
1901 /* Special case for dialog window procedure */
1902 if ((offset == DWLP_DLGPROC) && (size == sizeof(LONG_PTR)) && (wndPtr->flags & WIN_ISDIALOG))
1903 retvalue = (LONG_PTR)WINPROC_GetProc( (WNDPROC)retvalue, unicode );
1904 WIN_ReleasePtr( wndPtr );
1905 return retvalue;
1908 switch(offset)
1910 case GWLP_USERDATA: retvalue = wndPtr->userdata; break;
1911 case GWL_STYLE: retvalue = wndPtr->dwStyle; break;
1912 case GWL_EXSTYLE: retvalue = wndPtr->dwExStyle; break;
1913 case GWLP_ID: retvalue = wndPtr->wIDmenu; break;
1914 case GWLP_HINSTANCE: retvalue = (ULONG_PTR)wndPtr->hInstance; break;
1915 case GWLP_WNDPROC:
1916 /* This looks like a hack only for the edit control (see tests). This makes these controls
1917 * more tolerant to A/W mismatches. The lack of W->A->W conversion for such a mismatch suggests
1918 * that the hack is in GetWindowLongPtr[AW], not in winprocs.
1920 if (wndPtr->winproc == EDIT_winproc_handle && (!unicode != !(wndPtr->flags & WIN_ISUNICODE)))
1921 retvalue = (ULONG_PTR)wndPtr->winproc;
1922 else
1923 retvalue = (ULONG_PTR)WINPROC_GetProc( wndPtr->winproc, unicode );
1924 break;
1925 default:
1926 WARN("Unknown offset %d\n", offset );
1927 SetLastError( ERROR_INVALID_INDEX );
1928 break;
1930 WIN_ReleasePtr(wndPtr);
1931 return retvalue;
1935 /**********************************************************************
1936 * WIN_SetWindowLong
1938 * Helper function for SetWindowLong().
1940 * 0 is the failure code. However, in the case of failure SetLastError
1941 * must be set to distinguish between a 0 return value and a failure.
1943 LONG_PTR WIN_SetWindowLong( HWND hwnd, INT offset, UINT size, LONG_PTR newval, BOOL unicode )
1945 STYLESTRUCT style;
1946 BOOL ok;
1947 LONG_PTR retval = 0;
1948 WND *wndPtr;
1950 TRACE( "%p %d %lx %c\n", hwnd, offset, newval, unicode ? 'W' : 'A' );
1952 if (is_broadcast(hwnd))
1954 SetLastError( ERROR_INVALID_PARAMETER );
1955 return FALSE;
1958 if (!(wndPtr = WIN_GetPtr( hwnd )))
1960 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1961 return 0;
1963 if (wndPtr == WND_DESKTOP)
1965 /* can't change anything on the desktop window */
1966 SetLastError( ERROR_ACCESS_DENIED );
1967 return 0;
1969 if (wndPtr == WND_OTHER_PROCESS)
1971 if (offset == GWLP_WNDPROC)
1973 SetLastError( ERROR_ACCESS_DENIED );
1974 return 0;
1976 if (offset > 32767 || offset < -32767)
1978 SetLastError( ERROR_INVALID_INDEX );
1979 return 0;
1981 return SendMessageW( hwnd, WM_WINE_SETWINDOWLONG, MAKEWPARAM( offset, size ), newval );
1984 /* first some special cases */
1985 switch( offset )
1987 case GWL_STYLE:
1988 case GWL_EXSTYLE:
1989 style.styleOld =
1990 offset == GWL_STYLE ? wndPtr->dwStyle : wndPtr->dwExStyle;
1991 style.styleNew = newval;
1992 WIN_ReleasePtr( wndPtr );
1993 SendMessageW( hwnd, WM_STYLECHANGING, offset, (LPARAM)&style );
1994 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return 0;
1995 newval = style.styleNew;
1996 break;
1997 case GWLP_HWNDPARENT:
1998 if (wndPtr->parent == GetDesktopWindow())
2000 WIN_ReleasePtr( wndPtr );
2001 return (ULONG_PTR)WIN_SetOwner( hwnd, (HWND)newval );
2003 else
2005 WIN_ReleasePtr( wndPtr );
2006 return (ULONG_PTR)SetParent( hwnd, (HWND)newval );
2008 case GWLP_WNDPROC:
2010 WNDPROC proc;
2011 UINT old_flags = wndPtr->flags;
2012 retval = WIN_GetWindowLong( hwnd, offset, size, unicode );
2013 if (unicode) proc = WINPROC_AllocProc( NULL, (WNDPROC)newval );
2014 else proc = WINPROC_AllocProc( (WNDPROC)newval, NULL );
2015 if (proc) wndPtr->winproc = proc;
2016 if (WINPROC_IsUnicode( proc, unicode )) wndPtr->flags |= WIN_ISUNICODE;
2017 else wndPtr->flags &= ~WIN_ISUNICODE;
2018 if (!((old_flags ^ wndPtr->flags) & WIN_ISUNICODE))
2020 WIN_ReleasePtr( wndPtr );
2021 return retval;
2023 /* update is_unicode flag on the server side */
2024 break;
2026 case GWLP_ID:
2027 case GWLP_HINSTANCE:
2028 case GWLP_USERDATA:
2029 break;
2030 case DWLP_DLGPROC:
2031 if ((wndPtr->cbWndExtra - sizeof(LONG_PTR) >= DWLP_DLGPROC) &&
2032 (size == sizeof(LONG_PTR)) && (wndPtr->flags & WIN_ISDIALOG))
2034 WNDPROC *ptr = (WNDPROC *)((char *)wndPtr->wExtra + DWLP_DLGPROC);
2035 retval = (ULONG_PTR)WINPROC_GetProc( *ptr, unicode );
2036 if (unicode) *ptr = WINPROC_AllocProc( NULL, (WNDPROC)newval );
2037 else *ptr = WINPROC_AllocProc( (WNDPROC)newval, NULL );
2038 WIN_ReleasePtr( wndPtr );
2039 return retval;
2041 /* fall through */
2042 default:
2043 if (offset < 0 || offset > (int)(wndPtr->cbWndExtra - size))
2045 WARN("Invalid offset %d\n", offset );
2046 WIN_ReleasePtr( wndPtr );
2047 SetLastError( ERROR_INVALID_INDEX );
2048 return 0;
2050 else if (get_win_data( (char *)wndPtr->wExtra + offset, size ) == newval)
2052 /* already set to the same value */
2053 WIN_ReleasePtr( wndPtr );
2054 return newval;
2056 break;
2059 SERVER_START_REQ( set_window_info )
2061 req->handle = hwnd;
2062 req->extra_offset = -1;
2063 switch(offset)
2065 case GWL_STYLE:
2066 req->flags = SET_WIN_STYLE;
2067 req->style = newval;
2068 break;
2069 case GWL_EXSTYLE:
2070 req->flags = SET_WIN_EXSTYLE;
2071 /* WS_EX_TOPMOST can only be changed through SetWindowPos */
2072 newval = (newval & ~WS_EX_TOPMOST) | (wndPtr->dwExStyle & WS_EX_TOPMOST);
2073 req->ex_style = newval;
2074 break;
2075 case GWLP_ID:
2076 req->flags = SET_WIN_ID;
2077 req->id = newval;
2078 break;
2079 case GWLP_HINSTANCE:
2080 req->flags = SET_WIN_INSTANCE;
2081 req->instance = (void *)newval;
2082 break;
2083 case GWLP_WNDPROC:
2084 req->flags = SET_WIN_UNICODE;
2085 req->is_unicode = (wndPtr->flags & WIN_ISUNICODE) != 0;
2086 break;
2087 case GWLP_USERDATA:
2088 req->flags = SET_WIN_USERDATA;
2089 req->user_data = newval;
2090 break;
2091 default:
2092 req->flags = SET_WIN_EXTRA;
2093 req->extra_offset = offset;
2094 req->extra_size = size;
2095 set_win_data( &req->extra_value, newval, size );
2097 if ((ok = !wine_server_call_err( req )))
2099 switch(offset)
2101 case GWL_STYLE:
2102 wndPtr->dwStyle = newval;
2103 retval = reply->old_style;
2104 break;
2105 case GWL_EXSTYLE:
2106 wndPtr->dwExStyle = newval;
2107 retval = reply->old_ex_style;
2108 break;
2109 case GWLP_ID:
2110 wndPtr->wIDmenu = newval;
2111 retval = reply->old_id;
2112 break;
2113 case GWLP_HINSTANCE:
2114 wndPtr->hInstance = (HINSTANCE)newval;
2115 retval = (ULONG_PTR)reply->old_instance;
2116 break;
2117 case GWLP_WNDPROC:
2118 break;
2119 case GWLP_USERDATA:
2120 wndPtr->userdata = newval;
2121 retval = reply->old_user_data;
2122 break;
2123 default:
2124 retval = get_win_data( (char *)wndPtr->wExtra + offset, size );
2125 set_win_data( (char *)wndPtr->wExtra + offset, newval, size );
2126 break;
2130 SERVER_END_REQ;
2131 WIN_ReleasePtr( wndPtr );
2133 if (!ok) return 0;
2135 if (offset == GWL_STYLE || offset == GWL_EXSTYLE)
2137 USER_Driver->pSetWindowStyle( hwnd, offset, &style );
2138 SendMessageW( hwnd, WM_STYLECHANGED, offset, (LPARAM)&style );
2141 return retval;
2145 /**********************************************************************
2146 * GetWindowLong (USER.135)
2148 LONG WINAPI GetWindowLong16( HWND16 hwnd, INT16 offset )
2150 WND *wndPtr;
2151 LONG_PTR retvalue;
2152 BOOL is_winproc = (offset == GWLP_WNDPROC);
2154 if (offset >= 0)
2156 if (!(wndPtr = WIN_GetPtr( WIN_Handle32(hwnd) )))
2158 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2159 return 0;
2161 if (wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
2163 if (offset > (int)(wndPtr->cbWndExtra - sizeof(LONG)))
2166 * Some programs try to access last element from 16 bit
2167 * code using illegal offset value. Hopefully this is
2168 * what those programs really expect.
2170 if (wndPtr->cbWndExtra >= 4 && offset == wndPtr->cbWndExtra - sizeof(WORD))
2172 INT offset2 = wndPtr->cbWndExtra - sizeof(LONG);
2173 ERR( "- replaced invalid offset %d with %d\n", offset, offset2 );
2174 offset = offset2;
2176 else
2178 WARN("Invalid offset %d\n", offset );
2179 WIN_ReleasePtr( wndPtr );
2180 SetLastError( ERROR_INVALID_INDEX );
2181 return 0;
2184 is_winproc = ((offset == DWLP_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG));
2185 WIN_ReleasePtr( wndPtr );
2188 retvalue = GetWindowLongA( WIN_Handle32(hwnd), offset );
2189 if (is_winproc) retvalue = (LONG_PTR)WINPROC_GetProc16( (WNDPROC)retvalue, FALSE );
2190 return retvalue;
2194 /**********************************************************************
2195 * GetWindowWord (USER32.@)
2197 WORD WINAPI GetWindowWord( HWND hwnd, INT offset )
2199 switch(offset)
2201 case GWLP_ID:
2202 case GWLP_HINSTANCE:
2203 case GWLP_HWNDPARENT:
2204 break;
2205 default:
2206 if (offset < 0)
2208 WARN("Invalid offset %d\n", offset );
2209 SetLastError( ERROR_INVALID_INDEX );
2210 return 0;
2212 break;
2214 return WIN_GetWindowLong( hwnd, offset, sizeof(WORD), FALSE );
2218 /**********************************************************************
2219 * GetWindowLongA (USER32.@)
2221 LONG WINAPI GetWindowLongA( HWND hwnd, INT offset )
2223 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG), FALSE );
2227 /**********************************************************************
2228 * GetWindowLongW (USER32.@)
2230 LONG WINAPI GetWindowLongW( HWND hwnd, INT offset )
2232 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG), TRUE );
2236 /**********************************************************************
2237 * SetWindowLong (USER.136)
2239 LONG WINAPI SetWindowLong16( HWND16 hwnd, INT16 offset, LONG newval )
2241 WND *wndPtr;
2242 BOOL is_winproc = (offset == GWLP_WNDPROC);
2244 if (offset == DWLP_DLGPROC)
2246 if (!(wndPtr = WIN_GetPtr( WIN_Handle32(hwnd) )))
2248 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2249 return 0;
2251 if (wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
2253 is_winproc = ((wndPtr->cbWndExtra - sizeof(LONG_PTR) >= DWLP_DLGPROC) &&
2254 (wndPtr->flags & WIN_ISDIALOG));
2255 WIN_ReleasePtr( wndPtr );
2259 if (is_winproc)
2261 WNDPROC new_proc = WINPROC_AllocProc16( (WNDPROC16)newval );
2262 WNDPROC old_proc = (WNDPROC)SetWindowLongPtrA( WIN_Handle32(hwnd), offset, (LONG_PTR)new_proc );
2263 return (LONG)WINPROC_GetProc16( old_proc, FALSE );
2265 else return SetWindowLongA( WIN_Handle32(hwnd), offset, newval );
2269 /**********************************************************************
2270 * SetWindowWord (USER32.@)
2272 WORD WINAPI SetWindowWord( HWND hwnd, INT offset, WORD newval )
2274 switch(offset)
2276 case GWLP_ID:
2277 case GWLP_HINSTANCE:
2278 case GWLP_HWNDPARENT:
2279 break;
2280 default:
2281 if (offset < 0)
2283 WARN("Invalid offset %d\n", offset );
2284 SetLastError( ERROR_INVALID_INDEX );
2285 return 0;
2287 break;
2289 return WIN_SetWindowLong( hwnd, offset, sizeof(WORD), newval, FALSE );
2293 /**********************************************************************
2294 * SetWindowLongA (USER32.@)
2296 * See SetWindowLongW.
2298 LONG WINAPI SetWindowLongA( HWND hwnd, INT offset, LONG newval )
2300 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG), newval, FALSE );
2304 /**********************************************************************
2305 * SetWindowLongW (USER32.@) Set window attribute
2307 * SetWindowLong() alters one of a window's attributes or sets a 32-bit (long)
2308 * value in a window's extra memory.
2310 * The _hwnd_ parameter specifies the window. is the handle to a
2311 * window that has extra memory. The _newval_ parameter contains the
2312 * new attribute or extra memory value. If positive, the _offset_
2313 * parameter is the byte-addressed location in the window's extra
2314 * memory to set. If negative, _offset_ specifies the window
2315 * attribute to set, and should be one of the following values:
2317 * GWL_EXSTYLE The window's extended window style
2319 * GWL_STYLE The window's window style.
2321 * GWLP_WNDPROC Pointer to the window's window procedure.
2323 * GWLP_HINSTANCE The window's pplication instance handle.
2325 * GWLP_ID The window's identifier.
2327 * GWLP_USERDATA The window's user-specified data.
2329 * If the window is a dialog box, the _offset_ parameter can be one of
2330 * the following values:
2332 * DWLP_DLGPROC The address of the window's dialog box procedure.
2334 * DWLP_MSGRESULT The return value of a message
2335 * that the dialog box procedure processed.
2337 * DWLP_USER Application specific information.
2339 * RETURNS
2341 * If successful, returns the previous value located at _offset_. Otherwise,
2342 * returns 0.
2344 * NOTES
2346 * Extra memory for a window class is specified by a nonzero cbWndExtra
2347 * parameter of the WNDCLASS structure passed to RegisterClass() at the
2348 * time of class creation.
2350 * Using GWL_WNDPROC to set a new window procedure effectively creates
2351 * a window subclass. Use CallWindowProc() in the new windows procedure
2352 * to pass messages to the superclass's window procedure.
2354 * The user data is reserved for use by the application which created
2355 * the window.
2357 * Do not use GWL_STYLE to change the window's WS_DISABLED style;
2358 * instead, call the EnableWindow() function to change the window's
2359 * disabled state.
2361 * Do not use GWL_HWNDPARENT to reset the window's parent, use
2362 * SetParent() instead.
2364 * Win95:
2365 * When offset is GWL_STYLE and the calling app's ver is 4.0,
2366 * it sends WM_STYLECHANGING before changing the settings
2367 * and WM_STYLECHANGED afterwards.
2368 * App ver 4.0 can't use SetWindowLong to change WS_EX_TOPMOST.
2370 LONG WINAPI SetWindowLongW(
2371 HWND hwnd, /* [in] window to alter */
2372 INT offset, /* [in] offset, in bytes, of location to alter */
2373 LONG newval /* [in] new value of location */
2375 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG), newval, TRUE );
2379 /*******************************************************************
2380 * GetWindowTextA (USER32.@)
2382 INT WINAPI GetWindowTextA( HWND hwnd, LPSTR lpString, INT nMaxCount )
2384 WCHAR *buffer;
2386 if (!lpString) return 0;
2388 if (WIN_IsCurrentProcess( hwnd ))
2389 return (INT)SendMessageA( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2391 /* when window belongs to other process, don't send a message */
2392 if (nMaxCount <= 0) return 0;
2393 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, nMaxCount * sizeof(WCHAR) ))) return 0;
2394 get_server_window_text( hwnd, buffer, nMaxCount );
2395 if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, lpString, nMaxCount, NULL, NULL ))
2396 lpString[nMaxCount-1] = 0;
2397 HeapFree( GetProcessHeap(), 0, buffer );
2398 return strlen(lpString);
2402 /*******************************************************************
2403 * InternalGetWindowText (USER32.@)
2405 INT WINAPI InternalGetWindowText(HWND hwnd,LPWSTR lpString,INT nMaxCount )
2407 WND *win;
2409 if (nMaxCount <= 0) return 0;
2410 if (!(win = WIN_GetPtr( hwnd ))) return 0;
2411 if (win == WND_DESKTOP) lpString[0] = 0;
2412 else if (win != WND_OTHER_PROCESS)
2414 if (win->text) lstrcpynW( lpString, win->text, nMaxCount );
2415 else lpString[0] = 0;
2416 WIN_ReleasePtr( win );
2418 else
2420 get_server_window_text( hwnd, lpString, nMaxCount );
2422 return strlenW(lpString);
2426 /*******************************************************************
2427 * GetWindowTextW (USER32.@)
2429 INT WINAPI GetWindowTextW( HWND hwnd, LPWSTR lpString, INT nMaxCount )
2431 if (!lpString) return 0;
2433 if (WIN_IsCurrentProcess( hwnd ))
2434 return (INT)SendMessageW( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2436 /* when window belongs to other process, don't send a message */
2437 if (nMaxCount <= 0) return 0;
2438 get_server_window_text( hwnd, lpString, nMaxCount );
2439 return strlenW(lpString);
2443 /*******************************************************************
2444 * SetWindowTextA (USER32.@)
2445 * SetWindowText (USER32.@)
2447 BOOL WINAPI SetWindowTextA( HWND hwnd, LPCSTR lpString )
2449 if (is_broadcast(hwnd))
2451 SetLastError( ERROR_INVALID_PARAMETER );
2452 return FALSE;
2454 if (!WIN_IsCurrentProcess( hwnd ))
2455 WARN( "setting text %s of other process window %p should not use SendMessage\n",
2456 debugstr_a(lpString), hwnd );
2457 return (BOOL)SendMessageA( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2461 /*******************************************************************
2462 * SetWindowTextW (USER32.@)
2464 BOOL WINAPI SetWindowTextW( HWND hwnd, LPCWSTR lpString )
2466 if (is_broadcast(hwnd))
2468 SetLastError( ERROR_INVALID_PARAMETER );
2469 return FALSE;
2471 if (!WIN_IsCurrentProcess( hwnd ))
2472 WARN( "setting text %s of other process window %p should not use SendMessage\n",
2473 debugstr_w(lpString), hwnd );
2474 return (BOOL)SendMessageW( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2478 /*******************************************************************
2479 * GetWindowTextLengthA (USER32.@)
2481 INT WINAPI GetWindowTextLengthA( HWND hwnd )
2483 return SendMessageA( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2486 /*******************************************************************
2487 * GetWindowTextLengthW (USER32.@)
2489 INT WINAPI GetWindowTextLengthW( HWND hwnd )
2491 return SendMessageW( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2495 /*******************************************************************
2496 * IsWindow (USER32.@)
2498 BOOL WINAPI IsWindow( HWND hwnd )
2500 WND *ptr;
2501 BOOL ret;
2503 if (!(ptr = WIN_GetPtr( hwnd ))) return FALSE;
2504 if (ptr == WND_DESKTOP) return TRUE;
2506 if (ptr != WND_OTHER_PROCESS)
2508 WIN_ReleasePtr( ptr );
2509 return TRUE;
2512 /* check other processes */
2513 SERVER_START_REQ( get_window_info )
2515 req->handle = hwnd;
2516 ret = !wine_server_call_err( req );
2518 SERVER_END_REQ;
2519 return ret;
2523 /***********************************************************************
2524 * GetWindowThreadProcessId (USER32.@)
2526 DWORD WINAPI GetWindowThreadProcessId( HWND hwnd, LPDWORD process )
2528 WND *ptr;
2529 DWORD tid = 0;
2531 if (!(ptr = WIN_GetPtr( hwnd )))
2533 SetLastError( ERROR_INVALID_WINDOW_HANDLE);
2534 return 0;
2537 if (ptr != WND_OTHER_PROCESS && ptr != WND_DESKTOP)
2539 /* got a valid window */
2540 tid = ptr->tid;
2541 if (process) *process = GetCurrentProcessId();
2542 WIN_ReleasePtr( ptr );
2543 return tid;
2546 /* check other processes */
2547 SERVER_START_REQ( get_window_info )
2549 req->handle = hwnd;
2550 if (!wine_server_call_err( req ))
2552 tid = (DWORD)reply->tid;
2553 if (process) *process = (DWORD)reply->pid;
2556 SERVER_END_REQ;
2557 return tid;
2561 /*****************************************************************
2562 * GetParent (USER32.@)
2564 HWND WINAPI GetParent( HWND hwnd )
2566 WND *wndPtr;
2567 HWND retvalue = 0;
2569 if (!(wndPtr = WIN_GetPtr( hwnd )))
2571 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2572 return 0;
2574 if (wndPtr == WND_DESKTOP) return 0;
2575 if (wndPtr == WND_OTHER_PROCESS)
2577 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
2578 if (style & (WS_POPUP | WS_CHILD))
2580 SERVER_START_REQ( get_window_tree )
2582 req->handle = hwnd;
2583 if (!wine_server_call_err( req ))
2585 if (style & WS_POPUP) retvalue = reply->owner;
2586 else if (style & WS_CHILD) retvalue = reply->parent;
2589 SERVER_END_REQ;
2592 else
2594 if (wndPtr->dwStyle & WS_POPUP) retvalue = wndPtr->owner;
2595 else if (wndPtr->dwStyle & WS_CHILD) retvalue = wndPtr->parent;
2596 WIN_ReleasePtr( wndPtr );
2598 return retvalue;
2602 /*****************************************************************
2603 * GetAncestor (USER32.@)
2605 HWND WINAPI GetAncestor( HWND hwnd, UINT type )
2607 WND *win;
2608 HWND *list, ret = 0;
2610 switch(type)
2612 case GA_PARENT:
2613 if (!(win = WIN_GetPtr( hwnd )))
2615 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2616 return 0;
2618 if (win == WND_DESKTOP) return 0;
2619 if (win != WND_OTHER_PROCESS)
2621 ret = win->parent;
2622 WIN_ReleasePtr( win );
2624 else /* need to query the server */
2626 SERVER_START_REQ( get_window_tree )
2628 req->handle = hwnd;
2629 if (!wine_server_call_err( req )) ret = reply->parent;
2631 SERVER_END_REQ;
2633 break;
2635 case GA_ROOT:
2636 if (!(list = list_window_parents( hwnd ))) return 0;
2638 if (!list[0] || !list[1]) ret = WIN_GetFullHandle( hwnd ); /* top-level window */
2639 else
2641 int count = 2;
2642 while (list[count]) count++;
2643 ret = list[count - 2]; /* get the one before the desktop */
2645 HeapFree( GetProcessHeap(), 0, list );
2646 break;
2648 case GA_ROOTOWNER:
2649 if (is_desktop_window( hwnd )) return 0;
2650 ret = WIN_GetFullHandle( hwnd );
2651 for (;;)
2653 HWND parent = GetParent( ret );
2654 if (!parent) break;
2655 ret = parent;
2657 break;
2659 return ret;
2663 /*****************************************************************
2664 * SetParent (USER32.@)
2666 HWND WINAPI SetParent( HWND hwnd, HWND parent )
2668 HWND full_handle;
2669 HWND old_parent = 0;
2670 BOOL was_visible;
2671 WND *wndPtr;
2672 BOOL ret;
2674 if (is_broadcast(hwnd) || is_broadcast(parent))
2676 SetLastError(ERROR_INVALID_PARAMETER);
2677 return 0;
2680 if (!parent) parent = GetDesktopWindow();
2681 else if (parent == HWND_MESSAGE) parent = get_hwnd_message_parent();
2682 else parent = WIN_GetFullHandle( parent );
2684 if (!IsWindow( parent ))
2686 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2687 return 0;
2690 /* Some applications try to set a child as a parent */
2691 if (IsChild(hwnd, parent))
2693 SetLastError( ERROR_INVALID_PARAMETER );
2694 return 0;
2697 if (!(full_handle = WIN_IsCurrentThread( hwnd )))
2698 return (HWND)SendMessageW( hwnd, WM_WINE_SETPARENT, (WPARAM)parent, 0 );
2700 /* Windows hides the window first, then shows it again
2701 * including the WM_SHOWWINDOW messages and all */
2702 was_visible = ShowWindow( hwnd, SW_HIDE );
2704 wndPtr = WIN_GetPtr( hwnd );
2705 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return 0;
2707 SERVER_START_REQ( set_parent )
2709 req->handle = hwnd;
2710 req->parent = parent;
2711 if ((ret = !wine_server_call( req )))
2713 old_parent = reply->old_parent;
2714 wndPtr->parent = parent = reply->full_parent;
2718 SERVER_END_REQ;
2719 WIN_ReleasePtr( wndPtr );
2720 if (!ret) return 0;
2722 USER_Driver->pSetParent( full_handle, parent, old_parent );
2724 /* SetParent additionally needs to make hwnd the topmost window
2725 in the x-order and send the expected WM_WINDOWPOSCHANGING and
2726 WM_WINDOWPOSCHANGED notification messages.
2728 SetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0,
2729 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | (was_visible ? SWP_SHOWWINDOW : 0) );
2730 /* FIXME: a WM_MOVE is also generated (in the DefWindowProc handler
2731 * for WM_WINDOWPOSCHANGED) in Windows, should probably remove SWP_NOMOVE */
2733 return old_parent;
2737 /*******************************************************************
2738 * IsChild (USER32.@)
2740 BOOL WINAPI IsChild( HWND parent, HWND child )
2742 HWND *list = list_window_parents( child );
2743 int i;
2744 BOOL ret;
2746 if (!list) return FALSE;
2747 parent = WIN_GetFullHandle( parent );
2748 for (i = 0; list[i]; i++) if (list[i] == parent) break;
2749 ret = list[i] && list[i+1];
2750 HeapFree( GetProcessHeap(), 0, list );
2751 return ret;
2755 /***********************************************************************
2756 * IsWindowVisible (USER32.@)
2758 BOOL WINAPI IsWindowVisible( HWND hwnd )
2760 HWND *list;
2761 BOOL retval = TRUE;
2762 int i;
2764 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)) return FALSE;
2765 if (!(list = list_window_parents( hwnd ))) return TRUE;
2766 if (list[0])
2768 for (i = 0; list[i+1]; i++)
2769 if (!(GetWindowLongW( list[i], GWL_STYLE ) & WS_VISIBLE)) break;
2770 retval = !list[i+1] && (list[i] == GetDesktopWindow()); /* top message window isn't visible */
2772 HeapFree( GetProcessHeap(), 0, list );
2773 return retval;
2777 /***********************************************************************
2778 * WIN_IsWindowDrawable
2780 * hwnd is drawable when it is visible, all parents are not
2781 * minimized, and it is itself not minimized unless we are
2782 * trying to draw its default class icon.
2784 BOOL WIN_IsWindowDrawable( HWND hwnd, BOOL icon )
2786 HWND *list;
2787 BOOL retval = TRUE;
2788 int i;
2789 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
2791 if (!(style & WS_VISIBLE)) return FALSE;
2792 if ((style & WS_MINIMIZE) && icon && GetClassLongPtrW( hwnd, GCLP_HICON )) return FALSE;
2794 if (!(list = list_window_parents( hwnd ))) return TRUE;
2795 if (list[0])
2797 for (i = 0; list[i+1]; i++)
2798 if ((GetWindowLongW( list[i], GWL_STYLE ) & (WS_VISIBLE|WS_MINIMIZE)) != WS_VISIBLE)
2799 break;
2800 retval = !list[i+1] && (list[i] == GetDesktopWindow()); /* top message window isn't visible */
2802 HeapFree( GetProcessHeap(), 0, list );
2803 return retval;
2807 /*******************************************************************
2808 * GetTopWindow (USER32.@)
2810 HWND WINAPI GetTopWindow( HWND hwnd )
2812 if (!hwnd) hwnd = GetDesktopWindow();
2813 return GetWindow( hwnd, GW_CHILD );
2817 /*******************************************************************
2818 * GetWindow (USER32.@)
2820 HWND WINAPI GetWindow( HWND hwnd, UINT rel )
2822 HWND retval = 0;
2824 if (rel == GW_OWNER) /* this one may be available locally */
2826 WND *wndPtr = WIN_GetPtr( hwnd );
2827 if (!wndPtr)
2829 SetLastError( ERROR_INVALID_HANDLE );
2830 return 0;
2832 if (wndPtr == WND_DESKTOP) return 0;
2833 if (wndPtr != WND_OTHER_PROCESS)
2835 retval = wndPtr->owner;
2836 WIN_ReleasePtr( wndPtr );
2837 return retval;
2839 /* else fall through to server call */
2842 SERVER_START_REQ( get_window_tree )
2844 req->handle = hwnd;
2845 if (!wine_server_call_err( req ))
2847 switch(rel)
2849 case GW_HWNDFIRST:
2850 retval = reply->first_sibling;
2851 break;
2852 case GW_HWNDLAST:
2853 retval = reply->last_sibling;
2854 break;
2855 case GW_HWNDNEXT:
2856 retval = reply->next_sibling;
2857 break;
2858 case GW_HWNDPREV:
2859 retval = reply->prev_sibling;
2860 break;
2861 case GW_OWNER:
2862 retval = reply->owner;
2863 break;
2864 case GW_CHILD:
2865 retval = reply->first_child;
2866 break;
2870 SERVER_END_REQ;
2871 return retval;
2875 /*******************************************************************
2876 * ShowOwnedPopups (USER32.@)
2878 BOOL WINAPI ShowOwnedPopups( HWND owner, BOOL fShow )
2880 int count = 0;
2881 WND *pWnd;
2882 HWND *win_array = WIN_ListChildren( GetDesktopWindow() );
2884 if (!win_array) return TRUE;
2886 while (win_array[count]) count++;
2887 while (--count >= 0)
2889 if (GetWindow( win_array[count], GW_OWNER ) != owner) continue;
2890 if (!(pWnd = WIN_GetPtr( win_array[count] ))) continue;
2891 if (pWnd == WND_OTHER_PROCESS) continue;
2892 if (fShow)
2894 if (pWnd->flags & WIN_NEEDS_SHOW_OWNEDPOPUP)
2896 WIN_ReleasePtr( pWnd );
2897 /* In Windows, ShowOwnedPopups(TRUE) generates
2898 * WM_SHOWWINDOW messages with SW_PARENTOPENING,
2899 * regardless of the state of the owner
2901 SendMessageW(win_array[count], WM_SHOWWINDOW, SW_SHOWNORMAL, SW_PARENTOPENING);
2902 continue;
2905 else
2907 if (pWnd->dwStyle & WS_VISIBLE)
2909 WIN_ReleasePtr( pWnd );
2910 /* In Windows, ShowOwnedPopups(FALSE) generates
2911 * WM_SHOWWINDOW messages with SW_PARENTCLOSING,
2912 * regardless of the state of the owner
2914 SendMessageW(win_array[count], WM_SHOWWINDOW, SW_HIDE, SW_PARENTCLOSING);
2915 continue;
2918 WIN_ReleasePtr( pWnd );
2920 HeapFree( GetProcessHeap(), 0, win_array );
2921 return TRUE;
2925 /*******************************************************************
2926 * GetLastActivePopup (USER32.@)
2928 HWND WINAPI GetLastActivePopup( HWND hwnd )
2930 HWND retval = hwnd;
2932 SERVER_START_REQ( get_window_info )
2934 req->handle = hwnd;
2935 if (!wine_server_call_err( req )) retval = reply->last_active;
2937 SERVER_END_REQ;
2938 return retval;
2942 /*******************************************************************
2943 * WIN_ListChildren
2945 * Build an array of the children of a given window. The array must be
2946 * freed with HeapFree. Returns NULL when no windows are found.
2948 HWND *WIN_ListChildren( HWND hwnd )
2950 if (!hwnd)
2952 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2953 return NULL;
2955 return list_window_children( 0, hwnd, NULL, 0 );
2959 /*******************************************************************
2960 * EnumWindows (USER32.@)
2962 BOOL WINAPI EnumWindows( WNDENUMPROC lpEnumFunc, LPARAM lParam )
2964 HWND *list;
2965 BOOL ret = TRUE;
2966 int i;
2968 USER_CheckNotLock();
2970 /* We have to build a list of all windows first, to avoid */
2971 /* unpleasant side-effects, for instance if the callback */
2972 /* function changes the Z-order of the windows. */
2974 if (!(list = WIN_ListChildren( GetDesktopWindow() ))) return TRUE;
2976 /* Now call the callback function for every window */
2978 for (i = 0; list[i]; i++)
2980 /* Make sure that the window still exists */
2981 if (!IsWindow( list[i] )) continue;
2982 if (!(ret = lpEnumFunc( list[i], lParam ))) break;
2984 HeapFree( GetProcessHeap(), 0, list );
2985 return ret;
2989 /**********************************************************************
2990 * EnumThreadWindows (USER32.@)
2992 BOOL WINAPI EnumThreadWindows( DWORD id, WNDENUMPROC func, LPARAM lParam )
2994 HWND *list;
2995 int i;
2997 USER_CheckNotLock();
2999 if (!(list = list_window_children( 0, GetDesktopWindow(), NULL, id ))) return TRUE;
3001 /* Now call the callback function for every window */
3003 for (i = 0; list[i]; i++)
3004 if (!func( list[i], lParam )) break;
3005 HeapFree( GetProcessHeap(), 0, list );
3006 return TRUE;
3010 /***********************************************************************
3011 * EnumDesktopWindows (USER32.@)
3013 BOOL WINAPI EnumDesktopWindows( HDESK desktop, WNDENUMPROC func, LPARAM lparam )
3015 HWND *list;
3016 int i;
3018 USER_CheckNotLock();
3020 if (!(list = list_window_children( desktop, 0, NULL, 0 ))) return TRUE;
3022 for (i = 0; list[i]; i++)
3023 if (!func( list[i], lparam )) break;
3024 HeapFree( GetProcessHeap(), 0, list );
3025 return TRUE;
3029 /**********************************************************************
3030 * WIN_EnumChildWindows
3032 * Helper function for EnumChildWindows().
3034 static BOOL WIN_EnumChildWindows( HWND *list, WNDENUMPROC func, LPARAM lParam )
3036 HWND *childList;
3037 BOOL ret = FALSE;
3039 for ( ; *list; list++)
3041 /* Make sure that the window still exists */
3042 if (!IsWindow( *list )) continue;
3043 /* Build children list first */
3044 childList = WIN_ListChildren( *list );
3046 ret = func( *list, lParam );
3048 if (childList)
3050 if (ret) ret = WIN_EnumChildWindows( childList, func, lParam );
3051 HeapFree( GetProcessHeap(), 0, childList );
3053 if (!ret) return FALSE;
3055 return TRUE;
3059 /**********************************************************************
3060 * EnumChildWindows (USER32.@)
3062 BOOL WINAPI EnumChildWindows( HWND parent, WNDENUMPROC func, LPARAM lParam )
3064 HWND *list;
3065 BOOL ret;
3067 USER_CheckNotLock();
3069 if (!(list = WIN_ListChildren( parent ))) return FALSE;
3070 ret = WIN_EnumChildWindows( list, func, lParam );
3071 HeapFree( GetProcessHeap(), 0, list );
3072 return ret;
3076 /*******************************************************************
3077 * AnyPopup (USER.52)
3079 BOOL16 WINAPI AnyPopup16(void)
3081 return AnyPopup();
3085 /*******************************************************************
3086 * AnyPopup (USER32.@)
3088 BOOL WINAPI AnyPopup(void)
3090 int i;
3091 BOOL retvalue;
3092 HWND *list = WIN_ListChildren( GetDesktopWindow() );
3094 if (!list) return FALSE;
3095 for (i = 0; list[i]; i++)
3097 if (IsWindowVisible( list[i] ) && GetWindow( list[i], GW_OWNER )) break;
3099 retvalue = (list[i] != 0);
3100 HeapFree( GetProcessHeap(), 0, list );
3101 return retvalue;
3105 /*******************************************************************
3106 * FlashWindow (USER32.@)
3108 BOOL WINAPI FlashWindow( HWND hWnd, BOOL bInvert )
3110 WND *wndPtr;
3112 TRACE("%p\n", hWnd);
3114 if (IsIconic( hWnd ))
3116 RedrawWindow( hWnd, 0, 0, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_FRAME );
3118 wndPtr = WIN_GetPtr(hWnd);
3119 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return FALSE;
3120 if (bInvert && !(wndPtr->flags & WIN_NCACTIVATED))
3122 wndPtr->flags |= WIN_NCACTIVATED;
3124 else
3126 wndPtr->flags &= ~WIN_NCACTIVATED;
3128 WIN_ReleasePtr( wndPtr );
3129 return TRUE;
3131 else
3133 WPARAM wparam;
3135 wndPtr = WIN_GetPtr(hWnd);
3136 if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return FALSE;
3137 hWnd = wndPtr->hwndSelf; /* make it a full handle */
3139 if (bInvert) wparam = !(wndPtr->flags & WIN_NCACTIVATED);
3140 else wparam = (hWnd == GetForegroundWindow());
3142 WIN_ReleasePtr( wndPtr );
3143 SendMessageW( hWnd, WM_NCACTIVATE, wparam, (LPARAM)0 );
3144 return wparam;
3148 /*******************************************************************
3149 * FlashWindowEx (USER32.@)
3151 BOOL WINAPI FlashWindowEx( PFLASHWINFO pfwi )
3153 FIXME("%p\n", pfwi);
3154 return TRUE;
3157 /*******************************************************************
3158 * GetWindowContextHelpId (USER32.@)
3160 DWORD WINAPI GetWindowContextHelpId( HWND hwnd )
3162 DWORD retval;
3163 WND *wnd = WIN_GetPtr( hwnd );
3164 if (!wnd || wnd == WND_DESKTOP) return 0;
3165 if (wnd == WND_OTHER_PROCESS)
3167 if (IsWindow( hwnd )) FIXME( "not supported on other process window %p\n", hwnd );
3168 return 0;
3170 retval = wnd->helpContext;
3171 WIN_ReleasePtr( wnd );
3172 return retval;
3176 /*******************************************************************
3177 * SetWindowContextHelpId (USER32.@)
3179 BOOL WINAPI SetWindowContextHelpId( HWND hwnd, DWORD id )
3181 WND *wnd = WIN_GetPtr( hwnd );
3182 if (!wnd || wnd == WND_DESKTOP) return FALSE;
3183 if (wnd == WND_OTHER_PROCESS)
3185 if (IsWindow( hwnd )) FIXME( "not supported on other process window %p\n", hwnd );
3186 return 0;
3188 wnd->helpContext = id;
3189 WIN_ReleasePtr( wnd );
3190 return TRUE;
3194 /*******************************************************************
3195 * DragDetect (USER32.@)
3197 BOOL WINAPI DragDetect( HWND hWnd, POINT pt )
3199 MSG msg;
3200 RECT rect;
3201 WORD wDragWidth = GetSystemMetrics(SM_CXDRAG);
3202 WORD wDragHeight= GetSystemMetrics(SM_CYDRAG);
3204 rect.left = pt.x - wDragWidth;
3205 rect.right = pt.x + wDragWidth;
3207 rect.top = pt.y - wDragHeight;
3208 rect.bottom = pt.y + wDragHeight;
3210 SetCapture(hWnd);
3212 while(1)
3214 while (PeekMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE ))
3216 if( msg.message == WM_LBUTTONUP )
3218 ReleaseCapture();
3219 return 0;
3221 if( msg.message == WM_MOUSEMOVE )
3223 POINT tmp;
3224 tmp.x = (short)LOWORD(msg.lParam);
3225 tmp.y = (short)HIWORD(msg.lParam);
3226 if( !PtInRect( &rect, tmp ))
3228 ReleaseCapture();
3229 return 1;
3233 WaitMessage();
3235 return 0;
3238 /******************************************************************************
3239 * GetWindowModuleFileNameA (USER32.@)
3241 UINT WINAPI GetWindowModuleFileNameA( HWND hwnd, LPSTR module, UINT size )
3243 WND *win;
3244 HINSTANCE hinst;
3246 TRACE( "%p, %p, %u\n", hwnd, module, size );
3248 win = WIN_GetPtr( hwnd );
3249 if (!win || win == WND_OTHER_PROCESS || win == WND_DESKTOP)
3251 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
3252 return 0;
3254 hinst = win->hInstance;
3255 WIN_ReleasePtr( win );
3257 return GetModuleFileNameA( hinst, module, size );
3260 /******************************************************************************
3261 * GetWindowModuleFileNameW (USER32.@)
3263 UINT WINAPI GetWindowModuleFileNameW( HWND hwnd, LPWSTR module, UINT size )
3265 WND *win;
3266 HINSTANCE hinst;
3268 TRACE( "%p, %p, %u\n", hwnd, module, size );
3270 win = WIN_GetPtr( hwnd );
3271 if (!win || win == WND_OTHER_PROCESS || win == WND_DESKTOP)
3273 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
3274 return 0;
3276 hinst = win->hInstance;
3277 WIN_ReleasePtr( win );
3279 return GetModuleFileNameW( hinst, module, size );
3282 /******************************************************************************
3283 * GetWindowInfo (USER32.@)
3285 * Note: tests show that Windows doesn't check cbSize of the structure.
3287 BOOL WINAPI GetWindowInfo( HWND hwnd, PWINDOWINFO pwi)
3289 if (!pwi) return FALSE;
3290 if (!IsWindow(hwnd)) return FALSE;
3292 GetWindowRect(hwnd, &pwi->rcWindow);
3293 GetClientRect(hwnd, &pwi->rcClient);
3294 /* translate to screen coordinates */
3295 MapWindowPoints(hwnd, 0, (LPPOINT)&pwi->rcClient, 2);
3297 pwi->dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
3298 pwi->dwExStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
3299 pwi->dwWindowStatus = ((GetActiveWindow() == hwnd) ? WS_ACTIVECAPTION : 0);
3301 pwi->cxWindowBorders = pwi->rcClient.left - pwi->rcWindow.left;
3302 pwi->cyWindowBorders = pwi->rcWindow.bottom - pwi->rcClient.bottom;
3304 pwi->atomWindowType = GetClassLongW( hwnd, GCW_ATOM );
3305 pwi->wCreatorVersion = 0x0400;
3307 return TRUE;
3310 /******************************************************************************
3311 * SwitchDesktop (USER32.@)
3313 * NOTES: Sets the current input or interactive desktop.
3315 BOOL WINAPI SwitchDesktop( HDESK hDesktop)
3317 FIXME("SwitchDesktop(hwnd %p) stub!\n", hDesktop);
3318 return TRUE;
3321 /*****************************************************************************
3322 * SetLayeredWindowAttributes (USER32.@)
3324 BOOL WINAPI SetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags )
3326 BOOL ret;
3328 TRACE("(%p,%08x,%d,%x): stub!\n", hwnd, key, alpha, flags);
3330 SERVER_START_REQ( set_window_layered_info )
3332 req->handle = hwnd;
3333 req->color_key = key;
3334 req->alpha = alpha;
3335 req->flags = flags;
3336 ret = !wine_server_call_err( req );
3338 SERVER_END_REQ;
3340 if (ret) USER_Driver->pSetLayeredWindowAttributes( hwnd, key, alpha, flags );
3342 return ret;
3346 /*****************************************************************************
3347 * GetLayeredWindowAttributes (USER32.@)
3349 BOOL WINAPI GetLayeredWindowAttributes( HWND hwnd, COLORREF *key, BYTE *alpha, DWORD *flags )
3351 BOOL ret;
3353 SERVER_START_REQ( get_window_layered_info )
3355 req->handle = hwnd;
3356 if ((ret = !wine_server_call_err( req )))
3358 if (key) *key = reply->color_key;
3359 if (alpha) *alpha = reply->alpha;
3360 if (flags) *flags = reply->flags;
3363 SERVER_END_REQ;
3365 return ret;
3368 /*****************************************************************************
3369 * UpdateLayeredWindow (USER32.@)
3371 BOOL WINAPI UpdateLayeredWindow( HWND hwnd, HDC hdcDst, POINT *pptDst, SIZE *psize,
3372 HDC hdcSrc, POINT *pptSrc, COLORREF crKey, BLENDFUNCTION *pblend,
3373 DWORD dwFlags)
3375 static int once;
3376 if (!once)
3378 once = 1;
3379 FIXME("(%p,%p,%p,%p,%p,%p,0x%08x,%p,%d): stub!\n",
3380 hwnd, hdcDst, pptDst, psize, hdcSrc, pptSrc, crKey, pblend, dwFlags);
3382 return 0;
3385 /* 64bit versions */
3387 #ifdef GetWindowLongPtrW
3388 #undef GetWindowLongPtrW
3389 #endif
3391 #ifdef GetWindowLongPtrA
3392 #undef GetWindowLongPtrA
3393 #endif
3395 #ifdef SetWindowLongPtrW
3396 #undef SetWindowLongPtrW
3397 #endif
3399 #ifdef SetWindowLongPtrA
3400 #undef SetWindowLongPtrA
3401 #endif
3403 /*****************************************************************************
3404 * GetWindowLongPtrW (USER32.@)
3406 LONG_PTR WINAPI GetWindowLongPtrW( HWND hwnd, INT offset )
3408 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG_PTR), TRUE );
3411 /*****************************************************************************
3412 * GetWindowLongPtrA (USER32.@)
3414 LONG_PTR WINAPI GetWindowLongPtrA( HWND hwnd, INT offset )
3416 return WIN_GetWindowLong( hwnd, offset, sizeof(LONG_PTR), FALSE );
3419 /*****************************************************************************
3420 * SetWindowLongPtrW (USER32.@)
3422 LONG_PTR WINAPI SetWindowLongPtrW( HWND hwnd, INT offset, LONG_PTR newval )
3424 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG_PTR), newval, TRUE );
3427 /*****************************************************************************
3428 * SetWindowLongPtrA (USER32.@)
3430 LONG_PTR WINAPI SetWindowLongPtrA( HWND hwnd, INT offset, LONG_PTR newval )
3432 return WIN_SetWindowLong( hwnd, offset, sizeof(LONG_PTR), newval, FALSE );