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