windows/win.c

   1 /*
   2  * Window related functions
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  */
   6 #include <stdlib.h>
   7 #include <stdio.h>
   8 #include <string.h>
   9
  10 #include "options.h"
  11 #include "class.h"
  12 #include "win.h"
  13 #include "user.h"
  14 #include "dce.h"
  15 #include "sysmetrics.h"
  16 #include "menu.h"
  17 #include "cursoricon.h"
  18 #include "event.h"
  19 #include "message.h"
  20 #include "nonclient.h"
  21 #include "winpos.h"
  22 #include "color.h"
  23 #include "shm_main_blk.h"
  24 #include "dde_proc.h"
  25 #include "callback.h"
  26 #include "stddebug.h"
  27 /* #define DEBUG_WIN  */
  28 /* #define DEBUG_MENU */
  29 #include "debug.h"
  30
  31 static HWND hwndDesktop = 0;
  32 static HWND hWndSysModal = 0;
  33
  34 /***********************************************************************
  35  *           WIN_FindWndPtr
  36  *
  37  * Return a pointer to the WND structure corresponding to a HWND.
  38  */
  39 WND * WIN_FindWndPtr( HWND hwnd )
  40 {
  41     WND * ptr;
  42
  43     if (!hwnd) return NULL;
  44     ptr = (WND *) USER_HEAP_LIN_ADDR( hwnd );
  45     if (ptr->dwMagic != WND_MAGIC) return NULL;
  46     return ptr;
  47 }
  48
  49
  50 /***********************************************************************
  51  *           WIN_GetXWindow
  52  *
  53  * Return the X window associated to a window.
  54  */
  55 Window WIN_GetXWindow( HWND hwnd )
  56 {
  57     WND *wndPtr = WIN_FindWndPtr( hwnd );
  58     while (wndPtr && !wndPtr->window)
  59     {
  60         wndPtr = WIN_FindWndPtr( wndPtr->hwndParent );
  61     }
  62     return wndPtr ? wndPtr->window : 0;
  63 }
  64
  65
  66 /***********************************************************************
  67  *           WIN_UnlinkWindow
  68  *
  69  * Remove a window from the siblings linked list.
  70  */
  71 BOOL WIN_UnlinkWindow( HWND hwnd )
  72 {
  73     HWND * curWndPtr;
  74     WND *parentPtr, *wndPtr;
  75
  76     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
  77     if (!(parentPtr = WIN_FindWndPtr( wndPtr->hwndParent ))) return FALSE;
  78
  79     curWndPtr = &parentPtr->hwndChild;
  80
  81     while (*curWndPtr != hwnd)
  82     {
  83         WND * curPtr = WIN_FindWndPtr( *curWndPtr );
  84         curWndPtr = &curPtr->hwndNext;
  85     }
  86     *curWndPtr = wndPtr->hwndNext;
  87     return TRUE;
  88 }
  89
  90
  91 /***********************************************************************
  92  *           WIN_LinkWindow
  93  *
  94  * Insert a window into the siblings linked list.
  95  * The window is inserted after the specified window, which can also
  96  * be specified as HWND_TOP or HWND_BOTTOM.
  97  */
  98 BOOL WIN_LinkWindow( HWND hwnd, HWND hwndInsertAfter )
  99 {
 100     HWND * hwndPtr = NULL;  /* pointer to hwnd to change */
 101     WND *wndPtr, *parentPtr;
 102
 103     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
 104     if (!(parentPtr = WIN_FindWndPtr( wndPtr->hwndParent ))) return FALSE;
 105
 106     if ((hwndInsertAfter == HWND_TOP) || (hwndInsertAfter == HWND_BOTTOM))
 107     {
 108         hwndPtr = &parentPtr->hwndChild;  /* Point to first sibling hwnd */
 109         if (hwndInsertAfter == HWND_BOTTOM)  /* Find last sibling hwnd */
 110             while (*hwndPtr)
 111             {
 112                 WND * nextPtr = WIN_FindWndPtr( *hwndPtr );
 113                 hwndPtr = &nextPtr->hwndNext;
 114             }
 115     }
 116     else  /* Normal case */
 117     {
 118         WND * afterPtr = WIN_FindWndPtr( hwndInsertAfter );
 119         if (afterPtr) hwndPtr = &afterPtr->hwndNext;
 120     }
 121     if (!hwndPtr) return FALSE;
 122     wndPtr->hwndNext = *hwndPtr;
 123     *hwndPtr = hwnd;
 124     return TRUE;
 125 }
 126
 127
 128 /***********************************************************************
 129  *           WIN_FindWinToRepaint
 130  *
 131  * Find a window that needs repaint.
 132  */
 133 HWND WIN_FindWinToRepaint( HWND hwnd )
 134 {
 135     WND * wndPtr;
 136
 137       /* Note: the desktop window never gets WM_PAINT messages */
 138     if (!hwnd) hwnd = GetTopWindow( hwndDesktop );
 139     for ( ; hwnd != 0; hwnd = wndPtr->hwndNext )
 140     {
 141         if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return 0;
 142         dprintf_win( stddeb, "WIN_FindWinToRepaint: "NPFMT", style %08lx\n",
 143                      hwnd, wndPtr->dwStyle );
 144         if (!(wndPtr->dwStyle & WS_VISIBLE) || (wndPtr->flags & WIN_NO_REDRAW))
 145             continue;
 146         if ((wndPtr->dwStyle & WS_MINIMIZE) && (WIN_CLASS_INFO(wndPtr).hIcon))
 147             continue;
 148         if (wndPtr->hrgnUpdate || (wndPtr->flags & WIN_INTERNAL_PAINT))
 149             return hwnd;
 150         if (wndPtr->hwndChild)
 151         {
 152             HWND child;
 153             if ((child = WIN_FindWinToRepaint( wndPtr->hwndChild )))
 154                 return child;
 155         }
 156     }
 157     return 0;
 158 }
 159
 160
 161 /***********************************************************************
 162  *           WIN_SendParentNotify
 163  *
 164  * Send a WM_PARENTNOTIFY to all ancestors of the given window, unless
 165  * the window has the WS_EX_NOPARENTNOTIFY style.
 166  */
 167 void WIN_SendParentNotify( HWND hwnd, WORD event, WORD idChild, LONG lValue )
 168 {
 169     WND *wndPtr = WIN_FindWndPtr( hwnd );
 170
 171     while (wndPtr && (wndPtr->dwStyle & WS_CHILD))
 172     {
 173         if (wndPtr->dwExStyle & WS_EX_NOPARENTNOTIFY) break;
 174 #ifdef WINELIB32
 175         SendMessage( wndPtr->hwndParent, WM_PARENTNOTIFY,
 176                      MAKEWPARAM(event,idChild),
 177                      (LPARAM)lValue );
 178 #else
 179         SendMessage( wndPtr->hwndParent, WM_PARENTNOTIFY, event,
 180                      MAKELPARAM(LOWORD(lValue), idChild) );
 181 #endif
 182         wndPtr = WIN_FindWndPtr( wndPtr->hwndParent );
 183     }
 184 }
 185
 186
 187 /***********************************************************************
 188  *           WIN_DestroyWindow
 189  *
 190  * Destroy storage associated to a window
 191  */
 192 static void WIN_DestroyWindow( HWND hwnd )
 193 {
 194     WND *wndPtr = WIN_FindWndPtr( hwnd );
 195     CLASS *classPtr = CLASS_FindClassPtr( wndPtr->hClass );
 196
 197 #ifdef CONFIG_IPC
 198     if (main_block)
 199         DDE_DestroyWindow(hwnd);
 200 #endif  /* CONFIG_IPC */
 201
 202     if (!wndPtr || !classPtr) return;
 203     WIN_UnlinkWindow( hwnd ); /* Remove the window from the linked list */
 204     wndPtr->dwMagic = 0;  /* Mark it as invalid */
 205     if ((wndPtr->hrgnUpdate) || (wndPtr->flags & WIN_INTERNAL_PAINT))
 206     {
 207         if (wndPtr->hrgnUpdate) DeleteObject( wndPtr->hrgnUpdate );
 208         MSG_DecPaintCount( wndPtr->hmemTaskQ );
 209     }
 210     if (!(wndPtr->dwStyle & WS_CHILD))
 211     {
 212         if (wndPtr->wIDmenu) DestroyMenu( (HMENU)wndPtr->wIDmenu );
 213     }
 214     if (wndPtr->hSysMenu) DestroyMenu( wndPtr->hSysMenu );
 215     if (wndPtr->window) XDestroyWindow( display, wndPtr->window );
 216     if (classPtr->wc.style & CS_OWNDC) DCE_FreeDCE( wndPtr->hdce );
 217     classPtr->cWindows--;
 218     USER_HEAP_FREE( hwnd );
 219 }
 220
 221
 222 /***********************************************************************
 223  *           WIN_CreateDesktopWindow
 224  *
 225  * Create the desktop window.
 226  */
 227 BOOL WIN_CreateDesktopWindow(void)
 228 {
 229     WND *wndPtr;
 230     HCLASS hclass;
 231     CLASS *classPtr;
 232     HDC hdc;
 233
 234     if (!(hclass = CLASS_FindClassByName( DESKTOP_CLASS_ATOM, 0, &classPtr )))
 235         return FALSE;
 236
 237     hwndDesktop = USER_HEAP_ALLOC( sizeof(WND)+classPtr->wc.cbWndExtra );
 238     if (!hwndDesktop) return FALSE;
 239     wndPtr = (WND *) USER_HEAP_LIN_ADDR( hwndDesktop );
 240
 241     wndPtr->hwndNext          = 0;
 242     wndPtr->hwndChild         = 0;
 243     wndPtr->dwMagic           = WND_MAGIC;
 244     wndPtr->hwndParent        = 0;
 245     wndPtr->hwndOwner         = 0;
 246     wndPtr->hClass            = hclass;
 247     wndPtr->hInstance         = 0;
 248     wndPtr->rectWindow.left   = 0;
 249     wndPtr->rectWindow.top    = 0;
 250     wndPtr->rectWindow.right  = SYSMETRICS_CXSCREEN;
 251     wndPtr->rectWindow.bottom = SYSMETRICS_CYSCREEN;
 252     wndPtr->rectClient        = wndPtr->rectWindow;
 253     wndPtr->rectNormal        = wndPtr->rectWindow;
 254     wndPtr->ptIconPos.x       = -1;
 255     wndPtr->ptIconPos.y       = -1;
 256     wndPtr->ptMaxPos.x        = -1;
 257     wndPtr->ptMaxPos.y        = -1;
 258     wndPtr->hmemTaskQ         = 0;  /* Desktop does not belong to a task */
 259     wndPtr->hrgnUpdate        = 0;
 260     wndPtr->hwndLastActive    = hwndDesktop;
 261     wndPtr->lpfnWndProc       = classPtr->wc.lpfnWndProc;
 262     wndPtr->dwStyle           = WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
 263     wndPtr->dwExStyle         = 0;
 264     wndPtr->hdce              = 0;
 265     wndPtr->hVScroll          = 0;
 266     wndPtr->hHScroll          = 0;
 267     wndPtr->wIDmenu           = 0;
 268     wndPtr->hText             = 0;
 269     wndPtr->flags             = 0;
 270     wndPtr->window            = rootWindow;
 271     wndPtr->hSysMenu          = 0;
 272     wndPtr->hProp             = 0;
 273     EVENT_RegisterWindow( wndPtr->window, hwndDesktop );
 274     SendMessage( hwndDesktop, WM_NCCREATE, 0, 0 );
 275     if ((hdc = GetDC( hwndDesktop )) != 0)
 276     {
 277         SendMessage( hwndDesktop, WM_ERASEBKGND, (WPARAM)hdc, 0 );
 278         ReleaseDC( hwndDesktop, hdc );
 279     }
 280     return TRUE;
 281 }
 282
 283
 284 /***********************************************************************
 285  *           CreateWindow   (USER.41)
 286  */
 287 HWND CreateWindow( SEGPTR className, SEGPTR windowName,
 288                    DWORD style, INT x, INT y, INT width, INT height,
 289                    HWND parent, HMENU menu, HANDLE instance, SEGPTR data )
 290 {
 291     return CreateWindowEx( 0, className, windowName, style,
 292                            x, y, width, height, parent, menu, instance, data );
 293 }
 294
 295
 296 /***********************************************************************
 297  *           CreateWindowEx   (USER.452)
 298  */
 299 HWND CreateWindowEx( DWORD exStyle, SEGPTR className, SEGPTR windowName,
 300                      DWORD style, INT x, INT y, INT width, INT height,
 301                      HWND parent, HMENU menu, HANDLE instance, SEGPTR data )
 302 {
 303     HANDLE class, hwnd;
 304     CLASS *classPtr;
 305     WND *wndPtr;
 306     POINT maxSize, maxPos, minTrack, maxTrack;
 307     CREATESTRUCT createStruct;
 308     int wmcreate;
 309     XSetWindowAttributes win_attr;
 310
 311     /* FIXME: windowName and className should be SEGPTRs */
 312
 313     dprintf_win( stddeb, "CreateWindowEx: " );
 314     if (HIWORD(windowName))
 315         dprintf_win( stddeb, "'%s' ", (char *)PTR_SEG_TO_LIN(windowName) );
 316     else
 317         dprintf_win( stddeb, "%04x ", LOWORD(windowName) );
 318     if (HIWORD(className))
 319         dprintf_win( stddeb, "'%s' ", (char *)PTR_SEG_TO_LIN(className) );
 320     else
 321         dprintf_win( stddeb, "%04x ", LOWORD(className) );
 322
 323     dprintf_win(stddeb, "%08lx %08lx %d,%d %dx%d "NPFMT" "NPFMT" "NPFMT" %08lx\n",
 324                 exStyle, style, x, y, width, height,
 325                 parent, menu, instance, (DWORD)data);
 326
 327     if (x == CW_USEDEFAULT) x = y = 0;
 328     if (width == CW_USEDEFAULT)
 329     {
 330         width = 600;
 331         height = 400;
 332     }
 333
 334       /* Find the parent and class */
 335
 336     if (parent)
 337     {
 338         /* Make sure parent is valid */
 339         if (!IsWindow( parent )) {
 340             dprintf_win(stddeb,"CreateWindowEx: Parent "NPFMT" is not a window\n", parent);
 341             return 0;
 342         }
 343     }
 344     else
 345     {
 346         if (style & WS_CHILD) {
 347             dprintf_win(stddeb,"CreateWindowEx: no parent\n");
 348             return 0;  /* WS_CHILD needs a parent */
 349         }
 350     }
 351
 352     if (!(class = CLASS_FindClassByName( className, GetExePtr(instance),
 353                                          &classPtr )))
 354     {
 355         fprintf(stderr,"CreateWindow BAD CLASSNAME " );
 356         if (HIWORD(className)) fprintf( stderr, "'%s'\n",
 357                                         (char *)PTR_SEG_TO_LIN(className) );
 358         else fprintf( stderr, "%04x\n", LOWORD(className) );
 359         return 0;
 360     }
 361
 362       /* Correct the window style */
 363
 364     if (!(style & (WS_POPUP | WS_CHILD)))  /* Overlapped window */
 365         style |= WS_CAPTION | WS_CLIPSIBLINGS;
 366     if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
 367
 368       /* Create the window structure */
 369
 370     hwnd = USER_HEAP_ALLOC( sizeof(WND)+classPtr->wc.cbWndExtra );
 371     if (!hwnd) {
 372         dprintf_win(stddeb,"CreateWindowEx: Out of memory\n");
 373         return 0;
 374     }
 375
 376       /* Fill the structure */
 377
 378     wndPtr = (WND *) USER_HEAP_LIN_ADDR( hwnd );
 379     wndPtr->hwndNext       = 0;
 380     wndPtr->hwndChild      = 0;
 381     wndPtr->window         = 0;
 382     wndPtr->dwMagic        = WND_MAGIC;
 383     wndPtr->hwndParent     = (style & WS_CHILD) ? parent : hwndDesktop;
 384     wndPtr->hwndOwner      = (style & WS_CHILD) ? 0 : WIN_GetTopParent(parent);
 385     wndPtr->hClass         = class;
 386     wndPtr->hInstance      = instance;
 387     wndPtr->ptIconPos.x    = -1;
 388     wndPtr->ptIconPos.y    = -1;
 389     wndPtr->ptMaxPos.x     = -1;
 390     wndPtr->ptMaxPos.y     = -1;
 391     wndPtr->hmemTaskQ      = GetTaskQueue(0);
 392     wndPtr->hrgnUpdate     = 0;
 393     wndPtr->hwndPrevActive = 0;
 394     wndPtr->hwndLastActive = hwnd;
 395     wndPtr->lpfnWndProc    = classPtr->wc.lpfnWndProc;
 396     wndPtr->dwStyle        = style & ~WS_VISIBLE;
 397     wndPtr->dwExStyle      = exStyle;
 398     wndPtr->wIDmenu        = 0;
 399     wndPtr->hText          = 0;
 400     wndPtr->flags          = 0;
 401     wndPtr->hVScroll       = 0;
 402     wndPtr->hHScroll       = 0;
 403     wndPtr->hSysMenu       = 0;
 404     wndPtr->hProp          = 0;
 405
 406     if (classPtr->wc.cbWndExtra)
 407         memset( wndPtr->wExtra, 0, classPtr->wc.cbWndExtra );
 408     classPtr->cWindows++;
 409
 410       /* Get class or window DC if needed */
 411
 412     if (classPtr->wc.style & CS_OWNDC)
 413         wndPtr->hdce = DCE_AllocDCE( DCE_WINDOW_DC );
 414     else if (classPtr->wc.style & CS_CLASSDC)
 415         wndPtr->hdce = classPtr->hdce;
 416     else
 417         wndPtr->hdce = 0;
 418
 419       /* Insert the window in the linked list */
 420
 421     WIN_LinkWindow( hwnd, HWND_TOP );
 422
 423       /* Send the WM_GETMINMAXINFO message and fix the size if needed */
 424
 425     NC_GetMinMaxInfo( hwnd, &maxSize, &maxPos, &minTrack, &maxTrack );
 426
 427     if (maxSize.x < width) width = maxSize.x;
 428     if (maxSize.y < height) height = maxSize.y;
 429     if (width <= 0) width = 1;
 430     if (height <= 0) height = 1;
 431
 432     wndPtr->rectWindow.left   = x;
 433     wndPtr->rectWindow.top    = y;
 434     wndPtr->rectWindow.right  = x + width;
 435     wndPtr->rectWindow.bottom = y + height;
 436     wndPtr->rectClient        = wndPtr->rectWindow;
 437     wndPtr->rectNormal        = wndPtr->rectWindow;
 438
 439       /* Create the X window (only for top-level windows, and then only */
 440       /* when there's no desktop window) */
 441
 442     if (!(style & WS_CHILD) && (rootWindow == DefaultRootWindow(display)))
 443     {
 444         win_attr.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask |
 445                               PointerMotionMask | ButtonPressMask |
 446                               ButtonReleaseMask | FocusChangeMask;
 447         win_attr.override_redirect = TRUE;
 448         win_attr.colormap      = COLOR_WinColormap;
 449         win_attr.backing_store = Options.backingstore ? WhenMapped : NotUseful;
 450         win_attr.save_under    = ((classPtr->wc.style & CS_SAVEBITS) != 0);
 451         win_attr.cursor        = CURSORICON_XCursor;
 452         wndPtr->window = XCreateWindow( display, rootWindow, x, y,
 453                                         width, height, 0, CopyFromParent,
 454                                         InputOutput, CopyFromParent,
 455                                         CWEventMask | CWOverrideRedirect |
 456                                         CWColormap | CWCursor | CWSaveUnder |
 457                                         CWBackingStore, &win_attr );
 458         XStoreName( display, wndPtr->window, PTR_SEG_TO_LIN(windowName) );
 459         EVENT_RegisterWindow( wndPtr->window, hwnd );
 460     }
 461
 462     if ((style & WS_CAPTION) && !(style & WS_CHILD))
 463     {
 464         if (menu) SetMenu(hwnd, menu);
 465         else if (classPtr->wc.lpszMenuName)
 466             SetMenu( hwnd, LoadMenu( instance, classPtr->wc.lpszMenuName ) );
 467     }
 468     else wndPtr->wIDmenu = (UINT)menu;
 469
 470       /* Send the WM_CREATE message */
 471
 472     createStruct.lpCreateParams = (LPSTR)data;
 473     createStruct.hInstance      = instance;
 474     createStruct.hMenu          = menu;
 475     createStruct.hwndParent     = parent;
 476     createStruct.cx             = width;
 477     createStruct.cy             = height;
 478     createStruct.x              = x;
 479     createStruct.y              = y;
 480     createStruct.style          = style;
 481     createStruct.lpszName       = windowName;
 482     createStruct.lpszClass      = className;
 483     createStruct.dwExStyle      = 0;
 484
 485     wmcreate = SendMessage( hwnd, WM_NCCREATE, 0, MAKE_SEGPTR(&createStruct) );
 486     if (!wmcreate)
 487     {
 488         dprintf_win(stddeb,"CreateWindowEx: WM_NCCREATE return 0\n");
 489         wmcreate = -1;
 490     }
 491     else
 492     {
 493         WINPOS_SendNCCalcSize( hwnd, FALSE, &wndPtr->rectWindow,
 494                                NULL, NULL, NULL, &wndPtr->rectClient );
 495         wmcreate = SendMessage(hwnd, WM_CREATE, 0, MAKE_SEGPTR(&createStruct));
 496     }
 497
 498     if (wmcreate == -1)
 499     {
 500           /* Abort window creation */
 501         dprintf_win(stddeb,"CreateWindowEx: wmcreate==-1, aborting\n");
 502         WIN_DestroyWindow( hwnd );
 503         return 0;
 504     }
 505
 506       /* Create a copy of SysMenu */
 507     if (style & WS_SYSMENU) wndPtr->hSysMenu = CopySysMenu();
 508
 509     WIN_SendParentNotify( hwnd, WM_CREATE, wndPtr->wIDmenu, (LONG)hwnd );
 510
 511     /* Show the window, maximizing or minimizing if needed */
 512
 513     if (wndPtr->dwStyle & WS_MINIMIZE)
 514     {
 515         wndPtr->dwStyle &= ~WS_MAXIMIZE;
 516         WINPOS_FindIconPos( hwnd );
 517         SetWindowPos( hwnd, 0, wndPtr->ptIconPos.x, wndPtr->ptIconPos.y,
 518                       SYSMETRICS_CXICON, SYSMETRICS_CYICON,
 519                       SWP_FRAMECHANGED |
 520                       (style & WS_VISIBLE) ? SWP_SHOWWINDOW : 0 );
 521     }
 522     else if (wndPtr->dwStyle & WS_MAXIMIZE)
 523     {
 524         SetWindowPos( hwnd, 0, maxPos.x, maxPos.y, maxSize.x, maxSize.y,
 525                       SWP_FRAMECHANGED |
 526                       (style & WS_VISIBLE) ? SWP_SHOWWINDOW : 0 );
 527     }
 528     else if (style & WS_VISIBLE) ShowWindow( hwnd, SW_SHOW );
 529
 530     dprintf_win(stddeb, "CreateWindowEx: return "NPFMT" \n", hwnd);
 531     return hwnd;
 532 }
 533
 534
 535 /***********************************************************************
 536  *           DestroyWindow   (USER.53)
 537  */
 538 BOOL DestroyWindow( HWND hwnd )
 539 {
 540     WND * wndPtr;
 541     CLASS * classPtr;
 542
 543     dprintf_win(stddeb, "DestroyWindow ("NPFMT")\n", hwnd);
 544
 545       /* Initialisation */
 546
 547     if (hwnd == hwndDesktop) return FALSE;  /* Can't destroy desktop */
 548     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
 549     if (!(classPtr = CLASS_FindClassPtr( wndPtr->hClass ))) return FALSE;
 550
 551       /* Hide the window */
 552
 553     if (wndPtr->dwStyle & WS_VISIBLE)
 554         SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_HIDEWINDOW | SWP_NOACTIVATE |
 555                       SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE );
 556     if ((hwnd == GetCapture()) || IsChild( hwnd, GetCapture() ))
 557         ReleaseCapture();
 558     WIN_SendParentNotify( hwnd, WM_DESTROY, wndPtr->wIDmenu, (LONG)hwnd );
 559
 560       /* Recursively destroy owned windows */
 561
 562     for (;;)
 563     {
 564         HWND hwndSibling = GetWindow( hwnd, GW_HWNDFIRST );
 565         while (hwndSibling)
 566         {
 567             WND *siblingPtr = WIN_FindWndPtr( hwndSibling );
 568             if (siblingPtr->hwndOwner == hwnd) break;
 569             hwndSibling = siblingPtr->hwndNext;
 570         }
 571         if (hwndSibling) DestroyWindow( hwndSibling );
 572         else break;
 573     }
 574
 575       /* Send destroy messages and destroy children */
 576
 577     SendMessage( hwnd, WM_DESTROY, 0, 0 );
 578     while (wndPtr->hwndChild)  /* The child removes itself from the list */
 579         DestroyWindow( wndPtr->hwndChild );
 580     SendMessage( hwnd, WM_NCDESTROY, 0, 0 );
 581
 582       /* Destroy the window */
 583
 584     WIN_DestroyWindow( hwnd );
 585     return TRUE;
 586 }
 587
 588
 589 /***********************************************************************
 590  *           CloseWindow   (USER.43)
 591  */
 592 void CloseWindow(HWND hWnd)
 593 {
 594     WND * wndPtr = WIN_FindWndPtr(hWnd);
 595     if (wndPtr->dwStyle & WS_CHILD) return;
 596     ShowWindow(hWnd, SW_MINIMIZE);
 597 }
 598
 599
 600 /***********************************************************************
 601  *           OpenIcon   (USER.44)
 602  */
 603 BOOL OpenIcon(HWND hWnd)
 604 {
 605     if (!IsIconic(hWnd)) return FALSE;
 606     ShowWindow(hWnd, SW_SHOWNORMAL);
 607     return(TRUE);
 608 }
 609
 610
 611 /***********************************************************************
 612  *           FindWindow   (USER.50)
 613  */
 614 HWND FindWindow( SEGPTR ClassMatch, LPSTR TitleMatch )
 615 {
 616     HCLASS hclass;
 617     CLASS *classPtr;
 618     HWND hwnd;
 619
 620     if (ClassMatch)
 621     {
 622         hclass = CLASS_FindClassByName( ClassMatch, (HINSTANCE)0xffff,
 623                                         &classPtr );
 624         if (!hclass) return 0;
 625     }
 626     else hclass = 0;
 627
 628     hwnd = GetTopWindow( hwndDesktop );
 629     while(hwnd)
 630     {
 631         WND *wndPtr = WIN_FindWndPtr( hwnd );
 632         if (!hclass || (wndPtr->hClass == hclass))
 633         {
 634               /* Found matching class */
 635             if (!TitleMatch) return hwnd;
 636             if (wndPtr->hText)
 637             {
 638                 char *textPtr = (char *) USER_HEAP_LIN_ADDR( wndPtr->hText );
 639                 if (!strcmp( textPtr, TitleMatch )) return hwnd;
 640             }
 641         }
 642         hwnd = wndPtr->hwndNext;
 643     }
 644     return 0;
 645 }
 646
 647
 648 /**********************************************************************
 649  *           GetDesktopWindow        (USER.286)
 650  *           GetDeskTopHwnd          (USER.278)
 651  */
 652 HWND GetDesktopWindow(void)
 653 {
 654     return hwndDesktop;
 655 }
 656
 657
 658 /*******************************************************************
 659  *           EnableWindow   (USER.34)
 660  */
 661 BOOL EnableWindow( HWND hwnd, BOOL enable )
 662 {
 663     WND *wndPtr;
 664
 665     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
 666     if (enable && (wndPtr->dwStyle & WS_DISABLED))
 667     {
 668           /* Enable window */
 669         wndPtr->dwStyle &= ~WS_DISABLED;
 670         SendMessage( hwnd, WM_ENABLE, TRUE, 0 );
 671         return TRUE;
 672     }
 673     else if (!enable && !(wndPtr->dwStyle & WS_DISABLED))
 674     {
 675           /* Disable window */
 676         wndPtr->dwStyle |= WS_DISABLED;
 677         if ((hwnd == GetFocus()) || IsChild( hwnd, GetFocus() ))
 678             SetFocus( 0 );  /* A disabled window can't have the focus */
 679         if ((hwnd == GetCapture()) || IsChild( hwnd, GetCapture() ))
 680             ReleaseCapture();  /* A disabled window can't capture the mouse */
 681         SendMessage( hwnd, WM_ENABLE, FALSE, 0 );
 682         return FALSE;
 683     }
 684     return ((wndPtr->dwStyle & WS_DISABLED) != 0);
 685 }
 686
 687
 688 /***********************************************************************
 689  *           IsWindowEnabled   (USER.35)
 690  */
 691 BOOL IsWindowEnabled(HWND hWnd)
 692 {
 693     WND * wndPtr;
 694
 695     if (!(wndPtr = WIN_FindWndPtr(hWnd))) return FALSE;
 696     return !(wndPtr->dwStyle & WS_DISABLED);
 697 }
 698
 699
 700 /**********************************************************************
 701  *           GetWindowWord    (USER.133)
 702  */
 703 WORD GetWindowWord( HWND hwnd, short offset )
 704 {
 705     WND * wndPtr = WIN_FindWndPtr( hwnd );
 706     if (!wndPtr) return 0;
 707     if (offset >= 0) return *(WORD *)(((char *)wndPtr->wExtra) + offset);
 708     switch(offset)
 709     {
 710         case GWW_ID:         return wndPtr->wIDmenu;
 711 #ifdef WINELIB32
 712         case GWW_HWNDPARENT:
 713         case GWW_HINSTANCE:
 714             fprintf(stderr,"GetWindowWord called with offset %d.\n",offset);
 715             return 0;
 716 #else
 717         case GWW_HWNDPARENT: return (WORD)wndPtr->hwndParent;
 718         case GWW_HINSTANCE:  return (WORD)wndPtr->hInstance;
 719 #endif
 720     }
 721     return 0;
 722 }
 723
 724
 725 /**********************************************************************
 726  *           WIN_GetWindowInstance
 727  */
 728 HINSTANCE WIN_GetWindowInstance(HWND hwnd)
 729 {
 730     WND * wndPtr = WIN_FindWndPtr( hwnd );
 731     if (!wndPtr) return (HINSTANCE)0;
 732     return wndPtr->hInstance;
 733 }
 734
 735
 736 /**********************************************************************
 737  *           SetWindowWord    (USER.134)
 738  */
 739 WORD SetWindowWord( HWND hwnd, short offset, WORD newval )
 740 {
 741     WORD *ptr, retval;
 742     WND * wndPtr = WIN_FindWndPtr( hwnd );
 743     if (!wndPtr) return 0;
 744     if (offset >= 0) ptr = (WORD *)(((char *)wndPtr->wExtra) + offset);
 745     else switch(offset)
 746     {
 747 #ifdef WINELIB32
 748         case GWW_ID:
 749         case GWW_HINSTANCE:
 750             fprintf(stderr,"SetWindowWord called with offset %d.\n",offset);
 751             return 0;
 752 #else
 753         case GWW_ID:        ptr = &wndPtr->wIDmenu;   break;
 754         case GWW_HINSTANCE: ptr = (WORD*)&wndPtr->hInstance; break;
 755 #endif
 756         default: return 0;
 757     }
 758     retval = *ptr;
 759     *ptr = newval;
 760     return retval;
 761 }
 762
 763
 764 /**********************************************************************
 765  *           GetWindowLong    (USER.135)
 766  */
 767 LONG GetWindowLong( HWND hwnd, short offset )
 768 {
 769     WND * wndPtr = WIN_FindWndPtr( hwnd );
 770     if (!wndPtr) return 0;
 771     if (offset >= 0) return *(LONG *)(((char *)wndPtr->wExtra) + offset);
 772     switch(offset)
 773     {
 774         case GWL_STYLE:   return wndPtr->dwStyle;
 775         case GWL_EXSTYLE: return wndPtr->dwExStyle;
 776         case GWL_WNDPROC: return (LONG)wndPtr->lpfnWndProc;
 777 #ifdef WINELIB32
 778         case GWW_HWNDPARENT: return (LONG)wndPtr->hwndParent;
 779         case GWW_HINSTANCE:  return (LONG)wndPtr->hInstance;
 780 #endif
 781     }
 782     return 0;
 783 }
 784
 785
 786 /**********************************************************************
 787  *           SetWindowLong    (USER.136)
 788  */
 789 LONG SetWindowLong( HWND hwnd, short offset, LONG newval )
 790 {
 791     LONG *ptr, retval;
 792     WND * wndPtr = WIN_FindWndPtr( hwnd );
 793     if (!wndPtr) return 0;
 794     if (offset >= 0) ptr = (LONG *)(((char *)wndPtr->wExtra) + offset);
 795     else switch(offset)
 796     {
 797         case GWL_STYLE:   ptr = &wndPtr->dwStyle; break;
 798         case GWL_EXSTYLE: ptr = &wndPtr->dwExStyle; break;
 799         case GWL_WNDPROC: ptr = (LONG *)&wndPtr->lpfnWndProc; break;
 800         default: return 0;
 801     }
 802     retval = *ptr;
 803     *ptr = newval;
 804     return retval;
 805 }
 806
 807
 808 /*******************************************************************
 809  *         GetWindowText          (USER.36)
 810  */
 811 int WIN16_GetWindowText( HWND hwnd, SEGPTR lpString, int nMaxCount )
 812 {
 813     return (int)SendMessage(hwnd, WM_GETTEXT, (WORD)nMaxCount,
 814                                               (DWORD)lpString);
 815 }
 816
 817 int GetWindowText( HWND hwnd, LPSTR lpString, int nMaxCount )
 818 {
 819     int len;
 820     HANDLE handle;
 821
 822       /* We have to allocate a buffer on the USER heap */
 823       /* to be able to pass its address to 16-bit code */
 824     if (!(handle = USER_HEAP_ALLOC( nMaxCount ))) return 0;
 825     len = (int)SendMessage( hwnd, WM_GETTEXT, (WPARAM)nMaxCount,
 826                             (LPARAM)USER_HEAP_SEG_ADDR(handle) );
 827     strncpy( lpString, USER_HEAP_LIN_ADDR(handle), nMaxCount );
 828     USER_HEAP_FREE( handle );
 829     return len;
 830 }
 831
 832
 833 /*******************************************************************
 834  *         SetWindowText          (USER.37)
 835  */
 836 void WIN16_SetWindowText( HWND hwnd, SEGPTR lpString )
 837 {
 838     SendMessage( hwnd, WM_SETTEXT, 0, (DWORD)lpString );
 839 }
 840
 841 void SetWindowText( HWND hwnd, LPSTR lpString )
 842 {
 843     HANDLE handle;
 844
 845       /* We have to allocate a buffer on the USER heap */
 846       /* to be able to pass its address to 16-bit code */
 847     if (!(handle = USER_HEAP_ALLOC( strlen(lpString)+1 ))) return;
 848     strcpy( USER_HEAP_LIN_ADDR(handle), lpString );
 849     SendMessage( hwnd, WM_SETTEXT, 0, (LPARAM)USER_HEAP_SEG_ADDR(handle) );
 850     USER_HEAP_FREE( handle );
 851 }
 852
 853
 854 /*******************************************************************
 855  *         GetWindowTextLength    (USER.38)
 856  */
 857 int GetWindowTextLength(HWND hwnd)
 858 {
 859     return (int)SendMessage(hwnd, WM_GETTEXTLENGTH, 0, 0 );
 860 }
 861
 862
 863 /*******************************************************************
 864  *         IsWindow    (USER.47)
 865  */
 866 BOOL IsWindow( HWND hwnd )
 867 {
 868     WND * wndPtr = WIN_FindWndPtr( hwnd );
 869     return ((wndPtr != NULL) && (wndPtr->dwMagic == WND_MAGIC));
 870 }
 871
 872
 873 /*****************************************************************
 874  *         GetParent              (USER.46)
 875  */
 876 HWND GetParent(HWND hwnd)
 877 {
 878     WND *wndPtr = WIN_FindWndPtr(hwnd);
 879     if (!wndPtr) return 0;
 880     return (wndPtr->dwStyle & WS_CHILD) ?
 881             wndPtr->hwndParent : wndPtr->hwndOwner;
 882 }
 883
 884
 885 /*****************************************************************
 886  *         WIN_GetTopParent
 887  *
 888  * Get the top-level parent for a child window.
 889  */
 890 HWND WIN_GetTopParent( HWND hwnd )
 891 {
 892     while (hwnd)
 893     {
 894         WND *wndPtr = WIN_FindWndPtr( hwnd );
 895         if (wndPtr->dwStyle & WS_CHILD) hwnd = wndPtr->hwndParent;
 896         else break;
 897     }
 898     return hwnd;
 899 }
 900
 901
 902 /*****************************************************************
 903  *         SetParent              (USER.233)
 904  */
 905 HWND SetParent(HWND hwndChild, HWND hwndNewParent)
 906 {
 907     HWND temp;
 908
 909     WND *wndPtr = WIN_FindWndPtr(hwndChild);
 910     if (!wndPtr || !(wndPtr->dwStyle & WS_CHILD)) return 0;
 911
 912     temp = wndPtr->hwndParent;
 913
 914     WIN_UnlinkWindow(hwndChild);
 915     if (hwndNewParent)
 916       wndPtr->hwndParent = hwndNewParent;
 917     else
 918       wndPtr->hwndParent = GetDesktopWindow();
 919     WIN_LinkWindow(hwndChild, HWND_BOTTOM);
 920
 921     if (IsWindowVisible(hwndChild)) UpdateWindow(hwndChild);
 922
 923     return temp;
 924 }
 925
 926
 927
 928 /*******************************************************************
 929  *         IsChild    (USER.48)
 930  */
 931 BOOL IsChild( HWND parent, HWND child )
 932 {
 933     WND * wndPtr = WIN_FindWndPtr( child );
 934     while (wndPtr && (wndPtr->dwStyle & WS_CHILD))
 935     {
 936         if (wndPtr->hwndParent == parent) return TRUE;
 937         wndPtr = WIN_FindWndPtr( wndPtr->hwndParent );
 938     }
 939     return FALSE;
 940 }
 941
 942
 943 /***********************************************************************
 944  *           IsWindowVisible   (USER.49)
 945  */
 946 BOOL IsWindowVisible( HWND hwnd )
 947 {
 948     WND *wndPtr = WIN_FindWndPtr( hwnd );
 949     while (wndPtr && (wndPtr->dwStyle & WS_CHILD))
 950     {
 951         if (!(wndPtr->dwStyle & WS_VISIBLE)) return FALSE;
 952         wndPtr = WIN_FindWndPtr( wndPtr->hwndParent );
 953     }
 954     return (wndPtr && (wndPtr->dwStyle & WS_VISIBLE));
 955 }
 956
 957
 958
 959 /*******************************************************************
 960  *         GetTopWindow    (USER.229)
 961  */
 962 HWND GetTopWindow( HWND hwnd )
 963 {
 964     WND * wndPtr = WIN_FindWndPtr( hwnd );
 965     if (wndPtr) return wndPtr->hwndChild;
 966     else return 0;
 967 }
 968
 969
 970 /*******************************************************************
 971  *         GetWindow    (USER.262)
 972  */
 973 HWND GetWindow( HWND hwnd, WORD rel )
 974 {
 975     WND * wndPtr = WIN_FindWndPtr( hwnd );
 976     if (!wndPtr) return 0;
 977     switch(rel)
 978     {
 979     case GW_HWNDFIRST:
 980         if (wndPtr->hwndParent)
 981         {
 982             WND * parentPtr = WIN_FindWndPtr( wndPtr->hwndParent );
 983             return parentPtr->hwndChild;
 984         }
 985         else return 0;
 986
 987     case GW_HWNDLAST:
 988         if (!wndPtr->hwndParent) return 0;  /* Desktop window */
 989         while (wndPtr->hwndNext)
 990         {
 991             hwnd = wndPtr->hwndNext;
 992             wndPtr = WIN_FindWndPtr( hwnd );
 993         }
 994         return hwnd;
 995
 996     case GW_HWNDNEXT:
 997         return wndPtr->hwndNext;
 998
 999     case GW_HWNDPREV:
1000         {
1001             HWND hwndPrev;
1002
1003             if (wndPtr->hwndParent)
1004             {
1005                 WND * parentPtr = WIN_FindWndPtr( wndPtr->hwndParent );
1006                 hwndPrev = parentPtr->hwndChild;
1007             }
1008             else return 0;  /* Desktop window */
1009             if (hwndPrev == hwnd) return 0;
1010             while (hwndPrev)
1011             {
1012                 wndPtr = WIN_FindWndPtr( hwndPrev );
1013                 if (wndPtr->hwndNext == hwnd) break;
1014                 hwndPrev = wndPtr->hwndNext;
1015             }
1016             return hwndPrev;
1017         }
1018
1019     case GW_OWNER:
1020         return wndPtr->hwndOwner;
1021
1022     case GW_CHILD:
1023         return wndPtr->hwndChild;
1024     }
1025     return 0;
1026 }
1027
1028
1029 /*******************************************************************
1030  *         GetNextWindow    (USER.230)
1031  */
1032 HWND GetNextWindow( HWND hwnd, WORD flag )
1033 {
1034     if ((flag != GW_HWNDNEXT) && (flag != GW_HWNDPREV)) return 0;
1035     return GetWindow( hwnd, flag );
1036 }
1037
1038 /*******************************************************************
1039  *         ShowOwnedPopups  (USER.265)
1040  */
1041 void ShowOwnedPopups( HWND owner, BOOL fShow )
1042 {
1043     HWND hwnd = GetWindow( hwndDesktop, GW_CHILD );
1044     while (hwnd)
1045     {
1046         WND *wnd = WIN_FindWndPtr(hwnd);
1047         if (wnd->hwndOwner == owner && (wnd->dwStyle & WS_POPUP))
1048             ShowWindow( hwnd, fShow ? SW_SHOW : SW_HIDE );
1049         hwnd = wnd->hwndNext;
1050     }
1051 }
1052
1053
1054 /*******************************************************************
1055  *         GetLastActivePopup    (USER.287)
1056  */
1057 HWND GetLastActivePopup(HWND hwnd)
1058 {
1059     WND *wndPtr;
1060     wndPtr = WIN_FindWndPtr(hwnd);
1061     if (wndPtr == NULL) return hwnd;
1062     return wndPtr->hwndLastActive;
1063 }
1064
1065
1066 /*******************************************************************
1067  *           EnumWindows   (USER.54)
1068  */
1069 BOOL EnumWindows( FARPROC lpEnumFunc, LPARAM lParam )
1070 {
1071     HWND hwnd;
1072     WND *wndPtr;
1073     HWND *list, *pWnd;
1074     int count;
1075
1076     /* We have to build a list of all windows first, to avoid */
1077     /* unpleasant side-effects, for instance if the callback  */
1078     /* function changes the Z-order of the windows.           */
1079
1080       /* First count the windows */
1081
1082     count = 0;
1083     for (hwnd = GetTopWindow(hwndDesktop); hwnd != 0; hwnd = wndPtr->hwndNext)
1084     {
1085         if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
1086         count++;
1087     }
1088     if (!count) return TRUE;
1089
1090       /* Now build the list of all windows */
1091
1092     if (!(list = (HWND *)malloc( sizeof(HWND) * count ))) return FALSE;
1093     for (hwnd = GetTopWindow(hwndDesktop), pWnd = list; hwnd != 0; hwnd = wndPtr->hwndNext)
1094     {
1095         wndPtr = WIN_FindWndPtr( hwnd );
1096         *pWnd++ = hwnd;
1097     }
1098
1099       /* Now call the callback function for every window */
1100
1101     for (pWnd = list; count > 0; count--, pWnd++)
1102     {
1103           /* Make sure that window still exists */
1104         if (!IsWindow(*pWnd)) continue;
1105         if (!CallEnumWindowsProc( lpEnumFunc, *pWnd, lParam )) break;
1106     }
1107     free( list );
1108     return TRUE;
1109 }
1110
1111
1112 /**********************************************************************
1113  *           EnumTaskWindows   (USER.225)
1114  */
1115 BOOL EnumTaskWindows( HTASK hTask, FARPROC lpEnumFunc, LONG lParam )
1116 {
1117     HWND hwnd;
1118     WND *wndPtr;
1119     HWND *list, *pWnd;
1120     HANDLE hQueue = GetTaskQueue( hTask );
1121     int count;
1122
1123     /* This function is the same as EnumWindows(),    */
1124     /* except for an added check on the window queue. */
1125
1126       /* First count the windows */
1127
1128     count = 0;
1129     for (hwnd = GetTopWindow(hwndDesktop); hwnd != 0; hwnd = wndPtr->hwndNext)
1130     {
1131         if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
1132         if (wndPtr->hmemTaskQ == hQueue) count++;
1133     }
1134     if (!count) return TRUE;
1135
1136       /* Now build the list of all windows */
1137
1138     if (!(list = (HWND *)malloc( sizeof(HWND) * count ))) return FALSE;
1139     for (hwnd = GetTopWindow(hwndDesktop), pWnd = list; hwnd != 0; hwnd = wndPtr->hwndNext)
1140     {
1141         wndPtr = WIN_FindWndPtr( hwnd );
1142         if (wndPtr->hmemTaskQ == hQueue) *pWnd++ = hwnd;
1143     }
1144
1145       /* Now call the callback function for every window */
1146
1147     for (pWnd = list; count > 0; count--, pWnd++)
1148     {
1149           /* Make sure that window still exists */
1150         if (!IsWindow(*pWnd)) continue;
1151         if (!CallEnumTaskWndProc( lpEnumFunc, *pWnd, lParam )) break;
1152     }
1153     free( list );
1154     return TRUE;
1155 }
1156
1157
1158 /*******************************************************************
1159  *    WIN_EnumChildWin
1160  *
1161  *   o hwnd is the first child to use, loop until all next windows
1162  *     are processed
1163  *
1164  *   o call wdnenumprc
1165  *
1166  *   o call ourselves with the next child window
1167  *
1168  */
1169 static BOOL WIN_EnumChildWin(HWND hwnd, FARPROC wndenumprc, LPARAM lParam)
1170 {
1171     WND *wndPtr;
1172
1173     while (hwnd)
1174     {
1175         if (!(wndPtr=WIN_FindWndPtr(hwnd))) return 0;
1176         if (!CallEnumWindowsProc( wndenumprc, hwnd, lParam )) return 0;
1177         if (!WIN_EnumChildWin(wndPtr->hwndChild, wndenumprc, lParam)) return 0;
1178         hwnd=wndPtr->hwndNext;
1179     }
1180     return 1;
1181 }
1182
1183 /*******************************************************************
1184  *    EnumChildWindows        (USER.55)
1185  *
1186  *   o gets the first child of hwnd
1187  *
1188  *   o calls WIN_EnumChildWin to do a recursive decent of child windows
1189  */
1190 BOOL EnumChildWindows(HWND hwnd, FARPROC wndenumprc, LPARAM lParam)
1191 {
1192     WND *wndPtr;
1193
1194     dprintf_enum(stddeb,"EnumChildWindows\n");
1195
1196     if (hwnd == 0) return 0;
1197     if (!(wndPtr = WIN_FindWndPtr(hwnd))) return 0;
1198     hwnd = wndPtr->hwndChild;
1199     return WIN_EnumChildWin(hwnd, wndenumprc, lParam);
1200 }
1201
1202
1203 /*******************************************************************
1204  *                      AnyPopup                [USER.52]
1205  */
1206 BOOL AnyPopup()
1207 {
1208         dprintf_win(stdnimp,"EMPTY STUB !! AnyPopup !\n");
1209         return FALSE;
1210 }
1211
1212 /*******************************************************************
1213  *                      FlashWindow             [USER.105]
1214  */
1215 BOOL FlashWindow(HWND hWnd, BOOL bInvert)
1216 {
1217         dprintf_win(stdnimp,"EMPTY STUB !! FlashWindow !\n");
1218         return FALSE;
1219 }
1220
1221
1222 /*******************************************************************
1223  *                      SetSysModalWindow               [USER.188]
1224  */
1225 HWND SetSysModalWindow(HWND hWnd)
1226 {
1227         HWND hWndOldModal = hWndSysModal;
1228         hWndSysModal = hWnd;
1229         dprintf_win(stdnimp,"EMPTY STUB !! SetSysModalWindow("NPFMT") !\n", hWnd);
1230         return hWndOldModal;
1231 }
1232
1233
1234 /*******************************************************************
1235  *                      GetSysModalWindow               [USER.189]
1236  */
1237 HWND GetSysModalWindow(void)
1238 {
1239         return hWndSysModal;
1240 }