git.oblomov.eu Git - wine/blob - windows/win.c

   1 /*
   2  * Window related functions
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include "windef.h"
  10 #include "wine/winbase16.h"
  11 #include "wine/winuser16.h"
  12 #include "wine/unicode.h"
  13 #include "options.h"
  14 #include "win.h"
  15 #include "heap.h"
  16 #include "user.h"
  17 #include "dce.h"
  18 #include "controls.h"
  19 #include "cursoricon.h"
  20 #include "hook.h"
  21 #include "message.h"
  22 #include "queue.h"
  23 #include "winpos.h"
  24 #include "winerror.h"
  25 #include "stackframe.h"
  26 #include "debugtools.h"
  27
  28 DEFAULT_DEBUG_CHANNEL(win);
  29 DECLARE_DEBUG_CHANNEL(msg);
  30
  31 /**********************************************************************/
  32
  33 WND_DRIVER *WND_Driver = NULL;
  34
  35 /* Desktop window */
  36 static WND *pWndDesktop = NULL;
  37
  38 static HWND hwndSysModal = 0;
  39
  40 static WORD wDragWidth = 4;
  41 static WORD wDragHeight= 3;
  42
  43 /* thread safeness */
  44 static SYSLEVEL WIN_SysLevel = { CRITICAL_SECTION_INIT, 2 };
  45
  46 /***********************************************************************
  47  *           WIN_LockWnds
  48  *
  49  *   Locks access to all WND structures for thread safeness
  50  */
  51 void WIN_LockWnds( void )
  52 {
  53     _EnterSysLevel( &WIN_SysLevel );
  54 }
  55
  56 /***********************************************************************
  57  *           WIN_UnlockWnds
  58  *
  59  *  Unlocks access to all WND structures
  60  */
  61 void WIN_UnlockWnds( void )
  62 {
  63     _LeaveSysLevel( &WIN_SysLevel );
  64 }
  65
  66 /***********************************************************************
  67  *           WIN_SuspendWndsLock
  68  *
  69  *   Suspend the lock on WND structures.
  70  *   Returns the number of locks suspended
  71  */
  72 int WIN_SuspendWndsLock( void )
  73 {
  74     int isuspendedLocks = _ConfirmSysLevel( &WIN_SysLevel );
  75     int count = isuspendedLocks;
  76
  77     while ( count-- > 0 )
  78         _LeaveSysLevel( &WIN_SysLevel );
  79
  80     return isuspendedLocks;
  81 }
  82
  83 /***********************************************************************
  84  *           WIN_RestoreWndsLock
  85  *
  86  *  Restore the suspended locks on WND structures
  87  */
  88 void WIN_RestoreWndsLock( int ipreviousLocks )
  89 {
  90     while ( ipreviousLocks-- > 0 )
  91         _EnterSysLevel( &WIN_SysLevel );
  92 }
  93
  94 /***********************************************************************
  95  *           WIN_FindWndPtr
  96  *
  97  * Return a pointer to the WND structure corresponding to a HWND.
  98  */
  99 WND * WIN_FindWndPtr( HWND hwnd )
 100 {
 101     WND * ptr;
 102
 103     if (!hwnd || HIWORD(hwnd)) goto error2;
 104     ptr = (WND *) USER_HEAP_LIN_ADDR( hwnd );
 105     /* Lock all WND structures for thread safeness*/
 106     WIN_LockWnds();
 107     /*and increment destruction monitoring*/
 108      ptr->irefCount++;
 109
 110     if (ptr->dwMagic != WND_MAGIC) goto error;
 111     if (ptr->hwndSelf != hwnd)
 112     {
 113         ERR("Can't happen: hwnd %04x self pointer is %04x\n",hwnd, ptr->hwndSelf );
 114         goto error;
 115     }
 116     /* returns a locked pointer */
 117     return ptr;
 118  error:
 119     /* Unlock all WND structures for thread safeness*/
 120     WIN_UnlockWnds();
 121     /* and decrement destruction monitoring value */
 122      ptr->irefCount--;
 123
 124 error2:
 125     if ( hwnd!=0 )
 126       SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 127     return NULL;
 128 }
 129
 130 /***********************************************************************
 131  *           WIN_LockWndPtr
 132  *
 133  * Use in case the wnd ptr is not initialized with WIN_FindWndPtr
 134  * but by initWndPtr;
 135  * Returns the locked initialisation pointer
 136  */
 137 WND *WIN_LockWndPtr(WND *initWndPtr)
 138 {
 139     if(!initWndPtr) return 0;
 140
 141     /* Lock all WND structures for thread safeness*/
 142     WIN_LockWnds();
 143     /*and increment destruction monitoring*/
 144     initWndPtr->irefCount++;
 145
 146     return initWndPtr;
 147
 148 }
 149
 150 /***********************************************************************
 151  *           WIN_ReleaseWndPtr
 152  *
 153  * Release the pointer to the WND structure.
 154  */
 155 void WIN_ReleaseWndPtr(WND *wndPtr)
 156 {
 157     if(!wndPtr) return;
 158
 159     /*Decrement destruction monitoring value*/
 160      wndPtr->irefCount--;
 161      /* Check if it's time to release the memory*/
 162      if(wndPtr->irefCount == 0 && !wndPtr->dwMagic)
 163      {
 164          /* Release memory */
 165          USER_HEAP_FREE( wndPtr->hwndSelf);
 166          wndPtr->hwndSelf = 0;
 167      }
 168      else if(wndPtr->irefCount < 0)
 169      {
 170          /* This else if is useful to monitor the WIN_ReleaseWndPtr function */
 171          ERR("forgot a Lock on %p somewhere\n",wndPtr);
 172      }
 173      /*unlock all WND structures for thread safeness*/
 174      WIN_UnlockWnds();
 175 }
 176
 177 /***********************************************************************
 178  *           WIN_UpdateWndPtr
 179  *
 180  * Updates the value of oldPtr to newPtr.
 181  */
 182 void WIN_UpdateWndPtr(WND **oldPtr, WND *newPtr)
 183 {
 184     WND *tmpWnd = NULL;
 185
 186     tmpWnd = WIN_LockWndPtr(newPtr);
 187     WIN_ReleaseWndPtr(*oldPtr);
 188     *oldPtr = tmpWnd;
 189
 190 }
 191
 192 /***********************************************************************
 193  *           WIN_DumpWindow
 194  *
 195  * Dump the content of a window structure to stderr.
 196  */
 197 void WIN_DumpWindow( HWND hwnd )
 198 {
 199     WND *ptr;
 200     char className[80];
 201     int i;
 202
 203     if (!(ptr = WIN_FindWndPtr( hwnd )))
 204     {
 205         WARN("%04x is not a window handle\n", hwnd );
 206         return;
 207     }
 208
 209     if (!GetClassNameA( hwnd, className, sizeof(className ) ))
 210         strcpy( className, "#NULL#" );
 211
 212     TRACE("Window %04x (%p):\n", hwnd, ptr );
 213     DPRINTF( "next=%p  child=%p  parent=%p  owner=%p  class=%p '%s'\n"
 214              "inst=%04x  taskQ=%04x  updRgn=%04x  active=%04x dce=%p  idmenu=%08x\n"
 215              "style=%08lx  exstyle=%08lx  wndproc=%08x  text='%s'\n"
 216              "client=%d,%d-%d,%d  window=%d,%d-%d,%d"
 217              "sysmenu=%04x  flags=%04x  props=%p  vscroll=%p  hscroll=%p\n",
 218              ptr->next, ptr->child, ptr->parent, ptr->owner,
 219              ptr->class, className, ptr->hInstance, ptr->hmemTaskQ,
 220              ptr->hrgnUpdate, ptr->hwndLastActive, ptr->dce, ptr->wIDmenu,
 221              ptr->dwStyle, ptr->dwExStyle, (UINT)ptr->winproc,
 222              ptr->text ? debugstr_w(ptr->text) : "",
 223              ptr->rectClient.left, ptr->rectClient.top, ptr->rectClient.right,
 224              ptr->rectClient.bottom, ptr->rectWindow.left, ptr->rectWindow.top,
 225              ptr->rectWindow.right, ptr->rectWindow.bottom, ptr->hSysMenu,
 226              ptr->flags, ptr->pProp, ptr->pVScroll, ptr->pHScroll );
 227
 228     if (ptr->cbWndExtra)
 229     {
 230         DPRINTF( "extra bytes:" );
 231         for (i = 0; i < ptr->cbWndExtra; i++)
 232             DPRINTF( " %02x", *((BYTE*)ptr->wExtra+i) );
 233         DPRINTF( "\n" );
 234     }
 235     DPRINTF( "\n" );
 236     WIN_ReleaseWndPtr(ptr);
 237 }
 238
 239
 240 /***********************************************************************
 241  *           WIN_WalkWindows
 242  *
 243  * Walk the windows tree and print each window on stderr.
 244  */
 245 void WIN_WalkWindows( HWND hwnd, int indent )
 246 {
 247     WND *ptr;
 248     char className[80];
 249
 250     ptr = hwnd ? WIN_FindWndPtr( hwnd ) : WIN_GetDesktop();
 251
 252     if (!ptr)
 253     {
 254         WARN("Invalid window handle %04x\n", hwnd );
 255         return;
 256     }
 257
 258     if (!indent)  /* first time around */
 259        DPRINTF( "%-16.16s %-8.8s %-6.6s %-17.17s %-8.8s %s\n",
 260                  "hwnd", " wndPtr", "queue", "Class Name", " Style", " WndProc"
 261                  " Text");
 262
 263     while (ptr)
 264     {
 265         DPRINTF( "%*s%04x%*s", indent, "", ptr->hwndSelf, 13-indent,"");
 266
 267         GetClassNameA( ptr->hwndSelf, className, sizeof(className) );
 268         DPRINTF( "%08lx %-6.4x %-17.17s %08x %08x %.14s\n",
 269                  (DWORD)ptr, ptr->hmemTaskQ, className,
 270                  (UINT)ptr->dwStyle, (UINT)ptr->winproc,
 271                  ptr->text ? debugstr_w(ptr->text) : "<null>");
 272
 273         if (ptr->child) WIN_WalkWindows( ptr->child->hwndSelf, indent+1 );
 274         WIN_UpdateWndPtr(&ptr,ptr->next);
 275     }
 276 }
 277
 278 /***********************************************************************
 279  *           WIN_UnlinkWindow
 280  *
 281  * Remove a window from the siblings linked list.
 282  */
 283 BOOL WIN_UnlinkWindow( HWND hwnd )
 284 {
 285     WND *wndPtr, **ppWnd;
 286     BOOL ret = FALSE;
 287
 288     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
 289     else if(!wndPtr->parent)
 290     {
 291         WIN_ReleaseWndPtr(wndPtr);
 292         return FALSE;
 293     }
 294
 295     ppWnd = &wndPtr->parent->child;
 296     while (*ppWnd && *ppWnd != wndPtr) ppWnd = &(*ppWnd)->next;
 297     if (*ppWnd)
 298     {
 299         *ppWnd = wndPtr->next;
 300         ret = TRUE;
 301     }
 302     WIN_ReleaseWndPtr(wndPtr);
 303     return ret;
 304 }
 305
 306
 307 /***********************************************************************
 308  *           WIN_LinkWindow
 309  *
 310  * Insert a window into the siblings linked list.
 311  * The window is inserted after the specified window, which can also
 312  * be specified as HWND_TOP or HWND_BOTTOM.
 313  */
 314 BOOL WIN_LinkWindow( HWND hwnd, HWND hwndInsertAfter )
 315 {
 316     WND *wndPtr, **ppWnd;
 317
 318     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
 319     else if(!wndPtr->parent)
 320     {
 321         WIN_ReleaseWndPtr(wndPtr);
 322         return FALSE;
 323     }
 324     if ((hwndInsertAfter == HWND_TOP) || (hwndInsertAfter == HWND_BOTTOM))
 325     {
 326         ppWnd = &wndPtr->parent->child;  /* Point to first sibling hwnd */
 327         if (hwndInsertAfter == HWND_BOTTOM)  /* Find last sibling hwnd */
 328             while (*ppWnd) ppWnd = &(*ppWnd)->next;
 329     }
 330     else  /* Normal case */
 331     {
 332         WND * afterPtr = WIN_FindWndPtr( hwndInsertAfter );
 333             if (!afterPtr)
 334             {
 335                 WIN_ReleaseWndPtr(wndPtr);
 336                 return FALSE;
 337             }
 338         ppWnd = &afterPtr->next;
 339         WIN_ReleaseWndPtr(afterPtr);
 340     }
 341     wndPtr->next = *ppWnd;
 342     *ppWnd = wndPtr;
 343     WIN_ReleaseWndPtr(wndPtr);
 344     return TRUE;
 345 }
 346
 347
 348 /***********************************************************************
 349  *           WIN_FindWinToRepaint
 350  *
 351  * Find a window that needs repaint.
 352  */
 353 HWND WIN_FindWinToRepaint( HWND hwnd, HQUEUE16 hQueue )
 354 {
 355     HWND hwndRet;
 356     WND *pWnd;
 357
 358     /* Note: the desktop window never gets WM_PAINT messages
 359      * The real reason why is because Windows DesktopWndProc
 360      * does ValidateRgn inside WM_ERASEBKGND handler.
 361      */
 362
 363     pWnd = hwnd ? WIN_FindWndPtr(hwnd) : WIN_LockWndPtr(pWndDesktop->child);
 364
 365     for ( ; pWnd ; WIN_UpdateWndPtr(&pWnd,pWnd->next))
 366     {
 367         if (!(pWnd->dwStyle & WS_VISIBLE))
 368         {
 369             TRACE("skipping window %04x\n",
 370                          pWnd->hwndSelf );
 371         }
 372         else if ((pWnd->hmemTaskQ == hQueue) &&
 373                  (pWnd->hrgnUpdate || (pWnd->flags & WIN_INTERNAL_PAINT)))
 374             break;
 375
 376         else if (pWnd->child )
 377             if ((hwndRet = WIN_FindWinToRepaint( pWnd->child->hwndSelf, hQueue )) )
 378             {
 379                 WIN_ReleaseWndPtr(pWnd);
 380                 return hwndRet;
 381     }
 382
 383     }
 384
 385     if(!pWnd)
 386     {
 387         return 0;
 388     }
 389
 390     hwndRet = pWnd->hwndSelf;
 391
 392     /* look among siblings if we got a transparent window */
 393     while (pWnd && ((pWnd->dwExStyle & WS_EX_TRANSPARENT) ||
 394                     !(pWnd->hrgnUpdate || (pWnd->flags & WIN_INTERNAL_PAINT))))
 395     {
 396         WIN_UpdateWndPtr(&pWnd,pWnd->next);
 397     }
 398     if (pWnd)
 399     {
 400         hwndRet = pWnd->hwndSelf;
 401     WIN_ReleaseWndPtr(pWnd);
 402     }
 403     TRACE("found %04x\n",hwndRet);
 404     return hwndRet;
 405 }
 406
 407
 408 /***********************************************************************
 409  *           WIN_DestroyWindow
 410  *
 411  * Destroy storage associated to a window. "Internals" p.358
 412  * returns a locked wndPtr->next
 413  */
 414 static WND* WIN_DestroyWindow( WND* wndPtr )
 415 {
 416     HWND hwnd = wndPtr->hwndSelf;
 417     WND *pWnd;
 418
 419     TRACE("%04x\n", wndPtr->hwndSelf );
 420
 421     /* free child windows */
 422     WIN_LockWndPtr(wndPtr->child);
 423     while ((pWnd = wndPtr->child))
 424     {
 425         wndPtr->child = WIN_DestroyWindow( pWnd );
 426         WIN_ReleaseWndPtr(pWnd);
 427     }
 428
 429     /*
 430      * Clear the update region to make sure no WM_PAINT messages will be
 431      * generated for this window while processing the WM_NCDESTROY.
 432      */
 433     if ((wndPtr->hrgnUpdate) || (wndPtr->flags & WIN_INTERNAL_PAINT))
 434     {
 435         if (wndPtr->hrgnUpdate > 1)
 436           DeleteObject( wndPtr->hrgnUpdate );
 437
 438         QUEUE_DecPaintCount( wndPtr->hmemTaskQ );
 439
 440         wndPtr->hrgnUpdate = 0;
 441     }
 442
 443     /*
 444      * Send the WM_NCDESTROY to the window being destroyed.
 445      */
 446     SendMessageA( wndPtr->hwndSelf, WM_NCDESTROY, 0, 0);
 447
 448     /* FIXME: do we need to fake QS_MOUSEMOVE wakebit? */
 449
 450     WINPOS_CheckInternalPos( wndPtr );
 451     if( hwnd == GetCapture()) ReleaseCapture();
 452
 453     /* free resources associated with the window */
 454
 455     TIMER_RemoveWindowTimers( wndPtr->hwndSelf );
 456     PROPERTY_RemoveWindowProps( wndPtr );
 457
 458     wndPtr->dwMagic = 0;  /* Mark it as invalid */
 459
 460     /* toss stale messages from the queue */
 461
 462     if( wndPtr->hmemTaskQ )
 463     {
 464         BOOL          bPostQuit = FALSE;
 465         WPARAM      wQuitParam = 0;
 466         MESSAGEQUEUE* msgQ = (MESSAGEQUEUE*) QUEUE_Lock(wndPtr->hmemTaskQ);
 467         QMSG *qmsg;
 468
 469         while( (qmsg = QUEUE_FindMsg(msgQ, hwnd, 0, 0)) != 0 )
 470         {
 471             if( qmsg->msg.message == WM_QUIT )
 472             {
 473                 bPostQuit = TRUE;
 474                 wQuitParam = qmsg->msg.wParam;
 475             }
 476             QUEUE_RemoveMsg(msgQ, qmsg);
 477         }
 478
 479         QUEUE_Unlock(msgQ);
 480
 481         /* repost WM_QUIT to make sure this app exits its message loop */
 482         if( bPostQuit ) PostQuitMessage(wQuitParam);
 483         wndPtr->hmemTaskQ = 0;
 484     }
 485
 486     if (!(wndPtr->dwStyle & WS_CHILD))
 487        if (wndPtr->wIDmenu)
 488        {
 489            DestroyMenu( wndPtr->wIDmenu );
 490            wndPtr->wIDmenu = 0;
 491        }
 492     if (wndPtr->hSysMenu)
 493     {
 494         DestroyMenu( wndPtr->hSysMenu );
 495         wndPtr->hSysMenu = 0;
 496     }
 497     wndPtr->pDriver->pDestroyWindow( wndPtr );
 498     DCE_FreeWindowDCE( wndPtr );    /* Always do this to catch orphaned DCs */
 499     WINPROC_FreeProc( wndPtr->winproc, WIN_PROC_WINDOW );
 500     CLASS_RemoveWindow( wndPtr->class );
 501     wndPtr->class = NULL;
 502
 503     WIN_UpdateWndPtr(&pWnd,wndPtr->next);
 504
 505     wndPtr->pDriver->pFinalize(wndPtr);
 506
 507     return pWnd;
 508 }
 509
 510 /***********************************************************************
 511  *           WIN_ResetQueueWindows
 512  *
 513  * Reset the queue of all the children of a given window.
 514  * Return TRUE if something was done.
 515  */
 516 BOOL WIN_ResetQueueWindows( WND* wnd, HQUEUE16 hQueue, HQUEUE16 hNew )
 517 {
 518     BOOL ret = FALSE;
 519
 520     if (hNew)  /* Set a new queue */
 521     {
 522         for (wnd = WIN_LockWndPtr(wnd->child); (wnd);WIN_UpdateWndPtr(&wnd,wnd->next))
 523         {
 524             if (wnd->hmemTaskQ == hQueue)
 525             {
 526                 wnd->hmemTaskQ = hNew;
 527                 ret = TRUE;
 528             }
 529             if (wnd->child)
 530             {
 531                 ret |= WIN_ResetQueueWindows( wnd, hQueue, hNew );
 532         }
 533     }
 534     }
 535     else  /* Queue is being destroyed */
 536     {
 537         while (wnd->child)
 538         {
 539             WND *tmp = WIN_LockWndPtr(wnd->child);
 540             WND *tmp2;
 541             ret = FALSE;
 542             while (tmp)
 543             {
 544                 if (tmp->hmemTaskQ == hQueue)
 545                 {
 546                     DestroyWindow( tmp->hwndSelf );
 547                     ret = TRUE;
 548                     break;
 549                 }
 550                 tmp2 = WIN_LockWndPtr(tmp->child);
 551                 if (tmp2 && WIN_ResetQueueWindows(tmp2,hQueue,0))
 552                     ret = TRUE;
 553                 else
 554                 {
 555                     WIN_UpdateWndPtr(&tmp,tmp->next);
 556                 }
 557                 WIN_ReleaseWndPtr(tmp2);
 558             }
 559             WIN_ReleaseWndPtr(tmp);
 560             if (!ret) break;
 561         }
 562     }
 563     return ret;
 564 }
 565
 566 /***********************************************************************
 567  *           WIN_CreateDesktopWindow
 568  *
 569  * Create the desktop window.
 570  */
 571 BOOL WIN_CreateDesktopWindow(void)
 572 {
 573     struct tagCLASS *class;
 574     HWND hwndDesktop;
 575     INT wndExtra;
 576     DWORD clsStyle;
 577     WNDPROC winproc;
 578     DCE *dce;
 579
 580     TRACE("Creating desktop window\n");
 581
 582
 583     if (!WINPOS_CreateInternalPosAtom() ||
 584         !(class = CLASS_AddWindow( (ATOM)LOWORD(DESKTOP_CLASS_ATOM), 0, WIN_PROC_32W,
 585                                    &wndExtra, &winproc, &clsStyle, &dce )))
 586         return FALSE;
 587
 588     hwndDesktop = USER_HEAP_ALLOC( sizeof(WND) + wndExtra );
 589     if (!hwndDesktop) return FALSE;
 590     pWndDesktop = (WND *) USER_HEAP_LIN_ADDR( hwndDesktop );
 591
 592     pWndDesktop->pDriver = WND_Driver;
 593     pWndDesktop->pDriver->pInitialize(pWndDesktop);
 594
 595     pWndDesktop->next              = NULL;
 596     pWndDesktop->child             = NULL;
 597     pWndDesktop->parent            = NULL;
 598     pWndDesktop->owner             = NULL;
 599     pWndDesktop->class             = class;
 600     pWndDesktop->dwMagic           = WND_MAGIC;
 601     pWndDesktop->hwndSelf          = hwndDesktop;
 602     pWndDesktop->hInstance         = 0;
 603     pWndDesktop->rectWindow.left   = 0;
 604     pWndDesktop->rectWindow.top    = 0;
 605     pWndDesktop->rectWindow.right  = GetSystemMetrics(SM_CXSCREEN);
 606     pWndDesktop->rectWindow.bottom = GetSystemMetrics(SM_CYSCREEN);
 607     pWndDesktop->rectClient        = pWndDesktop->rectWindow;
 608     pWndDesktop->text              = NULL;
 609     pWndDesktop->hmemTaskQ         = GetFastQueue16();
 610     pWndDesktop->hrgnUpdate        = 0;
 611     pWndDesktop->hwndLastActive    = hwndDesktop;
 612     pWndDesktop->dwStyle           = WS_VISIBLE | WS_CLIPCHILDREN |
 613                                      WS_CLIPSIBLINGS;
 614     pWndDesktop->dwExStyle         = 0;
 615     pWndDesktop->clsStyle          = clsStyle;
 616     pWndDesktop->dce               = NULL;
 617     pWndDesktop->pVScroll          = NULL;
 618     pWndDesktop->pHScroll          = NULL;
 619     pWndDesktop->pProp             = NULL;
 620     pWndDesktop->wIDmenu           = 0;
 621     pWndDesktop->helpContext       = 0;
 622     pWndDesktop->flags             = 0;
 623     pWndDesktop->hSysMenu          = 0;
 624     pWndDesktop->userdata          = 0;
 625     pWndDesktop->winproc           = winproc;
 626     pWndDesktop->cbWndExtra        = wndExtra;
 627     pWndDesktop->irefCount         = 0;
 628
 629     if(!pWndDesktop->pDriver->pCreateDesktopWindow(pWndDesktop)) return FALSE;
 630
 631     SendMessageW( hwndDesktop, WM_NCCREATE, 0, 0 );
 632     pWndDesktop->flags |= WIN_NEEDS_ERASEBKGND;
 633     return TRUE;
 634 }
 635
 636
 637 /***********************************************************************
 638  *           WIN_FixCoordinates
 639  *
 640  * Fix the coordinates - Helper for WIN_CreateWindowEx.
 641  * returns default show mode in sw.
 642  * Note: the feature presented as undocumented *is* in the MSDN since 1993.
 643  */
 644 static void WIN_FixCoordinates( CREATESTRUCTA *cs, INT *sw)
 645 {
 646     if (cs->x == CW_USEDEFAULT || cs->x == CW_USEDEFAULT16 ||
 647         cs->cx == CW_USEDEFAULT || cs->cx == CW_USEDEFAULT16)
 648     {
 649         if (cs->style & (WS_CHILD | WS_POPUP))
 650         {
 651             if (cs->x == CW_USEDEFAULT || cs->x == CW_USEDEFAULT16) cs->x = cs->y = 0;
 652             if (cs->cx == CW_USEDEFAULT || cs->cx == CW_USEDEFAULT16) cs->cx = cs->cy = 0;
 653         }
 654         else  /* overlapped window */
 655         {
 656             STARTUPINFOA info;
 657
 658             GetStartupInfoA( &info );
 659
 660             if (cs->x == CW_USEDEFAULT || cs->x == CW_USEDEFAULT16)
 661             {
 662                 /* Never believe Microsoft's documentation... CreateWindowEx doc says
 663                  * that if an overlapped window is created with WS_VISIBLE style bit
 664                  * set and the x parameter is set to CW_USEDEFAULT, the system ignores
 665                  * the y parameter. However, disassembling NT implementation (WIN32K.SYS)
 666                  * reveals that
 667                  *
 668                  * 1) not only it checks for CW_USEDEFAULT but also for CW_USEDEFAULT16
 669                  * 2) it does not ignore the y parameter as the docs claim; instead, it
 670                  *    uses it as second parameter to ShowWindow() unless y is either
 671                  *    CW_USEDEFAULT or CW_USEDEFAULT16.
 672                  *
 673                  * The fact that we didn't do 2) caused bogus windows pop up when wine
 674                  * was running apps that were using this obscure feature. Example -
 675                  * calc.exe that comes with Win98 (only Win98, it's different from
 676                  * the one that comes with Win95 and NT)
 677                  */
 678                 if (cs->y != CW_USEDEFAULT && cs->y != CW_USEDEFAULT16) *sw = cs->y;
 679                 cs->x = (info.dwFlags & STARTF_USEPOSITION) ? info.dwX : 0;
 680                 cs->y = (info.dwFlags & STARTF_USEPOSITION) ? info.dwY : 0;
 681             }
 682
 683             if (cs->cx == CW_USEDEFAULT || cs->cx == CW_USEDEFAULT16)
 684             {
 685                 if (info.dwFlags & STARTF_USESIZE)
 686                 {
 687                     cs->cx = info.dwXSize;
 688                     cs->cy = info.dwYSize;
 689                 }
 690                 else  /* if no other hint from the app, pick 3/4 of the screen real estate */
 691                 {
 692                     RECT r;
 693                     SystemParametersInfoA( SPI_GETWORKAREA, 0, &r, 0);
 694                     cs->cx = (((r.right - r.left) * 3) / 4) - cs->x;
 695                     cs->cy = (((r.bottom - r.top) * 3) / 4) - cs->y;
 696                 }
 697             }
 698         }
 699     }
 700 }
 701
 702 /***********************************************************************
 703  *           WIN_CreateWindowEx
 704  *
 705  * Implementation of CreateWindowEx().
 706  */
 707 static HWND WIN_CreateWindowEx( CREATESTRUCTA *cs, ATOM classAtom,
 708                                 WINDOWPROCTYPE type )
 709 {
 710     INT sw = SW_SHOW;
 711     struct tagCLASS *classPtr;
 712     WND *wndPtr;
 713     HWND retvalue;
 714     HWND16 hwnd, hwndLinkAfter;
 715     POINT maxSize, maxPos, minTrack, maxTrack;
 716     INT wndExtra;
 717     DWORD clsStyle;
 718     WNDPROC winproc;
 719     DCE *dce;
 720     LRESULT CALLBACK (*localSend32)(HWND, UINT, WPARAM, LPARAM);
 721
 722     TRACE("%s %s %08lx %08lx %d,%d %dx%d %04x %04x %08x %p\n",
 723           (type == WIN_PROC_32W) ? debugres_w((LPWSTR)cs->lpszName) : debugres_a(cs->lpszName),
 724           (type == WIN_PROC_32W) ? debugres_w((LPWSTR)cs->lpszClass) : debugres_a(cs->lpszClass),
 725           cs->dwExStyle, cs->style, cs->x, cs->y, cs->cx, cs->cy,
 726           cs->hwndParent, cs->hMenu, cs->hInstance, cs->lpCreateParams );
 727
 728     TRACE("winproc type is %d (%s)\n", type, (type == WIN_PROC_16) ? "WIN_PROC_16" :
 729             ((type == WIN_PROC_32A) ? "WIN_PROC_32A" : "WIN_PROC_32W") );
 730
 731     /* Find the parent window */
 732
 733     if (cs->hwndParent)
 734     {
 735         /* Make sure parent is valid */
 736         if (!IsWindow( cs->hwndParent ))
 737         {
 738             WARN("Bad parent %04x\n", cs->hwndParent );
 739             return 0;
 740         }
 741     } else if ((cs->style & WS_CHILD) && !(cs->style & WS_POPUP)) {
 742         WARN("No parent for child window\n" );
 743         return 0;  /* WS_CHILD needs a parent, but WS_POPUP doesn't */
 744     }
 745
 746     /* Find the window class */
 747     if (!(classPtr = CLASS_AddWindow( classAtom, cs->hInstance, type,
 748                                       &wndExtra, &winproc, &clsStyle, &dce )))
 749     {
 750         WARN("Bad class '%s'\n", cs->lpszClass );
 751         return 0;
 752     }
 753
 754     WIN_FixCoordinates(cs, &sw); /* fix default coordinates */
 755
 756     /* Create the window structure */
 757
 758     if (!(hwnd = USER_HEAP_ALLOC( sizeof(*wndPtr) + wndExtra - sizeof(wndPtr->wExtra) )))
 759     {
 760         TRACE("out of memory\n" );
 761         return 0;
 762     }
 763
 764     /* Fill the window structure */
 765
 766     wndPtr = WIN_LockWndPtr((WND *) USER_HEAP_LIN_ADDR( hwnd ));
 767     wndPtr->next  = NULL;
 768     wndPtr->child = NULL;
 769
 770     if ((cs->style & WS_CHILD) && cs->hwndParent)
 771     {
 772         wndPtr->parent = WIN_FindWndPtr( cs->hwndParent );
 773         wndPtr->owner  = NULL;
 774         WIN_ReleaseWndPtr(wndPtr->parent);
 775     }
 776     else
 777     {
 778         wndPtr->parent = pWndDesktop;
 779         if (!cs->hwndParent || (cs->hwndParent == pWndDesktop->hwndSelf))
 780             wndPtr->owner = NULL;
 781         else
 782         {
 783             WND *tmpWnd = WIN_FindWndPtr(cs->hwndParent);
 784             wndPtr->owner = WIN_GetTopParentPtr(tmpWnd);
 785             WIN_ReleaseWndPtr(wndPtr->owner);
 786             WIN_ReleaseWndPtr(tmpWnd);
 787         }
 788     }
 789
 790
 791     wndPtr->pDriver = wndPtr->parent->pDriver;
 792     wndPtr->pDriver->pInitialize(wndPtr);
 793
 794     wndPtr->class          = classPtr;
 795     wndPtr->winproc        = winproc;
 796     wndPtr->dwMagic        = WND_MAGIC;
 797     wndPtr->hwndSelf       = hwnd;
 798     wndPtr->hInstance      = cs->hInstance;
 799     wndPtr->text           = NULL;
 800     wndPtr->hmemTaskQ      = GetFastQueue16();
 801     wndPtr->hrgnUpdate     = 0;
 802     wndPtr->hrgnWnd        = 0;
 803     wndPtr->hwndLastActive = hwnd;
 804     wndPtr->dwStyle        = cs->style & ~WS_VISIBLE;
 805     wndPtr->dwExStyle      = cs->dwExStyle;
 806     wndPtr->clsStyle       = clsStyle;
 807     wndPtr->wIDmenu        = 0;
 808     wndPtr->helpContext    = 0;
 809     wndPtr->flags          = (type == WIN_PROC_16) ? 0 : WIN_ISWIN32;
 810     wndPtr->pVScroll       = NULL;
 811     wndPtr->pHScroll       = NULL;
 812     wndPtr->pProp          = NULL;
 813     wndPtr->userdata       = 0;
 814     wndPtr->hSysMenu       = (wndPtr->dwStyle & WS_SYSMENU)
 815                              ? MENU_GetSysMenu( hwnd, 0 ) : 0;
 816     wndPtr->cbWndExtra     = wndExtra;
 817     wndPtr->irefCount      = 1;
 818
 819     if (wndExtra) memset( wndPtr->wExtra, 0, wndExtra);
 820
 821     /* Call the WH_CBT hook */
 822
 823     hwndLinkAfter = ((cs->style & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD)
 824  ? HWND_BOTTOM : HWND_TOP;
 825
 826     if (HOOK_IsHooked( WH_CBT ))
 827     {
 828         CBT_CREATEWNDA cbtc;
 829         LRESULT ret;
 830
 831         cbtc.lpcs = cs;
 832         cbtc.hwndInsertAfter = hwndLinkAfter;
 833         ret = (type == WIN_PROC_32W) ? HOOK_CallHooksW(WH_CBT, HCBT_CREATEWND, hwnd, (LPARAM)&cbtc)
 834                       : HOOK_CallHooksA(WH_CBT, HCBT_CREATEWND, hwnd, (LPARAM)&cbtc);
 835         if (ret)
 836         {
 837             TRACE("CBT-hook returned 0\n");
 838             wndPtr->pDriver->pFinalize(wndPtr);
 839             USER_HEAP_FREE( hwnd );
 840             CLASS_RemoveWindow( classPtr );
 841             retvalue =  0;
 842             goto end;
 843         }
 844     }
 845
 846     /* Correct the window style */
 847
 848     if (!(cs->style & WS_CHILD))
 849     {
 850         wndPtr->dwStyle |= WS_CLIPSIBLINGS;
 851         if (!(cs->style & WS_POPUP))
 852         {
 853             wndPtr->dwStyle |= WS_CAPTION;
 854             wndPtr->flags |= WIN_NEED_SIZE;
 855         }
 856     }
 857
 858     /* Get class or window DC if needed */
 859
 860     if (clsStyle & CS_OWNDC) wndPtr->dce = DCE_AllocDCE(hwnd,DCE_WINDOW_DC);
 861     else if (clsStyle & CS_CLASSDC) wndPtr->dce = dce;
 862     else wndPtr->dce = NULL;
 863
 864     /* Initialize the dimensions before sending WM_GETMINMAXINFO */
 865
 866     wndPtr->rectWindow.left   = cs->x;
 867     wndPtr->rectWindow.top    = cs->y;
 868     wndPtr->rectWindow.right  = cs->x + cs->cx;
 869     wndPtr->rectWindow.bottom = cs->y + cs->cy;
 870     wndPtr->rectClient        = wndPtr->rectWindow;
 871
 872     /* Send the WM_GETMINMAXINFO message and fix the size if needed */
 873
 874     if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD)))
 875     {
 876         WINPOS_GetMinMaxInfo( wndPtr, &maxSize, &maxPos, &minTrack, &maxTrack);
 877         if (maxSize.x < cs->cx) cs->cx = maxSize.x;
 878         if (maxSize.y < cs->cy) cs->cy = maxSize.y;
 879         if (cs->cx < minTrack.x ) cs->cx = minTrack.x;
 880         if (cs->cy < minTrack.y ) cs->cy = minTrack.y;
 881     }
 882
 883     if (cs->cx < 0) cs->cx = 0;
 884     if (cs->cy < 0) cs->cy = 0;
 885
 886     wndPtr->rectWindow.left   = cs->x;
 887     wndPtr->rectWindow.top    = cs->y;
 888     wndPtr->rectWindow.right  = cs->x + cs->cx;
 889     wndPtr->rectWindow.bottom = cs->y + cs->cy;
 890     wndPtr->rectClient        = wndPtr->rectWindow;
 891
 892     if(!wndPtr->pDriver->pCreateWindow(wndPtr, cs, type == WIN_PROC_32W))
 893     {
 894         retvalue = FALSE;
 895         goto end;
 896     }
 897
 898     /* Set the window menu */
 899
 900     if ((wndPtr->dwStyle & (WS_CAPTION | WS_CHILD)) == WS_CAPTION )
 901     {
 902         if (cs->hMenu) SetMenu(hwnd, cs->hMenu);
 903         else
 904         {
 905             LPCSTR menuName = (LPCSTR)GetClassLongA( hwnd, GCL_MENUNAME );
 906             if (menuName)
 907             {
 908                 if (HIWORD(cs->hInstance))
 909                     cs->hMenu = LoadMenuA(cs->hInstance,menuName);
 910                 else
 911                     cs->hMenu = LoadMenu16(cs->hInstance,menuName);
 912
 913                 if (cs->hMenu) SetMenu( hwnd, cs->hMenu );
 914             }
 915         }
 916     }
 917     else wndPtr->wIDmenu = (UINT)cs->hMenu;
 918
 919     /* Send the WM_CREATE message
 920      * Perhaps we shouldn't allow width/height changes as well.
 921      * See p327 in "Internals".
 922      */
 923
 924     maxPos.x = wndPtr->rectWindow.left; maxPos.y = wndPtr->rectWindow.top;
 925
 926     localSend32 = (type == WIN_PROC_32W) ? SendMessageW : SendMessageA;
 927     if( (*localSend32)( hwnd, WM_NCCREATE, 0, (LPARAM)cs) )
 928     {
 929         /* Insert the window in the linked list */
 930
 931         WIN_LinkWindow( hwnd, hwndLinkAfter );
 932
 933         WINPOS_SendNCCalcSize( hwnd, FALSE, &wndPtr->rectWindow,
 934                                NULL, NULL, 0, &wndPtr->rectClient );
 935         OffsetRect(&wndPtr->rectWindow, maxPos.x - wndPtr->rectWindow.left,
 936                                           maxPos.y - wndPtr->rectWindow.top);
 937         if( ((*localSend32)( hwnd, WM_CREATE, 0, (LPARAM)cs )) != -1 )
 938         {
 939             /* Send the size messages */
 940
 941             if (!(wndPtr->flags & WIN_NEED_SIZE))
 942             {
 943                 /* send it anyway */
 944                 if (((wndPtr->rectClient.right-wndPtr->rectClient.left) <0)
 945                     ||((wndPtr->rectClient.bottom-wndPtr->rectClient.top)<0))
 946                   WARN("sending bogus WM_SIZE message 0x%08lx\n",
 947                         MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left,
 948                                  wndPtr->rectClient.bottom-wndPtr->rectClient.top));
 949                 (*localSend32)( hwnd, WM_SIZE, SIZE_RESTORED,
 950                                 MAKELONG(wndPtr->rectClient.right-wndPtr->rectClient.left,
 951                                          wndPtr->rectClient.bottom-wndPtr->rectClient.top));
 952                 (*localSend32)( hwnd, WM_MOVE, 0,
 953                                 MAKELONG( wndPtr->rectClient.left,
 954                                           wndPtr->rectClient.top ) );
 955             }
 956
 957             /* Show the window, maximizing or minimizing if needed */
 958
 959             if (wndPtr->dwStyle & (WS_MINIMIZE | WS_MAXIMIZE))
 960             {
 961                 RECT16 newPos;
 962                 UINT16 swFlag = (wndPtr->dwStyle & WS_MINIMIZE) ? SW_MINIMIZE : SW_MAXIMIZE;
 963                 wndPtr->dwStyle &= ~(WS_MAXIMIZE | WS_MINIMIZE);
 964                 WINPOS_MinMaximize( wndPtr, swFlag, &newPos );
 965                 swFlag = ((wndPtr->dwStyle & WS_CHILD) || GetActiveWindow())
 966                     ? SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED
 967                     : SWP_NOZORDER | SWP_FRAMECHANGED;
 968                 SetWindowPos( hwnd, 0, newPos.left, newPos.top,
 969                                 newPos.right, newPos.bottom, swFlag );
 970             }
 971
 972             if( (wndPtr->dwStyle & WS_CHILD) && !(wndPtr->dwExStyle & WS_EX_NOPARENTNOTIFY) )
 973             {
 974                 /* Notify the parent window only */
 975
 976                 SendMessageA( wndPtr->parent->hwndSelf, WM_PARENTNOTIFY,
 977                                 MAKEWPARAM(WM_CREATE, wndPtr->wIDmenu), (LPARAM)hwnd );
 978                 if( !IsWindow(hwnd) )
 979                 {
 980                     retvalue = 0;
 981                     goto end;
 982                 }
 983             }
 984
 985             if (cs->style & WS_VISIBLE) ShowWindow( hwnd, sw );
 986
 987             /* Call WH_SHELL hook */
 988
 989             if (!(wndPtr->dwStyle & WS_CHILD) && !wndPtr->owner)
 990                 HOOK_CallHooks16( WH_SHELL, HSHELL_WINDOWCREATED, hwnd, 0 );
 991
 992             TRACE("created window %04x\n", hwnd);
 993             retvalue = hwnd;
 994             goto end;
 995         }
 996         WIN_UnlinkWindow( hwnd );
 997     }
 998
 999     /* Abort window creation */
1000
1001     WARN("aborted by WM_xxCREATE!\n");
1002     WIN_ReleaseWndPtr(WIN_DestroyWindow( wndPtr ));
1003     CLASS_RemoveWindow( classPtr );
1004     retvalue = 0;
1005 end:
1006     WIN_ReleaseWndPtr(wndPtr);
1007
1008     return retvalue;
1009 }
1010
1011
1012 /***********************************************************************
1013  *              CreateWindow (USER.41)
1014  */
1015 HWND16 WINAPI CreateWindow16( LPCSTR className, LPCSTR windowName,
1016                               DWORD style, INT16 x, INT16 y, INT16 width,
1017                               INT16 height, HWND16 parent, HMENU16 menu,
1018                               HINSTANCE16 instance, LPVOID data )
1019 {
1020     return CreateWindowEx16( 0, className, windowName, style,
1021                            x, y, width, height, parent, menu, instance, data );
1022 }
1023
1024
1025 /***********************************************************************
1026  *              CreateWindowEx (USER.452)
1027  */
1028 HWND16 WINAPI CreateWindowEx16( DWORD exStyle, LPCSTR className,
1029                                 LPCSTR windowName, DWORD style, INT16 x,
1030                                 INT16 y, INT16 width, INT16 height,
1031                                 HWND16 parent, HMENU16 menu,
1032                                 HINSTANCE16 instance, LPVOID data )
1033 {
1034     ATOM classAtom;
1035     CREATESTRUCTA cs;
1036     char buffer[256];
1037
1038     /* Find the class atom */
1039
1040     if (HIWORD(className))
1041     {
1042         if (!(classAtom = GlobalFindAtomA( className )))
1043         {
1044             ERR( "bad class name %s\n", debugres_a(className) );
1045             return 0;
1046         }
1047     }
1048     else
1049     {
1050         classAtom = LOWORD(className);
1051         if (!GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) ))
1052         {
1053             ERR( "bad atom %x\n", classAtom);
1054             return 0;
1055         }
1056         className = buffer;
1057     }
1058
1059     /* Fix the coordinates */
1060
1061     cs.x  = (x == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)x;
1062     cs.y  = (y == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)y;
1063     cs.cx = (width == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)width;
1064     cs.cy = (height == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)height;
1065
1066     /* Create the window */
1067
1068     cs.lpCreateParams = data;
1069     cs.hInstance      = (HINSTANCE)instance;
1070     cs.hMenu          = (HMENU)menu;
1071     cs.hwndParent     = (HWND)parent;
1072     cs.style          = style;
1073     cs.lpszName       = windowName;
1074     cs.lpszClass      = className;
1075     cs.dwExStyle      = exStyle;
1076
1077     return WIN_CreateWindowEx( &cs, classAtom, WIN_PROC_16 );
1078 }
1079
1080
1081 /***********************************************************************
1082  *              CreateWindowExA (USER32.@)
1083  */
1084 HWND WINAPI CreateWindowExA( DWORD exStyle, LPCSTR className,
1085                                  LPCSTR windowName, DWORD style, INT x,
1086                                  INT y, INT width, INT height,
1087                                  HWND parent, HMENU menu,
1088                                  HINSTANCE instance, LPVOID data )
1089 {
1090     ATOM classAtom;
1091     CREATESTRUCTA cs;
1092     char buffer[256];
1093
1094     if(!instance)
1095         instance=GetModuleHandleA(NULL);
1096
1097     if(exStyle & WS_EX_MDICHILD)
1098         return CreateMDIWindowA(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
1099
1100     /* Find the class atom */
1101
1102     if (HIWORD(className))
1103     {
1104         if (!(classAtom = GlobalFindAtomA( className )))
1105         {
1106             ERR( "bad class name %s\n", debugres_a(className) );
1107             return 0;
1108         }
1109     }
1110     else
1111     {
1112         classAtom = LOWORD(className);
1113         if (!GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) ))
1114         {
1115             ERR( "bad atom %x\n", classAtom);
1116             return 0;
1117         }
1118         className = buffer;
1119     }
1120
1121     /* Create the window */
1122
1123     cs.lpCreateParams = data;
1124     cs.hInstance      = instance;
1125     cs.hMenu          = menu;
1126     cs.hwndParent     = parent;
1127     cs.x              = x;
1128     cs.y              = y;
1129     cs.cx             = width;
1130     cs.cy             = height;
1131     cs.style          = style;
1132     cs.lpszName       = windowName;
1133     cs.lpszClass      = className;
1134     cs.dwExStyle      = exStyle;
1135
1136     return WIN_CreateWindowEx( &cs, classAtom, WIN_PROC_32A );
1137 }
1138
1139
1140 /***********************************************************************
1141  *              CreateWindowExW (USER32.@)
1142  */
1143 HWND WINAPI CreateWindowExW( DWORD exStyle, LPCWSTR className,
1144                                  LPCWSTR windowName, DWORD style, INT x,
1145                                  INT y, INT width, INT height,
1146                                  HWND parent, HMENU menu,
1147                                  HINSTANCE instance, LPVOID data )
1148 {
1149     ATOM classAtom;
1150     CREATESTRUCTW cs;
1151     WCHAR buffer[256];
1152
1153     if(!instance)
1154         instance=GetModuleHandleA(NULL);
1155
1156     if(exStyle & WS_EX_MDICHILD)
1157         return CreateMDIWindowW(className, windowName, style, x, y, width, height, parent, instance, (LPARAM)data);
1158
1159     /* Find the class atom */
1160
1161     if (HIWORD(className))
1162     {
1163         if (!(classAtom = GlobalFindAtomW( className )))
1164         {
1165             ERR( "bad class name %s\n", debugres_w(className) );
1166             return 0;
1167         }
1168     }
1169     else
1170     {
1171         classAtom = LOWORD(className);
1172         if (!GlobalGetAtomNameW( classAtom, buffer, sizeof(buffer)/sizeof(WCHAR) ))
1173         {
1174             ERR( "bad atom %x\n", classAtom);
1175             return 0;
1176         }
1177         className = buffer;
1178     }
1179
1180     /* Create the window */
1181
1182     cs.lpCreateParams = data;
1183     cs.hInstance      = instance;
1184     cs.hMenu          = menu;
1185     cs.hwndParent     = parent;
1186     cs.x              = x;
1187     cs.y              = y;
1188     cs.cx             = width;
1189     cs.cy             = height;
1190     cs.style          = style;
1191     cs.lpszName       = windowName;
1192     cs.lpszClass      = className;
1193     cs.dwExStyle      = exStyle;
1194
1195     /* Note: we rely on the fact that CREATESTRUCTA and */
1196     /* CREATESTRUCTW have the same layout. */
1197     return WIN_CreateWindowEx( (CREATESTRUCTA *)&cs, classAtom, WIN_PROC_32W );
1198 }
1199
1200 /***********************************************************************
1201  *           WIN_SendDestroyMsg
1202  */
1203 static void WIN_SendDestroyMsg( WND* pWnd )
1204 {
1205     if( CARET_GetHwnd() == pWnd->hwndSelf ) DestroyCaret();
1206     USER_Driver.pResetSelectionOwner( pWnd, TRUE );
1207
1208     /*
1209      * Send the WM_DESTROY to the window.
1210      */
1211     SendMessageA( pWnd->hwndSelf, WM_DESTROY, 0, 0);
1212
1213     /*
1214      * This WM_DESTROY message can trigger re-entrant calls to DestroyWindow
1215      * make sure that the window still exists when we come back.
1216      */
1217     if (IsWindow(pWnd->hwndSelf))
1218     {
1219       HWND* pWndArray = NULL;
1220       WND*  pChild    = NULL;
1221       int   nKidCount = 0;
1222
1223       /*
1224        * Now, if the window has kids, we have to send WM_DESTROY messages
1225        * recursively to it's kids. It seems that those calls can also
1226        * trigger re-entrant calls to DestroyWindow for the kids so we must
1227        * protect against corruption of the list of siblings. We first build
1228        * a list of HWNDs representing all the kids.
1229        */
1230       pChild = WIN_LockWndPtr(pWnd->child);
1231       while( pChild )
1232       {
1233         nKidCount++;
1234         WIN_UpdateWndPtr(&pChild,pChild->next);
1235       }
1236
1237       /*
1238        * If there are no kids, we're done.
1239        */
1240       if (nKidCount==0)
1241         return;
1242
1243       pWndArray = HeapAlloc(GetProcessHeap(), 0, nKidCount*sizeof(HWND));
1244
1245       /*
1246        * Sanity check
1247        */
1248       if (pWndArray==NULL)
1249         return;
1250
1251       /*
1252        * Now, enumerate all the kids in a list, since we wait to make the SendMessage
1253        * call, our linked list of siblings should be safe.
1254        */
1255       nKidCount = 0;
1256       pChild = WIN_LockWndPtr(pWnd->child);
1257       while( pChild )
1258       {
1259         pWndArray[nKidCount] = pChild->hwndSelf;
1260         nKidCount++;
1261         WIN_UpdateWndPtr(&pChild,pChild->next);
1262       }
1263
1264       /*
1265        * Now that we have a list, go through that list again and send the destroy
1266        * message to those windows. We are using the HWND to retrieve the
1267        * WND pointer so we are effectively checking that all the kid windows are
1268        * still valid before sending the message.
1269        */
1270       while (nKidCount>0)
1271       {
1272         pChild = WIN_FindWndPtr(pWndArray[--nKidCount]);
1273
1274         if (pChild!=NULL)
1275         {
1276           WIN_SendDestroyMsg( pChild );
1277           WIN_ReleaseWndPtr(pChild);
1278         }
1279       }
1280
1281       /*
1282        * Cleanup
1283        */
1284       HeapFree(GetProcessHeap(), 0, pWndArray);
1285     }
1286     else
1287       WARN("\tdestroyed itself while in WM_DESTROY!\n");
1288 }
1289
1290
1291 /***********************************************************************
1292  *              DestroyWindow (USER.53)
1293  */
1294 BOOL16 WINAPI DestroyWindow16( HWND16 hwnd )
1295 {
1296     return DestroyWindow(hwnd);
1297 }
1298
1299
1300 /***********************************************************************
1301  *              DestroyWindow (USER32.@)
1302  */
1303 BOOL WINAPI DestroyWindow( HWND hwnd )
1304 {
1305     WND * wndPtr;
1306     BOOL retvalue;
1307     HWND h;
1308     BOOL bFocusSet = FALSE;
1309
1310     TRACE("(%04x)\n", hwnd);
1311
1312     /* Initialization */
1313
1314     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
1315     if (wndPtr == pWndDesktop)
1316     {
1317         retvalue = FALSE; /* Can't destroy desktop */
1318         goto end;
1319     }
1320
1321     /* Look whether the focus is within the tree of windows we will
1322      * be destroying.
1323      */
1324     h = GetFocus16();
1325     while (h && (GetWindowLongA(h,GWL_STYLE) & WS_CHILD))
1326     {
1327         if (h == hwnd)
1328         {
1329             SetFocus(GetParent(h));
1330             bFocusSet = TRUE;
1331             break;
1332         }
1333         h = GetParent(h);
1334     }
1335     /* If the focus is on the window we will destroy and it has no parent,
1336      * set the focus to 0.
1337      */
1338     if (! bFocusSet && (h == hwnd))
1339     {
1340         if (!(GetWindowLongA(h,GWL_STYLE) & WS_CHILD))
1341             SetFocus(0);
1342     }
1343
1344       /* Call hooks */
1345
1346     if( HOOK_CallHooks16( WH_CBT, HCBT_DESTROYWND, hwnd, 0L) )
1347     {
1348         retvalue = FALSE;
1349         goto end;
1350     }
1351
1352     if (!(wndPtr->dwStyle & WS_CHILD) && !wndPtr->owner)
1353     {
1354         HOOK_CallHooks16( WH_SHELL, HSHELL_WINDOWDESTROYED, hwnd, 0L );
1355         /* FIXME: clean up palette - see "Internals" p.352 */
1356     }
1357
1358     if( !QUEUE_IsExitingQueue(wndPtr->hmemTaskQ) )
1359         if( wndPtr->dwStyle & WS_CHILD && !(wndPtr->dwExStyle & WS_EX_NOPARENTNOTIFY) )
1360         {
1361             /* Notify the parent window only */
1362             SendMessageA( wndPtr->parent->hwndSelf, WM_PARENTNOTIFY,
1363                             MAKEWPARAM(WM_DESTROY, wndPtr->wIDmenu), (LPARAM)hwnd );
1364             if( !IsWindow(hwnd) )
1365             {
1366                 retvalue = TRUE;
1367                 goto end;
1368             }
1369         }
1370
1371     USER_Driver.pResetSelectionOwner( wndPtr, FALSE ); /* before the window is unmapped */
1372
1373       /* Hide the window */
1374
1375     if (wndPtr->dwStyle & WS_VISIBLE)
1376     {
1377         SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_HIDEWINDOW |
1378                         SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE|
1379                         ((QUEUE_IsExitingQueue(wndPtr->hmemTaskQ))?SWP_DEFERERASE:0) );
1380         if (!IsWindow(hwnd))
1381         {
1382             retvalue = TRUE;
1383             goto end;
1384         }
1385     }
1386
1387       /* Recursively destroy owned windows */
1388
1389     if( !(wndPtr->dwStyle & WS_CHILD) )
1390     {
1391       /* make sure top menu popup doesn't get destroyed */
1392       MENU_PatchResidentPopup( (HQUEUE16)0xFFFF, wndPtr );
1393
1394       for (;;)
1395       {
1396         WND *siblingPtr = WIN_LockWndPtr(wndPtr->parent->child);  /* First sibling */
1397         while (siblingPtr)
1398         {
1399             if (siblingPtr->owner == wndPtr)
1400             {
1401                if (siblingPtr->hmemTaskQ == wndPtr->hmemTaskQ)
1402                    break;
1403                else
1404                    siblingPtr->owner = NULL;
1405             }
1406             WIN_UpdateWndPtr(&siblingPtr,siblingPtr->next);
1407         }
1408         if (siblingPtr)
1409         {
1410             DestroyWindow( siblingPtr->hwndSelf );
1411             WIN_ReleaseWndPtr(siblingPtr);
1412         }
1413         else break;
1414       }
1415
1416       if( !Options.managed || EVENT_CheckFocus() )
1417           WINPOS_ActivateOtherWindow(wndPtr);
1418
1419       if( wndPtr->owner &&
1420           wndPtr->owner->hwndLastActive == wndPtr->hwndSelf )
1421           wndPtr->owner->hwndLastActive = wndPtr->owner->hwndSelf;
1422     }
1423
1424       /* Send destroy messages */
1425
1426     WIN_SendDestroyMsg( wndPtr );
1427     if (!IsWindow(hwnd))
1428     {
1429         retvalue = TRUE;
1430         goto end;
1431     }
1432
1433       /* Unlink now so we won't bother with the children later on */
1434
1435     if( wndPtr->parent ) WIN_UnlinkWindow(hwnd);
1436
1437       /* Destroy the window storage */
1438
1439     WIN_ReleaseWndPtr(WIN_DestroyWindow( wndPtr ));
1440     retvalue = TRUE;
1441 end:
1442     WIN_ReleaseWndPtr(wndPtr);
1443     return retvalue;
1444 }
1445
1446
1447 /***********************************************************************
1448  *              CloseWindow (USER.43)
1449  */
1450 BOOL16 WINAPI CloseWindow16( HWND16 hwnd )
1451 {
1452     return CloseWindow( hwnd );
1453 }
1454
1455
1456 /***********************************************************************
1457  *              CloseWindow (USER32.@)
1458  */
1459 BOOL WINAPI CloseWindow( HWND hwnd )
1460 {
1461     WND * wndPtr = WIN_FindWndPtr( hwnd );
1462     BOOL retvalue;
1463
1464     if (!wndPtr || (wndPtr->dwStyle & WS_CHILD))
1465     {
1466         retvalue = FALSE;
1467         goto end;
1468     }
1469     ShowWindow( hwnd, SW_MINIMIZE );
1470     retvalue = TRUE;
1471 end:
1472     WIN_ReleaseWndPtr(wndPtr);
1473     return retvalue;
1474
1475 }
1476
1477
1478 /***********************************************************************
1479  *              OpenIcon (USER.44)
1480  */
1481 BOOL16 WINAPI OpenIcon16( HWND16 hwnd )
1482 {
1483     return OpenIcon( hwnd );
1484 }
1485
1486
1487 /***********************************************************************
1488  *              OpenIcon (USER32.@)
1489  */
1490 BOOL WINAPI OpenIcon( HWND hwnd )
1491 {
1492     if (!IsIconic( hwnd )) return FALSE;
1493     ShowWindow( hwnd, SW_SHOWNORMAL );
1494     return TRUE;
1495 }
1496
1497
1498 /***********************************************************************
1499  *           WIN_FindWindow
1500  *
1501  * Implementation of FindWindow() and FindWindowEx().
1502  */
1503 static HWND WIN_FindWindow( HWND parent, HWND child, ATOM className,
1504                               LPCWSTR title )
1505 {
1506     WND *pWnd;
1507     HWND retvalue;
1508
1509     if (child)
1510     {
1511         if (!(pWnd = WIN_FindWndPtr( child ))) return 0;
1512         if (parent)
1513         {
1514             if (!pWnd->parent || (pWnd->parent->hwndSelf != parent))
1515             {
1516                 retvalue = 0;
1517                 goto end;
1518             }
1519         }
1520         else if (pWnd->parent != pWndDesktop)
1521         {
1522             retvalue = 0;
1523             goto end;
1524         }
1525         WIN_UpdateWndPtr(&pWnd,pWnd->next);
1526     }
1527     else
1528     {
1529         if (!(pWnd = parent ? WIN_FindWndPtr(parent) : WIN_LockWndPtr(pWndDesktop)))
1530         {
1531             retvalue = 0;
1532             goto end;
1533         }
1534         WIN_UpdateWndPtr(&pWnd,pWnd->child);
1535     }
1536     if (!pWnd)
1537     {
1538         retvalue = 0;
1539         goto end;
1540     }
1541
1542     for ( ; pWnd ; WIN_UpdateWndPtr(&pWnd,pWnd->next))
1543     {
1544         if (className && (GetClassWord(pWnd->hwndSelf, GCW_ATOM) != className))
1545             continue;  /* Not the right class */
1546
1547         /* Now check the title */
1548
1549         if (!title)
1550         {
1551             retvalue = pWnd->hwndSelf;
1552             goto end;
1553         }
1554         if (pWnd->text && !strcmpW( pWnd->text, title ))
1555         {
1556             retvalue = pWnd->hwndSelf;
1557             goto end;
1558         }
1559     }
1560     retvalue = 0;
1561     /* In this case we need to check whether other processes
1562        own a window with the given paramters on the Desktop,
1563        but we don't, so let's at least warn about it */
1564     FIXME("Returning 0 without checking other processes\n");
1565 end:
1566     WIN_ReleaseWndPtr(pWnd);
1567     return retvalue;
1568 }
1569
1570
1571
1572 /***********************************************************************
1573  *              FindWindow (USER.50)
1574  */
1575 HWND16 WINAPI FindWindow16( LPCSTR className, LPCSTR title )
1576 {
1577     return FindWindowA( className, title );
1578 }
1579
1580
1581 /***********************************************************************
1582  *              FindWindowEx (USER.427)
1583  */
1584 HWND16 WINAPI FindWindowEx16( HWND16 parent, HWND16 child, LPCSTR className, LPCSTR title )
1585 {
1586     return FindWindowExA( parent, child, className, title );
1587 }
1588
1589
1590 /***********************************************************************
1591  *              FindWindowA (USER32.@)
1592  */
1593 HWND WINAPI FindWindowA( LPCSTR className, LPCSTR title )
1594 {
1595     HWND ret = FindWindowExA( 0, 0, className, title );
1596     if (!ret) SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1597     return ret;
1598 }
1599
1600
1601 /***********************************************************************
1602  *              FindWindowExA (USER32.@)
1603  */
1604 HWND WINAPI FindWindowExA( HWND parent, HWND child,
1605                                LPCSTR className, LPCSTR title )
1606 {
1607     ATOM atom = 0;
1608     LPWSTR buffer;
1609     HWND hwnd;
1610
1611     if (className)
1612     {
1613         /* If the atom doesn't exist, then no class */
1614         /* with this name exists either. */
1615         if (!(atom = GlobalFindAtomA( className )))
1616         {
1617             SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1618             return 0;
1619         }
1620     }
1621
1622     buffer = HEAP_strdupAtoW( GetProcessHeap(), 0, title );
1623     hwnd = WIN_FindWindow( parent, child, atom, buffer );
1624     HeapFree( GetProcessHeap(), 0, buffer );
1625     return hwnd;
1626 }
1627
1628
1629 /***********************************************************************
1630  *              FindWindowExW (USER32.@)
1631  */
1632 HWND WINAPI FindWindowExW( HWND parent, HWND child,
1633                                LPCWSTR className, LPCWSTR title )
1634 {
1635     ATOM atom = 0;
1636
1637     if (className)
1638     {
1639         /* If the atom doesn't exist, then no class */
1640         /* with this name exists either. */
1641         if (!(atom = GlobalFindAtomW( className )))
1642         {
1643             SetLastError (ERROR_CANNOT_FIND_WND_CLASS);
1644             return 0;
1645         }
1646     }
1647     return WIN_FindWindow( parent, child, atom, title );
1648 }
1649
1650
1651 /***********************************************************************
1652  *              FindWindowW (USER32.@)
1653  */
1654 HWND WINAPI FindWindowW( LPCWSTR className, LPCWSTR title )
1655 {
1656     return FindWindowExW( 0, 0, className, title );
1657 }
1658
1659
1660 /**********************************************************************
1661  *           WIN_GetDesktop
1662  * returns a locked pointer
1663  */
1664 WND *WIN_GetDesktop(void)
1665 {
1666     return WIN_LockWndPtr(pWndDesktop);
1667 }
1668 /**********************************************************************
1669  *           WIN_ReleaseDesktop
1670  * unlock the desktop pointer
1671  */
1672 void WIN_ReleaseDesktop(void)
1673 {
1674     WIN_ReleaseWndPtr(pWndDesktop);
1675 }
1676
1677
1678 /**********************************************************************
1679  *              GetDesktopWindow (USER.286)
1680  */
1681 HWND16 WINAPI GetDesktopWindow16(void)
1682 {
1683     return (HWND16)pWndDesktop->hwndSelf;
1684 }
1685
1686
1687 /**********************************************************************
1688  *              GetDesktopWindow (USER32.@)
1689  */
1690 HWND WINAPI GetDesktopWindow(void)
1691 {
1692     if (pWndDesktop) return pWndDesktop->hwndSelf;
1693     ERR( "You need the -desktop option when running with native USER\n" );
1694     ExitProcess(1);
1695     return 0;
1696 }
1697
1698
1699 /**********************************************************************
1700  *              GetDesktopHwnd (USER.278)
1701  *
1702  * Exactly the same thing as GetDesktopWindow(), but not documented.
1703  * Don't ask me why...
1704  */
1705 HWND16 WINAPI GetDesktopHwnd16(void)
1706 {
1707     return (HWND16)pWndDesktop->hwndSelf;
1708 }
1709
1710
1711 /*******************************************************************
1712  *              EnableWindow (USER.34)
1713  */
1714 BOOL16 WINAPI EnableWindow16( HWND16 hwnd, BOOL16 enable )
1715 {
1716     return EnableWindow( hwnd, enable );
1717 }
1718
1719
1720 /*******************************************************************
1721  *              EnableWindow (USER32.@)
1722  */
1723 BOOL WINAPI EnableWindow( HWND hwnd, BOOL enable )
1724 {
1725     WND *wndPtr;
1726     BOOL retvalue;
1727
1728     TRACE("EnableWindow32: ( %x, %d )\n", hwnd, enable);
1729
1730     if (!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
1731     if (enable && (wndPtr->dwStyle & WS_DISABLED))
1732     {
1733           /* Enable window */
1734         wndPtr->dwStyle &= ~WS_DISABLED;
1735
1736         if( wndPtr->flags & WIN_NATIVE )
1737             wndPtr->pDriver->pSetHostAttr( wndPtr, HAK_ACCEPTFOCUS, TRUE );
1738
1739         SendMessageA( hwnd, WM_ENABLE, TRUE, 0 );
1740         retvalue = TRUE;
1741         goto end;
1742     }
1743     else if (!enable && !(wndPtr->dwStyle & WS_DISABLED))
1744     {
1745         SendMessageA( wndPtr->hwndSelf, WM_CANCELMODE, 0, 0);
1746
1747           /* Disable window */
1748         wndPtr->dwStyle |= WS_DISABLED;
1749
1750         if( wndPtr->flags & WIN_NATIVE )
1751             wndPtr->pDriver->pSetHostAttr( wndPtr, HAK_ACCEPTFOCUS, FALSE );
1752
1753         if (hwnd == GetFocus())
1754         {
1755             SetFocus( 0 );  /* A disabled window can't have the focus */
1756         }
1757         if (hwnd == GetCapture())
1758         {
1759             ReleaseCapture();  /* A disabled window can't capture the mouse */
1760         }
1761         SendMessageA( hwnd, WM_ENABLE, FALSE, 0 );
1762         retvalue = FALSE;
1763         goto end;
1764     }
1765     retvalue = ((wndPtr->dwStyle & WS_DISABLED) != 0);
1766 end:
1767     WIN_ReleaseWndPtr(wndPtr);
1768     return retvalue;
1769 }
1770
1771
1772 /***********************************************************************
1773  *              IsWindowEnabled (USER.35)
1774  */
1775 BOOL16 WINAPI IsWindowEnabled16(HWND16 hWnd)
1776 {
1777     return IsWindowEnabled(hWnd);
1778 }
1779
1780
1781 /***********************************************************************
1782  *              IsWindowEnabled (USER32.@)
1783  */
1784 BOOL WINAPI IsWindowEnabled(HWND hWnd)
1785 {
1786     WND * wndPtr;
1787     BOOL retvalue;
1788
1789     if (!(wndPtr = WIN_FindWndPtr(hWnd))) return FALSE;
1790     retvalue = !(wndPtr->dwStyle & WS_DISABLED);
1791     WIN_ReleaseWndPtr(wndPtr);
1792     return retvalue;
1793
1794 }
1795
1796
1797 /***********************************************************************
1798  *              IsWindowUnicode (USER32.@)
1799  */
1800 BOOL WINAPI IsWindowUnicode( HWND hwnd )
1801 {
1802     WND * wndPtr;
1803     BOOL retvalue;
1804
1805     if (!(wndPtr = WIN_FindWndPtr(hwnd))) return FALSE;
1806     retvalue = (WINPROC_GetProcType( wndPtr->winproc ) == WIN_PROC_32W);
1807     WIN_ReleaseWndPtr(wndPtr);
1808     return retvalue;
1809 }
1810
1811
1812 /**********************************************************************
1813  *              GetWindowWord (USER.133)
1814  */
1815 WORD WINAPI GetWindowWord16( HWND16 hwnd, INT16 offset )
1816 {
1817     return GetWindowWord( hwnd, offset );
1818 }
1819
1820
1821 /**********************************************************************
1822  *              GetWindowWord (USER32.@)
1823  */
1824 WORD WINAPI GetWindowWord( HWND hwnd, INT offset )
1825 {
1826     WORD retvalue;
1827     WND * wndPtr = WIN_FindWndPtr( hwnd );
1828     if (!wndPtr) return 0;
1829     if (offset >= 0)
1830     {
1831         if (offset + sizeof(WORD) > wndPtr->cbWndExtra)
1832         {
1833             WARN("Invalid offset %d\n", offset );
1834             retvalue = 0;
1835             goto end;
1836         }
1837         retvalue = *(WORD *)(((char *)wndPtr->wExtra) + offset);
1838         goto end;
1839     }
1840     switch(offset)
1841     {
1842     case GWW_ID:
1843         if (HIWORD(wndPtr->wIDmenu))
1844                 WARN("GWW_ID: discards high bits of 0x%08x!\n",
1845                     wndPtr->wIDmenu);
1846         retvalue = (WORD)wndPtr->wIDmenu;
1847         goto end;
1848     case GWW_HWNDPARENT:
1849         retvalue =  GetParent(hwnd);
1850         goto end;
1851     case GWW_HINSTANCE:
1852         if (HIWORD(wndPtr->hInstance))
1853                 WARN("GWW_HINSTANCE: discards high bits of 0x%08x!\n",
1854                     wndPtr->hInstance);
1855         retvalue = (WORD)wndPtr->hInstance;
1856         goto end;
1857     default:
1858         WARN("Invalid offset %d\n", offset );
1859         retvalue = 0;
1860         goto end;
1861     }
1862 end:
1863     WIN_ReleaseWndPtr(wndPtr);
1864     return retvalue;
1865 }
1866
1867 /**********************************************************************
1868  *              SetWindowWord (USER.134)
1869  */
1870 WORD WINAPI SetWindowWord16( HWND16 hwnd, INT16 offset, WORD newval )
1871 {
1872     return SetWindowWord( hwnd, offset, newval );
1873 }
1874
1875
1876 /**********************************************************************
1877  *              SetWindowWord (USER32.@)
1878  */
1879 WORD WINAPI SetWindowWord( HWND hwnd, INT offset, WORD newval )
1880 {
1881     WORD *ptr, retval;
1882     WND * wndPtr = WIN_FindWndPtr( hwnd );
1883     if (!wndPtr) return 0;
1884     if (offset >= 0)
1885     {
1886         if (offset + sizeof(WORD) > wndPtr->cbWndExtra)
1887         {
1888             WARN("Invalid offset %d\n", offset );
1889             retval = 0;
1890             goto end;
1891         }
1892         ptr = (WORD *)(((char *)wndPtr->wExtra) + offset);
1893     }
1894     else switch(offset)
1895     {
1896         case GWW_ID:        ptr = (WORD *)&wndPtr->wIDmenu; break;
1897         case GWW_HINSTANCE: ptr = (WORD *)&wndPtr->hInstance; break;
1898         case GWW_HWNDPARENT: retval = SetParent( hwnd, newval );
1899                              goto end;
1900         default:
1901             WARN("Invalid offset %d\n", offset );
1902             retval = 0;
1903             goto end;
1904     }
1905     retval = *ptr;
1906     *ptr = newval;
1907 end:
1908     WIN_ReleaseWndPtr(wndPtr);
1909     return retval;
1910 }
1911
1912
1913 /**********************************************************************
1914  *           WIN_GetWindowLong
1915  *
1916  * Helper function for GetWindowLong().
1917  */
1918 static LONG WIN_GetWindowLong( HWND hwnd, INT offset, WINDOWPROCTYPE type )
1919 {
1920     LONG retvalue;
1921     WND * wndPtr = WIN_FindWndPtr( hwnd );
1922     if (!wndPtr) return 0;
1923     if (offset >= 0)
1924     {
1925         if (offset + sizeof(LONG) > wndPtr->cbWndExtra)
1926         {
1927             WARN("Invalid offset %d\n", offset );
1928             retvalue = 0;
1929             goto end;
1930         }
1931         retvalue = *(LONG *)(((char *)wndPtr->wExtra) + offset);
1932         /* Special case for dialog window procedure */
1933         if ((offset == DWL_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG))
1934         {
1935             retvalue = (LONG)WINPROC_GetProc( (HWINDOWPROC)retvalue, type );
1936             goto end;
1937     }
1938         goto end;
1939     }
1940     switch(offset)
1941     {
1942         case GWL_USERDATA:   retvalue = wndPtr->userdata;
1943                              goto end;
1944         case GWL_STYLE:      retvalue = wndPtr->dwStyle;
1945                              goto end;
1946         case GWL_EXSTYLE:    retvalue = wndPtr->dwExStyle;
1947                              goto end;
1948         case GWL_ID:         retvalue = (LONG)wndPtr->wIDmenu;
1949                              goto end;
1950         case GWL_WNDPROC:    retvalue = (LONG)WINPROC_GetProc( wndPtr->winproc,
1951                                                            type );
1952                              goto end;
1953         case GWL_HWNDPARENT: retvalue = GetParent(hwnd);
1954                              goto end;
1955         case GWL_HINSTANCE:  retvalue = wndPtr->hInstance;
1956                              goto end;
1957         default:
1958             WARN("Unknown offset %d\n", offset );
1959     }
1960     retvalue = 0;
1961 end:
1962     WIN_ReleaseWndPtr(wndPtr);
1963     return retvalue;
1964 }
1965
1966
1967 /**********************************************************************
1968  *           WIN_SetWindowLong
1969  *
1970  * Helper function for SetWindowLong().
1971  *
1972  * 0 is the failure code. However, in the case of failure SetLastError
1973  * must be set to distinguish between a 0 return value and a failure.
1974  *
1975  * FIXME: The error values for SetLastError may not be right. Can
1976  *        someone check with the real thing?
1977  */
1978 static LONG WIN_SetWindowLong( HWND hwnd, INT offset, LONG newval,
1979                                WINDOWPROCTYPE type )
1980 {
1981     LONG *ptr, retval;
1982     WND * wndPtr = WIN_FindWndPtr( hwnd );
1983     STYLESTRUCT style;
1984
1985     TRACE("%x=%p %x %lx %x\n",hwnd, wndPtr, offset, newval, type);
1986
1987     if (!wndPtr)
1988     {
1989        /* Is this the right error? */
1990        SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1991        return 0;
1992     }
1993
1994     if (offset >= 0)
1995     {
1996         if (offset + sizeof(LONG) > wndPtr->cbWndExtra)
1997         {
1998             WARN("Invalid offset %d\n", offset );
1999
2000             /* Is this the right error? */
2001             SetLastError( ERROR_OUTOFMEMORY );
2002
2003             retval = 0;
2004             goto end;
2005         }
2006         ptr = (LONG *)(((char *)wndPtr->wExtra) + offset);
2007         /* Special case for dialog window procedure */
2008         if ((offset == DWL_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG))
2009         {
2010             retval = (LONG)WINPROC_GetProc( (HWINDOWPROC)*ptr, type );
2011             WINPROC_SetProc( (HWINDOWPROC *)ptr, (WNDPROC16)newval,
2012                              type, WIN_PROC_WINDOW );
2013             goto end;
2014         }
2015     }
2016     else switch(offset)
2017     {
2018         case GWL_ID:
2019                 ptr = (DWORD*)&wndPtr->wIDmenu;
2020                 break;
2021         case GWL_HINSTANCE:
2022                 retval = SetWindowWord( hwnd, offset, newval );
2023                 goto end;
2024         case GWL_WNDPROC:
2025                 retval = (LONG)WINPROC_GetProc( wndPtr->winproc, type );
2026                 WINPROC_SetProc( &wndPtr->winproc, (WNDPROC16)newval,
2027                                                 type, WIN_PROC_WINDOW );
2028                 goto end;
2029         case GWL_STYLE:
2030                 style.styleOld = wndPtr->dwStyle;
2031                 style.styleNew = newval;
2032                 if (wndPtr->flags & WIN_ISWIN32)
2033                         SendMessageA(hwnd,WM_STYLECHANGING,GWL_STYLE,(LPARAM)&style);
2034                 wndPtr->dwStyle = style.styleNew;
2035                 if (wndPtr->flags & WIN_ISWIN32)
2036                         SendMessageA(hwnd,WM_STYLECHANGED,GWL_STYLE,(LPARAM)&style);
2037                 retval = style.styleOld;
2038                 goto end;
2039
2040         case GWL_USERDATA:
2041                 ptr = &wndPtr->userdata;
2042                 break;
2043         case GWL_EXSTYLE:
2044                 style.styleOld = wndPtr->dwExStyle;
2045                 style.styleNew = newval;
2046                 if (wndPtr->flags & WIN_ISWIN32)
2047                         SendMessageA(hwnd,WM_STYLECHANGING,GWL_EXSTYLE,(LPARAM)&style);
2048                 wndPtr->dwExStyle = newval;
2049                 if (wndPtr->flags & WIN_ISWIN32)
2050                         SendMessageA(hwnd,WM_STYLECHANGED,GWL_EXSTYLE,(LPARAM)&style);
2051                 retval = style.styleOld;
2052                 goto end;
2053
2054         default:
2055             WARN("Invalid offset %d\n", offset );
2056
2057             /* Don't think this is right error but it should do */
2058             SetLastError( ERROR_OUTOFMEMORY );
2059
2060             retval = 0;
2061             goto end;
2062     }
2063     retval = *ptr;
2064     *ptr = newval;
2065 end:
2066     WIN_ReleaseWndPtr(wndPtr);
2067     return retval;
2068 }
2069
2070
2071 /**********************************************************************
2072  *              GetWindowLong (USER.135)
2073  */
2074 LONG WINAPI GetWindowLong16( HWND16 hwnd, INT16 offset )
2075 {
2076     return WIN_GetWindowLong( (HWND)hwnd, offset, WIN_PROC_16 );
2077 }
2078
2079
2080 /**********************************************************************
2081  *              GetWindowLongA (USER32.@)
2082  */
2083 LONG WINAPI GetWindowLongA( HWND hwnd, INT offset )
2084 {
2085     return WIN_GetWindowLong( hwnd, offset, WIN_PROC_32A );
2086 }
2087
2088
2089 /**********************************************************************
2090  *              GetWindowLongW (USER32.@)
2091  */
2092 LONG WINAPI GetWindowLongW( HWND hwnd, INT offset )
2093 {
2094     return WIN_GetWindowLong( hwnd, offset, WIN_PROC_32W );
2095 }
2096
2097
2098 /**********************************************************************
2099  *              SetWindowLong (USER.136)
2100  */
2101 LONG WINAPI SetWindowLong16( HWND16 hwnd, INT16 offset, LONG newval )
2102 {
2103     return WIN_SetWindowLong( hwnd, offset, newval, WIN_PROC_16 );
2104 }
2105
2106
2107 /**********************************************************************
2108  *              SetWindowLongA (USER32.@)
2109  */
2110 LONG WINAPI SetWindowLongA( HWND hwnd, INT offset, LONG newval )
2111 {
2112     return WIN_SetWindowLong( hwnd, offset, newval, WIN_PROC_32A );
2113 }
2114
2115
2116 /**********************************************************************
2117  *              SetWindowLongW (USER32.@) Set window attribute
2118  *
2119  * SetWindowLong() alters one of a window's attributes or sets a 32-bit (long)
2120  * value in a window's extra memory.
2121  *
2122  * The _hwnd_ parameter specifies the window.  is the handle to a
2123  * window that has extra memory. The _newval_ parameter contains the
2124  * new attribute or extra memory value.  If positive, the _offset_
2125  * parameter is the byte-addressed location in the window's extra
2126  * memory to set.  If negative, _offset_ specifies the window
2127  * attribute to set, and should be one of the following values:
2128  *
2129  * GWL_EXSTYLE      The window's extended window style
2130  *
2131  * GWL_STYLE        The window's window style.
2132  *
2133  * GWL_WNDPROC      Pointer to the window's window procedure.
2134  *
2135  * GWL_HINSTANCE    The window's pplication instance handle.
2136  *
2137  * GWL_ID           The window's identifier.
2138  *
2139  * GWL_USERDATA     The window's user-specified data.
2140  *
2141  * If the window is a dialog box, the _offset_ parameter can be one of
2142  * the following values:
2143  *
2144  * DWL_DLGPROC      The address of the window's dialog box procedure.
2145  *
2146  * DWL_MSGRESULT    The return value of a message
2147  *                  that the dialog box procedure processed.
2148  *
2149  * DWL_USER         Application specific information.
2150  *
2151  * RETURNS
2152  *
2153  * If successful, returns the previous value located at _offset_. Otherwise,
2154  * returns 0.
2155  *
2156  * NOTES
2157  *
2158  * Extra memory for a window class is specified by a nonzero cbWndExtra
2159  * parameter of the WNDCLASS structure passed to RegisterClass() at the
2160  * time of class creation.
2161  *
2162  * Using GWL_WNDPROC to set a new window procedure effectively creates
2163  * a window subclass. Use CallWindowProc() in the new windows procedure
2164  * to pass messages to the superclass's window procedure.
2165  *
2166  * The user data is reserved for use by the application which created
2167  * the window.
2168  *
2169  * Do not use GWL_STYLE to change the window's WS_DISABLE style;
2170  * instead, call the EnableWindow() function to change the window's
2171  * disabled state.
2172  *
2173  * Do not use GWL_HWNDPARENT to reset the window's parent, use
2174  * SetParent() instead.
2175  *
2176  * Win95:
2177  * When offset is GWL_STYLE and the calling app's ver is 4.0,
2178  * it sends WM_STYLECHANGING before changing the settings
2179  * and WM_STYLECHANGED afterwards.
2180  * App ver 4.0 can't use SetWindowLong to change WS_EX_TOPMOST.
2181  *
2182  * BUGS
2183  *
2184  * GWL_STYLE does not dispatch WM_STYLE... messages.
2185  *
2186  * CONFORMANCE
2187  *
2188  * ECMA-234, Win32
2189  *
2190  */
2191 LONG WINAPI SetWindowLongW(
2192     HWND hwnd,  /* [in] window to alter */
2193     INT offset, /* [in] offset, in bytes, of location to alter */
2194     LONG newval /* [in] new value of location */
2195 ) {
2196     return WIN_SetWindowLong( hwnd, offset, newval, WIN_PROC_32W );
2197 }
2198
2199
2200 /*******************************************************************
2201  *              GetWindowText (USER.36)
2202  */
2203 INT16 WINAPI GetWindowText16( HWND16 hwnd, SEGPTR lpString, INT16 nMaxCount )
2204 {
2205     return (INT16)SendMessage16(hwnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString);
2206 }
2207
2208
2209 /*******************************************************************
2210  *              GetWindowTextA (USER32.@)
2211  */
2212 INT WINAPI GetWindowTextA( HWND hwnd, LPSTR lpString, INT nMaxCount )
2213 {
2214     return (INT)SendMessageA( hwnd, WM_GETTEXT, nMaxCount,
2215                                   (LPARAM)lpString );
2216 }
2217
2218 /*******************************************************************
2219  *              InternalGetWindowText (USER32.@)
2220  */
2221 INT WINAPI InternalGetWindowText(HWND hwnd,LPWSTR lpString,INT nMaxCount )
2222 {
2223     FIXME("(0x%08x,%p,0x%x),stub!\n",hwnd,lpString,nMaxCount);
2224     return GetWindowTextW(hwnd,lpString,nMaxCount);
2225 }
2226
2227
2228 /*******************************************************************
2229  *              GetWindowTextW (USER32.@)
2230  */
2231 INT WINAPI GetWindowTextW( HWND hwnd, LPWSTR lpString, INT nMaxCount )
2232 {
2233     return (INT)SendMessageW( hwnd, WM_GETTEXT, nMaxCount,
2234                                   (LPARAM)lpString );
2235 }
2236
2237
2238 /*******************************************************************
2239  *              SetWindowText (USER.37)
2240  */
2241 BOOL16 WINAPI SetWindowText16( HWND16 hwnd, SEGPTR lpString )
2242 {
2243     return (BOOL16)SendMessage16( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2244 }
2245
2246
2247 /*******************************************************************
2248  *              SetWindowText (USER32.@)
2249  */
2250 BOOL WINAPI SetWindowTextA( HWND hwnd, LPCSTR lpString )
2251 {
2252     return (BOOL)SendMessageA( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2253 }
2254
2255
2256 /*******************************************************************
2257  *              SetWindowTextW (USER32.@)
2258  */
2259 BOOL WINAPI SetWindowTextW( HWND hwnd, LPCWSTR lpString )
2260 {
2261     return (BOOL)SendMessageW( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
2262 }
2263
2264
2265 /*******************************************************************
2266  *              GetWindowTextLength (USER.38)
2267  */
2268 INT16 WINAPI GetWindowTextLength16( HWND16 hwnd )
2269 {
2270     return (INT16)SendMessage16( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2271 }
2272
2273
2274 /*******************************************************************
2275  *              GetWindowTextLengthA (USER32.@)
2276  */
2277 INT WINAPI GetWindowTextLengthA( HWND hwnd )
2278 {
2279     return SendMessageA( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2280 }
2281
2282 /*******************************************************************
2283  *              GetWindowTextLengthW (USER32.@)
2284  */
2285 INT WINAPI GetWindowTextLengthW( HWND hwnd )
2286 {
2287     return SendMessageW( hwnd, WM_GETTEXTLENGTH, 0, 0 );
2288 }
2289
2290
2291 /*******************************************************************
2292  *              IsWindow (USER.47)
2293  */
2294 BOOL16 WINAPI IsWindow16( HWND16 hwnd )
2295 {
2296     CURRENT_STACK16->es = USER_HeapSel;
2297     return IsWindow( hwnd );
2298 }
2299
2300
2301 /*******************************************************************
2302  *              IsWindow (USER32.@)
2303  */
2304 BOOL WINAPI IsWindow( HWND hwnd )
2305 {
2306     WND * wndPtr;
2307     BOOL retvalue;
2308
2309     if(!(wndPtr = WIN_FindWndPtr( hwnd ))) return FALSE;
2310     retvalue = (wndPtr->dwMagic == WND_MAGIC);
2311     WIN_ReleaseWndPtr(wndPtr);
2312     return retvalue;
2313
2314 }
2315
2316
2317 /*****************************************************************
2318  *              GetParent (USER.46)
2319  */
2320 HWND16 WINAPI GetParent16( HWND16 hwnd )
2321 {
2322     return (HWND16)GetParent( hwnd );
2323 }
2324
2325
2326 /*****************************************************************
2327  *              GetParent (USER32.@)
2328  */
2329 HWND WINAPI GetParent( HWND hwnd )
2330 {
2331     WND *wndPtr;
2332     HWND retvalue = 0;
2333
2334     if(!(wndPtr = WIN_FindWndPtr(hwnd))) return 0;
2335     if ((!(wndPtr->dwStyle & (WS_POPUP|WS_CHILD))))
2336         goto end;
2337
2338     WIN_UpdateWndPtr(&wndPtr,((wndPtr->dwStyle & WS_CHILD) ? wndPtr->parent : wndPtr->owner));
2339     if (wndPtr)
2340         retvalue = wndPtr->hwndSelf;
2341
2342 end:
2343     WIN_ReleaseWndPtr(wndPtr);
2344     return retvalue;
2345
2346 }
2347
2348 /*****************************************************************
2349  *         WIN_GetTopParent
2350  *
2351  * Get the top-level parent for a child window.
2352  * returns a locked pointer
2353  */
2354 WND* WIN_GetTopParentPtr( WND* pWnd )
2355 {
2356     WND *tmpWnd = WIN_LockWndPtr(pWnd);
2357
2358     while( tmpWnd && (tmpWnd->dwStyle & WS_CHILD))
2359     {
2360         WIN_UpdateWndPtr(&tmpWnd,tmpWnd->parent);
2361     }
2362     return tmpWnd;
2363 }
2364
2365 /*****************************************************************
2366  *         WIN_GetTopParent
2367  *
2368  * Get the top-level parent for a child window.
2369  */
2370 HWND WIN_GetTopParent( HWND hwnd )
2371 {
2372     HWND retvalue;
2373     WND *tmpPtr = WIN_FindWndPtr(hwnd);
2374     WND *wndPtr = WIN_GetTopParentPtr (tmpPtr );
2375
2376     retvalue = wndPtr ? wndPtr->hwndSelf : 0;
2377     WIN_ReleaseWndPtr(tmpPtr);
2378     WIN_ReleaseWndPtr(wndPtr);
2379     return retvalue;
2380 }
2381
2382
2383 /*****************************************************************
2384  *              SetParent (USER.233)
2385  */
2386 HWND16 WINAPI SetParent16( HWND16 hwndChild, HWND16 hwndNewParent )
2387 {
2388     return SetParent( hwndChild, hwndNewParent );
2389 }
2390
2391
2392 /*****************************************************************
2393  *              SetParent (USER32.@)
2394  */
2395 HWND WINAPI SetParent( HWND hwndChild, HWND hwndNewParent )
2396 {
2397   WND *wndPtr;
2398   DWORD dwStyle;
2399   WND *pWndNewParent;
2400   WND *pWndOldParent;
2401   HWND retvalue;
2402
2403
2404   if(!(wndPtr = WIN_FindWndPtr(hwndChild))) return 0;
2405
2406   dwStyle = wndPtr->dwStyle;
2407
2408   pWndNewParent = hwndNewParent ? WIN_FindWndPtr(hwndNewParent)
2409                                 : WIN_LockWndPtr(pWndDesktop);
2410
2411   /* Windows hides the window first, then shows it again
2412    * including the WM_SHOWWINDOW messages and all */
2413   if (dwStyle & WS_VISIBLE)
2414       ShowWindow( hwndChild, SW_HIDE );
2415
2416   pWndOldParent = WIN_LockWndPtr((*wndPtr->pDriver->pSetParent)(wndPtr, pWndNewParent));
2417
2418   /* SetParent additionally needs to make hwndChild the topmost window
2419      in the x-order and send the expected WM_WINDOWPOSCHANGING and
2420      WM_WINDOWPOSCHANGED notification messages.
2421   */
2422   SetWindowPos( hwndChild, HWND_TOPMOST, 0, 0, 0, 0,
2423       SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|((dwStyle & WS_VISIBLE)?SWP_SHOWWINDOW:0));
2424   /* FIXME: a WM_MOVE is also generated (in the DefWindowProc handler
2425    * for WM_WINDOWPOSCHANGED) in Windows, should probably remove SWP_NOMOVE */
2426
2427   retvalue = pWndOldParent?pWndOldParent->hwndSelf:0;
2428
2429   WIN_ReleaseWndPtr(pWndOldParent);
2430   WIN_ReleaseWndPtr(pWndNewParent);
2431   WIN_ReleaseWndPtr(wndPtr);
2432
2433   return retvalue;
2434
2435 }
2436
2437 /*******************************************************************
2438  *              IsChild (USER.48)
2439  */
2440 BOOL16 WINAPI IsChild16( HWND16 parent, HWND16 child )
2441 {
2442     return IsChild(parent,child);
2443 }
2444
2445
2446 /*******************************************************************
2447  *              IsChild (USER32.@)
2448  */
2449 BOOL WINAPI IsChild( HWND parent, HWND child )
2450 {
2451     WND * wndPtr = WIN_FindWndPtr( child );
2452     while (wndPtr && wndPtr->parent)
2453     {
2454         WIN_UpdateWndPtr(&wndPtr,wndPtr->parent);
2455         if (wndPtr->hwndSelf == GetDesktopWindow()) break;
2456         if (wndPtr->hwndSelf == parent)
2457         {
2458             WIN_ReleaseWndPtr(wndPtr);
2459             return TRUE;
2460         }
2461     }
2462     WIN_ReleaseWndPtr(wndPtr);
2463     return FALSE;
2464 }
2465
2466
2467 /***********************************************************************
2468  *              IsWindowVisible (USER.49)
2469  */
2470 BOOL16 WINAPI IsWindowVisible16( HWND16 hwnd )
2471 {
2472     return IsWindowVisible(hwnd);
2473 }
2474
2475
2476 /***********************************************************************
2477  *              IsWindowVisible (USER32.@)
2478  */
2479 BOOL WINAPI IsWindowVisible( HWND hwnd )
2480 {
2481     BOOL retval;
2482     WND *wndPtr = WIN_FindWndPtr( hwnd );
2483     while (wndPtr && wndPtr->parent)
2484     {
2485         if (!(wndPtr->dwStyle & WS_VISIBLE))
2486     {
2487             WIN_ReleaseWndPtr(wndPtr);
2488             return FALSE;
2489         }
2490         WIN_UpdateWndPtr(&wndPtr,wndPtr->parent);
2491     }
2492     retval = (wndPtr && (wndPtr->dwStyle & WS_VISIBLE));
2493     WIN_ReleaseWndPtr(wndPtr);
2494     return retval;
2495 }
2496
2497
2498 /***********************************************************************
2499  *           WIN_IsWindowDrawable
2500  *
2501  * hwnd is drawable when it is visible, all parents are not
2502  * minimized, and it is itself not minimized unless we are
2503  * trying to draw its default class icon.
2504  */
2505 BOOL WIN_IsWindowDrawable( WND* wnd, BOOL icon )
2506 {
2507   if (!(wnd->dwStyle & WS_VISIBLE)) return FALSE;
2508   if ((wnd->dwStyle & WS_MINIMIZE) &&
2509        icon && GetClassLongA( wnd->hwndSelf, GCL_HICON ))  return FALSE;
2510   for(wnd = wnd->parent; wnd; wnd = wnd->parent)
2511     if( wnd->dwStyle & WS_MINIMIZE ||
2512       !(wnd->dwStyle & WS_VISIBLE) ) break;
2513   return (wnd == NULL);
2514 }
2515
2516
2517 /*******************************************************************
2518  *              GetTopWindow (USER.229)
2519  */
2520 HWND16 WINAPI GetTopWindow16( HWND16 hwnd )
2521 {
2522     return GetTopWindow(hwnd);
2523 }
2524
2525
2526 /*******************************************************************
2527  *              GetTopWindow (USER32.@)
2528  */
2529 HWND WINAPI GetTopWindow( HWND hwnd )
2530 {
2531     HWND retval = 0;
2532     WND * wndPtr = (hwnd) ?
2533                    WIN_FindWndPtr( hwnd ) : WIN_GetDesktop();
2534
2535     if (wndPtr && wndPtr->child)
2536         retval = wndPtr->child->hwndSelf;
2537
2538     WIN_ReleaseWndPtr(wndPtr);
2539     return retval;
2540 }
2541
2542
2543 /*******************************************************************
2544  *              GetWindow (USER.262)
2545  */
2546 HWND16 WINAPI GetWindow16( HWND16 hwnd, WORD rel )
2547 {
2548     return GetWindow( hwnd,rel );
2549 }
2550
2551
2552 /*******************************************************************
2553  *              GetWindow (USER32.@)
2554  */
2555 HWND WINAPI GetWindow( HWND hwnd, WORD rel )
2556 {
2557     HWND retval;
2558
2559     WND * wndPtr = WIN_FindWndPtr( hwnd );
2560     if (!wndPtr) return 0;
2561     switch(rel)
2562     {
2563     case GW_HWNDFIRST:
2564         retval = wndPtr->parent ? wndPtr->parent->child->hwndSelf : 0;
2565         goto end;
2566
2567     case GW_HWNDLAST:
2568         if (!wndPtr->parent)
2569         {
2570             retval = 0;  /* Desktop window */
2571             goto end;
2572         }
2573         while (wndPtr->next)
2574         {
2575             WIN_UpdateWndPtr(&wndPtr,wndPtr->next);
2576         }
2577         retval = wndPtr->hwndSelf;
2578         goto end;
2579
2580     case GW_HWNDNEXT:
2581         retval = wndPtr->next ? wndPtr->next->hwndSelf : 0;
2582         goto end;
2583
2584     case GW_HWNDPREV:
2585         if (!wndPtr->parent)
2586         {
2587             retval = 0;  /* Desktop window */
2588             goto end;
2589         }
2590         WIN_UpdateWndPtr(&wndPtr,wndPtr->parent->child); /* First sibling */
2591         if (wndPtr->hwndSelf == hwnd)
2592         {
2593             retval = 0;  /* First in list */
2594             goto end;
2595         }
2596         while (wndPtr->next)
2597         {
2598             if (wndPtr->next->hwndSelf == hwnd)
2599             {
2600                 retval = wndPtr->hwndSelf;
2601                 goto end;
2602             }
2603             WIN_UpdateWndPtr(&wndPtr,wndPtr->next);
2604         }
2605         retval = 0;
2606         goto end;
2607
2608     case GW_OWNER:
2609         retval = wndPtr->owner ? wndPtr->owner->hwndSelf : 0;
2610         goto end;
2611
2612     case GW_CHILD:
2613         retval = wndPtr->child ? wndPtr->child->hwndSelf : 0;
2614         goto end;
2615     }
2616     retval = 0;
2617 end:
2618     WIN_ReleaseWndPtr(wndPtr);
2619     return retval;
2620 }
2621
2622
2623 /*******************************************************************
2624  *              GetNextWindow (USER.230)
2625  */
2626 HWND16 WINAPI GetNextWindow16( HWND16 hwnd, WORD flag )
2627 {
2628     if ((flag != GW_HWNDNEXT) && (flag != GW_HWNDPREV)) return 0;
2629     return GetWindow16( hwnd, flag );
2630 }
2631
2632 /***********************************************************************
2633  *           WIN_InternalShowOwnedPopups
2634  *
2635  * Internal version of ShowOwnedPopups; Wine functions should use this
2636  * to avoid interfering with application calls to ShowOwnedPopups
2637  * and to make sure the application can't prevent showing/hiding.
2638  *
2639  * Set unmanagedOnly to TRUE to show/hide unmanaged windows only.
2640  *
2641  */
2642
2643 BOOL WIN_InternalShowOwnedPopups( HWND owner, BOOL fShow, BOOL unmanagedOnly )
2644 {
2645     INT totalChild=0, count=0;
2646
2647     WND **pWnd = WIN_BuildWinArray(WIN_GetDesktop(), 0, &totalChild);
2648
2649     if (!pWnd) return TRUE;
2650
2651     /*
2652      * Show windows Lowest first, Highest last to preserve Z-Order
2653      */
2654     for (count = totalChild-1 ; count >=0; count--)
2655     {
2656         if (pWnd[count]->owner && (pWnd[count]->owner->hwndSelf == owner) && (pWnd[count]->dwStyle & WS_POPUP))
2657         {
2658             if (fShow)
2659             {
2660                 /* check in window was flagged for showing in previous WIN_InternalShowOwnedPopups call */
2661                 if (pWnd[count]->flags & WIN_NEEDS_INTERNALSOP)
2662                 {
2663                     /*
2664                      * Call ShowWindow directly because an application can intercept WM_SHOWWINDOW messages
2665                      */
2666                     ShowWindow(pWnd[count]->hwndSelf,SW_SHOW);
2667                     pWnd[count]->flags &= ~WIN_NEEDS_INTERNALSOP; /* remove the flag */
2668                 }
2669             }
2670             else
2671             {
2672                 if ( IsWindowVisible(pWnd[count]->hwndSelf) &&                   /* hide only if window is visible */
2673                      !( pWnd[count]->flags & WIN_NEEDS_INTERNALSOP ) &&          /* don't hide if previous call already did it */
2674                      !( unmanagedOnly && (pWnd[count]->dwExStyle & WS_EX_MANAGED) ) ) /* don't hide managed windows if unmanagedOnly is TRUE */
2675                 {
2676                     /*
2677                      * Call ShowWindow directly because an application can intercept WM_SHOWWINDOW messages
2678                      */
2679                     ShowWindow(pWnd[count]->hwndSelf,SW_HIDE);
2680                     /* flag the window for showing on next WIN_InternalShowOwnedPopups call */
2681                     pWnd[count]->flags |= WIN_NEEDS_INTERNALSOP;
2682                 }
2683             }
2684         }
2685     }
2686     WIN_ReleaseDesktop();
2687     WIN_ReleaseWinArray(pWnd);
2688
2689     return TRUE;
2690 }
2691
2692 /*******************************************************************
2693  *              ShowOwnedPopups (USER.265)
2694  */
2695 void WINAPI ShowOwnedPopups16( HWND16 owner, BOOL16 fShow )
2696 {
2697     ShowOwnedPopups( owner, fShow );
2698 }
2699
2700
2701 /*******************************************************************
2702  *              ShowOwnedPopups (USER32.@)
2703  */
2704 BOOL WINAPI ShowOwnedPopups( HWND owner, BOOL fShow )
2705 {
2706     UINT totalChild=0, count=0;
2707
2708     WND **pWnd = WIN_BuildWinArray(WIN_GetDesktop(), 0, &totalChild);
2709
2710     if (!pWnd) return TRUE;
2711
2712     for (; count < totalChild; count++)
2713     {
2714         if (pWnd[count]->owner && (pWnd[count]->owner->hwndSelf == owner) && (pWnd[count]->dwStyle & WS_POPUP))
2715         {
2716             if (fShow)
2717             {
2718                 if (pWnd[count]->flags & WIN_NEEDS_SHOW_OWNEDPOPUP)
2719                 {
2720                     /*
2721                      * In Windows, ShowOwnedPopups(TRUE) generates WM_SHOWWINDOW messages with SW_PARENTOPENING,
2722                      * regardless of the state of the owner
2723                      */
2724                     SendMessageA(pWnd[count]->hwndSelf, WM_SHOWWINDOW, SW_SHOW, SW_PARENTOPENING);
2725                     pWnd[count]->flags &= ~WIN_NEEDS_SHOW_OWNEDPOPUP;
2726                 }
2727             }
2728             else
2729             {
2730                 if (IsWindowVisible(pWnd[count]->hwndSelf))
2731                 {
2732                     /*
2733                      * In Windows, ShowOwnedPopups(FALSE) generates WM_SHOWWINDOW messages with SW_PARENTCLOSING,
2734                      * regardless of the state of the owner
2735                      */
2736                     SendMessageA(pWnd[count]->hwndSelf, WM_SHOWWINDOW, SW_HIDE, SW_PARENTCLOSING);
2737                     pWnd[count]->flags |= WIN_NEEDS_SHOW_OWNEDPOPUP;
2738                 }
2739             }
2740         }
2741     }
2742
2743     WIN_ReleaseDesktop();
2744     WIN_ReleaseWinArray(pWnd);
2745     return TRUE;
2746 }
2747
2748
2749 /*******************************************************************
2750  *              GetLastActivePopup (USER.287)
2751  */
2752 HWND16 WINAPI GetLastActivePopup16( HWND16 hwnd )
2753 {
2754     return GetLastActivePopup( hwnd );
2755 }
2756
2757 /*******************************************************************
2758  *              GetLastActivePopup (USER32.@)
2759  */
2760 HWND WINAPI GetLastActivePopup( HWND hwnd )
2761 {
2762     HWND retval;
2763     WND *wndPtr =WIN_FindWndPtr(hwnd);
2764     if (!wndPtr) return hwnd;
2765     retval = wndPtr->hwndLastActive;
2766     WIN_ReleaseWndPtr(wndPtr);
2767     if ((retval != hwnd) && (!IsWindow(retval)))
2768        retval = hwnd;
2769     return retval;
2770 }
2771
2772
2773 /*******************************************************************
2774  *           WIN_BuildWinArray
2775  *
2776  * Build an array of pointers to the children of a given window.
2777  * The array must be freed with WIN_ReleaseWinArray. Return NULL
2778  * when no windows are found.
2779  */
2780 WND **WIN_BuildWinArray( WND *wndPtr, UINT bwaFlags, UINT* pTotal )
2781 {
2782     /* Future: this function will lock all windows associated with this array */
2783
2784     WND **list, **ppWnd;
2785     WND *pWnd;
2786     UINT count = 0, skipOwned, skipHidden;
2787     DWORD skipFlags;
2788
2789     skipHidden = bwaFlags & BWA_SKIPHIDDEN;
2790     skipOwned = bwaFlags & BWA_SKIPOWNED;
2791     skipFlags = (bwaFlags & BWA_SKIPDISABLED) ? WS_DISABLED : 0;
2792     if( bwaFlags & BWA_SKIPICONIC ) skipFlags |= WS_MINIMIZE;
2793
2794     /* First count the windows */
2795
2796     if (!wndPtr)
2797         wndPtr = WIN_GetDesktop();
2798
2799     pWnd = WIN_LockWndPtr(wndPtr->child);
2800     while (pWnd)
2801     {
2802         if( !(pWnd->dwStyle & skipFlags) && !(skipOwned && pWnd->owner) &&
2803            (!skipHidden || (pWnd->dwStyle & WS_VISIBLE)) )
2804             count++;
2805         WIN_UpdateWndPtr(&pWnd,pWnd->next);
2806     }
2807
2808     if( count )
2809     {
2810         /* Now build the list of all windows */
2811
2812         if ((list = (WND **)HeapAlloc( GetProcessHeap(), 0, sizeof(WND *) * (count + 1))))
2813         {
2814             for (pWnd = WIN_LockWndPtr(wndPtr->child), ppWnd = list, count = 0; pWnd; WIN_UpdateWndPtr(&pWnd,pWnd->next))
2815             {
2816                 if( (pWnd->dwStyle & skipFlags) || (skipOwned && pWnd->owner) );
2817                 else if( !skipHidden || pWnd->dwStyle & WS_VISIBLE )
2818                 {
2819                    *ppWnd++ = pWnd;
2820                     count++;
2821                 }
2822             }
2823             WIN_ReleaseWndPtr(pWnd);
2824            *ppWnd = NULL;
2825         }
2826         else count = 0;
2827     } else list = NULL;
2828
2829     if( pTotal ) *pTotal = count;
2830     return list;
2831 }
2832 /*******************************************************************
2833  *           WIN_ReleaseWinArray
2834  */
2835 void WIN_ReleaseWinArray(WND **wndArray)
2836 {
2837     /* Future: this function will also unlock all windows associated with wndArray */
2838      HeapFree( GetProcessHeap(), 0, wndArray );
2839
2840 }
2841
2842 /*******************************************************************
2843  *              EnumWindows (USER32.@)
2844  */
2845 BOOL WINAPI EnumWindows( WNDENUMPROC lpEnumFunc, LPARAM lParam )
2846 {
2847     WND **list, **ppWnd;
2848
2849     /* We have to build a list of all windows first, to avoid */
2850     /* unpleasant side-effects, for instance if the callback */
2851     /* function changes the Z-order of the windows.          */
2852
2853     if (!(list = WIN_BuildWinArray(WIN_GetDesktop(), 0, NULL )))
2854     {
2855         WIN_ReleaseDesktop();
2856         return FALSE;
2857     }
2858
2859     /* Now call the callback function for every window */
2860
2861     for (ppWnd = list; *ppWnd; ppWnd++)
2862     {
2863         LRESULT lpEnumFuncRetval;
2864         int iWndsLocks = 0;
2865         /* Make sure that the window still exists */
2866         if (!IsWindow((*ppWnd)->hwndSelf)) continue;
2867
2868         /* To avoid any deadlocks, all the locks on the windows
2869            structures must be suspended before the control
2870            is passed to the application */
2871         iWndsLocks = WIN_SuspendWndsLock();
2872         lpEnumFuncRetval = lpEnumFunc( (*ppWnd)->hwndSelf, lParam);
2873         WIN_RestoreWndsLock(iWndsLocks);
2874
2875         if (!lpEnumFuncRetval) break;
2876     }
2877     WIN_ReleaseWinArray(list);
2878     WIN_ReleaseDesktop();
2879     return TRUE;
2880 }
2881
2882
2883 /**********************************************************************
2884  *              WIN_EnumQueueWindows
2885  *
2886  * Helper for EnumTaskWindows16 and EnumThreadWindows.
2887  */
2888 static BOOL WIN_EnumQueueWindows( HQUEUE16 queue, WNDENUMPROC func, LPARAM lParam )
2889 {
2890     WND **list, **ppWnd;
2891
2892     /* This function is the same as EnumWindows(),    */
2893     /* except for an added check on the window's task. */
2894
2895     if (!(list = WIN_BuildWinArray( WIN_GetDesktop(), 0, NULL )))
2896     {
2897         WIN_ReleaseDesktop();
2898         return FALSE;
2899     }
2900
2901     /* Now call the callback function for every window */
2902
2903     for (ppWnd = list; *ppWnd; ppWnd++)
2904     {
2905         LRESULT funcRetval;
2906         int iWndsLocks = 0;
2907         /* Make sure that the window still exists */
2908         if (!IsWindow((*ppWnd)->hwndSelf)) continue;
2909         if ((*ppWnd)->hmemTaskQ != queue) continue;
2910
2911         /* To avoid any deadlocks, all the locks on the windows
2912            structures must be suspended before the control
2913            is passed to the application */
2914         iWndsLocks = WIN_SuspendWndsLock();
2915         funcRetval = func( (*ppWnd)->hwndSelf, lParam );
2916         WIN_RestoreWndsLock(iWndsLocks);
2917
2918         if (!funcRetval) break;
2919     }
2920     WIN_ReleaseWinArray(list);
2921     WIN_ReleaseDesktop();
2922     return TRUE;
2923 }
2924
2925
2926 /**********************************************************************
2927  *              EnumTaskWindows16   (USER.225)
2928  */
2929 BOOL16 WINAPI EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func,
2930                                  LPARAM lParam )
2931 {
2932     HQUEUE16 queue = GetTaskQueue16( hTask );
2933     if (!queue) return FALSE;
2934     return WIN_EnumQueueWindows( queue, (WNDENUMPROC)func, lParam );
2935 }
2936
2937
2938 /**********************************************************************
2939  *              EnumThreadWindows (USER32.@)
2940  */
2941 BOOL WINAPI EnumThreadWindows( DWORD id, WNDENUMPROC func, LPARAM lParam )
2942 {
2943     HQUEUE16 queue = GetThreadQueue16( id );
2944     if (!queue) return FALSE;
2945     return WIN_EnumQueueWindows( queue, func, lParam );
2946 }
2947
2948
2949 /**********************************************************************
2950  *           WIN_EnumChildWindows
2951  *
2952  * Helper function for EnumChildWindows().
2953  */
2954 static BOOL16 WIN_EnumChildWindows( WND **ppWnd, WNDENUMPROC func, LPARAM lParam )
2955 {
2956     WND **childList;
2957     BOOL16 ret = FALSE;
2958
2959     for ( ; *ppWnd; ppWnd++)
2960     {
2961         int iWndsLocks = 0;
2962
2963         /* Make sure that the window still exists */
2964         if (!IsWindow((*ppWnd)->hwndSelf)) continue;
2965         /* Build children list first */
2966         childList = WIN_BuildWinArray( *ppWnd, BWA_SKIPOWNED, NULL );
2967
2968         /* To avoid any deadlocks, all the locks on the windows
2969            structures must be suspended before the control
2970            is passed to the application */
2971         iWndsLocks = WIN_SuspendWndsLock();
2972         ret = func( (*ppWnd)->hwndSelf, lParam );
2973         WIN_RestoreWndsLock(iWndsLocks);
2974
2975         if (childList)
2976         {
2977             if (ret) ret = WIN_EnumChildWindows( childList, func, lParam );
2978             WIN_ReleaseWinArray(childList);
2979         }
2980         if (!ret) return FALSE;
2981     }
2982     return TRUE;
2983 }
2984
2985
2986 /**********************************************************************
2987  *              EnumChildWindows (USER32.@)
2988  */
2989 BOOL WINAPI EnumChildWindows( HWND parent, WNDENUMPROC func,
2990                                   LPARAM lParam )
2991 {
2992     WND **list, *pParent;
2993
2994     if (!(pParent = WIN_FindWndPtr( parent ))) return FALSE;
2995     if (!(list = WIN_BuildWinArray( pParent, BWA_SKIPOWNED, NULL )))
2996     {
2997         WIN_ReleaseWndPtr(pParent);
2998         return FALSE;
2999     }
3000     WIN_EnumChildWindows( list, func, lParam );
3001     WIN_ReleaseWinArray(list);
3002     WIN_ReleaseWndPtr(pParent);
3003     return TRUE;
3004 }
3005
3006
3007 /*******************************************************************
3008  *              AnyPopup (USER.52)
3009  */
3010 BOOL16 WINAPI AnyPopup16(void)
3011 {
3012     return AnyPopup();
3013 }
3014
3015
3016 /*******************************************************************
3017  *              AnyPopup (USER32.@)
3018  */
3019 BOOL WINAPI AnyPopup(void)
3020 {
3021     WND *wndPtr = WIN_LockWndPtr(pWndDesktop->child);
3022     BOOL retvalue;
3023
3024     while (wndPtr)
3025     {
3026         if (wndPtr->owner && (wndPtr->dwStyle & WS_VISIBLE))
3027         {
3028             retvalue = TRUE;
3029             goto end;
3030         }
3031         WIN_UpdateWndPtr(&wndPtr,wndPtr->next);
3032     }
3033     retvalue = FALSE;
3034 end:
3035     WIN_ReleaseWndPtr(wndPtr);
3036     return retvalue;
3037 }
3038
3039
3040 /*******************************************************************
3041  *              FlashWindow (USER.105)
3042  */
3043 BOOL16 WINAPI FlashWindow16( HWND16 hWnd, BOOL16 bInvert )
3044 {
3045     return FlashWindow( hWnd, bInvert );
3046 }
3047
3048
3049 /*******************************************************************
3050  *              FlashWindow (USER32.@)
3051  */
3052 BOOL WINAPI FlashWindow( HWND hWnd, BOOL bInvert )
3053 {
3054     WND *wndPtr = WIN_FindWndPtr(hWnd);
3055
3056     TRACE("%04x\n", hWnd);
3057
3058     if (!wndPtr) return FALSE;
3059
3060     if (wndPtr->dwStyle & WS_MINIMIZE)
3061     {
3062         if (bInvert && !(wndPtr->flags & WIN_NCACTIVATED))
3063         {
3064             HDC hDC = GetDC(hWnd);
3065
3066             if (!SendMessage16( hWnd, WM_ERASEBKGND, (WPARAM16)hDC, 0 ))
3067                 wndPtr->flags |= WIN_NEEDS_ERASEBKGND;
3068
3069             ReleaseDC( hWnd, hDC );
3070             wndPtr->flags |= WIN_NCACTIVATED;
3071         }
3072         else
3073         {
3074             PAINT_RedrawWindow( hWnd, 0, 0, RDW_INVALIDATE | RDW_ERASE |
3075                                           RDW_UPDATENOW | RDW_FRAME, 0 );
3076             wndPtr->flags &= ~WIN_NCACTIVATED;
3077         }
3078         WIN_ReleaseWndPtr(wndPtr);
3079         return TRUE;
3080     }
3081     else
3082     {
3083         WPARAM16 wparam;
3084         if (bInvert) wparam = !(wndPtr->flags & WIN_NCACTIVATED);
3085         else wparam = (hWnd == GetActiveWindow());
3086
3087         SendMessage16( hWnd, WM_NCACTIVATE, wparam, (LPARAM)0 );
3088         WIN_ReleaseWndPtr(wndPtr);
3089         return wparam;
3090     }
3091 }
3092
3093
3094 /*******************************************************************
3095  *              SetSysModalWindow (USER.188)
3096  */
3097 HWND16 WINAPI SetSysModalWindow16( HWND16 hWnd )
3098 {
3099     HWND hWndOldModal = hwndSysModal;
3100     hwndSysModal = hWnd;
3101     FIXME("EMPTY STUB !! SetSysModalWindow(%04x) !\n", hWnd);
3102     return hWndOldModal;
3103 }
3104
3105
3106 /*******************************************************************
3107  *              GetSysModalWindow (USER.189)
3108  */
3109 HWND16 WINAPI GetSysModalWindow16(void)
3110 {
3111     return hwndSysModal;
3112 }
3113
3114
3115 /*******************************************************************
3116  *              GetWindowContextHelpId (USER32.@)
3117  */
3118 DWORD WINAPI GetWindowContextHelpId( HWND hwnd )
3119 {
3120     DWORD retval;
3121     WND *wnd = WIN_FindWndPtr( hwnd );
3122     if (!wnd) return 0;
3123     retval = wnd->helpContext;
3124     WIN_ReleaseWndPtr(wnd);
3125     return retval;
3126 }
3127
3128
3129 /*******************************************************************
3130  *              SetWindowContextHelpId (USER32.@)
3131  */
3132 BOOL WINAPI SetWindowContextHelpId( HWND hwnd, DWORD id )
3133 {
3134     WND *wnd = WIN_FindWndPtr( hwnd );
3135     if (!wnd) return FALSE;
3136     wnd->helpContext = id;
3137     WIN_ReleaseWndPtr(wnd);
3138     return TRUE;
3139 }
3140
3141
3142 /*******************************************************************
3143  *                      DRAG_QueryUpdate
3144  *
3145  * recursively find a child that contains spDragInfo->pt point
3146  * and send WM_QUERYDROPOBJECT
3147  */
3148 BOOL16 DRAG_QueryUpdate( HWND hQueryWnd, SEGPTR spDragInfo, BOOL bNoSend )
3149 {
3150  BOOL16         wParam, bResult = 0;
3151  POINT        pt;
3152  LPDRAGINFO16   ptrDragInfo = MapSL(spDragInfo);
3153  WND           *ptrQueryWnd = WIN_FindWndPtr(hQueryWnd),*ptrWnd;
3154  RECT           tempRect;
3155
3156  if( !ptrQueryWnd || !ptrDragInfo )
3157     goto end;
3158
3159  CONV_POINT16TO32( &ptrDragInfo->pt, &pt );
3160
3161  GetWindowRect(hQueryWnd,&tempRect);
3162
3163  if( !PtInRect(&tempRect,pt) ||
3164      (ptrQueryWnd->dwStyle & WS_DISABLED) )
3165     goto end;
3166
3167  if( !(ptrQueryWnd->dwStyle & WS_MINIMIZE) )
3168    {
3169      tempRect = ptrQueryWnd->rectClient;
3170      if(ptrQueryWnd->parent)
3171         MapWindowPoints( ptrQueryWnd->parent->hwndSelf, 0,
3172                            (LPPOINT)&tempRect, 2 );
3173
3174      if (PtInRect( &tempRect, pt))
3175         {
3176          wParam = 0;
3177
3178          for (ptrWnd = WIN_LockWndPtr(ptrQueryWnd->child); ptrWnd ;WIN_UpdateWndPtr(&ptrWnd,ptrWnd->next))
3179          {
3180              if( ptrWnd->dwStyle & WS_VISIBLE )
3181              {
3182                  GetWindowRect( ptrWnd->hwndSelf, &tempRect );
3183                  if (PtInRect( &tempRect, pt )) break;
3184              }
3185          }
3186
3187          if(ptrWnd)
3188          {
3189             TRACE_(msg)("hwnd = %04x, %d %d - %d %d\n",
3190                         ptrWnd->hwndSelf, ptrWnd->rectWindow.left, ptrWnd->rectWindow.top,
3191                         ptrWnd->rectWindow.right, ptrWnd->rectWindow.bottom );
3192             if( !(ptrWnd->dwStyle & WS_DISABLED) )
3193                 bResult = DRAG_QueryUpdate(ptrWnd->hwndSelf, spDragInfo, bNoSend);
3194
3195             WIN_ReleaseWndPtr(ptrWnd);
3196          }
3197
3198          if(bResult)
3199             goto end;
3200         }
3201      else wParam = 1;
3202    }
3203  else wParam = 1;
3204
3205  ScreenToClient16(hQueryWnd,&ptrDragInfo->pt);
3206
3207  ptrDragInfo->hScope = hQueryWnd;
3208
3209  bResult = ( bNoSend )
3210            ? ptrQueryWnd->dwExStyle & WS_EX_ACCEPTFILES
3211            : SendMessage16( hQueryWnd ,WM_QUERYDROPOBJECT ,
3212                           (WPARAM16)wParam ,(LPARAM) spDragInfo );
3213  if( !bResult )
3214      CONV_POINT32TO16( &pt, &ptrDragInfo->pt );
3215
3216 end:
3217  WIN_ReleaseWndPtr(ptrQueryWnd);
3218  return bResult;
3219 }
3220
3221
3222 /*******************************************************************
3223  *              DragDetect (USER.465)
3224  */
3225 BOOL16 WINAPI DragDetect16( HWND16 hWnd, POINT16 pt )
3226 {
3227     POINT pt32;
3228     CONV_POINT16TO32( &pt, &pt32 );
3229     return DragDetect( hWnd, pt32 );
3230 }
3231
3232 /*******************************************************************
3233  *              DragDetect (USER32.@)
3234  */
3235 BOOL WINAPI DragDetect( HWND hWnd, POINT pt )
3236 {
3237     MSG msg;
3238     RECT rect;
3239
3240     rect.left = pt.x - wDragWidth;
3241     rect.right = pt.x + wDragWidth;
3242
3243     rect.top = pt.y - wDragHeight;
3244     rect.bottom = pt.y + wDragHeight;
3245
3246     SetCapture(hWnd);
3247
3248     while(1)
3249     {
3250         while(PeekMessageA(&msg ,0 ,WM_MOUSEFIRST ,WM_MOUSELAST ,PM_REMOVE))
3251         {
3252             if( msg.message == WM_LBUTTONUP )
3253             {
3254                 ReleaseCapture();
3255                 return 0;
3256             }
3257             if( msg.message == WM_MOUSEMOVE )
3258             {
3259                 POINT tmp;
3260                 tmp.x = LOWORD(msg.lParam);
3261                 tmp.y = HIWORD(msg.lParam);
3262                 if( !PtInRect( &rect, tmp ))
3263                 {
3264                     ReleaseCapture();
3265                     return 1;
3266                 }
3267             }
3268         }
3269         WaitMessage();
3270     }
3271     return 0;
3272 }
3273
3274 /******************************************************************************
3275  *              DragObject (USER.464)
3276  */
3277 DWORD WINAPI DragObject16( HWND16 hwndScope, HWND16 hWnd, UINT16 wObj,
3278                            HANDLE16 hOfStruct, WORD szList, HCURSOR16 hCursor )
3279 {
3280     MSG msg;
3281     LPDRAGINFO16 lpDragInfo;
3282     SEGPTR      spDragInfo;
3283     HCURSOR16   hDragCursor=0, hOldCursor=0, hBummer=0;
3284     HGLOBAL16   hDragInfo  = GlobalAlloc16( GMEM_SHARE | GMEM_ZEROINIT, 2*sizeof(DRAGINFO16));
3285     WND        *wndPtr = WIN_FindWndPtr(hWnd);
3286     HCURSOR16   hCurrentCursor = 0;
3287     HWND16      hCurrentWnd = 0;
3288
3289     lpDragInfo = (LPDRAGINFO16) GlobalLock16(hDragInfo);
3290     spDragInfo = K32WOWGlobalLock16(hDragInfo);
3291
3292     if( !lpDragInfo || !spDragInfo )
3293     {
3294         WIN_ReleaseWndPtr(wndPtr);
3295         return 0L;
3296     }
3297
3298     hBummer = LoadCursorA(0, MAKEINTRESOURCEA(OCR_NO));
3299
3300     if( !hBummer || !wndPtr )
3301     {
3302         GlobalFree16(hDragInfo);
3303         WIN_ReleaseWndPtr(wndPtr);
3304         return 0L;
3305     }
3306
3307     if(hCursor)
3308     {
3309         if( !(hDragCursor = CURSORICON_IconToCursor(hCursor, FALSE)) )
3310         {
3311             GlobalFree16(hDragInfo);
3312             WIN_ReleaseWndPtr(wndPtr);
3313             return 0L;
3314         }
3315
3316         if( hDragCursor == hCursor ) hDragCursor = 0;
3317         else hCursor = hDragCursor;
3318
3319         hOldCursor = SetCursor(hDragCursor);
3320     }
3321
3322     lpDragInfo->hWnd   = hWnd;
3323     lpDragInfo->hScope = 0;
3324     lpDragInfo->wFlags = wObj;
3325     lpDragInfo->hList  = szList; /* near pointer! */
3326     lpDragInfo->hOfStruct = hOfStruct;
3327     lpDragInfo->l = 0L;
3328
3329     SetCapture(hWnd);
3330     ShowCursor( TRUE );
3331
3332     do
3333     {
3334         do{  WaitMessage(); }
3335         while( !PeekMessageA(&msg,0,WM_MOUSEFIRST,WM_MOUSELAST,PM_REMOVE) );
3336
3337        *(lpDragInfo+1) = *lpDragInfo;
3338
3339         lpDragInfo->pt.x = msg.pt.x;
3340         lpDragInfo->pt.y = msg.pt.y;
3341
3342         /* update DRAGINFO struct */
3343         TRACE_(msg)("lpDI->hScope = %04x\n",lpDragInfo->hScope);
3344
3345         if( DRAG_QueryUpdate(hwndScope, spDragInfo, FALSE) > 0 )
3346             hCurrentCursor = hCursor;
3347         else
3348         {
3349             hCurrentCursor = hBummer;
3350             lpDragInfo->hScope = 0;
3351         }
3352         if( hCurrentCursor )
3353             SetCursor(hCurrentCursor);
3354
3355         /* send WM_DRAGLOOP */
3356         SendMessage16( hWnd, WM_DRAGLOOP, (WPARAM16)(hCurrentCursor != hBummer),
3357                                           (LPARAM) spDragInfo );
3358         /* send WM_DRAGSELECT or WM_DRAGMOVE */
3359         if( hCurrentWnd != lpDragInfo->hScope )
3360         {
3361             if( hCurrentWnd )
3362                 SendMessage16( hCurrentWnd, WM_DRAGSELECT, 0,
3363                        (LPARAM)MAKELONG(LOWORD(spDragInfo)+sizeof(DRAGINFO16),
3364                                         HIWORD(spDragInfo)) );
3365             hCurrentWnd = lpDragInfo->hScope;
3366             if( hCurrentWnd )
3367                 SendMessage16( hCurrentWnd, WM_DRAGSELECT, 1, (LPARAM)spDragInfo);
3368         }
3369         else
3370             if( hCurrentWnd )
3371                 SendMessage16( hCurrentWnd, WM_DRAGMOVE, 0, (LPARAM)spDragInfo);
3372
3373     } while( msg.message != WM_LBUTTONUP && msg.message != WM_NCLBUTTONUP );
3374
3375     ReleaseCapture();
3376     ShowCursor( FALSE );
3377
3378     if( hCursor )
3379     {
3380         SetCursor( hOldCursor );
3381         if (hDragCursor) DestroyCursor( hDragCursor );
3382     }
3383
3384     if( hCurrentCursor != hBummer )
3385         msg.lParam = SendMessage16( lpDragInfo->hScope, WM_DROPOBJECT,
3386                                    (WPARAM16)hWnd, (LPARAM)spDragInfo );
3387     else
3388         msg.lParam = 0;
3389     GlobalFree16(hDragInfo);
3390     WIN_ReleaseWndPtr(wndPtr);
3391
3392     return (DWORD)(msg.lParam);
3393 }
3394
3395
3396 /******************************************************************************
3397  *              GetWindowModuleFileNameA (USER32.@)
3398  */
3399 UINT WINAPI GetWindowModuleFileNameA( HWND hwnd, LPSTR lpszFileName, UINT cchFileNameMax)
3400 {
3401     FIXME("GetWindowModuleFileNameA(hwnd 0x%x, lpszFileName %p, cchFileNameMax %u) stub!\n",
3402           hwnd, lpszFileName, cchFileNameMax);
3403     return 0;
3404 }
3405
3406 /******************************************************************************
3407  *              GetWindowModuleFileNameW (USER32.@)
3408  */
3409 UINT WINAPI GetWindowModuleFileNameW( HWND hwnd, LPSTR lpszFileName, UINT cchFileNameMax)
3410 {
3411     FIXME("GetWindowModuleFileNameW(hwnd 0x%x, lpszFileName %p, cchFileNameMax %u) stub!\n",
3412           hwnd, lpszFileName, cchFileNameMax);
3413     return 0;
3414 }