?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 961208
[wine.git] / windows / win.c
blob56cfa04a461f3a6b02665758f77cd601fe380d84
1 /*
2 * Window related functions
3 *
4 * Copyright 1993, 1994 Alexandre Julliard
5 */
6
7 #include <stdlib.h>
8 #include <stdio.h>
9 #include <string.h>
10 #include <X11/Xatom.h>
11
12 #include "options.h"
13 #include "class.h"
14 #include "win.h"
15 #include "heap.h"
16 #include "user.h"
17 #include "dce.h"
18 #include "sysmetrics.h"
19 #include "cursoricon.h"
20 #include "heap.h"
21 #include "hook.h"
22 #include "menu.h"
23 #include "message.h"
24 #include "nonclient.h"
25 #include "string32.h"
26 #include "queue.h"
27 #include "winpos.h"
28 #include "color.h"
29 #include "shm_main_blk.h"
30 #include "dde_proc.h"
31 #include "clipboard.h"
32 #include "winproc.h"
33 #include "stddebug.h"
34 /* #define DEBUG_WIN */
35 /* #define DEBUG_MENU */
36 #include "debug.h"
37
38 /* Desktop window */
39 static WND *pWndDesktop = NULL;
40
41 static HWND hwndSysModal = 0;
42
43 static WORD wDragWidth = 4;
44 static WORD wDragHeight= 3;
45
46 extern HCURSOR16 CURSORICON_IconToCursor(HICON16, BOOL32);
47 extern HWND32 CARET_GetHwnd(void);
48 extern BOOL32 WINPOS_ActivateOtherWindow(WND* pWnd);
49 extern void WINPOS_CheckActive(HWND32);
50
51 /***********************************************************************
52 * WIN_FindWndPtr
53 *
54 * Return a pointer to the WND structure corresponding to a HWND.
55 */
56 WND * WIN_FindWndPtr( HWND32 hwnd )
57 {
58 WND * ptr;
59
60 if (!hwnd || HIWORD(hwnd)) return NULL;
61 ptr = (WND *) USER_HEAP_LIN_ADDR( hwnd );
62 if (ptr->dwMagic != WND_MAGIC) return NULL;
63 if (ptr->hwndSelf != hwnd)
64 {
65 fprintf( stderr, "Can't happen: hwnd %04x self pointer is %04x\n",
66 hwnd, ptr->hwndSelf );
67 return NULL;
68 }
69 return ptr;
70 }
71
72
73 /***********************************************************************
74 * WIN_DumpWindow
75 *
76 * Dump the content of a window structure to stderr.
77 */
78 void WIN_DumpWindow( HWND32 hwnd )
79 {
80 WND *ptr;
81 char className[80];
82 int i;
83
84 if (!(ptr = WIN_FindWndPtr( hwnd )))
85 {
86 fprintf( stderr, "%04x is not a window handle\n", hwnd );
87 return;
88 }
89
90 if (!GetClassName32A( hwnd, className, sizeof(className ) ))
91 strcpy( className, "#NULL#" );
92
93 fprintf( stderr, "Window %04x (%p):\n", hwnd, ptr );
94 fprintf( stderr,
95 "next=%p child=%p parent=%p owner=%p class=%p '%s'\n"
96 "inst=%04x taskQ=%04x updRgn=%04x active=%04x dce=%p idmenu=%04x\n"
97 "style=%08lx exstyle=%08lx wndproc=%08x text='%s'\n"
98 "client=%d,%d-%d,%d window=%d,%d-%d,%d iconpos=%d,%d maxpos=%d,%d\n"
99 "sysmenu=%04x flags=%04x props=%p vscroll=%p hscroll=%p\n",
100 ptr->next, ptr->child, ptr->parent, ptr->owner,
101 ptr->class, className, ptr->hInstance, ptr->hmemTaskQ,
102 ptr->hrgnUpdate, ptr->hwndLastActive, ptr->dce, ptr->wIDmenu,
103 ptr->dwStyle, ptr->dwExStyle, (UINT32)ptr->winproc,
104 ptr->text ? ptr->text : "",
105 ptr->rectClient.left, ptr->rectClient.top, ptr->rectClient.right,
106 ptr->rectClient.bottom, ptr->rectWindow.left, ptr->rectWindow.top,
107 ptr->rectWindow.right, ptr->rectWindow.bottom, ptr->ptIconPos.x,
108 ptr->ptIconPos.y, ptr->ptMaxPos.x, ptr->ptMaxPos.y, ptr->hSysMenu,
109 ptr->flags, ptr->pProp, ptr->pVScroll, ptr->pHScroll );
110
111 if (ptr->class->cbWndExtra)
112 {
113 fprintf( stderr, "extra bytes:" );
114 for (i = 0; i < ptr->class->cbWndExtra; i++)
115 fprintf( stderr, " %02x", *((BYTE*)ptr->wExtra+i) );
116 fprintf( stderr, "\n" );
117 }
118 fprintf( stderr, "\n" );
119 }
120
121
122 /***********************************************************************
123 * WIN_WalkWindows
124 *
125 * Walk the windows tree and print each window on stderr.
126 */
127 void WIN_WalkWindows( HWND32 hwnd, int indent )
128 {
129 WND *ptr;
130 char className[80];
131
132 ptr = hwnd ? WIN_FindWndPtr( hwnd ) : pWndDesktop;
133 if (!ptr)
134 {
135 fprintf( stderr, "*** Invalid window handle %04x\n", hwnd );
136 return;
137 }
138
139 if (!indent) /* first time around */
140 fprintf( stderr, "%-16.16s %-8.8s %-6.6s %-17.17s %-8.8s %s\n",
141 "hwnd", " wndPtr", "queue", "Class Name", " Style", " WndProc");
142
143 while (ptr)
144 {
145 fprintf(stderr, "%*s%04x%*s", indent, "", ptr->hwndSelf, 13-indent,"");
146
147 GlobalGetAtomName16(ptr->class->atomName,className,sizeof(className));
148
149 fprintf( stderr, "%08lx %-6.4x %-17.17s %08x %08x\n",
150 (DWORD)ptr, ptr->hmemTaskQ, className,
151 (UINT32)ptr->dwStyle, (UINT32)ptr->winproc );
152
153 if (ptr->child) WIN_WalkWindows( ptr->child->hwndSelf, indent+1 );
154 ptr = ptr->next;
155 }
156 }
157
158
159 /***********************************************************************
160 * WIN_GetXWindow
161 *
162 * Return the X window associated to a window.
163 */
164 Window WIN_GetXWindow( HWND32 hwnd )
165 {
166 WND *wndPtr = WIN_FindWndPtr( hwnd );
167 while (wndPtr && !wndPtr->window) wndPtr = wndPtr->parent;
168 return wndPtr ? wndPtr->window : 0;
169 }
170
171
172 /***********************************************************************
173 * WIN_UnlinkWindow
174 *
175 * Remove a window from the siblings linked list.
176 */
177 BOOL32 WIN_UnlinkWindow( HWND32 hwnd )
178 {
179 WND *wndPtr, **ppWnd;
180
181 if (!(wndPtr = WIN_FindWndPtr( hwnd )) || !wndPtr->parent) return FALSE;
182 ppWnd = &wndPtr->parent->child;
183 while (*ppWnd != wndPtr) ppWnd = &(*ppWnd)->next;
184 *ppWnd = wndPtr->next;
185 return TRUE;
186 }
187
188
189 /***********************************************************************
190 * WIN_LinkWindow
191 *
192 * Insert a window into the siblings linked list.
193 * The window is inserted after the specified window, which can also
194 * be specified as HWND_TOP or HWND_BOTTOM.
195 */
196 BOOL32 WIN_LinkWindow( HWND32 hwnd, HWND32 hwndInsertAfter )
197 {
198 WND *wndPtr, **ppWnd;
199
200 if (!(wndPtr = WIN_FindWndPtr( hwnd )) || !wndPtr->parent) return FALSE;
201
202 if ((hwndInsertAfter == HWND_TOP) || (hwndInsertAfter == HWND_BOTTOM))
203 {
204 ppWnd = &wndPtr->parent->child; /* Point to first sibling hwnd */
205 if (hwndInsertAfter == HWND_BOTTOM) /* Find last sibling hwnd */
206 while (*ppWnd) ppWnd = &(*ppWnd)->next;
207 }
208 else /* Normal case */
209 {
210 WND * afterPtr = WIN_FindWndPtr( hwndInsertAfter );
211 if (!afterPtr) return FALSE;
212 ppWnd = &afterPtr->next;
213 }
214 wndPtr->next = *ppWnd;
215 *ppWnd = wndPtr;
216 return TRUE;
217 }
218
219
220 /***********************************************************************
221 * WIN_FindWinToRepaint
222 *
223 * Find a window that needs repaint.
224 */
225 HWND32 WIN_FindWinToRepaint( HWND32 hwnd, HQUEUE16 hQueue )
226 {
227 HWND hwndRet;
228 WND *pWnd = pWndDesktop;
229
230 /* Note: the desktop window never gets WM_PAINT messages
231 * The real reason why is because Windows DesktopWndProc
232 * does ValidateRgn inside WM_ERASEBKGND handler.
233 */
234
235 pWnd = hwnd ? WIN_FindWndPtr( hwnd ) : pWndDesktop->child;
236
237 for ( ; pWnd ; pWnd = pWnd->next )
238 {
239 if (!(pWnd->dwStyle & WS_VISIBLE) || (pWnd->flags & WIN_NO_REDRAW))
240 {
241 dprintf_win( stddeb, "FindWinToRepaint: skipping window %04x\n",
242 pWnd->hwndSelf );
243 continue;
244 }
245 if ((pWnd->hmemTaskQ == hQueue) &&
246 (pWnd->hrgnUpdate || (pWnd->flags & WIN_INTERNAL_PAINT))) break;
247
248 if (pWnd->child )
249 if ((hwndRet = WIN_FindWinToRepaint( pWnd->child->hwndSelf, hQueue )) )
250 return hwndRet;
251 }
252
253 if (!pWnd) return 0;
254
255 hwndRet = pWnd->hwndSelf;
256
257 /* look among siblings if we got a transparent window */
258 while (pWnd && ((pWnd->dwExStyle & WS_EX_TRANSPARENT) ||
259 !(pWnd->hrgnUpdate || (pWnd->flags & WIN_INTERNAL_PAINT))))
260 {
261 pWnd = pWnd->next;
262 }
263 if (pWnd) hwndRet = pWnd->hwndSelf;
264 dprintf_win(stddeb,"FindWinToRepaint: found %04x\n",hwndRet);
265 return hwndRet;
266 }
267
268
269 /***********************************************************************
270 * WIN_SendParentNotify
271 *
272 * Send a WM_PARENTNOTIFY to all ancestors of the given window, unless
273 * the window has the WS_EX_NOPARENTNOTIFY style.
274 */
275 void WIN_SendParentNotify(HWND32 hwnd, WORD event, WORD idChild, LPARAM lValue)
276 {
277 LPPOINT16 lppt = (LPPOINT16)&lValue;
278 WND *wndPtr = WIN_FindWndPtr( hwnd );
279 BOOL bMouse = ((event <= WM_MOUSELAST) && (event >= WM_MOUSEFIRST));
280
281 /* if lValue contains cursor coordinates they have to be
282 * mapped to the client area of parent window */
283
284 if (bMouse) MapWindowPoints16( 0, hwnd, lppt, 1 );
285
286 while (wndPtr)
287 {
288 if ((wndPtr->dwExStyle & WS_EX_NOPARENTNOTIFY) ||
289 !(wndPtr->dwStyle & WS_CHILD)) break;
290
291 if (bMouse)
292 {
293 lppt->x += wndPtr->rectClient.left;
294 lppt->y += wndPtr->rectClient.top;
295 }
296
297 wndPtr = wndPtr->parent;
298 SendMessage32A( wndPtr->hwndSelf, WM_PARENTNOTIFY,
299 MAKEWPARAM( event, idChild ), lValue );
300 }
301 }
302
303
304 /***********************************************************************
305 * WIN_DestroyWindow
306 *
307 * Destroy storage associated to a window. "Internals" p.358
308 */
309 static void WIN_DestroyWindow( WND* wndPtr )
310 {
311 HWND hwnd = wndPtr->hwndSelf;
312 WND* pWnd,*pNext;
313
314 dprintf_win( stddeb, "WIN_DestroyWindow: %04x\n", wndPtr->hwndSelf );
315
316 #ifdef CONFIG_IPC
317 if (main_block)
318 DDE_DestroyWindow(wndPtr->hwndSelf);
319 #endif /* CONFIG_IPC */
320
321 /* free child windows */
322
323 pNext = wndPtr->child;
324 while( (pWnd = pNext) )
325 {
326 pNext = pWnd->next;
327 WIN_DestroyWindow( pWnd );
328 }
329
330 SendMessage32A( wndPtr->hwndSelf, WM_NCDESTROY, 0, 0);
331
332 /* FIXME: do we need to fake QS_MOUSEMOVE wakebit? */
333
334 WINPOS_CheckActive( hwnd );
335 if( hwnd == GetCapture32()) ReleaseCapture();
336
337 /* free resources associated with the window */
338
339 TIMER_RemoveWindowTimers( wndPtr->hwndSelf );
340 PROPERTY_RemoveWindowProps( wndPtr );
341
342 wndPtr->dwMagic = 0; /* Mark it as invalid */
343 wndPtr->hwndSelf = 0;
344
345 if ((wndPtr->hrgnUpdate) || (wndPtr->flags & WIN_INTERNAL_PAINT))
346 {
347 if (wndPtr->hrgnUpdate) DeleteObject32( wndPtr->hrgnUpdate );
348 QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
349 }
350
351 /* toss stale messages from the queue */
352
353 if( wndPtr->hmemTaskQ )
354 {
355 int pos;
356 MESSAGEQUEUE* msgQ = (MESSAGEQUEUE*) GlobalLock16(wndPtr->hmemTaskQ);
357
358 while( (pos = QUEUE_FindMsg(msgQ, hwnd, 0, 0)) != -1 )
359 QUEUE_RemoveMsg(msgQ, pos);
360 wndPtr->hmemTaskQ = 0;
361 }
362
363 if (!(wndPtr->dwStyle & WS_CHILD))
364 if (wndPtr->wIDmenu) DestroyMenu( (HMENU16)wndPtr->wIDmenu );
365 if (wndPtr->hSysMenu) DestroyMenu( wndPtr->hSysMenu );
366 if (wndPtr->window) XDestroyWindow( display, wndPtr->window );
367 if (wndPtr->class->style & CS_OWNDC) DCE_FreeDCE( wndPtr->dce );
368
369 WINPROC_FreeProc( wndPtr->winproc );
370
371 wndPtr->class->cWindows--;
372 wndPtr->class = NULL;
373
374 USER_HEAP_FREE( hwnd );
375 }
376
377 /***********************************************************************
378 * WIN_ResetQueueWindows
379 */
380 void WIN_ResetQueueWindows( WND* wnd, HQUEUE16 hQueue, HQUEUE16 hNew )
381 {
382 WND* next;
383
384 while (wnd)
385 {
386 next = wnd->next;
387 if (wnd->hmemTaskQ == hQueue)
388 if( hNew ) wnd->hmemTaskQ = hNew;
389 else DestroyWindow( wnd->hwndSelf );
390 else WIN_ResetQueueWindows( wnd->child, hQueue, hNew );
391 wnd = next;
392 }
393 }
394
395 /***********************************************************************
396 * WIN_CreateDesktopWindow
397 *
398 * Create the desktop window.
399 */
400 BOOL32 WIN_CreateDesktopWindow(void)
401 {
402 CLASS *class;
403 HWND hwndDesktop;
404
405 dprintf_win(stddeb,"Creating desktop window\n");
406
407 if (!(class = CLASS_FindClassByAtom( DESKTOP_CLASS_ATOM, 0 )))
408 return FALSE;
409
410 hwndDesktop = USER_HEAP_ALLOC( sizeof(WND)+class->cbWndExtra );
411 if (!hwndDesktop) return FALSE;
412 pWndDesktop = (WND *) USER_HEAP_LIN_ADDR( hwndDesktop );
413
414 pWndDesktop->next = NULL;
415 pWndDesktop->child = NULL;
416 pWndDesktop->parent = NULL;
417 pWndDesktop->owner = NULL;
418 pWndDesktop->class = class;
419 pWndDesktop->winproc = NULL;
420 pWndDesktop->dwMagic = WND_MAGIC;
421 pWndDesktop->hwndSelf = hwndDesktop;
422 pWndDesktop->hInstance = 0;
423 pWndDesktop->rectWindow.left = 0;
424 pWndDesktop->rectWindow.top = 0;
425 pWndDesktop->rectWindow.right = SYSMETRICS_CXSCREEN;
426 pWndDesktop->rectWindow.bottom = SYSMETRICS_CYSCREEN;
427 pWndDesktop->rectClient = pWndDesktop->rectWindow;
428 pWndDesktop->rectNormal = pWndDesktop->rectWindow;
429 pWndDesktop->ptIconPos.x = -1;
430 pWndDesktop->ptIconPos.y = -1;
431 pWndDesktop->ptMaxPos.x = -1;
432 pWndDesktop->ptMaxPos.y = -1;
433 pWndDesktop->text = NULL;
434 pWndDesktop->hmemTaskQ = 0; /* Desktop does not belong to a task */
435 pWndDesktop->hrgnUpdate = 0;
436 pWndDesktop->hwndLastActive = hwndDesktop;
437 pWndDesktop->dwStyle = WS_VISIBLE | WS_CLIPCHILDREN |
438 WS_CLIPSIBLINGS;
439 pWndDesktop->dwExStyle = 0;
440 pWndDesktop->dce = NULL;
441 pWndDesktop->pVScroll = NULL;
442 pWndDesktop->pHScroll = NULL;
443 pWndDesktop->pProp = NULL;
444 pWndDesktop->wIDmenu = 0;
445 pWndDesktop->flags = 0;
446 pWndDesktop->window = rootWindow;
447 pWndDesktop->hSysMenu = 0;
448 pWndDesktop->userdata = 0;
449
450 WINPROC_SetProc( &pWndDesktop->winproc, (WNDPROC16)class->winproc, 0 );
451 EVENT_RegisterWindow( pWndDesktop );
452 SendMessage32A( hwndDesktop, WM_NCCREATE, 0, 0 );
453 pWndDesktop->flags |= WIN_NEEDS_ERASEBKGND;
454 return TRUE;
455 }
456
457
458 /***********************************************************************
459 * WIN_CreateWindowEx
460 *
461 * Implementation of CreateWindowEx().
462 */
463 static HWND WIN_CreateWindowEx( CREATESTRUCT32A *cs, ATOM classAtom,
464 BOOL unicode )
465 {
466 CLASS *classPtr;
467 WND *wndPtr;
468 HWND16 hwnd, hwndLinkAfter;
469 POINT16 maxSize, maxPos, minTrack, maxTrack;
470 LRESULT wmcreate;
471
472 dprintf_win( stddeb, "CreateWindowEx: " );
473 if (HIWORD(cs->lpszName)) dprintf_win( stddeb, "'%s' ", cs->lpszName );
474 else dprintf_win( stddeb, "#%04x ", LOWORD(cs->lpszName) );
475 if (HIWORD(cs->lpszClass)) dprintf_win( stddeb, "'%s' ", cs->lpszClass );
476 else dprintf_win( stddeb, "#%04x ", LOWORD(cs->lpszClass) );
477
478 dprintf_win( stddeb, "%08lx %08lx %d,%d %dx%d %04x %04x %04x %p\n",
479 cs->dwExStyle, cs->style, cs->x, cs->y, cs->cx, cs->cy,
480 cs->hwndParent, cs->hMenu, cs->hInstance, cs->lpCreateParams);
481
482 /* Find the parent window */
483
484 if (cs->hwndParent)
485 {
486 /* Make sure parent is valid */
487 if (!IsWindow( cs->hwndParent ))
488 {
489 fprintf( stderr, "CreateWindowEx: bad parent %04x\n", cs->hwndParent );
490 return 0;
491 }
492 }
493 else if (cs->style & WS_CHILD)
494 {
495 fprintf( stderr, "CreateWindowEx: no parent for child window\n" );
496 return 0; /* WS_CHILD needs a parent */
497 }
498
499 /* Find the window class */
500
501 if (!(classPtr = CLASS_FindClassByAtom( classAtom,
502 GetExePtr(cs->hInstance) )))
503 {
504 char buffer[256];
505 GlobalGetAtomName32A( classAtom, buffer, sizeof(buffer) );
506 fprintf( stderr, "CreateWindowEx: bad class '%s'\n", buffer );
507 return 0;
508 }
509
510 /* Fix the coordinates */
511
512 if (cs->x == CW_USEDEFAULT32) cs->x = cs->y = 0;
513 if (cs->cx == CW_USEDEFAULT32)
514 {
515 /* if (!(cs->style & (WS_CHILD | WS_POPUP))) cs->cx = cs->cy = 0;
516 else */
517 {
518 cs->cx = 600;
519 cs->cy = 400;
520 }
521 }
522
523 /* Create the window structure */
524
525 if (!(hwnd = USER_HEAP_ALLOC( sizeof(*wndPtr) + classPtr->cbWndExtra
526 - sizeof(wndPtr->wExtra) )))
527 {
528 dprintf_win( stddeb, "CreateWindowEx: out of memory\n" );
529 return 0;
530 }
531
532 /* Fill the window structure */
533
534 wndPtr = (WND *) USER_HEAP_LIN_ADDR( hwnd );
535 wndPtr->next = NULL;
536 wndPtr->child = NULL;
537
538 if (cs->style & WS_CHILD)
539 {
540 wndPtr->parent = WIN_FindWndPtr( cs->hwndParent );
541 wndPtr->owner = NULL;
542 }
543 else
544 {
545 wndPtr->parent = pWndDesktop;
546 if (!cs->hwndParent || (cs->hwndParent == pWndDesktop->hwndSelf))
547 wndPtr->owner = NULL;
548 else
549 wndPtr->owner = WIN_FindWndPtr(WIN_GetTopParent(cs->hwndParent));
550 }
551
552 wndPtr->window = 0;
553 wndPtr->class = classPtr;
554 wndPtr->winproc = NULL;
555 wndPtr->dwMagic = WND_MAGIC;
556 wndPtr->hwndSelf = hwnd;
557 wndPtr->hInstance = cs->hInstance;
558 wndPtr->ptIconPos.x = -1;
559 wndPtr->ptIconPos.y = -1;
560 wndPtr->ptMaxPos.x = -1;
561 wndPtr->ptMaxPos.y = -1;
562 wndPtr->text = NULL;
563 wndPtr->hmemTaskQ = GetTaskQueue(0);
564 wndPtr->hrgnUpdate = 0;
565 wndPtr->hwndLastActive = hwnd;
566 wndPtr->dwStyle = cs->style & ~WS_VISIBLE;
567 wndPtr->dwExStyle = cs->dwExStyle;
568 wndPtr->wIDmenu = 0;
569 wndPtr->flags = 0;
570 wndPtr->pVScroll = NULL;
571 wndPtr->pHScroll = NULL;
572 wndPtr->pProp = NULL;
573 wndPtr->hSysMenu = MENU_GetDefSysMenu();
574 wndPtr->userdata = 0;
575
576 if (classPtr->cbWndExtra) memset( wndPtr->wExtra, 0, classPtr->cbWndExtra);
577
578 /* Call the WH_CBT hook */
579
580 hwndLinkAfter = (cs->style & WS_CHILD) ? HWND_BOTTOM : HWND_TOP;
581
582 if (HOOK_IsHooked( WH_CBT ))
583 {
584 CBT_CREATEWND32A cbtc;
585
586 cbtc.lpcs = cs;
587 cbtc.hwndInsertAfter = hwndLinkAfter;
588 wmcreate = !HOOK_CallHooks32A( WH_CBT, HCBT_CREATEWND, hwnd,
589 (LPARAM)&cbtc );
590 if (!wmcreate)
591 {
592 dprintf_win(stddeb, "CreateWindowEx: CBT-hook returned 0\n");
593 USER_HEAP_FREE( hwnd );
594 return 0;
595 }
596 }
597
598 /* Set the window procedure */
599
600 classPtr->cWindows++;
601 WINPROC_SetProc( &wndPtr->winproc, (WNDPROC16)classPtr->winproc, 0 );
602
603 /* Correct the window style */
604
605 if (!(cs->style & (WS_POPUP | WS_CHILD))) /* Overlapped window */
606 {
607 wndPtr->dwStyle |= WS_CAPTION | WS_CLIPSIBLINGS;
608 wndPtr->flags |= WIN_NEED_SIZE;
609 }
610 if (cs->dwExStyle & WS_EX_DLGMODALFRAME) wndPtr->dwStyle &= ~WS_THICKFRAME;
611
612 /* Get class or window DC if needed */
613
614 if (classPtr->style & CS_OWNDC) wndPtr->dce = DCE_AllocDCE(hwnd,DCE_WINDOW_DC);
615 else if (classPtr->style & CS_CLASSDC) wndPtr->dce = classPtr->dce;
616 else wndPtr->dce = NULL;
617
618 /* Insert the window in the linked list */
619
620 WIN_LinkWindow( hwnd, hwndLinkAfter );
621
622 /* Send the WM_GETMINMAXINFO message and fix the size if needed */
623
624 if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD)))
625 {
626 NC_GetMinMaxInfo( wndPtr, &maxSize, &maxPos, &minTrack, &maxTrack );
627 if (maxSize.x < cs->cx) cs->cx = maxSize.x;
628 if (maxSize.y < cs->cy) cs->cy = maxSize.y;
629 if (cs->cx < minTrack.x ) cs->cx = minTrack.x;
630 if (cs->cy < minTrack.y ) cs->cy = minTrack.y;
631 }
632 if (cs->cx <= 0) cs->cx = 1;
633 if (cs->cy <= 0) cs->cy = 1;
634
635 wndPtr->rectWindow.left = cs->x;
636 wndPtr->rectWindow.top = cs->y;
637 wndPtr->rectWindow.right = cs->x + cs->cx;
638 wndPtr->rectWindow.bottom = cs->y + cs->cy;
639 wndPtr->rectClient = wndPtr->rectWindow;
640 wndPtr->rectNormal = wndPtr->rectWindow;
641
642 /* Create the X window (only for top-level windows, and then only */
643 /* when there's no desktop window) */
644
645 if (!(cs->style & WS_CHILD) && (rootWindow == DefaultRootWindow(display)))
646 {
647 XSetWindowAttributes win_attr;
648
649 if (Options.managed && ((cs->style & (WS_DLGFRAME | WS_THICKFRAME)) ||
650 (cs->dwExStyle & WS_EX_DLGMODALFRAME)))
651 {
652 win_attr.event_mask = ExposureMask | KeyPressMask |
653 KeyReleaseMask | PointerMotionMask |
654 ButtonPressMask | ButtonReleaseMask |
655 FocusChangeMask | StructureNotifyMask;
656 win_attr.override_redirect = FALSE;
657 wndPtr->flags |= WIN_MANAGED;
658 }
659 else
660 {
661 win_attr.event_mask = ExposureMask | KeyPressMask |
662 KeyReleaseMask | PointerMotionMask |
663 ButtonPressMask | ButtonReleaseMask |
664 FocusChangeMask | StructureNotifyMask;
665 win_attr.override_redirect = TRUE;
666 }
667 win_attr.colormap = COLOR_GetColormap();
668 win_attr.backing_store = Options.backingstore ? WhenMapped : NotUseful;
669 win_attr.save_under = ((classPtr->style & CS_SAVEBITS) != 0);
670 win_attr.cursor = CURSORICON_XCursor;
671 wndPtr->window = XCreateWindow( display, rootWindow, cs->x, cs->y,
672 cs->cx, cs->cy, 0, CopyFromParent,
673 InputOutput, CopyFromParent,
674 CWEventMask | CWOverrideRedirect |
675 CWColormap | CWCursor | CWSaveUnder |
676 CWBackingStore, &win_attr );
677
678 if ((wndPtr->flags & WIN_MANAGED) &&
679 (cs->dwExStyle & WS_EX_DLGMODALFRAME))
680 {
681 XSizeHints* size_hints = XAllocSizeHints();
682
683 if (size_hints)
684 {
685 size_hints->min_width = size_hints->max_width = cs->cx;
686 size_hints->min_height = size_hints->max_height = cs->cy;
687 size_hints->flags = (PSize | PMinSize | PMaxSize);
688 XSetWMSizeHints( display, wndPtr->window, size_hints,
689 XA_WM_NORMAL_HINTS );
690 XFree(size_hints);
691 }
692 }
693
694 if (cs->hwndParent) /* Get window owner */
695 {
696 Window win = WIN_GetXWindow( cs->hwndParent );
697 if (win) XSetTransientForHint( display, wndPtr->window, win );
698 }
699 EVENT_RegisterWindow( wndPtr );
700 }
701
702 /* Set the window menu */
703
704 if ((cs->style & WS_CAPTION) && !(cs->style & WS_CHILD))
705 {
706 if (cs->hMenu) SetMenu(hwnd, cs->hMenu);
707 else
708 {
709 #if 0 /* FIXME: should check if classPtr->menuNameW can be used as is */
710 if (classPtr->menuNameA)
711 cs->hMenu = HIWORD(classPtr->menuNameA) ?
712 LoadMenu(cs->hInstance,SEGPTR_GET(classPtr->menuNameA)):
713 LoadMenu(cs->hInstance,(SEGPTR)classPtr->menuNameA);
714 #else
715 SEGPTR menuName = (SEGPTR)GetClassLong16( hwnd, GCL_MENUNAME );
716 if (menuName) cs->hMenu = LoadMenu16( cs->hInstance, menuName );
717 #endif
718 }
719 if (cs->hMenu) SetMenu( hwnd, cs->hMenu );
720 }
721 else wndPtr->wIDmenu = (UINT)cs->hMenu;
722
723 /* Send the WM_CREATE message
724 * Perhaps we shouldn't allow width/height changes as well.
725 * See p327 in "Internals".
726 */
727
728 maxPos.x = wndPtr->rectWindow.left; maxPos.y = wndPtr->rectWindow.top;
729 if (unicode)
730 {
731 if (!SendMessage32W( hwnd, WM_NCCREATE, 0, (LPARAM)cs)) wmcreate = -1;
732 else
733 {
734 WINPOS_SendNCCalcSize( hwnd, FALSE, &wndPtr->rectWindow,
735 NULL, NULL, 0, &wndPtr->rectClient );
736 OffsetRect16(&wndPtr->rectWindow, maxPos.x - wndPtr->rectWindow.left,
737 maxPos.y - wndPtr->rectWindow.top);
738 wmcreate = SendMessage32W( hwnd, WM_CREATE, 0, (LPARAM)cs );
739 }
740 }
741 else
742 {
743 if (!SendMessage32A( hwnd, WM_NCCREATE, 0, (LPARAM)cs)) wmcreate = -1;
744 else
745 {
746 WINPOS_SendNCCalcSize( hwnd, FALSE, &wndPtr->rectWindow,
747 NULL, NULL, 0, &wndPtr->rectClient );
748 OffsetRect16(&wndPtr->rectWindow, maxPos.x - wndPtr->rectWindow.left,
749 maxPos.y - wndPtr->rectWindow.top);
750 wmcreate = SendMessage32A( hwnd, WM_CREATE, 0, (LPARAM)cs );
751 }
752 }
753
754 if (wmcreate == -1)
755 {
756 /* Abort window creation */
757 dprintf_win(stddeb,"CreateWindowEx: wmcreate==-1, aborting\n");
758 WIN_UnlinkWindow( hwnd );
759 WIN_DestroyWindow( wndPtr );
760 return 0;
761 }
762
763 /* Send the size messages */
764
765 if (!(wndPtr->flags & WIN_NEED_SIZE))
766 {
767 /* send it anyway */
768 SendMessage16( hwnd, WM_SIZE, SIZE_RESTORED,
769 MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left,
770 wndPtr->rectClient.bottom-wndPtr->rectClient.top));
771 SendMessage16( hwnd, WM_MOVE, 0, MAKELONG( wndPtr->rectClient.left,
772 wndPtr->rectClient.top ));
773 }
774
775 WIN_SendParentNotify( hwnd, WM_CREATE, wndPtr->wIDmenu, (LPARAM)hwnd );
776 if (!IsWindow(hwnd)) return 0;
777
778 /* Show the window, maximizing or minimizing if needed */
779
780 if (wndPtr->dwStyle & WS_MINIMIZE)
781 {
782 /* MinMaximize(hwnd, SW_SHOWMINNOACTIVE, 1) in "Internals" */
783
784 wndPtr->dwStyle &= ~WS_MAXIMIZE;
785 WINPOS_FindIconPos( hwnd );
786 SetWindowPos( hwnd, 0, wndPtr->ptIconPos.x, wndPtr->ptIconPos.y,
787 SYSMETRICS_CXICON, SYSMETRICS_CYICON,
788 SWP_FRAMECHANGED | ((GetActiveWindow())? SWP_NOACTIVATE : 0) );
789 }
790 else if (wndPtr->dwStyle & WS_MAXIMIZE)
791 {
792 /* MinMaximize(hwnd, SW_SHOWMAXIMIZED, 1) */
793
794 NC_GetMinMaxInfo( wndPtr, &maxSize, &maxPos, &minTrack, &maxTrack );
795 SetWindowPos( hwnd, 0, maxPos.x, maxPos.y, maxSize.x, maxSize.y,
796 ((GetActiveWindow())? SWP_NOACTIVATE : 0) | SWP_FRAMECHANGED );
797 }
798
799 if (cs->style & WS_VISIBLE) ShowWindow( hwnd, SW_SHOW );
800
801 /* Call WH_SHELL hook */
802
803 if (!(wndPtr->dwStyle & WS_CHILD) && !wndPtr->owner)
804 HOOK_CallHooks16( WH_SHELL, HSHELL_WINDOWCREATED, hwnd, 0 );
805
806 dprintf_win(stddeb, "CreateWindowEx: returning %04x\n", hwnd);
807 return hwnd;
808 }
809
810
811 /***********************************************************************
812 * CreateWindow16 (USER.41)
813 */
814 HWND16 CreateWindow16( LPCSTR className, LPCSTR windowName,
815 DWORD style, INT16 x, INT16 y, INT16 width,
816 INT16 height, HWND16 parent, HMENU16 menu,
817 HINSTANCE16 instance, LPVOID data )
818 {
819 return CreateWindowEx16( 0, className, windowName, style,
820 x, y, width, height, parent, menu, instance, data );
821 }
822
823
824 /***********************************************************************
825 * CreateWindowEx16 (USER.452)
826 */
827 HWND16 CreateWindowEx16( DWORD exStyle, LPCSTR className, LPCSTR windowName,
828 DWORD style, INT16 x, INT16 y, INT16 width,
829 INT16 height, HWND16 parent, HMENU16 menu,
830 HINSTANCE16 instance, LPVOID data )
831 {
832 ATOM classAtom;
833 CREATESTRUCT32A cs;
834
835 /* Find the class atom */
836
837 if (!(classAtom = GlobalFindAtom32A( className )))
838 {
839 fprintf( stderr, "CreateWindowEx16: bad class name " );
840 if (!HIWORD(className)) fprintf( stderr, "%04x\n", LOWORD(className) );
841 else fprintf( stderr, "'%s'\n", className );
842 return 0;
843 }
844
845 /* Fix the coordinates */
846
847 cs.x = (x == CW_USEDEFAULT16) ? CW_USEDEFAULT32 : (INT32)x;
848 cs.y = (y == CW_USEDEFAULT16) ? CW_USEDEFAULT32 : (INT32)y;
849 cs.cx = (width == CW_USEDEFAULT16) ? CW_USEDEFAULT32 : (INT32)width;
850 cs.cy = (height == CW_USEDEFAULT16) ? CW_USEDEFAULT32 : (INT32)height;
851
852 /* Create the window */
853
854 cs.lpCreateParams = data;
855 cs.hInstance = (HINSTANCE32)instance;
856 cs.hMenu = (HMENU32)menu;
857 cs.hwndParent = (HWND32)parent;
858 cs.style = style;
859 cs.lpszName = windowName;
860 cs.lpszClass = className;
861 cs.dwExStyle = exStyle;
862 return WIN_CreateWindowEx( &cs, classAtom, FALSE );
863 }
864
865
866 /***********************************************************************
867 * CreateWindowEx32A (USER32.82)
868 */
869 HWND32 CreateWindowEx32A( DWORD exStyle, LPCSTR className, LPCSTR windowName,
870 DWORD style, INT32 x, INT32 y, INT32 width,
871 INT32 height, HWND32 parent, HMENU32 menu,
872 HINSTANCE32 instance, LPVOID data )
873 {
874 ATOM classAtom;
875 CREATESTRUCT32A cs;
876
877 /* Find the class atom */
878
879 if (!(classAtom = GlobalFindAtom32A( className )))
880 {
881 fprintf( stderr, "CreateWindowEx32A: bad class name " );
882 if (!HIWORD(className)) fprintf( stderr, "%04x\n", LOWORD(className) );
883 else fprintf( stderr, "'%s'\n", className );
884 return 0;
885 }
886
887 /* Create the window */
888
889 cs.lpCreateParams = data;
890 cs.hInstance = instance;
891 cs.hMenu = menu;
892 cs.hwndParent = parent;
893 cs.x = x;
894 cs.y = y;
895 cs.cx = width;
896 cs.cy = height;
897 cs.style = style;
898 cs.lpszName = windowName;
899 cs.lpszClass = className;
900 cs.dwExStyle = exStyle;
901 return WIN_CreateWindowEx( &cs, classAtom, FALSE );
902 }
903
904
905 /***********************************************************************
906 * CreateWindowEx32W (USER32.83)
907 */
908 HWND32 CreateWindowEx32W( DWORD exStyle, LPCWSTR className, LPCWSTR windowName,
909 DWORD style, INT32 x, INT32 y, INT32 width,
910 INT32 height, HWND32 parent, HMENU32 menu,
911 HINSTANCE32 instance, LPVOID data )
912 {
913 ATOM classAtom;
914 CREATESTRUCT32W cs;
915
916 /* Find the class atom */
917
918 if (!(classAtom = GlobalFindAtom32W( className )))
919 {
920 if (HIWORD(className))
921 {
922 LPSTR cn = STRING32_DupUniToAnsi(className);
923 fprintf( stderr, "CreateWindowEx32W: bad class name '%s'\n",cn);
924 free(cn);
925 }
926 else
927 fprintf( stderr, "CreateWindowEx32W: bad class name %p\n", className );
928 return 0;
929 }
930
931 /* Create the window */
932
933 cs.lpCreateParams = data;
934 cs.hInstance = instance;
935 cs.hMenu = menu;
936 cs.hwndParent = parent;
937 cs.x = x;
938 cs.y = y;
939 cs.cx = width;
940 cs.cy = height;
941 cs.style = style;
942 cs.lpszName = windowName;
943 cs.lpszClass = className;
944 cs.dwExStyle = exStyle;
945 /* Note: we rely on the fact that CREATESTRUCT32A and */
946 /* CREATESTRUCT32W have the same layout. */
947 return WIN_CreateWindowEx( (CREATESTRUCT32A *)&cs, classAtom, TRUE );
948 }
949
950
951 /***********************************************************************
952 * WIN_CheckFocus
953 */
954 static void WIN_CheckFocus( WND* pWnd )
955 {
956 if( GetFocus16() == pWnd->hwndSelf )
957 SetFocus16( (pWnd->dwStyle & WS_CHILD) ? pWnd->parent->hwndSelf : 0 );
958 }
959
960 /***********************************************************************
961 * WIN_SendDestroyMsg
962 */
963 static void WIN_SendDestroyMsg( WND* pWnd )
964 {
965 WND* pChild;
966
967 WIN_CheckFocus(pWnd);
968
969 if( CARET_GetHwnd() == pWnd->hwndSelf ) DestroyCaret();
970 if( !pWnd->window ) CLIPBOARD_DisOwn( pWnd );
971
972 SendMessage32A( pWnd->hwndSelf, WM_DESTROY, 0, 0);
973
974 if( !IsWindow(pWnd->hwndSelf) )
975 {
976 dprintf_win(stddeb,"\tdestroyed itself while in WM_DESTROY!\n");
977 return;
978 }
979
980 pChild = pWnd->child;
981 while( pChild )
982 {
983 WIN_SendDestroyMsg( pChild );
984 pChild = pChild->next;
985 }
986 WIN_CheckFocus(pWnd);
987 }
988
989
990 /***********************************************************************
991 * DestroyWindow (USER.53)
992 */
993 BOOL DestroyWindow( HWND hwnd )
994 {
995 WND * wndPtr;
996
997 dprintf_win(stddeb, "DestroyWindow(%04x)\n", hwnd);
998
999 /* Initialization */
1000
1001 if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
1002 if (wndPtr == pWndDesktop) return FALSE; /* Can't destroy desktop */
1003
1004 /* Call hooks */
1005
1006 if( HOOK_CallHooks16( WH_CBT, HCBT_DESTROYWND, hwnd, 0L) )
1007 return FALSE;
1008
1009 if (!(wndPtr->dwStyle & WS_CHILD) && !wndPtr->owner)
1010 {
1011 HOOK_CallHooks16( WH_SHELL, HSHELL_WINDOWDESTROYED, hwnd, 0L );
1012 /* FIXME: clean up palette - see "Internals" p.352 */
1013 }
1014
1015 if( !QUEUE_IsDoomedQueue(wndPtr->hmemTaskQ) )
1016 WIN_SendParentNotify( hwnd, WM_DESTROY, wndPtr->wIDmenu, (LPARAM)hwnd );
1017 if( !IsWindow(hwnd) ) return TRUE;
1018
1019 if( wndPtr->window ) CLIPBOARD_DisOwn( wndPtr ); /* before window is unmapped */
1020
1021 /* Hide the window */
1022
1023 if (wndPtr->dwStyle & WS_VISIBLE)
1024 {
1025 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_HIDEWINDOW |
1026 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE |
1027 ((QUEUE_IsDoomedQueue(wndPtr->hmemTaskQ))?SWP_DEFERERASE:0) );
1028 if( !IsWindow(hwnd) ) return TRUE;
1029 }
1030
1031 /* Recursively destroy owned windows */
1032
1033 if( !(wndPtr->dwStyle & WS_CHILD) )
1034 {
1035 for (;;)
1036 {
1037 WND *siblingPtr = wndPtr->parent->child; /* First sibling */
1038 while (siblingPtr)
1039 {
1040 if (siblingPtr->owner == wndPtr)
1041 if (siblingPtr->hmemTaskQ == wndPtr->hmemTaskQ)
1042 break;
1043 else
1044 siblingPtr->owner = NULL;
1045 siblingPtr = siblingPtr->next;
1046 }
1047 if (siblingPtr) DestroyWindow( siblingPtr->hwndSelf );
1048 else break;
1049 }
1050
1051 WINPOS_ActivateOtherWindow(wndPtr);
1052
1053 if( wndPtr->owner &&
1054 wndPtr->owner->hwndLastActive == wndPtr->hwndSelf )
1055 wndPtr->owner->hwndLastActive = wndPtr->owner->hwndSelf;
1056 }
1057
1058 /* Send destroy messages */
1059
1060 WIN_SendDestroyMsg( wndPtr );
1061 if( !IsWindow(hwnd) ) return TRUE;
1062
1063 /* Unlink now so we won't bother with the children later on */
1064
1065 if( wndPtr->parent ) WIN_UnlinkWindow(hwnd);
1066
1067 /* Destroy the window storage */
1068
1069 WIN_DestroyWindow( wndPtr );
1070 return TRUE;
1071 }
1072
1073
1074 /***********************************************************************
1075 * CloseWindow (USER.43)
1076 */
1077 BOOL CloseWindow(HWND hWnd)
1078 {
1079 WND * wndPtr = WIN_FindWndPtr(hWnd);
1080 if (!wndPtr || (wndPtr->dwStyle & WS_CHILD)) return TRUE;
1081 ShowWindow(hWnd, SW_MINIMIZE);
1082 return TRUE;
1083 }
1084
1085
1086 /***********************************************************************
1087 * OpenIcon (USER.44)
1088 */
1089 BOOL OpenIcon(HWND hWnd)
1090 {
1091 if (!IsIconic(hWnd)) return FALSE;
1092 ShowWindow(hWnd, SW_SHOWNORMAL);
1093 return(TRUE);
1094 }
1095
1096
1097 /***********************************************************************
1098 * WIN_FindWindow
1099 *
1100 * Implementation of FindWindow() and FindWindowEx().
1101 */
1102 static HWND WIN_FindWindow( HWND parent, HWND child, ATOM className,
1103 LPCSTR title )
1104 {
1105 WND *pWnd;
1106 CLASS *pClass = NULL;
1107
1108 if (child)
1109 {
1110 if (!(pWnd = WIN_FindWndPtr( child ))) return 0;
1111 if (parent)
1112 {
1113 if (!pWnd->parent || (pWnd->parent->hwndSelf != parent)) return 0;
1114 }
1115 else if (pWnd->parent != pWndDesktop) return 0;
1116 pWnd = pWnd->next;
1117 }
1118 else
1119 {
1120 if (!(pWnd = parent ? WIN_FindWndPtr(parent) : pWndDesktop)) return 0;
1121 pWnd = pWnd->child;
1122 }
1123 if (!pWnd) return 0;
1124
1125 /* For a child window, all siblings will have the same hInstance, */
1126 /* so we can look for the class once and for all. */
1127
1128 if (className && (pWnd->dwStyle & WS_CHILD))
1129 {
1130 if (!(pClass = CLASS_FindClassByAtom( className, pWnd->hInstance )))
1131 return 0;
1132 }
1133
1134 for ( ; pWnd; pWnd = pWnd->next)
1135 {
1136 if (className && !(pWnd->dwStyle & WS_CHILD))
1137 {
1138 if (!(pClass = CLASS_FindClassByAtom( className, pWnd->hInstance)))
1139 continue; /* Skip this window */
1140 }
1141 if (pClass && (pWnd->class != pClass))
1142 continue; /* Not the right class */
1143
1144 /* Now check the title */
1145
1146 if (!title) return pWnd->hwndSelf;
1147 if (pWnd->text && !strcmp( pWnd->text, title )) return pWnd->hwndSelf;
1148 }
1149 return 0;
1150 }
1151
1152
1153
1154 /***********************************************************************
1155 * FindWindow16 (USER.50)
1156 */
1157 HWND16 FindWindow16( SEGPTR className, LPCSTR title )
1158 {
1159 return FindWindowEx16( 0, 0, className, title );
1160 }
1161
1162
1163 /***********************************************************************
1164 * FindWindowEx16 (USER.427)
1165 */
1166 HWND16 FindWindowEx16( HWND16 parent, HWND16 child,
1167 SEGPTR className, LPCSTR title )
1168 {
1169 ATOM atom = 0;
1170
1171 if (className)
1172 {
1173 /* If the atom doesn't exist, then no class */
1174 /* with this name exists either. */
1175 if (!(atom = GlobalFindAtom16( className ))) return 0;
1176 }
1177 return WIN_FindWindow( parent, child, atom, title );
1178 }
1179
1180
1181 /***********************************************************************
1182 * FindWindow32A (USER32.197)
1183 */
1184 HWND32 FindWindow32A( LPCSTR className, LPCSTR title )
1185 {
1186 return FindWindowEx32A( 0, 0, className, title );
1187 }
1188
1189
1190 /***********************************************************************
1191 * FindWindowEx32A (USER32.198)
1192 */
1193 HWND32 FindWindowEx32A( HWND32 parent, HWND32 child,
1194 LPCSTR className, LPCSTR title )
1195 {
1196 ATOM atom = 0;
1197
1198 if (className)
1199 {
1200 /* If the atom doesn't exist, then no class */
1201 /* with this name exists either. */
1202 if (!(atom = GlobalFindAtom32A( className ))) return 0;
1203 }
1204 return WIN_FindWindow( 0, 0, atom, title );
1205 }
1206
1207
1208 /***********************************************************************
1209 * FindWindowEx32W (USER32.199)
1210 */
1211 HWND32 FindWindowEx32W( HWND32 parent, HWND32 child,
1212 LPCWSTR className, LPCWSTR title )
1213 {
1214 ATOM atom = 0;
1215 char *buffer;
1216 HWND hwnd;
1217
1218 if (className)
1219 {
1220 /* If the atom doesn't exist, then no class */
1221 /* with this name exists either. */
1222 if (!(atom = GlobalFindAtom32W( className ))) return 0;
1223 }
1224 buffer = title ? STRING32_DupUniToAnsi( title ) : NULL;
1225 hwnd = WIN_FindWindow( 0, 0, atom, buffer );
1226 if (buffer) free( buffer );
1227 return hwnd;
1228 }
1229
1230
1231 /***********************************************************************
1232 * FindWindow32W (USER32.200)
1233 */
1234 HWND32 FindWindow32W( LPCWSTR className, LPCWSTR title )
1235 {
1236 return FindWindowEx32W( 0, 0, className, title );
1237 }
1238
1239
1240 /**********************************************************************
1241 * WIN_GetDesktop
1242 */
1243 WND *WIN_GetDesktop(void)
1244 {
1245 return pWndDesktop;
1246 }
1247
1248
1249 /**********************************************************************
1250 * GetDesktopWindow16 (USER.286)
1251 */
1252 HWND16 GetDesktopWindow16(void)
1253 {
1254 return (HWND16)pWndDesktop->hwndSelf;
1255 }
1256
1257
1258 /**********************************************************************
1259 * GetDesktopWindow32 (USER32.231)
1260 */
1261 HWND32 GetDesktopWindow32(void)
1262 {
1263 return pWndDesktop->hwndSelf;
1264 }
1265
1266
1267 /**********************************************************************
1268 * GetDesktopHwnd (USER.278)
1269 *
1270 * Exactly the same thing as GetDesktopWindow(), but not documented.
1271 * Don't ask me why...
1272 */
1273 HWND16 GetDesktopHwnd(void)
1274 {
1275 return (HWND16)pWndDesktop->hwndSelf;
1276 }
1277
1278
1279 /*******************************************************************
1280 * EnableWindow (USER.34)
1281 */
1282 BOOL EnableWindow( HWND hwnd, BOOL enable )
1283 {
1284 WND *wndPtr;
1285
1286 if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
1287 if (enable && (wndPtr->dwStyle & WS_DISABLED))
1288 {
1289 /* Enable window */
1290 wndPtr->dwStyle &= ~WS_DISABLED;
1291 SendMessage16( hwnd, WM_ENABLE, TRUE, 0 );
1292 return TRUE;
1293 }
1294 else if (!enable && !(wndPtr->dwStyle & WS_DISABLED))
1295 {
1296 /* Disable window */
1297 wndPtr->dwStyle |= WS_DISABLED;
1298 if ((hwnd == GetFocus32()) || IsChild( hwnd, GetFocus32() ))
1299 SetFocus32( 0 ); /* A disabled window can't have the focus */
1300 if ((hwnd == GetCapture32()) || IsChild( hwnd, GetCapture32() ))
1301 ReleaseCapture(); /* A disabled window can't capture the mouse */
1302 SendMessage16( hwnd, WM_ENABLE, FALSE, 0 );
1303 return FALSE;
1304 }
1305 return ((wndPtr->dwStyle & WS_DISABLED) != 0);
1306 }
1307
1308
1309 /***********************************************************************
1310 * IsWindowEnabled (USER.35) (USER32.348)
1311 */
1312 BOOL IsWindowEnabled(HWND hWnd)
1313 {
1314 WND * wndPtr;
1315
1316 if (!(wndPtr = WIN_FindWndPtr(hWnd))) return FALSE;
1317 return !(wndPtr->dwStyle & WS_DISABLED);
1318 }
1319
1320
1321 /***********************************************************************
1322 * IsWindowUnicode (USER32.349)
1323 */
1324 BOOL32 IsWindowUnicode( HWND32 hwnd )
1325 {
1326 WND * wndPtr;
1327
1328 if (!(wndPtr = WIN_FindWndPtr(hwnd))) return FALSE;
1329 return (WINPROC_GetProcType( wndPtr->winproc ) == WIN_PROC_32W);
1330 }
1331
1332
1333 /**********************************************************************
1334 * GetWindowWord (USER.133) (USER32.313)
1335 */
1336 WORD GetWindowWord( HWND32 hwnd, INT32 offset )
1337 {
1338 WND * wndPtr = WIN_FindWndPtr( hwnd );
1339 if (!wndPtr) return 0;
1340 if (offset >= 0)
1341 {
1342 if (offset + sizeof(WORD) > wndPtr->class->cbWndExtra)
1343 {
1344 fprintf( stderr, "SetWindowWord: invalid offset %d\n", offset );
1345 return 0;
1346 }
1347 return *(WORD *)(((char *)wndPtr->wExtra) + offset);
1348 }
1349 switch(offset)
1350 {
1351 case GWW_ID: return wndPtr->wIDmenu;
1352 case GWW_HWNDPARENT: return wndPtr->parent ? wndPtr->parent->hwndSelf : 0;
1353 case GWW_HINSTANCE: return (WORD)wndPtr->hInstance;
1354 default:
1355 fprintf( stderr, "GetWindowWord: invalid offset %d\n", offset );
1356 return 0;
1357 }
1358 }
1359
1360
1361 /**********************************************************************
1362 * WIN_GetWindowInstance
1363 */
1364 HINSTANCE16 WIN_GetWindowInstance( HWND32 hwnd )
1365 {
1366 WND * wndPtr = WIN_FindWndPtr( hwnd );
1367 if (!wndPtr) return (HINSTANCE16)0;
1368 return wndPtr->hInstance;
1369 }
1370
1371
1372 /**********************************************************************
1373 * SetWindowWord (USER.134) (USER32.523)
1374 */
1375 WORD SetWindowWord( HWND32 hwnd, INT32 offset, WORD newval )
1376 {
1377 WORD *ptr, retval;
1378 WND * wndPtr = WIN_FindWndPtr( hwnd );
1379 if (!wndPtr) return 0;
1380 if (offset >= 0)
1381 {
1382 if (offset + sizeof(WORD) > wndPtr->class->cbWndExtra)
1383 {
1384 fprintf( stderr, "SetWindowWord: invalid offset %d\n", offset );
1385 return 0;
1386 }
1387 ptr = (WORD *)(((char *)wndPtr->wExtra) + offset);
1388 }
1389 else switch(offset)
1390 {
1391 case GWW_ID: ptr = (WORD *)&wndPtr->wIDmenu; break;
1392 case GWW_HINSTANCE: ptr = (WORD *)&wndPtr->hInstance; break;
1393 case GWW_HWNDPARENT: return SetParent( hwnd, newval );
1394 default:
1395 fprintf( stderr, "SetWindowWord: invalid offset %d\n", offset );
1396 return 0;
1397 }
1398 retval = *ptr;
1399 *ptr = newval;
1400 return retval;
1401 }
1402
1403
1404 /**********************************************************************
1405 * WIN_GetWindowLong
1406 *
1407 * Helper function for GetWindowLong().
1408 */
1409 static LONG WIN_GetWindowLong( HWND32 hwnd, INT32 offset, WINDOWPROCTYPE type )
1410 {
1411 LONG retval;
1412 WND * wndPtr = WIN_FindWndPtr( hwnd );
1413 if (!wndPtr) return 0;
1414 if (offset >= 0)
1415 {
1416 if (offset + sizeof(LONG) > wndPtr->class->cbWndExtra)
1417 {
1418 fprintf( stderr, "GetWindowLong: invalid offset %d\n", offset );
1419 return 0;
1420 }
1421 retval = *(LONG *)(((char *)wndPtr->wExtra) + offset);
1422 /* Special case for dialog window procedure */
1423 if ((offset == DWL_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG))
1424 return (LONG)WINPROC_GetProc( (HWINDOWPROC)retval, type );
1425 return retval;
1426 }
1427 switch(offset)
1428 {
1429 case GWL_USERDATA: return wndPtr->userdata;
1430 case GWL_STYLE: return wndPtr->dwStyle;
1431 case GWL_EXSTYLE: return wndPtr->dwExStyle;
1432 case GWL_ID: return wndPtr->wIDmenu;
1433 case GWL_WNDPROC: return (LONG)WINPROC_GetProc( wndPtr->winproc,
1434 type );
1435 case GWL_HWNDPARENT: return wndPtr->parent ?
1436 (HWND32)wndPtr->parent->hwndSelf : 0;
1437 case GWL_HINSTANCE: return (HINSTANCE32)wndPtr->hInstance;
1438 default:
1439 fprintf( stderr, "GetWindowLong: unknown offset %d\n", offset );
1440 }
1441 return 0;
1442 }
1443
1444
1445 /**********************************************************************
1446 * WIN_SetWindowLong
1447 *
1448 * Helper function for SetWindowLong().
1449 */
1450 static LONG WIN_SetWindowLong( HWND32 hwnd, INT32 offset, LONG newval,
1451 WINDOWPROCTYPE type )
1452 {
1453 LONG *ptr, retval;
1454 WND * wndPtr = WIN_FindWndPtr( hwnd );
1455 if (!wndPtr) return 0;
1456 if (offset >= 0)
1457 {
1458 if (offset + sizeof(LONG) > wndPtr->class->cbWndExtra)
1459 {
1460 fprintf( stderr, "SetWindowLong: invalid offset %d\n", offset );
1461 return 0;
1462 }
1463 ptr = (LONG *)(((char *)wndPtr->wExtra) + offset);
1464 /* Special case for dialog window procedure */
1465 if ((offset == DWL_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG))
1466 {
1467 retval = (LONG)WINPROC_GetProc( (HWINDOWPROC)*ptr, type );
1468 WINPROC_SetProc( (HWINDOWPROC *)ptr, (WNDPROC16)newval, type );
1469 return retval;
1470 }
1471 }
1472 else switch(offset)
1473 {
1474 case GWL_ID:
1475 case GWL_HINSTANCE:
1476 return SetWindowWord( hwnd, offset, (WORD)newval );
1477 case GWL_WNDPROC:
1478 retval = (LONG)WINPROC_GetProc( wndPtr->winproc, type );
1479 WINPROC_SetProc( &wndPtr->winproc, (WNDPROC16)newval, type );
1480 return retval;
1481 case GWL_STYLE:
1482 ptr = &wndPtr->dwStyle;
1483 /* Some bits can't be changed this way */
1484 newval &= ~(WS_VISIBLE | WS_CHILD);
1485 newval |= (*ptr & (WS_VISIBLE | WS_CHILD));
1486 break;
1487 case GWL_USERDATA: ptr = &wndPtr->userdata; break;
1488 case GWL_EXSTYLE: ptr = &wndPtr->dwExStyle; break;
1489 default:
1490 fprintf( stderr, "SetWindowLong: invalid offset %d\n", offset );
1491 return 0;
1492 }
1493 retval = *ptr;
1494 *ptr = newval;
1495 return retval;
1496 }
1497
1498
1499 /**********************************************************************
1500 * GetWindowLong16 (USER.135)
1501 */
1502 LONG GetWindowLong16( HWND16 hwnd, INT16 offset )
1503 {
1504 return WIN_GetWindowLong( (HWND32)hwnd, offset, WIN_PROC_16 );
1505 }
1506
1507
1508 /**********************************************************************
1509 * GetWindowLong32A (USER32.304)
1510 */
1511 LONG GetWindowLong32A( HWND32 hwnd, INT32 offset )
1512 {
1513 return WIN_GetWindowLong( hwnd, offset, WIN_PROC_32A );
1514 }
1515
1516
1517 /**********************************************************************
1518 * GetWindowLong32W (USER32.305)
1519 */
1520 LONG GetWindowLong32W( HWND32 hwnd, INT32 offset )
1521 {
1522 return WIN_GetWindowLong( hwnd, offset, WIN_PROC_32W );
1523 }
1524
1525
1526 /**********************************************************************
1527 * SetWindowLong16 (USER.136)
1528 */
1529 LONG SetWindowLong16( HWND16 hwnd, INT16 offset, LONG newval )
1530 {
1531 return WIN_SetWindowLong( hwnd, offset, newval, WIN_PROC_16 );
1532 }
1533
1534
1535 /**********************************************************************
1536 * SetWindowLong32A (USER32.516)
1537 */
1538 LONG SetWindowLong32A( HWND32 hwnd, INT32 offset, LONG newval )
1539 {
1540 return WIN_SetWindowLong( hwnd, offset, newval, WIN_PROC_32A );
1541 }
1542
1543
1544 /**********************************************************************
1545 * SetWindowLong32W (USER32.517)
1546 */
1547 LONG SetWindowLong32W( HWND32 hwnd, INT32 offset, LONG newval )
1548 {
1549 return WIN_SetWindowLong( hwnd, offset, newval, WIN_PROC_32W );
1550 }
1551
1552
1553 /*******************************************************************
1554 * GetWindowText16 (USER.36)
1555 */
1556 INT16 GetWindowText16( HWND16 hwnd, SEGPTR lpString, INT16 nMaxCount )
1557 {
1558 return (INT16)SendMessage16(hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString);
1559 }
1560
1561
1562 /*******************************************************************
1563 * GetWindowText32A (USER32.308)
1564 */
1565 INT32 GetWindowText32A( HWND32 hwnd, LPSTR lpString, INT32 nMaxCount )
1566 {
1567 return (INT32)SendMessage32A( hwnd, WM_GETTEXT, nMaxCount,
1568 (LPARAM)lpString );
1569 }
1570
1571
1572 /*******************************************************************
1573 * GetWindowText32W (USER32.311)
1574 */
1575 INT32 GetWindowText32W( HWND32 hwnd, LPWSTR lpString, INT32 nMaxCount )
1576 {
1577 return (INT32)SendMessage32W( hwnd, WM_GETTEXT, nMaxCount,
1578 (LPARAM)lpString );
1579 }
1580
1581
1582 /*******************************************************************
1583 * SetWindowText16 (USER.37)
1584 */
1585 void SetWindowText16( HWND16 hwnd, SEGPTR lpString )
1586 {
1587 SendMessage16( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
1588 }
1589
1590
1591 /*******************************************************************
1592 * SetWindowText32A (USER32.)
1593 */
1594 void SetWindowText32A( HWND32 hwnd, LPCSTR lpString )
1595 {
1596 SendMessage32A( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
1597 }
1598
1599
1600 /*******************************************************************
1601 * SetWindowText32W (USER32.)
1602 */
1603 void SetWindowText32W( HWND32 hwnd, LPCWSTR lpString )
1604 {
1605 SendMessage32W( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
1606 }
1607
1608
1609 /*******************************************************************
1610 * GetWindowTextLength (USER.38)
1611 */
1612 int GetWindowTextLength(HWND hwnd)
1613 {
1614 return (int)SendMessage16(hwnd, WM_GETTEXTLENGTH, 0, 0 );
1615 }
1616
1617
1618 /*******************************************************************
1619 * IsWindow (USER.47) (USER32.347)
1620 */
1621 BOOL16 IsWindow( HWND32 hwnd )
1622 {
1623 WND * wndPtr = WIN_FindWndPtr( hwnd );
1624 return ((wndPtr != NULL) && (wndPtr->dwMagic == WND_MAGIC));
1625 }
1626
1627
1628 /*****************************************************************
1629 * GetParent16 (USER.46)
1630 */
1631 HWND16 GetParent16( HWND16 hwnd )
1632 {
1633 return (HWND16)GetParent32( hwnd );
1634 }
1635
1636
1637 /*****************************************************************
1638 * GetParent32 (USER32.277)
1639 */
1640 HWND32 GetParent32( HWND32 hwnd )
1641 {
1642 WND *wndPtr = WIN_FindWndPtr(hwnd);
1643 if (!wndPtr) return 0;
1644 wndPtr = (wndPtr->dwStyle & WS_CHILD) ? wndPtr->parent : wndPtr->owner;
1645 return wndPtr ? wndPtr->hwndSelf : 0;
1646 }
1647
1648
1649 /*****************************************************************
1650 * WIN_GetTopParent
1651 *
1652 * Get the top-level parent for a child window.
1653 */
1654 HWND32 WIN_GetTopParent( HWND32 hwnd )
1655 {
1656 WND *wndPtr = WIN_FindWndPtr( hwnd );
1657 while (wndPtr && (wndPtr->dwStyle & WS_CHILD)) wndPtr = wndPtr->parent;
1658 return wndPtr ? wndPtr->hwndSelf : 0;
1659 }
1660
1661
1662 /*****************************************************************
1663 * SetParent (USER.233)
1664 */
1665 HWND SetParent(HWND hwndChild, HWND hwndNewParent)
1666 {
1667 HWND oldParent;
1668
1669 WND *wndPtr = WIN_FindWndPtr(hwndChild);
1670 WND *pWndParent = WIN_FindWndPtr( hwndNewParent );
1671 if (!wndPtr || !pWndParent || !(wndPtr->dwStyle & WS_CHILD)) return 0;
1672
1673 oldParent = wndPtr->parent->hwndSelf;
1674
1675 WIN_UnlinkWindow(hwndChild);
1676 if (hwndNewParent) wndPtr->parent = pWndParent;
1677 WIN_LinkWindow(hwndChild, HWND_BOTTOM);
1678
1679 if (IsWindowVisible(hwndChild)) UpdateWindow(hwndChild);
1680
1681 return oldParent;
1682 }
1683
1684
1685
1686 /*******************************************************************
1687 * IsChild (USER.48)
1688 */
1689 BOOL IsChild( HWND parent, HWND child )
1690 {
1691 WND * wndPtr = WIN_FindWndPtr( child );
1692 while (wndPtr && (wndPtr->dwStyle & WS_CHILD))
1693 {
1694 wndPtr = wndPtr->parent;
1695 if (wndPtr->hwndSelf == parent) return TRUE;
1696 }
1697 return FALSE;
1698 }
1699
1700
1701 /***********************************************************************
1702 * IsWindowVisible (USER.49) (USER32.350)
1703 */
1704 BOOL IsWindowVisible( HWND hwnd )
1705 {
1706 WND *wndPtr = WIN_FindWndPtr( hwnd );
1707 while (wndPtr && (wndPtr->dwStyle & WS_CHILD))
1708 {
1709 if (!(wndPtr->dwStyle & WS_VISIBLE)) return FALSE;
1710 wndPtr = wndPtr->parent;
1711 }
1712 return (wndPtr && (wndPtr->dwStyle & WS_VISIBLE));
1713 }
1714
1715 /***********************************************************************
1716 * WIN_IsWindowDrawable
1717 *
1718 * hwnd is drawable when it is visible, all parents are not
1719 * minimized, and it is itself not minimized unless we are
1720 * trying to draw icon and the default class icon is set.
1721 */
1722 BOOL32 WIN_IsWindowDrawable( WND* wnd , BOOL32 icon )
1723 {
1724 HWND hwnd= wnd->hwndSelf;
1725 BOOL32 yes = TRUE;
1726
1727 while(wnd && yes)
1728 {
1729 if( wnd->dwStyle & WS_MINIMIZE )
1730 if( wnd->hwndSelf != hwnd ) break;
1731 else if( icon && wnd->class->hIcon ) break;
1732
1733 yes = yes && (wnd->dwStyle & WS_VISIBLE);
1734 wnd = wnd->parent; }
1735 return (!wnd && yes);
1736 }
1737
1738 /*******************************************************************
1739 * GetTopWindow (USER.229)
1740 */
1741 HWND GetTopWindow( HWND hwnd )
1742 {
1743 WND * wndPtr = WIN_FindWndPtr( hwnd );
1744 if (wndPtr && wndPtr->child) return wndPtr->child->hwndSelf;
1745 else return 0;
1746 }
1747
1748
1749 /*******************************************************************
1750 * GetWindow (USER.262)
1751 */
1752 HWND GetWindow( HWND hwnd, WORD rel )
1753 {
1754 WND * wndPtr = WIN_FindWndPtr( hwnd );
1755 if (!wndPtr) return 0;
1756 switch(rel)
1757 {
1758 case GW_HWNDFIRST:
1759 if (wndPtr->parent) return wndPtr->parent->child->hwndSelf;
1760 else return 0;
1761
1762 case GW_HWNDLAST:
1763 if (!wndPtr->parent) return 0; /* Desktop window */
1764 while (wndPtr->next) wndPtr = wndPtr->next;
1765 return wndPtr->hwndSelf;
1766
1767 case GW_HWNDNEXT:
1768 if (!wndPtr->next) return 0;
1769 return wndPtr->next->hwndSelf;
1770
1771 case GW_HWNDPREV:
1772 if (!wndPtr->parent) return 0; /* Desktop window */
1773 wndPtr = wndPtr->parent->child; /* First sibling */
1774 if (wndPtr->hwndSelf == hwnd) return 0; /* First in list */
1775 while (wndPtr->next)
1776 {
1777 if (wndPtr->next->hwndSelf == hwnd) return wndPtr->hwndSelf;
1778 wndPtr = wndPtr->next;
1779 }
1780 return 0;
1781
1782 case GW_OWNER:
1783 return wndPtr->owner ? wndPtr->owner->hwndSelf : 0;
1784
1785 case GW_CHILD:
1786 return wndPtr->child ? wndPtr->child->hwndSelf : 0;
1787 }
1788 return 0;
1789 }
1790
1791
1792 /*******************************************************************
1793 * GetNextWindow (USER.230)
1794 */
1795 HWND GetNextWindow( HWND hwnd, WORD flag )
1796 {
1797 if ((flag != GW_HWNDNEXT) && (flag != GW_HWNDPREV)) return 0;
1798 return GetWindow( hwnd, flag );
1799 }
1800
1801 /*******************************************************************
1802 * ShowOwnedPopups (USER.265)
1803 */
1804 void ShowOwnedPopups( HWND owner, BOOL fShow )
1805 {
1806 WND *pWnd = pWndDesktop->child;
1807 while (pWnd)
1808 {
1809 if (pWnd->owner && (pWnd->owner->hwndSelf == owner) &&
1810 (pWnd->dwStyle & WS_POPUP))
1811 ShowWindow( pWnd->hwndSelf, fShow ? SW_SHOW : SW_HIDE );
1812 pWnd = pWnd->next;
1813 }
1814 }
1815
1816
1817 /*******************************************************************
1818 * GetLastActivePopup (USER.287)
1819 */
1820 HWND GetLastActivePopup(HWND hwnd)
1821 {
1822 WND *wndPtr;
1823 wndPtr = WIN_FindWndPtr(hwnd);
1824 if (wndPtr == NULL) return hwnd;
1825 return wndPtr->hwndLastActive;
1826 }
1827
1828
1829 /*******************************************************************
1830 * WIN_BuildWinArray
1831 *
1832 * Build an array of pointers to all children of a given window.
1833 * The array must be freed with HeapFree(SystemHeap).
1834 */
1835 WND **WIN_BuildWinArray( WND *wndPtr )
1836 {
1837 WND **list, **ppWnd;
1838 WND *pWnd;
1839 INT32 count;
1840
1841 /* First count the windows */
1842
1843 if (!wndPtr) wndPtr = pWndDesktop;
1844 for (pWnd = wndPtr->child, count = 0; pWnd; pWnd = pWnd->next) count++;
1845 count++; /* For the terminating NULL */
1846
1847 /* Now build the list of all windows */
1848
1849 if (!(list = (WND **)HeapAlloc( SystemHeap, 0, sizeof(WND *) * count )))
1850 return NULL;
1851 for (pWnd = wndPtr->child, ppWnd = list; pWnd; pWnd = pWnd->next)
1852 *ppWnd++ = pWnd;
1853 *ppWnd = NULL;
1854 return list;
1855 }
1856
1857
1858 /*******************************************************************
1859 * EnumWindows16 (USER.54)
1860 */
1861 BOOL16 EnumWindows16( WNDENUMPROC16 lpEnumFunc, LPARAM lParam )
1862 {
1863 WND **list, **ppWnd;
1864
1865 /* We have to build a list of all windows first, to avoid */
1866 /* unpleasant side-effects, for instance if the callback */
1867 /* function changes the Z-order of the windows. */
1868
1869 if (!(list = WIN_BuildWinArray( pWndDesktop ))) return FALSE;
1870
1871 /* Now call the callback function for every window */
1872
1873 for (ppWnd = list; *ppWnd; ppWnd++)
1874 {
1875 /* Make sure that the window still exists */
1876 if (!IsWindow((*ppWnd)->hwndSelf)) continue;
1877 if (!lpEnumFunc( (*ppWnd)->hwndSelf, lParam )) break;
1878 }
1879 HeapFree( SystemHeap, 0, list );
1880 return TRUE;
1881 }
1882
1883
1884 /*******************************************************************
1885 * EnumWindows32 (USER32.192)
1886 */
1887 BOOL32 EnumWindows32( WNDENUMPROC32 lpEnumFunc, LPARAM lParam )
1888 {
1889 return (BOOL32)EnumWindows16( (WNDENUMPROC16)lpEnumFunc, lParam );
1890 }
1891
1892
1893 /**********************************************************************
1894 * EnumTaskWindows16 (USER.225)
1895 */
1896 BOOL16 EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func, LPARAM lParam )
1897 {
1898 WND **list, **ppWnd;
1899 HQUEUE16 hQueue = GetTaskQueue( hTask );
1900
1901 /* This function is the same as EnumWindows(), */
1902 /* except for an added check on the window queue. */
1903
1904 if (!(list = WIN_BuildWinArray( pWndDesktop ))) return FALSE;
1905
1906 /* Now call the callback function for every window */
1907
1908 for (ppWnd = list; *ppWnd; ppWnd++)
1909 {
1910 /* Make sure that the window still exists */
1911 if (!IsWindow((*ppWnd)->hwndSelf)) continue;
1912 if ((*ppWnd)->hmemTaskQ != hQueue) continue; /* Check the queue */
1913 if (!func( (*ppWnd)->hwndSelf, lParam )) break;
1914 }
1915 HeapFree( SystemHeap, 0, list );
1916 return TRUE;
1917 }
1918
1919
1920 /**********************************************************************
1921 * EnumThreadWindows (USER32.189)
1922 */
1923 BOOL32 EnumThreadWindows( DWORD id, WNDENUMPROC32 func, LPARAM lParam )
1924 {
1925 return (BOOL16)EnumTaskWindows16((HTASK16)id, (WNDENUMPROC16)func, lParam);
1926 }
1927
1928
1929 /**********************************************************************
1930 * WIN_EnumChildWindows
1931 *
1932 * Helper function for EnumChildWindows().
1933 */
1934 static BOOL16 WIN_EnumChildWindows( WND **ppWnd, WNDENUMPROC16 func,
1935 LPARAM lParam )
1936 {
1937 WND **childList;
1938 BOOL16 ret = FALSE;
1939
1940 while (*ppWnd)
1941 {
1942 /* Make sure that the window still exists */
1943 if (!IsWindow((*ppWnd)->hwndSelf)) continue;
1944 /* Build children list first */
1945 if (!(childList = WIN_BuildWinArray( *ppWnd ))) return FALSE;
1946 if (!func( (*ppWnd)->hwndSelf, lParam )) return FALSE;
1947 ret = WIN_EnumChildWindows( childList, func, lParam );
1948 HeapFree( SystemHeap, 0, childList );
1949 if (!ret) return FALSE;
1950 ppWnd++;
1951 }
1952 return TRUE;
1953 }
1954
1955
1956 /**********************************************************************
1957 * EnumChildWindows16 (USER.55)
1958 */
1959 BOOL16 EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func, LPARAM lParam )
1960 {
1961 WND **list, *pParent;
1962
1963 if (!(pParent = WIN_FindWndPtr( parent ))) return FALSE;
1964 if (!(list = WIN_BuildWinArray( pParent ))) return FALSE;
1965 WIN_EnumChildWindows( list, func, lParam );
1966 HeapFree( SystemHeap, 0, list );
1967 return TRUE;
1968 }
1969
1970
1971 /**********************************************************************
1972 * EnumChildWindows32 (USER32.177)
1973 */
1974 BOOL32 EnumChildWindows32( HWND32 parent, WNDENUMPROC32 func, LPARAM lParam )
1975 {
1976 return (BOOL32)EnumChildWindows16( (HWND16)parent, (WNDENUMPROC16)func,
1977 lParam );
1978 }
1979
1980
1981 /*******************************************************************
1982 * AnyPopup (USER.52)
1983 */
1984 BOOL AnyPopup(void)
1985 {
1986 WND *wndPtr;
1987 for (wndPtr = pWndDesktop->child; wndPtr; wndPtr = wndPtr->next)
1988 if (wndPtr->owner && (wndPtr->dwStyle & WS_VISIBLE)) return TRUE;
1989 return FALSE;
1990 }
1991
1992 /*******************************************************************
1993 * FlashWindow [USER.105]
1994 */
1995 BOOL FlashWindow(HWND hWnd, BOOL bInvert)
1996 {
1997 WND *wndPtr = WIN_FindWndPtr(hWnd);
1998
1999 dprintf_win(stddeb,"FlashWindow: %04x\n", hWnd);
2000
2001 if (!wndPtr) return FALSE;
2002
2003 if (wndPtr->dwStyle & WS_MINIMIZE)
2004 {
2005 if (bInvert && !(wndPtr->flags & WIN_NCACTIVATED))
2006 {
2007 HDC32 hDC = GetDC32(hWnd);
2008
2009 if (!SendMessage16( hWnd, WM_ERASEBKGND, (WPARAM16)hDC, 0 ))
2010 wndPtr->flags |= WIN_NEEDS_ERASEBKGND;
2011
2012 ReleaseDC32( hWnd, hDC );
2013 wndPtr->flags |= WIN_NCACTIVATED;
2014 }
2015 else
2016 {
2017 PAINT_RedrawWindow( hWnd, 0, 0, RDW_INVALIDATE | RDW_ERASE |
2018 RDW_UPDATENOW | RDW_FRAME, 0 );
2019 wndPtr->flags &= ~WIN_NCACTIVATED;
2020 }
2021 return TRUE;
2022 }
2023 else
2024 {
2025 WPARAM16 wparam;
2026 if (bInvert) wparam = !(wndPtr->flags & WIN_NCACTIVATED);
2027 else wparam = (hWnd == GetActiveWindow());
2028
2029 SendMessage16( hWnd, WM_NCACTIVATE, wparam, (LPARAM)0 );
2030 return wparam;
2031 }
2032 }
2033
2034
2035 /*******************************************************************
2036 * SetSysModalWindow16 (USER.188)
2037 */
2038 HWND16 SetSysModalWindow16( HWND16 hWnd )
2039 {
2040 HWND hWndOldModal = hwndSysModal;
2041 hwndSysModal = hWnd;
2042 dprintf_win(stdnimp,"EMPTY STUB !! SetSysModalWindow(%04x) !\n", hWnd);
2043 return hWndOldModal;
2044 }
2045
2046
2047 /*******************************************************************
2048 * GetSysModalWindow16 (USER.52)
2049 */
2050 HWND16 GetSysModalWindow16(void)
2051 {
2052 return hwndSysModal;
2053 }
2054
2055
2056 /*******************************************************************
2057 * DRAG_QueryUpdate
2058 *
2059 * recursively find a child that contains spDragInfo->pt point
2060 * and send WM_QUERYDROPOBJECT
2061 */
2062 BOOL16 DRAG_QueryUpdate( HWND hQueryWnd, SEGPTR spDragInfo, BOOL32 bNoSend )
2063 {
2064 BOOL16 wParam,bResult = 0;
2065 POINT16 pt;
2066 LPDRAGINFO ptrDragInfo = (LPDRAGINFO) PTR_SEG_TO_LIN(spDragInfo);
2067 WND *ptrQueryWnd = WIN_FindWndPtr(hQueryWnd),*ptrWnd;
2068 RECT16 tempRect;
2069
2070 if( !ptrQueryWnd || !ptrDragInfo ) return 0;
2071
2072 pt = ptrDragInfo->pt;
2073
2074 GetWindowRect16(hQueryWnd,&tempRect);
2075
2076 if( !PtInRect16(&tempRect,pt) ||
2077 (ptrQueryWnd->dwStyle & WS_DISABLED) )
2078 return 0;
2079
2080 if( !(ptrQueryWnd->dwStyle & WS_MINIMIZE) )
2081 {
2082 tempRect = ptrQueryWnd->rectClient;
2083 if(ptrQueryWnd->dwStyle & WS_CHILD)
2084 MapWindowPoints16(ptrQueryWnd->parent->hwndSelf,0,(LPPOINT16)&tempRect,2);
2085
2086 if( PtInRect16(&tempRect,pt) )
2087 {
2088 wParam = 0;
2089
2090 for (ptrWnd = ptrQueryWnd->child; ptrWnd ;ptrWnd = ptrWnd->next)
2091 if( ptrWnd->dwStyle & WS_VISIBLE )
2092 {
2093 GetWindowRect16(ptrWnd->hwndSelf,&tempRect);
2094
2095 if( PtInRect16(&tempRect,pt) )
2096 break;
2097 }
2098
2099 if(ptrWnd)
2100 {
2101 dprintf_msg(stddeb,"DragQueryUpdate: hwnd = %04x, %d %d - %d %d\n",
2102 ptrWnd->hwndSelf, ptrWnd->rectWindow.left, ptrWnd->rectWindow.top,
2103 ptrWnd->rectWindow.right, ptrWnd->rectWindow.bottom );
2104 if( !(ptrWnd->dwStyle & WS_DISABLED) )
2105 bResult = DRAG_QueryUpdate(ptrWnd->hwndSelf, spDragInfo, bNoSend);
2106 }
2107
2108 if(bResult) return bResult;
2109 }
2110 else wParam = 1;
2111 }
2112 else wParam = 1;
2113
2114 ScreenToClient16(hQueryWnd,&ptrDragInfo->pt);
2115
2116 ptrDragInfo->hScope = hQueryWnd;
2117
2118 bResult = ( bNoSend )
2119 ? ptrQueryWnd->dwExStyle & WS_EX_ACCEPTFILES
2120 : SendMessage16( hQueryWnd ,WM_QUERYDROPOBJECT ,
2121 (WPARAM16)wParam ,(LPARAM) spDragInfo );
2122 if( !bResult )
2123 ptrDragInfo->pt = pt;
2124
2125 return bResult;
2126 }
2127
2128 /*******************************************************************
2129 * DragDetect ( USER.465 )
2130 *
2131 */
2132 BOOL16 DragDetect(HWND16 hWnd, POINT16 pt)
2133 {
2134 MSG16 msg;
2135 RECT16 rect;
2136
2137 rect.left = pt.x - wDragWidth;
2138 rect.right = pt.x + wDragWidth;
2139
2140 rect.top = pt.y - wDragHeight;
2141 rect.bottom = pt.y + wDragHeight;
2142
2143 SetCapture32(hWnd);
2144
2145 while(1)
2146 {
2147 while(PeekMessage16(&msg ,0 ,WM_MOUSEFIRST ,WM_MOUSELAST ,PM_REMOVE))
2148 {
2149 if( msg.message == WM_LBUTTONUP )
2150 {
2151 ReleaseCapture();
2152 return 0;
2153 }
2154 if( msg.message == WM_MOUSEMOVE )
2155 {
2156 if( !PtInRect16( &rect, MAKEPOINT16(msg.lParam) ) )
2157 {
2158 ReleaseCapture();
2159 return 1;
2160 }
2161 }
2162 }
2163 WaitMessage();
2164 }
2165
2166 return 0;
2167 }
2168
2169 /******************************************************************************
2170 * DragObject ( USER.464 )
2171 *
2172 */
2173 DWORD DragObject(HWND hwndScope, HWND hWnd, WORD wObj, HANDLE16 hOfStruct,
2174 WORD szList , HCURSOR16 hCursor)
2175 {
2176 MSG16 msg;
2177 LPDRAGINFO lpDragInfo;
2178 SEGPTR spDragInfo;
2179 HCURSOR16 hDragCursor=0, hOldCursor=0, hBummer=0;
2180 HGLOBAL16 hDragInfo = GlobalAlloc16( GMEM_SHARE | GMEM_ZEROINIT, 2*sizeof(DRAGINFO));
2181 WND *wndPtr = WIN_FindWndPtr(hWnd);
2182 DWORD dwRet = 0;
2183 short dragDone = 0;
2184 HCURSOR16 hCurrentCursor = 0;
2185 HWND hCurrentWnd = 0;
2186 BOOL16 b;
2187
2188 lpDragInfo = (LPDRAGINFO) GlobalLock16(hDragInfo);
2189 spDragInfo = (SEGPTR) WIN16_GlobalLock16(hDragInfo);
2190
2191 if( !lpDragInfo || !spDragInfo ) return 0L;
2192
2193 hBummer = LoadCursor16(0,IDC_BUMMER);
2194
2195 if( !hBummer || !wndPtr )
2196 {
2197 GlobalFree16(hDragInfo);
2198 return 0L;
2199 }
2200
2201 if(hCursor)
2202 {
2203 if( !(hDragCursor = CURSORICON_IconToCursor(hCursor, FALSE)) )
2204 {
2205 GlobalFree16(hDragInfo);
2206 return 0L;
2207 }
2208
2209 if( hDragCursor == hCursor ) hDragCursor = 0;
2210 else hCursor = hDragCursor;
2211
2212 hOldCursor = SetCursor(hDragCursor);
2213 }
2214
2215 lpDragInfo->hWnd = hWnd;
2216 lpDragInfo->hScope = 0;
2217 lpDragInfo->wFlags = wObj;
2218 lpDragInfo->hList = szList; /* near pointer! */
2219 lpDragInfo->hOfStruct = hOfStruct;
2220 lpDragInfo->l = 0L;
2221
2222 SetCapture32(hWnd);
2223 ShowCursor(1);
2224
2225 while( !dragDone )
2226 {
2227 WaitMessage();
2228
2229 if( !PeekMessage16(&msg,0,WM_MOUSEFIRST,WM_MOUSELAST,PM_REMOVE) )
2230 continue;
2231
2232 *(lpDragInfo+1) = *lpDragInfo;
2233
2234 lpDragInfo->pt = msg.pt;
2235
2236 /* update DRAGINFO struct */
2237 dprintf_msg(stddeb,"drag: lpDI->hScope = %04x\n",lpDragInfo->hScope);
2238
2239 if( (b = DRAG_QueryUpdate(hwndScope, spDragInfo, FALSE)) > 0 )
2240 hCurrentCursor = hCursor;
2241 else
2242 {
2243 hCurrentCursor = hBummer;
2244 lpDragInfo->hScope = 0;
2245 }
2246 if( hCurrentCursor )
2247 SetCursor(hCurrentCursor);
2248
2249 dprintf_msg(stddeb,"drag: got %04x\n", b);
2250
2251 /* send WM_DRAGLOOP */
2252 SendMessage16( hWnd, WM_DRAGLOOP, (WPARAM16)(hCurrentCursor != hBummer) ,
2253 (LPARAM) spDragInfo );
2254 /* send WM_DRAGSELECT or WM_DRAGMOVE */
2255 if( hCurrentWnd != lpDragInfo->hScope )
2256 {
2257 if( hCurrentWnd )
2258 SendMessage16( hCurrentWnd, WM_DRAGSELECT, 0,
2259 (LPARAM)MAKELONG(LOWORD(spDragInfo)+sizeof(DRAGINFO),
2260 HIWORD(spDragInfo)) );
2261 hCurrentWnd = lpDragInfo->hScope;
2262 if( hCurrentWnd )
2263 SendMessage16( hCurrentWnd, WM_DRAGSELECT, 1, (LPARAM)spDragInfo);
2264 }
2265 else
2266 if( hCurrentWnd )
2267 SendMessage16( hCurrentWnd, WM_DRAGMOVE, 0, (LPARAM)spDragInfo);
2268
2269
2270 /* check if we're done */
2271 if( msg.message == WM_LBUTTONUP || msg.message == WM_NCLBUTTONUP )
2272 dragDone = TRUE;
2273 }
2274
2275 ReleaseCapture();
2276 ShowCursor(0);
2277
2278 if( hCursor )
2279 {
2280 SetCursor(hOldCursor);
2281 if( hDragCursor )
2282 DestroyCursor(hDragCursor);
2283 }
2284
2285 if( hCurrentCursor != hBummer )
2286 dwRet = SendMessage16( lpDragInfo->hScope, WM_DROPOBJECT,
2287 (WPARAM16)hWnd, (LPARAM)spDragInfo );
2288 GlobalFree16(hDragInfo);
2289
2290 return dwRet;
2291 }
2292
Windows API implementation