include/ntuser.h

   1 /*
   2  * Copyright 2021 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef _NTUSER_
  20 #define _NTUSER_
  21
  22 #include <winuser.h>
  23 #include <wingdi.h>
  24 #include <imm.h>
  25 #include <immdev.h>
  26 #include <winternl.h>
  27
  28 /* KernelCallbackTable codes, not compatible with Windows */
  29 enum
  30 {
  31     /* user32 callbacks */
  32     NtUserCallEnumDisplayMonitor,
  33     NtUserCallSendAsyncCallback,
  34     NtUserCallWinEventHook,
  35     NtUserCallWinProc,
  36     NtUserCallWindowsHook,
  37     NtUserCopyImage,
  38     NtUserDrawNonClientButton,
  39     NtUserDrawScrollBar,
  40     NtUserDrawText,
  41     NtUserFreeCachedClipboardData,
  42     NtUserImmProcessKey,
  43     NtUserImmTranslateMessage,
  44     NtUserInitBuiltinClasses,
  45     NtUserLoadDriver,
  46     NtUserLoadImage,
  47     NtUserLoadSysMenu,
  48     NtUserPostDDEMessage,
  49     NtUserRenderSynthesizedFormat,
  50     NtUserUnpackDDEMessage,
  51     /* win16 hooks */
  52     NtUserCallFreeIcon,
  53     NtUserThunkLock,
  54     /* Vulkan support */
  55     NtUserCallVulkanDebugReportCallback,
  56     NtUserCallVulkanDebugUtilsCallback,
  57     /* OpenGL support */
  58     NtUserCallOpenGLDebugMessageCallback,
  59     /* Driver-specific callbacks */
  60     NtUserDriverCallbackFirst,
  61     NtUserDriverCallbackLast = NtUserDriverCallbackFirst + 9,
  62     NtUserCallCount
  63 };
  64
  65 /* TEB thread info, not compatible with Windows */
  66 struct ntuser_thread_info
  67 {
  68     UINT64         driver_data;       /* driver-specific data */
  69     DWORD          message_time;      /* value for GetMessageTime */
  70     DWORD          message_pos;       /* value for GetMessagePos */
  71     UINT64         message_extra;     /* value for GetMessageExtraInfo */
  72     INPUT_MESSAGE_SOURCE msg_source;  /* Message source for current message */
  73     WORD           recursion_count;   /* SendMessage recursion counter */
  74     UINT           receive_flags;     /* currently received message flags */
  75     UINT           top_window;        /* desktop window */
  76     UINT           msg_window;        /* HWND_MESSAGE parent window */
  77     DPI_AWARENESS  dpi_awareness;     /* DPI awareness */
  78     UINT           default_imc;       /* default input context */
  79     UINT64         client_imm;        /* client IMM thread info */
  80     UINT64         wmchar_data;       /* client data for WM_CHAR mappings */
  81 };
  82
  83 static inline struct ntuser_thread_info *NtUserGetThreadInfo(void)
  84 {
  85 #ifndef _WIN64
  86     if (NtCurrentTeb()->GdiBatchCount)
  87     {
  88         TEB64 *teb64 = (TEB64 *)(UINT_PTR)NtCurrentTeb()->GdiBatchCount;
  89         return (struct ntuser_thread_info *)teb64->Win32ClientInfo;
  90     }
  91 #endif
  92     return (struct ntuser_thread_info *)NtCurrentTeb()->Win32ClientInfo;
  93 }
  94
  95 /* NtUserCallEnumDisplayMonitor params */
  96 struct enum_display_monitor_params
  97 {
  98     MONITORENUMPROC proc;
  99     HMONITOR monitor;
 100     HDC hdc;
 101     RECT rect;
 102     LPARAM lparam;
 103 };
 104
 105 /* NtUserCallSendAsyncCallback params */
 106 struct send_async_params
 107 {
 108     SENDASYNCPROC callback;
 109     HWND hwnd;
 110     UINT msg;
 111     ULONG_PTR data;
 112     LRESULT result;
 113 };
 114
 115 /* NtUserCallWinEventHook params */
 116 struct win_event_hook_params
 117 {
 118     DWORD event;
 119     HWND hwnd;
 120     LONG object_id;
 121     LONG child_id;
 122     void *handle;
 123     DWORD tid;
 124     DWORD time;
 125     WINEVENTPROC proc;
 126     WCHAR module[MAX_PATH];
 127 };
 128
 129 /* type of message-sending functions that need special WM_CHAR handling */
 130 enum wm_char_mapping
 131 {
 132     WMCHAR_MAP_POSTMESSAGE,
 133     WMCHAR_MAP_SENDMESSAGE,
 134     WMCHAR_MAP_SENDMESSAGETIMEOUT,
 135     WMCHAR_MAP_RECVMESSAGE,
 136     WMCHAR_MAP_DISPATCHMESSAGE,
 137     WMCHAR_MAP_CALLWINDOWPROC,
 138     WMCHAR_MAP_COUNT,
 139     WMCHAR_MAP_NOMAPPING = WMCHAR_MAP_COUNT
 140 };
 141
 142 /* NtUserCallWindowProc params */
 143 struct win_proc_params
 144 {
 145     WNDPROC func;
 146     HWND hwnd;
 147     UINT msg;
 148     WPARAM wparam;
 149     LPARAM lparam;
 150     LRESULT *result;
 151     BOOL ansi;
 152     BOOL ansi_dst;
 153     BOOL needs_unpack;
 154     enum wm_char_mapping mapping;
 155     DPI_AWARENESS_CONTEXT dpi_awareness;
 156     WNDPROC procA;
 157     WNDPROC procW;
 158 };
 159
 160 /* NtUserCallWindowsHook params */
 161 struct win_hook_params
 162 {
 163     void *proc;
 164     void *handle;
 165     DWORD pid;
 166     DWORD tid;
 167     int id;
 168     int code;
 169     WPARAM wparam;
 170     LPARAM lparam;
 171     UINT lparam_size;
 172     BOOL prev_unicode;
 173     BOOL next_unicode;
 174 };
 175
 176 /* NtUserCopyImage params */
 177 struct copy_image_params
 178 {
 179     HANDLE hwnd;
 180     UINT type;
 181     INT dx;
 182     INT dy;
 183     UINT flags;
 184 };
 185
 186 /* NtUserDrawText params */
 187 struct draw_text_params
 188 {
 189     HDC hdc;
 190     int count;
 191     RECT rect;
 192     RECT *ret_rect; /* FIXME: Use NtCallbackReturn instead */
 193     UINT flags;
 194     WCHAR str[1];
 195 };
 196
 197 /* NtUserFreeCachedClipboardData params */
 198 struct free_cached_data_params
 199 {
 200     UINT format;
 201     HANDLE handle;
 202 };
 203
 204 /* NtUserImmProcessKey params */
 205 struct imm_process_key_params
 206 {
 207     HWND hwnd;
 208     HKL hkl;
 209     UINT vkey;
 210     LPARAM key_data;
 211 };
 212
 213 /* NtUserImmTranslateMessage params */
 214 struct imm_translate_message_params
 215 {
 216     HWND hwnd;
 217     UINT msg;
 218     WPARAM wparam;
 219     LPARAM key_data;
 220 };
 221
 222 /* NtUserLoadImage params */
 223 struct load_image_params
 224 {
 225     HINSTANCE hinst;
 226     const WCHAR *name;
 227     UINT type;
 228     INT dx;
 229     INT dy;
 230     UINT flags;
 231 };
 232
 233 /* NtUserLoadSysMenu params */
 234 struct load_sys_menu_params
 235 {
 236     BOOL mdi;
 237 };
 238
 239 /* NtUserPostDDEMessage params */
 240 struct post_dde_message_params
 241 {
 242     HWND hwnd;
 243     UINT msg;
 244     WPARAM wparam;
 245     LPARAM lparam;
 246     DWORD dest_tid;
 247     DWORD type;
 248 };
 249
 250 /* NtUserRenderSynthesizedFormat params */
 251 struct render_synthesized_format_params
 252 {
 253     UINT format;
 254     UINT from;
 255 };
 256
 257 /* NtUserUnpackDDEMessage params */
 258 struct unpack_dde_message_result
 259 {
 260     WPARAM wparam;
 261     LPARAM lparam;
 262 };
 263
 264 struct unpack_dde_message_params
 265 {
 266     struct unpack_dde_message_result *result;  /* FIXME: Use NtCallbackReturn instead */
 267     HWND hwnd;
 268     UINT message;
 269     WPARAM wparam;
 270     LPARAM lparam;
 271     char data[1];
 272 };
 273
 274 /* process DPI awareness contexts */
 275 #define NTUSER_DPI_UNAWARE                0x00006010
 276 #define NTUSER_DPI_SYSTEM_AWARE           0x00006011
 277 #define NTUSER_DPI_PER_MONITOR_AWARE      0x00000012
 278 #define NTUSER_DPI_PER_MONITOR_AWARE_V2   0x00000022
 279 #define NTUSER_DPI_PER_UNAWARE_GDISCALED  0x40006010
 280
 281 /* message spy definitions */
 282 #define SPY_DISPATCHMESSAGE  0x0100
 283 #define SPY_SENDMESSAGE      0x0101
 284 #define SPY_DEFWNDPROC       0x0102
 285
 286 #define SPY_RESULT_OK      0x0001
 287 #define SPY_RESULT_DEFWND  0x0002
 288
 289 /* CreateDesktop wine specific flag */
 290 #define DF_WINE_CREATE_DESKTOP   0x80000000
 291
 292 /* NtUserMessageCall codes */
 293 enum
 294 {
 295     NtUserScrollBarWndProc    = 0x029a,
 296     NtUserPopupMenuWndProc    = 0x029c,
 297     NtUserDesktopWindowProc   = 0x029d,
 298     NtUserDefWindowProc       = 0x029e,
 299     NtUserCallWindowProc      = 0x02ab,
 300     NtUserSendMessage         = 0x02b1,
 301     NtUserSendMessageTimeout  = 0x02b3,
 302     NtUserSendNotifyMessage   = 0x02b7,
 303     NtUserSendMessageCallback = 0x02b8,
 304     /* Wine-specific exports */
 305     NtUserClipboardWindowProc = 0x0300,
 306     NtUserGetDispatchParams   = 0x3001,
 307     NtUserSendDriverMessage   = 0x3002,
 308     NtUserSpyGetMsgName       = 0x3003,
 309     NtUserSpyEnter            = 0x0304,
 310     NtUserSpyExit             = 0x0305,
 311     NtUserWinProcResult       = 0x0306,
 312     NtUserImeDriverCall       = 0x0307,
 313 };
 314
 315 /* NtUserThunkedMenuItemInfo codes */
 316 enum
 317 {
 318     NtUserSetMenuItemInfo,
 319     NtUserInsertMenuItem,
 320     /* Wine extensions */
 321     NtUserCheckMenuRadioItem,
 322     NtUserGetMenuDefaultItem,
 323     NtUserGetMenuItemID,
 324     NtUserGetMenuItemInfoA,
 325     NtUserGetMenuItemInfoW,
 326     NtUserGetMenuState,
 327     NtUserGetSubMenu,
 328 };
 329
 330 struct send_message_timeout_params
 331 {
 332     UINT flags;
 333     UINT timeout;
 334     DWORD_PTR result;
 335 };
 336
 337 struct send_message_callback_params
 338 {
 339     SENDASYNCPROC callback;
 340     ULONG_PTR data;
 341 };
 342
 343 /* color index used to retrieve system 55aa brush */
 344 #define COLOR_55AA_BRUSH  0x100
 345
 346 /* user object types */
 347 #define NTUSER_OBJ_WINDOW   0x01
 348 #define NTUSER_OBJ_MENU     0x02
 349 #define NTUSER_OBJ_ICON     0x03
 350 #define NTUSER_OBJ_WINPOS   0x04
 351 #define NTUSER_OBJ_ACCEL    0x08
 352 #define NTUSER_OBJ_HOOK     0x0f
 353 #define NTUSER_OBJ_IMC      0x11
 354
 355 /* NtUserScrollWindowEx flag */
 356 #define SW_NODCCACHE  0x8000
 357
 358 /* NtUserSetScrollInfo flag */
 359 #define SIF_RETURNPREV  0x1000
 360
 361 /* NtUserInitializeClientPfnArrays parameter, not compatible with Windows */
 362 struct user_client_procs
 363 {
 364     WNDPROC pButtonWndProc;
 365     WNDPROC pComboWndProc;
 366     WNDPROC pDefWindowProc;
 367     WNDPROC pDefDlgProc;
 368     WNDPROC pEditWndProc;
 369     WNDPROC pListBoxWndProc;
 370     WNDPROC pMDIClientWndProc;
 371     WNDPROC pScrollBarWndProc;
 372     WNDPROC pStaticWndProc;
 373     WNDPROC pImeWndProc;
 374     WNDPROC pDesktopWndProc;
 375     WNDPROC pIconTitleWndProc;
 376     WNDPROC pPopupMenuWndProc;
 377     WNDPROC pMessageWndProc;
 378 };
 379
 380 /* NtUserSetCursorIconData parameter, not compatible with Windows */
 381 struct cursoricon_frame
 382 {
 383     UINT     width;    /* frame-specific width */
 384     UINT     height;   /* frame-specific height */
 385     HBITMAP  color;    /* color bitmap */
 386     HBITMAP  alpha;    /* pre-multiplied alpha bitmap for 32-bpp icons */
 387     HBITMAP  mask;     /* mask bitmap (followed by color for 1-bpp icons) */
 388     POINT    hotspot;
 389 };
 390
 391 struct cursoricon_desc
 392 {
 393     UINT flags;
 394     UINT num_steps;
 395     UINT num_frames;
 396     UINT delay;
 397     struct cursoricon_frame *frames;
 398     DWORD *frame_seq;
 399     DWORD *frame_rates;
 400     HRSRC rsrc;
 401 };
 402
 403 struct client_menu_name
 404 {
 405     char  *nameA;
 406     WCHAR *nameW;
 407     UNICODE_STRING *nameUS;
 408 };
 409
 410 /* NtUserGetClipboardData params, not compatible with Windows */
 411 struct get_clipboard_params
 412 {
 413     void  *data;
 414     size_t size;
 415     size_t data_size;
 416     UINT   seqno;
 417     BOOL data_only;
 418 };
 419
 420 /* NtUserSetClipboardData params, not compatible with Windows */
 421 struct set_clipboard_params
 422 {
 423     void  *data;
 424     size_t size;
 425     BOOL   cache_only;
 426     UINT   seqno;
 427 };
 428
 429 /* NtUserNonClientButton params */
 430 struct draw_non_client_button_params
 431 {
 432     HWND hwnd;
 433     HDC hdc;
 434     enum NONCLIENT_BUTTON_TYPE type;
 435     RECT rect;
 436     BOOL down;
 437     BOOL grayed;
 438 };
 439
 440 /* NtUserDrawScrollBar params */
 441 struct draw_scroll_bar_params
 442 {
 443     HWND hwnd;
 444     HDC hdc;
 445     INT bar;
 446     UINT hit_test;
 447     struct SCROLL_TRACKING_INFO tracking_info;
 448     BOOL arrows;
 449     BOOL interior;
 450     RECT rect;
 451     UINT enable_flags;
 452     INT arrow_size;
 453     INT thumb_pos;
 454     INT thumb_size;
 455     BOOL vertical;
 456 };
 457
 458 /* NtUserUpdateInputContext param, not compatible with Window */
 459 enum input_context_attr
 460 {
 461     NtUserInputContextClientPtr,
 462     NtUserInputContextThreadId,
 463 };
 464
 465 /* NtUserAssociateInputContext result */
 466 enum associate_input_context_result
 467 {
 468     AICR_OK,
 469     AICR_FOCUS_CHANGED,
 470     AICR_FAILED,
 471 };
 472
 473 /* internal messages codes */
 474 enum wine_internal_message
 475 {
 476     WM_WINE_DESTROYWINDOW = 0x80000000,
 477     WM_WINE_SETWINDOWPOS,
 478     WM_WINE_SHOWWINDOW,
 479     WM_WINE_SETPARENT,
 480     WM_WINE_SETWINDOWLONG,
 481     WM_WINE_SETSTYLE,
 482     WM_WINE_SETACTIVEWINDOW,
 483     WM_WINE_KEYBOARD_LL_HOOK,
 484     WM_WINE_MOUSE_LL_HOOK,
 485     WM_WINE_CLIPCURSOR,
 486     WM_WINE_SETCURSOR,
 487     WM_WINE_UPDATEWINDOWSTATE,
 488     WM_WINE_FIRST_DRIVER_MSG = 0x80001000,  /* range of messages reserved for the USER driver */
 489     WM_WINE_LAST_DRIVER_MSG = 0x80001fff
 490 };
 491
 492 /* internal IME message */
 493 #define WM_IME_INTERNAL 0x287
 494 #define IME_INTERNAL_ACTIVATE   0x17
 495 #define IME_INTERNAL_DEACTIVATE 0x18
 496 #define IME_INTERNAL_HKL_ACTIVATE    0x19
 497 #define IME_INTERNAL_HKL_DEACTIVATE  0x20
 498
 499 /* internal WM_IME_NOTIFY wparams, not compatible with Windows */
 500 #define IMN_WINE_SET_OPEN_STATUS  0x000f
 501 #define IMN_WINE_SET_COMP_STRING  0x0010
 502
 503 /* builtin IME driver calls */
 504 enum wine_ime_call
 505 {
 506     WINE_IME_PROCESS_KEY,
 507     WINE_IME_TO_ASCII_EX,
 508 };
 509
 510 /* NtUserImeDriverCall params */
 511 struct ime_driver_call_params
 512 {
 513     HIMC himc;
 514     const BYTE *state;
 515     COMPOSITIONSTRING *compstr;
 516 };
 517
 518 #define WM_SYSTIMER  0x0118
 519
 520 /* the various structures that can be sent in messages, in platform-independent layout */
 521 struct packed_CREATESTRUCTW
 522 {
 523     ULONGLONG lpCreateParams;
 524     ULONGLONG hInstance;
 525     UINT      hMenu;
 526     DWORD     __pad1;
 527     UINT      hwndParent;
 528     DWORD     __pad2;
 529     INT       cy;
 530     INT       cx;
 531     INT       y;
 532     INT       x;
 533     LONG      style;
 534     ULONGLONG lpszName;
 535     ULONGLONG lpszClass;
 536     DWORD     dwExStyle;
 537     DWORD     __pad3;
 538 };
 539
 540 struct packed_DRAWITEMSTRUCT
 541 {
 542     UINT      CtlType;
 543     UINT      CtlID;
 544     UINT      itemID;
 545     UINT      itemAction;
 546     UINT      itemState;
 547     UINT      hwndItem;
 548     DWORD     __pad1;
 549     UINT      hDC;
 550     DWORD     __pad2;
 551     RECT      rcItem;
 552     ULONGLONG itemData;
 553 };
 554
 555 struct packed_MEASUREITEMSTRUCT
 556 {
 557     UINT      CtlType;
 558     UINT      CtlID;
 559     UINT      itemID;
 560     UINT      itemWidth;
 561     UINT      itemHeight;
 562     ULONGLONG itemData;
 563 };
 564
 565 struct packed_DELETEITEMSTRUCT
 566 {
 567     UINT      CtlType;
 568     UINT      CtlID;
 569     UINT      itemID;
 570     UINT      hwndItem;
 571     DWORD     __pad;
 572     ULONGLONG itemData;
 573 };
 574
 575 struct packed_COMPAREITEMSTRUCT
 576 {
 577     UINT      CtlType;
 578     UINT      CtlID;
 579     UINT      hwndItem;
 580     DWORD     __pad1;
 581     UINT      itemID1;
 582     ULONGLONG itemData1;
 583     UINT      itemID2;
 584     ULONGLONG itemData2;
 585     DWORD     dwLocaleId;
 586     DWORD     __pad2;
 587 };
 588
 589 struct packed_WINDOWPOS
 590 {
 591     UINT      hwnd;
 592     DWORD     __pad1;
 593     UINT      hwndInsertAfter;
 594     DWORD     __pad2;
 595     INT       x;
 596     INT       y;
 597     INT       cx;
 598     INT       cy;
 599     UINT      flags;
 600     DWORD     __pad3;
 601 };
 602
 603 struct packed_COPYDATASTRUCT
 604 {
 605     ULONGLONG dwData;
 606     DWORD     cbData;
 607     ULONGLONG lpData;
 608 };
 609
 610 struct packed_HELPINFO
 611 {
 612     UINT      cbSize;
 613     INT       iContextType;
 614     INT       iCtrlId;
 615     UINT      hItemHandle;
 616     DWORD     __pad;
 617     ULONGLONG dwContextId;
 618     POINT     MousePos;
 619 };
 620
 621 struct packed_NCCALCSIZE_PARAMS
 622 {
 623     RECT      rgrc[3];
 624     ULONGLONG __pad1;
 625     UINT      hwnd;
 626     DWORD     __pad2;
 627     UINT      hwndInsertAfter;
 628     DWORD     __pad3;
 629     INT       x;
 630     INT       y;
 631     INT       cx;
 632     INT       cy;
 633     UINT      flags;
 634     DWORD     __pad4;
 635 };
 636
 637 struct packed_MSG
 638 {
 639     UINT      hwnd;
 640     DWORD     __pad1;
 641     UINT      message;
 642     ULONGLONG wParam;
 643     ULONGLONG lParam;
 644     DWORD     time;
 645     POINT     pt;
 646     DWORD     __pad2;
 647 };
 648
 649 struct packed_MDINEXTMENU
 650 {
 651     UINT      hmenuIn;
 652     DWORD     __pad1;
 653     UINT      hmenuNext;
 654     DWORD     __pad2;
 655     UINT      hwndNext;
 656     DWORD     __pad3;
 657 };
 658
 659 struct packed_MDICREATESTRUCTW
 660 {
 661     ULONGLONG szClass;
 662     ULONGLONG szTitle;
 663     ULONGLONG hOwner;
 664     INT       x;
 665     INT       y;
 666     INT       cx;
 667     INT       cy;
 668     DWORD     style;
 669     ULONGLONG lParam;
 670 };
 671
 672
 673 HKL     WINAPI NtUserActivateKeyboardLayout( HKL layout, UINT flags );
 674 BOOL    WINAPI NtUserAddClipboardFormatListener( HWND hwnd );
 675 UINT    WINAPI NtUserAssociateInputContext( HWND hwnd, HIMC ctx, ULONG flags );
 676 BOOL    WINAPI NtUserAttachThreadInput( DWORD from, DWORD to, BOOL attach );
 677 HDC     WINAPI NtUserBeginPaint( HWND hwnd, PAINTSTRUCT *ps );
 678 NTSTATUS WINAPI NtUserBuildHimcList( UINT thread_id, UINT count, HIMC *buffer, UINT *size );
 679 NTSTATUS WINAPI NtUserBuildHwndList( HDESK desktop, ULONG unk2, ULONG unk3, ULONG unk4,
 680                                      ULONG thread_id, ULONG count, HWND *buffer, ULONG *size );
 681 ULONG_PTR WINAPI NtUserCallHwnd( HWND hwnd, DWORD code );
 682 ULONG_PTR WINAPI NtUserCallHwndParam( HWND hwnd, DWORD_PTR param, DWORD code );
 683 LRESULT WINAPI NtUserCallNextHookEx( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam );
 684 BOOL    WINAPI NtUserCallMsgFilter( MSG *msg, INT code );
 685 ULONG_PTR WINAPI NtUserCallNoParam( ULONG code );
 686 ULONG_PTR WINAPI NtUserCallOneParam( ULONG_PTR arg, ULONG code );
 687 ULONG_PTR WINAPI NtUserCallTwoParam( ULONG_PTR arg1, ULONG_PTR arg2, ULONG code );
 688 BOOL    WINAPI NtUserChangeClipboardChain( HWND hwnd, HWND next );
 689 LONG    WINAPI NtUserChangeDisplaySettings( UNICODE_STRING *devname, DEVMODEW *devmode, HWND hwnd,
 690                                             DWORD flags, void *lparam );
 691 DWORD   WINAPI NtUserCheckMenuItem( HMENU handle, UINT id, UINT flags );
 692 HWND    WINAPI NtUserChildWindowFromPointEx( HWND parent, LONG x, LONG y, UINT flags );
 693 BOOL    WINAPI NtUserClipCursor( const RECT *rect );
 694 BOOL    WINAPI NtUserCloseClipboard(void);
 695 BOOL    WINAPI NtUserCloseDesktop( HDESK handle );
 696 BOOL    WINAPI NtUserCloseWindowStation( HWINSTA handle );
 697 INT     WINAPI NtUserCopyAcceleratorTable( HACCEL src, ACCEL *dst, INT count );
 698 INT     WINAPI NtUserCountClipboardFormats(void);
 699 HACCEL  WINAPI NtUserCreateAcceleratorTable( ACCEL *table, INT count );
 700 BOOL    WINAPI NtUserCreateCaret( HWND hwnd, HBITMAP bitmap, int width, int height );
 701 HDESK   WINAPI NtUserCreateDesktopEx( OBJECT_ATTRIBUTES *attr, UNICODE_STRING *device,
 702                                       DEVMODEW *devmode, DWORD flags, ACCESS_MASK access,
 703                                       ULONG heap_size );
 704 HIMC    WINAPI NtUserCreateInputContext( UINT_PTR client_ptr );
 705 HWND    WINAPI NtUserCreateWindowEx( DWORD ex_style, UNICODE_STRING *class_name,
 706                                      UNICODE_STRING *version, UNICODE_STRING *window_name,
 707                                      DWORD style, INT x, INT y, INT cx, INT cy,
 708                                      HWND parent, HMENU menu, HINSTANCE instance, void *params,
 709                                      DWORD flags, HINSTANCE client_instance, DWORD unk, BOOL ansi );
 710 HWINSTA WINAPI NtUserCreateWindowStation( OBJECT_ATTRIBUTES *attr, ACCESS_MASK mask, ULONG arg3,
 711                                           ULONG arg4, ULONG arg5, ULONG arg6, ULONG arg7 );
 712 HDWP    WINAPI NtUserDeferWindowPosAndBand( HDWP hdwp, HWND hwnd, HWND after, INT x, INT y,
 713                                             INT cx, INT cy, UINT flags, UINT unk1, UINT unk2 );
 714 BOOL    WINAPI NtUserDeleteMenu( HMENU menu, UINT id, UINT flags );
 715 BOOL    WINAPI NtUserDestroyAcceleratorTable( HACCEL handle );
 716 BOOL    WINAPI NtUserDestroyCursor( HCURSOR cursor, ULONG arg );
 717 BOOL    WINAPI NtUserDestroyInputContext( HIMC handle );
 718 BOOL    WINAPI NtUserDestroyMenu( HMENU menu );
 719 BOOL    WINAPI NtUserDestroyWindow( HWND hwnd );
 720 BOOL    WINAPI NtUserDisableThreadIme( DWORD thread_id );
 721 LRESULT WINAPI NtUserDispatchMessage( const MSG *msg );
 722 NTSTATUS WINAPI NtUserDisplayConfigGetDeviceInfo( DISPLAYCONFIG_DEVICE_INFO_HEADER *packet );
 723 BOOL    WINAPI NtUserDragDetect( HWND hwnd, int x, int y );
 724 DWORD   WINAPI NtUserDragObject( HWND parent, HWND hwnd, UINT fmt, ULONG_PTR data, HCURSOR cursor );
 725 BOOL    WINAPI NtUserDrawCaptionTemp( HWND hwnd, HDC hdc, const RECT *rect, HFONT font,
 726                                       HICON icon, const WCHAR *str, UINT flags );
 727 BOOL    WINAPI NtUserDrawIconEx( HDC hdc, INT x0, INT y0, HICON icon, INT width,
 728                                  INT height, UINT istep, HBRUSH hbr, UINT flags );
 729 DWORD   WINAPI NtUserDrawMenuBarTemp( HWND hwnd, HDC hdc, RECT *rect, HMENU handle, HFONT font );
 730 BOOL    WINAPI NtUserEmptyClipboard(void);
 731 BOOL    WINAPI NtUserEnableMenuItem( HMENU handle, UINT id, UINT flags );
 732 BOOL    WINAPI NtUserEnableMouseInPointer( BOOL );
 733 BOOL    WINAPI NtUserEnableScrollBar( HWND hwnd, UINT bar, UINT flags );
 734 BOOL    WINAPI NtUserEndDeferWindowPosEx( HDWP hdwp, BOOL async );
 735 BOOL    WINAPI NtUserEndMenu(void);
 736 BOOL    WINAPI NtUserEndPaint( HWND hwnd, const PAINTSTRUCT *ps );
 737 NTSTATUS WINAPI NtUserEnumDisplayDevices( UNICODE_STRING *device, DWORD index,
 738                                           DISPLAY_DEVICEW *info, DWORD flags );
 739 BOOL    WINAPI NtUserEnumDisplayMonitors( HDC hdc, RECT *rect, MONITORENUMPROC proc, LPARAM lp );
 740 BOOL    WINAPI NtUserEnumDisplaySettings( UNICODE_STRING *device, DWORD mode,
 741                                           DEVMODEW *dev_mode, DWORD flags );
 742 INT     WINAPI NtUserExcludeUpdateRgn( HDC hdc, HWND hwnd );
 743 HICON   WINAPI NtUserFindExistingCursorIcon( UNICODE_STRING *module, UNICODE_STRING *res_name,
 744                                              void *desc );
 745 HWND    WINAPI NtUserFindWindowEx( HWND parent, HWND child, UNICODE_STRING *class,
 746                                    UNICODE_STRING *title, ULONG unk );
 747 BOOL    WINAPI NtUserFlashWindowEx( FLASHWINFO *info );
 748 HWND    WINAPI NtUserGetAncestor( HWND hwnd, UINT type );
 749 SHORT   WINAPI NtUserGetAsyncKeyState( INT key );
 750 ULONG   WINAPI NtUserGetAtomName( ATOM atom, UNICODE_STRING *name );
 751 UINT    WINAPI NtUserGetCaretBlinkTime(void);
 752 BOOL    WINAPI NtUserGetCaretPos( POINT *point );
 753 ATOM    WINAPI NtUserGetClassInfoEx( HINSTANCE instance, UNICODE_STRING *name, WNDCLASSEXW *wc,
 754                                      struct client_menu_name *menu_name, BOOL ansi );
 755 INT     WINAPI NtUserGetClassName( HWND hwnd, BOOL real, UNICODE_STRING *name );
 756 HANDLE  WINAPI NtUserGetClipboardData( UINT format, struct get_clipboard_params *params );
 757 INT     WINAPI NtUserGetClipboardFormatName( UINT format, WCHAR *buffer, INT maxlen );
 758 HWND    WINAPI NtUserGetClipboardOwner(void);
 759 DWORD   WINAPI NtUserGetClipboardSequenceNumber(void);
 760 HWND    WINAPI NtUserGetClipboardViewer(void);
 761 HCURSOR WINAPI NtUserGetCursor(void);
 762 HCURSOR WINAPI NtUserGetCursorFrameInfo( HCURSOR hCursor, DWORD istep, DWORD *rate_jiffies,
 763                                          DWORD *num_steps );
 764 BOOL    WINAPI NtUserGetCursorInfo( CURSORINFO *info );
 765 HDC     WINAPI NtUserGetDC( HWND hwnd );
 766 HDC     WINAPI NtUserGetDCEx( HWND hwnd, HRGN clip_rgn, DWORD flags );
 767 LONG    WINAPI NtUserGetDisplayConfigBufferSizes( UINT32 flags, UINT32 *num_path_info,
 768                                                   UINT32 *num_mode_info );
 769 UINT    WINAPI NtUserGetDoubleClickTime(void);
 770 BOOL    WINAPI NtUserGetDpiForMonitor( HMONITOR monitor, UINT type, UINT *x, UINT *y );
 771 HWND    WINAPI NtUserGetForegroundWindow(void);
 772 BOOL    WINAPI NtUserGetGUIThreadInfo( DWORD id, GUITHREADINFO *info );
 773 BOOL    WINAPI NtUserGetIconInfo( HICON icon, ICONINFO *info, UNICODE_STRING *module,
 774                                   UNICODE_STRING *res_name, DWORD *bpp, LONG unk );
 775 BOOL    WINAPI NtUserGetIconSize( HICON handle, UINT step, LONG *width, LONG *height );
 776 UINT    WINAPI NtUserGetInternalWindowPos( HWND hwnd, RECT *rect, POINT *pt );
 777 INT     WINAPI NtUserGetKeyNameText( LONG lparam, WCHAR *buffer, INT size );
 778 SHORT   WINAPI NtUserGetKeyState( INT vkey );
 779 HKL     WINAPI NtUserGetKeyboardLayout( DWORD thread_id );
 780 UINT    WINAPI NtUserGetKeyboardLayoutList( INT size, HKL *layouts );
 781 BOOL    WINAPI NtUserGetKeyboardLayoutName( WCHAR *name );
 782 BOOL    WINAPI NtUserGetKeyboardState( BYTE *state );
 783 BOOL    WINAPI NtUserGetLayeredWindowAttributes( HWND hwnd, COLORREF *key, BYTE *alpha, DWORD *flags );
 784 BOOL    WINAPI NtUserGetMenuBarInfo( HWND hwnd, LONG id, LONG item, MENUBARINFO *info );
 785 BOOL    WINAPI NtUserGetMenuItemRect( HWND hwnd, HMENU menu, UINT item, RECT *rect );
 786 BOOL    WINAPI NtUserGetMessage( MSG *msg, HWND hwnd, UINT first, UINT last );
 787 int     WINAPI NtUserGetMouseMovePointsEx( UINT size, MOUSEMOVEPOINT *ptin, MOUSEMOVEPOINT *ptout,
 788                                            int count, DWORD resolution );
 789 BOOL    WINAPI NtUserGetObjectInformation( HANDLE handle, INT index, void *info,
 790                                            DWORD len, DWORD *needed );
 791 HWND    WINAPI NtUserGetOpenClipboardWindow(void);
 792 BOOL    WINAPI NtUserGetPointerInfoList( UINT32 id, POINTER_INPUT_TYPE type, UINT_PTR, UINT_PTR, SIZE_T size,
 793                                          UINT32 *entry_count, UINT32 *pointer_count, void *pointer_info );
 794 INT     WINAPI NtUserGetPriorityClipboardFormat( UINT *list, INT count );
 795 HWINSTA WINAPI NtUserGetProcessWindowStation(void);
 796 HANDLE  WINAPI NtUserGetProp( HWND hwnd, const WCHAR *str );
 797 ULONG   WINAPI NtUserGetProcessDpiAwarenessContext( HANDLE process );
 798 DWORD   WINAPI NtUserGetQueueStatus( UINT flags );
 799 UINT    WINAPI NtUserGetRawInputBuffer( RAWINPUT *data, UINT *data_size, UINT header_size );
 800 UINT    WINAPI NtUserGetRawInputData( HRAWINPUT rawinput, UINT command, void *data, UINT *data_size, UINT header_size );
 801 UINT    WINAPI NtUserGetRawInputDeviceInfo( HANDLE handle, UINT command, void *data, UINT *data_size );
 802 UINT    WINAPI NtUserGetRawInputDeviceList( RAWINPUTDEVICELIST *devices, UINT *device_count, UINT size );
 803 UINT    WINAPI NtUserGetRegisteredRawInputDevices( RAWINPUTDEVICE *devices, UINT *device_count, UINT size );
 804 BOOL    WINAPI NtUserGetScrollBarInfo( HWND hwnd, LONG id, SCROLLBARINFO *info );
 805 ULONG   WINAPI NtUserGetSystemDpiForProcess( HANDLE process );
 806 HMENU   WINAPI NtUserGetSystemMenu( HWND hwnd, BOOL revert );
 807 HDESK   WINAPI NtUserGetThreadDesktop( DWORD thread );
 808 BOOL    WINAPI NtUserGetTitleBarInfo( HWND hwnd, TITLEBARINFO *info );
 809 INT     WINAPI NtUserGetUpdateRgn( HWND hwnd, HRGN hrgn, BOOL erase );
 810 BOOL    WINAPI NtUserGetUpdatedClipboardFormats( UINT *formats, UINT size, UINT *out_size );
 811 BOOL    WINAPI NtUserGetUpdateRect( HWND hwnd, RECT *rect, BOOL erase );
 812 HDC     WINAPI NtUserGetWindowDC( HWND hwnd );
 813 BOOL    WINAPI NtUserGetWindowPlacement( HWND hwnd, WINDOWPLACEMENT *placement );
 814 int     WINAPI NtUserGetWindowRgnEx( HWND hwnd, HRGN hrgn, UINT unk );
 815 BOOL    WINAPI NtUserHideCaret( HWND hwnd );
 816 BOOL    WINAPI NtUserHiliteMenuItem( HWND hwnd, HMENU handle, UINT item, UINT hilite );
 817 NTSTATUS WINAPI NtUserInitializeClientPfnArrays( const struct user_client_procs *client_procsA,
 818                                                  const struct user_client_procs *client_procsW,
 819                                                  const void *client_workers, HINSTANCE user_module );
 820 HICON   WINAPI NtUserInternalGetWindowIcon( HWND hwnd, UINT type );
 821 INT     WINAPI NtUserInternalGetWindowText( HWND hwnd, WCHAR *text, INT count );
 822 BOOL    WINAPI NtUserIsClipboardFormatAvailable( UINT format );
 823 BOOL    WINAPI NtUserIsMouseInPointerEnabled(void);
 824 BOOL    WINAPI NtUserInvalidateRect( HWND hwnd, const RECT *rect, BOOL erase );
 825 BOOL    WINAPI NtUserInvalidateRgn( HWND hwnd, HRGN hrgn, BOOL erase );
 826 BOOL    WINAPI NtUserKillTimer( HWND hwnd, UINT_PTR id );
 827 BOOL    WINAPI NtUserLockWindowUpdate( HWND hwnd );
 828 BOOL    WINAPI NtUserLogicalToPerMonitorDPIPhysicalPoint( HWND hwnd, POINT *pt );
 829 UINT    WINAPI NtUserMapVirtualKeyEx( UINT code, UINT type, HKL layout );
 830 INT     WINAPI NtUserMenuItemFromPoint( HWND hwnd, HMENU handle, int x, int y );
 831 LRESULT WINAPI NtUserMessageCall( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
 832                                   void *result_info, DWORD type, BOOL ansi );
 833 BOOL    WINAPI NtUserMoveWindow( HWND hwnd, INT x, INT y, INT cx, INT cy, BOOL repaint );
 834 DWORD   WINAPI NtUserMsgWaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
 835                                                   DWORD timeout, DWORD mask, DWORD flags );
 836 void    WINAPI NtUserNotifyIMEStatus( HWND hwnd, UINT status );
 837 void    WINAPI NtUserNotifyWinEvent( DWORD event, HWND hwnd, LONG object_id, LONG child_id );
 838 HWINSTA WINAPI NtUserOpenWindowStation( OBJECT_ATTRIBUTES *attr, ACCESS_MASK access );
 839 BOOL    WINAPI NtUserOpenClipboard( HWND hwnd, ULONG unk );
 840 HDESK   WINAPI NtUserOpenDesktop( OBJECT_ATTRIBUTES *attr, DWORD flags, ACCESS_MASK access );
 841 HDESK   WINAPI NtUserOpenInputDesktop( DWORD flags, BOOL inherit, ACCESS_MASK access );
 842 BOOL    WINAPI NtUserPeekMessage( MSG *msg_out, HWND hwnd, UINT first, UINT last, UINT flags );
 843 BOOL    WINAPI NtUserPerMonitorDPIPhysicalToLogicalPoint( HWND hwnd, POINT *pt );
 844 BOOL    WINAPI NtUserPostMessage( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam );
 845 BOOL    WINAPI NtUserPostThreadMessage( DWORD thread, UINT msg, WPARAM wparam, LPARAM lparam );
 846 BOOL    WINAPI NtUserPrintWindow( HWND hwnd, HDC hdc, UINT flags );
 847 LONG    WINAPI NtUserQueryDisplayConfig( UINT32 flags, UINT32 *paths_count, DISPLAYCONFIG_PATH_INFO *paths,
 848                                          UINT32 *modes_count, DISPLAYCONFIG_MODE_INFO *modes,
 849                                          DISPLAYCONFIG_TOPOLOGY_ID *topology_id);
 850 UINT_PTR WINAPI NtUserQueryInputContext( HIMC handle, UINT attr );
 851 HWND    WINAPI NtUserRealChildWindowFromPoint( HWND parent, LONG x, LONG y );
 852 BOOL    WINAPI NtUserRedrawWindow( HWND hwnd, const RECT *rect, HRGN hrgn, UINT flags );
 853 ATOM    WINAPI NtUserRegisterClassExWOW( const WNDCLASSEXW *wc, UNICODE_STRING *name, UNICODE_STRING *version,
 854                                          struct client_menu_name *client_menu_name, DWORD fnid, DWORD flags,
 855                                          DWORD *wow );
 856 BOOL    WINAPI NtUserRegisterHotKey( HWND hwnd, INT id, UINT modifiers, UINT vk );
 857 BOOL    WINAPI NtUserRegisterRawInputDevices( const RAWINPUTDEVICE *devices, UINT device_count, UINT size );
 858 INT     WINAPI NtUserReleaseDC( HWND hwnd, HDC hdc );
 859 BOOL    WINAPI NtUserRemoveClipboardFormatListener( HWND hwnd );
 860 BOOL    WINAPI NtUserRemoveMenu( HMENU menu, UINT id, UINT flags );
 861 HANDLE  WINAPI NtUserRemoveProp( HWND hwnd, const WCHAR *str );
 862 BOOL    WINAPI NtUserScrollDC( HDC hdc, INT dx, INT dy, const RECT *scroll, const RECT *clip,
 863                                HRGN ret_update_rgn, RECT *update_rect );
 864 INT     WINAPI NtUserScrollWindowEx( HWND hwnd, INT dx, INT dy, const RECT *rect,
 865                                      const RECT *clip_rect, HRGN update_rgn,
 866                                      RECT *update_rect, UINT flags ) DECLSPEC_HIDDEN;
 867 HPALETTE WINAPI NtUserSelectPalette( HDC hdc, HPALETTE palette, WORD force_background );
 868 UINT     WINAPI NtUserSendInput( UINT count, INPUT *inputs, int size );
 869 HWND     WINAPI NtUserSetActiveWindow( HWND hwnd );
 870 HWND     WINAPI NtUserSetCapture( HWND hwnd );
 871 DWORD    WINAPI NtUserSetClassLong( HWND hwnd, INT offset, LONG newval, BOOL ansi );
 872 ULONG_PTR WINAPI NtUserSetClassLongPtr( HWND hwnd, INT offset, LONG_PTR newval, BOOL ansi );
 873 WORD    WINAPI NtUserSetClassWord( HWND hwnd, INT offset, WORD newval );
 874 NTSTATUS WINAPI NtUserSetClipboardData( UINT format, HANDLE handle, struct set_clipboard_params *params );
 875 HWND    WINAPI NtUserSetClipboardViewer( HWND hwnd );
 876 HCURSOR WINAPI NtUserSetCursor( HCURSOR cursor );
 877 BOOL    WINAPI NtUserSetCursorIconData( HCURSOR cursor, UNICODE_STRING *module, UNICODE_STRING *res_name,
 878                                         struct cursoricon_desc *desc );
 879 BOOL    WINAPI NtUserSetCursorPos( INT x, INT y );
 880 HWND    WINAPI NtUserSetFocus( HWND hwnd );
 881 void    WINAPI NtUserSetInternalWindowPos( HWND hwnd, UINT cmd, RECT *rect, POINT *pt );
 882 BOOL    WINAPI NtUserSetKeyboardState( BYTE *state );
 883 BOOL    WINAPI NtUserSetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags );
 884 BOOL    WINAPI NtUserSetMenu( HWND hwnd, HMENU menu );
 885 BOOL    WINAPI NtUserSetMenuContextHelpId( HMENU handle, DWORD id );
 886 BOOL    WINAPI NtUserSetMenuDefaultItem( HMENU handle, UINT item, UINT bypos );
 887 BOOL    WINAPI NtUserSetObjectInformation( HANDLE handle, INT index, void *info, DWORD len );
 888 HWND    WINAPI NtUserSetParent( HWND hwnd, HWND parent );
 889 BOOL    WINAPI NtUserSetProcessDpiAwarenessContext( ULONG awareness, ULONG unknown );
 890 BOOL    WINAPI NtUserSetProcessWindowStation( HWINSTA handle );
 891 BOOL    WINAPI NtUserSetProp( HWND hwnd, const WCHAR *str, HANDLE handle );
 892 INT     WINAPI NtUserSetScrollInfo( HWND hwnd, INT bar, const SCROLLINFO *info, BOOL redraw );
 893 BOOL    WINAPI NtUserSetShellWindowEx( HWND shell, HWND list_view );
 894 BOOL    WINAPI NtUserSetSysColors( INT count, const INT *colors, const COLORREF *values );
 895 BOOL    WINAPI NtUserSetSystemMenu( HWND hwnd, HMENU menu );
 896 UINT_PTR WINAPI NtUserSetSystemTimer( HWND hwnd, UINT_PTR id, UINT timeout );
 897 BOOL    WINAPI NtUserSetThreadDesktop( HDESK handle );
 898 UINT_PTR WINAPI NtUserSetTimer( HWND hwnd, UINT_PTR id, UINT timeout, TIMERPROC proc, ULONG tolerance );
 899 LONG    WINAPI NtUserSetWindowLong( HWND hwnd, INT offset, LONG newval, BOOL ansi );
 900 LONG_PTR WINAPI NtUserSetWindowLongPtr( HWND hwnd, INT offset, LONG_PTR newval, BOOL ansi );
 901 BOOL    WINAPI NtUserSetWindowPlacement( HWND hwnd, const WINDOWPLACEMENT *wpl );
 902 BOOL    WINAPI NtUserSetWindowPos( HWND hwnd, HWND after, INT x, INT y, INT cx, INT cy, UINT flags );
 903 int     WINAPI NtUserSetWindowRgn( HWND hwnd, HRGN hrgn, BOOL redraw );
 904 WORD    WINAPI NtUserSetWindowWord( HWND hwnd, INT offset, WORD newval );
 905 HHOOK   WINAPI NtUserSetWindowsHookEx( HINSTANCE inst, UNICODE_STRING *module, DWORD tid, INT id,
 906                                        HOOKPROC proc, BOOL ansi );
 907 HWINEVENTHOOK WINAPI NtUserSetWinEventHook( DWORD event_min, DWORD event_max, HMODULE inst,
 908                                             UNICODE_STRING *module, WINEVENTPROC proc,
 909                                             DWORD pid, DWORD tid, DWORD flags );
 910 BOOL    WINAPI NtUserShowCaret( HWND hwnd );
 911 INT     WINAPI NtUserShowCursor( BOOL show );
 912 BOOL    WINAPI NtUserShowScrollBar( HWND hwnd, INT bar, BOOL show );
 913 BOOL    WINAPI NtUserShowWindow( HWND hwnd, INT cmd );
 914 BOOL    WINAPI NtUserShowWindowAsync( HWND hwnd, INT cmd );
 915 BOOL    WINAPI NtUserSystemParametersInfo( UINT action, UINT val, void *ptr, UINT winini );
 916 BOOL    WINAPI NtUserSystemParametersInfoForDpi( UINT action, UINT val, PVOID ptr, UINT winini, UINT dpi );
 917 BOOL    WINAPI NtUserThunkedMenuInfo( HMENU menu, const MENUINFO *info );
 918 UINT    WINAPI NtUserThunkedMenuItemInfo( HMENU menu, UINT pos, UINT flags, UINT method,
 919                                           MENUITEMINFOW *info, UNICODE_STRING *str );
 920 INT     WINAPI NtUserToUnicodeEx( UINT virt, UINT scan, const BYTE *state,
 921                                   WCHAR *str, int size, UINT flags, HKL layout );
 922 BOOL    WINAPI NtUserTrackMouseEvent( TRACKMOUSEEVENT *info );
 923 BOOL    WINAPI NtUserTrackPopupMenuEx( HMENU handle, UINT flags, INT x, INT y, HWND hwnd, TPMPARAMS *params );
 924 INT     WINAPI NtUserTranslateAccelerator( HWND hwnd, HACCEL accel, MSG *msg );
 925 BOOL    WINAPI NtUserTranslateMessage( const MSG *msg, UINT flags );
 926 BOOL    WINAPI NtUserUnhookWinEvent( HWINEVENTHOOK hEventHook );
 927 BOOL    WINAPI NtUserUnhookWindowsHookEx( HHOOK handle );
 928 BOOL    WINAPI NtUserUnregisterClass( UNICODE_STRING *name, HINSTANCE instance,
 929                                       struct client_menu_name *client_menu_name );
 930 BOOL    WINAPI NtUserUnregisterHotKey( HWND hwnd, INT id );
 931 BOOL    WINAPI NtUserUpdateInputContext( HIMC handle, UINT attr, UINT_PTR value );
 932 BOOL    WINAPI NtUserUpdateLayeredWindow( HWND hwnd, HDC hdc_dst, const POINT *pts_dst, const SIZE *size,
 933                                           HDC hdc_src, const POINT *pts_src, COLORREF key,
 934                                           const BLENDFUNCTION *blend, DWORD flags, const RECT *dirty );
 935 BOOL    WINAPI NtUserValidateRect( HWND hwnd, const RECT *rect );
 936 WORD    WINAPI NtUserVkKeyScanEx( WCHAR chr, HKL layout );
 937 DWORD   WINAPI NtUserWaitForInputIdle( HANDLE process, DWORD timeout, BOOL wow );
 938 BOOL    WINAPI NtUserWaitMessage(void);
 939 HWND    WINAPI NtUserWindowFromDC( HDC hdc );
 940 HWND    WINAPI NtUserWindowFromPoint( LONG x, LONG y );
 941
 942 /* NtUserCallNoParam codes, not compatible with Windows */
 943 enum
 944 {
 945     NtUserCallNoParam_DestroyCaret,
 946     NtUserCallNoParam_GetDesktopWindow,
 947     NtUserCallNoParam_GetDialogBaseUnits,
 948     NtUserCallNoParam_GetInputState,
 949     NtUserCallNoParam_GetProcessDefaultLayout,
 950     NtUserCallNoParam_GetProgmanWindow,
 951     NtUserCallNoParam_GetShellWindow,
 952     NtUserCallNoParam_GetTaskmanWindow,
 953     NtUserCallNoParam_ReleaseCapture,
 954     /* temporary exports */
 955     NtUserExitingThread,
 956     NtUserThreadDetach,
 957 };
 958
 959 static inline BOOL NtUserDestroyCaret(void)
 960 {
 961     return NtUserCallNoParam( NtUserCallNoParam_DestroyCaret );
 962 }
 963
 964 static inline HWND NtUserGetDesktopWindow(void)
 965 {
 966     return UlongToHandle( NtUserCallNoParam( NtUserCallNoParam_GetDesktopWindow ));
 967 }
 968
 969 static inline DWORD NtUserGetDialogBaseUnits(void)
 970 {
 971     return NtUserCallNoParam( NtUserCallNoParam_GetDialogBaseUnits );
 972 };
 973
 974 static inline BOOL NtUserGetInputState(void)
 975 {
 976     return NtUserCallNoParam( NtUserCallNoParam_GetInputState );
 977 }
 978
 979 static inline DWORD NtUserGetProcessDefaultLayout(void)
 980 {
 981     return NtUserCallNoParam( NtUserCallNoParam_GetProcessDefaultLayout );
 982 }
 983
 984 static inline HWND NtUserGetProgmanWindow(void)
 985 {
 986     return UlongToHandle( NtUserCallNoParam( NtUserCallNoParam_GetProgmanWindow ));
 987 }
 988
 989 static inline HWND NtUserGetShellWindow(void)
 990 {
 991     return UlongToHandle( NtUserCallNoParam( NtUserCallNoParam_GetShellWindow ));
 992 }
 993
 994 static inline HWND NtUserGetTaskmanWindow(void)
 995 {
 996     return UlongToHandle( NtUserCallNoParam( NtUserCallNoParam_GetTaskmanWindow ));
 997 }
 998
 999 static inline BOOL NtUserReleaseCapture(void)
1000 {
1001     return NtUserCallNoParam( NtUserCallNoParam_ReleaseCapture );
1002 }
1003
1004 /* NtUserCallOneParam codes, not compatible with Windows */
1005 enum
1006 {
1007     NtUserCallOneParam_BeginDeferWindowPos,
1008     NtUserCallOneParam_CreateCursorIcon,
1009     NtUserCallOneParam_CreateMenu,
1010     NtUserCallOneParam_EnableDC,
1011     NtUserCallOneParam_EnableThunkLock,
1012     NtUserCallOneParam_EnumClipboardFormats,
1013     NtUserCallOneParam_GetClipCursor,
1014     NtUserCallOneParam_GetCursorPos,
1015     NtUserCallOneParam_GetIconParam,
1016     NtUserCallOneParam_GetMenuItemCount,
1017     NtUserCallOneParam_GetPrimaryMonitorRect,
1018     NtUserCallOneParam_GetSysColor,
1019     NtUserCallOneParam_GetSysColorBrush,
1020     NtUserCallOneParam_GetSysColorPen,
1021     NtUserCallOneParam_GetSystemMetrics,
1022     NtUserCallOneParam_GetVirtualScreenRect,
1023     NtUserCallOneParam_IsWindowRectFullScreen,
1024     NtUserCallOneParam_MessageBeep,
1025     NtUserCallOneParam_RealizePalette,
1026     NtUserCallOneParam_ReplyMessage,
1027     NtUserCallOneParam_SetCaretBlinkTime,
1028     NtUserCallOneParam_SetProcessDefaultLayout,
1029     /* temporary exports */
1030     NtUserGetDeskPattern,
1031 };
1032
1033 static inline HDWP NtUserBeginDeferWindowPos( INT count )
1034 {
1035     return UlongToHandle( NtUserCallOneParam( count, NtUserCallOneParam_BeginDeferWindowPos ));
1036 }
1037
1038 static inline HICON NtUserCreateCursorIcon( BOOL is_icon )
1039 {
1040     return UlongToHandle( NtUserCallOneParam( is_icon, NtUserCallOneParam_CreateCursorIcon ));
1041 }
1042
1043 static inline HMENU NtUserCreateMenu( BOOL is_popup )
1044 {
1045     return UlongToHandle( NtUserCallOneParam( is_popup, NtUserCallOneParam_CreateMenu ));
1046 }
1047
1048 static inline WORD NtUserEnableDC( HDC hdc )
1049 {
1050     return NtUserCallOneParam( HandleToUlong(hdc), NtUserCallOneParam_EnableDC );
1051 }
1052
1053 static inline void NtUserEnableThunkLock( BOOL enable )
1054 {
1055     NtUserCallOneParam( enable, NtUserCallOneParam_EnableThunkLock );
1056 }
1057
1058 static inline UINT NtUserEnumClipboardFormats( UINT format )
1059 {
1060     return NtUserCallOneParam( format, NtUserCallOneParam_EnumClipboardFormats );
1061 }
1062
1063 static inline BOOL NtUserGetClipCursor( RECT *rect )
1064 {
1065     return NtUserCallOneParam( (UINT_PTR)rect, NtUserCallOneParam_GetClipCursor );
1066 }
1067
1068 static inline BOOL NtUserGetCursorPos( POINT *pt )
1069 {
1070     return NtUserCallOneParam( (UINT_PTR)pt, NtUserCallOneParam_GetCursorPos );
1071 }
1072
1073 static inline UINT_PTR NtUserGetIconParam( HICON icon )
1074 {
1075     return NtUserCallOneParam( HandleToUlong(icon), NtUserCallOneParam_GetIconParam );
1076 }
1077
1078 static inline UINT_PTR NtUserGetMenuItemCount( HMENU menu )
1079 {
1080     return NtUserCallOneParam( HandleToUlong(menu), NtUserCallOneParam_GetMenuItemCount );
1081 }
1082
1083 static inline RECT NtUserGetPrimaryMonitorRect(void)
1084 {
1085     RECT primary;
1086     NtUserCallOneParam( (UINT_PTR)&primary, NtUserCallOneParam_GetPrimaryMonitorRect );
1087     return primary;
1088 }
1089
1090 static inline BOOL NtUserSetCaretBlinkTime( unsigned int time )
1091 {
1092     return NtUserCallOneParam( time, NtUserCallOneParam_SetCaretBlinkTime );
1093 }
1094
1095 static inline COLORREF NtUserGetSysColor( INT index )
1096 {
1097     return NtUserCallOneParam( index, NtUserCallOneParam_GetSysColor );
1098 }
1099
1100 static inline HBRUSH NtUserGetSysColorBrush( INT index )
1101 {
1102     return UlongToHandle( NtUserCallOneParam( index, NtUserCallOneParam_GetSysColorBrush ));
1103 }
1104
1105 static inline HPEN NtUserGetSysColorPen( INT index )
1106 {
1107     return UlongToHandle( NtUserCallOneParam( index, NtUserCallOneParam_GetSysColorPen ));
1108 }
1109
1110 static inline INT NtUserGetSystemMetrics( INT index )
1111 {
1112     return NtUserCallOneParam( index, NtUserCallOneParam_GetSystemMetrics );
1113 }
1114
1115 static inline RECT NtUserGetVirtualScreenRect(void)
1116 {
1117     RECT virtual;
1118     NtUserCallOneParam( (UINT_PTR)&virtual, NtUserCallOneParam_GetVirtualScreenRect );
1119     return virtual;
1120 }
1121
1122 static inline BOOL NtUserIsWindowRectFullScreen( const RECT *rect )
1123 {
1124     return NtUserCallOneParam( (UINT_PTR)rect, NtUserCallOneParam_IsWindowRectFullScreen );
1125 }
1126
1127 static inline BOOL NtUserMessageBeep( UINT i )
1128 {
1129     return NtUserCallOneParam( i, NtUserCallOneParam_MessageBeep );
1130 }
1131
1132 static inline UINT NtUserRealizePalette( HDC hdc )
1133 {
1134     return NtUserCallOneParam( HandleToUlong(hdc), NtUserCallOneParam_RealizePalette );
1135 }
1136
1137 static inline BOOL NtUserReplyMessage( LRESULT result )
1138 {
1139     return NtUserCallOneParam( result, NtUserCallOneParam_ReplyMessage );
1140 }
1141
1142 static inline UINT NtUserSetProcessDefaultLayout( DWORD layout )
1143 {
1144     return NtUserCallOneParam( layout, NtUserCallOneParam_SetProcessDefaultLayout );
1145 }
1146
1147 /* NtUserCallTwoParam codes, not compatible with Windows */
1148 enum
1149 {
1150     NtUserCallTwoParam_GetDialogProc,
1151     NtUserCallTwoParam_GetMenuInfo,
1152     NtUserCallTwoParam_GetMonitorInfo,
1153     NtUserCallTwoParam_GetSystemMetricsForDpi,
1154     NtUserCallTwoParam_MonitorFromRect,
1155     NtUserCallTwoParam_SetCaretPos,
1156     NtUserCallTwoParam_SetIconParam,
1157     NtUserCallTwoParam_UnhookWindowsHook,
1158     /* temporary exports */
1159     NtUserAllocWinProc,
1160 };
1161
1162 static inline DLGPROC NtUserGetDialogProc( DLGPROC proc, BOOL ansi )
1163 {
1164     return (DLGPROC)NtUserCallTwoParam( (UINT_PTR)proc, ansi, NtUserCallTwoParam_GetDialogProc );
1165 }
1166
1167 static inline BOOL NtUserGetMenuInfo( HMENU menu, MENUINFO *info )
1168 {
1169     return NtUserCallTwoParam( HandleToUlong(menu), (ULONG_PTR)info,
1170                                NtUserCallTwoParam_GetMenuInfo );
1171 }
1172
1173 static inline BOOL NtUserGetMonitorInfo( HMONITOR monitor, MONITORINFO *info )
1174 {
1175     return NtUserCallTwoParam( HandleToUlong(monitor), (ULONG_PTR)info,
1176                                NtUserCallTwoParam_GetMonitorInfo );
1177 }
1178
1179 static inline INT NtUserGetSystemMetricsForDpi( INT index, UINT dpi )
1180 {
1181     return NtUserCallTwoParam( index, dpi, NtUserCallTwoParam_GetSystemMetricsForDpi );
1182 }
1183
1184 static inline HMONITOR NtUserMonitorFromRect( const RECT *rect, DWORD flags )
1185 {
1186     ULONG ret = NtUserCallTwoParam( (LONG_PTR)rect, flags, NtUserCallTwoParam_MonitorFromRect );
1187     return UlongToHandle( ret );
1188 }
1189
1190 static inline BOOL NtUserSetCaretPos( int x, int y )
1191 {
1192     return NtUserCallTwoParam( x, y, NtUserCallTwoParam_SetCaretPos );
1193 }
1194
1195 static inline UINT_PTR NtUserSetIconParam( HICON icon, ULONG_PTR param )
1196 {
1197     return NtUserCallTwoParam( HandleToUlong(icon), param, NtUserCallTwoParam_SetIconParam );
1198 }
1199
1200 static inline BOOL NtUserUnhookWindowsHook( INT id, HOOKPROC proc )
1201 {
1202     return NtUserCallTwoParam( id, (UINT_PTR)proc, NtUserCallTwoParam_UnhookWindowsHook );
1203 }
1204
1205 /* NtUserCallHwnd codes, not compatible with Windows */
1206 enum
1207 {
1208     NtUserCallHwnd_ActivateOtherWindow,
1209     NtUserCallHwnd_ArrangeIconicWindows,
1210     NtUserCallHwnd_DrawMenuBar,
1211     NtUserCallHwnd_GetDefaultImeWindow,
1212     NtUserCallHwnd_GetDialogInfo,
1213     NtUserCallHwnd_GetDpiForWindow,
1214     NtUserCallHwnd_GetMDIClientInfo,
1215     NtUserCallHwnd_GetParent,
1216     NtUserCallHwnd_GetWindowContextHelpId,
1217     NtUserCallHwnd_GetWindowDpiAwarenessContext,
1218     NtUserCallHwnd_GetWindowInputContext,
1219     NtUserCallHwnd_GetWindowSysSubMenu,
1220     NtUserCallHwnd_GetWindowTextLength,
1221     NtUserCallHwnd_IsWindow,
1222     NtUserCallHwnd_IsWindowEnabled,
1223     NtUserCallHwnd_IsWindowUnicode,
1224     NtUserCallHwnd_IsWindowVisible,
1225     NtUserCallHwnd_SetForegroundWindow,
1226     NtUserCallHwnd_SetProgmanWindow,
1227     NtUserCallHwnd_SetTaskmanWindow,
1228     /* temporary exports */
1229     NtUserGetFullWindowHandle,
1230     NtUserIsCurrehtProcessWindow,
1231     NtUserIsCurrehtThreadWindow,
1232 };
1233
1234 static inline void NtUserActivateOtherWindow( HWND hwnd )
1235 {
1236     NtUserCallHwnd( hwnd, NtUserCallHwnd_ActivateOtherWindow );
1237 }
1238
1239 static inline UINT NtUserArrangeIconicWindows( HWND parent )
1240 {
1241     return NtUserCallHwnd( parent, NtUserCallHwnd_ArrangeIconicWindows );
1242 }
1243
1244 static inline BOOL NtUserDrawMenuBar( HWND hwnd )
1245 {
1246     return NtUserCallHwnd( hwnd, NtUserCallHwnd_DrawMenuBar );
1247 }
1248
1249 static inline DWORD NtUserGetWindowContextHelpId( HWND hwnd )
1250 {
1251     return NtUserCallHwnd( hwnd, NtUserCallHwnd_GetWindowContextHelpId );
1252 }
1253
1254 static inline HWND NtUserGetDefaultImeWindow( HWND hwnd )
1255 {
1256     return UlongToHandle( NtUserCallHwnd( hwnd, NtUserCallHwnd_GetDefaultImeWindow ));
1257 }
1258
1259 static inline void *NtUserGetDialogInfo( HWND hwnd )
1260 {
1261     return (void *)NtUserCallHwnd( hwnd, NtUserCallHwnd_GetDialogInfo );
1262 }
1263
1264 static inline UINT NtUserGetDpiForWindow( HWND hwnd )
1265 {
1266     return NtUserCallHwnd( hwnd, NtUserCallHwnd_GetDpiForWindow );
1267 }
1268
1269 static inline void *NtUserGetMDIClientInfo( HWND hwnd )
1270 {
1271     return (void *)NtUserCallHwnd( hwnd, NtUserCallHwnd_GetMDIClientInfo );
1272 }
1273
1274 static inline HWND NtUserGetParent( HWND hwnd )
1275 {
1276     return UlongToHandle( NtUserCallHwnd( hwnd, NtUserCallHwnd_GetParent ));
1277 }
1278
1279 static inline DPI_AWARENESS_CONTEXT NtUserGetWindowDpiAwarenessContext( HWND hwnd )
1280 {
1281     return (DPI_AWARENESS_CONTEXT)NtUserCallHwnd( hwnd,
1282                                                   NtUserCallHwnd_GetWindowDpiAwarenessContext );
1283 }
1284
1285 static inline HIMC NtUserGetWindowInputContext( HWND hwnd )
1286 {
1287     return UlongToHandle( NtUserCallHwnd( hwnd, NtUserCallHwnd_GetWindowInputContext ));
1288 }
1289
1290 static inline HMENU NtUserGetWindowSysSubMenu( HWND hwnd )
1291 {
1292     return UlongToHandle( NtUserCallHwnd( hwnd, NtUserCallHwnd_GetWindowSysSubMenu ));
1293 }
1294
1295 static inline INT NtUserGetWindowTextLength( HWND hwnd )
1296 {
1297     return NtUserCallHwnd( hwnd, NtUserCallHwnd_GetWindowTextLength );
1298 }
1299
1300 static inline BOOL NtUserIsWindow( HWND hwnd )
1301 {
1302     return NtUserCallHwnd( hwnd, NtUserCallHwnd_IsWindow );
1303 }
1304
1305 static inline BOOL NtUserIsWindowEnabled( HWND hwnd )
1306 {
1307     return NtUserCallHwnd( hwnd, NtUserCallHwnd_IsWindowEnabled );
1308 }
1309
1310 static inline BOOL NtUserIsWindowUnicode( HWND hwnd )
1311 {
1312     return NtUserCallHwnd( hwnd, NtUserCallHwnd_IsWindowUnicode );
1313 }
1314
1315 static inline BOOL NtUserIsWindowVisible( HWND hwnd )
1316 {
1317     return NtUserCallHwnd( hwnd, NtUserCallHwnd_IsWindowVisible );
1318 }
1319
1320 static inline BOOL NtUserSetForegroundWindow( HWND hwnd )
1321 {
1322     return NtUserCallHwnd( hwnd, NtUserCallHwnd_SetForegroundWindow );
1323 }
1324
1325 static inline HWND NtUserSetProgmanWindow( HWND hwnd )
1326 {
1327     return UlongToHandle( NtUserCallHwnd( hwnd, NtUserCallHwnd_SetProgmanWindow ));
1328 }
1329
1330 static inline HWND NtUserSetTaskmanWindow( HWND hwnd )
1331 {
1332     return UlongToHandle( NtUserCallHwnd( hwnd, NtUserCallHwnd_SetTaskmanWindow ));
1333 }
1334
1335 /* NtUserCallHwndParam codes, not compatible with Windows */
1336 enum
1337 {
1338     NtUserCallHwndParam_ClientToScreen,
1339     NtUserCallHwndParam_EnableWindow,
1340     NtUserCallHwndParam_GetChildRect,
1341     NtUserCallHwndParam_GetClassLongA,
1342     NtUserCallHwndParam_GetClassLongW,
1343     NtUserCallHwndParam_GetClassLongPtrA,
1344     NtUserCallHwndParam_GetClassLongPtrW,
1345     NtUserCallHwndParam_GetClassWord,
1346     NtUserCallHwndParam_GetClientRect,
1347     NtUserCallHwndParam_GetScrollInfo,
1348     NtUserCallHwndParam_GetWindowInfo,
1349     NtUserCallHwndParam_GetWindowLongA,
1350     NtUserCallHwndParam_GetWindowLongW,
1351     NtUserCallHwndParam_GetWindowLongPtrA,
1352     NtUserCallHwndParam_GetWindowLongPtrW,
1353     NtUserCallHwndParam_GetWindowRect,
1354     NtUserCallHwndParam_GetWindowRelative,
1355     NtUserCallHwndParam_GetWindowThread,
1356     NtUserCallHwndParam_GetWindowWord,
1357     NtUserCallHwndParam_IsChild,
1358     NtUserCallHwndParam_KillSystemTimer,
1359     NtUserCallHwndParam_MapWindowPoints,
1360     NtUserCallHwndParam_MirrorRgn,
1361     NtUserCallHwndParam_MonitorFromWindow,
1362     NtUserCallHwndParam_ScreenToClient,
1363     NtUserCallHwndParam_SetDialogInfo,
1364     NtUserCallHwndParam_SetMDIClientInfo,
1365     NtUserCallHwndParam_SetWindowContextHelpId,
1366     NtUserCallHwndParam_ShowOwnedPopups,
1367     /* temporary exports */
1368     NtUserSetWindowStyle,
1369 };
1370
1371 static inline BOOL NtUserClientToScreen( HWND hwnd, POINT *pt )
1372 {
1373     return NtUserCallHwndParam( hwnd, (UINT_PTR)pt, NtUserCallHwndParam_ClientToScreen );
1374 }
1375
1376 static inline BOOL NtUserEnableWindow( HWND hwnd, BOOL enable )
1377 {
1378     return NtUserCallHwndParam( hwnd, enable, NtUserCallHwndParam_EnableWindow );
1379 }
1380
1381 static inline BOOL NtUserGetChildRect( HWND hwnd, RECT *rect )
1382 {
1383     return NtUserCallHwndParam( hwnd, (UINT_PTR)rect, NtUserCallHwndParam_GetChildRect );
1384 }
1385
1386 static inline DWORD NtUserGetClassLongA( HWND hwnd, INT offset )
1387 {
1388     return NtUserCallHwndParam( hwnd, offset, NtUserCallHwndParam_GetClassLongA );
1389 }
1390
1391 static inline ULONG_PTR NtUserGetClassLongPtrA( HWND hwnd, INT offset )
1392 {
1393     return NtUserCallHwndParam( hwnd, offset, NtUserCallHwndParam_GetClassLongPtrA );
1394 }
1395
1396 static inline ULONG_PTR NtUserGetClassLongPtrW( HWND hwnd, INT offset )
1397 {
1398     return NtUserCallHwndParam( hwnd, offset, NtUserCallHwndParam_GetClassLongPtrW );
1399 }
1400
1401 static inline DWORD NtUserGetClassLongW( HWND hwnd, INT offset )
1402 {
1403     return NtUserCallHwndParam( hwnd, offset, NtUserCallHwndParam_GetClassLongW );
1404 }
1405
1406 static inline WORD NtUserGetClassWord( HWND hwnd, INT offset )
1407 {
1408     return NtUserCallHwndParam( hwnd, offset, NtUserCallHwndParam_GetClassWord );
1409 }
1410
1411 static inline BOOL NtUserGetClientRect( HWND hwnd, RECT *rect )
1412 {
1413     return NtUserCallHwndParam( hwnd, (UINT_PTR)rect, NtUserCallHwndParam_GetClientRect );
1414 }
1415
1416 struct get_scroll_info_params
1417 {
1418     int bar;
1419     SCROLLINFO *info;
1420 };
1421
1422 static inline BOOL NtUserGetScrollInfo( HWND hwnd, INT bar, SCROLLINFO *info )
1423 {
1424     struct get_scroll_info_params params = { .bar = bar, .info = info };
1425     return NtUserCallHwndParam( hwnd, (UINT_PTR)&params, NtUserCallHwndParam_GetScrollInfo );
1426 }
1427
1428 static inline BOOL NtUserGetWindowInfo( HWND hwnd, WINDOWINFO *info )
1429 {
1430     return NtUserCallHwndParam( hwnd, (UINT_PTR)info, NtUserCallHwndParam_GetWindowInfo );
1431 }
1432
1433 static inline LONG NtUserGetWindowLongA( HWND hwnd, INT offset )
1434 {
1435     return NtUserCallHwndParam( hwnd, offset, NtUserCallHwndParam_GetWindowLongA );
1436 }
1437
1438 static inline LONG_PTR NtUserGetWindowLongPtrA( HWND hwnd, INT offset )
1439 {
1440     return NtUserCallHwndParam( hwnd, offset, NtUserCallHwndParam_GetWindowLongPtrA );
1441 }
1442
1443 static inline LONG_PTR NtUserGetWindowLongPtrW( HWND hwnd, INT offset )
1444 {
1445     return NtUserCallHwndParam( hwnd, offset, NtUserCallHwndParam_GetWindowLongPtrW );
1446 }
1447
1448 static inline LONG NtUserGetWindowLongW( HWND hwnd, INT offset )
1449 {
1450     return NtUserCallHwndParam( hwnd, offset, NtUserCallHwndParam_GetWindowLongW );
1451 }
1452
1453 static inline BOOL NtUserGetWindowRect( HWND hwnd, RECT *rect )
1454 {
1455     return NtUserCallHwndParam( hwnd, (UINT_PTR)rect, NtUserCallHwndParam_GetWindowRect );
1456 }
1457
1458 static inline HWND NtUserGetWindowRelative( HWND hwnd, UINT rel )
1459 {
1460     return UlongToHandle( NtUserCallHwndParam( hwnd, rel,
1461                                                NtUserCallHwndParam_GetWindowRelative ));
1462 }
1463
1464 static inline DWORD NtUserGetWindowThread( HWND hwnd, DWORD *process )
1465 {
1466     return NtUserCallHwndParam( hwnd, (UINT_PTR)process, NtUserCallHwndParam_GetWindowThread );
1467 }
1468
1469 static inline WORD NtUserGetWindowWord( HWND hwnd, INT offset )
1470 {
1471     return NtUserCallHwndParam( hwnd, offset, NtUserCallHwndParam_GetWindowWord );
1472 }
1473
1474 static inline BOOL NtUserIsChild( HWND parent, HWND child )
1475 {
1476     return NtUserCallHwndParam( parent, HandleToUlong(child), NtUserCallHwndParam_IsChild );
1477 }
1478
1479 static inline BOOL NtUserKillSystemTimer( HWND hwnd, UINT_PTR id )
1480 {
1481     return NtUserCallHwndParam( hwnd, id, NtUserCallHwndParam_KillSystemTimer );
1482 }
1483
1484 struct map_window_points_params
1485 {
1486     HWND hwnd_to;
1487     POINT *points;
1488     UINT count;
1489 };
1490
1491 static inline int NtUserMapWindowPoints( HWND hwnd_from, HWND hwnd_to, POINT *points, UINT count )
1492 {
1493     struct map_window_points_params params;
1494     params.hwnd_to = hwnd_to;
1495     params.points = points;
1496     params.count = count;
1497     return NtUserCallHwndParam( hwnd_from, (UINT_PTR)&params,
1498                                 NtUserCallHwndParam_MapWindowPoints );
1499 }
1500
1501 static inline BOOL NtUserMirrorRgn( HWND hwnd, HRGN hrgn )
1502 {
1503     return NtUserCallHwndParam( hwnd, HandleToUlong(hrgn), NtUserCallHwndParam_MirrorRgn );
1504 }
1505
1506 static inline HMONITOR NtUserMonitorFromWindow( HWND hwnd, DWORD flags )
1507 {
1508     ULONG ret = NtUserCallHwndParam(  hwnd, flags, NtUserCallHwndParam_MonitorFromWindow );
1509     return UlongToHandle( ret );
1510 }
1511
1512 static inline BOOL NtUserScreenToClient( HWND hwnd, POINT *pt )
1513 {
1514     return NtUserCallHwndParam( hwnd, (UINT_PTR)pt, NtUserCallHwndParam_ScreenToClient );
1515 }
1516
1517 static inline void NtUserSetDialogInfo( HWND hwnd, void *info )
1518 {
1519     NtUserCallHwndParam( hwnd, (UINT_PTR)info, NtUserCallHwndParam_SetDialogInfo );
1520 }
1521
1522 static inline void NtUserSetMDIClientInfo( HWND hwnd, void *info )
1523 {
1524     NtUserCallHwndParam( hwnd, (UINT_PTR)info, NtUserCallHwndParam_SetMDIClientInfo );
1525 }
1526
1527 static inline BOOL NtUserSetWindowContextHelpId( HWND hwnd, DWORD id )
1528 {
1529     return NtUserCallHwndParam( hwnd, id, NtUserCallHwndParam_SetWindowContextHelpId );
1530 }
1531
1532 static inline BOOL NtUserShowOwnedPopups( HWND hwnd, BOOL show )
1533 {
1534     return NtUserCallHwndParam( hwnd, show, NtUserCallHwndParam_ShowOwnedPopups );
1535 }
1536
1537 /* Wine extensions */
1538 BOOL WINAPI __wine_send_input( HWND hwnd, const INPUT *input, const RAWINPUT *rawinput );
1539
1540 #endif /* _NTUSER_ */