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