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