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