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