?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Moved a couple of definitions from include/wine/obj_oleaut.h to
[wine/multimedia.git] / windows / win.c
blobbefcd168c6cbaa2ca11079f92f6c10cd4f030614
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 | WS_CHILD)) == WS_CAPTION )
1146 {
1147 if (cs->hMenu) SetMenu(hwnd, cs->hMenu);
1148 else
1149 {
1150 LPCSTR menuName = (LPCSTR)GetClassLongA( hwnd, GCL_MENUNAME );
1151 if (menuName)
1152 {
1153 if (HIWORD(cs->hInstance))
1154 cs->hMenu = LoadMenuA(cs->hInstance,menuName);
1155 else
1156 cs->hMenu = HMENU_32(LoadMenu16(HINSTANCE_16(cs->hInstance),menuName));
1157
1158 if (cs->hMenu) SetMenu( hwnd, cs->hMenu );
1159 }
1160 }
1161 }
1162 else SetWindowLongW( hwnd, GWL_ID, (UINT)cs->hMenu );
1163 WIN_ReleaseWndPtr( wndPtr );
1164
1165 if (!USER_Driver.pCreateWindow( hwnd, cs, unicode))
1166 {
1167 WIN_DestroyWindow( hwnd );
1168 return 0;
1169 }
1170
1171 /* Notify the parent window only */
1172
1173 send_parent_notify( hwnd, WM_CREATE );
1174 if (!IsWindow( hwnd )) return 0;
1175
1176 if (cs->style & WS_VISIBLE)
1177 {
1178 /* in case WS_VISIBLE got set in the meantime */
1179 if (!(wndPtr = WIN_GetPtr( hwnd ))) return 0;
1180 WIN_SetStyle( hwnd, wndPtr->dwStyle & ~WS_VISIBLE );
1181 WIN_ReleasePtr( wndPtr );
1182 ShowWindow( hwnd, sw );
1183 }
1184
1185 /* Call WH_SHELL hook */
1186
1187 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) && !GetWindow( hwnd, GW_OWNER ))
1188 HOOK_CallHooks( WH_SHELL, HSHELL_WINDOWCREATED, (WPARAM)hwnd, 0, TRUE );
1189
1190 TRACE("created window %p\n", hwnd);
1191 return hwnd;
1192 }
1193
1194
1195 /***********************************************************************
1196 * CreateWindow (USER.41)
1197 */
1198 HWND16 WINAPI CreateWindow16( LPCSTR className, LPCSTR windowName,
1199 DWORD style, INT16 x, INT16 y, INT16 width,
1200 INT16 height, HWND16 parent, HMENU16 menu,
1201 HINSTANCE16 instance, LPVOID data )
1202 {
1203 return CreateWindowEx16( 0, className, windowName, style,
1204 x, y, width, height, parent, menu, instance, data );
1205 }
1206
1207
1208 /***********************************************************************
1209 * CreateWindowEx (USER.452)
1210 */
1211 HWND16 WINAPI CreateWindowEx16( DWORD exStyle, LPCSTR className,
1212 LPCSTR windowName, DWORD style, INT16 x,
1213 INT16 y, INT16 width, INT16 height,
1214 HWND16 parent, HMENU16 menu,
1215 HINSTANCE16 instance, LPVOID data )
1216 {
1217 ATOM classAtom;
1218 CREATESTRUCTA cs;
1219 char buffer[256];
1220
1221 /* Find the class atom */
1222
1223 if (HIWORD(className))
1224 {
1225 if (!(classAtom = GlobalFindAtomA( className )))
1226 {
1227 ERR( "bad class name %s\n", debugstr_a(className) );
1228 return 0;
1229 }
1230 }
1231 else
1232 {
1233 classAtom = LOWORD(className);
1234 if (!GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) ))
1235 {
1236 ERR( "bad atom %x\n", classAtom);
1237 return 0;
1238 }
1239 className = buffer;
1240 }
1241
1242 /* Fix the coordinates */
1243
1244 cs.x = (x == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)x;
1245 cs.y = (y == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)y;
1246 cs.cx = (width == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)width;
1247 cs.cy = (height == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)height;
1248
1249 /* Create the window */
1250
1251 cs.lpCreateParams = data;
1252 cs.hInstance = HINSTANCE_32(instance);
1253 cs.hMenu = HMENU_32(menu);
1254 cs.hwndParent = WIN_Handle32( parent );
1255 cs.style = style;
1256 cs.lpszName = windowName;
1257 cs.lpszClass = className;
1258 cs.dwExStyle = exStyle;
1259
1260 return HWND_16( WIN_CreateWindowEx( &cs, classAtom, WIN_PROC_16 ));
1261 }
1262
1263
1264 /***********************************************************************
1265 * CreateWindowExA (USER32.@)
1266 */
1267 HWND WINAPI CreateWindowExA( DWORD exStyle, LPCSTR className,
1268 LPCSTR windowName, DWORD style, INT x,
1269 INT y, INT width, INT height,
1270 HWND parent, HMENU menu,
1271 HINSTANCE instance, LPVOID data )
1272 {
1273 ATOM classAtom;
1274 CREATESTRUCTA cs;
1275 char buffer[256];
1276
1277 if(!instance)
1278 instance=GetModuleHandleA(NULL);
1279
1280 if(exStyle & WS_EX_MDICHILD)
1281 return CreateMDIWindowA(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
1282
1283 /* Find the class atom */
1284
1285 if (HIWORD(className))
1286 {
1287 if (!(classAtom = GlobalFindAtomA( className )))
1288 {
1289 ERR( "bad class name %s\n", debugstr_a(className) );
1290 return 0;
1291 }
1292 }
1293 else
1294 {
1295 classAtom = LOWORD(className);
1296 if (!GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) ))
1297 {
1298 ERR( "bad atom %x\n", classAtom);
1299 return 0;
1300 }
1301 className = buffer;
1302 }
1303
1304 /* Create the window */
1305
1306 cs.lpCreateParams = data;
1307 cs.hInstance = instance;
1308 cs.hMenu = menu;
1309 cs.hwndParent = parent;
1310 cs.x = x;
1311 cs.y = y;
1312 cs.cx = width;
1313 cs.cy = height;
1314 cs.style = style;
1315 cs.lpszName = windowName;
1316 cs.lpszClass = className;
1317 cs.dwExStyle = exStyle;
1318
1319 return WIN_CreateWindowEx( &cs, classAtom, WIN_PROC_32A );
1320 }
1321
1322
1323 /***********************************************************************
1324 * CreateWindowExW (USER32.@)
1325 */
1326 HWND WINAPI CreateWindowExW( DWORD exStyle, LPCWSTR className,
1327 LPCWSTR windowName, DWORD style, INT x,
1328 INT y, INT width, INT height,
1329 HWND parent, HMENU menu,
1330 HINSTANCE instance, LPVOID data )
1331 {
1332 ATOM classAtom;
1333 CREATESTRUCTW cs;
1334 WCHAR buffer[256];
1335
1336 if(!instance)
1337 instance=GetModuleHandleW(NULL);
1338
1339 if(exStyle & WS_EX_MDICHILD)
1340 return CreateMDIWindowW(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
1341
1342 /* Find the class atom */
1343
1344 if (HIWORD(className))
1345 {
1346 if (!(classAtom = GlobalFindAtomW( className )))
1347 {
1348 ERR( "bad class name %s\n", debugstr_w(className) );
1349 return 0;
1350 }
1351 }
1352 else
1353 {
1354 classAtom = LOWORD(className);
1355 if (!GlobalGetAtomNameW( classAtom, buffer, sizeof(buffer)/sizeof(WCHAR) ))
1356 {
1357 ERR( "bad atom %x\n", classAtom);
1358 return 0;
1359 }
1360 className = buffer;
1361 }
1362
1363 /* Create the window */
1364
1365 cs.lpCreateParams = data;
1366 cs.hInstance = instance;
1367 cs.hMenu = menu;
1368 cs.hwndParent = parent;
1369 cs.x = x;
1370 cs.y = y;
1371 cs.cx = width;
1372 cs.cy = height;
1373 cs.style = style;
1374 cs.lpszName = windowName;
1375 cs.lpszClass = className;
1376 cs.dwExStyle = exStyle;
1377
1378 /* Note: we rely on the fact that CREATESTRUCTA and */
1379 /* CREATESTRUCTW have the same layout. */
1380 return WIN_CreateWindowEx( (CREATESTRUCTA *)&cs, classAtom, WIN_PROC_32W );
1381 }
1382
1383
1384 /***********************************************************************
1385 * WIN_SendDestroyMsg
1386 */
1387 static void WIN_SendDestroyMsg( HWND hwnd )
1388 {
1389 GUITHREADINFO info;
1390
1391 if (GetGUIThreadInfo( GetCurrentThreadId(), &info ))
1392 {
1393 if (hwnd == info.hwndCaret) DestroyCaret();
1394 }
1395 if (USER_Driver.pResetSelectionOwner)
1396 USER_Driver.pResetSelectionOwner( hwnd, TRUE );
1397
1398 /*
1399 * Send the WM_DESTROY to the window.
1400 */
1401 SendMessageA( hwnd, WM_DESTROY, 0, 0);
1402
1403 /*
1404 * This WM_DESTROY message can trigger re-entrant calls to DestroyWindow
1405 * make sure that the window still exists when we come back.
1406 */
1407 if (IsWindow(hwnd))
1408 {
1409 HWND* pWndArray;
1410 int i;
1411
1412 if (!(pWndArray = WIN_ListChildren( hwnd ))) return;
1413
1414 /* start from the end (FIXME: is this needed?) */
1415 for (i = 0; pWndArray[i]; i++) ;
1416
1417 while (--i >= 0)
1418 {
1419 if (IsWindow( pWndArray[i] )) WIN_SendDestroyMsg( pWndArray[i] );
1420 }
1421 HeapFree( GetProcessHeap(), 0, pWndArray );
1422 }
1423 else
1424 WARN("\tdestroyed itself while in WM_DESTROY!\n");
1425 }
1426
1427
1428 /***********************************************************************
1429 * DestroyWindow (USER32.@)
1430 */
1431 BOOL WINAPI DestroyWindow( HWND hwnd )
1432 {
1433 BOOL is_child;
1434 HWND h;
1435
1436 if (!(hwnd = WIN_IsCurrentThread( hwnd )) || (hwnd == GetDesktopWindow()))
1437 {
1438 SetLastError( ERROR_ACCESS_DENIED );
1439 return FALSE;
1440 }
1441
1442 TRACE("(%p)\n", hwnd);
1443
1444 /* Look whether the focus is within the tree of windows we will
1445 * be destroying.
1446 */
1447 h = GetFocus();
1448 if (h == hwnd || IsChild( hwnd, h ))
1449 {
1450 HWND parent = GetAncestor( hwnd, GA_PARENT );
1451 if (parent == GetDesktopWindow()) parent = 0;
1452 SetFocus( parent );
1453 }
1454
1455 /* Call hooks */
1456
1457 if (HOOK_CallHooks( WH_CBT, HCBT_DESTROYWND, (WPARAM)hwnd, 0, TRUE )) return FALSE;
1458
1459 is_child = (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) != 0;
1460
1461 if (is_child)
1462 {
1463 if (!USER_IsExitingThread( GetCurrentThreadId() ))
1464 send_parent_notify( hwnd, WM_DESTROY );
1465 }
1466 else if (!GetWindow( hwnd, GW_OWNER ))
1467 {
1468 HOOK_CallHooks( WH_SHELL, HSHELL_WINDOWDESTROYED, (WPARAM)hwnd, 0L, TRUE );
1469 /* FIXME: clean up palette - see "Internals" p.352 */
1470 }
1471
1472 if (!IsWindow(hwnd)) return TRUE;
1473
1474 if (USER_Driver.pResetSelectionOwner)
1475 USER_Driver.pResetSelectionOwner( hwnd, FALSE ); /* before the window is unmapped */
1476
1477 /* Hide the window */
1478
1479 if (!ShowWindow( hwnd, SW_HIDE ))
1480 {
1481 if (hwnd == GetActiveWindow()) WINPOS_ActivateOtherWindow( hwnd );
1482 }
1483 if (!IsWindow(hwnd)) return TRUE;
1484
1485 /* Recursively destroy owned windows */
1486
1487 if (!is_child)
1488 {
1489 for (;;)
1490 {
1491 int i, got_one = 0;
1492 HWND *list = WIN_ListChildren( GetDesktopWindow() );
1493 if (list)
1494 {
1495 for (i = 0; list[i]; i++)
1496 {
1497 if (GetWindow( list[i], GW_OWNER ) != hwnd) continue;
1498 if (WIN_IsCurrentThread( list[i] ))
1499 {
1500 DestroyWindow( list[i] );
1501 got_one = 1;
1502 continue;
1503 }
1504 WIN_SetOwner( list[i], 0 );
1505 }
1506 HeapFree( GetProcessHeap(), 0, list );
1507 }
1508 if (!got_one) break;
1509 }
1510 }
1511
1512 /* Send destroy messages */
1513
1514 WIN_SendDestroyMsg( hwnd );
1515 if (!IsWindow( hwnd )) return TRUE;
1516
1517 /* Unlink now so we won't bother with the children later on */
1518
1519 WIN_UnlinkWindow( hwnd );
1520
1521 /* Destroy the window storage */
1522
1523 WIN_DestroyWindow( hwnd );
1524 return TRUE;
1525 }
1526
1527
1528 /***********************************************************************
1529 * CloseWindow (USER32.@)
1530 */
1531 BOOL WINAPI CloseWindow( HWND hwnd )
1532 {
1533 if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD) return FALSE;
1534 ShowWindow( hwnd, SW_MINIMIZE );
1535 return TRUE;
1536 }
1537
1538
1539 /***********************************************************************
1540 * OpenIcon (USER32.@)
1541 */
1542 BOOL WINAPI OpenIcon( HWND hwnd )
1543 {
1544 if (!IsIconic( hwnd )) return FALSE;
1545 ShowWindow( hwnd, SW_SHOWNORMAL );
1546 return TRUE;
1547 }
1548
1549
1550 /***********************************************************************
1551 * WIN_FindWindow
1552 *
1553 * Implementation of FindWindow() and FindWindowEx().
1554 */
1555 static HWND WIN_FindWindow( HWND parent, HWND child, ATOM className, LPCWSTR title )
1556 {
1557 HWND *list = NULL;
1558 HWND retvalue = 0;
1559 int i = 0, len = 0;
1560 WCHAR *buffer = NULL;
1561
1562 if (!parent) parent = GetDesktopWindow();
1563 if (title)
1564 {
1565 len = strlenW(title) + 1; /* one extra char to check for chars beyond the end */
1566 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return 0;
1567 }
1568
1569 if (!(list = list_window_children( parent, className, 0 ))) goto done;
1570
1571 if (child)
1572 {
1573 child = WIN_GetFullHandle( child );
1574 while (list[i] && list[i] != child) i++;
1575 if (!list[i]) goto done;
1576 i++; /* start from next window */
1577 }
1578
1579 if (title)
1580 {
1581 while (list[i])
1582 {
1583 if (GetWindowTextW( list[i], buffer, len ) && !strcmpiW( buffer, title )) break;
1584 i++;
1585 }
1586 }
1587 retvalue = list[i];
1588
1589 done:
1590 if (list) HeapFree( GetProcessHeap(), 0, list );
1591 if (buffer) HeapFree( GetProcessHeap(), 0, buffer );
1592 return retvalue;
1593 }
1594
1595
1596
1597 /***********************************************************************
1598 * FindWindowA (USER32.@)
1599 */
1600 HWND WINAPI FindWindowA( LPCSTR className, LPCSTR title )
1601 {
1602 HWND ret = FindWindowExA( 0, 0, className, title );
1603 if (!ret) SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1604 return ret;
1605 }
1606
1607
1608 /***********************************************************************
1609 * FindWindowExA (USER32.@)
1610 */
1611 HWND WINAPI FindWindowExA( HWND parent, HWND child,
1612 LPCSTR className, LPCSTR title )
1613 {
1614 ATOM atom = 0;
1615 LPWSTR buffer;
1616 HWND hwnd;
1617 INT len;
1618
1619 if (className)
1620 {
1621 /* If the atom doesn't exist, then no class */
1622 /* with this name exists either. */
1623 if (!(atom = GlobalFindAtomA( className )))
1624 {
1625 SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1626 return 0;
1627 }
1628 }
1629 if (!title) return WIN_FindWindow( parent, child, atom, NULL );
1630
1631 len = MultiByteToWideChar( CP_ACP, 0, title, -1, NULL, 0 );
1632 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return 0;
1633 MultiByteToWideChar( CP_ACP, 0, title, -1, buffer, len );
1634 hwnd = WIN_FindWindow( parent, child, atom, buffer );
1635 HeapFree( GetProcessHeap(), 0, buffer );
1636 return hwnd;
1637 }
1638
1639
1640 /***********************************************************************
1641 * FindWindowExW (USER32.@)
1642 */
1643 HWND WINAPI FindWindowExW( HWND parent, HWND child,
1644 LPCWSTR className, LPCWSTR title )
1645 {
1646 ATOM atom = 0;
1647
1648 if (className)
1649 {
1650 /* If the atom doesn't exist, then no class */
1651 /* with this name exists either. */
1652 if (!(atom = GlobalFindAtomW( className )))
1653 {
1654 SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1655 return 0;
1656 }
1657 }
1658 return WIN_FindWindow( parent, child, atom, title );
1659 }
1660
1661
1662 /***********************************************************************
1663 * FindWindowW (USER32.@)
1664 */
1665 HWND WINAPI FindWindowW( LPCWSTR className, LPCWSTR title )
1666 {
1667 return FindWindowExW( 0, 0, className, title );
1668 }
1669
1670
1671 /**********************************************************************
1672 * GetDesktopWindow (USER32.@)
1673 */
1674 HWND WINAPI GetDesktopWindow(void)
1675 {
1676 if (pWndDesktop) return pWndDesktop->hwndSelf;
1677 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" );
1678 ExitProcess(1);
1679 return 0;
1680 }
1681
1682
1683 /*******************************************************************
1684 * EnableWindow (USER32.@)
1685 */
1686 BOOL WINAPI EnableWindow( HWND hwnd, BOOL enable )
1687 {
1688 WND *wndPtr;
1689 BOOL retvalue;
1690 LONG style;
1691 HWND full_handle;
1692
1693 if (!(full_handle = WIN_IsCurrentThread( hwnd )))
1694 return SendMessageW( hwnd, WM_WINE_ENABLEWINDOW, enable, 0 );
1695
1696 hwnd = full_handle;
1697
1698 TRACE("( %p, %d )\n", hwnd, enable);
1699
1700 if (!(wndPtr = WIN_GetPtr( hwnd ))) return FALSE;
1701 style = wndPtr->dwStyle;
1702 retvalue = ((style & WS_DISABLED) != 0);
1703 WIN_ReleasePtr( wndPtr );
1704
1705 if (enable && retvalue)
1706 {
1707 WIN_SetStyle( hwnd, style & ~WS_DISABLED );
1708 SendMessageA( hwnd, WM_ENABLE, TRUE, 0 );
1709 }
1710 else if (!enable && !retvalue)
1711 {
1712 SendMessageA( hwnd, WM_CANCELMODE, 0, 0);
1713
1714 WIN_SetStyle( hwnd, style | WS_DISABLED );
1715
1716 if (hwnd == GetFocus() || IsChild(hwnd, GetFocus()))
1717 SetFocus( 0 ); /* A disabled window can't have the focus */
1718
1719 if (hwnd == GetCapture() || IsChild(hwnd, GetCapture()))
1720 ReleaseCapture(); /* A disabled window can't capture the mouse */
1721
1722 SendMessageA( hwnd, WM_ENABLE, FALSE, 0 );
1723 }
1724 return retvalue;
1725 }
1726
1727
1728 /***********************************************************************
1729 * IsWindowEnabled (USER32.@)
1730 */
1731 BOOL WINAPI IsWindowEnabled(HWND hWnd)
1732 {
1733 return !(GetWindowLongW( hWnd, GWL_STYLE ) & WS_DISABLED);
1734 }
1735
1736
1737 /***********************************************************************
1738 * IsWindowUnicode (USER32.@)
1739 */
1740 BOOL WINAPI IsWindowUnicode( HWND hwnd )
1741 {
1742 WND * wndPtr;
1743 BOOL retvalue;
1744
1745 if (!(wndPtr = WIN_FindWndPtr(hwnd))) return FALSE;
1746 retvalue = (WINPROC_GetProcType( wndPtr->winproc ) == WIN_PROC_32W);
1747 WIN_ReleaseWndPtr(wndPtr);
1748 return retvalue;
1749 }
1750
1751
1752 /**********************************************************************
1753 * GetWindowWord (USER32.@)
1754 */
1755 WORD WINAPI GetWindowWord( HWND hwnd, INT offset )
1756 {
1757 if (offset >= 0)
1758 {
1759 WORD retvalue = 0;
1760 WND *wndPtr = WIN_GetPtr( hwnd );
1761 if (!wndPtr)
1762 {
1763 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1764 return 0;
1765 }
1766 if (wndPtr == WND_OTHER_PROCESS)
1767 {
1768 if (IsWindow( hwnd ))
1769 FIXME( "(%d) not supported yet on other process window %p\n", offset, hwnd );
1770 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1771 return 0;
1772 }
1773 if (offset > (int)(wndPtr->cbWndExtra - sizeof(WORD)))
1774 {
1775 WARN("Invalid offset %d\n", offset );
1776 SetLastError( ERROR_INVALID_INDEX );
1777 }
1778 else retvalue = *(WORD *)(((char *)wndPtr->wExtra) + offset);
1779 WIN_ReleasePtr( wndPtr );
1780 return retvalue;
1781 }
1782
1783 switch(offset)
1784 {
1785 case GWL_HWNDPARENT:
1786 return GetWindowLongW( hwnd, offset );
1787 case GWL_ID:
1788 case GWL_HINSTANCE:
1789 {
1790 LONG ret = GetWindowLongW( hwnd, offset );
1791 if (HIWORD(ret))
1792 WARN("%d: discards high bits of 0x%08lx!\n", offset, ret );
1793 return LOWORD(ret);
1794 }
1795 default:
1796 WARN("Invalid offset %d\n", offset );
1797 return 0;
1798 }
1799 }
1800
1801
1802 /**********************************************************************
1803 * SetWindowWord (USER32.@)
1804 */
1805 WORD WINAPI SetWindowWord( HWND hwnd, INT offset, WORD newval )
1806 {
1807 WORD *ptr, retval;
1808 WND * wndPtr;
1809
1810 switch(offset)
1811 {
1812 case GWL_ID:
1813 case GWL_HINSTANCE:
1814 case GWL_HWNDPARENT:
1815 return SetWindowLongW( hwnd, offset, (UINT)newval );
1816 default:
1817 if (offset < 0)
1818 {
1819 WARN("Invalid offset %d\n", offset );
1820 SetLastError( ERROR_INVALID_INDEX );
1821 return 0;
1822 }
1823 }
1824
1825 wndPtr = WIN_GetPtr( hwnd );
1826 if (wndPtr == WND_OTHER_PROCESS)
1827 {
1828 if (IsWindow(hwnd))
1829 FIXME( "set %d <- %x not supported yet on other process window %p\n",
1830 offset, newval, hwnd );
1831 wndPtr = NULL;
1832 }
1833 if (!wndPtr)
1834 {
1835 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1836 return 0;
1837 }
1838
1839 if (offset > (int)(wndPtr->cbWndExtra - sizeof(WORD)))
1840 {
1841 WARN("Invalid offset %d\n", offset );
1842 WIN_ReleasePtr(wndPtr);
1843 SetLastError( ERROR_INVALID_INDEX );
1844 return 0;
1845 }
1846 ptr = (WORD *)(((char *)wndPtr->wExtra) + offset);
1847 retval = *ptr;
1848 *ptr = newval;
1849 WIN_ReleasePtr(wndPtr);
1850 return retval;
1851 }
1852
1853
1854 /**********************************************************************
1855 * WIN_GetWindowLong
1856 *
1857 * Helper function for GetWindowLong().
1858 */
1859 static LONG WIN_GetWindowLong( HWND hwnd, INT offset, WINDOWPROCTYPE type )
1860 {
1861 LONG retvalue = 0;
1862 WND *wndPtr;
1863
1864 if (offset == GWL_HWNDPARENT)
1865 {
1866 HWND parent = GetAncestor( hwnd, GA_PARENT );
1867 if (parent == GetDesktopWindow()) parent = GetWindow( hwnd, GW_OWNER );
1868 return (LONG)parent;
1869 }
1870
1871 if (!(wndPtr = WIN_GetPtr( hwnd )))
1872 {
1873 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1874 return 0;
1875 }
1876
1877 if (wndPtr == WND_OTHER_PROCESS)
1878 {
1879 if (offset >= 0)
1880 {
1881 if (IsWindow(hwnd))
1882 FIXME( "(%d) not supported on other process window %p\n", offset, hwnd );
1883 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1884 return 0;
1885 }
1886 if (offset == GWL_WNDPROC)
1887 {
1888 SetLastError( ERROR_ACCESS_DENIED );
1889 return 0;
1890 }
1891 SERVER_START_REQ( set_window_info )
1892 {
1893 req->handle = hwnd;
1894 req->flags = 0; /* don't set anything, just retrieve */
1895 if (!wine_server_call_err( req ))
1896 {
1897 switch(offset)
1898 {
1899 case GWL_STYLE: retvalue = reply->old_style; break;
1900 case GWL_EXSTYLE: retvalue = reply->old_ex_style; break;
1901 case GWL_ID: retvalue = reply->old_id; break;
1902 case GWL_HINSTANCE: retvalue = (ULONG_PTR)reply->old_instance; break;
1903 case GWL_USERDATA: retvalue = (ULONG_PTR)reply->old_user_data; break;
1904 default:
1905 SetLastError( ERROR_INVALID_INDEX );
1906 break;
1907 }
1908 }
1909 }
1910 SERVER_END_REQ;
1911 return retvalue;
1912 }
1913
1914 /* now we have a valid wndPtr */
1915
1916 if (offset >= 0)
1917 {
1918 if (offset > (int)(wndPtr->cbWndExtra - sizeof(LONG)))
1919 {
1920 /*
1921 * Some programs try to access last element from 16 bit
1922 * code using illegal offset value. Hopefully this is
1923 * what those programs really expect.
1924 */
1925 if (type == WIN_PROC_16 &&
1926 wndPtr->cbWndExtra >= 4 &&
1927 offset == wndPtr->cbWndExtra - sizeof(WORD))
1928 {
1929 INT offset2 = wndPtr->cbWndExtra - sizeof(LONG);
1930
1931 ERR( "- replaced invalid offset %d with %d\n",
1932 offset, offset2 );
1933
1934 retvalue = *(LONG *)(((char *)wndPtr->wExtra) + offset2);
1935 WIN_ReleasePtr( wndPtr );
1936 return retvalue;
1937 }
1938 WARN("Invalid offset %d\n", offset );
1939 WIN_ReleasePtr( wndPtr );
1940 SetLastError( ERROR_INVALID_INDEX );
1941 return 0;
1942 }
1943 retvalue = *(LONG *)(((char *)wndPtr->wExtra) + offset);
1944 /* Special case for dialog window procedure */
1945 if ((offset == DWL_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG))
1946 retvalue = (LONG)WINPROC_GetProc( (WNDPROC)retvalue, type );
1947 WIN_ReleasePtr( wndPtr );
1948 return retvalue;
1949 }
1950
1951 switch(offset)
1952 {
1953 case GWL_USERDATA: retvalue = wndPtr->userdata; break;
1954 case GWL_STYLE: retvalue = wndPtr->dwStyle; break;
1955 case GWL_EXSTYLE: retvalue = wndPtr->dwExStyle; break;
1956 case GWL_ID: retvalue = (LONG)wndPtr->wIDmenu; break;
1957 case GWL_WNDPROC: retvalue = (LONG)WINPROC_GetProc( wndPtr->winproc, type ); break;
1958 case GWL_HINSTANCE: retvalue = (LONG)wndPtr->hInstance; break;
1959 default:
1960 WARN("Unknown offset %d\n", offset );
1961 SetLastError( ERROR_INVALID_INDEX );
1962 break;
1963 }
1964 WIN_ReleasePtr(wndPtr);
1965 return retvalue;
1966 }
1967
1968
1969 /**********************************************************************
1970 * WIN_SetWindowLong
1971 *
1972 * Helper function for SetWindowLong().
1973 *
1974 * 0 is the failure code. However, in the case of failure SetLastError
1975 * must be set to distinguish between a 0 return value and a failure.
1976 */
1977 static LONG WIN_SetWindowLong( HWND hwnd, INT offset, LONG newval,
1978 WINDOWPROCTYPE type )
1979 {
1980 LONG retval = 0;
1981 WND *wndPtr;
1982
1983 TRACE( "%p %d %lx %x\n", hwnd, offset, newval, type );
1984
1985 if (!WIN_IsCurrentProcess( hwnd ))
1986 {
1987 if (offset == GWL_WNDPROC)
1988 {
1989 SetLastError( ERROR_ACCESS_DENIED );
1990 return 0;
1991 }
1992 return SendMessageW( hwnd, WM_WINE_SETWINDOWLONG, offset, newval );
1993 }
1994
1995 wndPtr = WIN_GetPtr( hwnd );
1996 if (wndPtr->hwndSelf == GetDesktopWindow())
1997 {
1998 /* can't change anything on the desktop window */
1999 WIN_ReleasePtr( wndPtr );
2000 SetLastError( ERROR_ACCESS_DENIED );
2001 return 0;
2002 }
2003
2004 if (offset >= 0)
2005 {
2006 LONG *ptr = (LONG *)(((char *)wndPtr->wExtra) + offset);
2007 if (offset > (int)(wndPtr->cbWndExtra - sizeof(LONG)))
2008 {
2009 WARN("Invalid offset %d\n", offset );
2010 WIN_ReleasePtr( wndPtr );
2011 SetLastError( ERROR_INVALID_INDEX );
2012 return 0;
2013 }
2014 /* Special case for dialog window procedure */
2015 if ((offset == DWL_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG))
2016 {
2017 retval = (LONG)WINPROC_GetProc( (WNDPROC)*ptr, type );
2018 WINPROC_SetProc( (WNDPROC *)ptr, (WNDPROC)newval, type, WIN_PROC_WINDOW );
2019 WIN_ReleasePtr( wndPtr );
2020 return retval;
2021 }
2022 retval = *ptr;
2023 *ptr = newval;
2024 WIN_ReleasePtr( wndPtr );
2025 }
2026 else
2027 {
2028 STYLESTRUCT style;
2029 BOOL ok;
2030
2031 /* first some special cases */
2032 switch( offset )
2033 {
2034 case GWL_STYLE:
2035 case GWL_EXSTYLE:
2036 style.styleOld = wndPtr->dwStyle;
2037 style.styleNew = newval;
2038 WIN_ReleasePtr( wndPtr );
2039 SendMessageW( hwnd, WM_STYLECHANGING, offset, (LPARAM)&style );
2040 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return 0;
2041 newval = style.styleNew;
2042 break;
2043 case GWL_HWNDPARENT:
2044 if (wndPtr->parent == GetDesktopWindow())
2045 {
2046 WIN_ReleasePtr( wndPtr );
2047 return (LONG)WIN_SetOwner( hwnd, (HWND)newval );
2048 }
2049 else
2050 {
2051 WIN_ReleasePtr( wndPtr );
2052 return (LONG)SetParent( hwnd, (HWND)newval );
2053 }
2054 case GWL_WNDPROC:
2055 retval = (LONG)WINPROC_GetProc( wndPtr->winproc, type );
2056 WINPROC_SetProc( &wndPtr->winproc, (WNDPROC)newval, type, WIN_PROC_WINDOW );
2057 WIN_ReleasePtr( wndPtr );
2058 return retval;
2059 case GWL_ID:
2060 case GWL_HINSTANCE:
2061 case GWL_USERDATA:
2062 break;
2063 default:
2064 WIN_ReleasePtr( wndPtr );
2065 WARN("Invalid offset %d\n", offset );
2066 SetLastError( ERROR_INVALID_INDEX );
2067 return 0;
2068 }
2069
2070 SERVER_START_REQ( set_window_info )
2071 {
2072 req->handle = hwnd;
2073 switch(offset)
2074 {
2075 case GWL_STYLE:
2076 req->flags = SET_WIN_STYLE;
2077 req->style = newval;
2078 break;
2079 case GWL_EXSTYLE:
2080 req->flags = SET_WIN_EXSTYLE;
2081 req->ex_style = newval;
2082 break;
2083 case GWL_ID:
2084 req->flags = SET_WIN_ID;
2085 req->id = newval;
2086 break;
2087 case GWL_HINSTANCE:
2088 req->flags = SET_WIN_INSTANCE;
2089 req->instance = (void *)newval;
2090 break;
2091 case GWL_USERDATA:
2092 req->flags = SET_WIN_USERDATA;
2093 req->user_data = (void *)newval;
2094 break;
2095 }
2096 if ((ok = !wine_server_call_err( req )))
2097 {
2098 switch(offset)
2099 {
2100 case GWL_STYLE:
2101 wndPtr->dwStyle = newval;
2102 retval = reply->old_style;
2103 break;
2104 case GWL_EXSTYLE:
2105 wndPtr->dwExStyle = newval;
2106 retval = reply->old_ex_style;
2107 break;
2108 case GWL_ID:
2109 wndPtr->wIDmenu = newval;
2110 retval = reply->old_id;
2111 break;
2112 case GWL_HINSTANCE:
2113 wndPtr->hInstance = (HINSTANCE)newval;
2114 retval = (ULONG_PTR)reply->old_instance;
2115 break;
2116 case GWL_USERDATA:
2117 wndPtr->userdata = newval;
2118 retval = (ULONG_PTR)reply->old_user_data;
2119 break;
2120 }
2121 }
2122 }
2123 SERVER_END_REQ;
2124 WIN_ReleasePtr( wndPtr );
2125
2126 if (!ok) return 0;
2127
2128 if (offset == GWL_STYLE && USER_Driver.pSetWindowStyle)
2129 USER_Driver.pSetWindowStyle( hwnd, retval );
2130
2131 if (offset == GWL_STYLE || offset == GWL_EXSTYLE)
2132 SendMessageW( hwnd, WM_STYLECHANGED, offset, (LPARAM)&style );
2133
2134 }
2135 return retval;
2136 }
2137
2138
2139 /**********************************************************************
2140 * GetWindowLong (USER.135)
2141 */
2142 LONG WINAPI GetWindowLong16( HWND16 hwnd, INT16 offset )
2143 {
2144 return WIN_GetWindowLong( WIN_Handle32(hwnd), offset, WIN_PROC_16 );
2145 }
2146
2147
2148 /**********************************************************************
2149 * GetWindowLongA (USER32.@)
2150 */
2151 LONG WINAPI GetWindowLongA( HWND hwnd, INT offset )
2152 {
2153 return WIN_GetWindowLong( hwnd, offset, WIN_PROC_32A );
2154 }
2155
2156
2157 /**********************************************************************
2158 * GetWindowLongW (USER32.@)
2159 */
2160 LONG WINAPI GetWindowLongW( HWND hwnd, INT offset )
2161 {
2162 return WIN_GetWindowLong( hwnd, offset, WIN_PROC_32W );
2163 }
2164
2165
2166 /**********************************************************************
2167 * SetWindowLong (USER.136)
2168 */
2169 LONG WINAPI SetWindowLong16( HWND16 hwnd, INT16 offset, LONG newval )
2170 {
2171 return WIN_SetWindowLong( WIN_Handle32(hwnd), offset, newval, WIN_PROC_16 );
2172 }
2173
2174
2175 /**********************************************************************
2176 * SetWindowLongA (USER32.@)
2177 */
2178 LONG WINAPI SetWindowLongA( HWND hwnd, INT offset, LONG newval )
2179 {
2180 return WIN_SetWindowLong( hwnd, offset, newval, WIN_PROC_32A );
2181 }
2182
2183
2184 /**********************************************************************
2185 * SetWindowLongW (USER32.@) Set window attribute
2186 *
2187 * SetWindowLong() alters one of a window's attributes or sets a 32-bit (long)
2188 * value in a window's extra memory.
2189 *
2190 * The _hwnd_ parameter specifies the window. is the handle to a
2191 * window that has extra memory. The _newval_ parameter contains the
2192 * new attribute or extra memory value. If positive, the _offset_
2193 * parameter is the byte-addressed location in the window's extra
2194 * memory to set. If negative, _offset_ specifies the window
2195 * attribute to set, and should be one of the following values:
2196 *
2197 * GWL_EXSTYLE The window's extended window style
2198 *
2199 * GWL_STYLE The window's window style.
2200 *
2201 * GWL_WNDPROC Pointer to the window's window procedure.
2202 *
2203 * GWL_HINSTANCE The window's pplication instance handle.
2204 *
2205 * GWL_ID The window's identifier.
2206 *
2207 * GWL_USERDATA The window's user-specified data.
2208 *
2209 * If the window is a dialog box, the _offset_ parameter can be one of
2210 * the following values:
2211 *
2212 * DWL_DLGPROC The address of the window's dialog box procedure.
2213 *
2214 * DWL_MSGRESULT The return value of a message
2215 * that the dialog box procedure processed.
2216 *
2217 * DWL_USER Application specific information.
2218 *
2219 * RETURNS
2220 *
2221 * If successful, returns the previous value located at _offset_. Otherwise,
2222 * returns 0.
2223 *
2224 * NOTES
2225 *
2226 * Extra memory for a window class is specified by a nonzero cbWndExtra
2227 * parameter of the WNDCLASS structure passed to RegisterClass() at the
2228 * time of class creation.
2229 *
2230 * Using GWL_WNDPROC to set a new window procedure effectively creates
2231 * a window subclass. Use CallWindowProc() in the new windows procedure
2232 * to pass messages to the superclass's window procedure.
2233 *
2234 * The user data is reserved for use by the application which created
2235 * the window.
2236 *
2237 * Do not use GWL_STYLE to change the window's WS_DISABLED style;
2238 * instead, call the EnableWindow() function to change the window's
2239 * disabled state.
2240 *
2241 * Do not use GWL_HWNDPARENT to reset the window's parent, use
2242 * SetParent() instead.
2243 *
2244 * Win95:
2245 * When offset is GWL_STYLE and the calling app's ver is 4.0,
2246 * it sends WM_STYLECHANGING before changing the settings
2247 * and WM_STYLECHANGED afterwards.
2248 * App ver 4.0 can't use SetWindowLong to change WS_EX_TOPMOST.
2249 */
2250 LONG WINAPI SetWindowLongW(
2251 HWND hwnd, /* [in] window to alter */
2252 INT offset, /* [in] offset, in bytes, of location to alter */
2253 LONG newval /* [in] new value of location */
2254 ) {
2255 return WIN_SetWindowLong( hwnd, offset, newval, WIN_PROC_32W );
2256 }
2257
2258
2259 /*******************************************************************
2260 * GetWindowTextA (USER32.@)
2261 */
2262 INT WINAPI GetWindowTextA( HWND hwnd, LPSTR lpString, INT nMaxCount )
2263 {
2264 WCHAR *buffer;
2265
2266 if (WIN_IsCurrentProcess( hwnd ))
2267 return (INT)SendMessageA( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2268
2269 /* when window belongs to other process, don't send a message */
2270 if (nMaxCount <= 0) return 0;
2271 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, nMaxCount * sizeof(WCHAR) ))) return 0;
2272 get_server_window_text( hwnd, buffer, nMaxCount );
2273 if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, lpString, nMaxCount, NULL, NULL ))
2274 lpString[nMaxCount-1] = 0;
2275 HeapFree( GetProcessHeap(), 0, buffer );
2276 return strlen(lpString);
2277 }
2278
2279
2280 /*******************************************************************
2281 * InternalGetWindowText (USER32.@)
2282 */
2283 INT WINAPI InternalGetWindowText(HWND hwnd,LPWSTR lpString,INT nMaxCount )
2284 {
2285 WND *win;
2286
2287 if (nMaxCount <= 0) return 0;
2288 if (!(win = WIN_GetPtr( hwnd ))) return 0;
2289 if (win != WND_OTHER_PROCESS)
2290 {
2291 if (win->text) lstrcpynW( lpString, win->text, nMaxCount );
2292 else lpString[0] = 0;
2293 WIN_ReleasePtr( win );
2294 }
2295 else
2296 {
2297 get_server_window_text( hwnd, lpString, nMaxCount );
2298 }
2299 return strlenW(lpString);
2300 }
2301
2302
2303 /*******************************************************************
2304 * GetWindowTextW (USER32.@)
2305 */
2306 INT WINAPI GetWindowTextW( HWND hwnd, LPWSTR lpString, INT nMaxCount )
2307 {
2308 if (WIN_IsCurrentProcess( hwnd ))
2309 return (INT)SendMessageW( hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString );
2310
2311 /* when window belongs to other process, don't send a message */
2312 if (nMaxCount <= 0) return 0;
2313 get_server_window_text( hwnd, lpString, nMaxCount );
2314 return strlenW(lpString);
2315 }
2316
2317
2318 /*******************************************************************
2319 * SetWindowText (USER32.@)
2320 * SetWindowTextA (USER32.@)
2321 */
2322 BOOL WINAPI SetWindowTextA( HWND hwnd, LPCSTR lpString )
2323 {
2324 if (!WIN_IsCurrentProcess( hwnd ))
2325 {
2326 FIXME( "cannot set text %s of other process window %p\n", debugstr_a(lpString), hwnd );
2327 SetLastError( ERROR_ACCESS_DENIED );
2328 return FALSE;
2329 }
2330 return (BOOL)SendMessageA( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2331 }
2332
2333
2334 /*******************************************************************
2335 * SetWindowTextW (USER32.@)
2336 */
2337 BOOL WINAPI SetWindowTextW( HWND hwnd, LPCWSTR lpString )
2338 {
2339 if (!WIN_IsCurrentProcess( hwnd ))
2340 {
2341 FIXME( "cannot set text %s of other process window %p\n", debugstr_w(lpString), hwnd );
2342 SetLastError( ERROR_ACCESS_DENIED );
2343 return FALSE;
2344 }
2345 return (BOOL)SendMessageW( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2346 }
2347
2348
2349 /*******************************************************************
2350 * GetWindowTextLengthA (USER32.@)
2351 */
2352 INT WINAPI GetWindowTextLengthA( HWND hwnd )
2353 {
2354 return SendMessageA( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2355 }
2356
2357 /*******************************************************************
2358 * GetWindowTextLengthW (USER32.@)
2359 */
2360 INT WINAPI GetWindowTextLengthW( HWND hwnd )
2361 {
2362 return SendMessageW( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2363 }
2364
2365
2366 /*******************************************************************
2367 * IsWindow (USER32.@)
2368 */
2369 BOOL WINAPI IsWindow( HWND hwnd )
2370 {
2371 WND *ptr;
2372 BOOL ret;
2373
2374 if (!(ptr = WIN_GetPtr( hwnd ))) return FALSE;
2375
2376 if (ptr != WND_OTHER_PROCESS)
2377 {
2378 WIN_ReleasePtr( ptr );
2379 return TRUE;
2380 }
2381
2382 /* check other processes */
2383 SERVER_START_REQ( get_window_info )
2384 {
2385 req->handle = hwnd;
2386 ret = !wine_server_call_err( req );
2387 }
2388 SERVER_END_REQ;
2389 return ret;
2390 }
2391
2392
2393 /***********************************************************************
2394 * GetWindowThreadProcessId (USER32.@)
2395 */
2396 DWORD WINAPI GetWindowThreadProcessId( HWND hwnd, LPDWORD process )
2397 {
2398 WND *ptr;
2399 DWORD tid = 0;
2400
2401 if (!(ptr = WIN_GetPtr( hwnd )))
2402 {
2403 SetLastError( ERROR_INVALID_WINDOW_HANDLE);
2404 return 0;
2405 }
2406
2407 if (ptr != WND_OTHER_PROCESS)
2408 {
2409 /* got a valid window */
2410 tid = ptr->tid;
2411 if (process) *process = GetCurrentProcessId();
2412 WIN_ReleasePtr( ptr );
2413 return tid;
2414 }
2415
2416 /* check other processes */
2417 SERVER_START_REQ( get_window_info )
2418 {
2419 req->handle = hwnd;
2420 if (!wine_server_call_err( req ))
2421 {
2422 tid = (DWORD)reply->tid;
2423 if (process) *process = (DWORD)reply->pid;
2424 }
2425 }
2426 SERVER_END_REQ;
2427 return tid;
2428 }
2429
2430
2431 /*****************************************************************
2432 * GetParent (USER32.@)
2433 */
2434 HWND WINAPI GetParent( HWND hwnd )
2435 {
2436 WND *wndPtr;
2437 HWND retvalue = 0;
2438
2439 if (!(wndPtr = WIN_GetPtr( hwnd )))
2440 {
2441 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2442 return 0;
2443 }
2444 if (wndPtr == WND_OTHER_PROCESS)
2445 {
2446 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
2447 if (style & (WS_POPUP | WS_CHILD))
2448 {
2449 SERVER_START_REQ( get_window_tree )
2450 {
2451 req->handle = hwnd;
2452 if (!wine_server_call_err( req ))
2453 {
2454 if (style & WS_POPUP) retvalue = reply->owner;
2455 else if (style & WS_CHILD) retvalue = reply->parent;
2456 }
2457 }
2458 SERVER_END_REQ;
2459 }
2460 }
2461 else
2462 {
2463 if (wndPtr->dwStyle & WS_POPUP) retvalue = wndPtr->owner;
2464 else if (wndPtr->dwStyle & WS_CHILD) retvalue = wndPtr->parent;
2465 WIN_ReleasePtr( wndPtr );
2466 }
2467 return retvalue;
2468 }
2469
2470
2471 /*****************************************************************
2472 * GetAncestor (USER32.@)
2473 */
2474 HWND WINAPI GetAncestor( HWND hwnd, UINT type )
2475 {
2476 WND *win;
2477 HWND *list, ret = 0;
2478
2479 switch(type)
2480 {
2481 case GA_PARENT:
2482 if (!(win = WIN_GetPtr( hwnd )))
2483 {
2484 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2485 return 0;
2486 }
2487 if (win != WND_OTHER_PROCESS)
2488 {
2489 ret = win->parent;
2490 WIN_ReleasePtr( win );
2491 }
2492 else /* need to query the server */
2493 {
2494 SERVER_START_REQ( get_window_tree )
2495 {
2496 req->handle = hwnd;
2497 if (!wine_server_call_err( req )) ret = reply->parent;
2498 }
2499 SERVER_END_REQ;
2500 }
2501 break;
2502
2503 case GA_ROOT:
2504 if (!(list = WIN_ListParents( hwnd ))) return 0;
2505
2506 if (!list[0] || !list[1]) ret = WIN_GetFullHandle( hwnd ); /* top-level window */
2507 else
2508 {
2509 int count = 2;
2510 while (list[count]) count++;
2511 ret = list[count - 2]; /* get the one before the desktop */
2512 }
2513 HeapFree( GetProcessHeap(), 0, list );
2514 break;
2515
2516 case GA_ROOTOWNER:
2517 if ((ret = WIN_GetFullHandle( hwnd )) == GetDesktopWindow()) return 0;
2518 for (;;)
2519 {
2520 HWND parent = GetParent( ret );
2521 if (!parent) break;
2522 ret = parent;
2523 }
2524 break;
2525 }
2526 return ret;
2527 }
2528
2529
2530 /*****************************************************************
2531 * SetParent (USER32.@)
2532 */
2533 HWND WINAPI SetParent( HWND hwnd, HWND parent )
2534 {
2535 WND *wndPtr;
2536 HWND retvalue, full_handle;
2537 BOOL was_visible;
2538
2539 if (!parent) parent = GetDesktopWindow();
2540 else parent = WIN_GetFullHandle( parent );
2541
2542 if (!IsWindow( parent ))
2543 {
2544 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
2545 return 0;
2546 }
2547
2548 if (!(full_handle = WIN_IsCurrentThread( hwnd )))
2549 return (HWND)SendMessageW( hwnd, WM_WINE_SETPARENT, (WPARAM)parent, 0 );
2550
2551 hwnd = full_handle;
2552
2553 if (USER_Driver.pSetParent)
2554 return USER_Driver.pSetParent( hwnd, parent );
2555
2556 /* Windows hides the window first, then shows it again
2557 * including the WM_SHOWWINDOW messages and all */
2558 was_visible = ShowWindow( hwnd, SW_HIDE );
2559
2560 if (!IsWindow( parent )) return 0;
2561 if (!(wndPtr = WIN_GetPtr(hwnd)) || wndPtr == WND_OTHER_PROCESS) return 0;
2562
2563 retvalue = wndPtr->parent; /* old parent */
2564 if (parent != retvalue)
2565 {
2566 WIN_LinkWindow( hwnd, parent, HWND_TOP );
2567
2568 if (parent != GetDesktopWindow()) /* a child window */
2569 {
2570 if (!(wndPtr->dwStyle & WS_CHILD))
2571 {
2572 HMENU menu = (HMENU)SetWindowLongW( hwnd, GWL_ID, 0 );
2573 if (menu) DestroyMenu( menu );
2574 }
2575 }
2576 }
2577 WIN_ReleasePtr( wndPtr );
2578
2579 /* SetParent additionally needs to make hwnd the topmost window
2580 in the x-order and send the expected WM_WINDOWPOSCHANGING and
2581 WM_WINDOWPOSCHANGED notification messages.
2582 */
2583 SetWindowPos( hwnd, HWND_TOPMOST, 0, 0, 0, 0,
2584 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | (was_visible ? SWP_SHOWWINDOW : 0) );
2585 /* FIXME: a WM_MOVE is also generated (in the DefWindowProc handler
2586 * for WM_WINDOWPOSCHANGED) in Windows, should probably remove SWP_NOMOVE */
2587 return retvalue;
2588 }
2589
2590
2591 /*******************************************************************
2592 * IsChild (USER32.@)
2593 */
2594 BOOL WINAPI IsChild( HWND parent, HWND child )
2595 {
2596 HWND *list = WIN_ListParents( child );
2597 int i;
2598 BOOL ret;
2599
2600 if (!list) return FALSE;
2601 parent = WIN_GetFullHandle( parent );
2602 for (i = 0; list[i]; i++) if (list[i] == parent) break;
2603 ret = (list[i] != 0);
2604 HeapFree( GetProcessHeap(), 0, list );
2605 return ret;
2606 }
2607
2608
2609 /***********************************************************************
2610 * IsWindowVisible (USER32.@)
2611 */
2612 BOOL WINAPI IsWindowVisible( HWND hwnd )
2613 {
2614 HWND *list;
2615 BOOL retval;
2616 int i;
2617
2618 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_VISIBLE)) return FALSE;
2619 if (!(list = WIN_ListParents( hwnd ))) return TRUE;
2620 for (i = 0; list[i]; i++)
2621 if (!(GetWindowLongW( list[i], GWL_STYLE ) & WS_VISIBLE)) break;
2622 retval = !list[i];
2623 HeapFree( GetProcessHeap(), 0, list );
2624 return retval;
2625 }
2626
2627
2628 /***********************************************************************
2629 * WIN_IsWindowDrawable
2630 *
2631 * hwnd is drawable when it is visible, all parents are not
2632 * minimized, and it is itself not minimized unless we are
2633 * trying to draw its default class icon.
2634 */
2635 BOOL WIN_IsWindowDrawable( HWND hwnd, BOOL icon )
2636 {
2637 HWND *list;
2638 BOOL retval;
2639 int i;
2640 LONG style = GetWindowLongW( hwnd, GWL_STYLE );
2641
2642 if (!(style & WS_VISIBLE)) return FALSE;
2643 if ((style & WS_MINIMIZE) && icon && GetClassLongA( hwnd, GCL_HICON )) return FALSE;
2644
2645 if (!(list = WIN_ListParents( hwnd ))) return TRUE;
2646 for (i = 0; list[i]; i++)
2647 if ((GetWindowLongW( list[i], GWL_STYLE ) & (WS_VISIBLE|WS_MINIMIZE)) != WS_VISIBLE)
2648 break;
2649 retval = !list[i];
2650 HeapFree( GetProcessHeap(), 0, list );
2651 return retval;
2652 }
2653
2654
2655 /*******************************************************************
2656 * GetTopWindow (USER32.@)
2657 */
2658 HWND WINAPI GetTopWindow( HWND hwnd )
2659 {
2660 if (!hwnd) hwnd = GetDesktopWindow();
2661 return GetWindow( hwnd, GW_CHILD );
2662 }
2663
2664
2665 /*******************************************************************
2666 * GetWindow (USER32.@)
2667 */
2668 HWND WINAPI GetWindow( HWND hwnd, UINT rel )
2669 {
2670 HWND retval = 0;
2671
2672 if (rel == GW_OWNER) /* this one may be available locally */
2673 {
2674 WND *wndPtr = WIN_GetPtr( hwnd );
2675 if (!wndPtr)
2676 {
2677 SetLastError( ERROR_INVALID_HANDLE );
2678 return 0;
2679 }
2680 if (wndPtr != WND_OTHER_PROCESS)
2681 {
2682 retval = wndPtr->owner;
2683 WIN_ReleasePtr( wndPtr );
2684 return retval;
2685 }
2686 /* else fall through to server call */
2687 }
2688
2689 SERVER_START_REQ( get_window_tree )
2690 {
2691 req->handle = hwnd;
2692 if (!wine_server_call_err( req ))
2693 {
2694 switch(rel)
2695 {
2696 case GW_HWNDFIRST:
2697 retval = reply->first_sibling;
2698 break;
2699 case GW_HWNDLAST:
2700 retval = reply->last_sibling;
2701 break;
2702 case GW_HWNDNEXT:
2703 retval = reply->next_sibling;
2704 break;
2705 case GW_HWNDPREV:
2706 retval = reply->prev_sibling;
2707 break;
2708 case GW_OWNER:
2709 retval = reply->owner;
2710 break;
2711 case GW_CHILD:
2712 retval = reply->first_child;
2713 break;
2714 }
2715 }
2716 }
2717 SERVER_END_REQ;
2718 return retval;
2719 }
2720
2721
2722 /***********************************************************************
2723 * WIN_InternalShowOwnedPopups
2724 *
2725 * Internal version of ShowOwnedPopups; Wine functions should use this
2726 * to avoid interfering with application calls to ShowOwnedPopups
2727 * and to make sure the application can't prevent showing/hiding.
2728 *
2729 * Set unmanagedOnly to TRUE to show/hide unmanaged windows only.
2730 *
2731 */
2732
2733 BOOL WIN_InternalShowOwnedPopups( HWND owner, BOOL fShow, BOOL unmanagedOnly )
2734 {
2735 int count = 0;
2736 WND *pWnd;
2737 HWND *win_array = WIN_ListChildren( GetDesktopWindow() );
2738
2739 if (!win_array) return TRUE;
2740
2741 /*
2742 * Show windows Lowest first, Highest last to preserve Z-Order
2743 */
2744 while (win_array[count]) count++;
2745 while (--count >= 0)
2746 {
2747 if (GetWindow( win_array[count], GW_OWNER ) != owner) continue;
2748 if (!(pWnd = WIN_FindWndPtr( win_array[count] ))) continue;
2749
2750 if (pWnd->dwStyle & WS_POPUP)
2751 {
2752 if (fShow)
2753 {
2754 /* check in window was flagged for showing in previous WIN_InternalShowOwnedPopups call */
2755 if (pWnd->flags & WIN_NEEDS_INTERNALSOP)
2756 {
2757 /*
2758 * Call ShowWindow directly because an application can intercept WM_SHOWWINDOW messages
2759 */
2760 ShowWindow(pWnd->hwndSelf,SW_SHOW);
2761 pWnd->flags &= ~WIN_NEEDS_INTERNALSOP; /* remove the flag */
2762 }
2763 }
2764 else
2765 {
2766 if ( IsWindowVisible(pWnd->hwndSelf) && /* hide only if window is visible */
2767 !( pWnd->flags & WIN_NEEDS_INTERNALSOP ) && /* don't hide if previous call already did it */
2768 !( unmanagedOnly && (pWnd->dwExStyle & WS_EX_MANAGED) ) ) /* don't hide managed windows if unmanagedOnly is TRUE */
2769 {
2770 /*
2771 * Call ShowWindow directly because an application can intercept WM_SHOWWINDOW messages
2772 */
2773 ShowWindow(pWnd->hwndSelf,SW_HIDE);
2774 /* flag the window for showing on next WIN_InternalShowOwnedPopups call */
2775 pWnd->flags |= WIN_NEEDS_INTERNALSOP;
2776 }
2777 }
2778 }
2779 WIN_ReleaseWndPtr( pWnd );
2780 }
2781 HeapFree( GetProcessHeap(), 0, win_array );
2782
2783 return TRUE;
2784 }
2785
2786 /*******************************************************************
2787 * ShowOwnedPopups (USER32.@)
2788 */
2789 BOOL WINAPI ShowOwnedPopups( HWND owner, BOOL fShow )
2790 {
2791 int count = 0;
2792 WND *pWnd;
2793 HWND *win_array = WIN_ListChildren( GetDesktopWindow() );
2794
2795 if (!win_array) return TRUE;
2796
2797 while (win_array[count]) count++;
2798 while (--count >= 0)
2799 {
2800 if (GetWindow( win_array[count], GW_OWNER ) != owner) continue;
2801 if (!(pWnd = WIN_FindWndPtr( win_array[count] ))) continue;
2802
2803 if (pWnd->dwStyle & WS_POPUP)
2804 {
2805 if (fShow)
2806 {
2807 if (pWnd->flags & WIN_NEEDS_SHOW_OWNEDPOPUP)
2808 {
2809 /* In Windows, ShowOwnedPopups(TRUE) generates
2810 * WM_SHOWWINDOW messages with SW_PARENTOPENING,
2811 * regardless of the state of the owner
2812 */
2813 SendMessageA(pWnd->hwndSelf, WM_SHOWWINDOW, SW_SHOW, SW_PARENTOPENING);
2814 pWnd->flags &= ~WIN_NEEDS_SHOW_OWNEDPOPUP;
2815 }
2816 }
2817 else
2818 {
2819 if (IsWindowVisible(pWnd->hwndSelf))
2820 {
2821 /* In Windows, ShowOwnedPopups(FALSE) generates
2822 * WM_SHOWWINDOW messages with SW_PARENTCLOSING,
2823 * regardless of the state of the owner
2824 */
2825 SendMessageA(pWnd->hwndSelf, WM_SHOWWINDOW, SW_HIDE, SW_PARENTCLOSING);
2826 pWnd->flags |= WIN_NEEDS_SHOW_OWNEDPOPUP;
2827 }
2828 }
2829 }
2830 WIN_ReleaseWndPtr( pWnd );
2831 }
2832 HeapFree( GetProcessHeap(), 0, win_array );
2833 return TRUE;
2834 }
2835
2836
2837 /*******************************************************************
2838 * GetLastActivePopup (USER32.@)
2839 */
2840 HWND WINAPI GetLastActivePopup( HWND hwnd )
2841 {
2842 HWND retval = hwnd;
2843
2844 SERVER_START_REQ( get_window_info )
2845 {
2846 req->handle = hwnd;
2847 if (!wine_server_call_err( req )) retval = reply->last_active;
2848 }
2849 SERVER_END_REQ;
2850 return retval;
2851 }
2852
2853
2854 /*******************************************************************
2855 * WIN_ListParents
2856 *
2857 * Build an array of all parents of a given window, starting with
2858 * the immediate parent. The array must be freed with HeapFree.
2859 * Returns NULL if window is a top-level window.
2860 */
2861 HWND *WIN_ListParents( HWND hwnd )
2862 {
2863 WND *win;
2864 HWND current, *list;
2865 int pos = 0, size = 16, count = 0;
2866
2867 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL;
2868
2869 current = hwnd;
2870 for (;;)
2871 {
2872 if (!(win = WIN_GetPtr( current ))) goto empty;
2873 if (win == WND_OTHER_PROCESS) break; /* need to do it the hard way */
2874 list[pos] = win->parent;
2875 WIN_ReleasePtr( win );
2876 if (!(current = list[pos]))
2877 {
2878 if (!pos) goto empty;
2879 return list;
2880 }
2881 if (++pos == size - 1)
2882 {
2883 /* need to grow the list */
2884 HWND *new_list = HeapReAlloc( GetProcessHeap(), 0, list, (size+16) * sizeof(HWND) );
2885 if (!new_list) goto empty;
2886 list = new_list;
2887 size += 16;
2888 }
2889 }
2890
2891 /* at least one parent belongs to another process, have to query the server */
2892
2893 for (;;)
2894 {
2895 count = 0;
2896 SERVER_START_REQ( get_window_parents )
2897 {
2898 req->handle = hwnd;
2899 wine_server_set_reply( req, list, (size-1) * sizeof(HWND) );
2900 if (!wine_server_call( req )) count = reply->count;
2901 }
2902 SERVER_END_REQ;
2903 if (!count) goto empty;
2904 if (size > count)
2905 {
2906 list[count] = 0;
2907 return list;
2908 }
2909 HeapFree( GetProcessHeap(), 0, list );
2910 size = count + 1;
2911 if (!(list = HeapAlloc( GetProcessHeap(), 0, size * sizeof(HWND) ))) return NULL;
2912 }
2913
2914 empty:
2915 HeapFree( GetProcessHeap(), 0, list );
2916 return NULL;
2917 }
2918
2919
2920 /*******************************************************************
2921 * WIN_ListChildren
2922 *
2923 * Build an array of the children of a given window. The array must be
2924 * freed with HeapFree. Returns NULL when no windows are found.
2925 */
2926 HWND *WIN_ListChildren( HWND hwnd )
2927 {
2928 return list_window_children( hwnd, 0, 0 );
2929 }
2930
2931
2932 /*******************************************************************
2933 * EnumWindows (USER32.@)
2934 */
2935 BOOL WINAPI EnumWindows( WNDENUMPROC lpEnumFunc, LPARAM lParam )
2936 {
2937 HWND *list;
2938 BOOL ret = TRUE;
2939 int i, iWndsLocks;
2940
2941 /* We have to build a list of all windows first, to avoid */
2942 /* unpleasant side-effects, for instance if the callback */
2943 /* function changes the Z-order of the windows. */
2944
2945 if (!(list = WIN_ListChildren( GetDesktopWindow() ))) return TRUE;
2946
2947 /* Now call the callback function for every window */
2948
2949 iWndsLocks = WIN_SuspendWndsLock();
2950 for (i = 0; list[i]; i++)
2951 {
2952 /* Make sure that the window still exists */
2953 if (!IsWindow( list[i] )) continue;
2954 if (!(ret = lpEnumFunc( list[i], lParam ))) break;
2955 }
2956 WIN_RestoreWndsLock(iWndsLocks);
2957 HeapFree( GetProcessHeap(), 0, list );
2958 return ret;
2959 }
2960
2961
2962 /**********************************************************************
2963 * EnumThreadWindows (USER32.@)
2964 */
2965 BOOL WINAPI EnumThreadWindows( DWORD id, WNDENUMPROC func, LPARAM lParam )
2966 {
2967 HWND *list;
2968 int i, iWndsLocks;
2969
2970 if (!(list = list_window_children( GetDesktopWindow(), 0, id ))) return TRUE;
2971
2972 /* Now call the callback function for every window */
2973
2974 iWndsLocks = WIN_SuspendWndsLock();
2975 for (i = 0; list[i]; i++)
2976 if (!func( list[i], lParam )) break;
2977 WIN_RestoreWndsLock(iWndsLocks);
2978 HeapFree( GetProcessHeap(), 0, list );
2979 return TRUE;
2980 }
2981
2982
2983 /**********************************************************************
2984 * WIN_EnumChildWindows
2985 *
2986 * Helper function for EnumChildWindows().
2987 */
2988 static BOOL WIN_EnumChildWindows( HWND *list, WNDENUMPROC func, LPARAM lParam )
2989 {
2990 HWND *childList;
2991 BOOL ret = FALSE;
2992
2993 for ( ; *list; list++)
2994 {
2995 /* Make sure that the window still exists */
2996 if (!IsWindow( *list )) continue;
2997 /* skip owned windows */
2998 if (GetWindow( *list, GW_OWNER )) continue;
2999 /* Build children list first */
3000 childList = WIN_ListChildren( *list );
3001
3002 ret = func( *list, lParam );
3003
3004 if (childList)
3005 {
3006 if (ret) ret = WIN_EnumChildWindows( childList, func, lParam );
3007 HeapFree( GetProcessHeap(), 0, childList );
3008 }
3009 if (!ret) return FALSE;
3010 }
3011 return TRUE;
3012 }
3013
3014
3015 /**********************************************************************
3016 * EnumChildWindows (USER32.@)
3017 */
3018 BOOL WINAPI EnumChildWindows( HWND parent, WNDENUMPROC func, LPARAM lParam )
3019 {
3020 HWND *list;
3021 int iWndsLocks;
3022
3023 if (!(list = WIN_ListChildren( parent ))) return FALSE;
3024 iWndsLocks = WIN_SuspendWndsLock();
3025 WIN_EnumChildWindows( list, func, lParam );
3026 WIN_RestoreWndsLock(iWndsLocks);
3027 HeapFree( GetProcessHeap(), 0, list );
3028 return TRUE;
3029 }
3030
3031
3032 /*******************************************************************
3033 * AnyPopup (USER.52)
3034 */
3035 BOOL16 WINAPI AnyPopup16(void)
3036 {
3037 return AnyPopup();
3038 }
3039
3040
3041 /*******************************************************************
3042 * AnyPopup (USER32.@)
3043 */
3044 BOOL WINAPI AnyPopup(void)
3045 {
3046 int i;
3047 BOOL retvalue;
3048 HWND *list = WIN_ListChildren( GetDesktopWindow() );
3049
3050 if (!list) return FALSE;
3051 for (i = 0; list[i]; i++)
3052 {
3053 if (IsWindowVisible( list[i] ) && GetWindow( list[i], GW_OWNER )) break;
3054 }
3055 retvalue = (list[i] != 0);
3056 HeapFree( GetProcessHeap(), 0, list );
3057 return retvalue;
3058 }
3059
3060
3061 /*******************************************************************
3062 * FlashWindow (USER32.@)
3063 */
3064 BOOL WINAPI FlashWindow( HWND hWnd, BOOL bInvert )
3065 {
3066 WND *wndPtr = WIN_FindWndPtr(hWnd);
3067
3068 TRACE("%p\n", hWnd);
3069
3070 if (!wndPtr) return FALSE;
3071 hWnd = wndPtr->hwndSelf; /* make it a full handle */
3072
3073 if (wndPtr->dwStyle & WS_MINIMIZE)
3074 {
3075 if (bInvert && !(wndPtr->flags & WIN_NCACTIVATED))
3076 {
3077 HDC hDC = GetDC(hWnd);
3078
3079 if (!SendMessageW( hWnd, WM_ERASEBKGND, (WPARAM)hDC, 0 ))
3080 wndPtr->flags |= WIN_NEEDS_ERASEBKGND;
3081
3082 ReleaseDC( hWnd, hDC );
3083 wndPtr->flags |= WIN_NCACTIVATED;
3084 }
3085 else
3086 {
3087 RedrawWindow( hWnd, 0, 0, RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_FRAME );
3088 wndPtr->flags &= ~WIN_NCACTIVATED;
3089 }
3090 WIN_ReleaseWndPtr(wndPtr);
3091 return TRUE;
3092 }
3093 else
3094 {
3095 WPARAM16 wparam;
3096 if (bInvert) wparam = !(wndPtr->flags & WIN_NCACTIVATED);
3097 else wparam = (hWnd == GetForegroundWindow());
3098
3099 WIN_ReleaseWndPtr(wndPtr);
3100 SendMessageW( hWnd, WM_NCACTIVATE, wparam, (LPARAM)0 );
3101 return wparam;
3102 }
3103 }
3104
3105
3106 /*******************************************************************
3107 * GetWindowContextHelpId (USER32.@)
3108 */
3109 DWORD WINAPI GetWindowContextHelpId( HWND hwnd )
3110 {
3111 DWORD retval;
3112 WND *wnd = WIN_FindWndPtr( hwnd );
3113 if (!wnd) return 0;
3114 retval = wnd->helpContext;
3115 WIN_ReleaseWndPtr(wnd);
3116 return retval;
3117 }
3118
3119
3120 /*******************************************************************
3121 * SetWindowContextHelpId (USER32.@)
3122 */
3123 BOOL WINAPI SetWindowContextHelpId( HWND hwnd, DWORD id )
3124 {
3125 WND *wnd = WIN_FindWndPtr( hwnd );
3126 if (!wnd) return FALSE;
3127 wnd->helpContext = id;
3128 WIN_ReleaseWndPtr(wnd);
3129 return TRUE;
3130 }
3131
3132
3133 /*******************************************************************
3134 * DragDetect (USER32.@)
3135 */
3136 BOOL WINAPI DragDetect( HWND hWnd, POINT pt )
3137 {
3138 MSG msg;
3139 RECT rect;
3140
3141 rect.left = pt.x - wDragWidth;
3142 rect.right = pt.x + wDragWidth;
3143
3144 rect.top = pt.y - wDragHeight;
3145 rect.bottom = pt.y + wDragHeight;
3146
3147 SetCapture(hWnd);
3148
3149 while(1)
3150 {
3151 while(PeekMessageA(&msg ,0 ,WM_MOUSEFIRST ,WM_MOUSELAST ,PM_REMOVE))
3152 {
3153 if( msg.message == WM_LBUTTONUP )
3154 {
3155 ReleaseCapture();
3156 return 0;
3157 }
3158 if( msg.message == WM_MOUSEMOVE )
3159 {
3160 POINT tmp;
3161 tmp.x = LOWORD(msg.lParam);
3162 tmp.y = HIWORD(msg.lParam);
3163 if( !PtInRect( &rect, tmp ))
3164 {
3165 ReleaseCapture();
3166 return 1;
3167 }
3168 }
3169 }
3170 WaitMessage();
3171 }
3172 return 0;
3173 }
3174
3175 /******************************************************************************
3176 * GetWindowModuleFileNameA (USER32.@)
3177 */
3178 UINT WINAPI GetWindowModuleFileNameA( HWND hwnd, LPSTR lpszFileName, UINT cchFileNameMax)
3179 {
3180 FIXME("GetWindowModuleFileNameA(hwnd %p, lpszFileName %p, cchFileNameMax %u) stub!\n",
3181 hwnd, lpszFileName, cchFileNameMax);
3182 return 0;
3183 }
3184
3185 /******************************************************************************
3186 * GetWindowModuleFileNameW (USER32.@)
3187 */
3188 UINT WINAPI GetWindowModuleFileNameW( HWND hwnd, LPSTR lpszFileName, UINT cchFileNameMax)
3189 {
3190 FIXME("GetWindowModuleFileNameW(hwnd %p, lpszFileName %p, cchFileNameMax %u) stub!\n",
3191 hwnd, lpszFileName, cchFileNameMax);
3192 return 0;
3193 }
3194
3195 /******************************************************************************
3196 * GetWindowInfo (USER32.@)
3197 * hwnd: in
3198 * pwi: out.
3199 * MS Documentation mentions that pwi->cbSize must be set to SIZEOF(WINDOWINFO)
3200 * this may be because this structure changed over time. If this is the
3201 * the case, then please: FIXME.
3202 * Using the structure described in MSDN for 98/ME/NT(4.0 SP3)/2000/XP.
3203 */
3204 BOOL WINAPI GetWindowInfo( HWND hwnd, PWINDOWINFO pwi)
3205 {
3206 WND *wndInfo = NULL;
3207 if (!pwi) return FALSE;
3208 if (pwi->cbSize != sizeof(WINDOWINFO))
3209 {
3210 FIXME("windowinfo->cbSize != sizeof(WINDOWINFO). Please report\n");
3211 return FALSE;
3212 }
3213 wndInfo = WIN_GetPtr(hwnd);
3214 if (!wndInfo) return FALSE;
3215 if (wndInfo == WND_OTHER_PROCESS)
3216 {
3217 FIXME("window belong to other process\n");
3218 return FALSE;
3219 }
3220
3221 pwi->rcWindow = wndInfo->rectWindow;
3222 pwi->rcClient = wndInfo->rectClient;
3223 pwi->dwStyle = wndInfo->dwStyle;
3224 pwi->dwExStyle = wndInfo->dwExStyle;
3225 pwi->dwWindowStatus = ((GetActiveWindow() == hwnd) ? WS_ACTIVECAPTION : 0);
3226 /* if active WS_ACTIVECAPTION, else 0 */
3227
3228 pwi->cxWindowBorders = ((wndInfo->dwStyle & WS_BORDER) ?
3229 GetSystemMetrics(SM_CXBORDER) : 0);
3230 pwi->cyWindowBorders = ((wndInfo->dwStyle & WS_BORDER) ?
3231 GetSystemMetrics(SM_CYBORDER) : 0);
3232 /* above two: I'm presuming that borders widths are the same
3233 * for each window - so long as its actually using a border.. */
3234
3235 pwi->atomWindowType = GetClassLongA( hwnd, GCW_ATOM );
3236 pwi->wCreatorVersion = GetVersion();
3237 /* Docs say this should be the version that
3238 * CREATED the window. But eh?.. Isn't that just the
3239 * version we are running.. Unless ofcourse its some wacky
3240 * RPC stuff or something */
3241
3242 WIN_ReleasePtr(wndInfo);
3243 return TRUE;
3244 }
Maarten's multimedia branch