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