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