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