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