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