[PATCH 0/1] MR2291: win32u: replace calling unix functions by unix_call and remove callback unix_funcs

[Fan WenJie (＠fanwenjie)]

Signed-off-by: Fan WenJie

calling unix funcions from PE must via unix_call, Because must switch fs register vaule and other context on wow64 mode. Currently calling some unix functions of win32u via function pointers. The patch modify the way of calling unix functions of win32u by unix_call

[PATCH 1/1] win32u: replace calling unix functions by unix_call and remove callback unix_funcs

[Fan WenJie]

From: Fan WenJie

Signed-off-by: Fan WenJie 
---
 dlls/win32u/Makefile.in      |    2 +-
 dlls/win32u/gdiobj.c         |  133 +---
 dlls/win32u/main.c           |    9 +-
 dlls/win32u/syscall.c        | 1081 +++++++++++++++++++++++++-
 dlls/win32u/win32u_private.h | 1385 +++++++++++++++++++++++++++++-----
 dlls/win32u/wrappers.c       |  790 +++++--------------
 6 files changed, 2472 insertions(+), 928 deletions(-)

diff --git a/dlls/win32u/Makefile.in b/dlls/win32u/Makefile.in
index 7274f132fa5..06bb005368f 100644
--- a/dlls/win32u/Makefile.in
+++ b/dlls/win32u/Makefile.in
@@ -6,7 +6,7 @@ IMPORTS   = ntdll winecrt0
 UNIX_CFLAGS  = $(FREETYPE_CFLAGS) $(FONTCONFIG_CFLAGS)
 UNIX_LIBS    = $(CARBON_LIBS) $(APPKIT_LIBS) $(PTHREAD_LIBS) -lm

-EXTRADLLFLAGS = -nodefaultlibs -Wb,--syscall-table,1
+EXTRADLLFLAGS = -Wb,--syscall-table,1

C_SRCS = \
    bitblt.c \
diff --git a/dlls/win32u/gdiobj.c b/dlls/win32u/gdiobj.c
index f88efbaa679..c02b7f56f64 100644
--- a/dlls/win32u/gdiobj.c
+++ b/dlls/win32u/gdiobj.c
@@ -1027,131 +1027,6 @@ BOOL WINAPI NtGdiSetColorAdjustment( HDC hdc, const COLORADJUSTMENT *ca )
     return FALSE;
 }

-
-static struct unix_funcs unix_funcs =
-{
-    NtGdiAbortDoc,
-    NtGdiAbortPath,
-    NtGdiAlphaBlend,
-    NtGdiAngleArc,
-    NtGdiArcInternal,
-    NtGdiBeginPath,
-    NtGdiBitBlt,
-    NtGdiCloseFigure,
-    NtGdiComputeXformCoefficients,
-    NtGdiCreateCompatibleBitmap,
-    NtGdiCreateCompatibleDC,
-    NtGdiCreateDIBitmapInternal,
-    NtGdiCreateMetafileDC,
-    NtGdiDdDDICheckVidPnExclusiveOwnership,
-    NtGdiDdDDICloseAdapter,
-    NtGdiDdDDICreateDCFromMemory,
-    NtGdiDdDDIDestroyDCFromMemory,
-    NtGdiDdDDIDestroyDevice,
-    NtGdiDdDDIEscape,
-    NtGdiDdDDIOpenAdapterFromDeviceName,
-    NtGdiDdDDIOpenAdapterFromLuid,
-    NtGdiDdDDIQueryVideoMemoryInfo,
-    NtGdiDdDDISetVidPnSourceOwner,
-    NtGdiDeleteObjectApp,
-    NtGdiDoPalette,
-    NtGdiEllipse,
-    NtGdiEndDoc,
-    NtGdiEndPath,
-    NtGdiEndPage,
-    NtGdiEnumFonts,
-    NtGdiExcludeClipRect,
-    NtGdiExtEscape,
-    NtGdiExtFloodFill,
-    NtGdiExtTextOutW,
-    NtGdiExtSelectClipRgn,
-    NtGdiFillPath,
-    NtGdiFillRgn,
-    NtGdiFontIsLinked,
-    NtGdiFrameRgn,
-    NtGdiGetAndSetDCDword,
-    NtGdiGetAppClipBox,
-    NtGdiGetBoundsRect,
-    NtGdiGetCharABCWidthsW,
-    NtGdiGetCharWidthW,
-    NtGdiGetCharWidthInfo,
-    NtGdiGetDIBitsInternal,
-    NtGdiGetDeviceCaps,
-    NtGdiGetDeviceGammaRamp,
-    NtGdiGetFontData,
-    NtGdiGetFontUnicodeRanges,
-    NtGdiGetGlyphIndicesW,
-    NtGdiGetGlyphOutline,
-    NtGdiGetKerningPairs,
-    NtGdiGetNearestColor,
-    NtGdiGetOutlineTextMetricsInternalW,
-    NtGdiGetPixel,
-    NtGdiGetRandomRgn,
-    NtGdiGetRasterizerCaps,
-    NtGdiGetRealizationInfo,
-    NtGdiGetTextCharsetInfo,
-    NtGdiGetTextExtentExW,
-    NtGdiGetTextFaceW,
-    NtGdiGetTextMetricsW,
-    NtGdiGradientFill,
-    NtGdiIntersectClipRect,
-    NtGdiInvertRgn,
-    NtGdiLineTo,
-    NtGdiMaskBlt,
-    NtGdiModifyWorldTransform,
-    NtGdiMoveTo,
-    NtGdiOffsetClipRgn,
-    NtGdiOpenDCW,
-    NtGdiPatBlt,
-    NtGdiPlgBlt,
-    NtGdiPolyDraw,
-    NtGdiPolyPolyDraw,
-    NtGdiPtVisible,
-    NtGdiRectVisible,
-    NtGdiRectangle,
-    NtGdiResetDC,
-    NtGdiResizePalette,
-    NtGdiRestoreDC,
-    NtGdiRoundRect,
-    NtGdiScaleViewportExtEx,
-    NtGdiScaleWindowExtEx,
-    NtGdiSelectBitmap,
-    NtGdiSelectBrush,
-    NtGdiSelectClipPath,
-    NtGdiSelectFont,
-    NtGdiSelectPen,
-    NtGdiSetBoundsRect,
-    NtGdiSetDIBitsToDeviceInternal,
-    NtGdiSetDeviceGammaRamp,
-    NtGdiSetLayout,
-    NtGdiSetPixel,
-    NtGdiSetSystemPaletteUse,
-    NtGdiStartDoc,
-    NtGdiStartPage,
-    NtGdiStretchBlt,
-    NtGdiStretchDIBitsInternal,
-    NtGdiStrokeAndFillPath,
-    NtGdiStrokePath,
-    NtGdiTransparentBlt,
-    NtGdiUnrealizeObject,
-    NtGdiUpdateColors,
-    NtGdiWidenPath,
-    NtUserDrawCaptionTemp,
-    NtUserDrawMenuBarTemp,
-    NtUserEndPaint,
-    NtUserExcludeUpdateRgn,
-    NtUserReleaseDC,
-    NtUserScrollDC,
-    NtUserSelectPalette,
-    NtUserUpdateLayeredWindow,
-
-    SetDIBits,
-    __wine_get_brush_bitmap_info,
-    __wine_get_file_outline_text_metric,
-    __wine_get_icm_profile,
-    __wine_send_input,
-};
-
 void gdi_init(void)
 {
     pthread_mutexattr_t attr;
@@ -1168,10 +1043,4 @@ void gdi_init(void)

dpi = font_init();
     init_stock_objects( dpi );
-}
-
-NTSTATUS callbacks_init( void *args )
-{
-    *(const struct unix_funcs **)args = &unix_funcs;
-    return 0;
-}
+}
\ No newline at end of file
diff --git a/dlls/win32u/main.c b/dlls/win32u/main.c
index 3d6a9c2d038..16e2513c661 100644
--- a/dlls/win32u/main.c
+++ b/dlls/win32u/main.c
@@ -29,9 +29,6 @@
 #include "wine/unixlib.h"

extern void *__wine_syscall_dispatcher DECLSPEC_HIDDEN;
-
-static unixlib_handle_t win32u_handle;
-
 void __cdecl __wine_spec_unimplemented_stub( const char *module, const char *function )
 {
     EXCEPTION_RECORD record;
@@ -53,11 +50,9 @@ BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, void *reserved )
     case DLL_PROCESS_ATTACH:
         LdrDisableThreadCalloutsForDll( inst );
         if (__wine_syscall_dispatcher) break;  /* already set through Wow64Transition */
-        if (!NtQueryVirtualMemory( GetCurrentProcess(), inst, MemoryWineUnixFuncs,
-                                   &win32u_handle, sizeof(win32u_handle), NULL ))
+        if (!__wine_init_unix_call())
         {
-            __wine_unix_call( win32u_handle, 0, &__wine_syscall_dispatcher );
-            wrappers_init( win32u_handle );
+            WINE_UNIX_CALL(0, &__wine_syscall_dispatcher );
         }
         break;
     }
diff --git a/dlls/win32u/syscall.c b/dlls/win32u/syscall.c
index 9020aa01126..08a2135a2a6 100644
--- a/dlls/win32u/syscall.c
+++ b/dlls/win32u/syscall.c
@@ -332,12 +332,965 @@ static NTSTATUS init( void *dispatcher )
     return ntdll_init_syscalls( 1, &syscall_table, dispatcher );
 }

-unixlib_entry_t __wine_unix_call_funcs[] =
+static NTSTATUS win32u_NtGdiAbortDoc(void* args)
 {
-    init,
-    callbacks_init,
+    struct NtGdiAbortDoc_params* params = (typeof(params))args;
+    params->$result = NtGdiAbortDoc( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiAbortPath(void* args)
+{
+    struct NtGdiAbortPath_params* params = (typeof(params))args;
+    params->$result = NtGdiAbortPath( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiAlphaBlend(void* args)
+{
+    struct NtGdiAlphaBlend_params* params = (typeof(params))args;
+    params->$result = NtGdiAlphaBlend( params->hdc_dst, params->x_dst, params->y_dst, params->width_dst, params->height_dst, params->hdc_src, params->x_src, params->y_src, params->width_src, params->height_src, params->blend_function, params->xform);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiAngleArc(void* args)
+{
+    struct NtGdiAngleArc_params* params = (typeof(params))args;
+    params->$result = NtGdiAngleArc( params->hdc, params->x, params->y, params->radius, params->start_angle, params->sweep_angle);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiArcInternal(void* args)
+{
+    struct NtGdiArcInternal_params* params = (typeof(params))args;
+    params->$result = NtGdiArcInternal( params->type, params->hdc, params->left, params->top, params->right, params->bottom, params->xstart, params->ystart, params->xend, params->yend);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiBeginPath(void* args)
+{
+    struct NtGdiBeginPath_params* params = (typeof(params))args;
+    params->$result = NtGdiBeginPath( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiBitBlt(void* args)
+{
+    struct NtGdiBitBlt_params* params = (typeof(params))args;
+    params->$result = NtGdiBitBlt( params->hdc_dst, params->x_dst, params->y_dst, params->width, params->height, params->hdc_src, params->x_src, params->y_src, params->rop, params->bk_color, params->fl);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiCloseFigure(void* args)
+{
+    struct NtGdiCloseFigure_params* params = (typeof(params))args;
+    params->$result = NtGdiCloseFigure( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiComputeXformCoefficients(void* args)
+{
+    struct NtGdiComputeXformCoefficients_params* params = (typeof(params))args;
+    params->$result = NtGdiComputeXformCoefficients( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiCreateCompatibleBitmap(void* args)
+{
+    struct NtGdiCreateCompatibleBitmap_params* params = (typeof(params))args;
+    params->$result = NtGdiCreateCompatibleBitmap( params->hdc, params->width, params->height);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiCreateCompatibleDC(void* args)
+{
+    struct NtGdiCreateCompatibleDC_params* params = (typeof(params))args;
+    params->$result = NtGdiCreateCompatibleDC( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiCreateDIBitmapInternal(void* args)
+{
+    struct NtGdiCreateDIBitmapInternal_params* params = (typeof(params))args;
+    params->$result = NtGdiCreateDIBitmapInternal( params->hdc, params->width, params->height, params->init, params->bits, params->data, params->coloruse, params->max_info, params->max_bits, params->flags, params->xform);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiCreateMetafileDC(void* args)
+{
+    struct NtGdiCreateMetafileDC_params* params = (typeof(params))args;
+    params->$result = NtGdiCreateMetafileDC( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDdDDICheckVidPnExclusiveOwnership(void* args)
+{
+    struct NtGdiDdDDICheckVidPnExclusiveOwnership_params* params = (typeof(params))args;
+    params->$result = NtGdiDdDDICheckVidPnExclusiveOwnership( params->desc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDdDDICloseAdapter(void* args)
+{
+    struct NtGdiDdDDICloseAdapter_params* params = (typeof(params))args;
+    params->$result = NtGdiDdDDICloseAdapter( params->desc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDdDDICreateDCFromMemory(void* args)
+{
+    struct NtGdiDdDDICreateDCFromMemory_params* params = (typeof(params))args;
+    params->$result = NtGdiDdDDICreateDCFromMemory( params->desc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDdDDIDestroyDCFromMemory(void* args)
+{
+    struct NtGdiDdDDIDestroyDCFromMemory_params* params = (typeof(params))args;
+    params->$result = NtGdiDdDDIDestroyDCFromMemory( params->desc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDdDDIDestroyDevice(void* args)
+{
+    struct NtGdiDdDDIDestroyDevice_params* params = (typeof(params))args;
+    params->$result = NtGdiDdDDIDestroyDevice( params->desc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDdDDIEscape(void* args)
+{
+    struct NtGdiDdDDIEscape_params* params = (typeof(params))args;
+    params->$result = NtGdiDdDDIEscape( params->desc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDdDDIOpenAdapterFromDeviceName(void* args)
+{
+    struct NtGdiDdDDIOpenAdapterFromDeviceName_params* params = (typeof(params))args;
+    params->$result = NtGdiDdDDIOpenAdapterFromDeviceName( params->desc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDdDDIOpenAdapterFromLuid(void* args)
+{
+    struct NtGdiDdDDIOpenAdapterFromLuid_params* params = (typeof(params))args;
+    params->$result = NtGdiDdDDIOpenAdapterFromLuid( params->desc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDdDDIQueryVideoMemoryInfo(void* args)
+{
+    struct NtGdiDdDDIQueryVideoMemoryInfo_params* params = (typeof(params))args;
+    params->$result = NtGdiDdDDIQueryVideoMemoryInfo( params->desc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDdDDISetVidPnSourceOwner(void* args)
+{
+    struct NtGdiDdDDISetVidPnSourceOwner_params* params = (typeof(params))args;
+    params->$result = NtGdiDdDDISetVidPnSourceOwner( params->desc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDeleteObjectApp(void* args)
+{
+    struct NtGdiDeleteObjectApp_params* params = (typeof(params))args;
+    params->$result = NtGdiDeleteObjectApp( params->obj);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiDoPalette(void* args)
+{
+    struct NtGdiDoPalette_params* params = (typeof(params))args;
+    params->$result = NtGdiDoPalette( params->handle, params->start, params->count, params->entries, params->func, params->inbound);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiEllipse(void* args)
+{
+    struct NtGdiEllipse_params* params = (typeof(params))args;
+    params->$result = NtGdiEllipse( params->hdc, params->left, params->top, params->right, params->bottom);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiEndDoc(void* args)
+{
+    struct NtGdiEndDoc_params* params = (typeof(params))args;
+    params->$result = NtGdiEndDoc( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiEndPath(void* args)
+{
+    struct NtGdiEndPath_params* params = (typeof(params))args;
+    params->$result = NtGdiEndPath( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiEndPage(void* args)
+{
+    struct NtGdiEndPage_params* params = (typeof(params))args;
+    params->$result = NtGdiEndPage( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiEnumFonts(void* args)
+{
+    struct NtGdiEnumFonts_params* params = (typeof(params))args;
+    params->$result = NtGdiEnumFonts( params->hdc, params->type, params->win32_compat, params->face_name_len, params->face_name, params->charset, params->count, params->buf);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiExcludeClipRect(void* args)
+{
+    struct NtGdiExcludeClipRect_params* params = (typeof(params))args;
+    params->$result = NtGdiExcludeClipRect( params->hdc, params->left, params->top, params->right, params->bottom);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiExtEscape(void* args)
+{
+    struct NtGdiExtEscape_params* params = (typeof(params))args;
+    params->$result = NtGdiExtEscape( params->hdc, params->driver, params->driver_id, params->escape, params->input_size, params->input, params->output_size, params->output);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiExtFloodFill(void* args)
+{
+    struct NtGdiExtFloodFill_params* params = (typeof(params))args;
+    params->$result = NtGdiExtFloodFill( params->hdc, params->x, params->y, params->color, params->type);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiExtTextOutW(void* args)
+{
+    struct NtGdiExtTextOutW_params* params = (typeof(params))args;
+    params->$result = NtGdiExtTextOutW( params->hdc, params->x, params->y, params->flags, params->rect, params->str, params->count, params->dx, params->cp);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiExtSelectClipRgn(void* args)
+{
+    struct NtGdiExtSelectClipRgn_params* params = (typeof(params))args;
+    params->$result = NtGdiExtSelectClipRgn( params->hdc, params->region, params->mode);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiFillPath(void* args)
+{
+    struct NtGdiFillPath_params* params = (typeof(params))args;
+    params->$result = NtGdiFillPath( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiFillRgn(void* args)
+{
+    struct NtGdiFillRgn_params* params = (typeof(params))args;
+    params->$result = NtGdiFillRgn( params->hdc, params->hrgn, params->hbrush);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiFontIsLinked(void* args)
+{
+    struct NtGdiFontIsLinked_params* params = (typeof(params))args;
+    params->$result = NtGdiFontIsLinked( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiFrameRgn(void* args)
+{
+    struct NtGdiFrameRgn_params* params = (typeof(params))args;
+    params->$result = NtGdiFrameRgn( params->hdc, params->hrgn, params->brush, params->width, params->height);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetAndSetDCDword(void* args)
+{
+    struct NtGdiGetAndSetDCDword_params* params = (typeof(params))args;
+    params->$result = NtGdiGetAndSetDCDword( params->hdc, params->method, params->value, params->result);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetAppClipBox(void* args)
+{
+    struct NtGdiGetAppClipBox_params* params = (typeof(params))args;
+    params->$result = NtGdiGetAppClipBox( params->hdc, params->rect);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetBoundsRect(void* args)
+{
+    struct NtGdiGetBoundsRect_params* params = (typeof(params))args;
+    params->$result = NtGdiGetBoundsRect( params->hdc, params->rect, params->flags);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetCharABCWidthsW(void* args)
+{
+    struct NtGdiGetCharABCWidthsW_params* params = (typeof(params))args;
+    params->$result = NtGdiGetCharABCWidthsW( params->hdc, params->first, params->last, params->chars, params->flags, params->buffer);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetCharWidthW(void* args)
+{
+    struct NtGdiGetCharWidthW_params* params = (typeof(params))args;
+    params->$result = NtGdiGetCharWidthW( params->hdc, params->first_char, params->last_char, params->chars, params->flags, params->buffer);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetCharWidthInfo(void* args)
+{
+    struct NtGdiGetCharWidthInfo_params* params = (typeof(params))args;
+    params->$result = NtGdiGetCharWidthInfo( params->hdc, params->info);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetDIBitsInternal(void* args)
+{
+    struct NtGdiGetDIBitsInternal_params* params = (typeof(params))args;
+    params->$result = NtGdiGetDIBitsInternal( params->hdc, params->hbitmap, params->startscan, params->lines, params->bits, params->info, params->coloruse, params->max_bits, params->max_info);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetDeviceCaps(void* args)
+{
+    struct NtGdiGetDeviceCaps_params* params = (typeof(params))args;
+    params->$result = NtGdiGetDeviceCaps( params->hdc, params->cap);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetDeviceGammaRamp(void* args)
+{
+    struct NtGdiGetDeviceGammaRamp_params* params = (typeof(params))args;
+    params->$result = NtGdiGetDeviceGammaRamp( params->hdc, params->ptr);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetFontData(void* args)
+{
+    struct NtGdiGetFontData_params* params = (typeof(params))args;
+    params->$result = NtGdiGetFontData( params->hdc, params->table, params->offset, params->buffer, params->length);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetFontUnicodeRanges(void* args)
+{
+    struct NtGdiGetFontUnicodeRanges_params* params = (typeof(params))args;
+    params->$result = NtGdiGetFontUnicodeRanges( params->hdc, params->lpgs);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetGlyphIndicesW(void* args)
+{
+    struct NtGdiGetGlyphIndicesW_params* params = (typeof(params))args;
+    params->$result = NtGdiGetGlyphIndicesW( params->hdc, params->str, params->count, params->indices, params->flags);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetGlyphOutline(void* args)
+{
+    struct NtGdiGetGlyphOutline_params* params = (typeof(params))args;
+    params->$result = NtGdiGetGlyphOutline( params->hdc, params->ch, params->format, params->metrics, params->size, params->buffer, params->mat2, params->ignore_rotation);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetKerningPairs(void* args)
+{
+    struct NtGdiGetKerningPairs_params* params = (typeof(params))args;
+    params->$result = NtGdiGetKerningPairs( params->hdc, params->count, params->kern_pair);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetNearestColor(void* args)
+{
+    struct NtGdiGetNearestColor_params* params = (typeof(params))args;
+    params->$result = NtGdiGetNearestColor( params->hdc, params->color);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetOutlineTextMetricsInternalW(void* args)
+{
+    struct NtGdiGetOutlineTextMetricsInternalW_params* params = (typeof(params))args;
+    params->$result = NtGdiGetOutlineTextMetricsInternalW( params->hdc, params->cbData, params->otm, params->opts);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetPixel(void* args)
+{
+    struct NtGdiGetPixel_params* params = (typeof(params))args;
+    params->$result = NtGdiGetPixel( params->hdc, params->x, params->y);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetRandomRgn(void* args)
+{
+    struct NtGdiGetRandomRgn_params* params = (typeof(params))args;
+    params->$result = NtGdiGetRandomRgn( params->hdc, params->region, params->code);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetRasterizerCaps(void* args)
+{
+    struct NtGdiGetRasterizerCaps_params* params = (typeof(params))args;
+    params->$result = NtGdiGetRasterizerCaps( params->status, params->size);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetRealizationInfo(void* args)
+{
+    struct NtGdiGetRealizationInfo_params* params = (typeof(params))args;
+    params->$result = NtGdiGetRealizationInfo( params->hdc, params->info);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetTextCharsetInfo(void* args)
+{
+    struct NtGdiGetTextCharsetInfo_params* params = (typeof(params))args;
+    params->$result = NtGdiGetTextCharsetInfo( params->hdc, params->fs, params->flags);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetTextExtentExW(void* args)
+{
+    struct NtGdiGetTextExtentExW_params* params = (typeof(params))args;
+    params->$result = NtGdiGetTextExtentExW( params->hdc, params->str, params->count, params->max_ext, params->nfit, params->dxs, params->size, params->flags);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetTextFaceW(void* args)
+{
+    struct NtGdiGetTextFaceW_params* params = (typeof(params))args;
+    params->$result = NtGdiGetTextFaceW( params->hdc, params->count, params->name, params->alias_name);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGetTextMetricsW(void* args)
+{
+    struct NtGdiGetTextMetricsW_params* params = (typeof(params))args;
+    params->$result = NtGdiGetTextMetricsW( params->hdc, params->metrics, params->flags);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiGradientFill(void* args)
+{
+    struct NtGdiGradientFill_params* params = (typeof(params))args;
+    params->$result = NtGdiGradientFill( params->hdc, params->vert_array, params->nvert, params->grad_array, params->ngrad, params->mode);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiIntersectClipRect(void* args)
+{
+    struct NtGdiIntersectClipRect_params* params = (typeof(params))args;
+    params->$result = NtGdiIntersectClipRect( params->hdc, params->left, params->top, params->right, params->bottom);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiInvertRgn(void* args)
+{
+    struct NtGdiInvertRgn_params* params = (typeof(params))args;
+    params->$result = NtGdiInvertRgn( params->hdc, params->hrgn);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiLineTo(void* args)
+{
+    struct NtGdiLineTo_params* params = (typeof(params))args;
+    params->$result = NtGdiLineTo( params->hdc, params->x, params->y);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiMaskBlt(void* args)
+{
+    struct NtGdiMaskBlt_params* params = (typeof(params))args;
+    params->$result = NtGdiMaskBlt( params->hdc, params->x_dst, params->y_dst, params->width_dst, params->height_dst, params->hdc_src, params->x_src, params->y_src, params->mask, params->x_mask, params->y_mask, params->rop, params->bk_color);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiModifyWorldTransform(void* args)
+{
+    struct NtGdiModifyWorldTransform_params* params = (typeof(params))args;
+    params->$result = NtGdiModifyWorldTransform( params->hdc, params->xform, params->mode);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiMoveTo(void* args)
+{
+    struct NtGdiMoveTo_params* params = (typeof(params))args;
+    params->$result = NtGdiMoveTo( params->hdc, params->x, params->y, params->pt);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiOffsetClipRgn(void* args)
+{
+    struct NtGdiOffsetClipRgn_params* params = (typeof(params))args;
+    params->$result = NtGdiOffsetClipRgn( params->hdc, params->x, params->y);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiOpenDCW(void* args)
+{
+    struct NtGdiOpenDCW_params* params = (typeof(params))args;
+    params->$result = NtGdiOpenDCW( params->device, params->devmode, params->output, params->type, params->is_display, params->hspool, params->driver_info, params->pdev);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiPatBlt(void* args)
+{
+    struct NtGdiPatBlt_params* params = (typeof(params))args;
+    params->$result = NtGdiPatBlt( params->hdc, params->left, params->top, params->width, params->height, params->rop);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiPlgBlt(void* args)
+{
+    struct NtGdiPlgBlt_params* params = (typeof(params))args;
+    params->$result = NtGdiPlgBlt( params->hdc, params->point, params->hdc_src, params->x_src, params->y_src, params->width, params->height, params->mask, params->x_mask, params->y_mask, params->bk_color);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiPolyDraw(void* args)
+{
+    struct NtGdiPolyDraw_params* params = (typeof(params))args;
+    params->$result = NtGdiPolyDraw( params->hdc, params->points, params->types, params->count);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiPolyPolyDraw(void* args)
+{
+    struct NtGdiPolyPolyDraw_params* params = (typeof(params))args;
+    params->$result = NtGdiPolyPolyDraw( params->hdc, params->points, params->counts, params->count, params->function);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiPtVisible(void* args)
+{
+    struct NtGdiPtVisible_params* params = (typeof(params))args;
+    params->$result = NtGdiPtVisible( params->hdc, params->x, params->y);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiRectVisible(void* args)
+{
+    struct NtGdiRectVisible_params* params = (typeof(params))args;
+    params->$result = NtGdiRectVisible( params->hdc, params->rect);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiRectangle(void* args)
+{
+    struct NtGdiRectangle_params* params = (typeof(params))args;
+    params->$result = NtGdiRectangle( params->hdc, params->left, params->top, params->right, params->bottom);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiResetDC(void* args)
+{
+    struct NtGdiResetDC_params* params = (typeof(params))args;
+    params->$result = NtGdiResetDC( params->hdc, params->devmode, params->banding, params->driver_info, params->dev);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiResizePalette(void* args)
+{
+    struct NtGdiResizePalette_params* params = (typeof(params))args;
+    params->$result = NtGdiResizePalette( params->palette, params->count);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiRestoreDC(void* args)
+{
+    struct NtGdiRestoreDC_params* params = (typeof(params))args;
+    params->$result = NtGdiRestoreDC( params->hdc, params->level);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiRoundRect(void* args)
+{
+    struct NtGdiRoundRect_params* params = (typeof(params))args;
+    params->$result = NtGdiRoundRect( params->hdc, params->left, params->top, params->right, params->bottom, params->ell_width, params->ell_height);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiScaleViewportExtEx(void* args)
+{
+    struct NtGdiScaleViewportExtEx_params* params = (typeof(params))args;
+    params->$result = NtGdiScaleViewportExtEx( params->hdc, params->x_num, params->x_denom, params->y_num, params->y_denom, params->size);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiScaleWindowExtEx(void* args)
+{
+    struct NtGdiScaleWindowExtEx_params* params = (typeof(params))args;
+    params->$result = NtGdiScaleWindowExtEx( params->hdc, params->x_num, params->x_denom, params->y_num, params->y_denom, params->size);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSelectBitmap(void* args)
+{
+    struct NtGdiSelectBitmap_params* params = (typeof(params))args;
+    params->$result = NtGdiSelectBitmap( params->hdc, params->handle);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSelectBrush(void* args)
+{
+    struct NtGdiSelectBrush_params* params = (typeof(params))args;
+    params->$result = NtGdiSelectBrush( params->hdc, params->handle);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSelectClipPath(void* args)
+{
+    struct NtGdiSelectClipPath_params* params = (typeof(params))args;
+    params->$result = NtGdiSelectClipPath( params->hdc, params->mode);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSelectFont(void* args)
+{
+    struct NtGdiSelectFont_params* params = (typeof(params))args;
+    params->$result = NtGdiSelectFont( params->hdc, params->handle);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSelectPen(void* args)
+{
+    struct NtGdiSelectPen_params* params = (typeof(params))args;
+    params->$result = NtGdiSelectPen( params->hdc, params->handle);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSetBoundsRect(void* args)
+{
+    struct NtGdiSetBoundsRect_params* params = (typeof(params))args;
+    params->$result = NtGdiSetBoundsRect( params->hdc, params->rect, params->flags);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSetDIBitsToDeviceInternal(void* args)
+{
+    struct NtGdiSetDIBitsToDeviceInternal_params* params = (typeof(params))args;
+    params->$result = NtGdiSetDIBitsToDeviceInternal( params->hdc, params->x_dst, params->y_dst, params->cx, params->cy, params->x_src, params->y_src, params->startscan, params->lines, params->bits, params->bmi, params->coloruse, params->max_bits, params->max_info, params->xform_coords, params->xform);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSetDeviceGammaRamp(void* args)
+{
+    struct NtGdiSetDeviceGammaRamp_params* params = (typeof(params))args;
+    params->$result = NtGdiSetDeviceGammaRamp( params->hdc, params->ptr);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSetLayout(void* args)
+{
+    struct NtGdiSetLayout_params* params = (typeof(params))args;
+    params->$result = NtGdiSetLayout( params->hdc, params->wox, params->layout);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSetPixel(void* args)
+{
+    struct NtGdiSetPixel_params* params = (typeof(params))args;
+    params->$result = NtGdiSetPixel( params->hdc, params->x, params->y, params->color);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiSetSystemPaletteUse(void* args)
+{
+    struct NtGdiSetSystemPaletteUse_params* params = (typeof(params))args;
+    params->$result = NtGdiSetSystemPaletteUse( params->hdc, params->use);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiStartDoc(void* args)
+{
+    struct NtGdiStartDoc_params* params = (typeof(params))args;
+    params->$result = NtGdiStartDoc( params->hdc, params->doc, params->banding, params->job);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiStartPage(void* args)
+{
+    struct NtGdiStartPage_params* params = (typeof(params))args;
+    params->$result = NtGdiStartPage( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiStretchBlt(void* args)
+{
+    struct NtGdiStretchBlt_params* params = (typeof(params))args;
+    params->$result = NtGdiStretchBlt( params->hdc, params->x_dst, params->y_dst, params->width_dst, params->height_dst, params->hdc_src, params->x_src, params->y_src, params->width_src, params->height_src, params->rop, params->bk_color);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiStretchDIBitsInternal(void* args)
+{
+    struct NtGdiStretchDIBitsInternal_params* params = (typeof(params))args;
+    params->$result = NtGdiStretchDIBitsInternal( params->hdc, params->x_dst, params->y_dst, params->width_dst, params->height_dst, params->x_src, params->y_src, params->width_src, params->height_src, params->bits, params->bmi, params->coloruse, params->rop, params->max_info, params->max_bits, params->xform);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiStrokeAndFillPath(void* args)
+{
+    struct NtGdiStrokeAndFillPath_params* params = (typeof(params))args;
+    params->$result = NtGdiStrokeAndFillPath( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiStrokePath(void* args)
+{
+    struct NtGdiStrokePath_params* params = (typeof(params))args;
+    params->$result = NtGdiStrokePath( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiTransparentBlt(void* args)
+{
+    struct NtGdiTransparentBlt_params* params = (typeof(params))args;
+    params->$result = NtGdiTransparentBlt( params->hdc, params->x_dst, params->y_dst, params->width_dst, params->height_dst, params->hdc_src, params->x_src, params->y_src, params->width_src, params->height_src, params->color);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiUnrealizeObject(void* args)
+{
+    struct NtGdiUnrealizeObject_params* params = (typeof(params))args;
+    params->$result = NtGdiUnrealizeObject( params->obj);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiUpdateColors(void* args)
+{
+    struct NtGdiUpdateColors_params* params = (typeof(params))args;
+    params->$result = NtGdiUpdateColors( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtGdiWidenPath(void* args)
+{
+    struct NtGdiWidenPath_params* params = (typeof(params))args;
+    params->$result = NtGdiWidenPath( params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtUserDrawCaptionTemp(void* args)
+{
+    struct NtUserDrawCaptionTemp_params* params = (typeof(params))args;
+    params->$result = NtUserDrawCaptionTemp( params->hwnd, params->hdc, params->rect, params->font, params->icon, params->str, params->flags);
+    return 0;
+}
+
+static NTSTATUS win32u_NtUserDrawMenuBarTemp(void* args)
+{
+    struct NtUserDrawMenuBarTemp_params* params = (typeof(params))args;
+    params->$result = NtUserDrawMenuBarTemp( params->hwnd, params->hdc, params->rect, params->handle, params->font);
+    return 0;
+}
+
+static NTSTATUS win32u_NtUserEndPaint(void* args)
+{
+    struct NtUserEndPaint_params* params = (typeof(params))args;
+    params->$result = NtUserEndPaint( params->hwnd, params->ps);
+    return 0;
+}
+
+static NTSTATUS win32u_NtUserExcludeUpdateRgn(void* args)
+{
+    struct NtUserExcludeUpdateRgn_params* params = (typeof(params))args;
+    params->$result = NtUserExcludeUpdateRgn( params->hdc, params->hwnd);
+    return 0;
+}
+
+static NTSTATUS win32u_NtUserReleaseDC(void* args)
+{
+    struct NtUserReleaseDC_params* params = (typeof(params))args;
+    params->$result = NtUserReleaseDC( params->hwnd, params->hdc);
+    return 0;
+}
+
+static NTSTATUS win32u_NtUserScrollDC(void* args)
+{
+    struct NtUserScrollDC_params* params = (typeof(params))args;
+    params->$result = NtUserScrollDC( params->hdc, params->dx, params->dy, params->scroll, params->clip, params->ret_update_rgn, params->update_rect);
+    return 0;
+}
+
+static NTSTATUS win32u_NtUserSelectPalette(void* args)
+{
+    struct NtUserSelectPalette_params* params = (typeof(params))args;
+    params->$result = NtUserSelectPalette( params->hdc, params->hpal, params->bkg);
+    return 0;
+}
+
+static NTSTATUS win32u_NtUserUpdateLayeredWindow(void* args)
+{
+    struct NtUserUpdateLayeredWindow_params* params = (typeof(params))args;
+    params->$result = NtUserUpdateLayeredWindow( params->hwnd, params->hdc_dst, params->pts_dst, params->size, params->hdc_src, params->pts_src, params->key, params->blend, params->flags, params->dirty);
+    return 0;
+}
+
+static NTSTATUS win32u_SetDIBits(void* args)
+{
+    struct SetDIBits_params* params = (typeof(params))args;
+    params->$result = SetDIBits( params->hdc, params->hbitmap, params->startscan, params->lines, params->bits, params->info, params->coloruse);
+    return 0;
+}
+
+static NTSTATUS win32u___wine_get_brush_bitmap_info(void* args)
+{
+    struct __wine_get_brush_bitmap_info_params* params = (typeof(params))args;
+    params->$result = __wine_get_brush_bitmap_info( params->handle, params->info, params->bits, params->usage);
+    return 0;
+}
+
+static NTSTATUS win32u___wine_get_file_outline_text_metric(void* args)
+{
+    struct __wine_get_file_outline_text_metric_params* params = (typeof(params))args;
+    params->$result = __wine_get_file_outline_text_metric( params->path, params->otm);
+    return 0;
+}
+
+static NTSTATUS win32u___wine_get_icm_profile(void* args)
+{
+    struct __wine_get_icm_profile_params* params = (typeof(params))args;
+    params->$result = __wine_get_icm_profile( params->hdc, params->allow_default, params->size, params->filename);
+    return 0;
+}
+
+static NTSTATUS win32u___wine_send_input(void* args)
+{
+    struct __wine_send_input_params* params = (typeof(params))args;
+    params->$result = __wine_send_input( params->hwnd, params->input, params->rawinput);
+    return 0;
+}
+
+const unixlib_entry_t __wine_unix_call_funcs[] =
+{
+    &init,
+    &win32u_NtGdiAbortDoc,
+    &win32u_NtGdiAbortPath,
+    &win32u_NtGdiAlphaBlend,
+    &win32u_NtGdiAngleArc,
+    &win32u_NtGdiArcInternal,
+    &win32u_NtGdiBeginPath,
+    &win32u_NtGdiBitBlt,
+    &win32u_NtGdiCloseFigure,
+    &win32u_NtGdiComputeXformCoefficients,
+    &win32u_NtGdiCreateCompatibleBitmap,
+    &win32u_NtGdiCreateCompatibleDC,
+    &win32u_NtGdiCreateDIBitmapInternal,
+    &win32u_NtGdiCreateMetafileDC,
+    &win32u_NtGdiDdDDICheckVidPnExclusiveOwnership,
+    &win32u_NtGdiDdDDICloseAdapter,
+    &win32u_NtGdiDdDDICreateDCFromMemory,
+    &win32u_NtGdiDdDDIDestroyDCFromMemory,
+    &win32u_NtGdiDdDDIDestroyDevice,
+    &win32u_NtGdiDdDDIEscape,
+    &win32u_NtGdiDdDDIOpenAdapterFromDeviceName,
+    &win32u_NtGdiDdDDIOpenAdapterFromLuid,
+    &win32u_NtGdiDdDDIQueryVideoMemoryInfo,
+    &win32u_NtGdiDdDDISetVidPnSourceOwner,
+    &win32u_NtGdiDeleteObjectApp,
+    &win32u_NtGdiDoPalette,
+    &win32u_NtGdiEllipse,
+    &win32u_NtGdiEndDoc,
+    &win32u_NtGdiEndPage,
+    &win32u_NtGdiEndPath,
+    &win32u_NtGdiEnumFonts,
+    &win32u_NtGdiExcludeClipRect,
+    &win32u_NtGdiExtEscape,
+    &win32u_NtGdiExtFloodFill,
+    &win32u_NtGdiExtSelectClipRgn,
+    &win32u_NtGdiExtTextOutW,
+    &win32u_NtGdiFillPath,
+    &win32u_NtGdiFillRgn,
+    &win32u_NtGdiFontIsLinked,
+    &win32u_NtGdiFrameRgn,
+    &win32u_NtGdiGetAndSetDCDword,
+    &win32u_NtGdiGetAppClipBox,
+    &win32u_NtGdiGetBoundsRect,
+    &win32u_NtGdiGetCharABCWidthsW,
+    &win32u_NtGdiGetCharWidthInfo,
+    &win32u_NtGdiGetCharWidthW,
+    &win32u_NtGdiGetDIBitsInternal,
+    &win32u_NtGdiGetDeviceCaps,
+    &win32u_NtGdiGetDeviceGammaRamp,
+    &win32u_NtGdiGetFontData,
+    &win32u_NtGdiGetFontUnicodeRanges,
+    &win32u_NtGdiGetGlyphIndicesW,
+    &win32u_NtGdiGetGlyphOutline,
+    &win32u_NtGdiGetKerningPairs,
+    &win32u_NtGdiGetNearestColor,
+    &win32u_NtGdiGetOutlineTextMetricsInternalW,
+    &win32u_NtGdiGetPixel,
+    &win32u_NtGdiGetRandomRgn,
+    &win32u_NtGdiGetRasterizerCaps,
+    &win32u_NtGdiGetRealizationInfo,
+    &win32u_NtGdiGetTextCharsetInfo,
+    &win32u_NtGdiGetTextExtentExW,
+    &win32u_NtGdiGetTextFaceW,
+    &win32u_NtGdiGetTextMetricsW,
+    &win32u_NtGdiGradientFill,
+    &win32u_NtGdiIntersectClipRect,
+    &win32u_NtGdiInvertRgn,
+    &win32u_NtGdiLineTo,
+    &win32u_NtGdiMaskBlt,
+    &win32u_NtGdiModifyWorldTransform,
+    &win32u_NtGdiMoveTo,
+    &win32u_NtGdiOffsetClipRgn,
+    &win32u_NtGdiOpenDCW,
+    &win32u_NtGdiPatBlt,
+    &win32u_NtGdiPlgBlt,
+    &win32u_NtGdiPolyDraw,
+    &win32u_NtGdiPolyPolyDraw,
+    &win32u_NtGdiPtVisible,
+    &win32u_NtGdiRectVisible,
+    &win32u_NtGdiRectangle,
+    &win32u_NtGdiResetDC,
+    &win32u_NtGdiResizePalette,
+    &win32u_NtGdiRestoreDC,
+    &win32u_NtGdiRoundRect,
+    &win32u_NtGdiScaleViewportExtEx,
+    &win32u_NtGdiScaleWindowExtEx,
+    &win32u_NtGdiSelectBitmap,
+    &win32u_NtGdiSelectBrush,
+    &win32u_NtGdiSelectClipPath,
+    &win32u_NtGdiSelectFont,
+    &win32u_NtGdiSelectPen,
+    &win32u_NtGdiSetBoundsRect,
+    &win32u_NtGdiSetDIBitsToDeviceInternal,
+    &win32u_NtGdiSetDeviceGammaRamp,
+    &win32u_NtGdiSetLayout,
+    &win32u_NtGdiSetPixel,
+    &win32u_NtGdiSetSystemPaletteUse,
+    &win32u_NtGdiStartDoc,
+    &win32u_NtGdiStartPage,
+    &win32u_NtGdiStretchBlt,
+    &win32u_NtGdiStretchDIBitsInternal,
+    &win32u_NtGdiStrokeAndFillPath,
+    &win32u_NtGdiStrokePath,
+    &win32u_NtGdiTransparentBlt,
+    &win32u_NtGdiUnrealizeObject,
+    &win32u_NtGdiUpdateColors,
+    &win32u_NtGdiWidenPath,
+    &win32u_NtUserDrawCaptionTemp,
+    &win32u_NtUserDrawMenuBarTemp,
+    &win32u_NtUserEndPaint,
+    &win32u_NtUserExcludeUpdateRgn,
+    &win32u_NtUserReleaseDC,
+    &win32u_NtUserScrollDC,
+    &win32u_NtUserSelectPalette,
+    &win32u_NtUserUpdateLayeredWindow,
+    &win32u_SetDIBits,
+    &win32u___wine_get_brush_bitmap_info,
+    &win32u___wine_get_file_outline_text_metric,
+    &win32u___wine_get_icm_profile,
+    &win32u___wine_send_input,
 };

+C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);
+
 #ifdef _WIN64

WINE_DEFAULT_DEBUG_CHANNEL(win32u);
@@ -350,8 +1303,126 @@ static NTSTATUS wow64_init( void *args )

const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
 {
-    init,
-    wow64_init,
+    &init,
+    &win32u_NtGdiAbortDoc,
+    &win32u_NtGdiAbortPath,
+    &win32u_NtGdiAlphaBlend,
+    &win32u_NtGdiAngleArc,
+    &win32u_NtGdiArcInternal,
+    &win32u_NtGdiBeginPath,
+    &win32u_NtGdiBitBlt,
+    &win32u_NtGdiCloseFigure,
+    &win32u_NtGdiComputeXformCoefficients,
+    &win32u_NtGdiCreateCompatibleBitmap,
+    &win32u_NtGdiCreateCompatibleDC,
+    &win32u_NtGdiCreateDIBitmapInternal,
+    &win32u_NtGdiCreateMetafileDC,
+    &win32u_NtGdiDdDDICheckVidPnExclusiveOwnership,
+    &win32u_NtGdiDdDDICloseAdapter,
+    &win32u_NtGdiDdDDICreateDCFromMemory,
+    &win32u_NtGdiDdDDIDestroyDCFromMemory,
+    &win32u_NtGdiDdDDIDestroyDevice,
+    &win32u_NtGdiDdDDIEscape,
+    &win32u_NtGdiDdDDIOpenAdapterFromDeviceName,
+    &win32u_NtGdiDdDDIOpenAdapterFromLuid,
+    &win32u_NtGdiDdDDIQueryVideoMemoryInfo,
+    &win32u_NtGdiDdDDISetVidPnSourceOwner,
+    &win32u_NtGdiDeleteObjectApp,
+    &win32u_NtGdiDoPalette,
+    &win32u_NtGdiEllipse,
+    &win32u_NtGdiEndDoc,
+    &win32u_NtGdiEndPage,
+    &win32u_NtGdiEndPath,
+    &win32u_NtGdiEnumFonts,
+    &win32u_NtGdiExcludeClipRect,
+    &win32u_NtGdiExtEscape,
+    &win32u_NtGdiExtFloodFill,
+    &win32u_NtGdiExtSelectClipRgn,
+    &win32u_NtGdiExtTextOutW,
+    &win32u_NtGdiFillPath,
+    &win32u_NtGdiFillRgn,
+    &win32u_NtGdiFontIsLinked,
+    &win32u_NtGdiFrameRgn,
+    &win32u_NtGdiGetAndSetDCDword,
+    &win32u_NtGdiGetAppClipBox,
+    &win32u_NtGdiGetBoundsRect,
+    &win32u_NtGdiGetCharABCWidthsW,
+    &win32u_NtGdiGetCharWidthInfo,
+    &win32u_NtGdiGetCharWidthW,
+    &win32u_NtGdiGetDIBitsInternal,
+    &win32u_NtGdiGetDeviceCaps,
+    &win32u_NtGdiGetDeviceGammaRamp,
+    &win32u_NtGdiGetFontData,
+    &win32u_NtGdiGetFontUnicodeRanges,
+    &win32u_NtGdiGetGlyphIndicesW,
+    &win32u_NtGdiGetGlyphOutline,
+    &win32u_NtGdiGetKerningPairs,
+    &win32u_NtGdiGetNearestColor,
+    &win32u_NtGdiGetOutlineTextMetricsInternalW,
+    &win32u_NtGdiGetPixel,
+    &win32u_NtGdiGetRandomRgn,
+    &win32u_NtGdiGetRasterizerCaps,
+    &win32u_NtGdiGetRealizationInfo,
+    &win32u_NtGdiGetTextCharsetInfo,
+    &win32u_NtGdiGetTextExtentExW,
+    &win32u_NtGdiGetTextFaceW,
+    &win32u_NtGdiGetTextMetricsW,
+    &win32u_NtGdiGradientFill,
+    &win32u_NtGdiIntersectClipRect,
+    &win32u_NtGdiInvertRgn,
+    &win32u_NtGdiLineTo,
+    &win32u_NtGdiMaskBlt,
+    &win32u_NtGdiModifyWorldTransform,
+    &win32u_NtGdiMoveTo,
+    &win32u_NtGdiOffsetClipRgn,
+    &win32u_NtGdiOpenDCW,
+    &win32u_NtGdiPatBlt,
+    &win32u_NtGdiPlgBlt,
+    &win32u_NtGdiPolyDraw,
+    &win32u_NtGdiPolyPolyDraw,
+    &win32u_NtGdiPtVisible,
+    &win32u_NtGdiRectVisible,
+    &win32u_NtGdiRectangle,
+    &win32u_NtGdiResetDC,
+    &win32u_NtGdiResizePalette,
+    &win32u_NtGdiRestoreDC,
+    &win32u_NtGdiRoundRect,
+    &win32u_NtGdiScaleViewportExtEx,
+    &win32u_NtGdiScaleWindowExtEx,
+    &win32u_NtGdiSelectBitmap,
+    &win32u_NtGdiSelectBrush,
+    &win32u_NtGdiSelectClipPath,
+    &win32u_NtGdiSelectFont,
+    &win32u_NtGdiSelectPen,
+    &win32u_NtGdiSetBoundsRect,
+    &win32u_NtGdiSetDIBitsToDeviceInternal,
+    &win32u_NtGdiSetDeviceGammaRamp,
+    &win32u_NtGdiSetLayout,
+    &win32u_NtGdiSetPixel,
+    &win32u_NtGdiSetSystemPaletteUse,
+    &win32u_NtGdiStartDoc,
+    &win32u_NtGdiStartPage,
+    &win32u_NtGdiStretchBlt,
+    &win32u_NtGdiStretchDIBitsInternal,
+    &win32u_NtGdiStrokeAndFillPath,
+    &win32u_NtGdiStrokePath,
+    &win32u_NtGdiTransparentBlt,
+    &win32u_NtGdiUnrealizeObject,
+    &win32u_NtGdiUpdateColors,
+    &win32u_NtGdiWidenPath,
+    &win32u_NtUserDrawCaptionTemp,
+    &win32u_NtUserDrawMenuBarTemp,
+    &win32u_NtUserEndPaint,
+    &win32u_NtUserExcludeUpdateRgn,
+    &win32u_NtUserReleaseDC,
+    &win32u_NtUserScrollDC,
+    &win32u_NtUserSelectPalette,
+    &win32u_NtUserUpdateLayeredWindow,
+    &win32u_SetDIBits,
+    &win32u___wine_get_brush_bitmap_info,
+    &win32u___wine_get_file_outline_text_metric,
+    &win32u___wine_get_icm_profile,
+    &win32u___wine_send_input,
 };

#endif /* _WIN64 */
diff --git a/dlls/win32u/win32u_private.h b/dlls/win32u/win32u_private.h
index 44847829b75..0bcb8b99333 100644
--- a/dlls/win32u/win32u_private.h
+++ b/dlls/win32u/win32u_private.h
@@ -32,182 +32,1214 @@
 #include "wine/debug.h"
 #include "wine/server.h"

-struct unix_funcs
-{
-    /* win32u functions */
-    INT      (WINAPI *pNtGdiAbortDoc)( HDC hdc );
-    BOOL     (WINAPI *pNtGdiAbortPath)( HDC hdc );
-    BOOL     (WINAPI *pNtGdiAlphaBlend)( HDC hdc_dst, int x_dst, int y_dst, int width_dst, int height_dst,
-                                         HDC hdc_src, int x_src, int y_src, int width_src, int height_src,
-                                         BLENDFUNCTION blend_function, HANDLE xform );
-    BOOL     (WINAPI *pNtGdiAngleArc)( HDC hdc, INT x, INT y, DWORD radius, FLOAT start_angle,
-                                       FLOAT sweep_angle );
-    BOOL     (WINAPI *pNtGdiArcInternal)( UINT type, HDC hdc, INT left, INT top, INT right, INT bottom,
-                                          INT xstart, INT ystart, INT xend, INT yend );
-    BOOL     (WINAPI *pNtGdiBeginPath)( HDC hdc );
-    BOOL     (WINAPI *pNtGdiBitBlt)( 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 );
-    BOOL     (WINAPI *pNtGdiCloseFigure)( HDC hdc );
-    BOOL     (WINAPI *pNtGdiComputeXformCoefficients)( HDC hdc );
-    HBITMAP  (WINAPI *pNtGdiCreateCompatibleBitmap)( HDC hdc, INT width, INT height );
-    HDC      (WINAPI *pNtGdiCreateCompatibleDC)( HDC hdc );
-    HBITMAP  (WINAPI *pNtGdiCreateDIBitmapInternal)( 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 );
-    HDC      (WINAPI *pNtGdiCreateMetafileDC)( HDC hdc );
-    NTSTATUS (WINAPI *pNtGdiDdDDICheckVidPnExclusiveOwnership)( const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc );
-    NTSTATUS (WINAPI *pNtGdiDdDDICloseAdapter)( const D3DKMT_CLOSEADAPTER *desc );
-    NTSTATUS (WINAPI *pNtGdiDdDDICreateDCFromMemory)( D3DKMT_CREATEDCFROMMEMORY *desc );
-    NTSTATUS (WINAPI *pNtGdiDdDDIDestroyDCFromMemory)( const D3DKMT_DESTROYDCFROMMEMORY *desc );
-    NTSTATUS (WINAPI *pNtGdiDdDDIDestroyDevice)( const D3DKMT_DESTROYDEVICE *desc );
-    NTSTATUS (WINAPI *pNtGdiDdDDIEscape)( const D3DKMT_ESCAPE *desc );
-    NTSTATUS (WINAPI *pNtGdiDdDDIOpenAdapterFromDeviceName)( D3DKMT_OPENADAPTERFROMDEVICENAME *desc );
-    NTSTATUS (WINAPI *pNtGdiDdDDIOpenAdapterFromLuid)( D3DKMT_OPENADAPTERFROMLUID *desc );
-    NTSTATUS (WINAPI *pNtGdiDdDDIQueryVideoMemoryInfo)( D3DKMT_QUERYVIDEOMEMORYINFO *desc );
-    NTSTATUS (WINAPI *pNtGdiDdDDISetVidPnSourceOwner)( const D3DKMT_SETVIDPNSOURCEOWNER *desc );
-    BOOL     (WINAPI *pNtGdiDeleteObjectApp)( HGDIOBJ obj );
-    LONG     (WINAPI *pNtGdiDoPalette)( HGDIOBJ handle, WORD start, WORD count, void *entries,
-                                        DWORD func, BOOL inbound );
-    BOOL     (WINAPI *pNtGdiEllipse)( HDC hdc, INT left, INT top, INT right, INT bottom );
-    INT      (WINAPI *pNtGdiEndDoc)(HDC hdc);
-    BOOL     (WINAPI *pNtGdiEndPath)( HDC hdc );
-    INT      (WINAPI *pNtGdiEndPage)( HDC hdc );
-    BOOL     (WINAPI *pNtGdiEnumFonts)( HDC hdc, ULONG type, ULONG win32_compat, ULONG face_name_len,
-                                        const WCHAR *face_name, ULONG charset, ULONG *count, void *buf );
-    INT      (WINAPI *pNtGdiExcludeClipRect)( HDC hdc, INT left, INT top, INT right, INT bottom );
-    INT      (WINAPI *pNtGdiExtEscape)( HDC hdc, WCHAR *driver, INT driver_id, INT escape, INT input_size,
-                                        const char *input, INT output_size, char *output );
-    BOOL     (WINAPI *pNtGdiExtFloodFill)( HDC hdc, INT x, INT y, COLORREF color, UINT type );
-    BOOL     (WINAPI *pNtGdiExtTextOutW)( HDC hdc, INT x, INT y, UINT flags, const RECT *rect,
-                                          const WCHAR *str, UINT count, const INT *dx, DWORD cp );
-    INT      (WINAPI *pNtGdiExtSelectClipRgn)( HDC hdc, HRGN region, INT mode );
-    BOOL     (WINAPI *pNtGdiFillPath)( HDC hdc );
-    BOOL     (WINAPI *pNtGdiFillRgn)( HDC hdc, HRGN hrgn, HBRUSH hbrush );
-    BOOL     (WINAPI *pNtGdiFontIsLinked)( HDC hdc );
-    BOOL     (WINAPI *pNtGdiFrameRgn)( HDC hdc, HRGN hrgn, HBRUSH brush, INT width, INT height );
-    BOOL     (WINAPI *pNtGdiGetAndSetDCDword)( HDC hdc, UINT method, DWORD value, DWORD *result );
-    INT      (WINAPI *pNtGdiGetAppClipBox)( HDC hdc, RECT *rect );
-    UINT     (WINAPI *pNtGdiGetBoundsRect)( HDC hdc, RECT *rect, UINT flags );
-    BOOL     (WINAPI *pNtGdiGetCharABCWidthsW)( HDC hdc, UINT first, UINT last, WCHAR *chars,
-                                                ULONG flags, void *buffer );
-    BOOL     (WINAPI *pNtGdiGetCharWidthW)( HDC hdc, UINT first_char, UINT last_char, WCHAR *chars,
-                                            ULONG flags, void *buffer );
-    BOOL     (WINAPI *pNtGdiGetCharWidthInfo)( HDC hdc, struct char_width_info *info );
-    INT      (WINAPI *pNtGdiGetDIBitsInternal)( HDC hdc, HBITMAP hbitmap, UINT startscan, UINT lines,
-                                                void *bits, BITMAPINFO *info, UINT coloruse,
-                                                UINT max_bits, UINT max_info );
-    INT      (WINAPI *pNtGdiGetDeviceCaps)( HDC hdc, INT cap );
-    BOOL     (WINAPI *pNtGdiGetDeviceGammaRamp)( HDC hdc, void *ptr );
-    DWORD    (WINAPI *pNtGdiGetFontData)( HDC hdc, DWORD table, DWORD offset, void *buffer, DWORD length );
-    DWORD    (WINAPI *pNtGdiGetFontUnicodeRanges)( HDC hdc, GLYPHSET *lpgs );
-    DWORD    (WINAPI *pNtGdiGetGlyphIndicesW)( HDC hdc, const WCHAR *str, INT count,
-                                               WORD *indices, DWORD flags );
-    DWORD    (WINAPI *pNtGdiGetGlyphOutline)( HDC hdc, UINT ch, UINT format, GLYPHMETRICS *metrics,
-                                              DWORD size, void *buffer, const MAT2 *mat2,
-                                              BOOL ignore_rotation );
-    DWORD    (WINAPI *pNtGdiGetKerningPairs)( HDC hdc, DWORD count, KERNINGPAIR *kern_pair );
-    COLORREF (WINAPI *pNtGdiGetNearestColor)( HDC hdc, COLORREF color );
-    UINT     (WINAPI *pNtGdiGetOutlineTextMetricsInternalW)( HDC hdc, UINT cbData,
-                                                             OUTLINETEXTMETRICW *otm, ULONG opts );
-    COLORREF (WINAPI *pNtGdiGetPixel)( HDC hdc, INT x, INT y );
-    INT      (WINAPI *pNtGdiGetRandomRgn)( HDC hdc, HRGN region, INT code );
-    BOOL     (WINAPI *pNtGdiGetRasterizerCaps)( RASTERIZER_STATUS *status, UINT size );
-    BOOL     (WINAPI *pNtGdiGetRealizationInfo)( HDC hdc, struct font_realization_info *info );
-    UINT     (WINAPI *pNtGdiGetTextCharsetInfo)( HDC hdc, FONTSIGNATURE *fs, DWORD flags );
-    BOOL     (WINAPI *pNtGdiGetTextExtentExW)( HDC hdc, const WCHAR *str, INT count, INT max_ext,
-                                               INT *nfit, INT *dxs, SIZE *size, UINT flags );
-    INT      (WINAPI *pNtGdiGetTextFaceW)( HDC hdc, INT count, WCHAR *name, BOOL alias_name );
-    BOOL     (WINAPI *pNtGdiGetTextMetricsW)( HDC hdc, TEXTMETRICW *metrics, ULONG flags );
-    BOOL     (WINAPI *pNtGdiGradientFill)( HDC hdc, TRIVERTEX *vert_array, ULONG nvert,
-                                           void *grad_array, ULONG ngrad, ULONG mode );
-    INT      (WINAPI *pNtGdiIntersectClipRect)( HDC hdc, INT left, INT top, INT right, INT bottom );
-    BOOL     (WINAPI *pNtGdiInvertRgn)( HDC hdc, HRGN hrgn );
-    BOOL     (WINAPI *pNtGdiLineTo)( HDC hdc, INT x, INT y );
-    BOOL     (WINAPI *pNtGdiMaskBlt)( HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst,
-                                      HDC hdc_src, INT x_src, INT y_src, HBITMAP mask,
-                                      INT x_mask, INT y_mask, DWORD rop, DWORD bk_color );
-    BOOL     (WINAPI *pNtGdiModifyWorldTransform)( HDC hdc, const XFORM *xform, DWORD mode );
-    BOOL     (WINAPI *pNtGdiMoveTo)( HDC hdc, INT x, INT y, POINT *pt );
-    INT      (WINAPI *pNtGdiOffsetClipRgn)( HDC hdc, INT x, INT y );
-    HDC      (WINAPI *pNtGdiOpenDCW)( UNICODE_STRING *device, const DEVMODEW *devmode,
-                                      UNICODE_STRING *output, ULONG type, BOOL is_display,
-                                      HANDLE hspool, DRIVER_INFO_2W *driver_info, void *pdev );
-    BOOL     (WINAPI *pNtGdiPatBlt)( HDC hdc, INT left, INT top, INT width, INT height, DWORD rop );
-    BOOL     (WINAPI *pNtGdiPlgBlt)( HDC hdc, const POINT *point, HDC hdc_src, INT x_src, INT y_src,
-                                     INT width, INT height, HBITMAP mask, INT x_mask, INT y_mask,
-                                     DWORD bk_color );
-    BOOL     (WINAPI *pNtGdiPolyDraw)(HDC hdc, const POINT *points, const BYTE *types, DWORD count );
-    ULONG    (WINAPI *pNtGdiPolyPolyDraw)( HDC hdc, const POINT *points, const ULONG *counts,
-                                           DWORD count, UINT function );
-    BOOL     (WINAPI *pNtGdiPtVisible)( HDC hdc, INT x, INT y );
-    BOOL     (WINAPI *pNtGdiRectVisible)( HDC hdc, const RECT *rect );
-    BOOL     (WINAPI *pNtGdiRectangle)( HDC hdc, INT left, INT top, INT right, INT bottom );
-    BOOL     (WINAPI *pNtGdiResetDC)( HDC hdc, const DEVMODEW *devmode, BOOL *banding,
-                                      DRIVER_INFO_2W *driver_info, void *dev );
-    BOOL     (WINAPI *pNtGdiResizePalette)( HPALETTE palette, UINT count );
-    BOOL     (WINAPI *pNtGdiRestoreDC)( HDC hdc, INT level );
-    BOOL     (WINAPI *pNtGdiRoundRect)( HDC hdc, INT left, INT top, INT right,
-                                        INT bottom, INT ell_width, INT ell_height );
-    BOOL     (WINAPI *pNtGdiScaleViewportExtEx)( HDC hdc, INT x_num, INT x_denom,
-                                                 INT y_num, INT y_denom, SIZE *size );
-    BOOL     (WINAPI *pNtGdiScaleWindowExtEx)( HDC hdc, INT x_num, INT x_denom,
-                                               INT y_num, INT y_denom, SIZE *size );
-    HGDIOBJ  (WINAPI *pNtGdiSelectBitmap)( HDC hdc, HGDIOBJ handle );
-    HGDIOBJ  (WINAPI *pNtGdiSelectBrush)( HDC hdc, HGDIOBJ handle );
-    BOOL     (WINAPI *pNtGdiSelectClipPath)( HDC hdc, INT mode );
-    HGDIOBJ  (WINAPI *pNtGdiSelectFont)( HDC hdc, HGDIOBJ handle );
-    HGDIOBJ  (WINAPI *pNtGdiSelectPen)( HDC hdc, HGDIOBJ handle );
-    UINT     (WINAPI *pNtGdiSetBoundsRect)( HDC hdc, const RECT *rect, UINT flags );
-    INT      (WINAPI *pNtGdiSetDIBitsToDeviceInternal)( HDC hdc, INT x_dst, INT y_dst, DWORD cx,
-                                                        DWORD cy, INT x_src, INT y_src, UINT startscan,
-                                                        UINT lines, const void *bits, const BITMAPINFO *bmi,
-                                                        UINT coloruse, UINT max_bits, UINT max_info,
-                                                        BOOL xform_coords, HANDLE xform );
-    BOOL     (WINAPI *pNtGdiSetDeviceGammaRamp)( HDC hdc, void *ptr );
-    DWORD    (WINAPI *pNtGdiSetLayout)( HDC hdc, LONG wox, DWORD layout );
-    COLORREF (WINAPI *pNtGdiSetPixel)( HDC hdc, INT x, INT y, COLORREF color );
-    UINT     (WINAPI *pNtGdiSetSystemPaletteUse)( HDC hdc, UINT use );
-    INT      (WINAPI *pNtGdiStartDoc)( HDC hdc, const DOCINFOW *doc, BOOL *banding, INT job );
-    INT      (WINAPI *pNtGdiStartPage)( HDC hdc );
-    BOOL     (WINAPI *pNtGdiStretchBlt)( HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst,
-                                         HDC hdc_src, INT x_src, INT y_src, INT width_src, INT height_src,
-                                         DWORD rop, COLORREF bk_color );
-    INT      (WINAPI *pNtGdiStretchDIBitsInternal)( HDC hdc, INT x_dst, INT y_dst, INT width_dst,
-                                                    INT height_dst, INT x_src, INT y_src, INT width_src,
-                                                    INT height_src, const void *bits, const BITMAPINFO *bmi,
-                                                    UINT coloruse, DWORD rop, UINT max_info, UINT max_bits,
-                                                    HANDLE xform );
-    BOOL     (WINAPI *pNtGdiStrokeAndFillPath)( HDC hdc );
-    BOOL     (WINAPI *pNtGdiStrokePath)( HDC hdc );
-    BOOL     (WINAPI *pNtGdiTransparentBlt)( HDC hdc, int x_dst, int y_dst, int width_dst, int height_dst,
-                                             HDC hdc_src, int x_src, int y_src, int width_src, int height_src,
-                                             UINT color );
-    BOOL     (WINAPI *pNtGdiUnrealizeObject)( HGDIOBJ obj );
-    BOOL     (WINAPI *pNtGdiUpdateColors)( HDC hdc );
-    BOOL     (WINAPI *pNtGdiWidenPath)( HDC hdc );
-    BOOL     (WINAPI *pNtUserDrawCaptionTemp)( HWND hwnd, HDC hdc, const RECT *rect, HFONT font,
-                                               HICON icon, const WCHAR *str, UINT flags );
-    DWORD    (WINAPI *pNtUserDrawMenuBarTemp)( HWND hwnd, HDC hdc, RECT *rect, HMENU handle, HFONT font );
-    BOOL     (WINAPI *pNtUserEndPaint)( HWND hwnd, const PAINTSTRUCT *ps );
-    INT      (WINAPI *pNtUserExcludeUpdateRgn)( HDC hdc, HWND hwnd );
-    INT      (WINAPI *pNtUserReleaseDC)( HWND hwnd, HDC hdc );
-    BOOL     (WINAPI *pNtUserScrollDC)( HDC hdc, INT dx, INT dy, const RECT *scroll, const RECT *clip,
-                                        HRGN ret_update_rgn, RECT *update_rect );
-    HPALETTE (WINAPI *pNtUserSelectPalette)( HDC hdc, HPALETTE hpal, WORD bkg );
-    BOOL     (WINAPI *pNtUserUpdateLayeredWindow)( 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 );
-
-    /* Wine-specific functions */
-    INT (WINAPI *pSetDIBits)( HDC hdc, HBITMAP hbitmap, UINT startscan,
-                              UINT lines, const void *bits, const BITMAPINFO *info,
-                              UINT coloruse );
-    BOOL (CDECL *get_brush_bitmap_info)( HBRUSH handle, BITMAPINFO *info, void *bits, UINT *usage );
-    BOOL (CDECL *get_file_outline_text_metric)( const WCHAR *path, OUTLINETEXTMETRICW *otm );
-    BOOL (CDECL *get_icm_profile)( HDC hdc, BOOL allow_default, DWORD *size, WCHAR *filename );
-    BOOL (CDECL *wine_send_input)( HWND hwnd, const INPUT *input, const RAWINPUT *rawinput );
+enum unix_call
+{
+    unix_init,
+    unix_NtGdiAbortDoc,
+    unix_NtGdiAbortPath,
+    unix_NtGdiAlphaBlend,
+    unix_NtGdiAngleArc,
+    unix_NtGdiArcInternal,
+    unix_NtGdiBeginPath,
+    unix_NtGdiBitBlt,
+    unix_NtGdiCloseFigure,
+    unix_NtGdiComputeXformCoefficients,
+    unix_NtGdiCreateCompatibleBitmap,
+    unix_NtGdiCreateCompatibleDC,
+    unix_NtGdiCreateDIBitmapInternal,
+    unix_NtGdiCreateMetafileDC,
+    unix_NtGdiDdDDICheckVidPnExclusiveOwnership,
+    unix_NtGdiDdDDICloseAdapter,
+    unix_NtGdiDdDDICreateDCFromMemory,
+    unix_NtGdiDdDDIDestroyDCFromMemory,
+    unix_NtGdiDdDDIDestroyDevice,
+    unix_NtGdiDdDDIEscape,
+    unix_NtGdiDdDDIOpenAdapterFromDeviceName,
+    unix_NtGdiDdDDIOpenAdapterFromLuid,
+    unix_NtGdiDdDDIQueryVideoMemoryInfo,
+    unix_NtGdiDdDDISetVidPnSourceOwner,
+    unix_NtGdiDeleteObjectApp,
+    unix_NtGdiDoPalette,
+    unix_NtGdiEllipse,
+    unix_NtGdiEndDoc,
+    unix_NtGdiEndPage,
+    unix_NtGdiEndPath,
+    unix_NtGdiEnumFonts,
+    unix_NtGdiExcludeClipRect,
+    unix_NtGdiExtEscape,
+    unix_NtGdiExtFloodFill,
+    unix_NtGdiExtSelectClipRgn,
+    unix_NtGdiExtTextOutW,
+    unix_NtGdiFillPath,
+    unix_NtGdiFillRgn,
+    unix_NtGdiFontIsLinked,
+    unix_NtGdiFrameRgn,
+    unix_NtGdiGetAndSetDCDword,
+    unix_NtGdiGetAppClipBox,
+    unix_NtGdiGetBoundsRect,
+    unix_NtGdiGetCharABCWidthsW,
+    unix_NtGdiGetCharWidthInfo,
+    unix_NtGdiGetCharWidthW,
+    unix_NtGdiGetDIBitsInternal,
+    unix_NtGdiGetDeviceCaps,
+    unix_NtGdiGetDeviceGammaRamp,
+    unix_NtGdiGetFontData,
+    unix_NtGdiGetFontUnicodeRanges,
+    unix_NtGdiGetGlyphIndicesW,
+    unix_NtGdiGetGlyphOutline,
+    unix_NtGdiGetKerningPairs,
+    unix_NtGdiGetNearestColor,
+    unix_NtGdiGetOutlineTextMetricsInternalW,
+    unix_NtGdiGetPixel,
+    unix_NtGdiGetRandomRgn,
+    unix_NtGdiGetRasterizerCaps,
+    unix_NtGdiGetRealizationInfo,
+    unix_NtGdiGetTextCharsetInfo,
+    unix_NtGdiGetTextExtentExW,
+    unix_NtGdiGetTextFaceW,
+    unix_NtGdiGetTextMetricsW,
+    unix_NtGdiGradientFill,
+    unix_NtGdiIntersectClipRect,
+    unix_NtGdiInvertRgn,
+    unix_NtGdiLineTo,
+    unix_NtGdiMaskBlt,
+    unix_NtGdiModifyWorldTransform,
+    unix_NtGdiMoveTo,
+    unix_NtGdiOffsetClipRgn,
+    unix_NtGdiOpenDCW,
+    unix_NtGdiPatBlt,
+    unix_NtGdiPlgBlt,
+    unix_NtGdiPolyDraw,
+    unix_NtGdiPolyPolyDraw,
+    unix_NtGdiPtVisible,
+    unix_NtGdiRectVisible,
+    unix_NtGdiRectangle,
+    unix_NtGdiResetDC,
+    unix_NtGdiResizePalette,
+    unix_NtGdiRestoreDC,
+    unix_NtGdiRoundRect,
+    unix_NtGdiScaleViewportExtEx,
+    unix_NtGdiScaleWindowExtEx,
+    unix_NtGdiSelectBitmap,
+    unix_NtGdiSelectBrush,
+    unix_NtGdiSelectClipPath,
+    unix_NtGdiSelectFont,
+    unix_NtGdiSelectPen,
+    unix_NtGdiSetBoundsRect,
+    unix_NtGdiSetDIBitsToDeviceInternal,
+    unix_NtGdiSetDeviceGammaRamp,
+    unix_NtGdiSetLayout,
+    unix_NtGdiSetPixel,
+    unix_NtGdiSetSystemPaletteUse,
+    unix_NtGdiStartDoc,
+    unix_NtGdiStartPage,
+    unix_NtGdiStretchBlt,
+    unix_NtGdiStretchDIBitsInternal,
+    unix_NtGdiStrokeAndFillPath,
+    unix_NtGdiStrokePath,
+    unix_NtGdiTransparentBlt,
+    unix_NtGdiUnrealizeObject,
+    unix_NtGdiUpdateColors,
+    unix_NtGdiWidenPath,
+    unix_NtUserDrawCaptionTemp,
+    unix_NtUserDrawMenuBarTemp,
+    unix_NtUserEndPaint,
+    unix_NtUserExcludeUpdateRgn,
+    unix_NtUserReleaseDC,
+    unix_NtUserScrollDC,
+    unix_NtUserSelectPalette,
+    unix_NtUserUpdateLayeredWindow,
+    unix_SetDIBits,
+    unix___wine_get_brush_bitmap_info,
+    unix___wine_get_file_outline_text_metric,
+    unix___wine_get_icm_profile,
+    unix___wine_send_input,
+    unix_count,
+};
+
+#ifdef __i386__
+#define MS_STRUCT __attribute__((ms_struct))
+#else
+#define MS_STRUCT
+#endif
+
+struct MS_STRUCT NtGdiAbortDoc_params
+{
+    HDC hdc;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiAbortPath_params
+{
+    HDC hdc;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiAlphaBlend_params
+{
+    HDC hdc_dst;
+    int x_dst;
+    int y_dst;
+    int width_dst;
+    int height_dst;
+    HDC hdc_src;
+    int x_src;
+    int y_src;
+    int width_src;
+    int height_src;
+    BLENDFUNCTION blend_function;
+    HANDLE xform;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiAngleArc_params
+{
+    HDC hdc;
+    INT x;
+    INT y;
+    DWORD radius;
+    FLOAT start_angle;
+    FLOAT sweep_angle;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiArcInternal_params
+{
+    UINT type;
+    HDC hdc;
+    INT left;
+    INT top;
+    INT right;
+    INT bottom;
+    INT xstart;
+    INT ystart;
+    INT xend;
+    INT yend;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiBeginPath_params
+{
+    HDC hdc;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiBitBlt_params
+{
+    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;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiCloseFigure_params
+{
+    HDC hdc;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiComputeXformCoefficients_params
+{
+    HDC hdc;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiCreateCompatibleBitmap_params
+{
+    HDC hdc;
+    INT width;
+    INT height;
+    HBITMAP $result;
+};
+
+struct MS_STRUCT NtGdiCreateCompatibleDC_params
+{
+    HDC hdc;
+    HDC $result;
+};
+
+struct MS_STRUCT NtGdiCreateDIBitmapInternal_params
+{
+    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;
+    HBITMAP $result;
+};
+
+struct MS_STRUCT NtGdiCreateMetafileDC_params
+{
+    HDC hdc;
+    HDC $result;
+};
+
+struct MS_STRUCT NtGdiDdDDICheckVidPnExclusiveOwnership_params
+{
+    const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc;
+    NTSTATUS $result;
+};
+
+struct MS_STRUCT NtGdiDdDDICloseAdapter_params
+{
+    const D3DKMT_CLOSEADAPTER *desc;
+    NTSTATUS $result;
+};
+
+struct MS_STRUCT NtGdiDdDDICreateDCFromMemory_params
+{
+    D3DKMT_CREATEDCFROMMEMORY *desc;
+    NTSTATUS $result;
+};
+
+struct MS_STRUCT NtGdiDdDDIDestroyDCFromMemory_params
+{
+    const D3DKMT_DESTROYDCFROMMEMORY *desc;
+    NTSTATUS $result;
+};
+
+struct MS_STRUCT NtGdiDdDDIDestroyDevice_params
+{
+    const D3DKMT_DESTROYDEVICE *desc;
+    NTSTATUS $result;
+};
+
+struct MS_STRUCT NtGdiDdDDIEscape_params
+{
+    const D3DKMT_ESCAPE *desc;
+    NTSTATUS $result;
+};
+
+struct MS_STRUCT NtGdiDdDDIOpenAdapterFromDeviceName_params
+{
+    D3DKMT_OPENADAPTERFROMDEVICENAME *desc;
+    NTSTATUS $result;
+};
+
+struct MS_STRUCT NtGdiDdDDIOpenAdapterFromLuid_params
+{
+    D3DKMT_OPENADAPTERFROMLUID *desc;
+    NTSTATUS $result;
+};
+
+struct MS_STRUCT NtGdiDdDDIQueryVideoMemoryInfo_params
+{
+    D3DKMT_QUERYVIDEOMEMORYINFO *desc;
+    NTSTATUS $result;
+};
+
+struct MS_STRUCT NtGdiDdDDISetVidPnSourceOwner_params
+{
+    const D3DKMT_SETVIDPNSOURCEOWNER *desc;
+    NTSTATUS $result;
+};
+
+struct MS_STRUCT NtGdiDeleteObjectApp_params
+{
+    HGDIOBJ obj;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiDoPalette_params
+{
+    HGDIOBJ handle;
+    WORD start;
+    WORD count;
+    void *entries;
+    DWORD func;
+    BOOL inbound;
+    LONG $result;
+};
+
+struct MS_STRUCT NtGdiEllipse_params
+{
+    HDC hdc;
+    INT left;
+    INT top;
+    INT right;
+    INT bottom;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiEndDoc_params
+{
+    HDC hdc;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiEndPath_params
+{
+    HDC hdc;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiEndPage_params
+{
+    HDC hdc;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiEnumFonts_params
+{
+    HDC hdc;
+    ULONG type;
+    ULONG win32_compat;
+    ULONG face_name_len;
+    const WCHAR *face_name;
+    ULONG charset;
+    ULONG *count;
+    void *buf;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiExcludeClipRect_params
+{
+    HDC hdc;
+    INT left;
+    INT top;
+    INT right;
+    INT bottom;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiExtEscape_params
+{
+    HDC hdc;
+    WCHAR *driver;
+    INT driver_id;
+    INT escape;
+    INT input_size;
+    const char *input;
+    INT output_size;
+    char *output;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiExtFloodFill_params
+{
+    HDC hdc;
+    INT x;
+    INT y;
+    COLORREF color;
+    UINT type;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiExtTextOutW_params
+{
+    HDC hdc;
+    INT x;
+    INT y;
+    UINT flags;
+    const RECT *rect;
+    const WCHAR *str;
+    UINT count;
+    const INT *dx;
+    DWORD cp;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiExtSelectClipRgn_params
+{
+    HDC hdc;
+    HRGN region;
+    INT mode;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiFillPath_params
+{
+    HDC hdc;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiFillRgn_params
+{
+    HDC hdc;
+    HRGN hrgn;
+    HBRUSH hbrush;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiFontIsLinked_params
+{
+    HDC hdc;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiFrameRgn_params
+{
+    HDC hdc;
+    HRGN hrgn;
+    HBRUSH brush;
+    INT width;
+    INT height;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiGetAndSetDCDword_params
+{
+    HDC hdc;
+    UINT method;
+    DWORD value;
+    DWORD *result;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiGetAppClipBox_params
+{
+    HDC hdc;
+    RECT *rect;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiGetBoundsRect_params
+{
+    HDC hdc;
+    RECT *rect;
+    UINT flags;
+    UINT $result;
+};
+
+struct MS_STRUCT NtGdiGetCharABCWidthsW_params
+{
+    HDC hdc;
+    UINT first;
+    UINT last;
+    WCHAR *chars;
+    ULONG flags;
+    void *buffer;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiGetCharWidthW_params
+{
+    HDC hdc;
+    UINT first_char;
+    UINT last_char;
+    WCHAR *chars;
+    ULONG flags;
+    void *buffer;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiGetCharWidthInfo_params
+{
+    HDC hdc;
+    struct char_width_info *info;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiGetDIBitsInternal_params
+{
+    HDC hdc;
+    HBITMAP hbitmap;
+    UINT startscan;
+    UINT lines;
+    void *bits;
+    BITMAPINFO *info;
+    UINT coloruse;
+    UINT max_bits;
+    UINT max_info;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiGetDeviceCaps_params
+{
+    HDC hdc;
+    INT cap;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiGetDeviceGammaRamp_params
+{
+    HDC hdc;
+    void *ptr;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiGetFontData_params
+{
+    HDC hdc;
+    DWORD table;
+    DWORD offset;
+    void *buffer;
+    DWORD length;
+    DWORD $result;
+};
+
+struct MS_STRUCT NtGdiGetFontUnicodeRanges_params
+{
+    HDC hdc;
+    GLYPHSET *lpgs;
+    DWORD $result;
+};
+
+struct MS_STRUCT NtGdiGetGlyphIndicesW_params
+{
+    HDC hdc;
+    const WCHAR *str;
+    INT count;
+    WORD *indices;
+    DWORD flags;
+    DWORD $result;
+};
+
+struct MS_STRUCT NtGdiGetGlyphOutline_params
+{
+    HDC hdc;
+    UINT ch;
+    UINT format;
+    GLYPHMETRICS *metrics;
+    DWORD size;
+    void *buffer;
+    const MAT2 *mat2;
+    BOOL ignore_rotation;
+    DWORD $result;
+};
+
+struct MS_STRUCT NtGdiGetKerningPairs_params
+{
+    HDC hdc;
+    DWORD count;
+    KERNINGPAIR *kern_pair;
+    DWORD $result;
+};
+
+struct MS_STRUCT NtGdiGetNearestColor_params
+{
+    HDC hdc;
+    COLORREF color;
+    COLORREF $result;
+};
+
+struct MS_STRUCT NtGdiGetOutlineTextMetricsInternalW_params
+{
+    HDC hdc;
+    UINT cbData;
+    OUTLINETEXTMETRICW *otm;
+    ULONG opts;
+    UINT $result;
+};
+
+struct MS_STRUCT NtGdiGetPixel_params
+{
+    HDC hdc;
+    INT x;
+    INT y;
+    COLORREF $result;
+};
+
+struct MS_STRUCT NtGdiGetRandomRgn_params
+{
+    HDC hdc;
+    HRGN region;
+    INT code;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiGetRasterizerCaps_params
+{
+    RASTERIZER_STATUS *status;
+    UINT size;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiGetRealizationInfo_params
+{
+    HDC hdc;
+    struct font_realization_info *info;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiGetTextCharsetInfo_params
+{
+    HDC hdc;
+    FONTSIGNATURE *fs;
+    DWORD flags;
+    UINT $result;
+};
+
+struct MS_STRUCT NtGdiGetTextExtentExW_params
+{
+    HDC hdc;
+    const WCHAR *str;
+    INT count;
+    INT max_ext;
+    INT *nfit;
+    INT *dxs;
+    SIZE *size;
+    UINT flags;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiGetTextFaceW_params
+{
+    HDC hdc;
+    INT count;
+    WCHAR *name;
+    BOOL alias_name;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiGetTextMetricsW_params
+{
+    HDC hdc;
+    TEXTMETRICW *metrics;
+    ULONG flags;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiGradientFill_params
+{
+    HDC hdc;
+    TRIVERTEX *vert_array;
+    ULONG nvert;
+    void *grad_array;
+    ULONG ngrad;
+    ULONG mode;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiIntersectClipRect_params
+{
+    HDC hdc;
+    INT left;
+    INT top;
+    INT right;
+    INT bottom;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiInvertRgn_params
+{
+    HDC hdc;
+    HRGN hrgn;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiLineTo_params
+{
+    HDC hdc;
+    INT x;
+    INT y;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiMaskBlt_params
+{
+    HDC hdc;
+    INT x_dst;
+    INT y_dst;
+    INT width_dst;
+    INT height_dst;
+    HDC hdc_src;
+    INT x_src;
+    INT y_src;
+    HBITMAP mask;
+    INT x_mask;
+    INT y_mask;
+    DWORD rop;
+    DWORD bk_color;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiModifyWorldTransform_params
+{
+    HDC hdc;
+    const XFORM *xform;
+    DWORD mode;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiMoveTo_params
+{
+    HDC hdc;
+    INT x;
+    INT y;
+    POINT *pt;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiOffsetClipRgn_params
+{
+    HDC hdc;
+    INT x;
+    INT y;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiOpenDCW_params
+{
+    UNICODE_STRING *device;
+    const DEVMODEW *devmode;
+    UNICODE_STRING *output;
+    ULONG type;
+    BOOL is_display;
+    HANDLE hspool;
+    DRIVER_INFO_2W *driver_info;
+    void *pdev;
+    HDC $result;
+};
+
+struct MS_STRUCT NtGdiPatBlt_params
+{
+    HDC hdc;
+    INT left;
+    INT top;
+    INT width;
+    INT height;
+    DWORD rop;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiPlgBlt_params
+{
+    HDC hdc;
+    const POINT *point;
+    HDC hdc_src;
+    INT x_src;
+    INT y_src;
+    INT width;
+    INT height;
+    HBITMAP mask;
+    INT x_mask;
+    INT y_mask;
+    DWORD bk_color;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiPolyDraw_params
+{
+    HDC hdc;
+    const POINT *points;
+    const BYTE *types;
+    DWORD count;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiPolyPolyDraw_params
+{
+    HDC hdc;
+    const POINT *points;
+    const ULONG *counts;
+    DWORD count;
+    UINT function;
+    ULONG $result;
+};
+
+struct MS_STRUCT NtGdiPtVisible_params
+{
+    HDC hdc;
+    INT x;
+    INT y;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiRectVisible_params
+{
+    HDC hdc;
+    const RECT *rect;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiRectangle_params
+{
+    HDC hdc;
+    INT left;
+    INT top;
+    INT right;
+    INT bottom;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiResetDC_params
+{
+    HDC hdc;
+    const DEVMODEW *devmode;
+    BOOL *banding;
+    DRIVER_INFO_2W *driver_info;
+    void *dev;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiResizePalette_params
+{
+    HPALETTE palette;
+    UINT count;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiRestoreDC_params
+{
+    HDC hdc;
+    INT level;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiRoundRect_params
+{
+    HDC hdc;
+    INT left;
+    INT top;
+    INT right;
+    INT bottom;
+    INT ell_width;
+    INT ell_height;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiScaleViewportExtEx_params
+{
+    HDC hdc;
+    INT x_num;
+    INT x_denom;
+    INT y_num;
+    INT y_denom;
+    SIZE *size;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiScaleWindowExtEx_params
+{
+    HDC hdc;
+    INT x_num;
+    INT x_denom;
+    INT y_num;
+    INT y_denom;
+    SIZE *size;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiSelectBitmap_params
+{
+    HDC hdc;
+    HGDIOBJ handle;
+    HGDIOBJ $result;
+};
+
+struct MS_STRUCT NtGdiSelectBrush_params
+{
+    HDC hdc;
+    HGDIOBJ handle;
+    HGDIOBJ $result;
+};
+
+struct MS_STRUCT NtGdiSelectClipPath_params
+{
+    HDC hdc;
+    INT mode;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiSelectFont_params
+{
+    HDC hdc;
+    HGDIOBJ handle;
+    HGDIOBJ $result;
+};
+
+struct MS_STRUCT NtGdiSelectPen_params
+{
+    HDC hdc;
+    HGDIOBJ handle;
+    HGDIOBJ $result;
+};
+
+struct MS_STRUCT NtGdiSetBoundsRect_params
+{
+    HDC hdc;
+    const RECT *rect;
+    UINT flags;
+    UINT $result;
+};
+
+struct MS_STRUCT NtGdiSetDIBitsToDeviceInternal_params
+{
+    HDC hdc;
+    INT x_dst;
+    INT y_dst;
+    DWORD cx;
+    DWORD cy;
+    INT x_src;
+    INT y_src;
+    UINT startscan;
+    UINT lines;
+    const void *bits;
+    const BITMAPINFO *bmi;
+    UINT coloruse;
+    UINT max_bits;
+    UINT max_info;
+    BOOL xform_coords;
+    HANDLE xform;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiSetDeviceGammaRamp_params
+{
+    HDC hdc;
+    void *ptr;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiSetLayout_params
+{
+    HDC hdc;
+    LONG wox;
+    DWORD layout;
+    DWORD $result;
+};
+
+struct MS_STRUCT NtGdiSetPixel_params
+{
+    HDC hdc;
+    INT x;
+    INT y;
+    COLORREF color;
+    COLORREF $result;
+};
+
+struct MS_STRUCT NtGdiSetSystemPaletteUse_params
+{
+    HDC hdc;
+    UINT use;
+    UINT $result;
+};
+
+struct MS_STRUCT NtGdiStartDoc_params
+{
+    HDC hdc;
+    const DOCINFOW *doc;
+    BOOL *banding;
+    INT job;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiStartPage_params
+{
+    HDC hdc;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiStretchBlt_params
+{
+    HDC hdc;
+    INT x_dst;
+    INT y_dst;
+    INT width_dst;
+    INT height_dst;
+    HDC hdc_src;
+    INT x_src;
+    INT y_src;
+    INT width_src;
+    INT height_src;
+    DWORD rop;
+    COLORREF bk_color;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiStretchDIBitsInternal_params
+{
+    HDC hdc;
+    INT x_dst;
+    INT y_dst;
+    INT width_dst;
+    INT height_dst;
+    INT x_src;
+    INT y_src;
+    INT width_src;
+    INT height_src;
+    const void *bits;
+    const BITMAPINFO *bmi;
+    UINT coloruse;
+    DWORD rop;
+    UINT max_info;
+    UINT max_bits;
+    HANDLE xform;
+    INT $result;
+};
+
+struct MS_STRUCT NtGdiStrokeAndFillPath_params
+{
+    HDC hdc;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiStrokePath_params
+{
+    HDC hdc;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiTransparentBlt_params
+{
+    HDC hdc;
+    int x_dst;
+    int y_dst;
+    int width_dst;
+    int height_dst;
+    HDC hdc_src;
+    int x_src;
+    int y_src;
+    int width_src;
+    int height_src;
+    UINT color;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiUnrealizeObject_params
+{
+    HGDIOBJ obj;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiUpdateColors_params
+{
+    HDC hdc;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtGdiWidenPath_params
+{
+    HDC hdc;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtUserDrawCaptionTemp_params
+{
+    HWND hwnd;
+    HDC hdc;
+    const RECT *rect;
+    HFONT font;
+    HICON icon;
+    const WCHAR *str;
+    UINT flags;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtUserDrawMenuBarTemp_params
+{
+    HWND hwnd;
+    HDC hdc;
+    RECT *rect;
+    HMENU handle;
+    HFONT font;
+    DWORD $result;
+};
+
+struct MS_STRUCT NtUserEndPaint_params
+{
+    HWND hwnd;
+    const PAINTSTRUCT *ps;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtUserExcludeUpdateRgn_params
+{
+    HDC hdc;
+    HWND hwnd;
+    INT $result;
+};
+
+struct MS_STRUCT NtUserReleaseDC_params
+{
+    HWND hwnd;
+    HDC hdc;
+    INT $result;
+};
+
+struct MS_STRUCT NtUserScrollDC_params
+{
+    HDC hdc;
+    INT dx;
+    INT dy;
+    const RECT *scroll;
+    const RECT *clip;
+    HRGN ret_update_rgn;
+    RECT *update_rect;
+    BOOL $result;
+};
+
+struct MS_STRUCT NtUserSelectPalette_params
+{
+    HDC hdc;
+    HPALETTE hpal;
+    WORD bkg;
+    HPALETTE $result;
+};
+
+struct MS_STRUCT NtUserUpdateLayeredWindow_params
+{
+    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;
+    BOOL $result;
+};
+
+struct MS_STRUCT SetDIBits_params
+{
+    HDC hdc;
+    HBITMAP hbitmap;
+    UINT startscan;
+    UINT lines;
+    const void *bits;
+    const BITMAPINFO *info;
+    UINT coloruse;
+    INT $result;
+};
+
+struct MS_STRUCT __wine_get_brush_bitmap_info_params
+{
+    HBRUSH handle;
+    BITMAPINFO *info;
+    void *bits;
+    UINT *usage;
+    BOOL $result;
+};
+
+struct MS_STRUCT __wine_get_file_outline_text_metric_params
+{
+    const WCHAR *path;
+    OUTLINETEXTMETRICW *otm;
+    BOOL $result;
+};
+
+struct MS_STRUCT __wine_get_icm_profile_params
+{
+    HDC hdc;
+    BOOL allow_default;
+    DWORD *size;
+    WCHAR *filename;
+    BOOL $result;
+};
+
+struct MS_STRUCT __wine_send_input_params
+{
+    HWND hwnd;
+    const INPUT *input;
+    const RAWINPUT *rawinput;
+    BOOL $result;
 };

/* clipboard.c */
@@ -416,7 +1448,6 @@ static inline void release_win_ptr( struct tagWND *ptr )
     user_unlock();
 }

-extern void wrappers_init( unixlib_handle_t handle ) DECLSPEC_HIDDEN;
 extern void gdi_init(void) DECLSPEC_HIDDEN;
 extern NTSTATUS callbacks_init( void *args ) DECLSPEC_HIDDEN;
 extern void winstation_init(void) DECLSPEC_HIDDEN;
diff --git a/dlls/win32u/wrappers.c b/dlls/win32u/wrappers.c
index e128705ef37..f035c19ba01 100644
--- a/dlls/win32u/wrappers.c
+++ b/dlls/win32u/wrappers.c
@@ -22,790 +22,368 @@
 #define WIN32_NO_STATUS
 #include "win32u_private.h"

-static const struct unix_funcs *unix_funcs;
+#define WIN32U_CALL(name, ...)                      \
+{                                                   \
+    struct name ##_params params = { __VA_ARGS__ }; \
+    WINE_UNIX_CALL(unix_##name, &params);           \
+    return params.$result;                          \
+}

INT WINAPI NtGdiAbortDoc( HDC hdc )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiAbortDoc( hdc );
-}
+WIN32U_CALL(NtGdiAbortDoc, hdc)

BOOL WINAPI NtGdiAbortPath( HDC hdc )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiAbortPath( hdc );
-}
+WIN32U_CALL(NtGdiAbortPath, hdc)

-BOOL WINAPI NtGdiAlphaBlend( HDC hdc_dst, int x_dst, int y_dst, int width_dst, int height_dst,
-                             HDC hdc_src, int x_src, int y_src, int width_src, int height_src,
-                             BLENDFUNCTION blend_function, HANDLE xform )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiAlphaBlend( hdc_dst, x_dst, y_dst, width_dst, height_dst, hdc_src,
-                                         x_src, y_src, width_src, height_src, blend_function, xform );
-}
+BOOL WINAPI NtGdiAlphaBlend( HDC hdc_dst, int x_dst, int y_dst, int width_dst, int height_dst, HDC hdc_src, int x_src, int y_src, int width_src, int height_src, BLENDFUNCTION blend_function, HANDLE xform )
+WIN32U_CALL(NtGdiAlphaBlend, hdc_dst, x_dst, y_dst, width_dst, height_dst, hdc_src, x_src, y_src, width_src, height_src, blend_function, xform)

BOOL WINAPI NtGdiAngleArc( HDC hdc, INT x, INT y, DWORD radius, FLOAT start_angle, FLOAT sweep_angle )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiAngleArc( hdc, x, y, radius, start_angle, sweep_angle );
-}
+WIN32U_CALL(NtGdiAngleArc, hdc, x, y, radius, start_angle, sweep_angle)

-BOOL WINAPI NtGdiArcInternal( UINT type, HDC hdc, INT left, INT top, INT right, INT bottom,
-                              INT xstart, INT ystart, INT xend, INT yend )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiArcInternal( type, hdc, left, top, right, bottom, xstart, ystart, xend, yend );
-}
+BOOL WINAPI NtGdiArcInternal( UINT type, HDC hdc, INT left, INT top, INT right, INT bottom, INT xstart, INT ystart, INT xend, INT yend )
+WIN32U_CALL(NtGdiArcInternal, type, hdc, left, top, right, bottom, xstart, ystart, xend, yend)

BOOL WINAPI NtGdiBeginPath( HDC hdc )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiBeginPath( hdc );
-}
+WIN32U_CALL(NtGdiBeginPath, hdc)

-BOOL WINAPI 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 )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiBitBlt( hdc_dst, x_dst, y_dst, width, height, hdc_src, x_src, y_src,
-                                     rop, bk_color, fl );
-}
+BOOL WINAPI 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 )
+WIN32U_CALL(NtGdiBitBlt, hdc_dst, x_dst, y_dst, width, height, hdc_src, x_src, y_src, rop, bk_color, fl)

BOOL WINAPI NtGdiCloseFigure( HDC hdc )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiCloseFigure( hdc );
-}
+WIN32U_CALL(NtGdiCloseFigure, hdc)

BOOL WINAPI NtGdiComputeXformCoefficients( HDC hdc )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiComputeXformCoefficients( hdc );
-}
+WIN32U_CALL(NtGdiComputeXformCoefficients, hdc)

HBITMAP WINAPI NtGdiCreateCompatibleBitmap( HDC hdc, INT width, INT height )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiCreateCompatibleBitmap( hdc, width, height );
-}
+WIN32U_CALL(NtGdiCreateCompatibleBitmap, hdc, width, height)

HDC WINAPI NtGdiCreateCompatibleDC( HDC hdc )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiCreateCompatibleDC( hdc );
-}
+WIN32U_CALL(NtGdiCreateCompatibleDC, hdc)

-HBITMAP WINAPI 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 )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiCreateDIBitmapInternal( hdc, width, height, init, bits, data,
-                                                     coloruse, max_info, max_bits, flags, xform );
-}
+HBITMAP WINAPI 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 )
+WIN32U_CALL(NtGdiCreateDIBitmapInternal, hdc, width, height, init, bits, data, coloruse, max_info, max_bits, flags, xform)

HDC WINAPI NtGdiCreateMetafileDC( HDC hdc )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiCreateMetafileDC( hdc );
-}
+WIN32U_CALL(NtGdiCreateMetafileDC, hdc)
+
+NTSTATUS WINAPI NtGdiDdDDICheckVidPnExclusiveOwnership( const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc )
+WIN32U_CALL(NtGdiDdDDICheckVidPnExclusiveOwnership, desc)
+
+NTSTATUS WINAPI NtGdiDdDDICloseAdapter( const D3DKMT_CLOSEADAPTER *desc )
+WIN32U_CALL(NtGdiDdDDICloseAdapter, desc)
+
+NTSTATUS WINAPI NtGdiDdDDICreateDCFromMemory( D3DKMT_CREATEDCFROMMEMORY *desc )
+WIN32U_CALL(NtGdiDdDDICreateDCFromMemory, desc)
+
+NTSTATUS WINAPI NtGdiDdDDIDestroyDCFromMemory( const D3DKMT_DESTROYDCFROMMEMORY *desc )
+WIN32U_CALL(NtGdiDdDDIDestroyDCFromMemory, desc)
+
+NTSTATUS WINAPI NtGdiDdDDIDestroyDevice( const D3DKMT_DESTROYDEVICE *desc )
+WIN32U_CALL(NtGdiDdDDIDestroyDevice, desc)
+
+NTSTATUS WINAPI NtGdiDdDDIEscape( const D3DKMT_ESCAPE *desc )
+WIN32U_CALL(NtGdiDdDDIEscape, desc)
+
+NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromDeviceName( D3DKMT_OPENADAPTERFROMDEVICENAME *desc )
+WIN32U_CALL(NtGdiDdDDIOpenAdapterFromDeviceName, desc)
+
+NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc )
+WIN32U_CALL(NtGdiDdDDIOpenAdapterFromLuid, desc)
+
+NTSTATUS WINAPI NtGdiDdDDIQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *desc )
+WIN32U_CALL(NtGdiDdDDIQueryVideoMemoryInfo, desc)
+
+NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER *desc )
+WIN32U_CALL(NtGdiDdDDISetVidPnSourceOwner, desc)

BOOL WINAPI NtGdiDeleteObjectApp( HGDIOBJ obj )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiDeleteObjectApp( obj );
-}
+WIN32U_CALL(NtGdiDeleteObjectApp, obj)

-LONG WINAPI NtGdiDoPalette( HGDIOBJ handle, WORD start, WORD count, void *entries,
-                            DWORD func, BOOL inbound )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiDoPalette( handle, start, count, entries, func, inbound );
-}
+LONG WINAPI NtGdiDoPalette( HGDIOBJ handle, WORD start, WORD count, void *entries, DWORD func, BOOL inbound )
+WIN32U_CALL(NtGdiDoPalette, handle, start, count, entries, func, inbound)

BOOL WINAPI NtGdiEllipse( HDC hdc, INT left, INT top, INT right, INT bottom )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiEllipse( hdc, left, top, right, bottom );
-}
+WIN32U_CALL(NtGdiEllipse, hdc, left, top, right, bottom)

-INT WINAPI NtGdiEndDoc( HDC hdc )
-{
-    if (!unix_funcs) return SP_ERROR;
-    return unix_funcs->pNtGdiEndDoc( hdc );
-}
+INT WINAPI NtGdiEndDoc(HDC hdc)
+WIN32U_CALL(NtGdiEndDoc, hdc)

BOOL WINAPI NtGdiEndPath( HDC hdc )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiEndPath( hdc );
-}
+WIN32U_CALL(NtGdiEndPath, hdc)

INT WINAPI NtGdiEndPage( HDC hdc )
-{
-    if (!unix_funcs) return SP_ERROR;
-    return unix_funcs->pNtGdiEndPage( hdc );
-}
+WIN32U_CALL(NtGdiEndPage, hdc)

-BOOL WINAPI NtUserEndPaint( HWND hwnd, const PAINTSTRUCT *ps )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtUserEndPaint( hwnd, ps );
-}
-
-BOOL WINAPI NtGdiEnumFonts( HDC hdc, ULONG type, ULONG win32_compat, ULONG face_name_len,
-                            const WCHAR *face_name, ULONG charset, ULONG *count, void *buf )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiEnumFonts( hdc, type, win32_compat, face_name_len, face_name,
-                                        charset, count, buf );
-}
+BOOL WINAPI NtGdiEnumFonts( HDC hdc, ULONG type, ULONG win32_compat, ULONG face_name_len, const WCHAR *face_name, ULONG charset, ULONG *count, void *buf )
+WIN32U_CALL(NtGdiEnumFonts, hdc, type, win32_compat, face_name_len, face_name, charset, count, buf)

INT WINAPI NtGdiExcludeClipRect( HDC hdc, INT left, INT top, INT right, INT bottom )
-{
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtGdiExcludeClipRect( hdc, left, top, right, bottom );
-}
+WIN32U_CALL(NtGdiExcludeClipRect, hdc, left, top, right, bottom)

-INT WINAPI NtGdiExtEscape( HDC hdc, WCHAR *driver, INT driver_id, INT escape, INT input_size,
-                           const char *input, INT output_size, char *output )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiExtEscape( hdc, driver, driver_id, escape, input_size, input,
-                                        output_size, output );
-}
+INT WINAPI NtGdiExtEscape( HDC hdc, WCHAR *driver, INT driver_id, INT escape, INT input_size, const char *input, INT output_size, char *output )
+WIN32U_CALL(NtGdiExtEscape, hdc, driver, driver_id, escape, input_size, input, output_size, output)

BOOL WINAPI NtGdiExtFloodFill( HDC hdc, INT x, INT y, COLORREF color, UINT type )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiExtFloodFill( hdc, x, y, color, type );
-}
+WIN32U_CALL(NtGdiExtFloodFill, hdc, x, y, color, type)

-BOOL WINAPI NtGdiExtTextOutW( HDC hdc, INT x, INT y, UINT flags, const RECT *rect,
-                              const WCHAR *str, UINT count, const INT *dx, DWORD cp )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiExtTextOutW( hdc, x, y, flags, rect, str, count, dx, cp );
-}
+BOOL WINAPI NtGdiExtTextOutW( HDC hdc, INT x, INT y, UINT flags, const RECT *rect, const WCHAR *str, UINT count, const INT *dx, DWORD cp )
+WIN32U_CALL(NtGdiExtTextOutW, hdc, x, y, flags, rect, str, count, dx, cp)

INT WINAPI NtGdiExtSelectClipRgn( HDC hdc, HRGN region, INT mode )
-{
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtGdiExtSelectClipRgn( hdc, region, mode );
-}
+WIN32U_CALL(NtGdiExtSelectClipRgn, hdc, region, mode)

BOOL WINAPI NtGdiFillPath( HDC hdc )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiFillPath( hdc );
-}
+WIN32U_CALL(NtGdiFillPath, hdc)

BOOL WINAPI NtGdiFillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiFillRgn( hdc, hrgn, hbrush );
-}
+WIN32U_CALL(NtGdiFillRgn, hdc, hrgn, hbrush)

BOOL WINAPI NtGdiFontIsLinked( HDC hdc )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiFontIsLinked( hdc );
-}
+WIN32U_CALL(NtGdiFontIsLinked, hdc)

BOOL WINAPI NtGdiFrameRgn( HDC hdc, HRGN hrgn, HBRUSH brush, INT width, INT height )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiFrameRgn( hdc, hrgn, brush, width, height );
-}
+WIN32U_CALL(NtGdiFrameRgn, hdc, hrgn, brush, width, height)

BOOL WINAPI NtGdiGetAndSetDCDword( HDC hdc, UINT method, DWORD value, DWORD *result )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetAndSetDCDword( hdc, method, value, result );
-}
+WIN32U_CALL(NtGdiGetAndSetDCDword, hdc, method, value, result)

INT WINAPI NtGdiGetAppClipBox( HDC hdc, RECT *rect )
-{
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtGdiGetAppClipBox( hdc, rect );
-}
+WIN32U_CALL(NtGdiGetAppClipBox, hdc, rect)

UINT WINAPI NtGdiGetBoundsRect( HDC hdc, RECT *rect, UINT flags )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetBoundsRect( hdc, rect, flags );
-}
+WIN32U_CALL(NtGdiGetBoundsRect, hdc, rect, flags)

-BOOL WINAPI NtGdiGetCharABCWidthsW( HDC hdc, UINT first, UINT last, WCHAR *chars,
-                                    ULONG flags, void *buffer )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetCharABCWidthsW( hdc, first, last, chars, flags, buffer );
-}
+BOOL WINAPI NtGdiGetCharABCWidthsW( HDC hdc, UINT first, UINT last, WCHAR *chars, ULONG flags, void *buffer )
+WIN32U_CALL(NtGdiGetCharABCWidthsW, hdc, first, last, chars, flags, buffer)

-BOOL WINAPI NtGdiGetCharWidthW( HDC hdc, UINT first_char, UINT last_char, WCHAR *chars,
-                                ULONG flags, void *buffer )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetCharWidthW( hdc, first_char, last_char, chars, flags, buffer );
-}
+BOOL WINAPI NtGdiGetCharWidthW( HDC hdc, UINT first_char, UINT last_char, WCHAR *chars, ULONG flags, void *buffer )
+WIN32U_CALL(NtGdiGetCharWidthW, hdc, first_char, last_char, chars, flags, buffer)

BOOL WINAPI NtGdiGetCharWidthInfo( HDC hdc, struct char_width_info *info )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetCharWidthInfo( hdc, info );
-}
+WIN32U_CALL(NtGdiGetCharWidthInfo, hdc, info)

-INT WINAPI NtGdiGetDIBitsInternal( HDC hdc, HBITMAP hbitmap, UINT startscan, UINT lines,
-                                   void *bits, BITMAPINFO *info, UINT coloruse,
-                                   UINT max_bits, UINT max_info )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetDIBitsInternal( hdc, hbitmap, startscan, lines, bits, info, coloruse,
-                                                max_bits, max_info );
-}
+INT WINAPI NtGdiGetDIBitsInternal( HDC hdc, HBITMAP hbitmap, UINT startscan, UINT lines, void *bits, BITMAPINFO *info, UINT coloruse, UINT max_bits, UINT max_info )
+WIN32U_CALL(NtGdiGetDIBitsInternal, hdc, hbitmap, startscan, lines, bits, info, coloruse, max_bits, max_info)

INT WINAPI NtGdiGetDeviceCaps( HDC hdc, INT cap )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetDeviceCaps( hdc, cap );
-}
+WIN32U_CALL(NtGdiGetDeviceCaps, hdc, cap)

BOOL WINAPI NtGdiGetDeviceGammaRamp( HDC hdc, void *ptr )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetDeviceGammaRamp( hdc, ptr );
-}
+WIN32U_CALL(NtGdiGetDeviceGammaRamp, hdc, ptr)

DWORD WINAPI NtGdiGetFontData( HDC hdc, DWORD table, DWORD offset, void *buffer, DWORD length )
-{
-    if (!unix_funcs) return GDI_ERROR;
-    return unix_funcs->pNtGdiGetFontData( hdc, table, offset, buffer, length );
-}
+WIN32U_CALL(NtGdiGetFontData, hdc, table, offset, buffer, length)

DWORD WINAPI NtGdiGetFontUnicodeRanges( HDC hdc, GLYPHSET *lpgs )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetFontUnicodeRanges( hdc, lpgs );
-}
+WIN32U_CALL(NtGdiGetFontUnicodeRanges, hdc, lpgs)

-DWORD WINAPI NtGdiGetGlyphIndicesW( HDC hdc, const WCHAR *str, INT count,
-                                    WORD *indices, DWORD flags )
-{
-    if (!unix_funcs) return GDI_ERROR;
-    return unix_funcs->pNtGdiGetGlyphIndicesW( hdc, str, count, indices, flags );
-}
+DWORD WINAPI NtGdiGetGlyphIndicesW( HDC hdc, const WCHAR *str, INT count, WORD *indices, DWORD flags )
+WIN32U_CALL(NtGdiGetGlyphIndicesW, hdc, str, count, indices, flags)

-DWORD WINAPI NtGdiGetGlyphOutline( HDC hdc, UINT ch, UINT format, GLYPHMETRICS *metrics,
-                                   DWORD size, void *buffer, const MAT2 *mat2,
-                                   BOOL ignore_rotation )
-{
-    if (!unix_funcs) return GDI_ERROR;
-    return unix_funcs->pNtGdiGetGlyphOutline( hdc, ch, format, metrics, size, buffer, mat2, ignore_rotation );
-}
+DWORD WINAPI NtGdiGetGlyphOutline( HDC hdc, UINT ch, UINT format, GLYPHMETRICS *metrics, DWORD size, void *buffer, const MAT2 *mat2, BOOL ignore_rotation )
+WIN32U_CALL(NtGdiGetGlyphOutline, hdc, ch, format, metrics, size, buffer, mat2, ignore_rotation)

DWORD WINAPI NtGdiGetKerningPairs( HDC hdc, DWORD count, KERNINGPAIR *kern_pair )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetKerningPairs( hdc, count, kern_pair );
-}
+WIN32U_CALL(NtGdiGetKerningPairs, hdc, count, kern_pair)

COLORREF WINAPI NtGdiGetNearestColor( HDC hdc, COLORREF color )
-{
-    if (!unix_funcs) return CLR_INVALID;
-    return unix_funcs->pNtGdiGetNearestColor( hdc, color );
-}
+WIN32U_CALL(NtGdiGetNearestColor, hdc, color)

-UINT WINAPI NtGdiGetOutlineTextMetricsInternalW( HDC hdc, UINT cbData,
-                                                 OUTLINETEXTMETRICW *otm, ULONG opts )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetOutlineTextMetricsInternalW( hdc, cbData, otm, opts );
-}
+UINT WINAPI NtGdiGetOutlineTextMetricsInternalW( HDC hdc, UINT cbData, OUTLINETEXTMETRICW *otm, ULONG opts )
+WIN32U_CALL(NtGdiGetOutlineTextMetricsInternalW, hdc, cbData, otm, opts)

COLORREF WINAPI NtGdiGetPixel( HDC hdc, INT x, INT y )
-{
-    if (!unix_funcs) return CLR_INVALID;
-    return unix_funcs->pNtGdiGetPixel( hdc, x, y );
-}
+WIN32U_CALL(NtGdiGetPixel, hdc, x, y)

INT WINAPI NtGdiGetRandomRgn( HDC hdc, HRGN region, INT code )
-{
-    if (!unix_funcs) return -1;
-    return unix_funcs->pNtGdiGetRandomRgn( hdc, region, code );
-}
+WIN32U_CALL(NtGdiGetRandomRgn, hdc, region, code)

BOOL WINAPI NtGdiGetRasterizerCaps( RASTERIZER_STATUS *status, UINT size )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetRasterizerCaps( status, size );
-}
+WIN32U_CALL(NtGdiGetRasterizerCaps, status, size)

BOOL WINAPI NtGdiGetRealizationInfo( HDC hdc, struct font_realization_info *info )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetRealizationInfo( hdc, info );
-}
+WIN32U_CALL(NtGdiGetRealizationInfo, hdc, info)

UINT WINAPI NtGdiGetTextCharsetInfo( HDC hdc, FONTSIGNATURE *fs, DWORD flags )
-{
-    if (!unix_funcs) return DEFAULT_CHARSET;
-    return unix_funcs->pNtGdiGetTextCharsetInfo( hdc, fs, flags );
-}
+WIN32U_CALL(NtGdiGetTextCharsetInfo, hdc, fs, flags)

-BOOL WINAPI NtGdiGetTextExtentExW( HDC hdc, const WCHAR *str, INT count, INT max_ext,
-                                   INT *nfit, INT *dxs, SIZE *size, UINT flags )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetTextExtentExW( hdc, str, count, max_ext, nfit, dxs, size, flags );
-}
+BOOL WINAPI NtGdiGetTextExtentExW( HDC hdc, const WCHAR *str, INT count, INT max_ext, INT *nfit, INT *dxs, SIZE *size, UINT flags )
+WIN32U_CALL(NtGdiGetTextExtentExW, hdc, str, count, max_ext, nfit, dxs, size, flags)

INT WINAPI NtGdiGetTextFaceW( HDC hdc, INT count, WCHAR *name, BOOL alias_name )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiGetTextFaceW( hdc, count, name, alias_name );
-}
+WIN32U_CALL(NtGdiGetTextFaceW, hdc, count, name, alias_name)

BOOL WINAPI NtGdiGetTextMetricsW( HDC hdc, TEXTMETRICW *metrics, ULONG flags )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGetTextMetricsW( hdc, metrics, flags );
-}
+WIN32U_CALL(NtGdiGetTextMetricsW, hdc, metrics, flags)

-BOOL WINAPI NtGdiGradientFill( HDC hdc, TRIVERTEX *vert_array, ULONG nvert,
-                               void *grad_array, ULONG ngrad, ULONG mode )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiGradientFill( hdc, vert_array, nvert, grad_array, ngrad, mode );
-}
+BOOL WINAPI NtGdiGradientFill( HDC hdc, TRIVERTEX *vert_array, ULONG nvert, void *grad_array, ULONG ngrad, ULONG mode )
+WIN32U_CALL(NtGdiGradientFill, hdc, vert_array, nvert, grad_array, ngrad, mode)

INT WINAPI NtGdiIntersectClipRect( HDC hdc, INT left, INT top, INT right, INT bottom )
-{
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtGdiIntersectClipRect( hdc, left, top, right, bottom );
-}
+WIN32U_CALL(NtGdiIntersectClipRect, hdc, left, top, right, bottom)

BOOL WINAPI NtGdiInvertRgn( HDC hdc, HRGN hrgn )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiInvertRgn( hdc, hrgn );
-}
+WIN32U_CALL(NtGdiInvertRgn, hdc, hrgn)

BOOL WINAPI NtGdiLineTo( HDC hdc, INT x, INT y )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiLineTo( hdc, x, y );
-}
+WIN32U_CALL(NtGdiLineTo, hdc, x, y)

-BOOL WINAPI NtGdiMaskBlt( HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst,
-                          HDC hdc_src, INT x_src, INT y_src, HBITMAP mask,
-                          INT x_mask, INT y_mask, DWORD rop, DWORD bk_color )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiMaskBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
-                                      x_src, y_src, mask, x_mask, y_mask, rop, bk_color );
-}
+BOOL WINAPI NtGdiMaskBlt( HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst, HDC hdc_src, INT x_src, INT y_src, HBITMAP mask, INT x_mask, INT y_mask, DWORD rop, DWORD bk_color )
+WIN32U_CALL(NtGdiMaskBlt, hdc, x_dst, y_dst, width_dst, height_dst, hdc_src, x_src, y_src, mask, x_mask, y_mask, rop, bk_color)

BOOL WINAPI NtGdiModifyWorldTransform( HDC hdc, const XFORM *xform, DWORD mode )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiModifyWorldTransform( hdc, xform, mode );
-}
+WIN32U_CALL(NtGdiModifyWorldTransform, hdc, xform, mode)

BOOL WINAPI NtGdiMoveTo( HDC hdc, INT x, INT y, POINT *pt )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiMoveTo( hdc, x, y, pt );
-}
+WIN32U_CALL(NtGdiMoveTo, hdc, x, y, pt)

INT WINAPI NtGdiOffsetClipRgn( HDC hdc, INT x, INT y )
-{
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtGdiOffsetClipRgn( hdc, x, y );
-}
+WIN32U_CALL(NtGdiOffsetClipRgn, hdc, x, y)

-HDC WINAPI NtGdiOpenDCW( UNICODE_STRING *device, const DEVMODEW *devmode,
-                         UNICODE_STRING *output, ULONG type, BOOL is_display,
-                         HANDLE hspool, DRIVER_INFO_2W *driver_info, void *pdev )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiOpenDCW( device, devmode, output, type, is_display,
-                                      hspool, driver_info, pdev );
-}
+HDC WINAPI NtGdiOpenDCW( UNICODE_STRING *device, const DEVMODEW *devmode, UNICODE_STRING *output, ULONG type, BOOL is_display, HANDLE hspool, DRIVER_INFO_2W *driver_info, void *pdev )
+WIN32U_CALL(NtGdiOpenDCW, device, devmode, output, type, is_display, hspool, driver_info, pdev)

BOOL WINAPI NtGdiPatBlt( HDC hdc, INT left, INT top, INT width, INT height, DWORD rop )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiPatBlt( hdc, left, top, width, height, rop );
-}
+WIN32U_CALL(NtGdiPatBlt, hdc, left, top, width, height, rop)

-BOOL WINAPI NtGdiPlgBlt( HDC hdc, const POINT *point, HDC hdc_src, INT x_src, INT y_src,
-                         INT width, INT height, HBITMAP mask, INT x_mask, INT y_mask,
-                         DWORD bk_color )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiPlgBlt( hdc, point, hdc_src, x_src, y_src, width, height, mask,
-                                     x_mask, y_mask, bk_color );
-}
+BOOL WINAPI NtGdiPlgBlt( HDC hdc, const POINT *point, HDC hdc_src, INT x_src, INT y_src, INT width, INT height, HBITMAP mask, INT x_mask, INT y_mask, DWORD bk_color )
+WIN32U_CALL(NtGdiPlgBlt, hdc, point, hdc_src, x_src, y_src, width, height, mask, x_mask, y_mask, bk_color)

-BOOL WINAPI NtGdiPolyDraw( HDC hdc, const POINT *points, const BYTE *types, DWORD count )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiPolyDraw( hdc, points, types, count );
-}
+BOOL WINAPI NtGdiPolyDraw(HDC hdc, const POINT *points, const BYTE *types, DWORD count )
+WIN32U_CALL(NtGdiPolyDraw, hdc, points, types, count)

-ULONG WINAPI NtGdiPolyPolyDraw( HDC hdc, const POINT *points, const ULONG *counts,
-                                DWORD count, UINT function )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiPolyPolyDraw( hdc, points, counts, count, function );
-}
+ULONG WINAPI NtGdiPolyPolyDraw( HDC hdc, const POINT *points, const ULONG *counts, DWORD count, UINT function )
+WIN32U_CALL(NtGdiPolyPolyDraw, hdc, points, counts, count, function)

BOOL WINAPI NtGdiPtVisible( HDC hdc, INT x, INT y )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiPtVisible( hdc, x, y );
-}
+WIN32U_CALL(NtGdiPtVisible, hdc, x, y)

BOOL WINAPI NtGdiRectVisible( HDC hdc, const RECT *rect )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiRectVisible( hdc, rect );
-}
+WIN32U_CALL(NtGdiRectVisible, hdc, rect)

BOOL WINAPI NtGdiRectangle( HDC hdc, INT left, INT top, INT right, INT bottom )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiRectangle( hdc, left, top, right, bottom );
-}
+WIN32U_CALL(NtGdiRectangle, hdc, left, top, right, bottom)

-BOOL WINAPI NtGdiResetDC( HDC hdc, const DEVMODEW *devmode, BOOL *banding,
-                          DRIVER_INFO_2W *driver_info, void *dev )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiResetDC( hdc, devmode, banding, driver_info, dev );
-}
+BOOL WINAPI NtGdiResetDC( HDC hdc, const DEVMODEW *devmode, BOOL *banding, DRIVER_INFO_2W *driver_info, void *dev )
+WIN32U_CALL(NtGdiResetDC, hdc, devmode, banding, driver_info, dev)

BOOL WINAPI NtGdiResizePalette( HPALETTE palette, UINT count )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiResizePalette( palette, count );
-}
+WIN32U_CALL(NtGdiResizePalette, palette, count)

BOOL WINAPI NtGdiRestoreDC( HDC hdc, INT level )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiRestoreDC( hdc, level );
-}
+WIN32U_CALL(NtGdiRestoreDC, hdc, level)

-BOOL WINAPI NtGdiRoundRect( HDC hdc, INT left, INT top, INT right,
-                            INT bottom, INT ell_width, INT ell_height )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiRoundRect( hdc, left, top, right, bottom, ell_width, ell_height );
-}
+BOOL WINAPI NtGdiRoundRect( HDC hdc, INT left, INT top, INT right, INT bottom, INT ell_width, INT ell_height )
+WIN32U_CALL(NtGdiRoundRect, hdc, left, top, right, bottom, ell_width, ell_height)

-BOOL WINAPI NtGdiScaleViewportExtEx( HDC hdc, INT x_num, INT x_denom,
-                                     INT y_num, INT y_denom, SIZE *size )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiScaleViewportExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
-}
+BOOL WINAPI NtGdiScaleViewportExtEx( HDC hdc, INT x_num, INT x_denom, INT y_num, INT y_denom, SIZE *size )
+WIN32U_CALL(NtGdiScaleViewportExtEx, hdc, x_num, x_denom, y_num, y_denom, size)

-BOOL WINAPI NtGdiScaleWindowExtEx( HDC hdc, INT x_num, INT x_denom,
-                                   INT y_num, INT y_denom, SIZE *size )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiScaleWindowExtEx( hdc, x_num, x_denom, y_num, y_denom, size );
-}
+BOOL WINAPI NtGdiScaleWindowExtEx( HDC hdc, INT x_num, INT x_denom, INT y_num, INT y_denom, SIZE *size )
+WIN32U_CALL(NtGdiScaleWindowExtEx, hdc, x_num, x_denom, y_num, y_denom, size)

HGDIOBJ WINAPI NtGdiSelectBitmap( HDC hdc, HGDIOBJ handle )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiSelectBitmap( hdc, handle );
-}
+WIN32U_CALL(NtGdiSelectBitmap, hdc, handle)

HGDIOBJ WINAPI NtGdiSelectBrush( HDC hdc, HGDIOBJ handle )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiSelectBrush( hdc, handle );
-}
+WIN32U_CALL(NtGdiSelectBrush, hdc, handle)

BOOL WINAPI NtGdiSelectClipPath( HDC hdc, INT mode )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiSelectClipPath( hdc, mode );
-}
+WIN32U_CALL(NtGdiSelectClipPath, hdc, mode)

HGDIOBJ WINAPI NtGdiSelectFont( HDC hdc, HGDIOBJ handle )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiSelectFont( hdc, handle );
-}
+WIN32U_CALL(NtGdiSelectFont, hdc, handle)

HGDIOBJ WINAPI NtGdiSelectPen( HDC hdc, HGDIOBJ handle )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiSelectPen( hdc, handle );
-}
+WIN32U_CALL(NtGdiSelectPen, hdc, handle)

UINT WINAPI NtGdiSetBoundsRect( HDC hdc, const RECT *rect, UINT flags )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiSetBoundsRect( hdc, rect, flags );
-}
+WIN32U_CALL(NtGdiSetBoundsRect, hdc, rect, flags)

-INT WINAPI NtGdiSetDIBitsToDeviceInternal( HDC hdc, INT x_dst, INT y_dst, DWORD cx,
-                                           DWORD cy, INT x_src, INT y_src, UINT startscan,
-                                           UINT lines, const void *bits, const BITMAPINFO *bmi,
-                                           UINT coloruse, UINT max_bits, UINT max_info,
-                                           BOOL xform_coords, HANDLE xform )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiSetDIBitsToDeviceInternal( hdc, x_dst, y_dst, cx, cy, x_src, y_src,
-                                                        startscan, lines, bits, bmi, coloruse,
-                                                        max_bits, max_info, xform_coords, xform );
-}
+INT WINAPI NtGdiSetDIBitsToDeviceInternal( HDC hdc, INT x_dst, INT y_dst, DWORD cx, DWORD cy, INT x_src, INT y_src, UINT startscan, UINT lines, const void *bits, const BITMAPINFO *bmi, UINT coloruse, UINT max_bits, UINT max_info, BOOL xform_coords, HANDLE xform )
+WIN32U_CALL(NtGdiSetDIBitsToDeviceInternal, hdc, x_dst, y_dst, cx, cy, x_src, y_src, startscan, lines, bits, bmi, coloruse, max_bits, max_info, xform_coords, xform)

BOOL WINAPI NtGdiSetDeviceGammaRamp( HDC hdc, void *ptr )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiSetDeviceGammaRamp( hdc, ptr );
-}
+WIN32U_CALL(NtGdiSetDeviceGammaRamp, hdc, ptr)

DWORD WINAPI NtGdiSetLayout( HDC hdc, LONG wox, DWORD layout )
-{
-    if (!unix_funcs) return GDI_ERROR;
-    return unix_funcs->pNtGdiSetLayout( hdc, wox, layout );
-}
+WIN32U_CALL(NtGdiSetLayout, hdc, wox, layout)

COLORREF WINAPI NtGdiSetPixel( HDC hdc, INT x, INT y, COLORREF color )
-{
-    if (!unix_funcs) return CLR_INVALID;
-    return unix_funcs->pNtGdiSetPixel( hdc, x, y, color );
-}
+WIN32U_CALL(NtGdiSetPixel, hdc, x, y, color)

UINT WINAPI NtGdiSetSystemPaletteUse( HDC hdc, UINT use )
-{
-    if (!unix_funcs) return SYSPAL_ERROR;
-    return unix_funcs->pNtGdiSetSystemPaletteUse( hdc, use );
-}
+WIN32U_CALL(NtGdiSetSystemPaletteUse, hdc, use)

INT WINAPI NtGdiStartDoc( HDC hdc, const DOCINFOW *doc, BOOL *banding, INT job )
-{
-    if (!unix_funcs) return SP_ERROR;
-    return unix_funcs->pNtGdiStartDoc( hdc, doc, banding, job );
-}
+WIN32U_CALL(NtGdiStartDoc, hdc, doc, banding, job)

INT WINAPI NtGdiStartPage( HDC hdc )
-{
-    if (!unix_funcs) return SP_ERROR;
-    return unix_funcs->pNtGdiStartPage( hdc );
-}
+WIN32U_CALL(NtGdiStartPage, hdc)

-BOOL WINAPI NtGdiStretchBlt( HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst,
-                             HDC hdc_src, INT x_src, INT y_src, INT width_src, INT height_src,
-                             DWORD rop, COLORREF bk_color )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiStretchBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
-                                         x_src, y_src, width_src, height_src, rop, bk_color );
-}
+BOOL WINAPI NtGdiStretchBlt( HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst, HDC hdc_src, INT x_src, INT y_src, INT width_src, INT height_src, DWORD rop, COLORREF bk_color )
+WIN32U_CALL(NtGdiStretchBlt, hdc, x_dst, y_dst, width_dst, height_dst, hdc_src, x_src, y_src, width_src, height_src, rop, bk_color)

-INT WINAPI NtGdiStretchDIBitsInternal( HDC hdc, INT x_dst, INT y_dst, INT width_dst,
-                                       INT height_dst, INT x_src, INT y_src, INT width_src,
-                                       INT height_src, const void *bits, const BITMAPINFO *bmi,
-                                       UINT coloruse, DWORD rop, UINT max_info, UINT max_bits,
-                                       HANDLE xform )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtGdiStretchDIBitsInternal( hdc, x_dst, y_dst, width_dst, height_dst,
-                                                    x_src, y_src, width_src, height_src, bits, bmi,
-                                                    coloruse, rop, max_info, max_bits, xform );
-}
+INT WINAPI NtGdiStretchDIBitsInternal( HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst, INT x_src, INT y_src, INT width_src, INT height_src, const void *bits, const BITMAPINFO *bmi, UINT coloruse, DWORD rop, UINT max_info, UINT max_bits, HANDLE xform )
+WIN32U_CALL(NtGdiStretchDIBitsInternal, hdc, x_dst, y_dst, width_dst, height_dst, x_src, y_src, width_src, height_src, bits, bmi, coloruse, rop, max_info, max_bits, xform)

BOOL WINAPI NtGdiStrokeAndFillPath( HDC hdc )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiStrokeAndFillPath( hdc );
-}
+WIN32U_CALL(NtGdiStrokeAndFillPath, hdc)

BOOL WINAPI NtGdiStrokePath( HDC hdc )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiStrokePath( hdc );
-}
+WIN32U_CALL(NtGdiStrokePath, hdc)

-BOOL WINAPI NtGdiTransparentBlt( HDC hdc, int x_dst, int y_dst, int width_dst, int height_dst,
-                                 HDC hdc_src, int x_src, int y_src, int width_src, int height_src,
-                                 UINT color )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiTransparentBlt( hdc, x_dst, y_dst, width_dst, height_dst, hdc_src,
-                                             x_src, y_src, width_src, height_src, color );
-}
+BOOL WINAPI NtGdiTransparentBlt( HDC hdc, int x_dst, int y_dst, int width_dst, int height_dst, HDC hdc_src, int x_src, int y_src, int width_src, int height_src, UINT color )
+WIN32U_CALL(NtGdiTransparentBlt, hdc, x_dst, y_dst, width_dst, height_dst, hdc_src, x_src, y_src, width_src, height_src, color)

BOOL WINAPI NtGdiUnrealizeObject( HGDIOBJ obj )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiUnrealizeObject( obj );
-}
+WIN32U_CALL(NtGdiUnrealizeObject, obj)

BOOL WINAPI NtGdiUpdateColors( HDC hdc )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiUpdateColors( hdc );
-}
+WIN32U_CALL(NtGdiUpdateColors, hdc)

BOOL WINAPI NtGdiWidenPath( HDC hdc )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtGdiWidenPath( hdc );
-}
-
-NTSTATUS WINAPI NtGdiDdDDICheckVidPnExclusiveOwnership( const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc )
-{
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDICheckVidPnExclusiveOwnership( desc );
-}
-
-NTSTATUS WINAPI NtGdiDdDDICloseAdapter( const D3DKMT_CLOSEADAPTER *desc )
-{
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDICloseAdapter( desc );
-}
-
-NTSTATUS WINAPI NtGdiDdDDICreateDCFromMemory( D3DKMT_CREATEDCFROMMEMORY *desc )
-{
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDICreateDCFromMemory( desc );
-}
-
-NTSTATUS WINAPI NtGdiDdDDIDestroyDCFromMemory( const D3DKMT_DESTROYDCFROMMEMORY *desc )
-{
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIDestroyDCFromMemory( desc );
-}
-
-NTSTATUS WINAPI NtGdiDdDDIDestroyDevice( const D3DKMT_DESTROYDEVICE *desc )
-{
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIDestroyDevice( desc );
-}
-
-NTSTATUS WINAPI NtGdiDdDDIEscape( const D3DKMT_ESCAPE *desc )
-{
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIEscape( desc );
-}
-
-NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromDeviceName( D3DKMT_OPENADAPTERFROMDEVICENAME *desc )
-{
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIOpenAdapterFromDeviceName( desc );
-}
-
-NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc )
-{
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIOpenAdapterFromLuid( desc );
-}
-
-NTSTATUS WINAPI NtGdiDdDDIQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *desc )
-{
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDIQueryVideoMemoryInfo( desc );
-}
-
-NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER *desc )
-{
-    if (!unix_funcs) return STATUS_NOT_SUPPORTED;
-    return unix_funcs->pNtGdiDdDDISetVidPnSourceOwner( desc );
-}
+WIN32U_CALL(NtGdiWidenPath, hdc)

-BOOL WINAPI NtUserDrawCaptionTemp( HWND hwnd, HDC hdc, const RECT *rect, HFONT font,
-                                   HICON icon, const WCHAR *str, UINT flags )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtUserDrawCaptionTemp( hwnd, hdc, rect, font, icon, str, flags );
-}
+BOOL WINAPI NtUserDrawCaptionTemp( HWND hwnd, HDC hdc, const RECT *rect, HFONT font, HICON icon, const WCHAR *str, UINT flags )
+WIN32U_CALL(NtUserDrawCaptionTemp, hwnd, hdc, rect, font, icon, str, flags)

DWORD WINAPI NtUserDrawMenuBarTemp( HWND hwnd, HDC hdc, RECT *rect, HMENU handle, HFONT font )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtUserDrawMenuBarTemp( hwnd, hdc, rect, handle, font );
-}
+WIN32U_CALL(NtUserDrawMenuBarTemp, hwnd, hdc, rect, handle, font)
+
+BOOL WINAPI NtUserEndPaint( HWND hwnd, const PAINTSTRUCT *ps )
+WIN32U_CALL(NtUserEndPaint, hwnd, ps)

INT WINAPI NtUserExcludeUpdateRgn( HDC hdc, HWND hwnd )
-{
-    if (!unix_funcs) return ERROR;
-    return unix_funcs->pNtUserExcludeUpdateRgn( hdc, hwnd );
-}
+WIN32U_CALL(NtUserExcludeUpdateRgn, hdc, hwnd)

INT WINAPI NtUserReleaseDC( HWND hwnd, HDC hdc )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtUserReleaseDC( hwnd, hdc );
-}
+WIN32U_CALL(NtUserReleaseDC, hwnd, hdc)

-BOOL WINAPI NtUserScrollDC( HDC hdc, INT dx, INT dy, const RECT *scroll, const RECT *clip,
-                            HRGN ret_update_rgn, RECT *update_rect )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtUserScrollDC( hdc, dx, dy, scroll, clip, ret_update_rgn, update_rect );
-}
+BOOL WINAPI NtUserScrollDC( HDC hdc, INT dx, INT dy, const RECT *scroll, const RECT *clip, HRGN ret_update_rgn, RECT *update_rect )
+WIN32U_CALL(NtUserScrollDC, hdc, dx, dy, scroll, clip, ret_update_rgn, update_rect)

HPALETTE WINAPI NtUserSelectPalette( HDC hdc, HPALETTE hpal, WORD bkg )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pNtUserSelectPalette( hdc, hpal, bkg );
-}
+WIN32U_CALL(NtUserSelectPalette, hdc, hpal, bkg)

-BOOL WINAPI 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 )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->pNtUserUpdateLayeredWindow( hwnd, hdc_dst, pts_dst, size, hdc_src, pts_src,
-                                                   key, blend, flags, dirty );
-}
+BOOL WINAPI 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 )
+WIN32U_CALL(NtUserUpdateLayeredWindow, hwnd, hdc_dst, pts_dst, size, hdc_src, pts_src, key, blend, flags, dirty)

-INT WINAPI SetDIBits( HDC hdc, HBITMAP hbitmap, UINT startscan,
-                      UINT lines, const void *bits, const BITMAPINFO *info,
-                      UINT coloruse )
-{
-    if (!unix_funcs) return 0;
-    return unix_funcs->pSetDIBits( hdc, hbitmap, startscan, lines, bits, info, coloruse );
-}
-
-BOOL CDECL __wine_get_icm_profile( HDC hdc, BOOL allow_default, DWORD *size, WCHAR *filename )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->get_icm_profile( hdc, allow_default, size, filename );
-}
+INT WINAPI SetDIBits( HDC hdc, HBITMAP hbitmap, UINT startscan, UINT lines, const void *bits, const BITMAPINFO *info, UINT coloruse )
+WIN32U_CALL(SetDIBits, hdc, hbitmap, startscan, lines, bits, info, coloruse)

BOOL CDECL __wine_get_brush_bitmap_info( HBRUSH handle, BITMAPINFO *info, void *bits, UINT *usage )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->get_brush_bitmap_info( handle, info, bits, usage );
-}
+WIN32U_CALL(__wine_get_brush_bitmap_info, handle, info, bits, usage)

BOOL CDECL __wine_get_file_outline_text_metric( const WCHAR *path, OUTLINETEXTMETRICW *otm )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->get_file_outline_text_metric( path, otm );
-}
+WIN32U_CALL(__wine_get_file_outline_text_metric, path, otm)
+
+BOOL CDECL __wine_get_icm_profile( HDC hdc, BOOL allow_default, DWORD *size, WCHAR *filename )
+WIN32U_CALL(__wine_get_icm_profile, hdc, allow_default, size, filename)

BOOL CDECL __wine_send_input( HWND hwnd, const INPUT *input, const RAWINPUT *rawinput )
-{
-    if (!unix_funcs) return FALSE;
-    return unix_funcs->wine_send_input( hwnd, input, rawinput );
-}
+WIN32U_CALL(__wine_send_input, hwnd, input, rawinput)

-extern void wrappers_init( unixlib_handle_t handle )
-{
-    const void *args;
-    if (!__wine_unix_call( handle, 1, &args )) unix_funcs = args;
-}
+#undef WIN32U_CALL
\ No newline at end of file