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