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