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