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