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