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