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