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