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