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