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