reactos/lib/user32/windows/window.c

   1 /* $Id: window.c,v 1.12 2002/09/07 15:12:45 chorns Exp $
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS user32.dll
   5  * FILE:            lib/user32/windows/window.c
   6  * PURPOSE:         Window management
   7  * PROGRAMMER:      Casper S. Hornstrup (chorns@users.sourceforge.net)
   8  * UPDATE HISTORY:
   9  *      06-06-2001  CSH  Created
  10  */
  11
  12 /* INCLUDES ******************************************************************/
  13
  14 #include <user32.h>
  15
  16 /* FUNCTIONS *****************************************************************/
  17
  18 NTSTATUS STDCALL
  19 User32SendNCCALCSIZEMessageForKernel(PVOID Arguments, ULONG ArgumentLength)
  20 {
  21   PSENDNCCALCSIZEMESSAGE_CALLBACK_ARGUMENTS CallbackArgs;
  22   SENDNCCALCSIZEMESSAGE_CALLBACK_RESULT Result;
  23   WNDPROC Proc;
  24
  25   DbgPrint("User32SendNCCALCSIZEMessageForKernel.\n");
  26   CallbackArgs = (PSENDNCCALCSIZEMESSAGE_CALLBACK_ARGUMENTS)Arguments;
  27   if (ArgumentLength != sizeof(SENDNCCALCSIZEMESSAGE_CALLBACK_ARGUMENTS))
  28     {
  29       DbgPrint("Wrong length.\n");
  30       return(STATUS_INFO_LENGTH_MISMATCH);
  31     }
  32   Proc = (WNDPROC)GetWindowLongW(CallbackArgs->Wnd, GWL_WNDPROC);
  33   DbgPrint("Proc %X\n", Proc);
  34   /* Call the window procedure; notice kernel messages are always unicode. */
  35   if (CallbackArgs->Validate)
  36     {
  37       Result.Result = CallWindowProcW(Proc, CallbackArgs->Wnd, WM_NCCALCSIZE,
  38                                       TRUE,
  39                                       (LPARAM)&CallbackArgs->Params);
  40       Result.Params = CallbackArgs->Params;
  41     }
  42   else
  43     {
  44       Result.Result = CallWindowProcW(Proc, CallbackArgs->Wnd, WM_NCCALCSIZE,
  45                                       FALSE, (LPARAM)&CallbackArgs->Rect);
  46       Result.Rect = CallbackArgs->Rect;
  47     }
  48   DbgPrint("Returning result %d.\n", Result);
  49   ZwCallbackReturn(&Result, sizeof(Result), STATUS_SUCCESS);
  50   /* Doesn't return. */
  51 }
  52
  53 NTSTATUS STDCALL
  54 User32SendGETMINMAXINFOMessageForKernel(PVOID Arguments, ULONG ArgumentLength)
  55 {
  56   PSENDGETMINMAXINFO_CALLBACK_ARGUMENTS CallbackArgs;
  57   SENDGETMINMAXINFO_CALLBACK_RESULT Result;
  58   WNDPROC Proc;
  59
  60   DbgPrint("User32SendGETMINAXINFOMessageForKernel.\n");
  61   CallbackArgs = (PSENDGETMINMAXINFO_CALLBACK_ARGUMENTS)Arguments;
  62   if (ArgumentLength != sizeof(SENDGETMINMAXINFO_CALLBACK_ARGUMENTS))
  63     {
  64       DbgPrint("Wrong length.\n");
  65       return(STATUS_INFO_LENGTH_MISMATCH);
  66     }
  67   Proc = (WNDPROC)GetWindowLongW(CallbackArgs->Wnd, GWL_WNDPROC);
  68   DbgPrint("Proc %X\n", Proc);
  69   /* Call the window procedure; notice kernel messages are always unicode. */
  70   Result.Result = CallWindowProcW(Proc, CallbackArgs->Wnd, WM_GETMINMAXINFO,
  71                                   0, (LPARAM)&CallbackArgs->MinMaxInfo);
  72   Result.MinMaxInfo = CallbackArgs->MinMaxInfo;
  73   DbgPrint("Returning result %d.\n", Result);
  74   ZwCallbackReturn(&Result, sizeof(Result), STATUS_SUCCESS);
  75   /* Doesn't return. */
  76 }
  77
  78 NTSTATUS STDCALL
  79 User32SendCREATEMessageForKernel(PVOID Arguments, ULONG ArgumentLength)
  80 {
  81   PSENDCREATEMESSAGE_CALLBACK_ARGUMENTS CallbackArgs;
  82   WNDPROC Proc;
  83   LRESULT Result;
  84
  85   DbgPrint("User32SendCREATEMessageForKernel.\n");
  86   CallbackArgs = (PSENDCREATEMESSAGE_CALLBACK_ARGUMENTS)Arguments;
  87   if (ArgumentLength != sizeof(SENDCREATEMESSAGE_CALLBACK_ARGUMENTS))
  88     {
  89       DbgPrint("Wrong length.\n");
  90       return(STATUS_INFO_LENGTH_MISMATCH);
  91     }
  92   Proc = (WNDPROC)GetWindowLongW(CallbackArgs->Wnd, GWL_WNDPROC);
  93   DbgPrint("Proc %X\n", Proc);
  94   /* Call the window procedure; notice kernel messages are always unicode. */
  95   Result = CallWindowProcW(Proc, CallbackArgs->Wnd, WM_CREATE, 0,
  96                            (LPARAM)&CallbackArgs->CreateStruct);
  97   DbgPrint("Returning result %d.\n", Result);
  98   ZwCallbackReturn(&Result, sizeof(LRESULT), STATUS_SUCCESS);
  99   /* Doesn't return. */
 100 }
 101
 102 NTSTATUS STDCALL
 103 User32SendNCCREATEMessageForKernel(PVOID Arguments, ULONG ArgumentLength)
 104 {
 105   PSENDNCCREATEMESSAGE_CALLBACK_ARGUMENTS CallbackArgs;
 106   WNDPROC Proc;
 107   LRESULT Result;
 108
 109   DbgPrint("User32SendNCCREATEMessageForKernel.\n");
 110   CallbackArgs = (PSENDNCCREATEMESSAGE_CALLBACK_ARGUMENTS)Arguments;
 111   if (ArgumentLength != sizeof(SENDNCCREATEMESSAGE_CALLBACK_ARGUMENTS))
 112     {
 113       DbgPrint("Wrong length.\n");
 114       return(STATUS_INFO_LENGTH_MISMATCH);
 115     }
 116   Proc = (WNDPROC)GetWindowLongW(CallbackArgs->Wnd, GWL_WNDPROC);
 117   DbgPrint("Proc %X\n", Proc);
 118   /* Call the window procedure; notice kernel messages are always unicode. */
 119   Result = CallWindowProcW(Proc, CallbackArgs->Wnd, WM_NCCREATE, 0,
 120                            (LPARAM)&CallbackArgs->CreateStruct);
 121   DbgPrint("Returning result %d.\n", Result);
 122   ZwCallbackReturn(&Result, sizeof(LRESULT), STATUS_SUCCESS);
 123   /* Doesn't return. */
 124 }
 125
 126 NTSTATUS STDCALL
 127 User32CallSendAsyncProcForKernel(PVOID Arguments, ULONG ArgumentLength)
 128 {
 129   PSENDASYNCPROC_CALLBACK_ARGUMENTS CallbackArgs;
 130
 131   DbgPrint("User32CallSendAsyncProcKernel()\n");
 132   CallbackArgs = (PSENDASYNCPROC_CALLBACK_ARGUMENTS)Arguments;
 133   if (ArgumentLength != sizeof(WINDOWPROC_CALLBACK_ARGUMENTS))
 134     {
 135       return(STATUS_INFO_LENGTH_MISMATCH);
 136     }
 137   CallbackArgs->Callback(CallbackArgs->Wnd, CallbackArgs->Msg,
 138                          CallbackArgs->Context, CallbackArgs->Result);
 139   return(STATUS_SUCCESS);
 140 }
 141
 142 NTSTATUS STDCALL
 143 User32CallWindowProcFromKernel(PVOID Arguments, ULONG ArgumentLength)
 144 {
 145   PWINDOWPROC_CALLBACK_ARGUMENTS CallbackArgs;
 146   LRESULT Result;
 147
 148   DbgPrint("User32CallWindowProcFromKernel()\n");
 149   CallbackArgs = (PWINDOWPROC_CALLBACK_ARGUMENTS)Arguments;
 150   if (ArgumentLength != sizeof(WINDOWPROC_CALLBACK_ARGUMENTS))
 151     {
 152       return(STATUS_INFO_LENGTH_MISMATCH);
 153     }
 154   if (CallbackArgs->Proc == NULL)
 155     {
 156       CallbackArgs->Proc = (WNDPROC)GetWindowLong(CallbackArgs->Wnd,
 157                                                   GWL_WNDPROC);
 158     }
 159   DbgPrint("CallbackArgs->Proc %X\n", CallbackArgs->Proc);
 160   Result = CallWindowProcW(CallbackArgs->Proc, CallbackArgs->Wnd,
 161                            CallbackArgs->Msg, CallbackArgs->wParam,
 162                            CallbackArgs->lParam);
 163   ZwCallbackReturn(&Result, sizeof(LRESULT), STATUS_SUCCESS);
 164   /* Doesn't return. */
 165 }
 166
 167 WINBOOL STDCALL
 168 AdjustWindowRect(LPRECT lpRect,
 169                  DWORD dwStyle,
 170                  WINBOOL bMenu)
 171 {
 172   return(AdjustWindowRectEx(lpRect, dwStyle, bMenu, 0));
 173 }
 174
 175 WINBOOL STDCALL
 176 AdjustWindowRectEx(LPRECT lpRect,
 177                    DWORD dwStyle,
 178                    WINBOOL bMenu,
 179                    DWORD dwExStyle)
 180 {
 181   return(FALSE);
 182 }
 183
 184 WINBOOL STDCALL
 185 AllowSetForegroundWindow(DWORD dwProcessId)
 186 {
 187   return(FALSE);
 188 }
 189
 190 WINBOOL STDCALL
 191 AnimateWindow(HWND hwnd,
 192               DWORD dwTime,
 193               DWORD dwFlags)
 194 {
 195   return FALSE;
 196 }
 197
 198 UINT STDCALL
 199 ArrangeIconicWindows(HWND hWnd)
 200 {
 201   return 0;
 202 }
 203
 204 HDWP STDCALL
 205 BeginDeferWindowPos(int nNumWindows)
 206 {
 207   return (HDWP)0;
 208 }
 209
 210 WINBOOL STDCALL
 211 BringWindowToTop(HWND hWnd)
 212 {
 213   return FALSE;
 214 }
 215
 216 WORD STDCALL
 217 CascadeWindows(HWND hwndParent,
 218                UINT wHow,
 219                CONST RECT *lpRect,
 220                UINT cKids,
 221                const HWND *lpKids)
 222 {
 223   return 0;
 224 }
 225
 226 HWND STDCALL
 227 ChildWindowFromPoint(HWND hWndParent,
 228                      POINT Point)
 229 {
 230   return (HWND)0;
 231 }
 232
 233 HWND STDCALL
 234 ChildWindowFromPointEx(HWND hwndParent,
 235                        POINT pt,
 236                        UINT uFlags)
 237 {
 238   return (HWND)0;
 239 }
 240
 241 WINBOOL STDCALL
 242 CloseWindow(HWND hWnd)
 243 {
 244   return FALSE;
 245 }
 246
 247 HWND STDCALL
 248 CreateWindowExA(DWORD dwExStyle,
 249                 LPCSTR lpClassName,
 250                 LPCSTR lpWindowName,
 251                 DWORD dwStyle,
 252                 int x,
 253                 int y,
 254                 int nWidth,
 255                 int nHeight,
 256                 HWND hWndParent,
 257                 HMENU hMenu,
 258                 HINSTANCE hInstance,
 259                 LPVOID lpParam)
 260 {
 261   UNICODE_STRING WindowName;
 262   UNICODE_STRING ClassName;
 263   HWND Handle;
 264   INT sw;
 265
 266   if (IS_ATOM(lpClassName))
 267     {
 268       RtlInitUnicodeString(&ClassName, NULL);
 269       ClassName.Buffer = (LPWSTR)lpClassName;
 270     }
 271   else
 272     {
 273       if (!RtlCreateUnicodeStringFromAsciiz(&(ClassName), (PCSZ)lpClassName))
 274         {
 275           SetLastError(ERROR_OUTOFMEMORY);
 276           return (HWND)0;
 277         }
 278     }
 279
 280   if (!RtlCreateUnicodeStringFromAsciiz(&WindowName, (PCSZ)lpWindowName))
 281     {
 282       if (!IS_ATOM(lpClassName))
 283         {
 284           RtlFreeUnicodeString(&ClassName);
 285         }
 286       SetLastError(ERROR_OUTOFMEMORY);
 287       return (HWND)0;
 288     }
 289
 290   /* Fixup default coordinates. */
 291   sw = SW_SHOW;
 292   if (x == CW_USEDEFAULT || nWidth == CW_USEDEFAULT)
 293     {
 294       if (dwStyle & (WS_CHILD | WS_POPUP))
 295         {
 296           if (x == CW_USEDEFAULT)
 297             {
 298               x = y = 0;
 299             }
 300           if (nWidth == CW_USEDEFAULT)
 301             {
 302               nWidth = nHeight = 0;
 303             }
 304         }
 305       else
 306         {
 307           STARTUPINFOA info;
 308
 309           GetStartupInfoA(&info);
 310
 311           if (x == CW_USEDEFAULT)
 312             {
 313               if (y != CW_USEDEFAULT)
 314                 {
 315                   sw = y;
 316                 }
 317               x = (info.dwFlags & STARTF_USEPOSITION) ? info.dwX : 0;
 318               y = (info.dwFlags & STARTF_USEPOSITION) ? info.dwY : 0;
 319             }
 320
 321           if (nWidth == CW_USEDEFAULT)
 322             {
 323               if (info.dwFlags & STARTF_USESIZE)
 324                 {
 325                   nWidth = info.dwXSize;
 326                   nHeight = info.dwYSize;
 327                 }
 328               else
 329                 {
 330                   RECT r;
 331
 332                   SystemParametersInfoA(SPI_GETWORKAREA, 0, &r, 0);
 333                   nWidth = (((r.right - r.left) * 3) / 4) - x;
 334                   nHeight = (((r.bottom - r.top) * 3) / 4) - y;
 335                 }
 336             }
 337         }
 338     }
 339
 340   Handle = NtUserCreateWindowEx(dwExStyle,
 341                                 &ClassName,
 342                                 &WindowName,
 343                                 dwStyle,
 344                                 x,
 345                                 y,
 346                                 nWidth,
 347                                 nHeight,
 348                                 hWndParent,
 349                                 hMenu,
 350                                 hInstance,
 351                                 lpParam,
 352                                 sw);
 353
 354   RtlFreeUnicodeString(&WindowName);
 355
 356   if (!IS_ATOM(lpClassName))
 357     {
 358       RtlFreeUnicodeString(&ClassName);
 359     }
 360
 361   return Handle;
 362 }
 363
 364 HWND STDCALL
 365 CreateWindowExW(DWORD dwExStyle,
 366                 LPCWSTR lpClassName,
 367                 LPCWSTR lpWindowName,
 368                 DWORD dwStyle,
 369                 int x,
 370                 int y,
 371                 int nWidth,
 372                 int nHeight,
 373                 HWND hWndParent,
 374                 HMENU hMenu,
 375                 HINSTANCE hInstance,
 376                 LPVOID lpParam)
 377 {
 378   UNICODE_STRING WindowName;
 379   UNICODE_STRING ClassName;
 380   HANDLE Handle;
 381   UINT sw;
 382
 383   if (IS_ATOM(lpClassName))
 384     {
 385       RtlInitUnicodeString(&ClassName, NULL);
 386       ClassName.Buffer = (LPWSTR)lpClassName;
 387     }
 388   else
 389     {
 390       RtlInitUnicodeString(&ClassName, lpClassName);
 391     }
 392
 393   RtlInitUnicodeString(&WindowName, lpWindowName);
 394
 395   /* Fixup default coordinates. */
 396   sw = SW_SHOW;
 397   if (x == CW_USEDEFAULT || nWidth == CW_USEDEFAULT)
 398     {
 399       if (dwStyle & (WS_CHILD | WS_POPUP))
 400         {
 401           if (x == CW_USEDEFAULT)
 402             {
 403               x = y = 0;
 404             }
 405           if (nWidth == CW_USEDEFAULT)
 406             {
 407               nWidth = nHeight = 0;
 408             }
 409         }
 410       else
 411         {
 412           STARTUPINFOW info;
 413
 414           GetStartupInfoW(&info);
 415
 416           if (x == CW_USEDEFAULT)
 417             {
 418               if (y != CW_USEDEFAULT)
 419                 {
 420                   sw = y;
 421                 }
 422               x = (info.dwFlags & STARTF_USEPOSITION) ? info.dwX : 0;
 423               y = (info.dwFlags & STARTF_USEPOSITION) ? info.dwY : 0;
 424             }
 425
 426           if (nWidth == CW_USEDEFAULT)
 427             {
 428               if (info.dwFlags & STARTF_USESIZE)
 429                 {
 430                   nWidth = info.dwXSize;
 431                   nHeight = info.dwYSize;
 432                 }
 433               else
 434                 {
 435                   RECT r;
 436
 437                   SystemParametersInfoW(SPI_GETWORKAREA, 0, &r, 0);
 438                   nWidth = (((r.right - r.left) * 3) / 4) - x;
 439                   nHeight = (((r.bottom - r.top) * 3) / 4) - y;
 440                 }
 441             }
 442         }
 443     }
 444
 445   Handle = NtUserCreateWindowEx(dwExStyle,
 446                                 &ClassName,
 447                                 &WindowName,
 448                                 dwStyle,
 449                                 x,
 450                                 y,
 451                                 nWidth,
 452                                 nHeight,
 453                                 hWndParent,
 454                                 hMenu,
 455                                 hInstance,
 456                                 lpParam,
 457                                 0);
 458
 459   return (HWND)Handle;
 460 }
 461
 462 HDWP STDCALL
 463 DeferWindowPos(HDWP hWinPosInfo,
 464                HWND hWnd,
 465                HWND hWndInsertAfter,
 466                int x,
 467                int y,
 468                int cx,
 469                int cy,
 470                UINT uFlags)
 471 {
 472   return (HDWP)0;
 473 }
 474
 475 WINBOOL STDCALL
 476 DestroyWindow(HWND hWnd)
 477 {
 478   return FALSE;
 479 }
 480
 481 WINBOOL STDCALL
 482 EndDeferWindowPos(HDWP hWinPosInfo)
 483 {
 484   return FALSE;
 485 }
 486
 487 WINBOOL STDCALL
 488 EnumChildWindows(HWND hWndParent,
 489                  ENUMWINDOWSPROC lpEnumFunc,
 490                  LPARAM lParam)
 491 {
 492   return FALSE;
 493 }
 494
 495 WINBOOL STDCALL
 496 EnumThreadWindows(DWORD dwThreadId,
 497                   ENUMWINDOWSPROC lpfn,
 498                   LPARAM lParam)
 499 {
 500   return FALSE;
 501 }
 502
 503 WINBOOL STDCALL
 504 EnumWindows(ENUMWINDOWSPROC lpEnumFunc,
 505             LPARAM lParam)
 506 {
 507   return FALSE;
 508 }
 509
 510 HWND STDCALL
 511 FindWindowA(LPCSTR lpClassName, LPCSTR lpWindowName)
 512 {
 513   //FIXME: FindWindow does not search children, but FindWindowEx does.
 514   //       what should we do about this?
 515   return FindWindowExA (NULL, NULL, lpClassName, lpWindowName);
 516 }
 517
 518 HWND STDCALL
 519 FindWindowExA(HWND hwndParent,
 520               HWND hwndChildAfter,
 521               LPCSTR lpszClass,
 522               LPCSTR lpszWindow)
 523 {
 524   return (HWND)0;
 525 }
 526
 527 HWND STDCALL
 528 FindWindowW(LPCWSTR lpClassName, LPCWSTR lpWindowName)
 529 {
 530   //FIXME: FindWindow does not search children, but FindWindowEx does.
 531   //       what should we do about this?
 532   return FindWindowExW (NULL, NULL, lpClassName, lpWindowName);
 533 }
 534
 535 HWND STDCALL
 536 FindWindowExW(HWND hwndParent,
 537               HWND hwndChildAfter,
 538               LPCWSTR lpszClass,
 539               LPCWSTR lpszWindow)
 540 {
 541   return (HWND)0;
 542 }
 543
 544 #undef GetAltTabInfo
 545
 546 BOOL STDCALL
 547 GetAltTabInfo(HWND hwnd,
 548               int iItem,
 549               PALTTABINFO pati,
 550               LPSTR pszItemText,
 551               UINT cchItemText)
 552 {
 553   return GetAltTabInfoA(hwnd,
 554     iItem,
 555           pati,
 556           pszItemText,
 557           cchItemText);
 558 }
 559
 560 BOOL STDCALL
 561 GetAltTabInfoA(HWND hwnd,
 562                int iItem,
 563                PALTTABINFO pati,
 564                LPSTR pszItemText,
 565                UINT cchItemText)
 566 {
 567   return FALSE;
 568 }
 569
 570 BOOL STDCALL
 571 GetAltTabInfoW(HWND hwnd,
 572                int iItem,
 573                PALTTABINFO pati,
 574                LPWSTR pszItemText,
 575                UINT cchItemText)
 576 {
 577   return FALSE;
 578 }
 579
 580 HWND STDCALL
 581 GetAncestor(HWND hwnd, UINT gaFlags)
 582 {
 583   return(NtUserGetAncestor(hwnd, gaFlags));
 584 }
 585
 586 WINBOOL STDCALL
 587 GetClientRect(HWND hWnd,
 588               LPRECT lpRect)
 589 {
 590   return FALSE;
 591 }
 592
 593 HWND STDCALL
 594 GetDesktopWindow(VOID)
 595 {
 596   return (HWND)0;
 597 }
 598
 599 HWND STDCALL
 600 GetForegroundWindow(VOID)
 601 {
 602   return (HWND)0;
 603 }
 604
 605 BOOL STDCALL
 606 GetGUIThreadInfo(DWORD idThread,
 607                  PGUITHREADINFO lpgui)
 608 {
 609   return FALSE;
 610 }
 611
 612 HWND STDCALL
 613 GetLastActivePopup(HWND hWnd)
 614 {
 615   return (HWND)0;
 616 }
 617
 618 HWND STDCALL
 619 GetParent(HWND hWnd)
 620 {
 621   return (HWND)0;
 622 }
 623
 624 WINBOOL STDCALL
 625 GetProcessDefaultLayout(DWORD *pdwDefaultLayout)
 626 {
 627   return FALSE;
 628 }
 629
 630 WINBOOL STDCALL
 631 GetTitleBarInfo(HWND hwnd,
 632                 PTITLEBARINFO pti)
 633 {
 634   return FALSE;
 635 }
 636
 637 HWND STDCALL
 638 GetTopWindow(HWND hWnd)
 639 {
 640   return (HWND)0;
 641 }
 642
 643 HWND STDCALL
 644 GetWindow(HWND hWnd,
 645           UINT uCmd)
 646 {
 647   return (HWND)0;
 648 }
 649
 650 WINBOOL STDCALL
 651 GetWindowInfo(HWND hwnd,
 652               PWINDOWINFO pwi)
 653 {
 654   return FALSE;
 655 }
 656
 657 #undef GetWindowModuleFileName
 658
 659 UINT STDCALL
 660 GetWindowModuleFileName(HWND hwnd,
 661                         LPSTR lpszFileName,
 662                         UINT cchFileNameMax)
 663 {
 664   return GetWindowModuleFileNameA(hwnd,
 665     lpszFileName,
 666     cchFileNameMax);
 667 }
 668
 669 UINT STDCALL
 670 GetWindowModuleFileNameA(HWND hwnd,
 671                          LPSTR lpszFileName,
 672                          UINT cchFileNameMax)
 673 {
 674   return 0;
 675 }
 676
 677 UINT STDCALL
 678 GetWindowModuleFileNameW(HWND hwnd,
 679                          LPWSTR lpszFileName,
 680                          UINT cchFileNameMax)
 681 {
 682   return 0;
 683 }
 684
 685 WINBOOL STDCALL
 686 GetWindowPlacement(HWND hWnd,
 687                    WINDOWPLACEMENT *lpwndpl)
 688 {
 689   return FALSE;
 690 }
 691
 692 WINBOOL STDCALL
 693 GetWindowRect(HWND hWnd,
 694               LPRECT lpRect)
 695 {
 696   return(NtUserGetWindowRect(hWnd, lpRect));
 697 }
 698
 699 int STDCALL
 700 GetWindowTextA(HWND hWnd, LPSTR lpString, int nMaxCount)
 701 {
 702   return(SendMessageA(hWnd, WM_GETTEXT, nMaxCount, (LPARAM)lpString));
 703 }
 704
 705 int STDCALL
 706 GetWindowTextLengthA(HWND hWnd)
 707 {
 708   return(SendMessageA(hWnd, WM_GETTEXTLENGTH, 0, 0));
 709 }
 710
 711 int STDCALL
 712 GetWindowTextLengthW(HWND hWnd)
 713 {
 714   return 0;
 715 }
 716
 717 int STDCALL
 718 GetWindowTextW(HWND hWnd,
 719                LPWSTR lpString,
 720                int nMaxCount)
 721 {
 722   return 0;
 723 }
 724
 725 DWORD STDCALL
 726 GetWindowThreadProcessId(HWND hWnd,
 727                          LPDWORD lpdwProcessId)
 728 {
 729   return 0;
 730 }
 731
 732 WINBOOL STDCALL
 733 IsChild(HWND hWndParent,
 734         HWND hWnd)
 735 {
 736   return FALSE;
 737 }
 738
 739 WINBOOL STDCALL
 740 IsIconic(HWND hWnd)
 741 {
 742   return FALSE;
 743 }
 744
 745 WINBOOL STDCALL
 746 IsWindow(HWND hWnd)
 747 {
 748   return FALSE;
 749 }
 750
 751 WINBOOL STDCALL
 752 IsWindowUnicode(HWND hWnd)
 753 {
 754   return FALSE;
 755 }
 756
 757 WINBOOL STDCALL
 758 IsWindowVisible(HWND hWnd)
 759 {
 760   while (GetWindowLong(hWnd, GWL_STYLE) & WS_CHILD)
 761     {
 762       if (!(GetWindowLong(hWnd, GWL_STYLE) & WS_VISIBLE))
 763         {
 764           return(FALSE);
 765         }
 766       hWnd = GetAncestor(hWnd, GA_PARENT);
 767     }
 768   return(GetWindowLong(hWnd, GWL_STYLE) & WS_VISIBLE);
 769 }
 770
 771 WINBOOL STDCALL
 772 IsZoomed(HWND hWnd)
 773 {
 774   return FALSE;
 775 }
 776
 777 WINBOOL STDCALL
 778 LockSetForegroundWindow(UINT uLockCode)
 779 {
 780   return FALSE;
 781 }
 782
 783 WINBOOL STDCALL
 784 MoveWindow(HWND hWnd,
 785            int X,
 786            int Y,
 787            int nWidth,
 788            int nHeight,
 789            WINBOOL bRepaint)
 790 {
 791   return FALSE;
 792 }
 793
 794 WINBOOL STDCALL
 795 OpenIcon(HWND hWnd)
 796 {
 797   return FALSE;
 798 }
 799
 800 HWND STDCALL
 801 RealChildWindowFromPoint(HWND hwndParent,
 802                          POINT ptParentClientCoords)
 803 {
 804   return (HWND)0;
 805 }
 806
 807 UINT
 808 RealGetWindowClass(HWND  hwnd,
 809                    LPTSTR pszType,
 810                    UINT  cchType)
 811 {
 812   return 0;
 813 }
 814
 815 WINBOOL STDCALL
 816 SetForegroundWindow(HWND hWnd)
 817 {
 818   return FALSE;
 819 }
 820
 821 WINBOOL STDCALL
 822 SetLayeredWindowAttributes(HWND hwnd,
 823                            COLORREF crKey,
 824                            BYTE bAlpha,
 825                            DWORD dwFlags)
 826 {
 827   return FALSE;
 828 }
 829
 830 HWND STDCALL
 831 SetParent(HWND hWndChild,
 832           HWND hWndNewParent)
 833 {
 834   return (HWND)0;
 835 }
 836
 837 WINBOOL STDCALL
 838 SetProcessDefaultLayout(DWORD dwDefaultLayout)
 839 {
 840   return FALSE;
 841 }
 842
 843 WINBOOL STDCALL
 844 SetWindowPlacement(HWND hWnd,
 845                    CONST WINDOWPLACEMENT *lpwndpl)
 846 {
 847   return FALSE;
 848 }
 849
 850 WINBOOL STDCALL
 851 SetWindowPos(HWND hWnd,
 852              HWND hWndInsertAfter,
 853              int X,
 854              int Y,
 855              int cx,
 856              int cy,
 857              UINT uFlags)
 858 {
 859   return FALSE;
 860 }
 861
 862 WINBOOL STDCALL
 863 SetWindowTextA(HWND hWnd,
 864                LPCSTR lpString)
 865 {
 866   return FALSE;
 867 }
 868
 869 WINBOOL STDCALL
 870 SetWindowTextW(HWND hWnd,
 871                LPCWSTR lpString)
 872 {
 873   return FALSE;
 874 }
 875
 876 WINBOOL STDCALL
 877 ShowOwnedPopups(HWND hWnd,
 878                 WINBOOL fShow)
 879 {
 880   return FALSE;
 881 }
 882
 883 WINBOOL STDCALL
 884 ShowWindow(HWND hWnd,
 885            int nCmdShow)
 886 {
 887   return NtUserShowWindow(hWnd, nCmdShow);
 888 }
 889
 890 WINBOOL STDCALL
 891 ShowWindowAsync(HWND hWnd,
 892                 int nCmdShow)
 893 {
 894   return FALSE;
 895 }
 896
 897 WORD STDCALL
 898 TileWindows(HWND hwndParent,
 899             UINT wHow,
 900             CONST RECT *lpRect,
 901             UINT cKids,
 902             const HWND *lpKids)
 903 {
 904   return 0;
 905 }
 906
 907 WINBOOL STDCALL
 908 UpdateLayeredWindow(HWND hwnd,
 909                     HDC hdcDst,
 910                     POINT *pptDst,
 911                     SIZE *psize,
 912                     HDC hdcSrc,
 913                     POINT *pptSrc,
 914                     COLORREF crKey,
 915                     BLENDFUNCTION *pblend,
 916                     DWORD dwFlags)
 917 {
 918   return FALSE;
 919 }
 920
 921 HWND STDCALL
 922 WindowFromPoint(POINT Point)
 923 {
 924   return (HWND)0;
 925 }
 926
 927 /* EOF */