win32ss/user/user32/windows/window.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS user32.dll
   4  * FILE:            win32ss/user/user32/windows/window.c
   5  * PURPOSE:         Window management
   6  * PROGRAMMERS:     Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  *                  Katayama Hirofumi MZ (katayama.hirofumi.mz@gmail.com)
   8  * UPDATE HISTORY:
   9  *      06-06-2001  CSH  Created
  10  */
  11
  12 #define DEBUG
  13 #include <user32.h>
  14
  15 WINE_DEFAULT_DEBUG_CHANNEL(user32);
  16
  17 void MDI_CalcDefaultChildPos( HWND hwndClient, INT total, LPPOINT lpPos, INT delta, UINT *id );
  18 extern LPCWSTR FASTCALL ClassNameToVersion(const void *lpszClass, LPCWSTR lpszMenuName, LPCWSTR *plpLibFileName, HANDLE *pContext, BOOL bAnsi);
  19
  20 /* FUNCTIONS *****************************************************************/
  21
  22
  23 NTSTATUS WINAPI
  24 User32CallSendAsyncProcForKernel(PVOID Arguments, ULONG ArgumentLength)
  25 {
  26     PSENDASYNCPROC_CALLBACK_ARGUMENTS CallbackArgs;
  27
  28     TRACE("User32CallSendAsyncProcKernel()\n");
  29
  30     CallbackArgs = (PSENDASYNCPROC_CALLBACK_ARGUMENTS)Arguments;
  31
  32     if (ArgumentLength != sizeof(SENDASYNCPROC_CALLBACK_ARGUMENTS))
  33     {
  34         return(STATUS_INFO_LENGTH_MISMATCH);
  35     }
  36
  37     CallbackArgs->Callback(CallbackArgs->Wnd,
  38                            CallbackArgs->Msg,
  39                            CallbackArgs->Context,
  40                            CallbackArgs->Result);
  41     return(STATUS_SUCCESS);
  42 }
  43
  44
  45 /*
  46  * @implemented
  47  */
  48 BOOL WINAPI
  49 AllowSetForegroundWindow(DWORD dwProcessId)
  50 {
  51     return NtUserxAllowSetForegroundWindow(dwProcessId);
  52 }
  53
  54
  55 /*
  56  * @unimplemented
  57  */
  58 HDWP WINAPI
  59 BeginDeferWindowPos(int nNumWindows)
  60 {
  61     return NtUserxBeginDeferWindowPos(nNumWindows);
  62 }
  63
  64
  65 /*
  66  * @implemented
  67  */
  68 BOOL WINAPI
  69 BringWindowToTop(HWND hWnd)
  70 {
  71     return NtUserSetWindowPos(hWnd,
  72                               HWND_TOP,
  73                               0,
  74                               0,
  75                               0,
  76                               0,
  77                               SWP_NOSIZE | SWP_NOMOVE);
  78 }
  79
  80
  81 VOID WINAPI
  82 SwitchToThisWindow(HWND hwnd, BOOL fAltTab)
  83 {
  84     NtUserxSwitchToThisWindow(hwnd, fAltTab);
  85 }
  86
  87
  88 /*
  89  * @implemented
  90  */
  91 HWND WINAPI
  92 ChildWindowFromPoint(HWND hWndParent,
  93                      POINT Point)
  94 {
  95     return (HWND) NtUserChildWindowFromPointEx(hWndParent, Point.x, Point.y, 0);
  96 }
  97
  98
  99 /*
 100  * @implemented
 101  */
 102 HWND WINAPI
 103 ChildWindowFromPointEx(HWND hwndParent,
 104                        POINT pt,
 105                        UINT uFlags)
 106 {
 107     return (HWND) NtUserChildWindowFromPointEx(hwndParent, pt.x, pt.y, uFlags);
 108 }
 109
 110
 111 /*
 112  * @implemented
 113  */
 114 BOOL WINAPI
 115 CloseWindow(HWND hWnd)
 116 {
 117     /* NOTE: CloseWindow does minimizes, and doesn't close. */
 118     SetActiveWindow(hWnd);
 119     return ShowWindow(hWnd, SW_SHOWMINIMIZED);
 120 }
 121
 122 FORCEINLINE
 123 VOID
 124 RtlInitLargeString(
 125     OUT PLARGE_STRING plstr,
 126     LPCVOID psz,
 127     BOOL bUnicode)
 128 {
 129     if(bUnicode)
 130     {
 131         RtlInitLargeUnicodeString((PLARGE_UNICODE_STRING)plstr, (PWSTR)psz, 0);
 132     }
 133     else
 134     {
 135         RtlInitLargeAnsiString((PLARGE_ANSI_STRING)plstr, (PSTR)psz, 0);
 136     }
 137 }
 138
 139 VOID
 140 NTAPI
 141 RtlFreeLargeString(
 142     IN PLARGE_STRING LargeString)
 143 {
 144     if (LargeString->Buffer)
 145     {
 146         RtlFreeHeap(GetProcessHeap(), 0, LargeString->Buffer);
 147         RtlZeroMemory(LargeString, sizeof(LARGE_STRING));
 148     }
 149 }
 150
 151 DWORD
 152 FASTCALL
 153 RtlGetExpWinVer( HMODULE hModule )
 154 {
 155     DWORD dwMajorVersion = 3;  // Set default to Windows 3.10.
 156     DWORD dwMinorVersion = 10;
 157     PIMAGE_NT_HEADERS pinth;
 158
 159     if ( hModule && !((ULONG_PTR)hModule >> 16))
 160     {
 161         pinth = RtlImageNtHeader( hModule );
 162
 163         dwMajorVersion = pinth->OptionalHeader.MajorSubsystemVersion;
 164
 165         if ( dwMajorVersion == 1 )
 166         {
 167             dwMajorVersion = 3;
 168         }
 169         else
 170         {
 171             dwMinorVersion = pinth->OptionalHeader.MinorSubsystemVersion;
 172         }
 173     }
 174     return MAKELONG(MAKEWORD(dwMinorVersion, dwMajorVersion), 0);
 175 }
 176
 177 HWND WINAPI
 178 User32CreateWindowEx(DWORD dwExStyle,
 179                      LPCSTR lpClassName,
 180                      LPCSTR lpWindowName,
 181                      DWORD dwStyle,
 182                      int x,
 183                      int y,
 184                      int nWidth,
 185                      int nHeight,
 186                      HWND hWndParent,
 187                      HMENU hMenu,
 188                      HINSTANCE hInstance,
 189                      LPVOID lpParam,
 190                      DWORD dwFlags)
 191 {
 192     LARGE_STRING WindowName;
 193     LARGE_STRING lstrClassName, *plstrClassName;
 194     LARGE_STRING lstrClassVersion, *plstrClassVersion;
 195     UNICODE_STRING ClassName;
 196     UNICODE_STRING ClassVersion;
 197     WNDCLASSEXA wceA;
 198     WNDCLASSEXW wceW;
 199     HMODULE hLibModule = NULL;
 200     DWORD dwLastError;
 201     BOOL Unicode, ClassFound = FALSE;
 202     HWND Handle = NULL;
 203     LPCWSTR lpszClsVersion;
 204     LPCWSTR lpLibFileName = NULL;
 205     HANDLE pCtx = NULL;
 206     DWORD dwFlagsVer;
 207
 208 #if 0
 209     DbgPrint("[window] User32CreateWindowEx style %d, exstyle %d, parent %d\n", dwStyle, dwExStyle, hWndParent);
 210 #endif
 211
 212     dwFlagsVer = RtlGetExpWinVer( hInstance ? hInstance : GetModuleHandleW(NULL) );
 213     TRACE("Module Version %x\n",dwFlagsVer);
 214
 215     if (!RegisterDefaultClasses)
 216     {
 217         TRACE("RegisterSystemControls\n");
 218         RegisterSystemControls();
 219     }
 220
 221     Unicode = !(dwFlags & NUCWE_ANSI);
 222
 223     if (IS_ATOM(lpClassName))
 224     {
 225         plstrClassName = (PVOID)lpClassName;
 226     }
 227     else
 228     {
 229         if (Unicode)
 230         {
 231             RtlInitUnicodeString(&ClassName, (PCWSTR)lpClassName);
 232         }
 233         else
 234         {
 235             if (!RtlCreateUnicodeStringFromAsciiz(&ClassName, (PCSZ)lpClassName))
 236             {
 237                 SetLastError(ERROR_OUTOFMEMORY);
 238                 return NULL;
 239             }
 240         }
 241
 242         /* Copy it to a LARGE_STRING */
 243         lstrClassName.Buffer = ClassName.Buffer;
 244         lstrClassName.Length = ClassName.Length;
 245         lstrClassName.MaximumLength = ClassName.MaximumLength;
 246         plstrClassName = &lstrClassName;
 247     }
 248
 249     /* Initialize a LARGE_STRING */
 250     RtlInitLargeString(&WindowName, lpWindowName, Unicode);
 251
 252     // HACK: The current implementation expects the Window name to be UNICODE
 253     if (!Unicode)
 254     {
 255         NTSTATUS Status;
 256         PSTR AnsiBuffer = WindowName.Buffer;
 257         ULONG AnsiLength = WindowName.Length;
 258
 259         WindowName.Length = 0;
 260         WindowName.MaximumLength = AnsiLength * sizeof(WCHAR);
 261         WindowName.Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
 262                                             0,
 263                                             WindowName.MaximumLength);
 264         if (!WindowName.Buffer)
 265         {
 266             SetLastError(ERROR_OUTOFMEMORY);
 267             goto cleanup;
 268         }
 269
 270         Status = RtlMultiByteToUnicodeN(WindowName.Buffer,
 271                                         WindowName.MaximumLength,
 272                                         &WindowName.Length,
 273                                         AnsiBuffer,
 274                                         AnsiLength);
 275         if (!NT_SUCCESS(Status))
 276         {
 277             goto cleanup;
 278         }
 279     }
 280
 281     if (!hMenu && (dwStyle & (WS_OVERLAPPEDWINDOW | WS_POPUP)))
 282     {
 283         if (Unicode)
 284         {
 285             wceW.cbSize = sizeof(wceW);
 286             if (GetClassInfoExW(hInstance, (LPCWSTR)lpClassName, &wceW) && wceW.lpszMenuName)
 287             {
 288                 hMenu = LoadMenuW(hInstance, wceW.lpszMenuName);
 289             }
 290         }
 291         else
 292         {
 293             wceA.cbSize = sizeof(wceA);
 294             if (GetClassInfoExA(hInstance, lpClassName, &wceA) && wceA.lpszMenuName)
 295             {
 296                 hMenu = LoadMenuA(hInstance, wceA.lpszMenuName);
 297             }
 298         }
 299     }
 300
 301     if (!Unicode) dwExStyle |= WS_EX_SETANSICREATOR;
 302
 303     lpszClsVersion = ClassNameToVersion(lpClassName, NULL, &lpLibFileName, &pCtx, !Unicode);
 304     if (!lpszClsVersion)
 305     {
 306         plstrClassVersion = plstrClassName;
 307     }
 308     else
 309     {
 310         RtlInitUnicodeString(&ClassVersion, lpszClsVersion);
 311         lstrClassVersion.Buffer = ClassVersion.Buffer;
 312         lstrClassVersion.Length = ClassVersion.Length;
 313         lstrClassVersion.MaximumLength = ClassVersion.MaximumLength;
 314         plstrClassVersion = &lstrClassVersion;
 315     }
 316
 317     for (;;)
 318     {
 319         Handle = NtUserCreateWindowEx(dwExStyle,
 320                                       plstrClassName,
 321                                       plstrClassVersion,
 322                                       &WindowName,
 323                                       dwStyle,
 324                                       x,
 325                                       y,
 326                                       nWidth,
 327                                       nHeight,
 328                                       hWndParent,
 329                                       hMenu,
 330                                       hInstance,
 331                                       lpParam,
 332                                       dwFlagsVer,
 333                                       pCtx );
 334         if (Handle) break;
 335         if (!lpLibFileName) break;
 336         if (!ClassFound)
 337         {
 338             dwLastError = GetLastError();
 339             if (dwLastError == ERROR_CANNOT_FIND_WND_CLASS)
 340             {
 341                 ClassFound = VersionRegisterClass(ClassName.Buffer, lpLibFileName, pCtx, &hLibModule);
 342                 if (ClassFound) continue;
 343             }
 344         }
 345         if (hLibModule)
 346         {
 347             dwLastError = GetLastError();
 348             FreeLibrary(hLibModule);
 349             SetLastError(dwLastError);
 350             hLibModule = NULL;
 351         }
 352         break;
 353     }
 354
 355 #if 0
 356     DbgPrint("[window] NtUserCreateWindowEx() == %d\n", Handle);
 357 #endif
 358
 359 cleanup:
 360     if (!Unicode)
 361     {
 362         if (!IS_ATOM(lpClassName))
 363             RtlFreeUnicodeString(&ClassName);
 364
 365         RtlFreeLargeString(&WindowName);
 366     }
 367
 368     return Handle;
 369 }
 370
 371
 372 /*
 373  * @implemented
 374  */
 375 HWND
 376 WINAPI
 377 DECLSPEC_HOTPATCH
 378 CreateWindowExA(DWORD dwExStyle,
 379                 LPCSTR lpClassName,
 380                 LPCSTR lpWindowName,
 381                 DWORD dwStyle,
 382                 int x,
 383                 int y,
 384                 int nWidth,
 385                 int nHeight,
 386                 HWND hWndParent,
 387                 HMENU hMenu,
 388                 HINSTANCE hInstance,
 389                 LPVOID lpParam)
 390 {
 391     MDICREATESTRUCTA mdi;
 392     HWND hwnd;
 393
 394     if (!RegisterDefaultClasses)
 395     {
 396        TRACE("CreateWindowExA RegisterSystemControls\n");
 397        RegisterSystemControls();
 398     }
 399
 400     if (dwExStyle & WS_EX_MDICHILD)
 401     {
 402         POINT mPos[2];
 403         UINT id = 0;
 404         HWND top_child;
 405         PWND pWndParent;
 406
 407         pWndParent = ValidateHwnd(hWndParent);
 408
 409         if (!pWndParent) return NULL;
 410
 411         if (pWndParent->fnid != FNID_MDICLIENT) // wine uses WIN_ISMDICLIENT
 412         {
 413            WARN("WS_EX_MDICHILD, but parent %p is not MDIClient\n", hWndParent);
 414            return NULL;
 415         }
 416
 417         /* lpParams of WM_[NC]CREATE is different for MDI children.
 418         * MDICREATESTRUCT members have the originally passed values.
 419         */
 420         mdi.szClass = lpClassName;
 421         mdi.szTitle = lpWindowName;
 422         mdi.hOwner = hInstance;
 423         mdi.x = x;
 424         mdi.y = y;
 425         mdi.cx = nWidth;
 426         mdi.cy = nHeight;
 427         mdi.style = dwStyle;
 428         mdi.lParam = (LPARAM)lpParam;
 429
 430         lpParam = (LPVOID)&mdi;
 431
 432         if (pWndParent->style & MDIS_ALLCHILDSTYLES)
 433         {
 434             if (dwStyle & WS_POPUP)
 435             {
 436                 WARN("WS_POPUP with MDIS_ALLCHILDSTYLES is not allowed\n");
 437                 return(0);
 438             }
 439             dwStyle |= (WS_CHILD | WS_CLIPSIBLINGS);
 440         }
 441         else
 442         {
 443             dwStyle &= ~WS_POPUP;
 444             dwStyle |= (WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CAPTION |
 445                 WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX);
 446         }
 447
 448         top_child = GetWindow(hWndParent, GW_CHILD);
 449
 450         if (top_child)
 451         {
 452             /* Restore current maximized child */
 453             if((dwStyle & WS_VISIBLE) && IsZoomed(top_child))
 454             {
 455                 TRACE("Restoring current maximized child %p\n", top_child);
 456                 SendMessageW( top_child, WM_SETREDRAW, FALSE, 0 );
 457                 ShowWindow(top_child, SW_RESTORE);
 458                 SendMessageW( top_child, WM_SETREDRAW, TRUE, 0 );
 459             }
 460         }
 461
 462         MDI_CalcDefaultChildPos(hWndParent, -1, mPos, 0, &id);
 463
 464         if (!(dwStyle & WS_POPUP)) hMenu = UlongToHandle(id);
 465
 466         if (dwStyle & (WS_CHILD | WS_POPUP))
 467         {
 468             if (x == CW_USEDEFAULT || x == CW_USEDEFAULT16)
 469             {
 470                 x = mPos[0].x;
 471                 y = mPos[0].y;
 472             }
 473             if (nWidth == CW_USEDEFAULT || nWidth == CW_USEDEFAULT16 || !nWidth)
 474                 nWidth = mPos[1].x;
 475             if (nHeight == CW_USEDEFAULT || nHeight == CW_USEDEFAULT16 || !nHeight)
 476                 nHeight = mPos[1].y;
 477         }
 478     }
 479
 480     hwnd = User32CreateWindowEx(dwExStyle,
 481                                 lpClassName,
 482                                 lpWindowName,
 483                                 dwStyle,
 484                                 x,
 485                                 y,
 486                                 nWidth,
 487                                 nHeight,
 488                                 hWndParent,
 489                                 hMenu,
 490                                 hInstance,
 491                                 lpParam,
 492                                 NUCWE_ANSI);
 493     return hwnd;
 494 }
 495
 496
 497 /*
 498  * @implemented
 499  */
 500 HWND
 501 WINAPI
 502 DECLSPEC_HOTPATCH
 503 CreateWindowExW(DWORD dwExStyle,
 504                 LPCWSTR lpClassName,
 505                 LPCWSTR lpWindowName,
 506                 DWORD dwStyle,
 507                 int x,
 508                 int y,
 509                 int nWidth,
 510                 int nHeight,
 511                 HWND hWndParent,
 512                 HMENU hMenu,
 513                 HINSTANCE hInstance,
 514                 LPVOID lpParam)
 515 {
 516     MDICREATESTRUCTW mdi;
 517     HWND hwnd;
 518
 519     if (!RegisterDefaultClasses)
 520     {
 521        ERR("CreateWindowExW RegisterSystemControls\n");
 522        RegisterSystemControls();
 523     }
 524
 525     if (dwExStyle & WS_EX_MDICHILD)
 526     {
 527         POINT mPos[2];
 528         UINT id = 0;
 529         HWND top_child;
 530         PWND pWndParent;
 531
 532         pWndParent = ValidateHwnd(hWndParent);
 533
 534         if (!pWndParent) return NULL;
 535
 536         if (pWndParent->fnid != FNID_MDICLIENT)
 537         {
 538            WARN("WS_EX_MDICHILD, but parent %p is not MDIClient\n", hWndParent);
 539            return NULL;
 540         }
 541
 542         /* lpParams of WM_[NC]CREATE is different for MDI children.
 543         * MDICREATESTRUCT members have the originally passed values.
 544         */
 545         mdi.szClass = lpClassName;
 546         mdi.szTitle = lpWindowName;
 547         mdi.hOwner = hInstance;
 548         mdi.x = x;
 549         mdi.y = y;
 550         mdi.cx = nWidth;
 551         mdi.cy = nHeight;
 552         mdi.style = dwStyle;
 553         mdi.lParam = (LPARAM)lpParam;
 554
 555         lpParam = (LPVOID)&mdi;
 556
 557         if (pWndParent->style & MDIS_ALLCHILDSTYLES)
 558         {
 559             if (dwStyle & WS_POPUP)
 560             {
 561                 WARN("WS_POPUP with MDIS_ALLCHILDSTYLES is not allowed\n");
 562                 return(0);
 563             }
 564             dwStyle |= (WS_CHILD | WS_CLIPSIBLINGS);
 565         }
 566         else
 567         {
 568             dwStyle &= ~WS_POPUP;
 569             dwStyle |= (WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CAPTION |
 570                 WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX);
 571         }
 572
 573         top_child = GetWindow(hWndParent, GW_CHILD);
 574
 575         if (top_child)
 576         {
 577             /* Restore current maximized child */
 578             if((dwStyle & WS_VISIBLE) && IsZoomed(top_child))
 579             {
 580                 TRACE("Restoring current maximized child %p\n", top_child);
 581                 SendMessageW( top_child, WM_SETREDRAW, FALSE, 0 );
 582                 ShowWindow(top_child, SW_RESTORE);
 583                 SendMessageW( top_child, WM_SETREDRAW, TRUE, 0 );
 584             }
 585         }
 586
 587         MDI_CalcDefaultChildPos(hWndParent, -1, mPos, 0, &id);
 588
 589         if (!(dwStyle & WS_POPUP)) hMenu = UlongToHandle(id);
 590
 591         if (dwStyle & (WS_CHILD | WS_POPUP))
 592         {
 593             if (x == CW_USEDEFAULT || x == CW_USEDEFAULT16)
 594             {
 595                 x = mPos[0].x;
 596                 y = mPos[0].y;
 597             }
 598             if (nWidth == CW_USEDEFAULT || nWidth == CW_USEDEFAULT16 || !nWidth)
 599                 nWidth = mPos[1].x;
 600             if (nHeight == CW_USEDEFAULT || nHeight == CW_USEDEFAULT16 || !nHeight)
 601                 nHeight = mPos[1].y;
 602         }
 603     }
 604
 605     hwnd = User32CreateWindowEx(dwExStyle,
 606                                 (LPCSTR)lpClassName,
 607                                 (LPCSTR)lpWindowName,
 608                                 dwStyle,
 609                                 x,
 610                                 y,
 611                                 nWidth,
 612                                 nHeight,
 613                                 hWndParent,
 614                                 hMenu,
 615                                 hInstance,
 616                                 lpParam,
 617                                 0);
 618     return hwnd;
 619 }
 620
 621 /*
 622  * @unimplemented
 623  */
 624 HDWP WINAPI
 625 DeferWindowPos(HDWP hWinPosInfo,
 626                HWND hWnd,
 627                HWND hWndInsertAfter,
 628                int x,
 629                int y,
 630                int cx,
 631                int cy,
 632                UINT uFlags)
 633 {
 634     return NtUserDeferWindowPos(hWinPosInfo, hWnd, hWndInsertAfter, x, y, cx, cy, uFlags);
 635 }
 636
 637
 638 /*
 639  * @unimplemented
 640  */
 641 BOOL WINAPI
 642 EndDeferWindowPos(HDWP hWinPosInfo)
 643 {
 644     return NtUserEndDeferWindowPosEx(hWinPosInfo, 0);
 645 }
 646
 647
 648 /*
 649  * @implemented
 650  */
 651 HWND WINAPI
 652 GetDesktopWindow(VOID)
 653 {
 654     PWND Wnd;
 655     HWND Ret = NULL;
 656
 657     _SEH2_TRY
 658     {
 659         Wnd = GetThreadDesktopWnd();
 660         if (Wnd != NULL)
 661             Ret = UserHMGetHandle(Wnd);
 662     }
 663     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 664     {
 665         /* Do nothing */
 666     }
 667     _SEH2_END;
 668
 669     return Ret;
 670 }
 671
 672
 673 static BOOL
 674 User32EnumWindows(HDESK hDesktop,
 675                   HWND hWndparent,
 676                   WNDENUMPROC lpfn,
 677                   LPARAM lParam,
 678                   DWORD dwThreadId,
 679                   BOOL bChildren)
 680 {
 681     DWORD i, dwCount = 0;
 682     HWND* pHwnd = NULL;
 683     HANDLE hHeap;
 684     NTSTATUS Status;
 685
 686     if (!lpfn)
 687     {
 688         SetLastError ( ERROR_INVALID_PARAMETER );
 689         return FALSE;
 690     }
 691
 692     /* FIXME instead of always making two calls, should we use some
 693        sort of persistent buffer and only grow it ( requiring a 2nd
 694        call ) when the buffer wasn't already big enough? */
 695     /* first get how many window entries there are */
 696     Status = NtUserBuildHwndList(hDesktop,
 697                                  hWndparent,
 698                                  bChildren,
 699                                  dwThreadId,
 700                                  lParam,
 701                                  NULL,
 702                                  &dwCount);
 703     if (!NT_SUCCESS(Status))
 704         return FALSE;
 705
 706     if (!dwCount)
 707     {
 708        if (!dwThreadId)
 709           return FALSE;
 710        else
 711           return TRUE;
 712     }
 713
 714     /* allocate buffer to receive HWND handles */
 715     hHeap = GetProcessHeap();
 716     pHwnd = HeapAlloc(hHeap, 0, sizeof(HWND)*(dwCount+1));
 717     if (!pHwnd)
 718     {
 719         SetLastError ( ERROR_NOT_ENOUGH_MEMORY );
 720         return FALSE;
 721     }
 722
 723     /* now call kernel again to fill the buffer this time */
 724     Status = NtUserBuildHwndList(hDesktop,
 725                                  hWndparent,
 726                                  bChildren,
 727                                  dwThreadId,
 728                                  lParam,
 729                                  pHwnd,
 730                                  &dwCount);
 731     if (!NT_SUCCESS(Status))
 732     {
 733         if (pHwnd)
 734             HeapFree(hHeap, 0, pHwnd);
 735         return FALSE;
 736     }
 737
 738     /* call the user's callback function until we're done or
 739        they tell us to quit */
 740     for ( i = 0; i < dwCount; i++ )
 741     {
 742         /* FIXME I'm only getting NULLs from Thread Enumeration, and it's
 743          * probably because I'm not doing it right in NtUserBuildHwndList.
 744          * Once that's fixed, we shouldn't have to check for a NULL HWND
 745          * here
 746          * This is now fixed in revision 50205. (jt)
 747          */
 748         if (!pHwnd[i]) /* don't enumerate a NULL HWND */
 749             continue;
 750         if (!(*lpfn)(pHwnd[i], lParam))
 751         {
 752             HeapFree ( hHeap, 0, pHwnd );
 753             return FALSE;
 754         }
 755     }
 756     if (pHwnd)
 757         HeapFree(hHeap, 0, pHwnd);
 758     return TRUE;
 759 }
 760
 761
 762 /*
 763  * @implemented
 764  */
 765 BOOL WINAPI
 766 EnumChildWindows(HWND hWndParent,
 767                  WNDENUMPROC lpEnumFunc,
 768                  LPARAM lParam)
 769 {
 770     if (!hWndParent)
 771     {
 772         return EnumWindows(lpEnumFunc, lParam);
 773     }
 774     return User32EnumWindows(NULL, hWndParent, lpEnumFunc, lParam, 0, TRUE);
 775 }
 776
 777
 778 /*
 779  * @implemented
 780  */
 781 BOOL WINAPI
 782 EnumThreadWindows(DWORD dwThreadId,
 783                   WNDENUMPROC lpfn,
 784                   LPARAM lParam)
 785 {
 786     if (!dwThreadId)
 787         dwThreadId = GetCurrentThreadId();
 788     return User32EnumWindows(NULL, NULL, lpfn, lParam, dwThreadId, FALSE);
 789 }
 790
 791
 792 /*
 793  * @implemented
 794  */
 795 BOOL WINAPI
 796 EnumWindows(WNDENUMPROC lpEnumFunc,
 797             LPARAM lParam)
 798 {
 799     return User32EnumWindows(NULL, NULL, lpEnumFunc, lParam, 0, FALSE);
 800 }
 801
 802
 803 /*
 804  * @implemented
 805  */
 806 BOOL WINAPI
 807 EnumDesktopWindows(HDESK hDesktop,
 808                    WNDENUMPROC lpfn,
 809                    LPARAM lParam)
 810 {
 811     return User32EnumWindows(hDesktop, NULL, lpfn, lParam, 0, FALSE);
 812 }
 813
 814
 815 /*
 816  * @implemented
 817  */
 818 HWND WINAPI
 819 FindWindowExA(HWND hwndParent,
 820               HWND hwndChildAfter,
 821               LPCSTR lpszClass,
 822               LPCSTR lpszWindow)
 823 {
 824     LPWSTR titleW = NULL;
 825     HWND hwnd = 0;
 826
 827     if (lpszWindow)
 828     {
 829         DWORD len = MultiByteToWideChar( CP_ACP, 0, lpszWindow, -1, NULL, 0 );
 830         if (!(titleW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return 0;
 831         MultiByteToWideChar( CP_ACP, 0, lpszWindow, -1, titleW, len );
 832     }
 833
 834     if (!IS_INTRESOURCE(lpszClass))
 835     {
 836         WCHAR classW[256];
 837         if (MultiByteToWideChar( CP_ACP, 0, lpszClass, -1, classW, sizeof(classW)/sizeof(WCHAR) ))
 838             hwnd = FindWindowExW( hwndParent, hwndChildAfter, classW, titleW );
 839     }
 840     else
 841     {
 842         hwnd = FindWindowExW( hwndParent, hwndChildAfter, (LPCWSTR)lpszClass, titleW );
 843     }
 844
 845     HeapFree( GetProcessHeap(), 0, titleW );
 846     return hwnd;
 847 }
 848
 849
 850 /*
 851  * @implemented
 852  */
 853 HWND WINAPI
 854 FindWindowExW(HWND hwndParent,
 855               HWND hwndChildAfter,
 856               LPCWSTR lpszClass,
 857               LPCWSTR lpszWindow)
 858 {
 859     UNICODE_STRING ucClassName, *pucClassName = NULL;
 860     UNICODE_STRING ucWindowName, *pucWindowName = NULL;
 861
 862     if (IS_ATOM(lpszClass))
 863     {
 864         ucClassName.Length = 0;
 865         ucClassName.Buffer = (LPWSTR)lpszClass;
 866         pucClassName = &ucClassName;
 867     }
 868     else if (lpszClass != NULL)
 869     {
 870         RtlInitUnicodeString(&ucClassName,
 871                              lpszClass);
 872         pucClassName = &ucClassName;
 873     }
 874
 875     if (lpszWindow != NULL)
 876     {
 877         RtlInitUnicodeString(&ucWindowName,
 878                              lpszWindow);
 879         pucWindowName = &ucWindowName;
 880     }
 881
 882     return NtUserFindWindowEx(hwndParent,
 883                               hwndChildAfter,
 884                               pucClassName,
 885                               pucWindowName,
 886                               0);
 887 }
 888
 889
 890 /*
 891  * @implemented
 892  */
 893 HWND WINAPI
 894 FindWindowA(LPCSTR lpClassName, LPCSTR lpWindowName)
 895 {
 896     //FIXME: FindWindow does not search children, but FindWindowEx does.
 897     //       what should we do about this?
 898     return FindWindowExA (NULL, NULL, lpClassName, lpWindowName);
 899 }
 900
 901
 902 /*
 903  * @implemented
 904  */
 905 HWND WINAPI
 906 FindWindowW(LPCWSTR lpClassName, LPCWSTR lpWindowName)
 907 {
 908     /*
 909
 910     There was a FIXME here earlier, but I think it is just a documentation unclarity.
 911
 912     FindWindow only searches top level windows. What they mean is that child
 913     windows of other windows than the desktop can be searched.
 914     FindWindowExW never does a recursive search.
 915
 916     / Joakim
 917     */
 918
 919     return FindWindowExW(NULL, NULL, lpClassName, lpWindowName);
 920 }
 921
 922
 923
 924 /*
 925  * @implemented
 926  */
 927 BOOL WINAPI
 928 GetAltTabInfoA(HWND hwnd,
 929                int iItem,
 930                PALTTABINFO pati,
 931                LPSTR pszItemText,
 932                UINT cchItemText)
 933 {
 934     return NtUserGetAltTabInfo(hwnd,iItem,pati,(LPWSTR)pszItemText,cchItemText,TRUE);
 935 }
 936
 937
 938 /*
 939  * @implemented
 940  */
 941 BOOL WINAPI
 942 GetAltTabInfoW(HWND hwnd,
 943                int iItem,
 944                PALTTABINFO pati,
 945                LPWSTR pszItemText,
 946                UINT cchItemText)
 947 {
 948     return NtUserGetAltTabInfo(hwnd,iItem,pati,pszItemText,cchItemText,FALSE);
 949 }
 950
 951
 952 /*
 953  * @implemented
 954  */
 955 HWND WINAPI
 956 GetAncestor(HWND hwnd, UINT gaFlags)
 957 {
 958     HWND Ret = NULL;
 959     PWND Ancestor, Wnd;
 960
 961     Wnd = ValidateHwnd(hwnd);
 962     if (!Wnd)
 963         return NULL;
 964
 965     _SEH2_TRY
 966     {
 967         Ancestor = NULL;
 968         switch (gaFlags)
 969         {
 970             case GA_PARENT:
 971                 if (Wnd->spwndParent != NULL)
 972                     Ancestor = DesktopPtrToUser(Wnd->spwndParent);
 973                 break;
 974
 975             default:
 976                 /* FIXME: Call win32k for now */
 977                 Wnd = NULL;
 978                 break;
 979         }
 980
 981         if (Ancestor != NULL)
 982             Ret = UserHMGetHandle(Ancestor);
 983     }
 984     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 985     {
 986         /* Do nothing */
 987     }
 988     _SEH2_END;
 989
 990     if (!Wnd) /* Fall back */
 991         Ret = NtUserGetAncestor(hwnd, gaFlags);
 992
 993     return Ret;
 994 }
 995
 996
 997 /*
 998  * @implemented
 999  */
1000 BOOL WINAPI
1001 GetClientRect(HWND hWnd, LPRECT lpRect)
1002 {
1003     PWND Wnd = ValidateHwnd(hWnd);
1004
1005     if (!Wnd) return FALSE;
1006     if (Wnd->style & WS_MINIMIZED)
1007     {
1008        lpRect->left = lpRect->top = 0;
1009        lpRect->right = GetSystemMetrics(SM_CXMINIMIZED);
1010        lpRect->bottom = GetSystemMetrics(SM_CYMINIMIZED);
1011        return TRUE;
1012     }
1013     if ( hWnd != GetDesktopWindow()) // Wnd->fnid != FNID_DESKTOP )
1014     {
1015 /*        lpRect->left = lpRect->top = 0;
1016         lpRect->right = Wnd->rcClient.right - Wnd->rcClient.left;
1017         lpRect->bottom = Wnd->rcClient.bottom - Wnd->rcClient.top;
1018 */
1019         *lpRect = Wnd->rcClient;
1020         OffsetRect(lpRect, -Wnd->rcClient.left, -Wnd->rcClient.top);
1021     }
1022     else
1023     {
1024         lpRect->left = lpRect->top = 0;
1025         lpRect->right = Wnd->rcClient.right;
1026         lpRect->bottom = Wnd->rcClient.bottom;
1027 /* Do this until Init bug is fixed. This sets 640x480, see InitMetrics.
1028         lpRect->right = GetSystemMetrics(SM_CXSCREEN);
1029         lpRect->bottom = GetSystemMetrics(SM_CYSCREEN);
1030 */    }
1031     return TRUE;
1032 }
1033
1034
1035 /*
1036  * @implemented
1037  */
1038 HWND WINAPI
1039 GetLastActivePopup(HWND hWnd)
1040 {
1041     PWND Wnd;
1042     HWND Ret = hWnd;
1043
1044     Wnd = ValidateHwnd(hWnd);
1045     if (Wnd != NULL)
1046     {
1047         _SEH2_TRY
1048         {
1049             if (Wnd->spwndLastActive)
1050             {
1051                PWND LastActive = DesktopPtrToUser(Wnd->spwndLastActive);
1052                Ret = UserHMGetHandle(LastActive);
1053             }
1054         }
1055         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1056         {
1057             /* Do nothing */
1058         }
1059         _SEH2_END;
1060     }
1061     return Ret;
1062 }
1063
1064
1065 /*
1066  * @implemented
1067  */
1068 HWND WINAPI
1069 GetParent(HWND hWnd)
1070 {
1071     PWND Wnd, WndParent;
1072     HWND Ret = NULL;
1073
1074     Wnd = ValidateHwnd(hWnd);
1075     if (Wnd != NULL)
1076     {
1077         _SEH2_TRY
1078         {
1079             WndParent = NULL;
1080             if (Wnd->style & WS_POPUP)
1081             {
1082                 if (Wnd->spwndOwner != NULL)
1083                     WndParent = DesktopPtrToUser(Wnd->spwndOwner);
1084             }
1085             else if (Wnd->style & WS_CHILD)
1086             {
1087                 if (Wnd->spwndParent != NULL)
1088                     WndParent = DesktopPtrToUser(Wnd->spwndParent);
1089             }
1090
1091             if (WndParent != NULL)
1092                 Ret = UserHMGetHandle(WndParent);
1093         }
1094         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1095         {
1096             /* Do nothing */
1097         }
1098         _SEH2_END;
1099     }
1100
1101     return Ret;
1102 }
1103
1104
1105 /*
1106  * @implemented
1107  */
1108 BOOL WINAPI
1109 GetProcessDefaultLayout(DWORD *pdwDefaultLayout)
1110 {
1111 return (BOOL)NtUserCallOneParam( (DWORD_PTR)pdwDefaultLayout, ONEPARAM_ROUTINE_GETPROCDEFLAYOUT);
1112 }
1113
1114
1115 /*
1116  * @implemented
1117  */
1118 HWND WINAPI
1119 GetWindow(HWND hWnd,
1120           UINT uCmd)
1121 {
1122     PWND Wnd, FoundWnd;
1123     HWND Ret = NULL;
1124
1125     Wnd = ValidateHwnd(hWnd);
1126     if (!Wnd)
1127         return NULL;
1128
1129     _SEH2_TRY
1130     {
1131         FoundWnd = NULL;
1132         switch (uCmd)
1133         {
1134             case GW_OWNER:
1135                 if (Wnd->spwndOwner != NULL)
1136                     FoundWnd = DesktopPtrToUser(Wnd->spwndOwner);
1137                 break;
1138
1139             case GW_HWNDFIRST:
1140                 if(Wnd->spwndParent != NULL)
1141                 {
1142                     FoundWnd = DesktopPtrToUser(Wnd->spwndParent);
1143                     if (FoundWnd->spwndChild != NULL)
1144                         FoundWnd = DesktopPtrToUser(FoundWnd->spwndChild);
1145                 }
1146                 break;
1147             case GW_HWNDNEXT:
1148                 if (Wnd->spwndNext != NULL)
1149                     FoundWnd = DesktopPtrToUser(Wnd->spwndNext);
1150                 break;
1151
1152             case GW_HWNDPREV:
1153                 if (Wnd->spwndPrev != NULL)
1154                     FoundWnd = DesktopPtrToUser(Wnd->spwndPrev);
1155                 break;
1156
1157             case GW_CHILD:
1158                 if (Wnd->spwndChild != NULL)
1159                     FoundWnd = DesktopPtrToUser(Wnd->spwndChild);
1160                 break;
1161
1162             case GW_HWNDLAST:
1163                 FoundWnd = Wnd;
1164                 while ( FoundWnd->spwndNext != NULL)
1165                     FoundWnd = DesktopPtrToUser(FoundWnd->spwndNext);
1166                 break;
1167
1168             default:
1169                 Wnd = NULL;
1170                 break;
1171         }
1172
1173         if (FoundWnd != NULL)
1174             Ret = UserHMGetHandle(FoundWnd);
1175     }
1176     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1177     {
1178         /* Do nothing */
1179     }
1180     _SEH2_END;
1181
1182     return Ret;
1183 }
1184
1185
1186 /*
1187  * @implemented
1188  */
1189 HWND WINAPI
1190 GetTopWindow(HWND hWnd)
1191 {
1192     if (!hWnd) hWnd = GetDesktopWindow();
1193     return GetWindow(hWnd, GW_CHILD);
1194 }
1195
1196
1197 /*
1198  * @implemented
1199  */
1200 BOOL
1201 WINAPI
1202 DECLSPEC_HOTPATCH
1203 GetWindowInfo(HWND hWnd,
1204               PWINDOWINFO pwi)
1205 {
1206     PWND pWnd;
1207     PCLS pCls = NULL;
1208     SIZE Size = {0,0};
1209     BOOL Ret = FALSE;
1210
1211     if ( !pwi || pwi->cbSize != sizeof(WINDOWINFO))
1212        SetLastError(ERROR_INVALID_PARAMETER); // Just set the error and go!
1213
1214     pWnd = ValidateHwnd(hWnd);
1215     if (!pWnd)
1216         return Ret;
1217
1218     UserGetWindowBorders(pWnd->style, pWnd->ExStyle, &Size, FALSE);
1219
1220     _SEH2_TRY
1221     {
1222        pCls = DesktopPtrToUser(pWnd->pcls);
1223        pwi->rcWindow = pWnd->rcWindow;
1224        pwi->rcClient = pWnd->rcClient;
1225        pwi->dwStyle = pWnd->style;
1226        pwi->dwExStyle = pWnd->ExStyle;
1227        pwi->cxWindowBorders = Size.cx;
1228        pwi->cyWindowBorders = Size.cy;
1229        pwi->dwWindowStatus = 0;
1230        if (pWnd->state & WNDS_ACTIVEFRAME || (GetActiveWindow() == hWnd))
1231           pwi->dwWindowStatus = WS_ACTIVECAPTION;
1232        pwi->atomWindowType = (pCls ? pCls->atomClassName : 0 );
1233
1234        if ( pWnd->state2 & WNDS2_WIN50COMPAT )
1235        {
1236           pwi->wCreatorVersion = 0x500;
1237        }
1238        else if ( pWnd->state2 & WNDS2_WIN40COMPAT )
1239        {
1240           pwi->wCreatorVersion = 0x400;
1241        }
1242        else if ( pWnd->state2 & WNDS2_WIN31COMPAT )
1243        {
1244           pwi->wCreatorVersion =  0x30A;
1245        }
1246        else
1247        {
1248           pwi->wCreatorVersion = 0x300;
1249        }
1250
1251        Ret = TRUE;
1252     }
1253     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1254     {
1255         /* Do nothing */
1256     }
1257     _SEH2_END;
1258
1259    return Ret;
1260 }
1261
1262
1263 /*
1264  * @implemented
1265  */
1266 UINT WINAPI
1267 GetWindowModuleFileNameA(HWND hwnd,
1268                          LPSTR lpszFileName,
1269                          UINT cchFileNameMax)
1270 {
1271     PWND Wnd = ValidateHwnd(hwnd);
1272
1273     if (!Wnd)
1274         return 0;
1275
1276     return GetModuleFileNameA(Wnd->hModule, lpszFileName, cchFileNameMax);
1277 }
1278
1279
1280 /*
1281  * @implemented
1282  */
1283 UINT WINAPI
1284 GetWindowModuleFileNameW(HWND hwnd,
1285                          LPWSTR lpszFileName,
1286                          UINT cchFileNameMax)
1287 {
1288        PWND Wnd = ValidateHwnd(hwnd);
1289
1290     if (!Wnd)
1291         return 0;
1292
1293     return GetModuleFileNameW( Wnd->hModule, lpszFileName, cchFileNameMax );
1294 }
1295
1296 /*
1297  * @implemented
1298  */
1299 BOOL WINAPI
1300 GetWindowRect(HWND hWnd,
1301               LPRECT lpRect)
1302 {
1303     PWND Wnd = ValidateHwnd(hWnd);
1304
1305     if (!Wnd) return FALSE;
1306     if ( hWnd != GetDesktopWindow()) // Wnd->fnid != FNID_DESKTOP )
1307     {
1308         *lpRect = Wnd->rcWindow;
1309     }
1310     else
1311     {
1312         lpRect->left = lpRect->top = 0;
1313         lpRect->right = Wnd->rcWindow.right;
1314         lpRect->bottom = Wnd->rcWindow.bottom;
1315 /* Do this until Init bug is fixed. This sets 640x480, see InitMetrics.
1316         lpRect->right = GetSystemMetrics(SM_CXSCREEN);
1317         lpRect->bottom = GetSystemMetrics(SM_CYSCREEN);
1318 */    }
1319     return TRUE;
1320 }
1321
1322 /*
1323  * @implemented
1324  */
1325 int WINAPI
1326 GetWindowTextA(HWND hWnd, LPSTR lpString, int nMaxCount)
1327 {
1328     PWND Wnd;
1329     INT Length = 0;
1330
1331     if (lpString == NULL || nMaxCount == 0)
1332         return 0;
1333
1334     Wnd = ValidateHwnd(hWnd);
1335     if (!Wnd)
1336         return 0;
1337
1338     lpString[0] = '\0';
1339
1340     if (!TestWindowProcess(Wnd))
1341     {
1342         _SEH2_TRY
1343         {
1344             Length = DefWindowProcA(hWnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString);
1345         }
1346         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1347         {
1348             Length = 0;
1349         }
1350         _SEH2_END;
1351     }
1352     else
1353     {
1354         Length = SendMessageA(hWnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString);
1355     }
1356     //ERR("GWTA Len %d : %s\n",Length,lpString);
1357     return Length;
1358 }
1359
1360 /*
1361  * @implemented
1362  */
1363 int WINAPI
1364 GetWindowTextLengthA(HWND hWnd)
1365 {
1366     PWND Wnd;
1367
1368     Wnd = ValidateHwnd(hWnd);
1369     if (!Wnd)
1370         return 0;
1371
1372     if (!TestWindowProcess(Wnd))
1373     {
1374         return DefWindowProcA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1375     }
1376     else
1377     {
1378         return SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0);
1379     }
1380 }
1381
1382 /*
1383  * @implemented
1384  */
1385 int WINAPI
1386 GetWindowTextLengthW(HWND hWnd)
1387 {
1388     PWND Wnd;
1389
1390     Wnd = ValidateHwnd(hWnd);
1391     if (!Wnd)
1392         return 0;
1393
1394     if (!TestWindowProcess(Wnd))
1395     {
1396         return DefWindowProcW(hWnd, WM_GETTEXTLENGTH, 0, 0);
1397     }
1398     else
1399     {
1400         return SendMessageW(hWnd, WM_GETTEXTLENGTH, 0, 0);
1401     }
1402 }
1403
1404 /*
1405  * @implemented
1406  */
1407 int WINAPI
1408 GetWindowTextW(HWND hWnd, LPWSTR lpString, int nMaxCount)
1409 {
1410     PWND Wnd;
1411     INT Length = 0;
1412
1413     if (lpString == NULL || nMaxCount == 0)
1414         return 0;
1415
1416     Wnd = ValidateHwnd(hWnd);
1417     if (!Wnd)
1418         return 0;
1419
1420     lpString[0] = L'\0';
1421
1422     if (!TestWindowProcess(Wnd))
1423     {
1424         _SEH2_TRY
1425         {
1426             Length = DefWindowProcW(hWnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString);
1427         }
1428         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1429         {
1430             Length = 0;
1431         }
1432         _SEH2_END;
1433     }
1434     else
1435     {
1436         Length = SendMessageW(hWnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString);
1437     }
1438     //ERR("GWTW Len %d : %S\n",Length,lpString);
1439     return Length;
1440 }
1441
1442 DWORD WINAPI
1443 GetWindowThreadProcessId(HWND hWnd,
1444                          LPDWORD lpdwProcessId)
1445 {
1446     DWORD Ret = 0;
1447     PTHREADINFO ti;
1448     PWND pWnd = ValidateHwnd(hWnd);
1449
1450     if (!pWnd) return Ret;
1451
1452     ti = pWnd->head.pti;
1453
1454     if (ti)
1455     {
1456         if (ti == GetW32ThreadInfo())
1457         { // We are current.
1458           //FIXME("Current!\n");
1459             if (lpdwProcessId)
1460                 *lpdwProcessId = (DWORD_PTR)NtCurrentTeb()->ClientId.UniqueProcess;
1461             Ret = (DWORD_PTR)NtCurrentTeb()->ClientId.UniqueThread;
1462         }
1463         else
1464         { // Ask kernel for info.
1465           //FIXME("Kernel call!\n");
1466             if (lpdwProcessId)
1467                 *lpdwProcessId = NtUserQueryWindow(hWnd, QUERY_WINDOW_UNIQUE_PROCESS_ID);
1468             Ret = NtUserQueryWindow(hWnd, QUERY_WINDOW_UNIQUE_THREAD_ID);
1469         }
1470     }
1471     return Ret;
1472 }
1473
1474
1475 /*
1476  * @implemented
1477  */
1478 BOOL WINAPI
1479 IsChild(HWND hWndParent,
1480     HWND hWnd)
1481 {
1482     PWND WndParent, DesktopWnd,  Wnd;
1483     BOOL Ret = FALSE;
1484
1485     WndParent = ValidateHwnd(hWndParent);
1486     if (!WndParent)
1487         return FALSE;
1488     Wnd = ValidateHwnd(hWnd);
1489     if (!Wnd)
1490         return FALSE;
1491
1492     DesktopWnd = GetThreadDesktopWnd();
1493     if (!DesktopWnd)
1494         return FALSE;
1495
1496     _SEH2_TRY
1497     {
1498         while (Wnd != NULL && ((Wnd->style & (WS_POPUP|WS_CHILD)) == WS_CHILD))
1499         {
1500             if (Wnd->spwndParent != NULL)
1501             {
1502                 Wnd = DesktopPtrToUser(Wnd->spwndParent);
1503
1504                 if (Wnd == WndParent)
1505                 {
1506                     Ret = TRUE;
1507                     break;
1508                 }
1509             }
1510             else
1511                 break;
1512         }
1513     }
1514     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1515     {
1516         /* Do nothing */
1517     }
1518     _SEH2_END;
1519
1520     return Ret;
1521 }
1522
1523
1524 /*
1525  * @implemented
1526  */
1527 BOOL WINAPI
1528 IsIconic(HWND hWnd)
1529 {
1530     PWND Wnd = ValidateHwnd(hWnd);
1531
1532     if (Wnd != NULL)
1533         return (Wnd->style & WS_MINIMIZE) != 0;
1534
1535     return FALSE;
1536 }
1537
1538
1539 /*
1540  * @implemented
1541  */
1542 BOOL WINAPI
1543 IsWindow(HWND hWnd)
1544 {
1545     PWND Wnd = ValidateHwndNoErr(hWnd);
1546     if (Wnd != NULL)
1547     {
1548         if (Wnd->state & WNDS_DESTROYED ||
1549             Wnd->state2 & WNDS2_INDESTROY)
1550            return FALSE;
1551         return TRUE;
1552     }
1553
1554     return FALSE;
1555 }
1556
1557
1558 /*
1559  * @implemented
1560  */
1561 BOOL WINAPI
1562 IsWindowUnicode(HWND hWnd)
1563 {
1564     PWND Wnd = ValidateHwnd(hWnd);
1565
1566     if (Wnd != NULL)
1567         return Wnd->Unicode;
1568
1569     return FALSE;
1570 }
1571
1572
1573 /*
1574  * @implemented
1575  */
1576 BOOL WINAPI
1577 IsWindowVisible(HWND hWnd)
1578 {
1579     BOOL Ret = FALSE;
1580     PWND Wnd = ValidateHwnd(hWnd);
1581
1582     if (Wnd != NULL)
1583     {
1584         _SEH2_TRY
1585         {
1586             Ret = TRUE;
1587
1588             do
1589             {
1590                 if (!(Wnd->style & WS_VISIBLE))
1591                 {
1592                     Ret = FALSE;
1593                     break;
1594                 }
1595
1596                 if (Wnd->spwndParent != NULL)
1597                     Wnd = DesktopPtrToUser(Wnd->spwndParent);
1598                 else
1599                     break;
1600
1601             } while (Wnd != NULL);
1602         }
1603         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1604         {
1605             Ret = FALSE;
1606         }
1607         _SEH2_END;
1608     }
1609
1610     return Ret;
1611 }
1612
1613
1614 /*
1615  * @implemented
1616  */
1617 BOOL WINAPI
1618 IsWindowEnabled(HWND hWnd)
1619 {
1620     // AG: I don't know if child windows are affected if the parent is
1621     // disabled. I think they stop processing messages but stay appearing
1622     // as enabled.
1623
1624     return !(GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_DISABLED);
1625 }
1626
1627
1628 /*
1629  * @implemented
1630  */
1631 BOOL WINAPI
1632 IsZoomed(HWND hWnd)
1633 {
1634     return (GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_MAXIMIZE) != 0;
1635 }
1636
1637
1638 /*
1639  * @implemented
1640  */
1641 BOOL WINAPI
1642 LockSetForegroundWindow(UINT uLockCode)
1643 {
1644     return NtUserxLockSetForegroundWindow(uLockCode);
1645 }
1646
1647
1648 /*
1649  * @implemented
1650  */
1651 BOOL WINAPI
1652 AnimateWindow(HWND hwnd,
1653               DWORD dwTime,
1654               DWORD dwFlags)
1655 {
1656     /* FIXME Add animation code */
1657
1658     /* If trying to show/hide and it's already   *
1659      * shown/hidden or invalid window, fail with *
1660      * invalid parameter                         */
1661
1662     BOOL visible;
1663     visible = IsWindowVisible(hwnd);
1664     if(!IsWindow(hwnd) ||
1665        (visible && !(dwFlags & AW_HIDE)) ||
1666        (!visible && (dwFlags & AW_HIDE)))
1667     {
1668         SetLastError(ERROR_INVALID_PARAMETER);
1669         return FALSE;
1670     }
1671
1672     ShowWindow(hwnd, (dwFlags & AW_HIDE) ? SW_HIDE : ((dwFlags & AW_ACTIVATE) ? SW_SHOW : SW_SHOWNA));
1673
1674     return TRUE;
1675 }
1676
1677
1678 /*
1679  * @implemented
1680  */
1681 BOOL WINAPI
1682 OpenIcon(HWND hWnd)
1683 {
1684     if (!(GetWindowLongPtrW(hWnd, GWL_STYLE) & WS_MINIMIZE))
1685         return FALSE;
1686
1687     ShowWindow(hWnd,SW_RESTORE);
1688     return TRUE;
1689 }
1690
1691
1692 /*
1693  * @implemented
1694  */
1695 HWND WINAPI
1696 RealChildWindowFromPoint(HWND hwndParent,
1697                          POINT ptParentClientCoords)
1698 {
1699     return NtUserRealChildWindowFromPoint(hwndParent, ptParentClientCoords.x, ptParentClientCoords.y);
1700 }
1701
1702 /*
1703  * @unimplemented
1704  */
1705 BOOL WINAPI
1706 SetForegroundWindow(HWND hWnd)
1707 {
1708     return NtUserxSetForegroundWindow(hWnd);
1709 }
1710
1711
1712 /*
1713  * @implemented
1714  */
1715 BOOL WINAPI
1716 SetProcessDefaultLayout(DWORD dwDefaultLayout)
1717 {
1718 return NtUserCallOneParam( (DWORD_PTR)dwDefaultLayout, ONEPARAM_ROUTINE_SETPROCDEFLAYOUT);
1719 }
1720
1721
1722 /*
1723  * @implemented
1724  */
1725 BOOL
1726 WINAPI
1727 DECLSPEC_HOTPATCH
1728 SetWindowTextA(HWND hWnd,
1729                LPCSTR lpString)
1730 {
1731   PWND pwnd;
1732
1733   pwnd = ValidateHwnd(hWnd);
1734   if (pwnd)
1735   {
1736      if (!TestWindowProcess(pwnd))
1737      {
1738         /* do not send WM_GETTEXT messages to other processes */
1739         return (DefWindowProcA(hWnd, WM_SETTEXT, 0, (LPARAM)lpString) >= 0);
1740      }
1741      return (SendMessageA(hWnd, WM_SETTEXT, 0, (LPARAM)lpString) >= 0);
1742   }
1743   return FALSE;
1744 }
1745
1746
1747 /*
1748  * @implemented
1749  */
1750 BOOL
1751 WINAPI
1752 DECLSPEC_HOTPATCH
1753 SetWindowTextW(HWND hWnd,
1754                LPCWSTR lpString)
1755 {
1756   PWND pwnd;
1757
1758   pwnd = ValidateHwnd(hWnd);
1759   if (pwnd)
1760   {
1761      if (!TestWindowProcess(pwnd))
1762      {
1763         /* do not send WM_GETTEXT messages to other processes */
1764         return (DefWindowProcW(hWnd, WM_SETTEXT, 0, (LPARAM)lpString) >= 0);
1765      }
1766      return (SendMessageW(hWnd, WM_SETTEXT, 0, (LPARAM)lpString) >= 0);
1767   }
1768   return FALSE;
1769 }
1770
1771
1772 /*
1773  * @implemented
1774  */
1775 BOOL WINAPI
1776 ShowOwnedPopups(HWND hWnd, BOOL fShow)
1777 {
1778     return NtUserxShowOwnedPopups(hWnd, fShow);
1779 }
1780
1781
1782 /*
1783  * @implemented
1784  */
1785 BOOL WINAPI
1786 UpdateLayeredWindow( HWND hwnd,
1787                      HDC hdcDst,
1788                      POINT *pptDst,
1789                      SIZE *psize,
1790                      HDC hdcSrc,
1791                      POINT *pptSrc,
1792                      COLORREF crKey,
1793                      BLENDFUNCTION *pbl,
1794                      DWORD dwFlags)
1795 {
1796   if (dwFlags & ULW_EX_NORESIZE)  /* only valid for UpdateLayeredWindowIndirect */
1797   {
1798      SetLastError( ERROR_INVALID_PARAMETER );
1799      return FALSE;
1800   }
1801   return NtUserUpdateLayeredWindow( hwnd,
1802                                     hdcDst,
1803                                     pptDst,
1804                                     psize,
1805                                     hdcSrc,
1806                                     pptSrc,
1807                                     crKey,
1808                                     pbl,
1809                                     dwFlags,
1810                                     NULL);
1811 }
1812
1813 /*
1814  * @implemented
1815  */
1816 BOOL WINAPI
1817 UpdateLayeredWindowIndirect(HWND hwnd,
1818                             const UPDATELAYEREDWINDOWINFO *info)
1819 {
1820   if (info && info->cbSize == sizeof(*info))
1821   {
1822      return NtUserUpdateLayeredWindow( hwnd,
1823                                        info->hdcDst,
1824                                        (POINT *)info->pptDst,
1825                                        (SIZE *)info->psize,
1826                                        info->hdcSrc,
1827                                        (POINT *)info->pptSrc,
1828                                        info->crKey,
1829                                        (BLENDFUNCTION *)info->pblend,
1830                                        info->dwFlags,
1831                                        (RECT *)info->prcDirty);
1832   }
1833   SetLastError(ERROR_INVALID_PARAMETER);
1834   return FALSE;
1835 }
1836
1837 /*
1838  * @implemented
1839  */
1840 BOOL WINAPI
1841 SetWindowContextHelpId(HWND hwnd,
1842                        DWORD dwContextHelpId)
1843 {
1844     return NtUserxSetWindowContextHelpId(hwnd, dwContextHelpId);
1845 }
1846
1847 /*
1848  * @implemented
1849  */
1850 DWORD WINAPI
1851 GetWindowContextHelpId(HWND hwnd)
1852 {
1853     return NtUserxGetWindowContextHelpId(hwnd);
1854 }
1855
1856 /*
1857  * @implemented
1858  */
1859 int WINAPI
1860 InternalGetWindowText(HWND hWnd, LPWSTR lpString, int nMaxCount)
1861 {
1862     INT Ret = NtUserInternalGetWindowText(hWnd, lpString, nMaxCount);
1863     if (Ret == 0 && lpString)
1864         *lpString = L'\0';
1865     return Ret;
1866 }
1867
1868 /*
1869  * @implemented
1870  */
1871 BOOL WINAPI
1872 IsHungAppWindow(HWND hwnd)
1873 {
1874     PWND Window;
1875     UNICODE_STRING ClassName;
1876     WCHAR szClass[16];
1877     static const UNICODE_STRING GhostClass = RTL_CONSTANT_STRING(L"Ghost");
1878
1879     /* Ghost is a hung window */
1880     RtlInitEmptyUnicodeString(&ClassName, szClass, sizeof(szClass));
1881     Window = ValidateHwnd(hwnd);
1882     if (Window && Window->fnid == FNID_GHOST &&
1883         NtUserGetClassName(hwnd, FALSE, &ClassName) &&
1884         RtlEqualUnicodeString(&ClassName, &GhostClass, TRUE))
1885     {
1886         return TRUE;
1887     }
1888
1889     return (NtUserQueryWindow(hwnd, QUERY_WINDOW_ISHUNG) != 0);
1890 }
1891
1892 /*
1893  * @implemented
1894  */
1895 VOID WINAPI
1896 SetLastErrorEx(DWORD dwErrCode, DWORD dwType)
1897 {
1898     SetLastError(dwErrCode);
1899 }
1900
1901 /*
1902  * @implemented
1903  */
1904 HWND WINAPI
1905 GetFocus(VOID)
1906 {
1907     return (HWND)NtUserGetThreadState(THREADSTATE_FOCUSWINDOW);
1908 }
1909
1910 DWORD WINAPI
1911 GetRealWindowOwner(HWND hwnd)
1912 {
1913     return NtUserQueryWindow(hwnd, QUERY_WINDOW_REAL_ID);
1914 }
1915
1916 /*
1917  * @implemented
1918  */
1919 HWND WINAPI
1920 SetTaskmanWindow(HWND hWnd)
1921 {
1922     return NtUserxSetTaskmanWindow(hWnd);
1923 }
1924
1925 /*
1926  * @implemented
1927  */
1928 HWND WINAPI
1929 SetProgmanWindow(HWND hWnd)
1930 {
1931     return NtUserxSetProgmanWindow(hWnd);
1932 }
1933
1934 /*
1935  * @implemented
1936  */
1937 HWND WINAPI
1938 GetProgmanWindow(VOID)
1939 {
1940     return (HWND)NtUserGetThreadState(THREADSTATE_PROGMANWINDOW);
1941 }
1942
1943 /*
1944  * @implemented
1945  */
1946 HWND WINAPI
1947 GetTaskmanWindow(VOID)
1948 {
1949     return (HWND)NtUserGetThreadState(THREADSTATE_TASKMANWINDOW);
1950 }
1951
1952 /*
1953  * @implemented
1954  */
1955 BOOL WINAPI
1956 ScrollWindow(HWND hWnd,
1957              int dx,
1958              int dy,
1959              CONST RECT *lpRect,
1960              CONST RECT *prcClip)
1961 {
1962     return NtUserScrollWindowEx(hWnd,
1963                                 dx,
1964                                 dy,
1965                                 lpRect,
1966                                 prcClip,
1967                                 0,
1968                                 NULL,
1969                                 (lpRect ? 0 : SW_SCROLLCHILDREN) | (SW_ERASE|SW_INVALIDATE|SW_SCROLLWNDDCE)) != ERROR;
1970 }
1971
1972 /* ScrollWindow uses the window DC, ScrollWindowEx doesn't */
1973
1974 /*
1975  * @implemented
1976  */
1977 INT WINAPI
1978 ScrollWindowEx(HWND hWnd,
1979                int dx,
1980                int dy,
1981                CONST RECT *prcScroll,
1982                CONST RECT *prcClip,
1983                HRGN hrgnUpdate,
1984                LPRECT prcUpdate,
1985                UINT flags)
1986 {
1987     if (flags & SW_SMOOTHSCROLL)
1988     {
1989        FIXME("SW_SMOOTHSCROLL not supported.");
1990        // Fall through....
1991     }
1992     return NtUserScrollWindowEx(hWnd,
1993                                 dx,
1994                                 dy,
1995                                 prcScroll,
1996                                 prcClip,
1997                                 hrgnUpdate,
1998                                 prcUpdate,
1999                                 flags);
2000 }
2001
2002 /*
2003  * @implemented
2004  */
2005 BOOL WINAPI
2006 AnyPopup(VOID)
2007 {
2008     int i;
2009     BOOL retvalue;
2010     HWND *list = WIN_ListChildren( GetDesktopWindow() );
2011
2012     if (!list) return FALSE;
2013     for (i = 0; list[i]; i++)
2014     {
2015         if (IsWindowVisible( list[i] ) && GetWindow( list[i], GW_OWNER )) break;
2016     }
2017     retvalue = (list[i] != 0);
2018     HeapFree( GetProcessHeap(), 0, list );
2019     return retvalue;
2020 }
2021
2022 /*
2023  * @implemented
2024  */
2025 BOOL WINAPI
2026 IsWindowInDestroy(HWND hWnd)
2027 {
2028     PWND pwnd;
2029     pwnd = ValidateHwnd(hWnd);
2030     if (!pwnd)
2031        return FALSE;
2032     return ((pwnd->state2 & WNDS2_INDESTROY) == WNDS2_INDESTROY);
2033 }
2034
2035 /*
2036  * @implemented
2037  */
2038 VOID WINAPI
2039 DisableProcessWindowsGhosting(VOID)
2040 {
2041     NtUserxEnableProcessWindowGhosting(FALSE);
2042 }
2043
2044 /* EOF */
2045