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