mirror of
git://source.winehq.org/git/wine.git
synced 2024-10-14 18:37:17 +00:00
2209 lines
64 KiB
C
2209 lines
64 KiB
C
/*
|
|
* Win32u kernel interface
|
|
*
|
|
* Copyright 2021 Alexandre Julliard
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include "ntstatus.h"
|
|
#define WIN32_NO_STATUS
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "ntgdi.h"
|
|
#include "ntuser.h"
|
|
#include "wine/unixlib.h"
|
|
#include "wine/asm.h"
|
|
#include "win32syscalls.h"
|
|
|
|
void *__wine_syscall_dispatcher = NULL;
|
|
|
|
static unixlib_handle_t win32u_handle;
|
|
|
|
/*******************************************************************
|
|
* syscalls
|
|
*/
|
|
#ifdef __arm64ec__
|
|
enum syscall_ids
|
|
{
|
|
#define SYSCALL_ENTRY(id,name,args) __id_##name = id + 0x1000,
|
|
ALL_SYSCALLS64
|
|
#undef SYSCALL_ENTRY
|
|
};
|
|
|
|
#define SYSCALL_API __attribute__((naked))
|
|
|
|
INT SYSCALL_API NtGdiAbortDoc( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiAbortDoc );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiAbortPath( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiAbortPath );
|
|
}
|
|
|
|
HANDLE SYSCALL_API NtGdiAddFontMemResourceEx( void *ptr, DWORD size, void *dv, ULONG dv_size,
|
|
DWORD *count )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiAddFontMemResourceEx );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiAddFontResourceW( const WCHAR *str, ULONG size, ULONG files, DWORD flags,
|
|
DWORD tid, void *dv )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiAddFontResourceW );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiAlphaBlend( HDC hdcDst, int xDst, int yDst, int widthDst, int heightDst,
|
|
HDC hdcSrc, int xSrc, int ySrc, int widthSrc, int heightSrc,
|
|
DWORD blend_func, HANDLE xform )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiAlphaBlend );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiAngleArc( HDC hdc, INT x, INT y, DWORD dwRadius, DWORD start_angle, DWORD sweep_angle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiAngleArc );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiArcInternal( UINT type, HDC hdc, INT left, INT top, INT right,
|
|
INT bottom, INT xstart, INT ystart, INT xend, INT yend )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiArcInternal );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiBeginPath( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiBeginPath );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiBitBlt( HDC hdc_dst, INT x_dst, INT y_dst, INT width, INT height,
|
|
HDC hdc_src, INT x_src, INT y_src, DWORD rop, DWORD bk_color, FLONG fl )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiBitBlt );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiCloseFigure( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCloseFigure );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiCombineRgn( HRGN hDest, HRGN hSrc1, HRGN hSrc2, INT mode )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCombineRgn );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiComputeXformCoefficients( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiComputeXformCoefficients );
|
|
}
|
|
|
|
HBITMAP SYSCALL_API NtGdiCreateBitmap( INT width, INT height, UINT planes,
|
|
UINT bpp, const void *bits )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateBitmap );
|
|
}
|
|
|
|
HANDLE SYSCALL_API NtGdiCreateClientObj( ULONG type )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateClientObj );
|
|
}
|
|
|
|
HBITMAP SYSCALL_API NtGdiCreateCompatibleBitmap( HDC hdc, INT width, INT height )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateCompatibleBitmap );
|
|
}
|
|
|
|
HDC SYSCALL_API NtGdiCreateCompatibleDC( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateCompatibleDC );
|
|
}
|
|
|
|
HBRUSH SYSCALL_API NtGdiCreateDIBBrush( const void *data, UINT coloruse, UINT size,
|
|
BOOL is_8x8, BOOL pen, const void *client )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateDIBBrush );
|
|
}
|
|
|
|
HBITMAP SYSCALL_API NtGdiCreateDIBSection( HDC hdc, HANDLE section, DWORD offset, const BITMAPINFO *bmi,
|
|
UINT usage, UINT header_size, ULONG flags,
|
|
ULONG_PTR color_space, void **bits )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateDIBSection );
|
|
}
|
|
|
|
HBITMAP SYSCALL_API NtGdiCreateDIBitmapInternal( HDC hdc, INT width, INT height, DWORD init,
|
|
const void *bits, const BITMAPINFO *data,
|
|
UINT coloruse, UINT max_info, UINT max_bits,
|
|
ULONG flags, HANDLE xform )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateDIBitmapInternal );
|
|
}
|
|
|
|
HRGN SYSCALL_API NtGdiCreateEllipticRgn( INT left, INT top, INT right, INT bottom )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateEllipticRgn );
|
|
}
|
|
|
|
HPALETTE SYSCALL_API NtGdiCreateHalftonePalette( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateHalftonePalette );
|
|
}
|
|
|
|
HBRUSH SYSCALL_API NtGdiCreateHatchBrushInternal( INT style, COLORREF color, BOOL pen )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateHatchBrushInternal );
|
|
}
|
|
|
|
HDC SYSCALL_API NtGdiCreateMetafileDC( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateMetafileDC );
|
|
}
|
|
|
|
HPALETTE SYSCALL_API NtGdiCreatePaletteInternal( const LOGPALETTE *palette, UINT count )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreatePaletteInternal );
|
|
}
|
|
|
|
HBRUSH SYSCALL_API NtGdiCreatePatternBrushInternal( HBITMAP bitmap, BOOL pen, BOOL is_8x8 )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreatePatternBrushInternal );
|
|
}
|
|
|
|
HPEN SYSCALL_API NtGdiCreatePen( INT style, INT width, COLORREF color, HBRUSH brush )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreatePen );
|
|
}
|
|
|
|
HRGN SYSCALL_API NtGdiCreateRectRgn( INT left, INT top, INT right, INT bottom )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateRectRgn );
|
|
}
|
|
|
|
HRGN SYSCALL_API NtGdiCreateRoundRectRgn( INT left, INT top, INT right, INT bottom,
|
|
INT ellipse_width, INT ellipse_height )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateRoundRectRgn );
|
|
}
|
|
|
|
HBRUSH SYSCALL_API NtGdiCreateSolidBrush( COLORREF color, HBRUSH brush )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiCreateSolidBrush );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDICheckVidPnExclusiveOwnership( const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDICheckVidPnExclusiveOwnership );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDICloseAdapter( const D3DKMT_CLOSEADAPTER *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDICloseAdapter );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDICreateDCFromMemory( D3DKMT_CREATEDCFROMMEMORY *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDICreateDCFromMemory );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDICreateDevice( D3DKMT_CREATEDEVICE *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDICreateDevice );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDIDestroyDCFromMemory( const D3DKMT_DESTROYDCFROMMEMORY *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDIDestroyDCFromMemory );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDIDestroyDevice( const D3DKMT_DESTROYDEVICE *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDIDestroyDevice );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDIEscape( const D3DKMT_ESCAPE *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDIEscape );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDIOpenAdapterFromDeviceName( D3DKMT_OPENADAPTERFROMDEVICENAME *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDIOpenAdapterFromDeviceName );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDIOpenAdapterFromHdc( D3DKMT_OPENADAPTERFROMHDC *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDIOpenAdapterFromHdc );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDIOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDIOpenAdapterFromLuid );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDIQueryAdapterInfo( D3DKMT_QUERYADAPTERINFO *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDIQueryAdapterInfo );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDIQueryStatistics( D3DKMT_QUERYSTATISTICS *stats )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDIQueryStatistics );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDIQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDIQueryVideoMemoryInfo );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDISetQueuedLimit( D3DKMT_SETQUEUEDLIMIT *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDISetQueuedLimit );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDdDDISetVidPnSourceOwner );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiDeleteClientObj( HGDIOBJ handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDeleteClientObj );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiDeleteObjectApp( HGDIOBJ obj )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDeleteObjectApp );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiDescribePixelFormat( HDC hdc, INT format, UINT size, PIXELFORMATDESCRIPTOR *descr )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDescribePixelFormat );
|
|
}
|
|
|
|
LONG SYSCALL_API NtGdiDoPalette( HGDIOBJ handle, WORD start, WORD count, void *entries,
|
|
DWORD func, BOOL inbound )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDoPalette );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiDrawStream( HDC hdc, ULONG in, void *pvin )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiDrawStream );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiEllipse( HDC hdc, INT left, INT top, INT right, INT bottom )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiEllipse );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiEndDoc( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiEndDoc );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiEndPage( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiEndPage );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiEndPath( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiEndPath );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiEnumFonts( HDC hdc, ULONG type, ULONG win32_compat, ULONG face_name_len,
|
|
const WCHAR *face_name, ULONG charset, ULONG *count, void *buf )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiEnumFonts );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiEqualRgn( HRGN hrgn1, HRGN hrgn2 )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiEqualRgn );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiExcludeClipRect( HDC hdc, INT left, INT top, INT right, INT bottom )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiExcludeClipRect );
|
|
}
|
|
|
|
HPEN SYSCALL_API NtGdiExtCreatePen( DWORD style, DWORD width, ULONG brush_style, ULONG color,
|
|
ULONG_PTR client_hatch, ULONG_PTR hatch, DWORD style_count,
|
|
const DWORD *style_bits, ULONG dib_size, BOOL old_style,
|
|
HBRUSH brush )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiExtCreatePen );
|
|
}
|
|
|
|
HRGN SYSCALL_API NtGdiExtCreateRegion( const XFORM *xform, DWORD count, const RGNDATA *rgndata )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiExtCreateRegion );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiExtEscape( HDC hdc, WCHAR *driver, int driver_id, INT escape, INT input_size,
|
|
const char *input, INT output_size, char *output )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiExtEscape );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiExtFloodFill( HDC hdc, INT x, INT y, COLORREF color, UINT fill_type )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiExtFloodFill );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiExtGetObjectW( HGDIOBJ handle, INT count, void *buffer )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiExtGetObjectW );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiExtSelectClipRgn( HDC hdc, HRGN rgn, INT mode )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiExtSelectClipRgn );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiExtTextOutW( HDC hdc, INT x, INT y, UINT flags, const RECT *lprect,
|
|
const WCHAR *str, UINT count, const INT *lpDx, DWORD cp )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiExtTextOutW );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiFillPath( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiFillPath );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiFillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiFillRgn );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiFlattenPath( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiFlattenPath );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiFlush(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiFlush );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiFontIsLinked( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiFontIsLinked );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiFrameRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush, INT width, INT height )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiFrameRgn );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetAndSetDCDword( HDC hdc, UINT method, DWORD value, DWORD *prev_value )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetAndSetDCDword );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiGetAppClipBox( HDC hdc, RECT *rect )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetAppClipBox );
|
|
}
|
|
|
|
LONG SYSCALL_API NtGdiGetBitmapBits( HBITMAP hbitmap, LONG count, LPVOID bits )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetBitmapBits );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetBitmapDimension( HBITMAP hbitmap, LPSIZE size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetBitmapDimension );
|
|
}
|
|
|
|
UINT SYSCALL_API NtGdiGetBoundsRect( HDC hdc, RECT *rect, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetBoundsRect );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetCharABCWidthsW( HDC hdc, UINT first, UINT last, WCHAR *chars,
|
|
ULONG flags, void *buffer )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetCharABCWidthsW );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetCharWidthInfo( HDC hdc, struct char_width_info *info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetCharWidthInfo );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetCharWidthW( HDC hdc, UINT first, UINT last, WCHAR *chars,
|
|
ULONG flags, void *buf )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetCharWidthW );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetColorAdjustment( HDC hdc, COLORADJUSTMENT *ca )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetColorAdjustment );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetDCDword( HDC hdc, UINT method, DWORD *result )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetDCDword );
|
|
}
|
|
|
|
HANDLE SYSCALL_API NtGdiGetDCObject( HDC hdc, UINT type )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetDCObject );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetDCPoint( HDC hdc, UINT method, POINT *result )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetDCPoint );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiGetDIBitsInternal( HDC hdc, HBITMAP hbitmap, UINT startscan, UINT lines,
|
|
void *bits, BITMAPINFO *info, UINT coloruse,
|
|
UINT max_bits, UINT max_info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetDIBitsInternal );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiGetDeviceCaps( HDC hdc, INT cap )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetDeviceCaps );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetDeviceGammaRamp( HDC hdc, void *ptr )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetDeviceGammaRamp );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtGdiGetFontData( HDC hdc, DWORD table, DWORD offset, void *buffer, DWORD length )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetFontData );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetFontFileData( DWORD instance_id, DWORD file_index, UINT64 *offset,
|
|
void *buff, SIZE_T buff_size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetFontFileData );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetFontFileInfo( DWORD instance_id, DWORD file_index, struct font_fileinfo *info,
|
|
SIZE_T size, SIZE_T *needed )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetFontFileInfo );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtGdiGetFontUnicodeRanges( HDC hdc, GLYPHSET *lpgs )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetFontUnicodeRanges );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtGdiGetGlyphIndicesW( HDC hdc, const WCHAR *str, INT count,
|
|
WORD *indices, DWORD flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetGlyphIndicesW );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtGdiGetGlyphOutline( HDC hdc, UINT ch, UINT format, GLYPHMETRICS *metrics,
|
|
DWORD size, void *buffer, const MAT2 *mat2,
|
|
BOOL ignore_rotation )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetGlyphOutline );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtGdiGetKerningPairs( HDC hdc, DWORD count, KERNINGPAIR *kern_pair )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetKerningPairs );
|
|
}
|
|
|
|
COLORREF SYSCALL_API NtGdiGetNearestColor( HDC hdc, COLORREF color )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetNearestColor );
|
|
}
|
|
|
|
UINT SYSCALL_API NtGdiGetNearestPaletteIndex( HPALETTE hpalette, COLORREF color )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetNearestPaletteIndex );
|
|
}
|
|
|
|
UINT SYSCALL_API NtGdiGetOutlineTextMetricsInternalW( HDC hdc, UINT cbData,
|
|
OUTLINETEXTMETRICW *lpOTM, ULONG opts )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetOutlineTextMetricsInternalW );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiGetPath( HDC hdc, POINT *points, BYTE *types, INT size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetPath );
|
|
}
|
|
|
|
COLORREF SYSCALL_API NtGdiGetPixel( HDC hdc, INT x, INT y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetPixel );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiGetRandomRgn( HDC hDC, HRGN hRgn, INT iCode )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetRandomRgn );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetRasterizerCaps( RASTERIZER_STATUS *status, UINT size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetRasterizerCaps );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetRealizationInfo( HDC hdc, struct font_realization_info *info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetRealizationInfo );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtGdiGetRegionData( HRGN hrgn, DWORD count, RGNDATA *rgndata )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetRegionData );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiGetRgnBox( HRGN hrgn, RECT *rect )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetRgnBox );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtGdiGetSpoolMessage( void *ptr1, DWORD data2, void *ptr3, DWORD data4 )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetSpoolMessage );
|
|
}
|
|
|
|
UINT SYSCALL_API NtGdiGetSystemPaletteUse( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetSystemPaletteUse );
|
|
}
|
|
|
|
UINT SYSCALL_API NtGdiGetTextCharsetInfo( HDC hdc, FONTSIGNATURE *fs, DWORD flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetTextCharsetInfo );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetTextExtentExW( HDC hdc, const WCHAR *str, INT count, INT max_ext,
|
|
INT *nfit, INT *dxs, SIZE *size, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetTextExtentExW );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiGetTextFaceW( HDC hdc, INT count, WCHAR *name, BOOL alias_name )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetTextFaceW );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetTextMetricsW( HDC hdc, TEXTMETRICW *metrics, ULONG flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetTextMetricsW );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGetTransform( HDC hdc, DWORD which, XFORM *xform )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGetTransform );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiGradientFill( HDC hdc, TRIVERTEX *vert_array, ULONG nvert,
|
|
void *grad_array, ULONG ngrad, ULONG mode )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiGradientFill );
|
|
}
|
|
|
|
HFONT SYSCALL_API NtGdiHfontCreate( const void *logfont, ULONG size, ULONG type,
|
|
ULONG flags, void *data )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiHfontCreate );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiIcmBrushInfo( HDC hdc, HBRUSH handle, BITMAPINFO *info, void *bits,
|
|
ULONG *bits_size, UINT *usage, BOOL *unk, UINT mode )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiIcmBrushInfo );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtGdiInitSpool(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiInitSpool );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiIntersectClipRect( HDC hdc, INT left, INT top, INT right, INT bottom )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiIntersectClipRect );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiInvertRgn( HDC hdc, HRGN hrgn )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiInvertRgn );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiLineTo( HDC hdc, INT x, INT y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiLineTo );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiMaskBlt( HDC hdcDest, INT nXDest, INT nYDest, INT nWidth, INT nHeight,
|
|
HDC hdcSrc, INT nXSrc, INT nYSrc, HBITMAP hbmMask,
|
|
INT xMask, INT yMask, DWORD dwRop, DWORD bk_color )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiMaskBlt );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiModifyWorldTransform( HDC hdc, const XFORM *xform, DWORD mode )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiModifyWorldTransform );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiMoveTo( HDC hdc, INT x, INT y, POINT *pt )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiMoveTo );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiOffsetClipRgn( HDC hdc, INT x, INT y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiOffsetClipRgn );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiOffsetRgn( HRGN hrgn, INT x, INT y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiOffsetRgn );
|
|
}
|
|
|
|
HDC SYSCALL_API NtGdiOpenDCW( UNICODE_STRING *device, const DEVMODEW *devmode, UNICODE_STRING *output,
|
|
ULONG type, BOOL is_display, HANDLE hspool, DRIVER_INFO_2W *driver_info,
|
|
void *pdev )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiOpenDCW );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiPatBlt( HDC hdc, INT left, INT top, INT width, INT height, DWORD rop )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiPatBlt );
|
|
}
|
|
|
|
HRGN SYSCALL_API NtGdiPathToRegion( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiPathToRegion );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiPlgBlt( HDC hdcDest, const POINT *lpPoint, HDC hdcSrc, INT nXSrc, INT nYSrc,
|
|
INT nWidth, INT nHeight, HBITMAP hbmMask, INT xMask, INT yMask,
|
|
DWORD bk_color )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiPlgBlt );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiPolyDraw( HDC hdc, const POINT *points, const BYTE *types, DWORD count )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiPolyDraw );
|
|
}
|
|
|
|
ULONG SYSCALL_API NtGdiPolyPolyDraw( HDC hdc, const POINT *points, const ULONG *counts,
|
|
DWORD count, UINT function )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiPolyPolyDraw );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiPtInRegion( HRGN hrgn, INT x, INT y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiPtInRegion );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiPtVisible( HDC hdc, INT x, INT y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiPtVisible );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiRectInRegion( HRGN hrgn, const RECT *rect )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiRectInRegion );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiRectVisible( HDC hdc, const RECT *rect )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiRectVisible );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiRectangle( HDC hdc, INT left, INT top, INT right, INT bottom )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiRectangle );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiRemoveFontMemResourceEx( HANDLE handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiRemoveFontMemResourceEx );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiRemoveFontResourceW( const WCHAR *str, ULONG size, ULONG files, DWORD flags,
|
|
DWORD tid, void *dv )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiRemoveFontResourceW );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiResetDC( HDC hdc, const DEVMODEW *devmode, BOOL *banding,
|
|
DRIVER_INFO_2W *driver_info, void *dev )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiResetDC );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiResizePalette( HPALETTE hPal, UINT count )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiResizePalette );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiRestoreDC( HDC hdc, INT level )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiRestoreDC );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiRoundRect( HDC hdc, INT left, INT top, INT right,
|
|
INT bottom, INT ell_width, INT ell_height )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiRoundRect );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiSaveDC( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSaveDC );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiScaleViewportExtEx( HDC hdc, INT x_num, INT x_denom,
|
|
INT y_num, INT y_denom, SIZE *size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiScaleViewportExtEx );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiScaleWindowExtEx( HDC hdc, INT x_num, INT x_denom,
|
|
INT y_num, INT y_denom, SIZE *size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiScaleWindowExtEx );
|
|
}
|
|
|
|
HGDIOBJ SYSCALL_API NtGdiSelectBitmap( HDC hdc, HGDIOBJ handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSelectBitmap );
|
|
}
|
|
|
|
HGDIOBJ SYSCALL_API NtGdiSelectBrush( HDC hdc, HGDIOBJ handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSelectBrush );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiSelectClipPath( HDC hdc, INT mode )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSelectClipPath );
|
|
}
|
|
|
|
HGDIOBJ SYSCALL_API NtGdiSelectFont( HDC hdc, HGDIOBJ handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSelectFont );
|
|
}
|
|
|
|
HGDIOBJ SYSCALL_API NtGdiSelectPen( HDC hdc, HGDIOBJ handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSelectPen );
|
|
}
|
|
|
|
LONG SYSCALL_API NtGdiSetBitmapBits( HBITMAP hbitmap, LONG count, LPCVOID bits )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetBitmapBits );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiSetBitmapDimension( HBITMAP hbitmap, INT x, INT y, LPSIZE prevSize )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetBitmapDimension );
|
|
}
|
|
|
|
UINT SYSCALL_API NtGdiSetBoundsRect( HDC hdc, const RECT *rect, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetBoundsRect );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiSetBrushOrg( HDC hdc, INT x, INT y, POINT *oldorg )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetBrushOrg );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiSetColorAdjustment( HDC hdc, const COLORADJUSTMENT *ca )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetColorAdjustment );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiSetDIBitsToDeviceInternal( HDC hdc, INT xDest, INT yDest, DWORD cx,
|
|
DWORD cy, INT xSrc, INT ySrc, UINT startscan,
|
|
UINT lines, const void *bits, const BITMAPINFO *bmi,
|
|
UINT coloruse, UINT max_bits, UINT max_info,
|
|
BOOL xform_coords, HANDLE xform )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetDIBitsToDeviceInternal );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiSetDeviceGammaRamp( HDC hdc, void *ptr )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetDeviceGammaRamp );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtGdiSetLayout( HDC hdc, LONG wox, DWORD layout )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetLayout );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiSetMagicColors( HDC hdc, DWORD magic, ULONG index )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetMagicColors );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiSetMetaRgn( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetMetaRgn );
|
|
}
|
|
|
|
COLORREF SYSCALL_API NtGdiSetPixel( HDC hdc, INT x, INT y, COLORREF color )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetPixel );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiSetPixelFormat( HDC hdc, INT format )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetPixelFormat );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiSetRectRgn( HRGN hrgn, INT left, INT top, INT right, INT bottom )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetRectRgn );
|
|
}
|
|
|
|
UINT SYSCALL_API NtGdiSetSystemPaletteUse( HDC hdc, UINT use )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetSystemPaletteUse );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiSetTextJustification( HDC hdc, INT extra, INT breaks )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetTextJustification );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiSetVirtualResolution( HDC hdc, DWORD horz_res, DWORD vert_res,
|
|
DWORD horz_size, DWORD vert_size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSetVirtualResolution );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiStartDoc( HDC hdc, const DOCINFOW *doc, BOOL *banding, INT job )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiStartDoc );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiStartPage( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiStartPage );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiStretchBlt( HDC hdcDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
|
|
HDC hdcSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
|
|
DWORD rop, COLORREF bk_color )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiStretchBlt );
|
|
}
|
|
|
|
INT SYSCALL_API NtGdiStretchDIBitsInternal( HDC hdc, INT xDst, INT yDst, INT widthDst, INT heightDst,
|
|
INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
|
|
const void *bits, const BITMAPINFO *bmi, UINT coloruse,
|
|
DWORD rop, UINT max_info, UINT max_bits, HANDLE xform )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiStretchDIBitsInternal );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiStrokeAndFillPath( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiStrokeAndFillPath );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiStrokePath( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiStrokePath );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiSwapBuffers( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiSwapBuffers );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiTransformPoints( HDC hdc, const POINT *points_in, POINT *points_out,
|
|
INT count, UINT mode )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiTransformPoints );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiTransparentBlt( HDC hdcDest, int xDest, int yDest, int widthDest, int heightDest,
|
|
HDC hdcSrc, int xSrc, int ySrc, int widthSrc, int heightSrc,
|
|
UINT crTransparent )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiTransparentBlt );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiUnrealizeObject( HGDIOBJ obj )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiUnrealizeObject );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiUpdateColors( HDC hDC )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiUpdateColors );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtGdiWidenPath( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtGdiWidenPath );
|
|
}
|
|
|
|
HKL SYSCALL_API NtUserActivateKeyboardLayout( HKL layout, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserActivateKeyboardLayout );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserAddClipboardFormatListener( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserAddClipboardFormatListener );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserAssociateInputContext( HWND hwnd, HIMC ctx, ULONG flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserAssociateInputContext );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserAttachThreadInput( DWORD from, DWORD to, BOOL attach )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserAttachThreadInput );
|
|
}
|
|
|
|
HDC SYSCALL_API NtUserBeginPaint( HWND hwnd, PAINTSTRUCT *ps )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserBeginPaint );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtUserBuildHimcList( UINT thread_id, UINT count, HIMC *buffer, UINT *size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserBuildHimcList );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtUserBuildHwndList( HDESK desktop, ULONG unk2, ULONG unk3, ULONG unk4,
|
|
ULONG thread_id, ULONG count, HWND *buffer, ULONG *size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserBuildHwndList );
|
|
}
|
|
|
|
ULONG_PTR SYSCALL_API NtUserCallHwnd( HWND hwnd, DWORD code )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCallHwnd );
|
|
}
|
|
|
|
ULONG_PTR SYSCALL_API NtUserCallHwndParam( HWND hwnd, DWORD_PTR param, DWORD code )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCallHwndParam );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserCallMsgFilter( MSG *msg, INT code )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCallMsgFilter );
|
|
}
|
|
|
|
LRESULT SYSCALL_API NtUserCallNextHookEx( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCallNextHookEx );
|
|
}
|
|
|
|
ULONG_PTR SYSCALL_API NtUserCallNoParam( ULONG code )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCallNoParam );
|
|
}
|
|
|
|
ULONG_PTR SYSCALL_API NtUserCallOneParam( ULONG_PTR arg, ULONG code )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCallOneParam );
|
|
}
|
|
|
|
ULONG_PTR SYSCALL_API NtUserCallTwoParam( ULONG_PTR arg1, ULONG_PTR arg2, ULONG code )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCallTwoParam );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserChangeClipboardChain( HWND hwnd, HWND next )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserChangeClipboardChain );
|
|
}
|
|
|
|
LONG SYSCALL_API NtUserChangeDisplaySettings( UNICODE_STRING *devname, DEVMODEW *devmode, HWND hwnd,
|
|
DWORD flags, void *lparam )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserChangeDisplaySettings );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtUserCheckMenuItem( HMENU handle, UINT id, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCheckMenuItem );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserChildWindowFromPointEx( HWND parent, LONG x, LONG y, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserChildWindowFromPointEx );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserClipCursor( const RECT *rect )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserClipCursor );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserCloseClipboard(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCloseClipboard );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserCloseDesktop( HDESK handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCloseDesktop );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserCloseWindowStation( HWINSTA handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCloseWindowStation );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserCopyAcceleratorTable( HACCEL src, ACCEL *dst, INT count )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCopyAcceleratorTable );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserCountClipboardFormats(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCountClipboardFormats );
|
|
}
|
|
|
|
HACCEL SYSCALL_API NtUserCreateAcceleratorTable( ACCEL *table, INT count )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCreateAcceleratorTable );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserCreateCaret( HWND hwnd, HBITMAP bitmap, int width, int height )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCreateCaret );
|
|
}
|
|
|
|
HDESK SYSCALL_API NtUserCreateDesktopEx( OBJECT_ATTRIBUTES *attr, UNICODE_STRING *device,
|
|
DEVMODEW *devmode, DWORD flags, ACCESS_MASK access,
|
|
ULONG heap_size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCreateDesktopEx );
|
|
}
|
|
|
|
HIMC SYSCALL_API NtUserCreateInputContext( UINT_PTR client_ptr )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCreateInputContext );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserCreateWindowEx( DWORD ex_style, UNICODE_STRING *class_name,
|
|
UNICODE_STRING *version, UNICODE_STRING *window_name,
|
|
DWORD style, INT x, INT y, INT cx, INT cy,
|
|
HWND parent, HMENU menu, HINSTANCE instance, void *params,
|
|
DWORD flags, HINSTANCE client_instance, DWORD unk, BOOL ansi )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCreateWindowEx );
|
|
}
|
|
|
|
HWINSTA SYSCALL_API NtUserCreateWindowStation( OBJECT_ATTRIBUTES *attr, ACCESS_MASK access, ULONG arg3,
|
|
ULONG arg4, ULONG arg5, ULONG arg6, ULONG arg7 )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserCreateWindowStation );
|
|
}
|
|
|
|
HDWP SYSCALL_API NtUserDeferWindowPosAndBand( HDWP hdwp, HWND hwnd, HWND after,
|
|
INT x, INT y, INT cx, INT cy,
|
|
UINT flags, UINT unk1, UINT unk2 )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDeferWindowPosAndBand );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserDeleteMenu( HMENU handle, UINT id, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDeleteMenu );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserDestroyAcceleratorTable( HACCEL handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDestroyAcceleratorTable );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserDestroyCursor( HCURSOR cursor, ULONG arg )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDestroyCursor );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserDestroyInputContext( HIMC handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDestroyInputContext );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserDestroyMenu( HMENU handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDestroyMenu );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserDestroyWindow( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDestroyWindow );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserDisableThreadIme( DWORD thread_id )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDisableThreadIme );
|
|
}
|
|
|
|
LRESULT SYSCALL_API NtUserDispatchMessage( const MSG *msg )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDispatchMessage );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtUserDisplayConfigGetDeviceInfo( DISPLAYCONFIG_DEVICE_INFO_HEADER *packet )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDisplayConfigGetDeviceInfo );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserDragDetect( HWND hwnd, int x, int y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDragDetect );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtUserDragObject( HWND parent, HWND hwnd, UINT fmt, ULONG_PTR data, HCURSOR cursor )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDragObject );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserDrawCaptionTemp( HWND hwnd, HDC hdc, const RECT *rect, HFONT font,
|
|
HICON icon, const WCHAR *str, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDrawCaptionTemp );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserDrawIconEx( HDC hdc, INT x0, INT y0, HICON icon, INT width,
|
|
INT height, UINT step, HBRUSH brush, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDrawIconEx );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtUserDrawMenuBarTemp( HWND hwnd, HDC hdc, RECT *rect, HMENU handle, HFONT font )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserDrawMenuBarTemp );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserEmptyClipboard(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserEmptyClipboard );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserEnableMenuItem( HMENU handle, UINT id, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserEnableMenuItem );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserEnableMouseInPointer( BOOL enable )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserEnableMouseInPointer );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserEnableScrollBar( HWND hwnd, UINT bar, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserEnableScrollBar );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserEndDeferWindowPosEx( HDWP hdwp, BOOL async )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserEndDeferWindowPosEx );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserEndMenu(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserEndMenu );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserEndPaint( HWND hwnd, const PAINTSTRUCT *ps )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserEndPaint );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtUserEnumDisplayDevices( UNICODE_STRING *device, DWORD index,
|
|
DISPLAY_DEVICEW *info, DWORD flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserEnumDisplayDevices );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserEnumDisplayMonitors( HDC hdc, RECT *rect, MONITORENUMPROC proc, LPARAM lparam )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserEnumDisplayMonitors );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserEnumDisplaySettings( UNICODE_STRING *device, DWORD index, DEVMODEW *devmode, DWORD flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserEnumDisplaySettings );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserExcludeUpdateRgn( HDC hdc, HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserExcludeUpdateRgn );
|
|
}
|
|
|
|
HICON SYSCALL_API NtUserFindExistingCursorIcon( UNICODE_STRING *module, UNICODE_STRING *res_name, void *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserFindExistingCursorIcon );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserFindWindowEx( HWND parent, HWND child, UNICODE_STRING *class, UNICODE_STRING *title,
|
|
ULONG unk )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserFindWindowEx );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserFlashWindowEx( FLASHWINFO *info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserFlashWindowEx );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserGetAncestor( HWND hwnd, UINT type )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetAncestor );
|
|
}
|
|
|
|
SHORT SYSCALL_API NtUserGetAsyncKeyState( INT key )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetAsyncKeyState );
|
|
}
|
|
|
|
ULONG SYSCALL_API NtUserGetAtomName( ATOM atom, UNICODE_STRING *name )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetAtomName );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserGetCaretBlinkTime(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetCaretBlinkTime );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetCaretPos( POINT *pt )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetCaretPos );
|
|
}
|
|
|
|
ATOM SYSCALL_API NtUserGetClassInfoEx( HINSTANCE instance, UNICODE_STRING *name, WNDCLASSEXW *wc,
|
|
struct client_menu_name *menu_name, BOOL ansi )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetClassInfoEx );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserGetClassName( HWND hwnd, BOOL real, UNICODE_STRING *name )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetClassName );
|
|
}
|
|
|
|
HANDLE SYSCALL_API NtUserGetClipboardData( UINT format, struct get_clipboard_params *params )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetClipboardData );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserGetClipboardFormatName( UINT format, WCHAR *buffer, INT maxlen )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetClipboardFormatName );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserGetClipboardOwner(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetClipboardOwner );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtUserGetClipboardSequenceNumber(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetClipboardSequenceNumber );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserGetClipboardViewer(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetClipboardViewer );
|
|
}
|
|
|
|
HCURSOR SYSCALL_API NtUserGetCursor(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetCursor );
|
|
}
|
|
|
|
HCURSOR SYSCALL_API NtUserGetCursorFrameInfo( HCURSOR cursor, DWORD istep, DWORD *rate_jiffies,
|
|
DWORD *num_steps )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetCursorFrameInfo );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetCursorInfo( CURSORINFO *info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetCursorInfo );
|
|
}
|
|
|
|
HDC SYSCALL_API NtUserGetDC( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetDC );
|
|
}
|
|
|
|
HDC SYSCALL_API NtUserGetDCEx( HWND hwnd, HRGN clip_rgn, DWORD flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetDCEx );
|
|
}
|
|
|
|
LONG SYSCALL_API NtUserGetDisplayConfigBufferSizes( UINT32 flags, UINT32 *num_path_info,
|
|
UINT32 *num_mode_info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetDisplayConfigBufferSizes );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserGetDoubleClickTime(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetDoubleClickTime );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetDpiForMonitor( HMONITOR monitor, UINT type, UINT *x, UINT *y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetDpiForMonitor );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserGetForegroundWindow(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetForegroundWindow );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetGUIThreadInfo( DWORD id, GUITHREADINFO *info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetGUIThreadInfo );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetIconInfo( HICON icon, ICONINFO *info, UNICODE_STRING *module,
|
|
UNICODE_STRING *res_name, DWORD *bpp, LONG unk )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetIconInfo );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetIconSize( HICON handle, UINT step, LONG *width, LONG *height )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetIconSize );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserGetInternalWindowPos( HWND hwnd, RECT *rect, POINT *pt )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetInternalWindowPos );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserGetKeyNameText( LONG lparam, WCHAR *buffer, INT size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetKeyNameText );
|
|
}
|
|
|
|
SHORT SYSCALL_API NtUserGetKeyState( INT vkey )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetKeyState );
|
|
}
|
|
|
|
HKL SYSCALL_API NtUserGetKeyboardLayout( DWORD thread_id )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetKeyboardLayout );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserGetKeyboardLayoutList( INT size, HKL *layouts )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetKeyboardLayoutList );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetKeyboardLayoutName( WCHAR *name )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetKeyboardLayoutName );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetKeyboardState( BYTE *state )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetKeyboardState );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetLayeredWindowAttributes( HWND hwnd, COLORREF *key, BYTE *alpha, DWORD *flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetLayeredWindowAttributes );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetMenuBarInfo( HWND hwnd, LONG id, LONG item, MENUBARINFO *info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetMenuBarInfo );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetMenuItemRect( HWND hwnd, HMENU handle, UINT item, RECT *rect )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetMenuItemRect );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetMessage( MSG *msg, HWND hwnd, UINT first, UINT last )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetMessage );
|
|
}
|
|
|
|
int SYSCALL_API NtUserGetMouseMovePointsEx( UINT size, MOUSEMOVEPOINT *ptin, MOUSEMOVEPOINT *ptout,
|
|
int count, DWORD resolution )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetMouseMovePointsEx );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetObjectInformation( HANDLE handle, INT index, void *info,
|
|
DWORD len, DWORD *needed )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetObjectInformation );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserGetOpenClipboardWindow(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetOpenClipboardWindow );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetPointerInfoList( UINT32 id, POINTER_INPUT_TYPE type, UINT_PTR unk0, UINT_PTR unk1, SIZE_T size,
|
|
UINT32 *entry_count, UINT32 *pointer_count, void *pointer_info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetPointerInfoList );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserGetPriorityClipboardFormat( UINT *list, INT count )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetPriorityClipboardFormat );
|
|
}
|
|
|
|
ULONG SYSCALL_API NtUserGetProcessDpiAwarenessContext( HANDLE process )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetProcessDpiAwarenessContext );
|
|
}
|
|
|
|
HWINSTA SYSCALL_API NtUserGetProcessWindowStation(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetProcessWindowStation );
|
|
}
|
|
|
|
HANDLE SYSCALL_API NtUserGetProp( HWND hwnd, const WCHAR *str )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetProp );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtUserGetQueueStatus( UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetQueueStatus );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserGetRawInputBuffer( RAWINPUT *data, UINT *data_size, UINT header_size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetRawInputBuffer );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserGetRawInputData( HRAWINPUT rawinput, UINT command, void *data, UINT *data_size, UINT header_size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetRawInputData );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserGetRawInputDeviceInfo( HANDLE handle, UINT command, void *data, UINT *data_size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetRawInputDeviceInfo );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserGetRawInputDeviceList( RAWINPUTDEVICELIST *device_list, UINT *device_count, UINT size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetRawInputDeviceList );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserGetRegisteredRawInputDevices( RAWINPUTDEVICE *devices, UINT *device_count, UINT device_size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetRegisteredRawInputDevices );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetScrollBarInfo( HWND hwnd, LONG id, SCROLLBARINFO *info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetScrollBarInfo );
|
|
}
|
|
|
|
ULONG SYSCALL_API NtUserGetSystemDpiForProcess( HANDLE process )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetSystemDpiForProcess );
|
|
}
|
|
|
|
HMENU SYSCALL_API NtUserGetSystemMenu( HWND hwnd, BOOL revert )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetSystemMenu );
|
|
}
|
|
|
|
HDESK SYSCALL_API NtUserGetThreadDesktop( DWORD thread )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetThreadDesktop );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetTitleBarInfo( HWND hwnd, TITLEBARINFO *info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetTitleBarInfo );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetUpdateRect( HWND hwnd, RECT *rect, BOOL erase )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetUpdateRect );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserGetUpdateRgn( HWND hwnd, HRGN hrgn, BOOL erase )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetUpdateRgn );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetUpdatedClipboardFormats( UINT *formats, UINT size, UINT *out_size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetUpdatedClipboardFormats );
|
|
}
|
|
|
|
HDC SYSCALL_API NtUserGetWindowDC( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetWindowDC );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserGetWindowPlacement( HWND hwnd, WINDOWPLACEMENT *placement )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetWindowPlacement );
|
|
}
|
|
|
|
int SYSCALL_API NtUserGetWindowRgnEx( HWND hwnd, HRGN hrgn, UINT unk )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserGetWindowRgnEx );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserHideCaret( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserHideCaret );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserHiliteMenuItem( HWND hwnd, HMENU handle, UINT item, UINT hilite )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserHiliteMenuItem );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtUserInitializeClientPfnArrays( const struct user_client_procs *client_procsA,
|
|
const struct user_client_procs *client_procsW,
|
|
const void *client_workers, HINSTANCE user_module )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserInitializeClientPfnArrays );
|
|
}
|
|
|
|
HICON SYSCALL_API NtUserInternalGetWindowIcon( HWND hwnd, UINT type )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserInternalGetWindowIcon );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserInternalGetWindowText( HWND hwnd, WCHAR *text, INT count )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserInternalGetWindowText );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserInvalidateRect( HWND hwnd, const RECT *rect, BOOL erase )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserInvalidateRect );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserInvalidateRgn( HWND hwnd, HRGN hrgn, BOOL erase )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserInvalidateRgn );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserIsClipboardFormatAvailable( UINT format )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserIsClipboardFormatAvailable );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserIsMouseInPointerEnabled(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserIsMouseInPointerEnabled );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserKillTimer( HWND hwnd, UINT_PTR id )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserKillTimer );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserLockWindowUpdate( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserLockWindowUpdate );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserLogicalToPerMonitorDPIPhysicalPoint( HWND hwnd, POINT *pt )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserLogicalToPerMonitorDPIPhysicalPoint );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserMapVirtualKeyEx( UINT code, UINT type, HKL layout )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserMapVirtualKeyEx );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserMenuItemFromPoint( HWND hwnd, HMENU handle, int x, int y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserMenuItemFromPoint );
|
|
}
|
|
|
|
LRESULT SYSCALL_API NtUserMessageCall( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
|
|
void *result_info, DWORD type, BOOL ansi )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserMessageCall );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserMoveWindow( HWND hwnd, INT x, INT y, INT cx, INT cy, BOOL repaint )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserMoveWindow );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtUserMsgWaitForMultipleObjectsEx( DWORD count, const HANDLE *handles,
|
|
DWORD timeout, DWORD mask, DWORD flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserMsgWaitForMultipleObjectsEx );
|
|
}
|
|
|
|
void SYSCALL_API NtUserNotifyIMEStatus( HWND hwnd, UINT status )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserNotifyIMEStatus );
|
|
}
|
|
|
|
void SYSCALL_API NtUserNotifyWinEvent( DWORD event, HWND hwnd, LONG object_id, LONG child_id )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserNotifyWinEvent );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserOpenClipboard( HWND hwnd, ULONG unk )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserOpenClipboard );
|
|
}
|
|
|
|
HDESK SYSCALL_API NtUserOpenDesktop( OBJECT_ATTRIBUTES *attr, DWORD flags, ACCESS_MASK access )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserOpenDesktop );
|
|
}
|
|
|
|
HDESK SYSCALL_API NtUserOpenInputDesktop( DWORD flags, BOOL inherit, ACCESS_MASK access )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserOpenInputDesktop );
|
|
}
|
|
|
|
HWINSTA SYSCALL_API NtUserOpenWindowStation( OBJECT_ATTRIBUTES *attr, ACCESS_MASK access )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserOpenWindowStation );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserPeekMessage( MSG *msg_out, HWND hwnd, UINT first, UINT last, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserPeekMessage );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserPerMonitorDPIPhysicalToLogicalPoint( HWND hwnd, POINT *pt )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserPerMonitorDPIPhysicalToLogicalPoint );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserPostMessage( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserPostMessage );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserPostThreadMessage( DWORD thread, UINT msg, WPARAM wparam, LPARAM lparam )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserPostThreadMessage );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserPrintWindow( HWND hwnd, HDC hdc, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserPrintWindow );
|
|
}
|
|
|
|
LONG SYSCALL_API NtUserQueryDisplayConfig( UINT32 flags, UINT32 *paths_count, DISPLAYCONFIG_PATH_INFO *paths,
|
|
UINT32 *modes_count, DISPLAYCONFIG_MODE_INFO *modes,
|
|
DISPLAYCONFIG_TOPOLOGY_ID *topology_id )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserQueryDisplayConfig );
|
|
}
|
|
|
|
UINT_PTR SYSCALL_API NtUserQueryInputContext( HIMC handle, UINT attr )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserQueryInputContext );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserRealChildWindowFromPoint( HWND parent, LONG x, LONG y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserRealChildWindowFromPoint );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserRedrawWindow( HWND hwnd, const RECT *rect, HRGN hrgn, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserRedrawWindow );
|
|
}
|
|
|
|
ATOM SYSCALL_API NtUserRegisterClassExWOW( const WNDCLASSEXW *wc, UNICODE_STRING *name, UNICODE_STRING *version,
|
|
struct client_menu_name *client_menu_name, DWORD fnid,
|
|
DWORD flags, DWORD *wow )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserRegisterClassExWOW );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserRegisterHotKey( HWND hwnd, INT id, UINT modifiers, UINT vk )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserRegisterHotKey );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserRegisterRawInputDevices( const RAWINPUTDEVICE *devices, UINT device_count, UINT device_size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserRegisterRawInputDevices );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserReleaseDC( HWND hwnd, HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserReleaseDC );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserRemoveClipboardFormatListener( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserRemoveClipboardFormatListener );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserRemoveMenu( HMENU handle, UINT id, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserRemoveMenu );
|
|
}
|
|
|
|
HANDLE SYSCALL_API NtUserRemoveProp( HWND hwnd, const WCHAR *str )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserRemoveProp );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserScrollDC( HDC hdc, INT dx, INT dy, const RECT *scroll, const RECT *clip,
|
|
HRGN ret_update_rgn, RECT *update_rect )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserScrollDC );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserScrollWindowEx( HWND hwnd, INT dx, INT dy, const RECT *rect,
|
|
const RECT *clip_rect, HRGN update_rgn,
|
|
RECT *update_rect, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserScrollWindowEx );
|
|
}
|
|
|
|
HPALETTE SYSCALL_API NtUserSelectPalette( HDC hdc, HPALETTE hpal, WORD bkg )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSelectPalette );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserSendInput( UINT count, INPUT *inputs, int size )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSendInput );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserSetActiveWindow( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetActiveWindow );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserSetCapture( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetCapture );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtUserSetClassLong( HWND hwnd, INT offset, LONG newval, BOOL ansi )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetClassLong );
|
|
}
|
|
|
|
ULONG_PTR SYSCALL_API NtUserSetClassLongPtr( HWND hwnd, INT offset, LONG_PTR newval, BOOL ansi )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetClassLongPtr );
|
|
}
|
|
|
|
WORD SYSCALL_API NtUserSetClassWord( HWND hwnd, INT offset, WORD newval )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetClassWord );
|
|
}
|
|
|
|
NTSTATUS SYSCALL_API NtUserSetClipboardData( UINT format, HANDLE data, struct set_clipboard_params *params )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetClipboardData );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserSetClipboardViewer( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetClipboardViewer );
|
|
}
|
|
|
|
HCURSOR SYSCALL_API NtUserSetCursor( HCURSOR cursor )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetCursor );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetCursorIconData( HCURSOR cursor, UNICODE_STRING *module, UNICODE_STRING *res_name,
|
|
struct cursoricon_desc *desc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetCursorIconData );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetCursorPos( INT x, INT y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetCursorPos );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserSetFocus( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetFocus );
|
|
}
|
|
|
|
void SYSCALL_API NtUserSetInternalWindowPos( HWND hwnd, UINT cmd, RECT *rect, POINT *pt )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetInternalWindowPos );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetKeyboardState( BYTE *state )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetKeyboardState );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetLayeredWindowAttributes( HWND hwnd, COLORREF key, BYTE alpha, DWORD flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetLayeredWindowAttributes );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetMenu( HWND hwnd, HMENU menu )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetMenu );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetMenuContextHelpId( HMENU handle, DWORD id )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetMenuContextHelpId );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetMenuDefaultItem( HMENU handle, UINT item, UINT bypos )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetMenuDefaultItem );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetObjectInformation( HANDLE handle, INT index, void *info, DWORD len )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetObjectInformation );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserSetParent( HWND hwnd, HWND parent )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetParent );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetProcessDpiAwarenessContext( ULONG awareness, ULONG unknown )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetProcessDpiAwarenessContext );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetProcessWindowStation( HWINSTA handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetProcessWindowStation );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetProp( HWND hwnd, const WCHAR *str, HANDLE handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetProp );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserSetScrollInfo( HWND hwnd, int bar, const SCROLLINFO *info, BOOL redraw )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetScrollInfo );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetShellWindowEx( HWND shell, HWND list_view )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetShellWindowEx );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetSysColors( INT count, const INT *colors, const COLORREF *values )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetSysColors );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetSystemMenu( HWND hwnd, HMENU menu )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetSystemMenu );
|
|
}
|
|
|
|
UINT_PTR SYSCALL_API NtUserSetSystemTimer( HWND hwnd, UINT_PTR id, UINT timeout )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetSystemTimer );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetThreadDesktop( HDESK handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetThreadDesktop );
|
|
}
|
|
|
|
UINT_PTR SYSCALL_API NtUserSetTimer( HWND hwnd, UINT_PTR id, UINT timeout, TIMERPROC proc, ULONG tolerance )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetTimer );
|
|
}
|
|
|
|
HWINEVENTHOOK SYSCALL_API NtUserSetWinEventHook( DWORD event_min, DWORD event_max, HMODULE inst,
|
|
UNICODE_STRING *module, WINEVENTPROC proc,
|
|
DWORD pid, DWORD tid, DWORD flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetWinEventHook );
|
|
}
|
|
|
|
LONG SYSCALL_API NtUserSetWindowLong( HWND hwnd, INT offset, LONG newval, BOOL ansi )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetWindowLong );
|
|
}
|
|
|
|
LONG_PTR SYSCALL_API NtUserSetWindowLongPtr( HWND hwnd, INT offset, LONG_PTR newval, BOOL ansi )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetWindowLongPtr );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetWindowPlacement( HWND hwnd, const WINDOWPLACEMENT *wpl )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetWindowPlacement );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSetWindowPos( HWND hwnd, HWND after, INT x, INT y, INT cx, INT cy, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetWindowPos );
|
|
}
|
|
|
|
int SYSCALL_API NtUserSetWindowRgn( HWND hwnd, HRGN hrgn, BOOL redraw )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetWindowRgn );
|
|
}
|
|
|
|
WORD SYSCALL_API NtUserSetWindowWord( HWND hwnd, INT offset, WORD newval )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetWindowWord );
|
|
}
|
|
|
|
HHOOK SYSCALL_API NtUserSetWindowsHookEx( HINSTANCE inst, UNICODE_STRING *module, DWORD tid, INT id,
|
|
HOOKPROC proc, BOOL ansi )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSetWindowsHookEx );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserShowCaret( HWND hwnd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserShowCaret );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserShowCursor( BOOL show )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserShowCursor );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserShowScrollBar( HWND hwnd, INT bar, BOOL show )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserShowScrollBar );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserShowWindow( HWND hwnd, INT cmd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserShowWindow );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserShowWindowAsync( HWND hwnd, INT cmd )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserShowWindowAsync );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSystemParametersInfo( UINT action, UINT val, void *ptr, UINT winini )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSystemParametersInfo );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserSystemParametersInfoForDpi( UINT action, UINT val, PVOID ptr, UINT winini, UINT dpi )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserSystemParametersInfoForDpi );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserThunkedMenuInfo( HMENU menu, const MENUINFO *info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserThunkedMenuInfo );
|
|
}
|
|
|
|
UINT SYSCALL_API NtUserThunkedMenuItemInfo( HMENU handle, UINT pos, UINT flags, UINT method,
|
|
MENUITEMINFOW *info, UNICODE_STRING *str )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserThunkedMenuItemInfo );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserToUnicodeEx( UINT virt, UINT scan, const BYTE *state,
|
|
WCHAR *str, int size, UINT flags, HKL layout )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserToUnicodeEx );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserTrackMouseEvent( TRACKMOUSEEVENT *info )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserTrackMouseEvent );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserTrackPopupMenuEx( HMENU handle, UINT flags, INT x, INT y, HWND hwnd,
|
|
TPMPARAMS *params )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserTrackPopupMenuEx );
|
|
}
|
|
|
|
INT SYSCALL_API NtUserTranslateAccelerator( HWND hwnd, HACCEL accel, MSG *msg )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserTranslateAccelerator );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserTranslateMessage( const MSG *msg, UINT flags )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserTranslateMessage );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserUnhookWinEvent( HWINEVENTHOOK handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserUnhookWinEvent );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserUnhookWindowsHookEx( HHOOK handle )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserUnhookWindowsHookEx );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserUnregisterClass( UNICODE_STRING *name, HINSTANCE instance,
|
|
struct client_menu_name *client_menu_name )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserUnregisterClass );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserUnregisterHotKey( HWND hwnd, INT id )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserUnregisterHotKey );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserUpdateInputContext( HIMC handle, UINT attr, UINT_PTR value )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserUpdateInputContext );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserUpdateLayeredWindow( HWND hwnd, HDC hdc_dst, const POINT *pts_dst, const SIZE *size,
|
|
HDC hdc_src, const POINT *pts_src, COLORREF key,
|
|
const BLENDFUNCTION *blend, DWORD flags, const RECT *dirty )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserUpdateLayeredWindow );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserValidateRect( HWND hwnd, const RECT *rect )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserValidateRect );
|
|
}
|
|
|
|
WORD SYSCALL_API NtUserVkKeyScanEx( WCHAR chr, HKL layout )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserVkKeyScanEx );
|
|
}
|
|
|
|
DWORD SYSCALL_API NtUserWaitForInputIdle( HANDLE process, DWORD timeout, BOOL wow )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserWaitForInputIdle );
|
|
}
|
|
|
|
BOOL SYSCALL_API NtUserWaitMessage(void)
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserWaitMessage );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserWindowFromDC( HDC hdc )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserWindowFromDC );
|
|
}
|
|
|
|
HWND SYSCALL_API NtUserWindowFromPoint( LONG x, LONG y )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id_NtUserWindowFromPoint );
|
|
}
|
|
|
|
BOOL SYSCALL_API __wine_get_file_outline_text_metric( const WCHAR *path, TEXTMETRICW *otm,
|
|
UINT *em_square, WCHAR *face_name )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id___wine_get_file_outline_text_metric );
|
|
}
|
|
|
|
BOOL SYSCALL_API __wine_get_icm_profile( HDC hdc, BOOL allow_default, DWORD *size, WCHAR *filename )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id___wine_get_icm_profile );
|
|
}
|
|
|
|
BOOL SYSCALL_API __wine_send_input( HWND hwnd, const INPUT *input, const RAWINPUT *rawinput )
|
|
{
|
|
__ASM_SYSCALL_FUNC( __id___wine_send_input );
|
|
}
|
|
|
|
#else /* __arm64ec__ */
|
|
|
|
#ifdef _WIN64
|
|
#define SYSCALL_ENTRY(id,name,args) __ASM_SYSCALL_FUNC( id + 0x1000, name )
|
|
ALL_SYSCALLS64
|
|
#else
|
|
#define SYSCALL_ENTRY(id,name,args) __ASM_SYSCALL_FUNC( id + 0x1000, name, args )
|
|
DEFINE_SYSCALL_HELPER32()
|
|
ALL_SYSCALLS32
|
|
#endif
|
|
#undef SYSCALL_ENTRY
|
|
|
|
#endif /* __arm64ec__ */
|
|
|
|
|
|
void __cdecl __wine_spec_unimplemented_stub( const char *module, const char *function )
|
|
{
|
|
EXCEPTION_RECORD record;
|
|
|
|
record.ExceptionCode = EXCEPTION_WINE_STUB;
|
|
record.ExceptionFlags = EH_NONCONTINUABLE;
|
|
record.ExceptionRecord = NULL;
|
|
record.ExceptionAddress = __wine_spec_unimplemented_stub;
|
|
record.NumberParameters = 2;
|
|
record.ExceptionInformation[0] = (ULONG_PTR)module;
|
|
record.ExceptionInformation[1] = (ULONG_PTR)function;
|
|
for (;;) RtlRaiseException( &record );
|
|
}
|
|
|
|
BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, void *reserved )
|
|
{
|
|
HMODULE ntdll;
|
|
void **dispatcher_ptr;
|
|
const UNICODE_STRING ntdll_name = RTL_CONSTANT_STRING( L"ntdll.dll" );
|
|
|
|
switch (reason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
LdrDisableThreadCalloutsForDll( inst );
|
|
if (__wine_syscall_dispatcher) break; /* already set through Wow64Transition */
|
|
LdrGetDllHandle( NULL, 0, &ntdll_name, &ntdll );
|
|
dispatcher_ptr = RtlFindExportedRoutineByName( ntdll, "__wine_syscall_dispatcher" );
|
|
__wine_syscall_dispatcher = *dispatcher_ptr;
|
|
if (!NtQueryVirtualMemory( GetCurrentProcess(), inst, MemoryWineUnixFuncs,
|
|
&win32u_handle, sizeof(win32u_handle), NULL ))
|
|
__wine_unix_call( win32u_handle, 0, NULL );
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|