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